Add Direct3D 12 RenderingDevice implementation

42 files changed, 75707 insertions, 14 deletions

diff --git a/.github/workflows/windows_builds.yml b/.github/workflows/windows_builds.yml
index 7e8853634a..35ed1a773d 100644
--- a/.github/workflows/windows_builds.yml
+++ b/.github/workflows/windows_builds.yml
@@ -7,7 +7,7 @@ on:
 env:
   # Used for the cache key. Add version suffix to force clean build.
   GODOT_BASE_BRANCH: master
-  SCONSFLAGS: verbose=yes warnings=extra werror=yes module_text_server_fb_enabled=yes
+  SCONSFLAGS: verbose=yes warnings=extra werror=yes module_text_server_fb_enabled=yes d3d12=yes "dxc_path=${{github.workspace}}/dxc" "mesa_libs=${{github.workspace}}/godot-nir-static"
   SCONS_CACHE_MSVC_CONFIG: true
 
 concurrency:
@@ -49,6 +49,28 @@ jobs:
       - name: Setup python and scons
         uses: ./.github/actions/godot-deps
 
+      - name: Download pre-built DirectX Shader Compiler
+        uses: dsaltares/fetch-gh-release-asset@1.0.0
+        with:
+          repo: Microsoft/DirectXShaderCompiler
+          version: tags/v1.7.2308
+          file: dxc_2023_08_14.zip
+          target: dxc.zip
+
+      - name: Extract pre-built DirectX Shader Compiler
+        run: 7z x dxc.zip -o${{github.workspace}}/dxc
+
+      - name: Download pre-built Mesa-NIR
+        uses: dsaltares/fetch-gh-release-asset@1.0.0
+        with:
+          repo: godotengine/godot-nir-static
+          version: tags/23.1.0-devel
+          file: godot-nir-23.1.0-1-devel.zip
+          target: godot-nir-static.zip
+
+      - name: Extract pre-built Mesa-NIR
+        run: 7z x godot-nir-static.zip -o${{github.workspace}}/godot-nir-static
+
       - name: Setup MSVC problem matcher
         uses: ammaraskar/msvc-problem-matcher@master
 
diff --git a/COPYRIGHT.txt b/COPYRIGHT.txt
index 03415b4c39..0d116438ef 100644
--- a/COPYRIGHT.txt
+++ b/COPYRIGHT.txt
@@ -194,6 +194,16 @@ Copyright: 2018, Eric Lasota
  2018, Microsoft Corp.
 License: Expat
 
+Files: ./thirdparty/d3d12ma/
+Comment: D3D12 Memory Allocator
+Copyright: 2019-2022 Advanced Micro Devices, Inc.
+License: Expat
+
+Files: ./thirdparty/directx_headers/
+Comment: DirectX Headers
+Copyright: Microsoft Corporation
+License: Expat
+
 Files: ./thirdparty/doctest/
 Comment: doctest
 Copyright: 2016-2023, Viktor Kirilov
diff --git a/SConstruct b/SConstruct
index 534d5bd95d..9dc1caa0b6 100644
--- a/SConstruct
+++ b/SConstruct
@@ -191,6 +191,7 @@ opts.Add(BoolVariable("brotli", "Enable Brotli for decompresson and WOFF2 fonts
 opts.Add(BoolVariable("xaudio2", "Enable the XAudio2 audio driver", False))
 opts.Add(BoolVariable("vulkan", "Enable the vulkan rendering driver", True))
 opts.Add(BoolVariable("opengl3", "Enable the OpenGL/GLES3 rendering driver", True))
+opts.Add(BoolVariable("d3d12", "Enable the Direct3D 12 rendering driver (Windows only)", False))
 opts.Add(BoolVariable("openxr", "Enable the OpenXR driver", True))
 opts.Add(BoolVariable("use_volk", "Use the volk library to load the Vulkan loader dynamically", True))
 opts.Add(BoolVariable("disable_exceptions", "Force disabling exception handling code", True))
diff --git a/core/config/project_settings.cpp b/core/config/project_settings.cpp
index 93934f2320..bf1595b41b 100644
--- a/core/config/project_settings.cpp
+++ b/core/config/project_settings.cpp
@@ -95,7 +95,7 @@ const PackedStringArray ProjectSettings::_get_supported_features() {
 	features.append(VERSION_FULL_CONFIG);
 	features.append(VERSION_FULL_BUILD);
 
-#ifdef VULKAN_ENABLED
+#if defined(VULKAN_ENABLED) || defined(D3D12_ENABLED)
 	features.append("Forward Plus");
 	features.append("Mobile");
 #endif
@@ -1399,6 +1399,12 @@ ProjectSettings::ProjectSettings() {
 	GLOBAL_DEF("rendering/rendering_device/staging_buffer/texture_upload_region_size_px", 64);
 	GLOBAL_DEF("rendering/rendering_device/pipeline_cache/save_chunk_size_mb", 3.0);
 	GLOBAL_DEF("rendering/rendering_device/vulkan/max_descriptors_per_pool", 64);
+	GLOBAL_DEF_RST("rendering/rendering_device/d3d12/max_resource_descriptors_per_frame", 16384);
+	custom_prop_info["rendering/rendering_device/d3d12/max_resource_descriptors_per_frame"] = PropertyInfo(Variant::INT, "rendering/rendering_device/d3d12/max_resource_descriptors_per_frame", PROPERTY_HINT_RANGE, "512,262144");
+	GLOBAL_DEF_RST("rendering/rendering_device/d3d12/max_sampler_descriptors_per_frame", 1024);
+	custom_prop_info["rendering/rendering_device/d3d12/max_sampler_descriptors_per_frame"] = PropertyInfo(Variant::INT, "rendering/rendering_device/d3d12/max_sampler_descriptors_per_frame", PROPERTY_HINT_RANGE, "256,2048");
+	GLOBAL_DEF_RST("rendering/rendering_device/d3d12/max_misc_descriptors_per_frame", 512);
+	custom_prop_info["rendering/rendering_device/d3d12/max_misc_descriptors_per_frame"] = PropertyInfo(Variant::INT, "rendering/rendering_device/d3d12/max_misc_descriptors_per_frame", PROPERTY_HINT_RANGE, "32,4096");
 
 	GLOBAL_DEF_BASIC(PropertyInfo(Variant::INT, "rendering/textures/canvas_textures/default_texture_filter", PROPERTY_HINT_ENUM, "Nearest,Linear,Linear Mipmap,Nearest Mipmap"), 1);
 	GLOBAL_DEF_BASIC(PropertyInfo(Variant::INT, "rendering/textures/canvas_textures/default_texture_repeat", PROPERTY_HINT_ENUM, "Disable,Enable,Mirror"), 0);
diff --git a/core/core_bind.cpp b/core/core_bind.cpp
index 981d9b0025..d91c659d1e 100644
--- a/core/core_bind.cpp
+++ b/core/core_bind.cpp
@@ -662,6 +662,7 @@ void OS::_bind_methods() {
 
 	BIND_ENUM_CONSTANT(RENDERING_DRIVER_VULKAN);
 	BIND_ENUM_CONSTANT(RENDERING_DRIVER_OPENGL3);
+	BIND_ENUM_CONSTANT(RENDERING_DRIVER_D3D12);
 
 	BIND_ENUM_CONSTANT(SYSTEM_DIR_DESKTOP);
 	BIND_ENUM_CONSTANT(SYSTEM_DIR_DCIM);
diff --git a/core/core_bind.h b/core/core_bind.h
index 5f51b64eb7..715e26cf23 100644
--- a/core/core_bind.h
+++ b/core/core_bind.h
@@ -129,6 +129,7 @@ public:
 	enum RenderingDriver {
 		RENDERING_DRIVER_VULKAN,
 		RENDERING_DRIVER_OPENGL3,
+		RENDERING_DRIVER_D3D12,
 	};
 
 	virtual PackedStringArray get_connected_midi_inputs();
diff --git a/doc/classes/OS.xml b/doc/classes/OS.xml
index ad89efb256..44197dbd0c 100644
--- a/doc/classes/OS.xml
+++ b/doc/classes/OS.xml
@@ -699,6 +699,9 @@
 		<constant name="RENDERING_DRIVER_OPENGL3" value="1" enum="RenderingDriver">
 			The OpenGL 3 rendering driver. It uses OpenGL 3.3 Core Profile on desktop platforms, OpenGL ES 3.0 on mobile devices, and WebGL 2.0 on Web.
 		</constant>
+		<constant name="RENDERING_DRIVER_D3D12" value="2" enum="RenderingDriver">
+			The Direct3D 12 rendering driver.
+		</constant>
 		<constant name="SYSTEM_DIR_DESKTOP" value="0" enum="SystemDir">
 			Desktop directory path.
 		</constant>
diff --git a/doc/classes/ProjectSettings.xml b/doc/classes/ProjectSettings.xml
index 3fc9e94427..42569f2a79 100644
--- a/doc/classes/ProjectSettings.xml
+++ b/doc/classes/ProjectSettings.xml
@@ -2616,6 +2616,18 @@
 		<member name="rendering/renderer/rendering_method.web" type="String" setter="" getter="" default="&quot;gl_compatibility&quot;">
 			Override for [member rendering/renderer/rendering_method] on web.
 		</member>
+		<member name="rendering/rendering_device/d3d12/max_misc_descriptors_per_frame" type="int" setter="" getter="" default="512">
+			The number of entries in the miscellaneous descriptors heap the Direct3D 12 rendering driver uses each frame, used for various operations like clearing a texture.
+			Depending on the complexity of scenes, this value may be lowered or may need to be raised.
+		</member>
+		<member name="rendering/rendering_device/d3d12/max_resource_descriptors_per_frame" type="int" setter="" getter="" default="16384">
+			The number of entries in the resource descriptors heap the Direct3D 12 rendering driver uses each frame, used for most rendering operations.
+			Depending on the complexity of scenes, this value may be lowered or may need to be raised.
+		</member>
+		<member name="rendering/rendering_device/d3d12/max_sampler_descriptors_per_frame" type="int" setter="" getter="" default="1024">
+			The number of entries in the sampler descriptors heap the Direct3D 12 rendering driver uses each frame, used for most rendering operations.
+			Depending on the complexity of scenes, this value may be lowered or may need to be raised.
+		</member>
 		<member name="rendering/rendering_device/driver" type="String" setter="" getter="">
 			Sets the driver to be used by the renderer when using a RenderingDevice-based renderer like the clustered renderer or the mobile renderer. This property can not be edited directly, instead, set the driver using the platform-specific overrides.
 		</member>
diff --git a/drivers/SCsub b/drivers/SCsub
index c633a0591b..9c8b16d3e5 100644
--- a/drivers/SCsub
+++ b/drivers/SCsub
@@ -25,6 +25,8 @@ SConscript("winmidi/SCsub")
 # Graphics drivers
 if env["vulkan"]:
     SConscript("vulkan/SCsub")
+if env["d3d12"]:
+    SConscript("d3d12/SCsub")
 if env["opengl3"]:
     SConscript("gl_context/SCsub")
     SConscript("gles3/SCsub")
diff --git a/drivers/d3d12/SCsub b/drivers/d3d12/SCsub
new file mode 100644
index 0000000000..ce7134fb77
--- /dev/null
+++ b/drivers/d3d12/SCsub
@@ -0,0 +1,151 @@
+#!/usr/bin/env python
+
+import os
+from pathlib import Path
+
+Import("env")
+
+env_d3d12_rd = env.Clone()
+
+thirdparty_obj = []
+
+
+# DirectX Headers (must take precedence over Windows SDK's).
+
+env.Prepend(CPPPATH=["#thirdparty/directx_headers"])
+env_d3d12_rd.Prepend(CPPPATH=["#thirdparty/directx_headers"])
+
+
+# Direct3D 12 Memory Allocator.
+
+env.Append(CPPPATH=["#thirdparty/d3d12ma"])
+env_d3d12_rd.Append(CPPPATH=["#thirdparty/d3d12ma"])
+
+
+# Agility SDK.
+
+if env["agility_sdk_path"] != "":
+    env_d3d12_rd.Append(CPPDEFINES=["AGILITY_SDK_ENABLED"])
+    if env["agility_sdk_multiarch"]:
+        env_d3d12_rd.Append(CPPDEFINES=["AGILITY_SDK_MULTIARCH_ENABLED"])
+
+
+# PIX.
+
+if env["pix_path"] != "":
+    env_d3d12_rd.Append(CPPDEFINES=["PIX_ENABLED"])
+    env_d3d12_rd.Append(CPPPATH=[env["pix_path"] + "/Include"])
+
+
+# Mesa (SPIR-V to DXIL functionality).
+
+mesa_dir = (env["mesa_libs"] + "/godot-mesa").replace("\\", "/")
+mesa_gen_dir = (env["mesa_libs"] + "/godot-mesa/generated").replace("\\", "/")
+mesa_absdir = Dir(mesa_dir).abspath
+mesa_gen_absdir = Dir(mesa_dir + "/generated").abspath
+
+custom_build_steps = [
+    [
+        "src/compiler",
+        "glsl/ir_expression_operation.py enum > %s/ir_expression_operation.h",
+        "ir_expression_operation.h",
+    ],
+    ["src/compiler/nir", "nir_builder_opcodes_h.py > %s/nir_builder_opcodes.h", "nir_builder_opcodes.h"],
+    ["src/compiler/nir", "nir_constant_expressions.py > %s/nir_constant_expressions.c", "nir_constant_expressions.c"],
+    ["src/compiler/nir", "nir_intrinsics_h.py --outdir %s", "nir_intrinsics.h"],
+    ["src/compiler/nir", "nir_intrinsics_c.py --outdir %s", "nir_intrinsics.c"],
+    ["src/compiler/nir", "nir_intrinsics_indices_h.py --outdir %s", "nir_intrinsics_indices.h"],
+    ["src/compiler/nir", "nir_opcodes_h.py > %s/nir_opcodes.h", "nir_opcodes.h"],
+    ["src/compiler/nir", "nir_opcodes_c.py > %s/nir_opcodes.c", "nir_opcodes.c"],
+    ["src/compiler/nir", "nir_opt_algebraic.py > %s/nir_opt_algebraic.c", "nir_opt_algebraic.c"],
+    ["src/compiler/spirv", "vtn_generator_ids_h.py spir-v.xml %s/vtn_generator_ids.h", "vtn_generator_ids.h"],
+    [
+        "src/microsoft/compiler",
+        "dxil_nir_algebraic.py -p ../../../src/compiler/nir > %s/dxil_nir_algebraic.c",
+        "dxil_nir_algebraic.c",
+    ],
+    ["src/util", "format_srgb.py > %s/format_srgb.c", "format_srgb.c"],
+    ["src/util/format", "u_format_table.py u_format.csv --header > %s/u_format_pack.h", "u_format_pack.h"],
+    ["src/util/format", "u_format_table.py u_format.csv > %s/u_format_table.c", "u_format_table.c"],
+]
+
+mesa_gen_include_paths = [mesa_gen_dir + "/src"]
+
+# See update_mesa.sh for explanation.
+for v in custom_build_steps:
+    subdir = v[0]
+    cmd = v[1]
+    gen_filename = v[2]
+
+    in_dir = str(Path(mesa_absdir + "/" + subdir))
+    out_full_path = mesa_dir + "/generated/" + subdir
+    out_file_full_path = out_full_path + "/" + gen_filename
+
+    if gen_filename.endswith(".h"):
+        mesa_gen_include_paths += [out_full_path.replace("\\", "/")]
+
+mesa_private_inc_paths = [v[0] for v in os.walk(mesa_absdir)]
+mesa_private_inc_paths = [v.replace(mesa_absdir, mesa_dir) for v in mesa_private_inc_paths]
+mesa_private_inc_paths = [v.replace("\\", "/") for v in mesa_private_inc_paths]
+# Avoid build results depending on if generated files already exist.
+mesa_private_inc_paths = [v for v in mesa_private_inc_paths if not v.startswith(mesa_gen_dir)]
+mesa_private_inc_paths.sort()
+# Include the list of the generated ones now, so out-of-the-box sources can include generated headers.
+mesa_private_inc_paths += mesa_gen_include_paths
+# We have to blacklist some because we are bindly adding every Mesa directory
+# to the include path and in some cases that causes the wrong header to be included.
+mesa_blacklist_inc_paths = [
+    "src/c11",
+]
+mesa_blacklist_inc_paths = [mesa_dir + "/" + v for v in mesa_blacklist_inc_paths]
+mesa_private_inc_paths = [v for v in mesa_private_inc_paths if v not in mesa_blacklist_inc_paths]
+
+# Added by ourselves.
+extra_defines = [
+    "WINDOWS_NO_FUTEX",
+]
+
+# These defines are inspired by the Meson build scripts in the original repo.
+extra_defines += [
+    "__STDC_CONSTANT_MACROS",
+    "__STDC_FORMAT_MACROS",
+    "__STDC_LIMIT_MACROS",
+    ("PACKAGE_VERSION", '\\"' + Path(mesa_absdir + "/VERSION").read_text().strip() + '\\"'),
+    ("PACKAGE_BUGREPORT", '\\"https://gitlab.freedesktop.org/mesa/mesa/-/issues\\"'),
+    "PIPE_SUBSYSTEM_WINDOWS_USER",
+    ("_Static_assert", "static_assert"),
+]
+
+if env.msvc:
+    extra_defines += [
+        "_USE_MATH_DEFINES",
+        "VC_EXTRALEAN",
+        "_CRT_SECURE_NO_WARNINGS",
+        "_CRT_SECURE_NO_DEPRECATE",
+        "_SCL_SECURE_NO_WARNINGS",
+        "_SCL_SECURE_NO_DEPRECATE",
+        "_ALLOW_KEYWORD_MACROS",
+        ("_HAS_EXCEPTIONS", 0),
+        "NOMINMAX",
+        "HAVE_STRUCT_TIMESPEC",
+    ]
+
+# This is needed since rendering_device_d3d12.cpp needs to include some Mesa internals.
+env_d3d12_rd.Prepend(CPPPATH=mesa_private_inc_paths)
+# For the same reason as above, the defines must be the same as in the 3rd-party code itself.
+env_d3d12_rd.Append(CPPDEFINES=extra_defines)
+
+
+# Add all.
+
+env.drivers_sources += thirdparty_obj
+
+
+# Godot source files.
+
+driver_obj = []
+env_d3d12_rd.add_source_files(driver_obj, "*.cpp")
+env.drivers_sources += driver_obj
+
+# Needed to force rebuilding the driver files when the thirdparty code is updated.
+env.Depends(driver_obj, thirdparty_obj)
diff --git a/drivers/d3d12/d3d12_context.cpp b/drivers/d3d12/d3d12_context.cpp
new file mode 100644
index 0000000000..6933089208
--- /dev/null
+++ b/drivers/d3d12/d3d12_context.cpp
@@ -0,0 +1,1067 @@
+/**************************************************************************/
+/*  d3d12_context.cpp                                                     */
+/**************************************************************************/
+/*                         This file is part of:                          */
+/*                             GODOT ENGINE                               */
+/*                        https://godotengine.org                         */
+/**************************************************************************/
+/* Copyright (c) 2014-present Godot Engine contributors (see AUTHORS.md). */
+/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur.                  */
+/*                                                                        */
+/* Permission is hereby granted, free of charge, to any person obtaining  */
+/* a copy of this software and associated documentation files (the        */
+/* "Software"), to deal in the Software without restriction, including    */
+/* without limitation the rights to use, copy, modify, merge, publish,    */
+/* distribute, sublicense, and/or sell copies of the Software, and to     */
+/* permit persons to whom the Software is furnished to do so, subject to  */
+/* the following conditions:                                              */
+/*                                                                        */
+/* The above copyright notice and this permission notice shall be         */
+/* included in all copies or substantial portions of the Software.        */
+/*                                                                        */
+/* 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. */
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY   */
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,   */
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE      */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                 */
+/**************************************************************************/
+
+#include "d3d12_context.h"
+
+#include "core/config/engine.h"
+#include "core/config/project_settings.h"
+#include "core/string/ustring.h"
+#include "core/templates/local_vector.h"
+#include "core/version.h"
+#include "servers/rendering/rendering_device.h"
+
+#include "dxcapi.h"
+
+extern "C" {
+char godot_nir_arch_name[32];
+
+#ifdef AGILITY_SDK_ENABLED
+__declspec(dllexport) extern const UINT D3D12SDKVersion = 610;
+#ifdef AGILITY_SDK_MULTIARCH_ENABLED
+#if defined(__aarch64__) || defined(_M_ARM64) || defined(_M_ARM64EC)
+__declspec(dllexport) extern const char *D3D12SDKPath = "\\.\\arm64";
+#else
+__declspec(dllexport) extern const char *D3D12SDKPath = "\\.\\x86_64";
+#endif
+#else
+__declspec(dllexport) extern const char *D3D12SDKPath = "\\.";
+#endif // AGILITY_SDK_MULTIARCH
+#endif // AGILITY_SDK_ENABLED
+}
+
+#ifdef PIX_ENABLED
+#define USE_PIX
+#include "WinPixEventRuntime/pix3.h"
+#endif
+
+#define ARRAY_SIZE(a) (sizeof(a) / sizeof(a[0]))
+
+void D3D12Context::_debug_message_func(
+		D3D12_MESSAGE_CATEGORY p_category,
+		D3D12_MESSAGE_SEVERITY p_severity,
+		D3D12_MESSAGE_ID p_id,
+		LPCSTR p_description,
+		void *p_context) {
+	String type_string;
+	switch (p_category) {
+		case D3D12_MESSAGE_CATEGORY_APPLICATION_DEFINED:
+			type_string = "APPLICATION_DEFINED";
+			break;
+		case D3D12_MESSAGE_CATEGORY_MISCELLANEOUS:
+			type_string = "MISCELLANEOUS";
+			break;
+		case D3D12_MESSAGE_CATEGORY_INITIALIZATION:
+			type_string = "INITIALIZATION";
+			break;
+		case D3D12_MESSAGE_CATEGORY_CLEANUP:
+			type_string = "CLEANUP";
+			break;
+		case D3D12_MESSAGE_CATEGORY_COMPILATION:
+			type_string = "COMPILATION";
+			break;
+		case D3D12_MESSAGE_CATEGORY_STATE_CREATION:
+			type_string = "STATE_CREATION";
+			break;
+		case D3D12_MESSAGE_CATEGORY_STATE_SETTING:
+			type_string = "STATE_SETTING";
+			break;
+		case D3D12_MESSAGE_CATEGORY_STATE_GETTING:
+			type_string = "STATE_GETTING";
+			break;
+		case D3D12_MESSAGE_CATEGORY_RESOURCE_MANIPULATION:
+			type_string = "RESOURCE_MANIPULATION";
+			break;
+		case D3D12_MESSAGE_CATEGORY_EXECUTION:
+			type_string = "EXECUTION";
+			break;
+		case D3D12_MESSAGE_CATEGORY_SHADER:
+			type_string = "SHADER";
+			break;
+	}
+
+	String error_message(type_string +
+			" - Message Id Number: " + String::num_int64(p_id) +
+			"\n\t" + p_description);
+
+	// Convert D3D12 severity to our own log macros.
+	switch (p_severity) {
+		case D3D12_MESSAGE_SEVERITY_MESSAGE:
+			print_verbose(error_message);
+			break;
+		case D3D12_MESSAGE_SEVERITY_INFO:
+			print_line(error_message);
+			break;
+		case D3D12_MESSAGE_SEVERITY_WARNING:
+			WARN_PRINT(error_message);
+			break;
+		case D3D12_MESSAGE_SEVERITY_ERROR:
+		case D3D12_MESSAGE_SEVERITY_CORRUPTION:
+			ERR_PRINT(error_message);
+			CRASH_COND_MSG(Engine::get_singleton()->is_abort_on_gpu_errors_enabled(),
+					"Crashing, because abort on GPU errors is enabled.");
+			break;
+	}
+}
+
+uint32_t D3D12Context::SubgroupCapabilities::supported_stages_flags_rd() const {
+	// If there's a way to check exactly which are supported, I have yet to find it.
+	return (
+			RenderingDevice::ShaderStage::SHADER_STAGE_FRAGMENT_BIT |
+			RenderingDevice::ShaderStage::SHADER_STAGE_COMPUTE_BIT);
+}
+
+uint32_t D3D12Context::SubgroupCapabilities::supported_operations_flags_rd() const {
+	if (!wave_ops_supported) {
+		return 0;
+	} else {
+		return (
+				RenderingDevice::SubgroupOperations::SUBGROUP_BASIC_BIT |
+				RenderingDevice::SubgroupOperations::SUBGROUP_BALLOT_BIT |
+				RenderingDevice::SubgroupOperations::SUBGROUP_VOTE_BIT |
+				RenderingDevice::SubgroupOperations::SUBGROUP_SHUFFLE_BIT |
+				RenderingDevice::SubgroupOperations::SUBGROUP_SHUFFLE_RELATIVE_BIT |
+				RenderingDevice::SubgroupOperations::SUBGROUP_QUAD_BIT |
+				RenderingDevice::SubgroupOperations::SUBGROUP_ARITHMETIC_BIT |
+				RenderingDevice::SubgroupOperations::SUBGROUP_CLUSTERED_BIT);
+	}
+}
+
+Error D3D12Context::_check_capabilities() {
+	// Assume not supported until proven otherwise.
+	vrs_capabilities.draw_call_supported = false;
+	vrs_capabilities.primitive_supported = false;
+	vrs_capabilities.primitive_in_multiviewport = false;
+	vrs_capabilities.ss_image_supported = false;
+	vrs_capabilities.ss_image_tile_size = 1;
+	vrs_capabilities.additional_rates_supported = false;
+	multiview_capabilities.is_supported = false;
+	multiview_capabilities.geometry_shader_is_supported = false;
+	multiview_capabilities.tessellation_shader_is_supported = false;
+	multiview_capabilities.max_view_count = 0;
+	multiview_capabilities.max_instance_count = 0;
+	multiview_capabilities.is_supported = false;
+	subgroup_capabilities.size = 0;
+	subgroup_capabilities.wave_ops_supported = false;
+	shader_capabilities.shader_model = D3D_SHADER_MODEL_6_0;
+	shader_capabilities.native_16bit_ops = false;
+	storage_buffer_capabilities.storage_buffer_16_bit_access_is_supported = false;
+	format_capabilities.relaxed_casting_supported = false;
+
+	{
+		D3D12_FEATURE_DATA_SHADER_MODEL shader_model = {};
+		shader_model.HighestShaderModel = MIN(D3D_HIGHEST_SHADER_MODEL, D3D_SHADER_MODEL_6_6);
+		HRESULT res = md.device->CheckFeatureSupport(D3D12_FEATURE_SHADER_MODEL, &shader_model, sizeof(shader_model));
+		ERR_FAIL_COND_V_MSG(res, ERR_CANT_CREATE, "CheckFeatureSupport failed with error " + vformat("0x%08ux", res) + ".");
+		shader_capabilities.shader_model = shader_model.HighestShaderModel;
+	}
+	print_verbose("- Shader:");
+	print_verbose("  model: " + itos(shader_capabilities.shader_model >> 4) + "." + itos(shader_capabilities.shader_model & 0xf));
+
+	D3D12_FEATURE_DATA_D3D12_OPTIONS options = {};
+	HRESULT res = md.device->CheckFeatureSupport(D3D12_FEATURE_D3D12_OPTIONS, &options, sizeof(options));
+	if (SUCCEEDED(res)) {
+		storage_buffer_capabilities.storage_buffer_16_bit_access_is_supported = options.TypedUAVLoadAdditionalFormats;
+	}
+
+	D3D12_FEATURE_DATA_D3D12_OPTIONS1 options1 = {};
+	res = md.device->CheckFeatureSupport(D3D12_FEATURE_D3D12_OPTIONS1, &options1, sizeof(options1));
+	if (SUCCEEDED(res)) {
+		subgroup_capabilities.size = options1.WaveLaneCountMin;
+		subgroup_capabilities.wave_ops_supported = options1.WaveOps;
+	}
+
+	D3D12_FEATURE_DATA_D3D12_OPTIONS3 options3 = {};
+	res = md.device->CheckFeatureSupport(D3D12_FEATURE_D3D12_OPTIONS3, &options3, sizeof(options3));
+	if (SUCCEEDED(res)) {
+		// https://docs.microsoft.com/en-us/windows/win32/api/d3d12/ne-d3d12-d3d12_view_instancing_tier
+		// https://microsoft.github.io/DirectX-Specs/d3d/ViewInstancing.html#sv_viewid
+		if (options3.ViewInstancingTier >= D3D12_VIEW_INSTANCING_TIER_1) {
+			multiview_capabilities.is_supported = true;
+			multiview_capabilities.geometry_shader_is_supported = options3.ViewInstancingTier >= D3D12_VIEW_INSTANCING_TIER_3;
+			multiview_capabilities.tessellation_shader_is_supported = options3.ViewInstancingTier >= D3D12_VIEW_INSTANCING_TIER_3;
+			multiview_capabilities.max_view_count = D3D12_MAX_VIEW_INSTANCE_COUNT;
+			multiview_capabilities.max_instance_count = UINT32_MAX;
+		}
+	}
+
+	D3D12_FEATURE_DATA_D3D12_OPTIONS6 options6 = {};
+	res = md.device->CheckFeatureSupport(D3D12_FEATURE_D3D12_OPTIONS6, &options6, sizeof(options6));
+	if (SUCCEEDED(res)) {
+		if (options6.VariableShadingRateTier >= D3D12_VARIABLE_SHADING_RATE_TIER_1) {
+			vrs_capabilities.draw_call_supported = true;
+			if (options6.VariableShadingRateTier >= D3D12_VARIABLE_SHADING_RATE_TIER_2) {
+				vrs_capabilities.primitive_supported = true;
+				vrs_capabilities.primitive_in_multiviewport = options6.PerPrimitiveShadingRateSupportedWithViewportIndexing;
+				vrs_capabilities.ss_image_supported = true;
+				vrs_capabilities.ss_image_tile_size = options6.ShadingRateImageTileSize;
+				vrs_capabilities.additional_rates_supported = options6.AdditionalShadingRatesSupported;
+			}
+		}
+	}
+
+	D3D12_FEATURE_DATA_D3D12_OPTIONS12 options12 = {};
+	res = md.device->CheckFeatureSupport(D3D12_FEATURE_D3D12_OPTIONS12, &options12, sizeof(options12));
+	if (SUCCEEDED(res)) {
+		format_capabilities.relaxed_casting_supported = options12.RelaxedFormatCastingSupported;
+	}
+
+	if (vrs_capabilities.draw_call_supported || vrs_capabilities.primitive_supported || vrs_capabilities.ss_image_supported) {
+		print_verbose("- D3D12 Variable Rate Shading supported:");
+		if (vrs_capabilities.draw_call_supported) {
+			print_verbose("  Draw call");
+		}
+		if (vrs_capabilities.primitive_supported) {
+			print_verbose(String("  Per-primitive (multi-viewport: ") + (vrs_capabilities.primitive_in_multiviewport ? "yes" : "no") + ")");
+		}
+		if (vrs_capabilities.ss_image_supported) {
+			print_verbose(String("  Screen-space image (tile size: ") + itos(vrs_capabilities.ss_image_tile_size) + ")");
+		}
+		if (vrs_capabilities.additional_rates_supported) {
+			print_verbose(String("  Additional rates: ") + (vrs_capabilities.additional_rates_supported ? "yes" : "no"));
+		}
+	} else {
+		print_verbose("- D3D12 Variable Rate Shading not supported");
+	}
+
+	if (multiview_capabilities.is_supported) {
+		print_verbose("- D3D12 multiview supported:");
+		print_verbose("  max view count: " + itos(multiview_capabilities.max_view_count));
+		//print_verbose("  max instances: " + itos(multiview_capabilities.max_instance_count)); // Hardcoded; not very useful at the moment.
+	} else {
+		print_verbose("- D3D12 multiview not supported");
+	}
+
+	if (format_capabilities.relaxed_casting_supported) {
+		print_verbose("- Relaxed casting supported");
+	} else {
+		print_verbose("- Relaxed casting not supported");
+	}
+
+	return OK;
+}
+
+Error D3D12Context::_initialize_debug_layers() {
+	ComPtr<ID3D12Debug> debug_controller;
+	HRESULT res = D3D12GetDebugInterface(IID_PPV_ARGS(&debug_controller));
+	ERR_FAIL_COND_V(res, ERR_QUERY_FAILED);
+	debug_controller->EnableDebugLayer();
+	return OK;
+}
+
+Error D3D12Context::_select_adapter(int &r_index) {
+	{
+		UINT flags = _use_validation_layers() ? DXGI_CREATE_FACTORY_DEBUG : 0;
+		HRESULT res = CreateDXGIFactory2(flags, IID_PPV_ARGS(&dxgi_factory));
+		ERR_FAIL_COND_V(!SUCCEEDED(res), ERR_CANT_CREATE);
+	}
+
+	ComPtr<IDXGIFactory6> factory6;
+	dxgi_factory.As(&factory6);
+
+	// TODO: Use IDXCoreAdapterList, which gives more comprehensive information.
+	LocalVector<IDXGIAdapter1 *> adapters;
+	while (true) {
+		IDXGIAdapter1 *curr_adapter = nullptr;
+		if (factory6) {
+			if (factory6->EnumAdapterByGpuPreference(adapters.size(), DXGI_GPU_PREFERENCE_HIGH_PERFORMANCE, IID_PPV_ARGS(&curr_adapter)) == DXGI_ERROR_NOT_FOUND) {
+				break;
+			}
+		} else {
+			if (dxgi_factory->EnumAdapters1(adapters.size(), &curr_adapter) == DXGI_ERROR_NOT_FOUND) {
+				break;
+			}
+		}
+		adapters.push_back(curr_adapter);
+	}
+
+	ERR_FAIL_COND_V_MSG(adapters.size() == 0, ERR_CANT_CREATE, "Adapters enumeration reported zero accessible devices.");
+
+	// The device should really be a preference, but for now choosing a discrete GPU over the
+	// integrated one is better than the default.
+
+	int32_t adapter_index = -1;
+	int type_selected = -1;
+	LocalVector<RenderingDevice::DeviceType> adapter_types;
+	print_verbose("D3D12 devices:");
+	for (uint32_t i = 0; i < adapters.size(); ++i) {
+		DXGI_ADAPTER_DESC1 desc = {};
+		adapters[i]->GetDesc1(&desc);
+
+		String name = desc.Description;
+		String dev_type;
+		RenderingDevice::DeviceType type = {};
+		if (((desc.Flags & DXGI_ADAPTER_FLAG_SOFTWARE))) {
+			type = RenderingDevice::DEVICE_TYPE_CPU;
+		} else {
+			type = desc.DedicatedVideoMemory ? RenderingDevice::DEVICE_TYPE_DISCRETE_GPU : RenderingDevice::DEVICE_TYPE_INTEGRATED_GPU;
+		}
+		adapter_types.push_back(type);
+
+		switch (type) {
+			case RenderingDevice::DEVICE_TYPE_DISCRETE_GPU: {
+				dev_type = "Discrete";
+			} break;
+			case RenderingDevice::DEVICE_TYPE_INTEGRATED_GPU: {
+				dev_type = "Integrated";
+			} break;
+			case RenderingDevice::DEVICE_TYPE_VIRTUAL_GPU: {
+				dev_type = "Virtual";
+			} break;
+			case RenderingDevice::DEVICE_TYPE_CPU: {
+				dev_type = "CPU";
+			} break;
+			default: {
+				dev_type = "Other";
+			} break;
+		}
+		print_verbose("  #" + itos(i) + ": " + name + ", " + dev_type);
+
+		switch (type) {
+			case RenderingDevice::DEVICE_TYPE_DISCRETE_GPU: {
+				if (type_selected < 4) {
+					type_selected = 4;
+					adapter_index = i;
+				}
+			} break;
+			case RenderingDevice::DEVICE_TYPE_INTEGRATED_GPU: {
+				if (type_selected < 3) {
+					type_selected = 3;
+					adapter_index = i;
+				}
+			} break;
+			case RenderingDevice::DEVICE_TYPE_VIRTUAL_GPU: {
+				if (type_selected < 2) {
+					type_selected = 2;
+					adapter_index = i;
+				}
+			} break;
+			case RenderingDevice::DEVICE_TYPE_CPU: {
+				if (type_selected < 1) {
+					type_selected = 1;
+					adapter_index = i;
+				}
+			} break;
+			default: {
+				if (type_selected < 0) {
+					type_selected = 0;
+					adapter_index = i;
+				}
+			} break;
+		}
+	}
+
+	int32_t user_adapter_index = Engine::get_singleton()->get_gpu_index(); // Force user selected GPU.
+	if (user_adapter_index >= 0 && user_adapter_index < (int32_t)adapters.size()) {
+		adapter_index = user_adapter_index;
+	}
+
+	ERR_FAIL_COND_V_MSG(adapter_index == -1, ERR_CANT_CREATE, "None of D3D12 devices supports hardware rendering.");
+
+	gpu = adapters[adapter_index];
+	for (uint32_t i = 0; i < adapters.size(); ++i) {
+		adapters[i]->Release();
+	}
+
+	adapter_type = adapter_types[adapter_index];
+
+	ComPtr<IDXGIFactory5> factory5;
+	dxgi_factory.As(&factory5);
+	if (factory5) {
+		BOOL result = FALSE; // sizeof(bool) != sizeof(BOOL), in general.
+		HRESULT res = factory5->CheckFeatureSupport(DXGI_FEATURE_PRESENT_ALLOW_TEARING, &result, sizeof(result));
+		if (SUCCEEDED(res)) {
+			tearing_supported = result;
+		} else {
+			ERR_PRINT("CheckFeatureSupport failed with error " + vformat("0x%08ux", res) + ".");
+		}
+	}
+
+	r_index = adapter_index;
+
+	return OK;
+}
+
+void D3D12Context::_dump_adapter_info(int p_index) {
+	{
+		const D3D_FEATURE_LEVEL FEATURE_LEVELS[] = {
+			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,
+		};
+
+		D3D12_FEATURE_DATA_FEATURE_LEVELS feat_levels = {};
+		feat_levels.NumFeatureLevels = ARRAY_SIZE(FEATURE_LEVELS);
+		feat_levels.pFeatureLevelsRequested = FEATURE_LEVELS;
+
+		HRESULT res = md.device->CheckFeatureSupport(D3D12_FEATURE_FEATURE_LEVELS, &feat_levels, sizeof(feat_levels));
+		ERR_FAIL_COND_MSG(res, "CheckFeatureSupport failed with error " + vformat("0x%08ux", res) + ".");
+
+		// Example: D3D_FEATURE_LEVEL_12_1 = 0xc100.
+		uint32_t feat_level_major = feat_levels.MaxSupportedFeatureLevel >> 12;
+		uint32_t feat_level_minor = (feat_levels.MaxSupportedFeatureLevel >> 16) & 0xff;
+		feature_level = feat_level_major * 10 + feat_level_minor;
+	}
+
+	String rendering_method;
+	if (OS::get_singleton()->get_current_rendering_method() == "mobile") {
+		rendering_method = "Forward Mobile";
+	} else {
+		rendering_method = "Forward+";
+	}
+
+	static const struct {
+		uint32_t id;
+		const char *name;
+	} vendor_names[] = {
+		{ 0x1002, "AMD" },
+		{ 0x1010, "ImgTec" },
+		{ 0x106B, "Apple" },
+		{ 0x10DE, "NVIDIA" },
+		{ 0x13B5, "ARM" },
+		{ 0x1414, "Microsoft" },
+		{ 0x5143, "Qualcomm" },
+		{ 0x8086, "Intel" },
+		{ 0, nullptr },
+	};
+
+	DXGI_ADAPTER_DESC gpu_desc = {};
+	gpu->GetDesc(&gpu_desc);
+
+	adapter_name = gpu_desc.Description;
+	pipeline_cache_id = String::hex_encode_buffer((uint8_t *)&gpu_desc.AdapterLuid, sizeof(LUID));
+	pipeline_cache_id += "-driver-" + itos(gpu_desc.Revision);
+	{
+		adapter_vendor = "Unknown";
+		uint32_t vendor_idx = 0;
+		while (vendor_names[vendor_idx].name != nullptr) {
+			if (gpu_desc.VendorId == vendor_names[vendor_idx].id) {
+				adapter_vendor = vendor_names[vendor_idx].name;
+				break;
+			}
+			vendor_idx++;
+		}
+	}
+
+	print_line(vformat("D3D12 feature level %s - %s - Using D3D12 Adapter #%d: %s", get_device_api_version(), rendering_method, p_index, adapter_name));
+}
+
+Error D3D12Context::_create_device(DeviceBasics &r_basics) {
+	HRESULT res = D3D12CreateDevice(gpu.Get(), D3D_FEATURE_LEVEL_11_0, IID_PPV_ARGS(r_basics.device.GetAddressOf()));
+	ERR_FAIL_COND_V_MSG(res, ERR_CANT_CREATE, "D3D12CreateDevice failed with error " + vformat("0x%08ux", res) + ".");
+
+	// Create direct command queue.
+	D3D12_COMMAND_QUEUE_DESC queue_desc = {};
+	queue_desc.Flags = D3D12_COMMAND_QUEUE_FLAG_NONE;
+	queue_desc.Type = D3D12_COMMAND_LIST_TYPE_DIRECT;
+	res = r_basics.device->CreateCommandQueue(&queue_desc, IID_PPV_ARGS(r_basics.queue.GetAddressOf()));
+	ERR_FAIL_COND_V(res, ERR_CANT_CREATE);
+
+	// Create sync objects.
+	res = r_basics.device->CreateFence(0, D3D12_FENCE_FLAG_NONE, IID_PPV_ARGS(r_basics.fence.GetAddressOf()));
+	ERR_FAIL_COND_V(res, ERR_CANT_CREATE);
+	r_basics.fence_event = CreateEvent(nullptr, FALSE, FALSE, nullptr);
+	ERR_FAIL_NULL_V(r_basics.fence_event, ERR_CANT_CREATE);
+
+	if (_use_validation_layers()) {
+		ComPtr<ID3D12InfoQueue> info_queue;
+		res = r_basics.device.As(&info_queue);
+		ERR_FAIL_COND_V(res, ERR_CANT_CREATE);
+
+#if 0 // This causes crashes. Needs investigation.
+		ComPtr<ID3D12InfoQueue1> info_queue_1;
+		device.As(&info_queue_1);
+		if (info_queue_1) {
+			// Custom printing supported (added in Windows 10 Release Preview build 20236).
+
+			info_queue_1->SetMuteDebugOutput(TRUE);
+
+			res = info_queue_1->RegisterMessageCallback(&_debug_message_func, D3D12_MESSAGE_CALLBACK_IGNORE_FILTERS, nullptr, 0);
+			ERR_FAIL_COND_V(res, ERR_CANT_CREATE);
+		} else
+#endif
+		{
+			// Rely on D3D12's own debug printing.
+
+			if (Engine::get_singleton()->is_abort_on_gpu_errors_enabled()) {
+				res = info_queue->SetBreakOnSeverity(D3D12_MESSAGE_SEVERITY_WARNING, TRUE);
+				ERR_FAIL_COND_V(res, ERR_CANT_CREATE);
+			}
+		}
+		D3D12_MESSAGE_SEVERITY severities_to_mute[] = {
+			D3D12_MESSAGE_SEVERITY_INFO,
+		};
+
+		D3D12_MESSAGE_ID messages_to_mute[] = {
+			D3D12_MESSAGE_ID_CLEARRENDERTARGETVIEW_MISMATCHINGCLEARVALUE,
+			D3D12_MESSAGE_ID_CLEARDEPTHSTENCILVIEW_MISMATCHINGCLEARVALUE,
+			// These happen due to how D3D12MA manages buffers; seem bening.
+			D3D12_MESSAGE_ID_HEAP_ADDRESS_RANGE_HAS_NO_RESOURCE,
+			D3D12_MESSAGE_ID_HEAP_ADDRESS_RANGE_INTERSECTS_MULTIPLE_BUFFERS,
+		};
+
+		D3D12_INFO_QUEUE_FILTER filter = {};
+		filter.DenyList.NumSeverities = ARRAY_SIZE(severities_to_mute);
+		filter.DenyList.pSeverityList = severities_to_mute;
+		filter.DenyList.NumIDs = ARRAY_SIZE(messages_to_mute);
+		filter.DenyList.pIDList = messages_to_mute;
+
+		res = info_queue->PushStorageFilter(&filter);
+		ERR_FAIL_COND_V(res, ERR_CANT_CREATE);
+	}
+
+	return OK;
+}
+
+Error D3D12Context::_get_device_limits() {
+	D3D12_FEATURE_DATA_D3D12_OPTIONS options = {};
+	HRESULT res = md.device->CheckFeatureSupport(D3D12_FEATURE_D3D12_OPTIONS, &options, sizeof(options));
+	ERR_FAIL_COND_V_MSG(res, ERR_UNAVAILABLE, "CheckFeatureSupport failed with error " + vformat("0x%08ux", res) + ".");
+
+	// https://docs.microsoft.com/en-us/windows/win32/direct3d12/hardware-support
+	gpu_limits.max_srvs_per_shader_stage = options.ResourceBindingTier == D3D12_RESOURCE_BINDING_TIER_1 ? 128 : UINT64_MAX;
+	gpu_limits.max_cbvs_per_shader_stage = options.ResourceBindingTier <= D3D12_RESOURCE_BINDING_TIER_2 ? 14 : UINT64_MAX;
+	gpu_limits.max_samplers_across_all_stages = options.ResourceBindingTier == D3D12_RESOURCE_BINDING_TIER_1 ? 16 : 2048;
+	if (options.ResourceBindingTier == D3D12_RESOURCE_BINDING_TIER_1) {
+		gpu_limits.max_uavs_across_all_stages = feature_level <= 110 ? 8 : 64;
+	} else if (options.ResourceBindingTier == D3D12_RESOURCE_BINDING_TIER_2) {
+		gpu_limits.max_uavs_across_all_stages = 64;
+	} else {
+		gpu_limits.max_uavs_across_all_stages = UINT64_MAX;
+	}
+
+	md.queue->GetTimestampFrequency(&gpu_limits.timestamp_frequency);
+
+	return OK;
+}
+
+bool D3D12Context::_use_validation_layers() {
+	return Engine::get_singleton()->is_validation_layers_enabled();
+}
+
+Error D3D12Context::window_create(DisplayServer::WindowID p_window_id, DisplayServer::VSyncMode p_vsync_mode, HWND p_window, HINSTANCE p_instance, int p_width, int p_height) {
+	ERR_FAIL_COND_V(windows.has(p_window_id), ERR_INVALID_PARAMETER);
+
+	Window window;
+	window.hwnd = p_window;
+	window.width = p_width;
+	window.height = p_height;
+	window.vsync_mode = p_vsync_mode;
+	Error err = _update_swap_chain(&window);
+	ERR_FAIL_COND_V(err != OK, ERR_CANT_CREATE);
+
+	windows[p_window_id] = window;
+	return OK;
+}
+
+void D3D12Context::window_resize(DisplayServer::WindowID p_window, int p_width, int p_height) {
+	ERR_FAIL_COND(!windows.has(p_window));
+	windows[p_window].width = p_width;
+	windows[p_window].height = p_height;
+	_update_swap_chain(&windows[p_window]);
+}
+
+int D3D12Context::window_get_width(DisplayServer::WindowID p_window) {
+	ERR_FAIL_COND_V(!windows.has(p_window), -1);
+	return windows[p_window].width;
+}
+
+int D3D12Context::window_get_height(DisplayServer::WindowID p_window) {
+	ERR_FAIL_COND_V(!windows.has(p_window), -1);
+	return windows[p_window].height;
+}
+
+bool D3D12Context::window_is_valid_swapchain(DisplayServer::WindowID p_window) {
+	ERR_FAIL_COND_V(!windows.has(p_window), false);
+	Window *w = &windows[p_window];
+	return (bool)w->swapchain;
+}
+
+CD3DX12_CPU_DESCRIPTOR_HANDLE D3D12Context::window_get_framebuffer_rtv_handle(DisplayServer::WindowID p_window) {
+	ERR_FAIL_COND_V(!windows.has(p_window), CD3DX12_CPU_DESCRIPTOR_HANDLE(CD3DX12_DEFAULT()));
+	ERR_FAIL_COND_V(!buffers_prepared, CD3DX12_CPU_DESCRIPTOR_HANDLE(CD3DX12_DEFAULT()));
+	Window *w = &windows[p_window];
+	CD3DX12_CPU_DESCRIPTOR_HANDLE rtv_handle(
+			w->rtv_heap->GetCPUDescriptorHandleForHeapStart(),
+			w->current_buffer,
+			md.device->GetDescriptorHandleIncrementSize(D3D12_DESCRIPTOR_HEAP_TYPE_RTV));
+	return rtv_handle;
+}
+
+ID3D12Resource *D3D12Context::window_get_framebuffer_texture(DisplayServer::WindowID p_window) {
+	ERR_FAIL_COND_V(!windows.has(p_window), nullptr);
+	ERR_FAIL_COND_V(!buffers_prepared, nullptr);
+	Window *w = &windows[p_window];
+	if (w->swapchain) {
+		return w->render_targets[w->current_buffer].Get();
+	} else {
+		return nullptr;
+	}
+}
+
+void D3D12Context::window_destroy(DisplayServer::WindowID p_window_id) {
+	ERR_FAIL_COND(!windows.has(p_window_id));
+	_wait_for_idle_queue(md.queue.Get());
+	windows.erase(p_window_id);
+}
+
+Error D3D12Context::_update_swap_chain(Window *window) {
+	if (window->width == 0 || window->height == 0) {
+		// Likely window minimized, no swapchain created.
+		return ERR_SKIP;
+	}
+
+	DisplayServer::VSyncMode curr_vsync_mode = window->vsync_mode;
+	bool vsync_mode_available = false;
+	UINT swapchain_flags = 0;
+	do {
+		switch (window->vsync_mode) {
+			case DisplayServer::VSYNC_MAILBOX: {
+				window->sync_interval = 1;
+				window->present_flags = DXGI_PRESENT_RESTART;
+				swapchain_flags = 0;
+				vsync_mode_available = true;
+			} break;
+			case DisplayServer::VSYNC_ADAPTIVE: {
+				vsync_mode_available = false; // I don't know how to set this up.
+			} break;
+			case DisplayServer::VSYNC_ENABLED: {
+				window->sync_interval = 1;
+				window->present_flags = 0;
+				swapchain_flags = 0;
+				vsync_mode_available = true;
+			} break;
+			case DisplayServer::VSYNC_DISABLED: {
+				window->sync_interval = 0;
+				window->present_flags = tearing_supported ? DXGI_PRESENT_ALLOW_TEARING : 0;
+				swapchain_flags = tearing_supported ? DXGI_SWAP_CHAIN_FLAG_ALLOW_TEARING : 0;
+				vsync_mode_available = true;
+			} break;
+		}
+
+		// Set the windows swap effect if it is available, otherwise FLIP_DISCARD is used.
+		if (vsync_mode_available) {
+			if (window->vsync_mode != curr_vsync_mode || !window->swapchain) {
+				window->vsync_mode = curr_vsync_mode;
+				print_verbose("Using swapchain flags: " + itos(swapchain_flags) + ", sync interval: " + itos(window->sync_interval) + ", present flags: " + itos(window->present_flags));
+			}
+		} else {
+			String present_mode_string;
+			switch (window->vsync_mode) {
+				case DisplayServer::VSYNC_MAILBOX:
+					present_mode_string = "Mailbox";
+					break;
+				case DisplayServer::VSYNC_ADAPTIVE:
+					present_mode_string = "Adaptive";
+					break;
+				case DisplayServer::VSYNC_ENABLED:
+					present_mode_string = "Enabled";
+					break;
+				case DisplayServer::VSYNC_DISABLED:
+					present_mode_string = "Disabled";
+					break;
+			}
+			WARN_PRINT(vformat("The requested V-Sync mode %s is not available. Falling back to V-Sync mode Enabled.", present_mode_string));
+			window->vsync_mode = DisplayServer::VSYNC_ENABLED; // Set to default.
+		}
+	} while (!vsync_mode_available);
+
+	if (window->swapchain) {
+		_wait_for_idle_queue(md.queue.Get());
+		for (uint32_t i = 0; i < IMAGE_COUNT; i++) {
+			window->render_targets[i].Reset();
+		}
+		window->rtv_heap.Reset();
+
+		// D3D12 docs: "IDXGISwapChain::ResizeBuffers can't be used to add or remove this flag."
+		bool allow_tearing_flag_changed = (swapchain_flags & DXGI_SWAP_CHAIN_FLAG_ALLOW_TEARING) != (window->swapchain_flags & DXGI_SWAP_CHAIN_FLAG_ALLOW_TEARING);
+		if (allow_tearing_flag_changed) {
+			window->swapchain.Reset();
+		}
+	}
+
+	if (!window->swapchain) {
+		DXGI_SWAP_CHAIN_DESC1 swapchain_desc = {};
+		swapchain_desc.BufferCount = IMAGE_COUNT;
+		swapchain_desc.Width = 0;
+		swapchain_desc.Height = 0;
+		swapchain_desc.Format = DXGI_FORMAT_R8G8B8A8_UNORM;
+		swapchain_desc.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT;
+		swapchain_desc.SwapEffect = DXGI_SWAP_EFFECT_FLIP_DISCARD;
+		swapchain_desc.SampleDesc.Count = 1;
+		swapchain_desc.Flags = swapchain_flags;
+		swapchain_desc.Scaling = DXGI_SCALING_NONE;
+
+		ComPtr<IDXGISwapChain1> swapchain;
+		HRESULT res = dxgi_factory->CreateSwapChainForHwnd(md.queue.Get(), window->hwnd, &swapchain_desc, nullptr, nullptr, swapchain.GetAddressOf());
+		ERR_FAIL_COND_V(res, ERR_CANT_CREATE);
+		swapchain.As(&window->swapchain);
+		ERR_FAIL_NULL_V(window->swapchain, ERR_CANT_CREATE);
+
+		format = swapchain_desc.Format;
+
+		res = dxgi_factory->MakeWindowAssociation(window->hwnd, DXGI_MWA_NO_ALT_ENTER | DXGI_MWA_NO_WINDOW_CHANGES);
+		ERR_FAIL_COND_V(res, ERR_CANT_CREATE);
+
+		res = window->swapchain->GetDesc1(&swapchain_desc);
+		ERR_FAIL_COND_V(res, ERR_CANT_CREATE);
+		ERR_FAIL_COND_V(swapchain_desc.BufferCount != IMAGE_COUNT, ERR_BUG);
+		window->width = swapchain_desc.Width;
+		window->height = swapchain_desc.Height;
+
+	} else {
+		HRESULT res = window->swapchain->ResizeBuffers(IMAGE_COUNT, window->width, window->height, DXGI_FORMAT_UNKNOWN, swapchain_flags);
+		ERR_FAIL_COND_V(res, ERR_UNAVAILABLE);
+	}
+
+	window->swapchain_flags = swapchain_flags;
+	window->current_buffer = window->swapchain->GetCurrentBackBufferIndex();
+
+	// Describe and create a render target view (RTV) descriptor heap.
+	D3D12_DESCRIPTOR_HEAP_DESC rtv_heap_desc = {};
+	rtv_heap_desc.NumDescriptors = IMAGE_COUNT;
+	rtv_heap_desc.Type = D3D12_DESCRIPTOR_HEAP_TYPE_RTV;
+	rtv_heap_desc.Flags = D3D12_DESCRIPTOR_HEAP_FLAG_NONE;
+	HRESULT res = md.device->CreateDescriptorHeap(&rtv_heap_desc, IID_PPV_ARGS(window->rtv_heap.GetAddressOf()));
+	ERR_FAIL_COND_V(res, ERR_CANT_CREATE);
+
+	CD3DX12_CPU_DESCRIPTOR_HANDLE rtv_handle(window->rtv_heap->GetCPUDescriptorHandleForHeapStart());
+
+	for (uint32_t i = 0; i < IMAGE_COUNT; i++) {
+		res = window->swapchain->GetBuffer(i, IID_PPV_ARGS(&window->render_targets[i]));
+		ERR_FAIL_COND_V(res, ERR_CANT_CREATE);
+
+		md.device->CreateRenderTargetView(window->render_targets[i].Get(), nullptr, rtv_handle);
+		rtv_handle.Offset(1, md.device->GetDescriptorHandleIncrementSize(D3D12_DESCRIPTOR_HEAP_TYPE_RTV));
+	}
+
+	return OK;
+}
+
+Error D3D12Context::initialize() {
+	if (_use_validation_layers()) {
+		Error err = _initialize_debug_layers();
+		ERR_FAIL_COND_V(err, ERR_CANT_CREATE);
+	}
+
+	int adapter_index = 0;
+
+	Error err = _select_adapter(adapter_index);
+	ERR_FAIL_COND_V(err, ERR_CANT_CREATE);
+
+	err = _create_device(md);
+	ERR_FAIL_COND_V(err, ERR_CANT_CREATE);
+
+	_dump_adapter_info(adapter_index);
+
+	err = _check_capabilities();
+	ERR_FAIL_COND_V(err, ERR_CANT_CREATE);
+
+	err = _get_device_limits();
+	ERR_FAIL_COND_V(err, ERR_CANT_CREATE);
+
+	{
+		HRESULT res = md.device->CreateFence(0, D3D12_FENCE_FLAG_NONE, IID_PPV_ARGS(frame_fence.GetAddressOf()));
+		ERR_FAIL_COND_V(res, ERR_CANT_CREATE);
+		frame_fence_event = CreateEvent(nullptr, FALSE, FALSE, nullptr);
+		ERR_FAIL_NULL_V(frame_fence_event, ERR_CANT_CREATE);
+	}
+
+	{ // Initialize allocator.
+		D3D12MA::ALLOCATOR_DESC allocator_desc = {};
+		allocator_desc.pDevice = md.device.Get();
+		allocator_desc.pAdapter = gpu.Get();
+
+		HRESULT res = D3D12MA::CreateAllocator(&allocator_desc, &allocator);
+		ERR_FAIL_COND_V_MSG(res, ERR_CANT_CREATE, "D3D12MA::CreateAllocator failed with error " + vformat("0x%08ux", res) + ".");
+	}
+
+	return OK;
+}
+
+void D3D12Context::set_setup_list(ID3D12CommandList *p_command_list) {
+	command_list_queue.write[0] = p_command_list;
+}
+
+void D3D12Context::append_command_list(ID3D12CommandList *p_command_list) {
+	if (command_list_queue.size() <= command_list_count) {
+		command_list_queue.resize(command_list_count + 1);
+	}
+
+	command_list_queue.write[command_list_count] = p_command_list;
+	command_list_count++;
+}
+
+void D3D12Context::_wait_for_idle_queue(ID3D12CommandQueue *p_queue) {
+	md.fence_value++;
+	p_queue->Signal(md.fence.Get(), md.fence_value);
+	md.fence->SetEventOnCompletion(md.fence_value, md.fence_event);
+	WaitForSingleObjectEx(md.fence_event, INFINITE, FALSE);
+#ifdef PIX_ENABLED
+	PIXNotifyWakeFromFenceSignal(md.fence_event);
+#endif
+}
+
+void D3D12Context::flush(bool p_flush_setup, bool p_flush_pending) {
+	if (p_flush_setup && command_list_queue[0]) {
+		md.queue->ExecuteCommandLists(1, command_list_queue.ptr());
+		command_list_queue.write[0] = nullptr;
+	}
+
+	if (p_flush_pending && command_list_count > 1) {
+		md.queue->ExecuteCommandLists(command_list_count - 1, command_list_queue.ptr() + 1);
+		command_list_count = 1;
+	}
+
+	if (p_flush_setup || p_flush_pending) {
+		_wait_for_idle_queue(md.queue.Get());
+	}
+}
+
+void D3D12Context::prepare_buffers(ID3D12GraphicsCommandList *p_command_list) {
+	// Ensure no more than FRAME_LAG renderings are outstanding.
+	if (frame >= IMAGE_COUNT) {
+		UINT64 min_value = frame - IMAGE_COUNT;
+		if (frame_fence->GetCompletedValue() < min_value) {
+			frame_fence->SetEventOnCompletion(min_value, frame_fence_event);
+			WaitForSingleObjectEx(frame_fence_event, INFINITE, FALSE);
+#ifdef PIX_ENABLED
+			PIXNotifyWakeFromFenceSignal(frame_fence_event);
+#endif
+		}
+	}
+
+	D3D12_RESOURCE_BARRIER *barriers = (D3D12_RESOURCE_BARRIER *)alloca(windows.size() * sizeof(D3D12_RESOURCE_BARRIER));
+
+	uint32_t n = 0;
+	for (KeyValue<int, Window> &E : windows) {
+		Window *w = &E.value;
+		w->current_buffer = w->swapchain->GetCurrentBackBufferIndex();
+		barriers[n++] = CD3DX12_RESOURCE_BARRIER::Transition(w->render_targets[w->current_buffer].Get(), D3D12_RESOURCE_STATE_PRESENT, D3D12_RESOURCE_STATE_RENDER_TARGET);
+	}
+
+	p_command_list->ResourceBarrier(n, barriers);
+
+	buffers_prepared = true;
+}
+
+void D3D12Context::postpare_buffers(ID3D12GraphicsCommandList *p_command_list) {
+	D3D12_RESOURCE_BARRIER *barriers = (D3D12_RESOURCE_BARRIER *)alloca(windows.size() * sizeof(D3D12_RESOURCE_BARRIER));
+
+	uint32_t n = 0;
+	for (KeyValue<int, Window> &E : windows) {
+		Window *w = &E.value;
+		barriers[n++] = CD3DX12_RESOURCE_BARRIER::Transition(w->render_targets[w->current_buffer].Get(), D3D12_RESOURCE_STATE_RENDER_TARGET, D3D12_RESOURCE_STATE_PRESENT);
+	}
+
+	p_command_list->ResourceBarrier(n, barriers);
+}
+
+Error D3D12Context::swap_buffers() {
+	ID3D12CommandList *const *commands_ptr = nullptr;
+	UINT commands_to_submit = 0;
+
+	if (command_list_queue[0] == nullptr) {
+		// No setup command, but commands to submit, submit from the first and skip command.
+		if (command_list_count > 1) {
+			commands_ptr = command_list_queue.ptr() + 1;
+			commands_to_submit = command_list_count - 1;
+		}
+	} else {
+		commands_ptr = command_list_queue.ptr();
+		commands_to_submit = command_list_count;
+	}
+
+	md.queue->ExecuteCommandLists(commands_to_submit, commands_ptr);
+
+	command_list_queue.write[0] = nullptr;
+	command_list_count = 1;
+
+	for (KeyValue<int, Window> &E : windows) {
+		Window *w = &E.value;
+
+		if (!w->swapchain) {
+			continue;
+		}
+		HRESULT res = w->swapchain->Present(w->sync_interval, w->present_flags);
+		if (res) {
+			print_verbose("D3D12: Presenting swapchain of window " + itos(E.key) + " failed with error " + vformat("0x%08ux", res) + ".");
+		}
+	}
+
+	md.queue->Signal(frame_fence.Get(), frame);
+	frame++;
+
+	buffers_prepared = false;
+	return OK;
+}
+
+void D3D12Context::resize_notify() {
+}
+
+ComPtr<ID3D12Device> D3D12Context::get_device() {
+	return md.device;
+}
+
+ComPtr<IDXGIAdapter> D3D12Context::get_adapter() {
+	return gpu;
+}
+
+D3D12MA::Allocator *D3D12Context::get_allocator() {
+	return allocator.Get();
+}
+
+int D3D12Context::get_swapchain_image_count() const {
+	return IMAGE_COUNT;
+}
+
+DXGI_FORMAT D3D12Context::get_screen_format() const {
+	return format;
+}
+
+D3D12Context::DeviceLimits D3D12Context::get_device_limits() const {
+	return gpu_limits;
+}
+
+RID D3D12Context::local_device_create() {
+	LocalDevice ld;
+	_create_device(ld);
+	return local_device_owner.make_rid(ld);
+}
+
+ComPtr<ID3D12Device> D3D12Context::local_device_get_d3d12_device(RID p_local_device) {
+	LocalDevice *ld = local_device_owner.get_or_null(p_local_device);
+	return ld->device;
+}
+
+void D3D12Context::local_device_push_command_lists(RID p_local_device, ID3D12CommandList *const *p_lists, int p_count) {
+	LocalDevice *ld = local_device_owner.get_or_null(p_local_device);
+	ERR_FAIL_COND(ld->waiting);
+
+	ld->queue->ExecuteCommandLists(p_count, p_lists);
+
+	ld->waiting = true;
+}
+
+void D3D12Context::local_device_sync(RID p_local_device) {
+	LocalDevice *ld = local_device_owner.get_or_null(p_local_device);
+	ERR_FAIL_COND(!ld->waiting);
+
+	ld->fence_value++;
+	ld->queue->Signal(ld->fence.Get(), ld->fence_value);
+	ld->fence->SetEventOnCompletion(ld->fence_value, ld->fence_event);
+	WaitForSingleObjectEx(ld->fence_event, INFINITE, FALSE);
+#ifdef PIX_ENABLED
+	PIXNotifyWakeFromFenceSignal(ld->fence_event);
+#endif
+
+	ld->waiting = false;
+}
+
+void D3D12Context::local_device_free(RID p_local_device) {
+	LocalDevice *ld = local_device_owner.get_or_null(p_local_device);
+
+	CloseHandle(ld->fence_event);
+
+	local_device_owner.free(p_local_device);
+}
+
+void D3D12Context::command_begin_label(ID3D12GraphicsCommandList *p_command_list, String p_label_name, const Color p_color) {
+#ifdef PIX_ENABLED
+	PIXBeginEvent(p_command_list, p_color.to_argb32(), p_label_name.utf8().get_data());
+#endif
+}
+
+void D3D12Context::command_insert_label(ID3D12GraphicsCommandList *p_command_list, String p_label_name, const Color p_color) {
+#ifdef PIX_ENABLED
+	PIXSetMarker(p_command_list, p_color.to_argb32(), p_label_name.utf8().get_data());
+#endif
+}
+
+void D3D12Context::command_end_label(ID3D12GraphicsCommandList *p_command_list) {
+#ifdef PIX_ENABLED
+	PIXEndEvent(p_command_list);
+#endif
+}
+
+void D3D12Context::set_object_name(ID3D12Object *p_object, String p_object_name) {
+	ERR_FAIL_NULL(p_object);
+	int name_len = p_object_name.size();
+	WCHAR *name_w = (WCHAR *)alloca(sizeof(WCHAR) * (name_len + 1));
+	MultiByteToWideChar(CP_UTF8, 0, p_object_name.utf8().get_data(), -1, name_w, name_len);
+	p_object->SetName(name_w);
+}
+
+String D3D12Context::get_device_vendor_name() const {
+	return adapter_vendor;
+}
+String D3D12Context::get_device_name() const {
+	return adapter_name;
+}
+
+RenderingDevice::DeviceType D3D12Context::get_device_type() const {
+	return adapter_type;
+}
+
+String D3D12Context::get_device_api_version() const {
+	return vformat("%d_%d", feature_level / 10, feature_level % 10);
+}
+
+String D3D12Context::get_device_pipeline_cache_uuid() const {
+	return pipeline_cache_id;
+}
+
+DisplayServer::VSyncMode D3D12Context::get_vsync_mode(DisplayServer::WindowID p_window) const {
+	ERR_FAIL_COND_V_MSG(!windows.has(p_window), DisplayServer::VSYNC_ENABLED, "Could not get V-Sync mode for window with WindowID " + itos(p_window) + " because it does not exist.");
+	return windows[p_window].vsync_mode;
+}
+
+void D3D12Context::set_vsync_mode(DisplayServer::WindowID p_window, DisplayServer::VSyncMode p_mode) {
+	ERR_FAIL_COND_MSG(!windows.has(p_window), "Could not set V-Sync mode for window with WindowID " + itos(p_window) + " because it does not exist.");
+	windows[p_window].vsync_mode = p_mode;
+	_update_swap_chain(&windows[p_window]);
+}
+
+D3D12Context::D3D12Context() {
+	command_list_queue.resize(1); // First one is always the setup command.
+	command_list_queue.write[0] = nullptr;
+
+	strcpy(godot_nir_arch_name, Engine::get_singleton()->get_architecture_name().ascii().get_data());
+}
+
+D3D12Context::~D3D12Context() {
+	if (md.fence_event) {
+		CloseHandle(md.fence_event);
+	}
+	if (frame_fence_event) {
+		CloseHandle(frame_fence_event);
+	}
+}
diff --git a/drivers/d3d12/d3d12_context.h b/drivers/d3d12/d3d12_context.h
new file mode 100644
index 0000000000..31e75affd0
--- /dev/null
+++ b/drivers/d3d12/d3d12_context.h
@@ -0,0 +1,248 @@
+/**************************************************************************/
+/*  d3d12_context.h                                                       */
+/**************************************************************************/
+/*                         This file is part of:                          */
+/*                             GODOT ENGINE                               */
+/*                        https://godotengine.org                         */
+/**************************************************************************/
+/* Copyright (c) 2014-present Godot Engine contributors (see AUTHORS.md). */
+/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur.                  */
+/*                                                                        */
+/* Permission is hereby granted, free of charge, to any person obtaining  */
+/* a copy of this software and associated documentation files (the        */
+/* "Software"), to deal in the Software without restriction, including    */
+/* without limitation the rights to use, copy, modify, merge, publish,    */
+/* distribute, sublicense, and/or sell copies of the Software, and to     */
+/* permit persons to whom the Software is furnished to do so, subject to  */
+/* the following conditions:                                              */
+/*                                                                        */
+/* The above copyright notice and this permission notice shall be         */
+/* included in all copies or substantial portions of the Software.        */
+/*                                                                        */
+/* 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. */
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY   */
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,   */
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE      */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                 */
+/**************************************************************************/
+
+#ifndef D3D12_CONTEXT_H
+#define D3D12_CONTEXT_H
+
+#include "core/error/error_list.h"
+#include "core/os/mutex.h"
+#include "core/string/ustring.h"
+#include "core/templates/rb_map.h"
+#include "core/templates/rid_owner.h"
+#include "servers/display_server.h"
+#include "servers/rendering/rendering_device.h"
+
+#include "d3dx12.h"
+#include <dxgi1_6.h>
+#define D3D12MA_D3D12_HEADERS_ALREADY_INCLUDED
+#include "D3D12MemAlloc.h"
+
+#include <wrl/client.h>
+using Microsoft::WRL::ComPtr;
+
+class D3D12Context {
+public:
+	struct DeviceLimits {
+		uint64_t max_srvs_per_shader_stage;
+		uint64_t max_cbvs_per_shader_stage;
+		uint64_t max_samplers_across_all_stages;
+		uint64_t max_uavs_across_all_stages;
+		uint64_t timestamp_frequency;
+	};
+
+	struct SubgroupCapabilities {
+		uint32_t size;
+		bool wave_ops_supported;
+		uint32_t supported_stages_flags_rd() const;
+		uint32_t supported_operations_flags_rd() const;
+	};
+
+	// Following VulkanContext definition.
+	struct MultiviewCapabilities {
+		bool is_supported;
+		bool geometry_shader_is_supported;
+		bool tessellation_shader_is_supported;
+		uint32_t max_view_count;
+		uint32_t max_instance_count;
+	};
+
+	struct VRSCapabilities {
+		bool draw_call_supported; // We can specify our fragment rate on a draw call level.
+		bool primitive_supported; // We can specify our fragment rate on each drawcall.
+		bool primitive_in_multiviewport;
+		bool ss_image_supported; // We can provide a density map attachment on our framebuffer.
+		uint32_t ss_image_tile_size;
+		bool additional_rates_supported;
+	};
+
+	struct ShaderCapabilities {
+		D3D_SHADER_MODEL shader_model;
+		bool native_16bit_ops;
+	};
+
+	struct StorageBufferCapabilities {
+		bool storage_buffer_16_bit_access_is_supported;
+	};
+
+	struct FormatCapabilities {
+		bool relaxed_casting_supported;
+	};
+
+private:
+	enum {
+		FRAME_LAG = 2,
+		IMAGE_COUNT = FRAME_LAG + 1,
+	};
+
+	ComPtr<IDXGIFactory2> dxgi_factory;
+	ComPtr<IDXGIAdapter> gpu;
+	DeviceLimits gpu_limits = {};
+	struct DeviceBasics {
+		ComPtr<ID3D12Device> device;
+		ComPtr<ID3D12CommandQueue> queue;
+		ComPtr<ID3D12Fence> fence;
+		HANDLE fence_event = nullptr;
+		UINT64 fence_value = 0;
+	} md; // 'Main device', as opposed to local device.
+
+	uint32_t feature_level = 0; // Major * 10 + minor.
+	bool tearing_supported = false;
+	SubgroupCapabilities subgroup_capabilities;
+	MultiviewCapabilities multiview_capabilities;
+	VRSCapabilities vrs_capabilities;
+	ShaderCapabilities shader_capabilities;
+	StorageBufferCapabilities storage_buffer_capabilities;
+	FormatCapabilities format_capabilities;
+
+	String adapter_vendor;
+	String adapter_name;
+	RenderingDevice::DeviceType adapter_type = {};
+	String pipeline_cache_id;
+
+	ComPtr<D3D12MA::Allocator> allocator;
+
+	bool buffers_prepared = false;
+
+	DXGI_FORMAT format = DXGI_FORMAT_UNKNOWN;
+	uint32_t frame = 0;
+	ComPtr<ID3D12Fence> frame_fence;
+	HANDLE frame_fence_event = nullptr;
+
+	struct Window {
+		HWND hwnd = nullptr;
+		ComPtr<IDXGISwapChain3> swapchain;
+		UINT swapchain_flags = 0;
+		UINT sync_interval = 1;
+		UINT present_flags = 0;
+		ComPtr<ID3D12Resource> render_targets[IMAGE_COUNT];
+		uint32_t current_buffer = 0;
+		int width = 0;
+		int height = 0;
+		DisplayServer::VSyncMode vsync_mode = DisplayServer::VSYNC_ENABLED;
+		ComPtr<ID3D12DescriptorHeap> rtv_heap;
+	};
+
+	struct LocalDevice : public DeviceBasics {
+		bool waiting = false;
+		HANDLE fence_event = nullptr;
+		UINT64 fence_value = 0;
+	};
+
+	RID_Owner<LocalDevice, true> local_device_owner;
+
+	HashMap<DisplayServer::WindowID, Window> windows;
+
+	// Commands.
+
+	Vector<ID3D12CommandList *> command_list_queue;
+	int command_list_count = 1;
+
+	static void _debug_message_func(
+			D3D12_MESSAGE_CATEGORY p_category,
+			D3D12_MESSAGE_SEVERITY p_severity,
+			D3D12_MESSAGE_ID p_id,
+			LPCSTR p_description,
+			void *p_context);
+
+	Error _initialize_debug_layers();
+
+	Error _select_adapter(int &r_index);
+	void _dump_adapter_info(int p_index);
+	Error _create_device(DeviceBasics &r_basics);
+	Error _get_device_limits();
+	Error _check_capabilities();
+
+	Error _update_swap_chain(Window *window);
+
+	void _wait_for_idle_queue(ID3D12CommandQueue *p_queue);
+
+protected:
+	virtual bool _use_validation_layers();
+
+public:
+	uint32_t get_feat_level_major() const { return feature_level / 10; };
+	uint32_t get_feat_level_minor() const { return feature_level % 10; };
+	const SubgroupCapabilities &get_subgroup_capabilities() const { return subgroup_capabilities; };
+	const MultiviewCapabilities &get_multiview_capabilities() const { return multiview_capabilities; };
+	const VRSCapabilities &get_vrs_capabilities() const { return vrs_capabilities; };
+	const ShaderCapabilities &get_shader_capabilities() const { return shader_capabilities; };
+	const StorageBufferCapabilities &get_storage_buffer_capabilities() const { return storage_buffer_capabilities; };
+	const FormatCapabilities &get_format_capabilities() const { return format_capabilities; };
+
+	ComPtr<ID3D12Device> get_device();
+	ComPtr<IDXGIAdapter> get_adapter();
+	D3D12MA::Allocator *get_allocator();
+	int get_swapchain_image_count() const;
+	Error window_create(DisplayServer::WindowID p_window_id, DisplayServer::VSyncMode p_vsync_mode, HWND p_window, HINSTANCE p_instance, int p_width, int p_height);
+	void window_resize(DisplayServer::WindowID p_window_id, int p_width, int p_height);
+	int window_get_width(DisplayServer::WindowID p_window = 0);
+	int window_get_height(DisplayServer::WindowID p_window = 0);
+	bool window_is_valid_swapchain(DisplayServer::WindowID p_window = 0);
+	void window_destroy(DisplayServer::WindowID p_window_id);
+	CD3DX12_CPU_DESCRIPTOR_HANDLE window_get_framebuffer_rtv_handle(DisplayServer::WindowID p_window = 0);
+	ID3D12Resource *window_get_framebuffer_texture(DisplayServer::WindowID p_window = 0);
+
+	RID local_device_create();
+	ComPtr<ID3D12Device> local_device_get_d3d12_device(RID p_local_device);
+	void local_device_push_command_lists(RID p_local_device, ID3D12CommandList *const *p_lists, int p_count);
+	void local_device_sync(RID p_local_device);
+	void local_device_free(RID p_local_device);
+
+	DXGI_FORMAT get_screen_format() const;
+	DeviceLimits get_device_limits() const;
+
+	void set_setup_list(ID3D12CommandList *p_command_list);
+	void append_command_list(ID3D12CommandList *p_command_list);
+	void resize_notify();
+	void flush(bool p_flush_setup = false, bool p_flush_pending = false);
+	void prepare_buffers(ID3D12GraphicsCommandList *p_command_list);
+	void postpare_buffers(ID3D12GraphicsCommandList *p_command_list);
+	Error swap_buffers();
+	Error initialize();
+
+	void command_begin_label(ID3D12GraphicsCommandList *p_command_list, String p_label_name, const Color p_color);
+	void command_insert_label(ID3D12GraphicsCommandList *p_command_list, String p_label_name, const Color p_color);
+	void command_end_label(ID3D12GraphicsCommandList *p_command_list);
+	void set_object_name(ID3D12Object *p_object, String p_object_name);
+
+	String get_device_vendor_name() const;
+	String get_device_name() const;
+	RenderingDevice::DeviceType get_device_type() const;
+	String get_device_api_version() const;
+	String get_device_pipeline_cache_uuid() const;
+
+	void set_vsync_mode(DisplayServer::WindowID p_window, DisplayServer::VSyncMode p_mode);
+	DisplayServer::VSyncMode get_vsync_mode(DisplayServer::WindowID p_window = 0) const;
+
+	D3D12Context();
+	virtual ~D3D12Context();
+};
+
+#endif // D3D12_CONTEXT_H
diff --git a/drivers/d3d12/d3d12_godot_nir_bridge.h b/drivers/d3d12/d3d12_godot_nir_bridge.h
new file mode 100644
index 0000000000..f66c4edf89
--- /dev/null
+++ b/drivers/d3d12/d3d12_godot_nir_bridge.h
@@ -0,0 +1,60 @@
+/**************************************************************************/
+/*  d3d12_godot_nir_bridge.h                                              */
+/**************************************************************************/
+/*                         This file is part of:                          */
+/*                             GODOT ENGINE                               */
+/*                        https://godotengine.org                         */
+/**************************************************************************/
+/* Copyright (c) 2014-present Godot Engine contributors (see AUTHORS.md). */
+/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur.                  */
+/*                                                                        */
+/* Permission is hereby granted, free of charge, to any person obtaining  */
+/* a copy of this software and associated documentation files (the        */
+/* "Software"), to deal in the Software without restriction, including    */
+/* without limitation the rights to use, copy, modify, merge, publish,    */
+/* distribute, sublicense, and/or sell copies of the Software, and to     */
+/* permit persons to whom the Software is furnished to do so, subject to  */
+/* the following conditions:                                              */
+/*                                                                        */
+/* The above copyright notice and this permission notice shall be         */
+/* included in all copies or substantial portions of the Software.        */
+/*                                                                        */
+/* 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. */
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY   */
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,   */
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE      */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                 */
+/**************************************************************************/
+
+#ifndef D3D12_GODOT_NIR_BRIDGE_H
+#define D3D12_GODOT_NIR_BRIDGE_H
+
+#include <stdint.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+// This one leaves room for potentially extremely copious bindings in a set.
+static const uint32_t GODOT_NIR_DESCRIPTOR_SET_MULTIPLIER = 100000000;
+// This one leaves room for potentially big sized arrays.
+static const uint32_t GODOT_NIR_BINDING_MULTIPLIER = 100000;
+
+static const uint64_t GODOT_NIR_SC_SENTINEL_MAGIC = 0x45678900; // This must be as big as to be VBR-ed as a 32 bits number.
+static const uint64_t GODOT_NIR_SC_SENTINEL_MAGIC_MASK = 0xffffffffffffff00;
+static const uint64_t GODOT_NIR_SC_SENTINEL_ID_MASK = 0x00000000000000ff;
+
+typedef struct GodotNirCallbacks {
+	void *data;
+	void (*report_resource)(uint32_t p_register, uint32_t p_space, uint32_t p_dxil_type, void *p_data);
+	void (*report_sc_bit_offset_fn)(uint32_t p_sc_id, uint64_t p_bit_offset, void *p_data);
+	void (*report_bitcode_bit_offset_fn)(uint64_t p_bit_offset, void *p_data);
+} GodotNirCallbacks;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // D3D12_GODOT_NIR_BRIDGE_H
diff --git a/drivers/d3d12/d3d12ma.cpp b/drivers/d3d12/d3d12ma.cpp
new file mode 100644
index 0000000000..0ac2f71074
--- /dev/null
+++ b/drivers/d3d12/d3d12ma.cpp
@@ -0,0 +1,34 @@
+/**************************************************************************/
+/*  d3d12ma.cpp                                                           */
+/**************************************************************************/
+/*                         This file is part of:                          */
+/*                             GODOT ENGINE                               */
+/*                        https://godotengine.org                         */
+/**************************************************************************/
+/* Copyright (c) 2014-present Godot Engine contributors (see AUTHORS.md). */
+/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur.                  */
+/*                                                                        */
+/* Permission is hereby granted, free of charge, to any person obtaining  */
+/* a copy of this software and associated documentation files (the        */
+/* "Software"), to deal in the Software without restriction, including    */
+/* without limitation the rights to use, copy, modify, merge, publish,    */
+/* distribute, sublicense, and/or sell copies of the Software, and to     */
+/* permit persons to whom the Software is furnished to do so, subject to  */
+/* the following conditions:                                              */
+/*                                                                        */
+/* The above copyright notice and this permission notice shall be         */
+/* included in all copies or substantial portions of the Software.        */
+/*                                                                        */
+/* 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. */
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY   */
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,   */
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE      */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                 */
+/**************************************************************************/
+
+#include "d3d12_context.h"
+
+#pragma warning(disable : 4189 4324 4505)
+#include "thirdparty/d3d12ma/D3D12MemAlloc.cpp"
diff --git a/drivers/d3d12/rendering_device_d3d12.cpp b/drivers/d3d12/rendering_device_d3d12.cpp
new file mode 100644
index 0000000000..839bcf6bc7
--- /dev/null
+++ b/drivers/d3d12/rendering_device_d3d12.cpp
@@ -0,0 +1,9480 @@
+/**************************************************************************/
+/*  rendering_device_d3d12.cpp                                            */
+/**************************************************************************/
+/*                         This file is part of:                          */
+/*                             GODOT ENGINE                               */
+/*                        https://godotengine.org                         */
+/**************************************************************************/
+/* Copyright (c) 2014-present Godot Engine contributors (see AUTHORS.md). */
+/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur.                  */
+/*                                                                        */
+/* Permission is hereby granted, free of charge, to any person obtaining  */
+/* a copy of this software and associated documentation files (the        */
+/* "Software"), to deal in the Software without restriction, including    */
+/* without limitation the rights to use, copy, modify, merge, publish,    */
+/* distribute, sublicense, and/or sell copies of the Software, and to     */
+/* permit persons to whom the Software is furnished to do so, subject to  */
+/* the following conditions:                                              */
+/*                                                                        */
+/* The above copyright notice and this permission notice shall be         */
+/* included in all copies or substantial portions of the Software.        */
+/*                                                                        */
+/* 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. */
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY   */
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,   */
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE      */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                 */
+/**************************************************************************/
+
+#include "rendering_device_d3d12.h"
+
+#include "core/config/project_settings.h"
+#include "core/io/compression.h"
+#include "core/io/file_access.h"
+#include "core/io/marshalls.h"
+#include "core/object/worker_thread_pool.h"
+#include "core/os/os.h"
+#include "core/templates/hashfuncs.h"
+#include "d3d12_godot_nir_bridge.h"
+#include "modules/regex/regex.h"
+#include "thirdparty/zlib/zlib.h"
+
+#ifdef DEV_ENABLED
+#include "core/crypto/hashing_context.h"
+#endif
+
+// No point in fighting warnings in Mesa.
+#pragma warning(push)
+#pragma warning(disable : 4200) // "nonstandard extension used: zero-sized array in struct/union".
+#pragma warning(disable : 4806) // "'&': unsafe operation: no value of type 'bool' promoted to type 'uint32_t' can equal the given constant".
+#include "dxil_validator.h"
+#include "nir_spirv.h"
+#include "nir_to_dxil.h"
+#include "spirv_to_dxil.h"
+extern "C" {
+#include "dxil_spirv_nir.h"
+}
+#pragma warning(pop)
+
+#define ALIGN(m_number, m_alignment) ((((m_number) + ((m_alignment)-1)) / (m_alignment)) * (m_alignment))
+
+#ifdef USE_SMALL_ALLOCS_POOL
+static const uint32_t SMALL_ALLOCATION_MAX_SIZE = 4096;
+#endif
+
+static const D3D12_RANGE VOID_RANGE = {};
+
+static const uint32_t MAX_VULKAN_SETS = 16;
+static const uint32_t ROOT_CONSTANT_SPACE = MAX_VULKAN_SETS + 1;
+static const uint32_t ROOT_CONSTANT_REGISTER = 0;
+static const uint32_t RUNTIME_DATA_SPACE = MAX_VULKAN_SETS + 2;
+static const uint32_t RUNTIME_DATA_REGISTER = 0;
+
+static const uint32_t MAX_IMAGE_FORMAT_PLANES = 2;
+
+#ifdef DEV_ENABLED
+//#define DEBUG_COUNT_BARRIERS
+#endif
+
+RenderingDeviceD3D12::Buffer *RenderingDeviceD3D12::_get_buffer_from_owner(RID p_buffer) {
+	Buffer *buffer = nullptr;
+	if (vertex_buffer_owner.owns(p_buffer)) {
+		buffer = vertex_buffer_owner.get_or_null(p_buffer);
+	} else if (index_buffer_owner.owns(p_buffer)) {
+		buffer = index_buffer_owner.get_or_null(p_buffer);
+	} else if (uniform_buffer_owner.owns(p_buffer)) {
+		buffer = uniform_buffer_owner.get_or_null(p_buffer);
+	} else if (texture_buffer_owner.owns(p_buffer)) {
+		buffer = &texture_buffer_owner.get_or_null(p_buffer)->buffer;
+	} else if (storage_buffer_owner.owns(p_buffer)) {
+		buffer = storage_buffer_owner.get_or_null(p_buffer);
+	}
+	return buffer;
+}
+
+void RenderingDeviceD3D12::_add_dependency(RID p_id, RID p_depends_on) {
+	if (!dependency_map.has(p_depends_on)) {
+		dependency_map[p_depends_on] = HashSet<RID>();
+	}
+
+	dependency_map[p_depends_on].insert(p_id);
+
+	if (!reverse_dependency_map.has(p_id)) {
+		reverse_dependency_map[p_id] = HashSet<RID>();
+	}
+
+	reverse_dependency_map[p_id].insert(p_depends_on);
+}
+
+void RenderingDeviceD3D12::_free_dependencies(RID p_id) {
+	// Direct dependencies must be freed.
+
+	HashMap<RID, HashSet<RID>>::Iterator E = dependency_map.find(p_id);
+	if (E) {
+		while (E->value.size()) {
+			free(*E->value.begin());
+		}
+		dependency_map.remove(E);
+	}
+
+	// Reverse dependencies must be unreferenced.
+	E = reverse_dependency_map.find(p_id);
+
+	if (E) {
+		for (const RID &F : E->value) {
+			HashMap<RID, HashSet<RID>>::Iterator G = dependency_map.find(F);
+			ERR_CONTINUE(!G);
+			ERR_CONTINUE(!G->value.has(p_id));
+			G->value.erase(p_id);
+		}
+
+		reverse_dependency_map.remove(E);
+	}
+}
+
+// NOTE: RD's packed format names are reversed in relation to DXGI's; e.g.:.
+// - DATA_FORMAT_A8B8G8R8_UNORM_PACK32 -> DXGI_FORMAT_R8G8B8A8_UNORM (packed; note ABGR vs. RGBA).
+// - DATA_FORMAT_B8G8R8A8_UNORM -> DXGI_FORMAT_B8G8R8A8_UNORM (not packed; note BGRA order matches).
+// TODO: Add YUV formats properly, which would require better support for planes in the RD API.
+const RenderingDeviceD3D12::D3D12Format RenderingDeviceD3D12::d3d12_formats[RenderingDevice::DATA_FORMAT_MAX] = {
+	/* DATA_FORMAT_R4G4_UNORM_PACK8 */ {},
+	/* DATA_FORMAT_R4G4B4A4_UNORM_PACK16 */ { DXGI_FORMAT_B4G4R4A4_UNORM, DXGI_FORMAT_B4G4R4A4_UNORM, D3D12_ENCODE_SHADER_4_COMPONENT_MAPPING(1, 2, 3, 0) },
+	/* DATA_FORMAT_B4G4R4A4_UNORM_PACK16 */ { DXGI_FORMAT_B4G4R4A4_UNORM, DXGI_FORMAT_B4G4R4A4_UNORM, D3D12_ENCODE_SHADER_4_COMPONENT_MAPPING(3, 2, 1, 0) },
+	/* DATA_FORMAT_R5G6B5_UNORM_PACK16 */ { DXGI_FORMAT_B5G6R5_UNORM, DXGI_FORMAT_B5G6R5_UNORM },
+	/* DATA_FORMAT_B5G6R5_UNORM_PACK16 */ { DXGI_FORMAT_B5G6R5_UNORM, DXGI_FORMAT_B5G6R5_UNORM, D3D12_ENCODE_SHADER_4_COMPONENT_MAPPING(2, 1, 0, 3) },
+	/* DATA_FORMAT_R5G5B5A1_UNORM_PACK16 */ { DXGI_FORMAT_B5G6R5_UNORM, DXGI_FORMAT_B5G5R5A1_UNORM, D3D12_ENCODE_SHADER_4_COMPONENT_MAPPING(1, 2, 3, 0) },
+	/* DATA_FORMAT_B5G5R5A1_UNORM_PACK16 */ { DXGI_FORMAT_B5G6R5_UNORM, DXGI_FORMAT_B5G5R5A1_UNORM, D3D12_ENCODE_SHADER_4_COMPONENT_MAPPING(3, 2, 1, 0) },
+	/* DATA_FORMAT_A1R5G5B5_UNORM_PACK16 */ { DXGI_FORMAT_B5G6R5_UNORM, DXGI_FORMAT_B5G5R5A1_UNORM },
+	/* DATA_FORMAT_R8_UNORM */ { DXGI_FORMAT_R8_TYPELESS, DXGI_FORMAT_R8_UNORM },
+	/* DATA_FORMAT_R8_SNORM */ { DXGI_FORMAT_R8_TYPELESS, DXGI_FORMAT_R8_SNORM },
+	/* DATA_FORMAT_R8_USCALED */ { DXGI_FORMAT_R8_TYPELESS, DXGI_FORMAT_R8_UINT },
+	/* DATA_FORMAT_R8_SSCALED */ { DXGI_FORMAT_R8_TYPELESS, DXGI_FORMAT_R8_SINT },
+	/* DATA_FORMAT_R8_UINT */ { DXGI_FORMAT_R8_TYPELESS, DXGI_FORMAT_R8_UINT },
+	/* DATA_FORMAT_R8_SINT */ { DXGI_FORMAT_R8_TYPELESS, DXGI_FORMAT_R8_SINT },
+	/* DATA_FORMAT_R8_SRGB */ {},
+	/* DATA_FORMAT_R8G8_UNORM */ { DXGI_FORMAT_R8G8_TYPELESS, DXGI_FORMAT_R8G8_UNORM },
+	/* DATA_FORMAT_R8G8_SNORM */ { DXGI_FORMAT_R8G8_TYPELESS, DXGI_FORMAT_R8G8_SNORM },
+	/* DATA_FORMAT_R8G8_USCALED */ { DXGI_FORMAT_R8G8_TYPELESS, DXGI_FORMAT_R8G8_UINT },
+	/* DATA_FORMAT_R8G8_SSCALED */ { DXGI_FORMAT_R8G8_TYPELESS, DXGI_FORMAT_R8G8_SINT },
+	/* DATA_FORMAT_R8G8_UINT */ { DXGI_FORMAT_R8G8_TYPELESS, DXGI_FORMAT_R8G8_UINT },
+	/* DATA_FORMAT_R8G8_SINT */ { DXGI_FORMAT_R8G8_TYPELESS, DXGI_FORMAT_R8G8_SINT },
+	/* DATA_FORMAT_R8G8_SRGB */ {},
+	/* DATA_FORMAT_R8G8B8_UNORM */ {},
+	/* DATA_FORMAT_R8G8B8_SNORM */ {},
+	/* DATA_FORMAT_R8G8B8_USCALED */ {},
+	/* DATA_FORMAT_R8G8B8_SSCALED */ {},
+	/* DATA_FORMAT_R8G8B8_UINT */ {},
+	/* DATA_FORMAT_R8G8B8_SINT */ {},
+	/* DATA_FORMAT_R8G8B8_SRGB */ {},
+	/* DATA_FORMAT_B8G8R8_UNORM */ {},
+	/* DATA_FORMAT_B8G8R8_SNORM */ {},
+	/* DATA_FORMAT_B8G8R8_USCALED */ {},
+	/* DATA_FORMAT_B8G8R8_SSCALED */ {},
+	/* DATA_FORMAT_B8G8R8_UINT */ {},
+	/* DATA_FORMAT_B8G8R8_SINT */ {},
+	/* DATA_FORMAT_B8G8R8_SRGB */ {},
+	/* DATA_FORMAT_R8G8B8A8_UNORM */ { DXGI_FORMAT_R8G8B8A8_TYPELESS, DXGI_FORMAT_R8G8B8A8_UNORM },
+	/* DATA_FORMAT_R8G8B8A8_SNORM */ { DXGI_FORMAT_R8G8B8A8_TYPELESS, DXGI_FORMAT_R8G8B8A8_SNORM },
+	/* DATA_FORMAT_R8G8B8A8_USCALED */ { DXGI_FORMAT_R8G8B8A8_TYPELESS, DXGI_FORMAT_R8G8B8A8_UINT },
+	/* DATA_FORMAT_R8G8B8A8_SSCALED */ { DXGI_FORMAT_R8G8B8A8_TYPELESS, DXGI_FORMAT_R8G8B8A8_SINT },
+	/* DATA_FORMAT_R8G8B8A8_UINT */ { DXGI_FORMAT_R8G8B8A8_TYPELESS, DXGI_FORMAT_R8G8B8A8_UINT },
+	/* DATA_FORMAT_R8G8B8A8_SINT */ { DXGI_FORMAT_R8G8B8A8_TYPELESS, DXGI_FORMAT_R8G8B8A8_SINT },
+	/* DATA_FORMAT_R8G8B8A8_SRGB */ { DXGI_FORMAT_R8G8B8A8_TYPELESS, DXGI_FORMAT_R8G8B8A8_UNORM_SRGB },
+	/* DATA_FORMAT_B8G8R8A8_UNORM */ { DXGI_FORMAT_B8G8R8A8_TYPELESS, DXGI_FORMAT_B8G8R8A8_UNORM },
+	/* DATA_FORMAT_B8G8R8A8_SNORM */ { DXGI_FORMAT_R8G8B8A8_TYPELESS, DXGI_FORMAT_R8G8B8A8_SNORM },
+	/* DATA_FORMAT_B8G8R8A8_USCALED */ { DXGI_FORMAT_R8G8B8A8_TYPELESS, DXGI_FORMAT_R8G8B8A8_UINT },
+	/* DATA_FORMAT_B8G8R8A8_SSCALED */ { DXGI_FORMAT_R8G8B8A8_TYPELESS, DXGI_FORMAT_R8G8B8A8_SINT },
+	/* DATA_FORMAT_B8G8R8A8_UINT */ { DXGI_FORMAT_R8G8B8A8_TYPELESS, DXGI_FORMAT_R8G8B8A8_UINT },
+	/* DATA_FORMAT_B8G8R8A8_SINT */ { DXGI_FORMAT_R8G8B8A8_TYPELESS, DXGI_FORMAT_R8G8B8A8_SINT },
+	/* DATA_FORMAT_B8G8R8A8_SRGB */ { DXGI_FORMAT_B8G8R8A8_TYPELESS, DXGI_FORMAT_R8G8B8A8_UNORM_SRGB },
+	/* DATA_FORMAT_A8B8G8R8_UNORM_PACK32 */ { DXGI_FORMAT_R8G8B8A8_TYPELESS, DXGI_FORMAT_R8G8B8A8_UNORM },
+	/* DATA_FORMAT_A8B8G8R8_SNORM_PACK32 */ { DXGI_FORMAT_R8G8B8A8_TYPELESS, DXGI_FORMAT_R8G8B8A8_SNORM },
+	/* DATA_FORMAT_A8B8G8R8_USCALED_PACK32 */ { DXGI_FORMAT_R8G8B8A8_TYPELESS, DXGI_FORMAT_R8G8B8A8_UINT },
+	/* DATA_FORMAT_A8B8G8R8_SSCALED_PACK32 */ { DXGI_FORMAT_R8G8B8A8_TYPELESS, DXGI_FORMAT_R8G8B8A8_SINT },
+	/* DATA_FORMAT_A8B8G8R8_UINT_PACK32 */ { DXGI_FORMAT_R8G8B8A8_TYPELESS, DXGI_FORMAT_R8G8B8A8_UINT },
+	/* DATA_FORMAT_A8B8G8R8_SINT_PACK32 */ { DXGI_FORMAT_R8G8B8A8_TYPELESS, DXGI_FORMAT_R8G8B8A8_SINT },
+	/* DATA_FORMAT_A8B8G8R8_SRGB_PACK32 */ { DXGI_FORMAT_B8G8R8A8_TYPELESS, DXGI_FORMAT_B8G8R8A8_UNORM_SRGB },
+	/* DATA_FORMAT_A2R10G10B10_UNORM_PACK32 */ { DXGI_FORMAT_R10G10B10A2_TYPELESS, DXGI_FORMAT_R10G10B10A2_UNORM, D3D12_ENCODE_SHADER_4_COMPONENT_MAPPING(2, 1, 0, 3) },
+	/* DATA_FORMAT_A2R10G10B10_SNORM_PACK32 */ {},
+	/* DATA_FORMAT_A2R10G10B10_USCALED_PACK32 */ { DXGI_FORMAT_R10G10B10A2_TYPELESS, DXGI_FORMAT_R10G10B10A2_UINT, D3D12_ENCODE_SHADER_4_COMPONENT_MAPPING(2, 1, 0, 3) },
+	/* DATA_FORMAT_A2R10G10B10_SSCALED_PACK32 */ {},
+	/* DATA_FORMAT_A2R10G10B10_UINT_PACK32 */ { DXGI_FORMAT_R10G10B10A2_TYPELESS, DXGI_FORMAT_R10G10B10A2_UINT, D3D12_ENCODE_SHADER_4_COMPONENT_MAPPING(2, 1, 0, 3) },
+	/* DATA_FORMAT_A2R10G10B10_SINT_PACK32 */ {},
+	/* DATA_FORMAT_A2B10G10R10_UNORM_PACK32 */ { DXGI_FORMAT_R10G10B10A2_TYPELESS, DXGI_FORMAT_R10G10B10A2_UNORM },
+	/* DATA_FORMAT_A2B10G10R10_SNORM_PACK32 */ {},
+	/* DATA_FORMAT_A2B10G10R10_USCALED_PACK32 */ { DXGI_FORMAT_R10G10B10A2_TYPELESS, DXGI_FORMAT_R10G10B10A2_UINT },
+	/* DATA_FORMAT_A2B10G10R10_SSCALED_PACK32 */ {},
+	/* DATA_FORMAT_A2B10G10R10_UINT_PACK32 */ { DXGI_FORMAT_R10G10B10A2_TYPELESS, DXGI_FORMAT_R10G10B10A2_UINT },
+	/* DATA_FORMAT_A2B10G10R10_SINT_PACK32 */ {},
+	/* DATA_FORMAT_R16_UNORM */ { DXGI_FORMAT_R16_TYPELESS, DXGI_FORMAT_R16_UNORM },
+	/* DATA_FORMAT_R16_SNORM */ { DXGI_FORMAT_R16_TYPELESS, DXGI_FORMAT_R16_SNORM },
+	/* DATA_FORMAT_R16_USCALED */ { DXGI_FORMAT_R16_TYPELESS, DXGI_FORMAT_R16_UINT },
+	/* DATA_FORMAT_R16_SSCALED */ { DXGI_FORMAT_R16_TYPELESS, DXGI_FORMAT_R16_SINT },
+	/* DATA_FORMAT_R16_UINT */ { DXGI_FORMAT_R16_TYPELESS, DXGI_FORMAT_R16_UINT },
+	/* DATA_FORMAT_R16_SINT */ { DXGI_FORMAT_R16_TYPELESS, DXGI_FORMAT_R16_SINT },
+	/* DATA_FORMAT_R16_SFLOAT */ { DXGI_FORMAT_R16_TYPELESS, DXGI_FORMAT_R16_FLOAT },
+	/* DATA_FORMAT_R16G16_UNORM */ { DXGI_FORMAT_R16G16_TYPELESS, DXGI_FORMAT_R16G16_UNORM },
+	/* DATA_FORMAT_R16G16_SNORM */ { DXGI_FORMAT_R16G16_TYPELESS, DXGI_FORMAT_R16G16_SNORM },
+	/* DATA_FORMAT_R16G16_USCALED */ { DXGI_FORMAT_R16G16_TYPELESS, DXGI_FORMAT_R16G16_UINT },
+	/* DATA_FORMAT_R16G16_SSCALED */ { DXGI_FORMAT_R16G16_TYPELESS, DXGI_FORMAT_R16G16_SINT },
+	/* DATA_FORMAT_R16G16_UINT */ { DXGI_FORMAT_R16G16_TYPELESS, DXGI_FORMAT_R16G16_UINT },
+	/* DATA_FORMAT_R16G16_SINT */ { DXGI_FORMAT_R16G16_TYPELESS, DXGI_FORMAT_R16G16_SINT },
+	/* DATA_FORMAT_R16G16_SFLOAT */ { DXGI_FORMAT_R16G16_TYPELESS, DXGI_FORMAT_R16G16_FLOAT },
+	/* DATA_FORMAT_R16G16B16_UNORM */ {},
+	/* DATA_FORMAT_R16G16B16_SNORM */ {},
+	/* DATA_FORMAT_R16G16B16_USCALED */ {},
+	/* DATA_FORMAT_R16G16B16_SSCALED */ {},
+	/* DATA_FORMAT_R16G16B16_UINT */ {},
+	/* DATA_FORMAT_R16G16B16_SINT */ {},
+	/* DATA_FORMAT_R16G16B16_SFLOAT */ {},
+	/* DATA_FORMAT_R16G16B16A16_UNORM */ { DXGI_FORMAT_R16G16B16A16_TYPELESS, DXGI_FORMAT_R16G16B16A16_UNORM },
+	/* DATA_FORMAT_R16G16B16A16_SNORM */ { DXGI_FORMAT_R16G16B16A16_TYPELESS, DXGI_FORMAT_R16G16B16A16_SNORM },
+	/* DATA_FORMAT_R16G16B16A16_USCALED */ { DXGI_FORMAT_R16G16B16A16_TYPELESS, DXGI_FORMAT_R16G16B16A16_UINT },
+	/* DATA_FORMAT_R16G16B16A16_SSCALED */ { DXGI_FORMAT_R16G16B16A16_TYPELESS, DXGI_FORMAT_R16G16B16A16_SINT },
+	/* DATA_FORMAT_R16G16B16A16_UINT */ { DXGI_FORMAT_R16G16B16A16_TYPELESS, DXGI_FORMAT_R16G16B16A16_UINT },
+	/* DATA_FORMAT_R16G16B16A16_SINT */ { DXGI_FORMAT_R16G16B16A16_TYPELESS, DXGI_FORMAT_R16G16B16A16_SINT },
+	/* DATA_FORMAT_R16G16B16A16_SFLOAT */ { DXGI_FORMAT_R16G16B16A16_TYPELESS, DXGI_FORMAT_R16G16B16A16_FLOAT },
+	/* DATA_FORMAT_R32_UINT */ { DXGI_FORMAT_R32_TYPELESS, DXGI_FORMAT_R32_UINT },
+	/* DATA_FORMAT_R32_SINT */ { DXGI_FORMAT_R32_TYPELESS, DXGI_FORMAT_R32_SINT },
+	/* DATA_FORMAT_R32_SFLOAT */ { DXGI_FORMAT_R32_TYPELESS, DXGI_FORMAT_R32_FLOAT },
+	/* DATA_FORMAT_R32G32_UINT */ { DXGI_FORMAT_R32G32_TYPELESS, DXGI_FORMAT_R32G32_UINT },
+	/* DATA_FORMAT_R32G32_SINT */ { DXGI_FORMAT_R32G32_TYPELESS, DXGI_FORMAT_R32G32_SINT },
+	/* DATA_FORMAT_R32G32_SFLOAT */ { DXGI_FORMAT_R32G32_TYPELESS, DXGI_FORMAT_R32G32_FLOAT },
+	/* DATA_FORMAT_R32G32B32_UINT */ { DXGI_FORMAT_R32G32B32_TYPELESS, DXGI_FORMAT_R32G32B32_UINT },
+	/* DATA_FORMAT_R32G32B32_SINT */ { DXGI_FORMAT_R32G32B32_TYPELESS, DXGI_FORMAT_R32G32B32_SINT },
+	/* DATA_FORMAT_R32G32B32_SFLOAT */ { DXGI_FORMAT_R32G32B32_TYPELESS, DXGI_FORMAT_R32G32B32_FLOAT },
+	/* DATA_FORMAT_R32G32B32A32_UINT */ { DXGI_FORMAT_R32G32B32A32_TYPELESS, DXGI_FORMAT_R32G32B32A32_UINT },
+	/* DATA_FORMAT_R32G32B32A32_SINT */ { DXGI_FORMAT_R32G32B32A32_TYPELESS, DXGI_FORMAT_R32G32B32A32_SINT },
+	/* DATA_FORMAT_R32G32B32A32_SFLOAT */ { DXGI_FORMAT_R32G32B32A32_TYPELESS, DXGI_FORMAT_R32G32B32A32_FLOAT },
+	/* DATA_FORMAT_R64_UINT */ {},
+	/* DATA_FORMAT_R64_SINT */ {},
+	/* DATA_FORMAT_R64_SFLOAT */ {},
+	/* DATA_FORMAT_R64G64_UINT */ {},
+	/* DATA_FORMAT_R64G64_SINT */ {},
+	/* DATA_FORMAT_R64G64_SFLOAT */ {},
+	/* DATA_FORMAT_R64G64B64_UINT */ {},
+	/* DATA_FORMAT_R64G64B64_SINT */ {},
+	/* DATA_FORMAT_R64G64B64_SFLOAT */ {},
+	/* DATA_FORMAT_R64G64B64A64_UINT */ {},
+	/* DATA_FORMAT_R64G64B64A64_SINT */ {},
+	/* DATA_FORMAT_R64G64B64A64_SFLOAT */ {},
+	/* DATA_FORMAT_B10G11R11_UFLOAT_PACK32 */ { DXGI_FORMAT_R11G11B10_FLOAT, DXGI_FORMAT_R11G11B10_FLOAT },
+	/* DATA_FORMAT_E5B9G9R9_UFLOAT_PACK32 */ { DXGI_FORMAT_R9G9B9E5_SHAREDEXP, DXGI_FORMAT_R9G9B9E5_SHAREDEXP },
+	/* DATA_FORMAT_D16_UNORM */ { DXGI_FORMAT_R16_TYPELESS, DXGI_FORMAT_R16_UNORM, 0, DXGI_FORMAT_D16_UNORM },
+	/* DATA_FORMAT_X8_D24_UNORM_PACK32 */ { DXGI_FORMAT_R24G8_TYPELESS, DXGI_FORMAT_UNKNOWN, 0, DXGI_FORMAT_D24_UNORM_S8_UINT },
+	/* DATA_FORMAT_D32_SFLOAT */ { DXGI_FORMAT_R32_TYPELESS, DXGI_FORMAT_R32_FLOAT, D3D12_DEFAULT_SHADER_4_COMPONENT_MAPPING, DXGI_FORMAT_D32_FLOAT },
+	/* DATA_FORMAT_S8_UINT */ {},
+	/* DATA_FORMAT_D16_UNORM_S8_UINT */ {},
+	/* DATA_FORMAT_D24_UNORM_S8_UINT */ { DXGI_FORMAT_R24G8_TYPELESS, DXGI_FORMAT_UNKNOWN, 0, DXGI_FORMAT_D24_UNORM_S8_UINT },
+	/* DATA_FORMAT_D32_SFLOAT_S8_UINT */ { DXGI_FORMAT_R32G8X24_TYPELESS, DXGI_FORMAT_R32_FLOAT_X8X24_TYPELESS, D3D12_DEFAULT_SHADER_4_COMPONENT_MAPPING, DXGI_FORMAT_D32_FLOAT_S8X24_UINT },
+	/* DATA_FORMAT_BC1_RGB_UNORM_BLOCK */ { DXGI_FORMAT_BC1_TYPELESS, DXGI_FORMAT_BC1_UNORM, D3D12_ENCODE_SHADER_4_COMPONENT_MAPPING(0, 1, 2, D3D12_SHADER_COMPONENT_MAPPING_FORCE_VALUE_1) },
+	/* DATA_FORMAT_BC1_RGB_SRGB_BLOCK */ { DXGI_FORMAT_BC1_TYPELESS, DXGI_FORMAT_BC1_UNORM_SRGB, D3D12_ENCODE_SHADER_4_COMPONENT_MAPPING(0, 1, 2, D3D12_SHADER_COMPONENT_MAPPING_FORCE_VALUE_1) },
+	/* DATA_FORMAT_BC1_RGBA_UNORM_BLOCK */ { DXGI_FORMAT_BC1_TYPELESS, DXGI_FORMAT_BC1_UNORM },
+	/* DATA_FORMAT_BC1_RGBA_SRGB_BLOCK */ { DXGI_FORMAT_BC1_TYPELESS, DXGI_FORMAT_BC1_UNORM_SRGB },
+	/* DATA_FORMAT_BC2_UNORM_BLOCK */ { DXGI_FORMAT_BC2_TYPELESS, DXGI_FORMAT_BC2_UNORM },
+	/* DATA_FORMAT_BC2_SRGB_BLOCK */ { DXGI_FORMAT_BC2_TYPELESS, DXGI_FORMAT_BC2_UNORM_SRGB },
+	/* DATA_FORMAT_BC3_UNORM_BLOCK */ { DXGI_FORMAT_BC3_TYPELESS, DXGI_FORMAT_BC3_UNORM },
+	/* DATA_FORMAT_BC3_SRGB_BLOCK */ { DXGI_FORMAT_BC3_TYPELESS, DXGI_FORMAT_BC3_UNORM_SRGB },
+	/* DATA_FORMAT_BC4_UNORM_BLOCK */ { DXGI_FORMAT_BC4_TYPELESS, DXGI_FORMAT_BC4_UNORM },
+	/* DATA_FORMAT_BC4_SNORM_BLOCK */ { DXGI_FORMAT_BC4_TYPELESS, DXGI_FORMAT_BC4_SNORM },
+	/* DATA_FORMAT_BC5_UNORM_BLOCK */ { DXGI_FORMAT_BC5_TYPELESS, DXGI_FORMAT_BC5_UNORM },
+	/* DATA_FORMAT_BC5_SNORM_BLOCK */ { DXGI_FORMAT_BC5_TYPELESS, DXGI_FORMAT_BC5_SNORM },
+	/* DATA_FORMAT_BC6H_UFLOAT_BLOCK */ { DXGI_FORMAT_BC6H_TYPELESS, DXGI_FORMAT_BC6H_UF16 },
+	/* DATA_FORMAT_BC6H_SFLOAT_BLOCK */ { DXGI_FORMAT_BC6H_TYPELESS, DXGI_FORMAT_BC6H_SF16 },
+	/* DATA_FORMAT_BC7_UNORM_BLOCK */ { DXGI_FORMAT_BC7_TYPELESS, DXGI_FORMAT_BC7_UNORM },
+	/* DATA_FORMAT_BC7_SRGB_BLOCK */ { DXGI_FORMAT_BC7_TYPELESS, DXGI_FORMAT_BC7_UNORM_SRGB },
+	/* DATA_FORMAT_ETC2_R8G8B8_UNORM_BLOCK */ {},
+	/* DATA_FORMAT_ETC2_R8G8B8_SRGB_BLOCK */ {},
+	/* DATA_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK */ {},
+	/* DATA_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK */ {},
+	/* DATA_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK */ {},
+	/* DATA_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK */ {},
+	/* DATA_FORMAT_EAC_R11_UNORM_BLOCK */ {},
+	/* DATA_FORMAT_EAC_R11_SNORM_BLOCK */ {},
+	/* DATA_FORMAT_EAC_R11G11_UNORM_BLOCK */ {},
+	/* DATA_FORMAT_EAC_R11G11_SNORM_BLOCK */ {},
+	/* DATA_FORMAT_ASTC_4x4_UNORM_BLOCK */ {},
+	/* DATA_FORMAT_ASTC_4x4_SRGB_BLOCK */ {},
+	/* DATA_FORMAT_ASTC_5x4_UNORM_BLOCK */ {},
+	/* DATA_FORMAT_ASTC_5x4_SRGB_BLOCK */ {},
+	/* DATA_FORMAT_ASTC_5x5_UNORM_BLOCK */ {},
+	/* DATA_FORMAT_ASTC_5x5_SRGB_BLOCK */ {},
+	/* DATA_FORMAT_ASTC_6x5_UNORM_BLOCK */ {},
+	/* DATA_FORMAT_ASTC_6x5_SRGB_BLOCK */ {},
+	/* DATA_FORMAT_ASTC_6x6_UNORM_BLOCK */ {},
+	/* DATA_FORMAT_ASTC_6x6_SRGB_BLOCK */ {},
+	/* DATA_FORMAT_ASTC_8x5_UNORM_BLOCK */ {},
+	/* DATA_FORMAT_ASTC_8x5_SRGB_BLOCK */ {},
+	/* DATA_FORMAT_ASTC_8x6_UNORM_BLOCK */ {},
+	/* DATA_FORMAT_ASTC_8x6_SRGB_BLOCK */ {},
+	/* DATA_FORMAT_ASTC_8x8_UNORM_BLOCK */ {},
+	/* DATA_FORMAT_ASTC_8x8_SRGB_BLOCK */ {},
+	/* DATA_FORMAT_ASTC_10x5_UNORM_BLOCK */ {},
+	/* DATA_FORMAT_ASTC_10x5_SRGB_BLOCK */ {},
+	/* DATA_FORMAT_ASTC_10x6_UNORM_BLOCK */ {},
+	/* DATA_FORMAT_ASTC_10x6_SRGB_BLOCK */ {},
+	/* DATA_FORMAT_ASTC_10x8_UNORM_BLOCK */ {},
+	/* DATA_FORMAT_ASTC_10x8_SRGB_BLOCK */ {},
+	/* DATA_FORMAT_ASTC_10x10_UNORM_BLOCK */ {},
+	/* DATA_FORMAT_ASTC_10x10_SRGB_BLOCK */ {},
+	/* DATA_FORMAT_ASTC_12x10_UNORM_BLOCK */ {},
+	/* DATA_FORMAT_ASTC_12x10_SRGB_BLOCK */ {},
+	/* DATA_FORMAT_ASTC_12x12_UNORM_BLOCK */ {},
+	/* DATA_FORMAT_ASTC_12x12_SRGB_BLOCK */ {},
+	/* DATA_FORMAT_G8B8G8R8_422_UNORM */ {},
+	/* DATA_FORMAT_B8G8R8G8_422_UNORM */ {},
+	/* DATA_FORMAT_G8_B8_R8_3PLANE_420_UNORM */ {},
+	/* DATA_FORMAT_G8_B8R8_2PLANE_420_UNORM */ {},
+	/* DATA_FORMAT_G8_B8_R8_3PLANE_422_UNORM */ {},
+	/* DATA_FORMAT_G8_B8R8_2PLANE_422_UNORM */ {},
+	/* DATA_FORMAT_G8_B8_R8_3PLANE_444_UNORM */ {},
+	/* DATA_FORMAT_R10X6_UNORM_PACK16 */ {},
+	/* DATA_FORMAT_R10X6G10X6_UNORM_2PACK16 */ {},
+	/* DATA_FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16 */ {},
+	/* DATA_FORMAT_G10X6B10X6G10X6R10X6_422_UNORM_4PACK16 */ {},
+	/* DATA_FORMAT_B10X6G10X6R10X6G10X6_422_UNORM_4PACK16 */ {},
+	/* DATA_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16 */ {},
+	/* DATA_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16 */ {},
+	/* DATA_FORMAT_G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16 */ {},
+	/* DATA_FORMAT_G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16 */ {},
+	/* DATA_FORMAT_G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16 */ {},
+	/* DATA_FORMAT_R12X4_UNORM_PACK16 */ {},
+	/* DATA_FORMAT_R12X4G12X4_UNORM_2PACK16 */ {},
+	/* DATA_FORMAT_R12X4G12X4B12X4A12X4_UNORM_4PACK16 */ {},
+	/* DATA_FORMAT_G12X4B12X4G12X4R12X4_422_UNORM_4PACK16 */ {},
+	/* DATA_FORMAT_B12X4G12X4R12X4G12X4_422_UNORM_4PACK16 */ {},
+	/* DATA_FORMAT_G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16 */ {},
+	/* DATA_FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16 */ {},
+	/* DATA_FORMAT_G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16 */ {},
+	/* DATA_FORMAT_G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16 */ {},
+	/* DATA_FORMAT_G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16 */ {},
+	/* DATA_FORMAT_G16B16G16R16_422_UNORM */ {},
+	/* DATA_FORMAT_B16G16R16G16_422_UNORM */ {},
+	/* DATA_FORMAT_G16_B16_R16_3PLANE_420_UNORM */ {},
+	/* DATA_FORMAT_G16_B16R16_2PLANE_420_UNORM */ {},
+	/* DATA_FORMAT_G16_B16_R16_3PLANE_422_UNORM */ {},
+	/* DATA_FORMAT_G16_B16R16_2PLANE_422_UNORM */ {},
+	/* DATA_FORMAT_G16_B16_R16_3PLANE_444_UNORM */ {},
+};
+
+const char *RenderingDeviceD3D12::named_formats[RenderingDevice::DATA_FORMAT_MAX] = {
+	"R4G4_Unorm_Pack8",
+	"R4G4B4A4_Unorm_Pack16",
+	"B4G4R4A4_Unorm_Pack16",
+	"R5G6B5_Unorm_Pack16",
+	"B5G6R5_Unorm_Pack16",
+	"R5G5B5A1_Unorm_Pack16",
+	"B5G5R5A1_Unorm_Pack16",
+	"A1R5G5B5_Unorm_Pack16",
+	"R8_Unorm",
+	"R8_Snorm",
+	"R8_Uscaled",
+	"R8_Sscaled",
+	"R8_Uint",
+	"R8_Sint",
+	"R8_Srgb",
+	"R8G8_Unorm",
+	"R8G8_Snorm",
+	"R8G8_Uscaled",
+	"R8G8_Sscaled",
+	"R8G8_Uint",
+	"R8G8_Sint",
+	"R8G8_Srgb",
+	"R8G8B8_Unorm",
+	"R8G8B8_Snorm",
+	"R8G8B8_Uscaled",
+	"R8G8B8_Sscaled",
+	"R8G8B8_Uint",
+	"R8G8B8_Sint",
+	"R8G8B8_Srgb",
+	"B8G8R8_Unorm",
+	"B8G8R8_Snorm",
+	"B8G8R8_Uscaled",
+	"B8G8R8_Sscaled",
+	"B8G8R8_Uint",
+	"B8G8R8_Sint",
+	"B8G8R8_Srgb",
+	"R8G8B8A8_Unorm",
+	"R8G8B8A8_Snorm",
+	"R8G8B8A8_Uscaled",
+	"R8G8B8A8_Sscaled",
+	"R8G8B8A8_Uint",
+	"R8G8B8A8_Sint",
+	"R8G8B8A8_Srgb",
+	"B8G8R8A8_Unorm",
+	"B8G8R8A8_Snorm",
+	"B8G8R8A8_Uscaled",
+	"B8G8R8A8_Sscaled",
+	"B8G8R8A8_Uint",
+	"B8G8R8A8_Sint",
+	"B8G8R8A8_Srgb",
+	"A8B8G8R8_Unorm_Pack32",
+	"A8B8G8R8_Snorm_Pack32",
+	"A8B8G8R8_Uscaled_Pack32",
+	"A8B8G8R8_Sscaled_Pack32",
+	"A8B8G8R8_Uint_Pack32",
+	"A8B8G8R8_Sint_Pack32",
+	"A8B8G8R8_Srgb_Pack32",
+	"A2R10G10B10_Unorm_Pack32",
+	"A2R10G10B10_Snorm_Pack32",
+	"A2R10G10B10_Uscaled_Pack32",
+	"A2R10G10B10_Sscaled_Pack32",
+	"A2R10G10B10_Uint_Pack32",
+	"A2R10G10B10_Sint_Pack32",
+	"A2B10G10R10_Unorm_Pack32",
+	"A2B10G10R10_Snorm_Pack32",
+	"A2B10G10R10_Uscaled_Pack32",
+	"A2B10G10R10_Sscaled_Pack32",
+	"A2B10G10R10_Uint_Pack32",
+	"A2B10G10R10_Sint_Pack32",
+	"R16_Unorm",
+	"R16_Snorm",
+	"R16_Uscaled",
+	"R16_Sscaled",
+	"R16_Uint",
+	"R16_Sint",
+	"R16_Sfloat",
+	"R16G16_Unorm",
+	"R16G16_Snorm",
+	"R16G16_Uscaled",
+	"R16G16_Sscaled",
+	"R16G16_Uint",
+	"R16G16_Sint",
+	"R16G16_Sfloat",
+	"R16G16B16_Unorm",
+	"R16G16B16_Snorm",
+	"R16G16B16_Uscaled",
+	"R16G16B16_Sscaled",
+	"R16G16B16_Uint",
+	"R16G16B16_Sint",
+	"R16G16B16_Sfloat",
+	"R16G16B16A16_Unorm",
+	"R16G16B16A16_Snorm",
+	"R16G16B16A16_Uscaled",
+	"R16G16B16A16_Sscaled",
+	"R16G16B16A16_Uint",
+	"R16G16B16A16_Sint",
+	"R16G16B16A16_Sfloat",
+	"R32_Uint",
+	"R32_Sint",
+	"R32_Sfloat",
+	"R32G32_Uint",
+	"R32G32_Sint",
+	"R32G32_Sfloat",
+	"R32G32B32_Uint",
+	"R32G32B32_Sint",
+	"R32G32B32_Sfloat",
+	"R32G32B32A32_Uint",
+	"R32G32B32A32_Sint",
+	"R32G32B32A32_Sfloat",
+	"R64_Uint",
+	"R64_Sint",
+	"R64_Sfloat",
+	"R64G64_Uint",
+	"R64G64_Sint",
+	"R64G64_Sfloat",
+	"R64G64B64_Uint",
+	"R64G64B64_Sint",
+	"R64G64B64_Sfloat",
+	"R64G64B64A64_Uint",
+	"R64G64B64A64_Sint",
+	"R64G64B64A64_Sfloat",
+	"B10G11R11_Ufloat_Pack32",
+	"E5B9G9R9_Ufloat_Pack32",
+	"D16_Unorm",
+	"X8_D24_Unorm_Pack32",
+	"D32_Sfloat",
+	"S8_Uint",
+	"D16_Unorm_S8_Uint",
+	"D24_Unorm_S8_Uint",
+	"D32_Sfloat_S8_Uint",
+	"Bc1_Rgb_Unorm_Block",
+	"Bc1_Rgb_Srgb_Block",
+	"Bc1_Rgba_Unorm_Block",
+	"Bc1_Rgba_Srgb_Block",
+	"Bc2_Unorm_Block",
+	"Bc2_Srgb_Block",
+	"Bc3_Unorm_Block",
+	"Bc3_Srgb_Block",
+	"Bc4_Unorm_Block",
+	"Bc4_Snorm_Block",
+	"Bc5_Unorm_Block",
+	"Bc5_Snorm_Block",
+	"Bc6H_Ufloat_Block",
+	"Bc6H_Sfloat_Block",
+	"Bc7_Unorm_Block",
+	"Bc7_Srgb_Block",
+	"Etc2_R8G8B8_Unorm_Block",
+	"Etc2_R8G8B8_Srgb_Block",
+	"Etc2_R8G8B8A1_Unorm_Block",
+	"Etc2_R8G8B8A1_Srgb_Block",
+	"Etc2_R8G8B8A8_Unorm_Block",
+	"Etc2_R8G8B8A8_Srgb_Block",
+	"Eac_R11_Unorm_Block",
+	"Eac_R11_Snorm_Block",
+	"Eac_R11G11_Unorm_Block",
+	"Eac_R11G11_Snorm_Block",
+	"Astc_4X4_Unorm_Block",
+	"Astc_4X4_Srgb_Block",
+	"Astc_5X4_Unorm_Block",
+	"Astc_5X4_Srgb_Block",
+	"Astc_5X5_Unorm_Block",
+	"Astc_5X5_Srgb_Block",
+	"Astc_6X5_Unorm_Block",
+	"Astc_6X5_Srgb_Block",
+	"Astc_6X6_Unorm_Block",
+	"Astc_6X6_Srgb_Block",
+	"Astc_8X5_Unorm_Block",
+	"Astc_8X5_Srgb_Block",
+	"Astc_8X6_Unorm_Block",
+	"Astc_8X6_Srgb_Block",
+	"Astc_8X8_Unorm_Block",
+	"Astc_8X8_Srgb_Block",
+	"Astc_10X5_Unorm_Block",
+	"Astc_10X5_Srgb_Block",
+	"Astc_10X6_Unorm_Block",
+	"Astc_10X6_Srgb_Block",
+	"Astc_10X8_Unorm_Block",
+	"Astc_10X8_Srgb_Block",
+	"Astc_10X10_Unorm_Block",
+	"Astc_10X10_Srgb_Block",
+	"Astc_12X10_Unorm_Block",
+	"Astc_12X10_Srgb_Block",
+	"Astc_12X12_Unorm_Block",
+	"Astc_12X12_Srgb_Block",
+	"G8B8G8R8_422_Unorm",
+	"B8G8R8G8_422_Unorm",
+	"G8_B8_R8_3Plane_420_Unorm",
+	"G8_B8R8_2Plane_420_Unorm",
+	"G8_B8_R8_3Plane_422_Unorm",
+	"G8_B8R8_2Plane_422_Unorm",
+	"G8_B8_R8_3Plane_444_Unorm",
+	"R10X6_Unorm_Pack16",
+	"R10X6G10X6_Unorm_2Pack16",
+	"R10X6G10X6B10X6A10X6_Unorm_4Pack16",
+	"G10X6B10X6G10X6R10X6_422_Unorm_4Pack16",
+	"B10X6G10X6R10X6G10X6_422_Unorm_4Pack16",
+	"G10X6_B10X6_R10X6_3Plane_420_Unorm_3Pack16",
+	"G10X6_B10X6R10X6_2Plane_420_Unorm_3Pack16",
+	"G10X6_B10X6_R10X6_3Plane_422_Unorm_3Pack16",
+	"G10X6_B10X6R10X6_2Plane_422_Unorm_3Pack16",
+	"G10X6_B10X6_R10X6_3Plane_444_Unorm_3Pack16",
+	"R12X4_Unorm_Pack16",
+	"R12X4G12X4_Unorm_2Pack16",
+	"R12X4G12X4B12X4A12X4_Unorm_4Pack16",
+	"G12X4B12X4G12X4R12X4_422_Unorm_4Pack16",
+	"B12X4G12X4R12X4G12X4_422_Unorm_4Pack16",
+	"G12X4_B12X4_R12X4_3Plane_420_Unorm_3Pack16",
+	"G12X4_B12X4R12X4_2Plane_420_Unorm_3Pack16",
+	"G12X4_B12X4_R12X4_3Plane_422_Unorm_3Pack16",
+	"G12X4_B12X4R12X4_2Plane_422_Unorm_3Pack16",
+	"G12X4_B12X4_R12X4_3Plane_444_Unorm_3Pack16",
+	"G16B16G16R16_422_Unorm",
+	"B16G16R16G16_422_Unorm",
+	"G16_B16_R16_3Plane_420_Unorm",
+	"G16_B16R16_2Plane_420_Unorm",
+	"G16_B16_R16_3Plane_422_Unorm",
+	"G16_B16R16_2Plane_422_Unorm",
+	"G16_B16_R16_3Plane_444_Unorm",
+};
+
+int RenderingDeviceD3D12::get_format_vertex_size(DataFormat p_format) {
+	switch (p_format) {
+		case DATA_FORMAT_R8_UNORM:
+		case DATA_FORMAT_R8_SNORM:
+		case DATA_FORMAT_R8_UINT:
+		case DATA_FORMAT_R8_SINT:
+		case DATA_FORMAT_R8G8_UNORM:
+		case DATA_FORMAT_R8G8_SNORM:
+		case DATA_FORMAT_R8G8_UINT:
+		case DATA_FORMAT_R8G8_SINT:
+		case DATA_FORMAT_R8G8B8_UNORM:
+		case DATA_FORMAT_R8G8B8_SNORM:
+		case DATA_FORMAT_R8G8B8_UINT:
+		case DATA_FORMAT_R8G8B8_SINT:
+		case DATA_FORMAT_B8G8R8_UNORM:
+		case DATA_FORMAT_B8G8R8_SNORM:
+		case DATA_FORMAT_B8G8R8_UINT:
+		case DATA_FORMAT_B8G8R8_SINT:
+		case DATA_FORMAT_R8G8B8A8_UNORM:
+		case DATA_FORMAT_R8G8B8A8_SNORM:
+		case DATA_FORMAT_R8G8B8A8_UINT:
+		case DATA_FORMAT_R8G8B8A8_SINT:
+		case DATA_FORMAT_B8G8R8A8_UNORM:
+		case DATA_FORMAT_B8G8R8A8_SNORM:
+		case DATA_FORMAT_B8G8R8A8_UINT:
+		case DATA_FORMAT_B8G8R8A8_SINT:
+		case DATA_FORMAT_A2B10G10R10_UNORM_PACK32:
+			return 4;
+		case DATA_FORMAT_R16_UNORM:
+		case DATA_FORMAT_R16_SNORM:
+		case DATA_FORMAT_R16_UINT:
+		case DATA_FORMAT_R16_SINT:
+		case DATA_FORMAT_R16_SFLOAT:
+			return 4;
+		case DATA_FORMAT_R16G16_UNORM:
+		case DATA_FORMAT_R16G16_SNORM:
+		case DATA_FORMAT_R16G16_UINT:
+		case DATA_FORMAT_R16G16_SINT:
+		case DATA_FORMAT_R16G16_SFLOAT:
+			return 4;
+		case DATA_FORMAT_R16G16B16_UNORM:
+		case DATA_FORMAT_R16G16B16_SNORM:
+		case DATA_FORMAT_R16G16B16_UINT:
+		case DATA_FORMAT_R16G16B16_SINT:
+		case DATA_FORMAT_R16G16B16_SFLOAT:
+			return 8;
+		case DATA_FORMAT_R16G16B16A16_UNORM:
+		case DATA_FORMAT_R16G16B16A16_SNORM:
+		case DATA_FORMAT_R16G16B16A16_UINT:
+		case DATA_FORMAT_R16G16B16A16_SINT:
+		case DATA_FORMAT_R16G16B16A16_SFLOAT:
+			return 8;
+		case DATA_FORMAT_R32_UINT:
+		case DATA_FORMAT_R32_SINT:
+		case DATA_FORMAT_R32_SFLOAT:
+			return 4;
+		case DATA_FORMAT_R32G32_UINT:
+		case DATA_FORMAT_R32G32_SINT:
+		case DATA_FORMAT_R32G32_SFLOAT:
+			return 8;
+		case DATA_FORMAT_R32G32B32_UINT:
+		case DATA_FORMAT_R32G32B32_SINT:
+		case DATA_FORMAT_R32G32B32_SFLOAT:
+			return 12;
+		case DATA_FORMAT_R32G32B32A32_UINT:
+		case DATA_FORMAT_R32G32B32A32_SINT:
+		case DATA_FORMAT_R32G32B32A32_SFLOAT:
+			return 16;
+		case DATA_FORMAT_R64_UINT:
+		case DATA_FORMAT_R64_SINT:
+		case DATA_FORMAT_R64_SFLOAT:
+			return 8;
+		case DATA_FORMAT_R64G64_UINT:
+		case DATA_FORMAT_R64G64_SINT:
+		case DATA_FORMAT_R64G64_SFLOAT:
+			return 16;
+		case DATA_FORMAT_R64G64B64_UINT:
+		case DATA_FORMAT_R64G64B64_SINT:
+		case DATA_FORMAT_R64G64B64_SFLOAT:
+			return 24;
+		case DATA_FORMAT_R64G64B64A64_UINT:
+		case DATA_FORMAT_R64G64B64A64_SINT:
+		case DATA_FORMAT_R64G64B64A64_SFLOAT:
+			return 32;
+		default:
+			return 0;
+	}
+}
+
+uint32_t RenderingDeviceD3D12::get_image_format_pixel_size(DataFormat p_format) {
+	switch (p_format) {
+		case DATA_FORMAT_R4G4_UNORM_PACK8:
+			return 1;
+		case DATA_FORMAT_R4G4B4A4_UNORM_PACK16:
+		case DATA_FORMAT_B4G4R4A4_UNORM_PACK16:
+		case DATA_FORMAT_R5G6B5_UNORM_PACK16:
+		case DATA_FORMAT_B5G6R5_UNORM_PACK16:
+		case DATA_FORMAT_R5G5B5A1_UNORM_PACK16:
+		case DATA_FORMAT_B5G5R5A1_UNORM_PACK16:
+		case DATA_FORMAT_A1R5G5B5_UNORM_PACK16:
+			return 2;
+		case DATA_FORMAT_R8_UNORM:
+		case DATA_FORMAT_R8_SNORM:
+		case DATA_FORMAT_R8_USCALED:
+		case DATA_FORMAT_R8_SSCALED:
+		case DATA_FORMAT_R8_UINT:
+		case DATA_FORMAT_R8_SINT:
+		case DATA_FORMAT_R8_SRGB:
+			return 1;
+		case DATA_FORMAT_R8G8_UNORM:
+		case DATA_FORMAT_R8G8_SNORM:
+		case DATA_FORMAT_R8G8_USCALED:
+		case DATA_FORMAT_R8G8_SSCALED:
+		case DATA_FORMAT_R8G8_UINT:
+		case DATA_FORMAT_R8G8_SINT:
+		case DATA_FORMAT_R8G8_SRGB:
+			return 2;
+		case DATA_FORMAT_R8G8B8_UNORM:
+		case DATA_FORMAT_R8G8B8_SNORM:
+		case DATA_FORMAT_R8G8B8_USCALED:
+		case DATA_FORMAT_R8G8B8_SSCALED:
+		case DATA_FORMAT_R8G8B8_UINT:
+		case DATA_FORMAT_R8G8B8_SINT:
+		case DATA_FORMAT_R8G8B8_SRGB:
+		case DATA_FORMAT_B8G8R8_UNORM:
+		case DATA_FORMAT_B8G8R8_SNORM:
+		case DATA_FORMAT_B8G8R8_USCALED:
+		case DATA_FORMAT_B8G8R8_SSCALED:
+		case DATA_FORMAT_B8G8R8_UINT:
+		case DATA_FORMAT_B8G8R8_SINT:
+		case DATA_FORMAT_B8G8R8_SRGB:
+			return 3;
+		case DATA_FORMAT_R8G8B8A8_UNORM:
+		case DATA_FORMAT_R8G8B8A8_SNORM:
+		case DATA_FORMAT_R8G8B8A8_USCALED:
+		case DATA_FORMAT_R8G8B8A8_SSCALED:
+		case DATA_FORMAT_R8G8B8A8_UINT:
+		case DATA_FORMAT_R8G8B8A8_SINT:
+		case DATA_FORMAT_R8G8B8A8_SRGB:
+		case DATA_FORMAT_B8G8R8A8_UNORM:
+		case DATA_FORMAT_B8G8R8A8_SNORM:
+		case DATA_FORMAT_B8G8R8A8_USCALED:
+		case DATA_FORMAT_B8G8R8A8_SSCALED:
+		case DATA_FORMAT_B8G8R8A8_UINT:
+		case DATA_FORMAT_B8G8R8A8_SINT:
+		case DATA_FORMAT_B8G8R8A8_SRGB:
+			return 4;
+		case DATA_FORMAT_A8B8G8R8_UNORM_PACK32:
+		case DATA_FORMAT_A8B8G8R8_SNORM_PACK32:
+		case DATA_FORMAT_A8B8G8R8_USCALED_PACK32:
+		case DATA_FORMAT_A8B8G8R8_SSCALED_PACK32:
+		case DATA_FORMAT_A8B8G8R8_UINT_PACK32:
+		case DATA_FORMAT_A8B8G8R8_SINT_PACK32:
+		case DATA_FORMAT_A8B8G8R8_SRGB_PACK32:
+		case DATA_FORMAT_A2R10G10B10_UNORM_PACK32:
+		case DATA_FORMAT_A2R10G10B10_SNORM_PACK32:
+		case DATA_FORMAT_A2R10G10B10_USCALED_PACK32:
+		case DATA_FORMAT_A2R10G10B10_SSCALED_PACK32:
+		case DATA_FORMAT_A2R10G10B10_UINT_PACK32:
+		case DATA_FORMAT_A2R10G10B10_SINT_PACK32:
+		case DATA_FORMAT_A2B10G10R10_UNORM_PACK32:
+		case DATA_FORMAT_A2B10G10R10_SNORM_PACK32:
+		case DATA_FORMAT_A2B10G10R10_USCALED_PACK32:
+		case DATA_FORMAT_A2B10G10R10_SSCALED_PACK32:
+		case DATA_FORMAT_A2B10G10R10_UINT_PACK32:
+		case DATA_FORMAT_A2B10G10R10_SINT_PACK32:
+			return 4;
+		case DATA_FORMAT_R16_UNORM:
+		case DATA_FORMAT_R16_SNORM:
+		case DATA_FORMAT_R16_USCALED:
+		case DATA_FORMAT_R16_SSCALED:
+		case DATA_FORMAT_R16_UINT:
+		case DATA_FORMAT_R16_SINT:
+		case DATA_FORMAT_R16_SFLOAT:
+			return 2;
+		case DATA_FORMAT_R16G16_UNORM:
+		case DATA_FORMAT_R16G16_SNORM:
+		case DATA_FORMAT_R16G16_USCALED:
+		case DATA_FORMAT_R16G16_SSCALED:
+		case DATA_FORMAT_R16G16_UINT:
+		case DATA_FORMAT_R16G16_SINT:
+		case DATA_FORMAT_R16G16_SFLOAT:
+			return 4;
+		case DATA_FORMAT_R16G16B16_UNORM:
+		case DATA_FORMAT_R16G16B16_SNORM:
+		case DATA_FORMAT_R16G16B16_USCALED:
+		case DATA_FORMAT_R16G16B16_SSCALED:
+		case DATA_FORMAT_R16G16B16_UINT:
+		case DATA_FORMAT_R16G16B16_SINT:
+		case DATA_FORMAT_R16G16B16_SFLOAT:
+			return 6;
+		case DATA_FORMAT_R16G16B16A16_UNORM:
+		case DATA_FORMAT_R16G16B16A16_SNORM:
+		case DATA_FORMAT_R16G16B16A16_USCALED:
+		case DATA_FORMAT_R16G16B16A16_SSCALED:
+		case DATA_FORMAT_R16G16B16A16_UINT:
+		case DATA_FORMAT_R16G16B16A16_SINT:
+		case DATA_FORMAT_R16G16B16A16_SFLOAT:
+			return 8;
+		case DATA_FORMAT_R32_UINT:
+		case DATA_FORMAT_R32_SINT:
+		case DATA_FORMAT_R32_SFLOAT:
+			return 4;
+		case DATA_FORMAT_R32G32_UINT:
+		case DATA_FORMAT_R32G32_SINT:
+		case DATA_FORMAT_R32G32_SFLOAT:
+			return 8;
+		case DATA_FORMAT_R32G32B32_UINT:
+		case DATA_FORMAT_R32G32B32_SINT:
+		case DATA_FORMAT_R32G32B32_SFLOAT:
+			return 12;
+		case DATA_FORMAT_R32G32B32A32_UINT:
+		case DATA_FORMAT_R32G32B32A32_SINT:
+		case DATA_FORMAT_R32G32B32A32_SFLOAT:
+			return 16;
+		case DATA_FORMAT_R64_UINT:
+		case DATA_FORMAT_R64_SINT:
+		case DATA_FORMAT_R64_SFLOAT:
+			return 8;
+		case DATA_FORMAT_R64G64_UINT:
+		case DATA_FORMAT_R64G64_SINT:
+		case DATA_FORMAT_R64G64_SFLOAT:
+			return 16;
+		case DATA_FORMAT_R64G64B64_UINT:
+		case DATA_FORMAT_R64G64B64_SINT:
+		case DATA_FORMAT_R64G64B64_SFLOAT:
+			return 24;
+		case DATA_FORMAT_R64G64B64A64_UINT:
+		case DATA_FORMAT_R64G64B64A64_SINT:
+		case DATA_FORMAT_R64G64B64A64_SFLOAT:
+			return 32;
+		case DATA_FORMAT_B10G11R11_UFLOAT_PACK32:
+		case DATA_FORMAT_E5B9G9R9_UFLOAT_PACK32:
+			return 4;
+		case DATA_FORMAT_D16_UNORM:
+			return 2;
+		case DATA_FORMAT_X8_D24_UNORM_PACK32:
+			return 4;
+		case DATA_FORMAT_D32_SFLOAT:
+			return 4;
+		case DATA_FORMAT_S8_UINT:
+			return 1;
+		case DATA_FORMAT_D16_UNORM_S8_UINT:
+			return 4;
+		case DATA_FORMAT_D24_UNORM_S8_UINT:
+			return 4;
+		case DATA_FORMAT_D32_SFLOAT_S8_UINT:
+			return 5; // ?
+		case DATA_FORMAT_BC1_RGB_UNORM_BLOCK:
+		case DATA_FORMAT_BC1_RGB_SRGB_BLOCK:
+		case DATA_FORMAT_BC1_RGBA_UNORM_BLOCK:
+		case DATA_FORMAT_BC1_RGBA_SRGB_BLOCK:
+		case DATA_FORMAT_BC2_UNORM_BLOCK:
+		case DATA_FORMAT_BC2_SRGB_BLOCK:
+		case DATA_FORMAT_BC3_UNORM_BLOCK:
+		case DATA_FORMAT_BC3_SRGB_BLOCK:
+		case DATA_FORMAT_BC4_UNORM_BLOCK:
+		case DATA_FORMAT_BC4_SNORM_BLOCK:
+		case DATA_FORMAT_BC5_UNORM_BLOCK:
+		case DATA_FORMAT_BC5_SNORM_BLOCK:
+		case DATA_FORMAT_BC6H_UFLOAT_BLOCK:
+		case DATA_FORMAT_BC6H_SFLOAT_BLOCK:
+		case DATA_FORMAT_BC7_UNORM_BLOCK:
+		case DATA_FORMAT_BC7_SRGB_BLOCK:
+			return 1;
+		case DATA_FORMAT_ETC2_R8G8B8_UNORM_BLOCK:
+		case DATA_FORMAT_ETC2_R8G8B8_SRGB_BLOCK:
+		case DATA_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK:
+		case DATA_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK:
+		case DATA_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK:
+		case DATA_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK:
+			return 1;
+		case DATA_FORMAT_EAC_R11_UNORM_BLOCK:
+		case DATA_FORMAT_EAC_R11_SNORM_BLOCK:
+		case DATA_FORMAT_EAC_R11G11_UNORM_BLOCK:
+		case DATA_FORMAT_EAC_R11G11_SNORM_BLOCK:
+			return 1;
+		case DATA_FORMAT_ASTC_4x4_UNORM_BLOCK:
+		case DATA_FORMAT_ASTC_4x4_SRGB_BLOCK:
+		case DATA_FORMAT_ASTC_5x4_UNORM_BLOCK:
+		case DATA_FORMAT_ASTC_5x4_SRGB_BLOCK:
+		case DATA_FORMAT_ASTC_5x5_UNORM_BLOCK:
+		case DATA_FORMAT_ASTC_5x5_SRGB_BLOCK:
+		case DATA_FORMAT_ASTC_6x5_UNORM_BLOCK:
+		case DATA_FORMAT_ASTC_6x5_SRGB_BLOCK:
+		case DATA_FORMAT_ASTC_6x6_UNORM_BLOCK:
+		case DATA_FORMAT_ASTC_6x6_SRGB_BLOCK:
+		case DATA_FORMAT_ASTC_8x5_UNORM_BLOCK:
+		case DATA_FORMAT_ASTC_8x5_SRGB_BLOCK:
+		case DATA_FORMAT_ASTC_8x6_UNORM_BLOCK:
+		case DATA_FORMAT_ASTC_8x6_SRGB_BLOCK:
+		case DATA_FORMAT_ASTC_8x8_UNORM_BLOCK:
+		case DATA_FORMAT_ASTC_8x8_SRGB_BLOCK:
+		case DATA_FORMAT_ASTC_10x5_UNORM_BLOCK:
+		case DATA_FORMAT_ASTC_10x5_SRGB_BLOCK:
+		case DATA_FORMAT_ASTC_10x6_UNORM_BLOCK:
+		case DATA_FORMAT_ASTC_10x6_SRGB_BLOCK:
+		case DATA_FORMAT_ASTC_10x8_UNORM_BLOCK:
+		case DATA_FORMAT_ASTC_10x8_SRGB_BLOCK:
+		case DATA_FORMAT_ASTC_10x10_UNORM_BLOCK:
+		case DATA_FORMAT_ASTC_10x10_SRGB_BLOCK:
+		case DATA_FORMAT_ASTC_12x10_UNORM_BLOCK:
+		case DATA_FORMAT_ASTC_12x10_SRGB_BLOCK:
+		case DATA_FORMAT_ASTC_12x12_UNORM_BLOCK:
+		case DATA_FORMAT_ASTC_12x12_SRGB_BLOCK:
+			return 1;
+		case DATA_FORMAT_G8B8G8R8_422_UNORM:
+		case DATA_FORMAT_B8G8R8G8_422_UNORM:
+			return 4;
+		case DATA_FORMAT_G8_B8_R8_3PLANE_420_UNORM:
+		case DATA_FORMAT_G8_B8R8_2PLANE_420_UNORM:
+		case DATA_FORMAT_G8_B8_R8_3PLANE_422_UNORM:
+		case DATA_FORMAT_G8_B8R8_2PLANE_422_UNORM:
+		case DATA_FORMAT_G8_B8_R8_3PLANE_444_UNORM:
+			return 4;
+		case DATA_FORMAT_R10X6_UNORM_PACK16:
+		case DATA_FORMAT_R10X6G10X6_UNORM_2PACK16:
+		case DATA_FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16:
+		case DATA_FORMAT_G10X6B10X6G10X6R10X6_422_UNORM_4PACK16:
+		case DATA_FORMAT_B10X6G10X6R10X6G10X6_422_UNORM_4PACK16:
+		case DATA_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16:
+		case DATA_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16:
+		case DATA_FORMAT_G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16:
+		case DATA_FORMAT_G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16:
+		case DATA_FORMAT_G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16:
+		case DATA_FORMAT_R12X4_UNORM_PACK16:
+		case DATA_FORMAT_R12X4G12X4_UNORM_2PACK16:
+		case DATA_FORMAT_R12X4G12X4B12X4A12X4_UNORM_4PACK16:
+		case DATA_FORMAT_G12X4B12X4G12X4R12X4_422_UNORM_4PACK16:
+		case DATA_FORMAT_B12X4G12X4R12X4G12X4_422_UNORM_4PACK16:
+		case DATA_FORMAT_G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16:
+		case DATA_FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16:
+		case DATA_FORMAT_G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16:
+		case DATA_FORMAT_G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16:
+		case DATA_FORMAT_G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16:
+			return 2;
+		case DATA_FORMAT_G16B16G16R16_422_UNORM:
+		case DATA_FORMAT_B16G16R16G16_422_UNORM:
+		case DATA_FORMAT_G16_B16_R16_3PLANE_420_UNORM:
+		case DATA_FORMAT_G16_B16R16_2PLANE_420_UNORM:
+		case DATA_FORMAT_G16_B16_R16_3PLANE_422_UNORM:
+		case DATA_FORMAT_G16_B16R16_2PLANE_422_UNORM:
+		case DATA_FORMAT_G16_B16_R16_3PLANE_444_UNORM:
+			return 8;
+		default: {
+			ERR_PRINT("Format not handled, bug");
+		}
+	}
+
+	return 1;
+}
+
+// https://www.khronos.org/registry/DataFormat/specs/1.1/dataformat.1.1.pdf
+
+void RenderingDeviceD3D12::get_compressed_image_format_block_dimensions(DataFormat p_format, uint32_t &r_w, uint32_t &r_h) {
+	switch (p_format) {
+		case DATA_FORMAT_BC1_RGB_UNORM_BLOCK:
+		case DATA_FORMAT_BC1_RGB_SRGB_BLOCK:
+		case DATA_FORMAT_BC1_RGBA_UNORM_BLOCK:
+		case DATA_FORMAT_BC1_RGBA_SRGB_BLOCK:
+		case DATA_FORMAT_BC2_UNORM_BLOCK:
+		case DATA_FORMAT_BC2_SRGB_BLOCK:
+		case DATA_FORMAT_BC3_UNORM_BLOCK:
+		case DATA_FORMAT_BC3_SRGB_BLOCK:
+		case DATA_FORMAT_BC4_UNORM_BLOCK:
+		case DATA_FORMAT_BC4_SNORM_BLOCK:
+		case DATA_FORMAT_BC5_UNORM_BLOCK:
+		case DATA_FORMAT_BC5_SNORM_BLOCK:
+		case DATA_FORMAT_BC6H_UFLOAT_BLOCK:
+		case DATA_FORMAT_BC6H_SFLOAT_BLOCK:
+		case DATA_FORMAT_BC7_UNORM_BLOCK:
+		case DATA_FORMAT_BC7_SRGB_BLOCK:
+		case DATA_FORMAT_ETC2_R8G8B8_UNORM_BLOCK:
+		case DATA_FORMAT_ETC2_R8G8B8_SRGB_BLOCK:
+		case DATA_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK:
+		case DATA_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK:
+		case DATA_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK:
+		case DATA_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK:
+		case DATA_FORMAT_EAC_R11_UNORM_BLOCK:
+		case DATA_FORMAT_EAC_R11_SNORM_BLOCK:
+		case DATA_FORMAT_EAC_R11G11_UNORM_BLOCK:
+		case DATA_FORMAT_EAC_R11G11_SNORM_BLOCK:
+		case DATA_FORMAT_ASTC_4x4_UNORM_BLOCK: // Again, not sure about astc.
+		case DATA_FORMAT_ASTC_4x4_SRGB_BLOCK:
+		case DATA_FORMAT_ASTC_5x4_UNORM_BLOCK:
+		case DATA_FORMAT_ASTC_5x4_SRGB_BLOCK:
+		case DATA_FORMAT_ASTC_5x5_UNORM_BLOCK:
+		case DATA_FORMAT_ASTC_5x5_SRGB_BLOCK:
+		case DATA_FORMAT_ASTC_6x5_UNORM_BLOCK:
+		case DATA_FORMAT_ASTC_6x5_SRGB_BLOCK:
+		case DATA_FORMAT_ASTC_6x6_UNORM_BLOCK:
+		case DATA_FORMAT_ASTC_6x6_SRGB_BLOCK:
+		case DATA_FORMAT_ASTC_8x5_UNORM_BLOCK:
+		case DATA_FORMAT_ASTC_8x5_SRGB_BLOCK:
+		case DATA_FORMAT_ASTC_8x6_UNORM_BLOCK:
+		case DATA_FORMAT_ASTC_8x6_SRGB_BLOCK:
+		case DATA_FORMAT_ASTC_8x8_UNORM_BLOCK:
+		case DATA_FORMAT_ASTC_8x8_SRGB_BLOCK:
+		case DATA_FORMAT_ASTC_10x5_UNORM_BLOCK:
+		case DATA_FORMAT_ASTC_10x5_SRGB_BLOCK:
+		case DATA_FORMAT_ASTC_10x6_UNORM_BLOCK:
+		case DATA_FORMAT_ASTC_10x6_SRGB_BLOCK:
+		case DATA_FORMAT_ASTC_10x8_UNORM_BLOCK:
+		case DATA_FORMAT_ASTC_10x8_SRGB_BLOCK:
+		case DATA_FORMAT_ASTC_10x10_UNORM_BLOCK:
+		case DATA_FORMAT_ASTC_10x10_SRGB_BLOCK:
+		case DATA_FORMAT_ASTC_12x10_UNORM_BLOCK:
+		case DATA_FORMAT_ASTC_12x10_SRGB_BLOCK:
+		case DATA_FORMAT_ASTC_12x12_UNORM_BLOCK:
+		case DATA_FORMAT_ASTC_12x12_SRGB_BLOCK:
+			r_w = 4;
+			r_h = 4;
+			return;
+		default: {
+			r_w = 1;
+			r_h = 1;
+		}
+	}
+}
+
+uint32_t RenderingDeviceD3D12::get_compressed_image_format_block_byte_size(DataFormat p_format) {
+	switch (p_format) {
+		case DATA_FORMAT_BC1_RGB_UNORM_BLOCK:
+		case DATA_FORMAT_BC1_RGB_SRGB_BLOCK:
+		case DATA_FORMAT_BC1_RGBA_UNORM_BLOCK:
+		case DATA_FORMAT_BC1_RGBA_SRGB_BLOCK:
+			return 8;
+		case DATA_FORMAT_BC2_UNORM_BLOCK:
+		case DATA_FORMAT_BC2_SRGB_BLOCK:
+			return 16;
+		case DATA_FORMAT_BC3_UNORM_BLOCK:
+		case DATA_FORMAT_BC3_SRGB_BLOCK:
+			return 16;
+		case DATA_FORMAT_BC4_UNORM_BLOCK:
+		case DATA_FORMAT_BC4_SNORM_BLOCK:
+			return 8;
+		case DATA_FORMAT_BC5_UNORM_BLOCK:
+		case DATA_FORMAT_BC5_SNORM_BLOCK:
+			return 16;
+		case DATA_FORMAT_BC6H_UFLOAT_BLOCK:
+		case DATA_FORMAT_BC6H_SFLOAT_BLOCK:
+			return 16;
+		case DATA_FORMAT_BC7_UNORM_BLOCK:
+		case DATA_FORMAT_BC7_SRGB_BLOCK:
+			return 16;
+		case DATA_FORMAT_ETC2_R8G8B8_UNORM_BLOCK:
+		case DATA_FORMAT_ETC2_R8G8B8_SRGB_BLOCK:
+			return 8;
+		case DATA_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK:
+		case DATA_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK:
+			return 8;
+		case DATA_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK:
+		case DATA_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK:
+			return 16;
+		case DATA_FORMAT_EAC_R11_UNORM_BLOCK:
+		case DATA_FORMAT_EAC_R11_SNORM_BLOCK:
+			return 8;
+		case DATA_FORMAT_EAC_R11G11_UNORM_BLOCK:
+		case DATA_FORMAT_EAC_R11G11_SNORM_BLOCK:
+			return 16;
+		case DATA_FORMAT_ASTC_4x4_UNORM_BLOCK: // Again, not sure about astc.
+		case DATA_FORMAT_ASTC_4x4_SRGB_BLOCK:
+		case DATA_FORMAT_ASTC_5x4_UNORM_BLOCK:
+		case DATA_FORMAT_ASTC_5x4_SRGB_BLOCK:
+		case DATA_FORMAT_ASTC_5x5_UNORM_BLOCK:
+		case DATA_FORMAT_ASTC_5x5_SRGB_BLOCK:
+		case DATA_FORMAT_ASTC_6x5_UNORM_BLOCK:
+		case DATA_FORMAT_ASTC_6x5_SRGB_BLOCK:
+		case DATA_FORMAT_ASTC_6x6_UNORM_BLOCK:
+		case DATA_FORMAT_ASTC_6x6_SRGB_BLOCK:
+		case DATA_FORMAT_ASTC_8x5_UNORM_BLOCK:
+		case DATA_FORMAT_ASTC_8x5_SRGB_BLOCK:
+		case DATA_FORMAT_ASTC_8x6_UNORM_BLOCK:
+		case DATA_FORMAT_ASTC_8x6_SRGB_BLOCK:
+		case DATA_FORMAT_ASTC_8x8_UNORM_BLOCK:
+		case DATA_FORMAT_ASTC_8x8_SRGB_BLOCK:
+		case DATA_FORMAT_ASTC_10x5_UNORM_BLOCK:
+		case DATA_FORMAT_ASTC_10x5_SRGB_BLOCK:
+		case DATA_FORMAT_ASTC_10x6_UNORM_BLOCK:
+		case DATA_FORMAT_ASTC_10x6_SRGB_BLOCK:
+		case DATA_FORMAT_ASTC_10x8_UNORM_BLOCK:
+		case DATA_FORMAT_ASTC_10x8_SRGB_BLOCK:
+		case DATA_FORMAT_ASTC_10x10_UNORM_BLOCK:
+		case DATA_FORMAT_ASTC_10x10_SRGB_BLOCK:
+		case DATA_FORMAT_ASTC_12x10_UNORM_BLOCK:
+		case DATA_FORMAT_ASTC_12x10_SRGB_BLOCK:
+		case DATA_FORMAT_ASTC_12x12_UNORM_BLOCK:
+		case DATA_FORMAT_ASTC_12x12_SRGB_BLOCK:
+			return 8; // Wrong.
+		default: {
+		}
+	}
+	return 1;
+}
+
+uint32_t RenderingDeviceD3D12::get_compressed_image_format_pixel_rshift(DataFormat p_format) {
+	switch (p_format) {
+		case DATA_FORMAT_BC1_RGB_UNORM_BLOCK: // These formats are half byte size, so rshift is 1.
+		case DATA_FORMAT_BC1_RGB_SRGB_BLOCK:
+		case DATA_FORMAT_BC1_RGBA_UNORM_BLOCK:
+		case DATA_FORMAT_BC1_RGBA_SRGB_BLOCK:
+		case DATA_FORMAT_BC4_UNORM_BLOCK:
+		case DATA_FORMAT_BC4_SNORM_BLOCK:
+		case DATA_FORMAT_ETC2_R8G8B8_UNORM_BLOCK:
+		case DATA_FORMAT_ETC2_R8G8B8_SRGB_BLOCK:
+		case DATA_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK:
+		case DATA_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK:
+		case DATA_FORMAT_EAC_R11_UNORM_BLOCK:
+		case DATA_FORMAT_EAC_R11_SNORM_BLOCK:
+			return 1;
+		default: {
+		}
+	}
+
+	return 0;
+}
+
+uint32_t RenderingDeviceD3D12::get_image_format_plane_count(DataFormat p_format) {
+	uint32_t planes = 1;
+	switch (p_format) {
+		case DATA_FORMAT_D16_UNORM_S8_UINT:
+		case DATA_FORMAT_D24_UNORM_S8_UINT:
+		case DATA_FORMAT_D32_SFLOAT_S8_UINT: {
+			planes = 2;
+		}
+		default: {
+		}
+	}
+	DEV_ASSERT(planes <= MAX_IMAGE_FORMAT_PLANES);
+	return planes;
+}
+
+uint32_t RenderingDeviceD3D12::get_image_format_required_size(DataFormat p_format, uint32_t p_width, uint32_t p_height, uint32_t p_depth, uint32_t p_mipmaps, uint32_t *r_blockw, uint32_t *r_blockh, uint32_t *r_depth) {
+	ERR_FAIL_COND_V(p_mipmaps == 0, 0);
+	uint32_t w = p_width;
+	uint32_t h = p_height;
+	uint32_t d = p_depth;
+
+	uint32_t size = 0;
+
+	uint32_t pixel_size = get_image_format_pixel_size(p_format);
+	uint32_t pixel_rshift = get_compressed_image_format_pixel_rshift(p_format);
+	uint32_t blockw, blockh;
+	get_compressed_image_format_block_dimensions(p_format, blockw, blockh);
+
+	for (uint32_t i = 0; i < p_mipmaps; i++) {
+		uint32_t bw = w % blockw != 0 ? w + (blockw - w % blockw) : w;
+		uint32_t bh = h % blockh != 0 ? h + (blockh - h % blockh) : h;
+
+		uint32_t s = bw * bh;
+
+		s *= pixel_size;
+		s >>= pixel_rshift;
+		size += s * d;
+		if (r_blockw) {
+			*r_blockw = bw;
+		}
+		if (r_blockh) {
+			*r_blockh = bh;
+		}
+		if (r_depth) {
+			*r_depth = d;
+		}
+		w = MAX(blockw, w >> 1);
+		h = MAX(blockh, h >> 1);
+		d = MAX(1u, d >> 1);
+	}
+
+	return size;
+}
+
+uint32_t RenderingDeviceD3D12::get_image_required_mipmaps(uint32_t p_width, uint32_t p_height, uint32_t p_depth) {
+	// Formats and block size don't really matter here since they can all go down to 1px (even if block is larger).
+	uint32_t w = p_width;
+	uint32_t h = p_height;
+	uint32_t d = p_depth;
+
+	uint32_t mipmaps = 1;
+
+	while (true) {
+		if (w == 1 && h == 1 && d == 1) {
+			break;
+		}
+
+		w = MAX(1u, w >> 1);
+		h = MAX(1u, h >> 1);
+		d = MAX(1u, d >> 1);
+
+		mipmaps++;
+	}
+
+	return mipmaps;
+}
+
+///////////////////////
+
+const D3D12_COMPARISON_FUNC RenderingDeviceD3D12::compare_operators[RenderingDevice::COMPARE_OP_MAX] = {
+	D3D12_COMPARISON_FUNC_NEVER,
+	D3D12_COMPARISON_FUNC_LESS,
+	D3D12_COMPARISON_FUNC_EQUAL,
+	D3D12_COMPARISON_FUNC_LESS_EQUAL,
+	D3D12_COMPARISON_FUNC_GREATER,
+	D3D12_COMPARISON_FUNC_NOT_EQUAL,
+	D3D12_COMPARISON_FUNC_GREATER_EQUAL,
+	D3D12_COMPARISON_FUNC_ALWAYS,
+};
+
+const D3D12_STENCIL_OP RenderingDeviceD3D12::stencil_operations[RenderingDevice::STENCIL_OP_MAX] = {
+	D3D12_STENCIL_OP_KEEP,
+	D3D12_STENCIL_OP_ZERO,
+	D3D12_STENCIL_OP_REPLACE,
+	D3D12_STENCIL_OP_INCR_SAT,
+	D3D12_STENCIL_OP_DECR_SAT,
+	D3D12_STENCIL_OP_INVERT,
+	D3D12_STENCIL_OP_INCR,
+	D3D12_STENCIL_OP_DECR,
+};
+
+const UINT RenderingDeviceD3D12::rasterization_sample_count[RenderingDevice::TEXTURE_SAMPLES_MAX] = {
+	1,
+	2,
+	4,
+	8,
+	16,
+	32,
+	64,
+};
+
+const D3D12_LOGIC_OP RenderingDeviceD3D12::logic_operations[RenderingDevice::LOGIC_OP_MAX] = {
+	D3D12_LOGIC_OP_CLEAR,
+	D3D12_LOGIC_OP_AND,
+	D3D12_LOGIC_OP_AND_REVERSE,
+	D3D12_LOGIC_OP_COPY,
+	D3D12_LOGIC_OP_AND_INVERTED,
+	D3D12_LOGIC_OP_NOOP,
+	D3D12_LOGIC_OP_XOR,
+	D3D12_LOGIC_OP_OR,
+	D3D12_LOGIC_OP_NOR,
+	D3D12_LOGIC_OP_EQUIV,
+	D3D12_LOGIC_OP_INVERT,
+	D3D12_LOGIC_OP_OR_REVERSE,
+	D3D12_LOGIC_OP_COPY_INVERTED,
+	D3D12_LOGIC_OP_OR_INVERTED,
+	D3D12_LOGIC_OP_NAND,
+	D3D12_LOGIC_OP_SET,
+};
+
+const D3D12_BLEND RenderingDeviceD3D12::blend_factors[RenderingDevice::BLEND_FACTOR_MAX] = {
+	D3D12_BLEND_ZERO,
+	D3D12_BLEND_ONE,
+	D3D12_BLEND_SRC_COLOR,
+	D3D12_BLEND_INV_SRC_COLOR,
+	D3D12_BLEND_DEST_COLOR,
+	D3D12_BLEND_INV_DEST_COLOR,
+	D3D12_BLEND_SRC_ALPHA,
+	D3D12_BLEND_INV_SRC_ALPHA,
+	D3D12_BLEND_DEST_ALPHA,
+	D3D12_BLEND_INV_DEST_ALPHA,
+	D3D12_BLEND_BLEND_FACTOR,
+	D3D12_BLEND_INV_BLEND_FACTOR,
+	D3D12_BLEND_BLEND_FACTOR,
+	D3D12_BLEND_INV_BLEND_FACTOR,
+	D3D12_BLEND_SRC_ALPHA_SAT,
+	D3D12_BLEND_SRC1_COLOR,
+	D3D12_BLEND_INV_SRC1_COLOR,
+	D3D12_BLEND_SRC1_ALPHA,
+	D3D12_BLEND_INV_SRC1_ALPHA,
+};
+
+const D3D12_BLEND_OP RenderingDeviceD3D12::blend_operations[RenderingDevice::BLEND_OP_MAX] = {
+	D3D12_BLEND_OP_ADD,
+	D3D12_BLEND_OP_SUBTRACT,
+	D3D12_BLEND_OP_REV_SUBTRACT,
+	D3D12_BLEND_OP_MIN,
+	D3D12_BLEND_OP_MAX,
+};
+
+const D3D12_TEXTURE_ADDRESS_MODE RenderingDeviceD3D12::address_modes[RenderingDevice::SAMPLER_REPEAT_MODE_MAX] = {
+	D3D12_TEXTURE_ADDRESS_MODE_WRAP,
+	D3D12_TEXTURE_ADDRESS_MODE_MIRROR,
+	D3D12_TEXTURE_ADDRESS_MODE_CLAMP,
+	D3D12_TEXTURE_ADDRESS_MODE_BORDER,
+	D3D12_TEXTURE_ADDRESS_MODE_MIRROR_ONCE,
+};
+
+const FLOAT RenderingDeviceD3D12::sampler_border_colors[RenderingDevice::SAMPLER_BORDER_COLOR_MAX][4] = {
+	{ 0, 0, 0, 0 },
+	{ 0, 0, 0, 0 },
+	{ 0, 0, 0, 1 },
+	{ 0, 0, 0, 1 },
+	{ 1, 1, 1, 1 },
+	{ 1, 1, 1, 1 },
+};
+
+const D3D12_RESOURCE_DIMENSION RenderingDeviceD3D12::d3d12_texture_dimension[RenderingDevice::TEXTURE_TYPE_MAX] = {
+	D3D12_RESOURCE_DIMENSION_TEXTURE1D,
+	D3D12_RESOURCE_DIMENSION_TEXTURE2D,
+	D3D12_RESOURCE_DIMENSION_TEXTURE3D,
+	D3D12_RESOURCE_DIMENSION_TEXTURE2D,
+	D3D12_RESOURCE_DIMENSION_TEXTURE1D,
+	D3D12_RESOURCE_DIMENSION_TEXTURE2D,
+	D3D12_RESOURCE_DIMENSION_TEXTURE2D,
+};
+
+/******************/
+/**** RESOURCE ****/
+/******************/
+
+static const D3D12_RESOURCE_STATES RESOURCE_READ_STATES =
+		D3D12_RESOURCE_STATE_VERTEX_AND_CONSTANT_BUFFER |
+		D3D12_RESOURCE_STATE_INDEX_BUFFER |
+		D3D12_RESOURCE_STATE_DEPTH_READ |
+		D3D12_RESOURCE_STATE_NON_PIXEL_SHADER_RESOURCE |
+		D3D12_RESOURCE_STATE_PIXEL_SHADER_RESOURCE |
+		D3D12_RESOURCE_STATE_INDIRECT_ARGUMENT |
+		D3D12_RESOURCE_STATE_COPY_SOURCE |
+		D3D12_RESOURCE_STATE_RESOLVE_SOURCE |
+		D3D12_RESOURCE_STATE_SHADING_RATE_SOURCE;
+
+static const D3D12_RESOURCE_STATES RESOURCE_WRITE_STATES =
+		D3D12_RESOURCE_STATE_RENDER_TARGET |
+		D3D12_RESOURCE_STATE_DEPTH_WRITE |
+		D3D12_RESOURCE_STATE_COPY_DEST |
+		D3D12_RESOURCE_STATE_RESOLVE_DEST;
+
+static const D3D12_RESOURCE_STATES RESOURCE_RW_STATES =
+		D3D12_RESOURCE_STATE_UNORDERED_ACCESS;
+
+void RenderingDeviceD3D12::ResourceState::extend(D3D12_RESOURCE_STATES p_states_to_add) {
+	states |= p_states_to_add;
+
+#ifdef DEV_ENABLED
+	if ((states & RESOURCE_RW_STATES)) {
+		if ((states & RESOURCE_READ_STATES)) {
+			// Thanks to [[SRV_UAV_AMBIGUITY]], this is not necessarily an error.
+		}
+		if ((states & RESOURCE_WRITE_STATES)) {
+			ERR_PRINT("Error in new state mask: has R/W state plus some W/O state(s).");
+		}
+	} else {
+		if ((states & RESOURCE_WRITE_STATES)) {
+			if ((states & RESOURCE_READ_STATES)) {
+				ERR_PRINT("Error in new state mask: mixes R/O and W/O states.");
+			} else {
+				uint32_t num_w_states = 0;
+				for (uint32_t i = 0; i < sizeof(D3D12_RESOURCE_STATES) * 8; i++) {
+					num_w_states += ((states & RESOURCE_WRITE_STATES) & (1 << i)) ? 1 : 0;
+				}
+				ERR_PRINT("Error in new state mask: has multiple W/O states.");
+			}
+		}
+	}
+#endif
+}
+
+void RenderingDeviceD3D12::_resource_transition_batch(Resource *p_resource, uint32_t p_subresource, uint32_t p_num_planes, D3D12_RESOURCE_STATES p_new_state, ID3D12Resource *p_resource_override) {
+	DEV_ASSERT(p_subresource != UINT32_MAX); // We don't support an "all-resources" command here.
+	DEV_ASSERT(p_new_state != D3D12_RESOURCE_STATE_COMMON); // No need to support this for now.
+
+#ifdef DEBUG_COUNT_BARRIERS
+	uint64_t start = OS::get_singleton()->get_ticks_usec();
+#endif
+
+	Resource::States *res_states = p_resource->get_states_ptr();
+	D3D12_RESOURCE_STATES *curr_state = &res_states->subresource_states[p_subresource];
+
+	ID3D12Resource *res_to_transition = p_resource_override ? p_resource_override : p_resource->resource;
+
+	bool redundant_transition = ((*curr_state) & p_new_state) == p_new_state;
+	if (redundant_transition) {
+		bool just_written = *curr_state == D3D12_RESOURCE_STATE_UNORDERED_ACCESS;
+		bool needs_uav_barrier = just_written && res_states->last_batch_with_uav_barrier != res_barriers_batch;
+		if (needs_uav_barrier) {
+			if (res_barriers.size() < res_barriers_count + 1) {
+				res_barriers.resize(res_barriers_count + 1);
+			}
+			res_barriers[res_barriers_count] = CD3DX12_RESOURCE_BARRIER::UAV(res_to_transition);
+			res_barriers_count++;
+			res_states->last_batch_with_uav_barrier = res_barriers_batch;
+		}
+	} else {
+		uint64_t subres_mask_piece = ((uint64_t)1 << (p_subresource & 0b111111));
+		uint8_t subres_qword = p_subresource >> 6;
+
+		if (res_barriers_requests.has(res_states)) {
+			BarrierRequest &br = res_barriers_requests.get(res_states);
+			DEV_ASSERT(br.dx_resource == res_to_transition);
+			DEV_ASSERT(br.subres_mask_qwords == ALIGN(res_states->subresource_states.size(), 64) / 64);
+			DEV_ASSERT(br.planes == p_num_planes);
+
+			// First, find if the subresource already has a barrier scheduled.
+			uint8_t curr_group_idx = 0;
+			bool same_transition_scheduled = false;
+			for (curr_group_idx = 0; curr_group_idx < br.groups_count; curr_group_idx++) {
+				if (unlikely(br.groups[curr_group_idx].state.get_state_mask() == BarrierRequest::DELETED_GROUP)) {
+					continue;
+				}
+				if ((br.groups[curr_group_idx].subres_mask[subres_qword] & subres_mask_piece)) {
+					uint32_t state_mask = br.groups[curr_group_idx].state.get_state_mask();
+					same_transition_scheduled = (state_mask & (uint32_t)p_new_state) == (uint32_t)p_new_state;
+					break;
+				}
+			}
+			if (!same_transition_scheduled) {
+				bool subres_already_there = curr_group_idx != br.groups_count;
+				ResourceState final_state;
+				if (subres_already_there) {
+					final_state = br.groups[curr_group_idx].state;
+					final_state.extend(p_new_state);
+					bool subres_alone = true;
+					for (uint8_t i = 0; i < br.subres_mask_qwords; i++) {
+						if (i == subres_qword) {
+							if (br.groups[curr_group_idx].subres_mask[i] != subres_mask_piece) {
+								subres_alone = false;
+								break;
+							}
+						} else {
+							if (br.groups[curr_group_idx].subres_mask[i] != 0) {
+								subres_alone = false;
+								break;
+							}
+						}
+					}
+					bool relocated = false;
+					if (subres_alone) {
+						// Subresource is there by itself.
+						for (uint8_t i = 0; i < br.groups_count; i++) {
+							if (unlikely(i == curr_group_idx)) {
+								continue;
+							}
+							if (unlikely(br.groups[i].state.get_state_mask() == BarrierRequest::DELETED_GROUP)) {
+								continue;
+							}
+							// There's another group with the final state; relocate to it.
+							if (br.groups[i].state.get_state_mask() == final_state.get_state_mask()) {
+								br.groups[curr_group_idx].subres_mask[subres_qword] &= ~subres_mask_piece;
+								relocated = true;
+								break;
+							}
+						}
+						if (relocated) {
+							// Let's delete the group where it used to be by itself.
+							if (curr_group_idx == br.groups_count - 1) {
+								br.groups_count--;
+							} else {
+								br.groups[curr_group_idx].state = ResourceState(BarrierRequest::DELETED_GROUP);
+							}
+						} else {
+							// Its current group, where it's alone, can extend its state.
+							br.groups[curr_group_idx].state = final_state;
+						}
+					} else {
+						// Already there, but not by itself and the state mask is different, so it now belongs to a different group.
+						br.groups[curr_group_idx].subres_mask[subres_qword] &= ~subres_mask_piece;
+						subres_already_there = false;
+					}
+				} else {
+					final_state = p_new_state;
+				}
+				if (!subres_already_there) {
+					// See if it fits exactly the state of some of the groups to fit it there.
+					for (uint8_t i = 0; i < br.groups_count; i++) {
+						if (unlikely(i == curr_group_idx)) {
+							continue;
+						}
+						if (unlikely(br.groups[i].state.get_state_mask() == BarrierRequest::DELETED_GROUP)) {
+							continue;
+						}
+						if (br.groups[i].state.get_state_mask() == final_state.get_state_mask()) {
+							br.groups[i].subres_mask[subres_qword] |= subres_mask_piece;
+							subres_already_there = true;
+							break;
+						}
+					}
+					if (!subres_already_there) {
+						// Add a new group to accommodate this subresource.
+						uint8_t group_to_fill = 0;
+						if (br.groups_count < BarrierRequest::MAX_GROUPS) {
+							// There are still free groups.
+							group_to_fill = br.groups_count;
+							br.groups_count++;
+						} else {
+							// Let's try to take over a deleted one.
+							for (; group_to_fill < br.groups_count; group_to_fill++) {
+								if (unlikely(br.groups[group_to_fill].state.get_state_mask() == BarrierRequest::DELETED_GROUP)) {
+									break;
+								}
+							}
+							CRASH_COND(group_to_fill == br.groups_count);
+						}
+
+						br.groups[group_to_fill].state = final_state;
+						for (uint8_t i = 0; i < br.subres_mask_qwords; i++) {
+							if (unlikely(i == subres_qword)) {
+								br.groups[group_to_fill].subres_mask[i] = subres_mask_piece;
+							} else {
+								br.groups[group_to_fill].subres_mask[i] = 0;
+							}
+						}
+					}
+				}
+			}
+		} else {
+			BarrierRequest &br = res_barriers_requests[res_states];
+			br.dx_resource = res_to_transition;
+			br.subres_mask_qwords = ALIGN(p_resource->get_states_ptr()->subresource_states.size(), 64) / 64;
+			CRASH_COND(p_resource->get_states_ptr()->subresource_states.size() > BarrierRequest::MAX_SUBRESOURCES);
+			br.planes = p_num_planes;
+			br.groups[0].state = p_new_state;
+			for (uint8_t i = 0; i < br.subres_mask_qwords; i++) {
+				if (unlikely(i == subres_qword)) {
+					br.groups[0].subres_mask[i] = subres_mask_piece;
+				} else {
+					br.groups[0].subres_mask[i] = 0;
+				}
+			}
+			br.groups_count = 1;
+		}
+	}
+
+	if (p_new_state == D3D12_RESOURCE_STATE_UNORDERED_ACCESS) {
+		res_states->last_batch_transitioned_to_uav = res_barriers_batch;
+	}
+
+#ifdef DEBUG_COUNT_BARRIERS
+	frame_barriers_cpu_time += OS::get_singleton()->get_ticks_usec() - start;
+#endif
+}
+
+void RenderingDeviceD3D12::_resource_transitions_flush(ID3D12GraphicsCommandList *p_command_list) {
+#ifdef DEBUG_COUNT_BARRIERS
+	uint64_t start = OS::get_singleton()->get_ticks_usec();
+#endif
+
+	for (const KeyValue<Resource::States *, BarrierRequest> &E : res_barriers_requests) {
+		Resource::States *res_states = E.key;
+		const BarrierRequest &br = E.value;
+
+		uint32_t num_subresources = res_states->subresource_states.size();
+
+		// When there's not a lot of subresources, the empirical finding is that it's better
+		// to avoid attempting the single-barrier optimization.
+		static const uint32_t SINGLE_BARRIER_ATTEMPT_MAX_NUM_SUBRESOURCES = 48;
+
+		bool may_do_single_barrier = br.groups_count == 1 && num_subresources * br.planes >= SINGLE_BARRIER_ATTEMPT_MAX_NUM_SUBRESOURCES;
+		if (may_do_single_barrier) {
+			// A single group means we may be able to do a single all-subresources barrier.
+
+			{
+				// First requisite is that all subresources are involved.
+
+				uint8_t subres_mask_full_qwords = num_subresources / 64;
+				for (uint32_t i = 0; i < subres_mask_full_qwords; i++) {
+					if (br.groups[0].subres_mask[i] != UINT64_MAX) {
+						may_do_single_barrier = false;
+						break;
+					}
+				}
+				if (may_do_single_barrier) {
+					if (num_subresources % 64) {
+						DEV_ASSERT(br.subres_mask_qwords == subres_mask_full_qwords + 1);
+						uint64_t mask_tail_qword = 0;
+						for (uint8_t i = 0; i < num_subresources % 64; i++) {
+							mask_tail_qword |= ((uint64_t)1 << i);
+						}
+						if ((br.groups[0].subres_mask[subres_mask_full_qwords] & mask_tail_qword) != mask_tail_qword) {
+							may_do_single_barrier = false;
+						}
+					}
+				}
+			}
+
+			if (may_do_single_barrier) {
+				// Second requisite is that the source state is the same for all.
+
+				for (uint32_t i = 1; i < num_subresources; i++) {
+					if (res_states->subresource_states[i] != res_states->subresource_states[0]) {
+						may_do_single_barrier = false;
+						break;
+					}
+				}
+
+				if (may_do_single_barrier) {
+					// Hurray!, we can do a single barrier (plus maybe a UAV one, too).
+
+					bool just_written = res_states->subresource_states[0] == D3D12_RESOURCE_STATE_UNORDERED_ACCESS;
+					bool needs_uav_barrier = just_written && res_states->last_batch_with_uav_barrier != res_barriers_batch;
+
+					uint32_t needed_barriers = (needs_uav_barrier ? 1 : 0) + 1;
+					if (res_barriers.size() < res_barriers_count + needed_barriers) {
+						res_barriers.resize(res_barriers_count + needed_barriers);
+					}
+
+					if (needs_uav_barrier) {
+						res_barriers[res_barriers_count] = CD3DX12_RESOURCE_BARRIER::UAV(br.dx_resource);
+						res_barriers_count++;
+						res_states->last_batch_with_uav_barrier = res_barriers_batch;
+					}
+
+					if (res_states->subresource_states[0] != br.groups[0].state.get_state_mask()) {
+						res_barriers[res_barriers_count] = CD3DX12_RESOURCE_BARRIER::Transition(br.dx_resource, res_states->subresource_states[0], br.groups[0].state.get_state_mask(), D3D12_RESOURCE_BARRIER_ALL_SUBRESOURCES);
+						res_barriers_count++;
+					}
+
+					for (uint32_t i = 0; i < num_subresources; i++) {
+						res_states->subresource_states[i] = br.groups[0].state.get_state_mask();
+					}
+				}
+			}
+		}
+
+		if (!may_do_single_barrier) {
+			for (uint8_t i = 0; i < br.groups_count; i++) {
+				const BarrierRequest::Group &g = E.value.groups[i];
+
+				if (unlikely(g.state.get_state_mask() == BarrierRequest::DELETED_GROUP)) {
+					continue;
+				}
+
+				uint32_t subresource = 0;
+				do {
+					uint64_t subres_mask_piece = ((uint64_t)1 << (subresource % 64));
+					uint8_t subres_qword = subresource / 64;
+
+					if (likely(g.subres_mask[subres_qword] == 0)) {
+						subresource += 64;
+						continue;
+					}
+
+					if (likely(!(g.subres_mask[subres_qword] & subres_mask_piece))) {
+						subresource++;
+						continue;
+					}
+
+					D3D12_RESOURCE_STATES *curr_state = &res_states->subresource_states[subresource];
+
+					bool just_written = *curr_state == D3D12_RESOURCE_STATE_UNORDERED_ACCESS;
+					bool needs_uav_barrier = just_written && res_states->last_batch_with_uav_barrier != res_barriers_batch;
+
+					uint32_t needed_barriers = (needs_uav_barrier ? 1 : 0) + br.planes;
+					if (res_barriers.size() < res_barriers_count + needed_barriers) {
+						res_barriers.resize(res_barriers_count + needed_barriers);
+					}
+
+					if (needs_uav_barrier) {
+						res_barriers[res_barriers_count] = CD3DX12_RESOURCE_BARRIER::UAV(br.dx_resource);
+						res_barriers_count++;
+						res_states->last_batch_with_uav_barrier = res_barriers_batch;
+					}
+
+					if (*curr_state != g.state.get_state_mask()) {
+						for (uint8_t k = 0; k < br.planes; k++) {
+							res_barriers[res_barriers_count] = CD3DX12_RESOURCE_BARRIER::Transition(br.dx_resource, *curr_state, g.state.get_state_mask(), subresource + k * num_subresources);
+							res_barriers_count++;
+						}
+					}
+
+					*curr_state = g.state.get_state_mask();
+
+					subresource++;
+				} while (subresource < num_subresources);
+			}
+		}
+	}
+
+	if (res_barriers_count) {
+		p_command_list->ResourceBarrier(res_barriers_count, res_barriers.ptr());
+		res_barriers_requests.clear();
+	}
+
+#ifdef DEBUG_COUNT_BARRIERS
+	frame_barriers_count += res_barriers_count;
+	frame_barriers_batches_count++;
+	frame_barriers_cpu_time += OS::get_singleton()->get_ticks_usec() - start;
+#endif
+
+	res_barriers_count = 0;
+	res_barriers_batch++;
+}
+
+/***************************/
+/**** BUFFER MANAGEMENT ****/
+/***************************/
+
+Error RenderingDeviceD3D12::_buffer_allocate(Buffer *p_buffer, uint32_t p_size, D3D12_RESOURCE_STATES p_usage, D3D12_HEAP_TYPE p_heap_type) {
+	ERR_FAIL_COND_V(p_heap_type != D3D12_HEAP_TYPE_DEFAULT && p_heap_type != D3D12_HEAP_TYPE_READBACK, ERR_INVALID_PARAMETER);
+
+	// D3D12 debug layers complain at CBV creation time if the size is not multiple of the value per the spec
+	// but also if you give a rounded size at that point because it will extend beyond the
+	// memory of the resource. Therefore, it seems the only way is to create it with a
+	// rounded size.
+	CD3DX12_RESOURCE_DESC resource_desc = CD3DX12_RESOURCE_DESC::Buffer(ALIGN(p_size, D3D12_CONSTANT_BUFFER_DATA_PLACEMENT_ALIGNMENT));
+	if ((p_usage & D3D12_RESOURCE_STATE_UNORDERED_ACCESS)) {
+		resource_desc.Flags |= D3D12_RESOURCE_FLAG_ALLOW_UNORDERED_ACCESS;
+	}
+
+	D3D12MA::ALLOCATION_DESC allocation_desc = {};
+	allocation_desc.HeapType = p_heap_type;
+#ifdef USE_SMALL_ALLOCS_POOL
+	if (p_size <= SMALL_ALLOCATION_MAX_SIZE) {
+		allocation_desc.CustomPool = _find_or_create_small_allocs_pool(p_heap_type, D3D12_HEAP_FLAG_ALLOW_ONLY_BUFFERS);
+	}
+#endif
+
+	HRESULT res = context->get_allocator()->CreateResource(
+			&allocation_desc,
+			&resource_desc,
+			D3D12_RESOURCE_STATE_COPY_DEST,
+			nullptr,
+			&p_buffer->allocation,
+			IID_PPV_ARGS(&p_buffer->resource));
+	ERR_FAIL_COND_V_MSG(res, ERR_CANT_CREATE, "Can't create buffer of size: " + itos(p_size) + ", error " + vformat("0x%08ux", res) + ".");
+
+	p_buffer->size = p_size;
+	p_buffer->usage = p_usage;
+	p_buffer->own_states.subresource_states.push_back(D3D12_RESOURCE_STATE_COPY_DEST);
+
+	buffer_memory += p_size;
+
+	return OK;
+}
+
+Error RenderingDeviceD3D12::_buffer_free(Buffer *p_buffer) {
+	ERR_FAIL_COND_V(p_buffer->size == 0, ERR_INVALID_PARAMETER);
+
+	buffer_memory -= p_buffer->size;
+
+	p_buffer->resource->Release();
+	p_buffer->resource = nullptr;
+	p_buffer->allocation->Release();
+	p_buffer->allocation = nullptr;
+	p_buffer->size = 0;
+
+	return OK;
+}
+
+Error RenderingDeviceD3D12::_insert_staging_block() {
+	StagingBufferBlock block;
+
+	D3D12_RESOURCE_DESC resource_desc = {};
+	resource_desc.Dimension = D3D12_RESOURCE_DIMENSION_BUFFER;
+	resource_desc.Alignment = 0;
+	resource_desc.Width = staging_buffer_block_size;
+	resource_desc.Height = 1;
+	resource_desc.DepthOrArraySize = 1;
+	resource_desc.MipLevels = 1;
+	resource_desc.Format = DXGI_FORMAT_UNKNOWN;
+	resource_desc.SampleDesc.Count = 1;
+	resource_desc.SampleDesc.Quality = 0;
+	resource_desc.Layout = D3D12_TEXTURE_LAYOUT_ROW_MAJOR;
+	resource_desc.Flags = D3D12_RESOURCE_FLAG_NONE;
+
+	D3D12MA::ALLOCATION_DESC allocation_desc = {};
+	allocation_desc.HeapType = D3D12_HEAP_TYPE_UPLOAD;
+
+	HRESULT res = context->get_allocator()->CreateResource(
+			&allocation_desc,
+			&resource_desc,
+			D3D12_RESOURCE_STATE_GENERIC_READ,
+			NULL,
+			&block.allocation,
+			IID_PPV_ARGS(&block.resource));
+	ERR_FAIL_COND_V_MSG(res, ERR_CANT_CREATE, "CreateResource failed with error " + vformat("0x%08ux", res) + ".");
+
+	staging_buffer_blocks.insert(staging_buffer_current, block);
+	return OK;
+}
+
+Error RenderingDeviceD3D12::_staging_buffer_allocate(uint32_t p_amount, uint32_t p_required_align, uint32_t &r_alloc_offset, uint32_t &r_alloc_size, bool p_can_segment) {
+	// Determine a block to use.
+
+	r_alloc_size = p_amount;
+
+	while (true) {
+		r_alloc_offset = 0;
+
+		// See if we can use current block.
+		if (staging_buffer_blocks[staging_buffer_current].frame_used == frames_drawn) {
+			// We used this block this frame, let's see if there is still room.
+
+			uint32_t write_from = staging_buffer_blocks[staging_buffer_current].fill_amount;
+
+			{
+				uint32_t align_remainder = write_from % p_required_align;
+				if (align_remainder != 0) {
+					write_from += p_required_align - align_remainder;
+				}
+			}
+
+			int32_t available_bytes = int32_t(staging_buffer_block_size) - int32_t(write_from);
+
+			if ((int32_t)p_amount < available_bytes) {
+				// All is good, we should be ok, all will fit.
+				r_alloc_offset = write_from;
+			} else if (p_can_segment && available_bytes >= (int32_t)p_required_align) {
+				// Ok all won't fit but at least we can fit a chunkie.
+				// All is good, update what needs to be written to.
+				r_alloc_offset = write_from;
+				r_alloc_size = available_bytes - (available_bytes % p_required_align);
+
+			} else {
+				// Can't fit it into this buffer.
+				// Will need to try next buffer.
+
+				staging_buffer_current = (staging_buffer_current + 1) % staging_buffer_blocks.size();
+
+				// Before doing anything, though, let's check that we didn't manage to fill all functions.
+				// Possible in a single frame.
+				if (staging_buffer_blocks[staging_buffer_current].frame_used == frames_drawn) {
+					// Guess we did.. ok, let's see if we can insert a new block.
+					if ((uint64_t)staging_buffer_blocks.size() * staging_buffer_block_size < staging_buffer_max_size) {
+						// We can, so we are safe.
+						Error err = _insert_staging_block();
+						if (err) {
+							return err;
+						}
+						// Claim for this frame.
+						staging_buffer_blocks.write[staging_buffer_current].frame_used = frames_drawn;
+					} else {
+						// Ok, worst case scenario, all the staging buffers belong to this frame
+						// and this frame is not even done
+						// If this is the main thread, it means the user is likely loading a lot of resources at once,.
+						// Otherwise, the thread should just be blocked until the next frame (currently unimplemented).
+
+						if (false) { // Separate thread from render.
+
+							//block_until_next_frame()
+							continue;
+						} else {
+							// Flush EVERYTHING including setup commands. IF not immediate, also need to flush the draw commands.
+							_flush(true);
+
+							// Clear the whole staging buffer.
+							for (int i = 0; i < staging_buffer_blocks.size(); i++) {
+								staging_buffer_blocks.write[i].frame_used = 0;
+								staging_buffer_blocks.write[i].fill_amount = 0;
+							}
+							// Claim current.
+							staging_buffer_blocks.write[staging_buffer_current].frame_used = frames_drawn;
+						}
+					}
+
+				} else {
+					// Not from current frame, so continue and try again.
+					continue;
+				}
+			}
+
+		} else if (staging_buffer_blocks[staging_buffer_current].frame_used <= frames_drawn - frame_count) {
+			// This is an old block, which was already processed, let's reuse.
+			staging_buffer_blocks.write[staging_buffer_current].frame_used = frames_drawn;
+			staging_buffer_blocks.write[staging_buffer_current].fill_amount = 0;
+		} else {
+			// This block may still be in use, let's not touch it unless we have to, so.. can we create a new one?
+			if ((uint64_t)staging_buffer_blocks.size() * staging_buffer_block_size < staging_buffer_max_size) {
+				// We are still allowed to create a new block, so let's do that and insert it for current pos.
+				Error err = _insert_staging_block();
+				if (err) {
+					return err;
+				}
+				// Claim for this frame.
+				staging_buffer_blocks.write[staging_buffer_current].frame_used = frames_drawn;
+			} else {
+				// Oops, we are out of room and we can't create more.
+				// Let's flush older frames.
+				// The logic here is that if a game is loading a lot of data from the main thread, it will need to be stalled anyway.
+				// If loading from a separate thread, we can block that thread until next frame when more room is made (not currently implemented, though).
+
+				if (false) {
+					// Separate thread from render.
+					//block_until_next_frame()
+					continue; // And try again.
+				} else {
+					_flush(false);
+
+					for (int i = 0; i < staging_buffer_blocks.size(); i++) {
+						// Clear all functions but the ones from this frame.
+						int block_idx = (i + staging_buffer_current) % staging_buffer_blocks.size();
+						if (staging_buffer_blocks[block_idx].frame_used == frames_drawn) {
+							break; // Ok, we reached something from this frame, abort.
+						}
+
+						staging_buffer_blocks.write[block_idx].frame_used = 0;
+						staging_buffer_blocks.write[block_idx].fill_amount = 0;
+					}
+
+					// Claim for current frame.
+					staging_buffer_blocks.write[staging_buffer_current].frame_used = frames_drawn;
+				}
+			}
+		}
+
+		// All was good, break.
+		break;
+	}
+
+	staging_buffer_used = true;
+
+	return OK;
+}
+
+Error RenderingDeviceD3D12::_buffer_update(Buffer *p_buffer, size_t p_offset, const uint8_t *p_data, size_t p_data_size, bool p_use_draw_command_list, uint32_t p_required_align) {
+	// Submitting may get chunked for various reasons, so convert this to a task.
+	size_t to_submit = p_data_size;
+	size_t submit_from = 0;
+
+	while (to_submit > 0) {
+		uint32_t block_write_offset;
+		uint32_t block_write_amount;
+
+		Error err = _staging_buffer_allocate(MIN(to_submit, staging_buffer_block_size), p_required_align, block_write_offset, block_write_amount);
+		if (err) {
+			return err;
+		}
+
+		// Map staging buffer.
+
+		void *data_ptr = nullptr;
+		{
+			HRESULT res = staging_buffer_blocks[staging_buffer_current].resource->Map(0, &VOID_RANGE, &data_ptr);
+			ERR_FAIL_COND_V_MSG(res, ERR_CANT_CREATE, "Map failed with error " + vformat("0x%08ux", res) + ".");
+		}
+
+		// Copy to staging buffer.
+		memcpy(((uint8_t *)data_ptr) + block_write_offset, p_data + submit_from, block_write_amount);
+
+		// Unmap.
+		staging_buffer_blocks[staging_buffer_current].resource->Unmap(0, &VOID_RANGE);
+
+		// Insert a command to copy this.
+		ID3D12GraphicsCommandList *command_list = (p_use_draw_command_list ? frames[frame].draw_command_list : frames[frame].setup_command_list).Get();
+		command_list->CopyBufferRegion(p_buffer->resource, submit_from + p_offset, staging_buffer_blocks[staging_buffer_current].resource, block_write_offset, block_write_amount);
+
+		staging_buffer_blocks.write[staging_buffer_current].fill_amount = block_write_offset + block_write_amount;
+
+		to_submit -= block_write_amount;
+		submit_from += block_write_amount;
+	}
+
+	return OK;
+}
+
+/*****************/
+/**** TEXTURE ****/
+/*****************/
+
+RID RenderingDeviceD3D12::texture_create(const TextureFormat &p_format, const TextureView &p_view, const Vector<Vector<uint8_t>> &p_data) {
+	_THREAD_SAFE_METHOD_
+
+	D3D12_RESOURCE_DESC1 resource_desc = {}; // Using D3D12_RESOURCE_DESC1. Thanks to the layout, it's sliceable down to D3D12_RESOURCE_DESC if needed.
+	resource_desc.Alignment = 0; // D3D12MA will override this to use a smaller alignment than the default if possible.
+
+	Vector<DataFormat> allowed_formats;
+	if (p_format.shareable_formats.size()) {
+		ERR_FAIL_COND_V_MSG(p_format.shareable_formats.find(p_format.format) == -1, RID(),
+				"If supplied a list of shareable formats, the current format must be present in the list");
+		ERR_FAIL_COND_V_MSG(p_view.format_override != DATA_FORMAT_MAX && p_format.shareable_formats.find(p_view.format_override) == -1, RID(),
+				"If supplied a list of shareable formats, the current view format override must be present in the list");
+		allowed_formats = p_format.shareable_formats;
+	} else {
+		allowed_formats.push_back(p_format.format);
+		if (p_view.format_override != DATA_FORMAT_MAX) {
+			allowed_formats.push_back(p_view.format_override);
+		}
+	}
+
+	ERR_FAIL_INDEX_V(p_format.texture_type, TEXTURE_TYPE_MAX, RID());
+
+	resource_desc.Dimension = d3d12_texture_dimension[p_format.texture_type];
+
+	ERR_FAIL_COND_V_MSG(p_format.width < 1, RID(), "Width must be equal or greater than 1 for all textures");
+
+	resource_desc.Format = d3d12_formats[p_format.format].family;
+
+	resource_desc.Width = p_format.width;
+	if (resource_desc.Dimension == D3D12_RESOURCE_DIMENSION_TEXTURE3D || resource_desc.Dimension == D3D12_RESOURCE_DIMENSION_TEXTURE2D) {
+		ERR_FAIL_COND_V_MSG(p_format.height < 1, RID(), "Height must be equal or greater than 1 for 2D and 3D textures");
+		resource_desc.Height = p_format.height;
+	} else {
+		resource_desc.Height = 1;
+	}
+
+	if (resource_desc.Dimension == D3D12_RESOURCE_DIMENSION_TEXTURE3D) {
+		ERR_FAIL_COND_V_MSG(p_format.depth < 1, RID(), "Depth must be equal or greater than 1 for 3D textures");
+		resource_desc.DepthOrArraySize = p_format.depth;
+	} else {
+		resource_desc.DepthOrArraySize = 1;
+	}
+
+	ERR_FAIL_COND_V(p_format.mipmaps < 1, RID());
+
+	resource_desc.MipLevels = p_format.mipmaps;
+
+	if (p_format.texture_type == TEXTURE_TYPE_1D_ARRAY || p_format.texture_type == TEXTURE_TYPE_2D_ARRAY || p_format.texture_type == TEXTURE_TYPE_CUBE_ARRAY || p_format.texture_type == TEXTURE_TYPE_CUBE) {
+		ERR_FAIL_COND_V_MSG(p_format.array_layers < 1, RID(),
+				"Amount of layers must be equal or greater than 1 for arrays and cubemaps.");
+		ERR_FAIL_COND_V_MSG((p_format.texture_type == TEXTURE_TYPE_CUBE_ARRAY || p_format.texture_type == TEXTURE_TYPE_CUBE) && (p_format.array_layers % 6) != 0, RID(),
+				"Cubemap and cubemap array textures must provide a layer number that is multiple of 6");
+		resource_desc.DepthOrArraySize *= p_format.array_layers;
+	}
+
+	ERR_FAIL_INDEX_V(p_format.samples, TEXTURE_SAMPLES_MAX, RID());
+
+	// Usage.
+
+	if ((p_format.usage_bits & TEXTURE_USAGE_COLOR_ATTACHMENT_BIT)) {
+		resource_desc.Flags |= D3D12_RESOURCE_FLAG_ALLOW_RENDER_TARGET;
+	} else {
+		if ((p_format.usage_bits & TEXTURE_USAGE_CAN_COPY_TO_BIT)) {
+			resource_desc.Flags |= D3D12_RESOURCE_FLAG_ALLOW_UNORDERED_ACCESS; // For clearing via UAV.
+		}
+	}
+
+	if (p_format.usage_bits & TEXTURE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT) {
+		resource_desc.Flags |= D3D12_RESOURCE_FLAG_ALLOW_DEPTH_STENCIL;
+	}
+
+	if (p_format.usage_bits & TEXTURE_USAGE_STORAGE_BIT) {
+		resource_desc.Flags |= D3D12_RESOURCE_FLAG_ALLOW_UNORDERED_ACCESS;
+	}
+
+	resource_desc.SampleDesc = {};
+	DXGI_FORMAT format_to_test = (resource_desc.Flags & D3D12_RESOURCE_FLAG_ALLOW_DEPTH_STENCIL) ? d3d12_formats[p_format.format].dsv_format : d3d12_formats[p_format.format].general_format;
+	if (!(resource_desc.Flags & D3D12_RESOURCE_FLAG_ALLOW_UNORDERED_ACCESS)) {
+		resource_desc.SampleDesc.Count = MIN(
+				_find_max_common_supported_sample_count(&format_to_test, 1),
+				rasterization_sample_count[p_format.samples]);
+	} else {
+		// No MSAA in D3D12 if storage. May have become possible recently where supported, though.
+		resource_desc.SampleDesc.Count = 1;
+	}
+	resource_desc.SampleDesc.Quality = resource_desc.SampleDesc.Count == 1 ? 0 : DXGI_STANDARD_MULTISAMPLE_QUALITY_PATTERN;
+
+	uint32_t required_mipmaps = get_image_required_mipmaps(p_format.width, p_format.height, p_format.depth);
+
+	ERR_FAIL_COND_V_MSG(required_mipmaps < p_format.mipmaps, RID(),
+			"Too many mipmaps requested for texture format and dimensions (" + itos(p_format.mipmaps) + "), maximum allowed: (" + itos(required_mipmaps) + ").");
+
+	if (p_data.size()) {
+		ERR_FAIL_COND_V_MSG(!(p_format.usage_bits & TEXTURE_USAGE_CAN_UPDATE_BIT), RID(),
+				"Texture needs the TEXTURE_USAGE_CAN_UPDATE_BIT usage flag in order to be updated at initialization or later");
+
+		int expected_images = p_format.array_layers;
+		ERR_FAIL_COND_V_MSG(p_data.size() != expected_images, RID(),
+				"Default supplied data for image format is of invalid length (" + itos(p_data.size()) + "), should be (" + itos(expected_images) + ").");
+
+		for (uint32_t i = 0; i < p_format.array_layers; i++) {
+			uint32_t required_size = get_image_format_required_size(p_format.format, p_format.width, p_format.height, p_format.depth, p_format.mipmaps);
+			ERR_FAIL_COND_V_MSG((uint32_t)p_data[i].size() != required_size, RID(),
+					"Data for slice index " + itos(i) + " (mapped to layer " + itos(i) + ") differs in size (supplied: " + itos(p_data[i].size()) + ") than what is required by the format (" + itos(required_size) + ").");
+		}
+	}
+
+	// Validate that this image is supported for the intended use.
+
+	// If views of different families are wanted, special setup is needed for proper sharing among them.
+	// Two options here:
+	// 1. If ID3DDevice10 is present and driver reports relaxed casting is, leverage its new extended resource creation API (via D3D12MA).
+	// 2. Otherwise, fall back to an approach based on abusing aliasing, hoping for the best.
+	bool cross_family_sharing = false;
+	ComPtr<ID3D12Device10> device10;
+	device.As(&device10);
+	bool relaxed_casting_available = device10.Get() && context->get_format_capabilities().relaxed_casting_supported;
+	LocalVector<DXGI_FORMAT> castable_formats;
+
+	HashMap<DataFormat, D3D12_RESOURCE_FLAGS> aliases_forbidden_flags;
+	D3D12_RESOURCE_FLAGS accum_forbidden_flags = {};
+	for (DataFormat curr_format : allowed_formats) {
+		// For now, we'll validate usages only the main format, to match what Vulkan RD does.
+		// TODO: The aliasing trick assumes the main format is the only writable one. We should either validate for that or handle a different order gracefully.
+		bool checking_main_format = curr_format == p_format.format;
+
+		String format_text = "'" + String(named_formats[p_format.format]) + "'";
+
+		ERR_FAIL_COND_V_MSG(d3d12_formats[curr_format].family == DXGI_FORMAT_UNKNOWN, RID(), "Format " + format_text + " is not supported.");
+
+		if (d3d12_formats[curr_format].family != d3d12_formats[allowed_formats[0]].family) {
+			cross_family_sharing = true;
+		}
+		if (relaxed_casting_available) {
+			castable_formats.push_back(d3d12_formats[curr_format].general_format);
+		}
+
+		D3D12_FEATURE_DATA_FORMAT_SUPPORT srv_rtv_support = {};
+		srv_rtv_support.Format = d3d12_formats[curr_format].general_format;
+		HRESULT res = device->CheckFeatureSupport(D3D12_FEATURE_FORMAT_SUPPORT, &srv_rtv_support, sizeof(srv_rtv_support));
+		ERR_FAIL_COND_V_MSG(res, RID(), "CheckFeatureSupport failed with error " + vformat("0x%08ux", res) + ".");
+
+		D3D12_FEATURE_DATA_FORMAT_SUPPORT uav_support = srv_rtv_support; // Fine for now.
+
+		D3D12_FEATURE_DATA_FORMAT_SUPPORT dsv_support = {};
+		dsv_support.Format = d3d12_formats[curr_format].dsv_format;
+		res = device->CheckFeatureSupport(D3D12_FEATURE_FORMAT_SUPPORT, &dsv_support, sizeof(dsv_support));
+		ERR_FAIL_COND_V_MSG(res, RID(), "CheckFeatureSupport failed with error " + vformat("0x%08ux", res) + ".");
+
+		if (checking_main_format) {
+			if ((p_format.usage_bits & (TEXTURE_USAGE_SAMPLING_BIT | TEXTURE_USAGE_COLOR_ATTACHMENT_BIT))) {
+				if (p_format.mipmaps && !(srv_rtv_support.Support1 & D3D12_FORMAT_SUPPORT1_MIP)) {
+					ERR_FAIL_V_MSG(RID(), "Format " + format_text + " does not support mip.maps.");
+				}
+			}
+
+			// Per https://docs.microsoft.com/en-us/windows/win32/api/d3d12/ne-d3d12-d3d12_format_support1,
+			// as long as the resource can be used as a texture, Sample() will work with point filter at least.
+			// However, we've empirically found that checking for at least D3D12_FORMAT_SUPPORT1_SHADER_LOAD is needed.
+			// That's almost good for integer formats. The problem is that theoretically there may be
+			// float formats that support LOAD but not SAMPLE fully, so this check will not detect
+			// such a flaw in the format. Linearly interpolated sampling would just not work on them.
+			// [[IMPLICIT_SAMPLE]]
+			if ((p_format.usage_bits & TEXTURE_USAGE_SAMPLING_BIT) && !(srv_rtv_support.Support1 & (D3D12_FORMAT_SUPPORT1_SHADER_LOAD | D3D12_FORMAT_SUPPORT1_SHADER_SAMPLE))) {
+				ERR_FAIL_V_MSG(RID(), "Format " + format_text + " does not support usage as a sampled texture.");
+			}
+
+			if ((p_format.usage_bits & TEXTURE_USAGE_SAMPLING_BIT) && d3d12_formats[curr_format].general_format == DXGI_FORMAT_UNKNOWN) {
+				ERR_FAIL_V_MSG(RID(), "Format " + format_text + " does not support usage as a sampled texture.");
+			}
+
+			if ((p_format.usage_bits & TEXTURE_USAGE_COLOR_ATTACHMENT_BIT) && !(srv_rtv_support.Support1 & D3D12_FORMAT_SUPPORT1_RENDER_TARGET)) {
+				ERR_FAIL_V_MSG(RID(), "Format " + format_text + " does not support usage as color attachment.");
+			}
+		}
+
+		if ((p_format.usage_bits & TEXTURE_USAGE_CAN_COPY_TO_BIT)) {
+			// We need to check if the texture can be cleared; if it's not flagged for color attachment , we have to see if it's possible via a UAV.
+			if (!(p_format.usage_bits & TEXTURE_USAGE_COLOR_ATTACHMENT_BIT)) {
+				if (!(uav_support.Support1 & D3D12_FORMAT_SUPPORT1_TYPED_UNORDERED_ACCESS_VIEW)) {
+					if (checking_main_format) {
+						ERR_FAIL_V_MSG(RID(), "Format " + format_text + " does not support usage as a copy-to texture, because clearing it is not supported.");
+					} else {
+						aliases_forbidden_flags[curr_format] |= D3D12_RESOURCE_FLAG_ALLOW_UNORDERED_ACCESS;
+						accum_forbidden_flags |= D3D12_RESOURCE_FLAG_ALLOW_UNORDERED_ACCESS;
+					}
+				}
+			}
+		}
+
+		if ((p_format.usage_bits & TEXTURE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT) && !(dsv_support.Support1 & D3D12_FORMAT_SUPPORT1_DEPTH_STENCIL)) {
+			if (checking_main_format) {
+				printf("dxgiformat: %x\n", resource_desc.Format);
+				ERR_FAIL_V_MSG(RID(), "Format " + format_text + " does not support usage as depth-stencil attachment.");
+			} else {
+				aliases_forbidden_flags[curr_format] |= D3D12_RESOURCE_FLAG_ALLOW_DEPTH_STENCIL;
+				accum_forbidden_flags |= D3D12_RESOURCE_FLAG_ALLOW_DEPTH_STENCIL;
+			}
+		}
+
+		if ((p_format.usage_bits & TEXTURE_USAGE_STORAGE_BIT)) {
+			if (!(uav_support.Support1 & D3D12_FORMAT_SUPPORT1_TYPED_UNORDERED_ACCESS_VIEW)) { // Maybe check LOAD/STORE, too?
+				if (checking_main_format) {
+					ERR_FAIL_V_MSG(RID(), "Format " + format_text + " does not support usage as storage image.");
+				} else {
+					aliases_forbidden_flags[curr_format] |= D3D12_RESOURCE_FLAG_ALLOW_UNORDERED_ACCESS;
+					accum_forbidden_flags |= D3D12_RESOURCE_FLAG_ALLOW_UNORDERED_ACCESS;
+				}
+			}
+		}
+
+		if (checking_main_format) {
+			if ((p_format.usage_bits & TEXTURE_USAGE_STORAGE_ATOMIC_BIT) && !(uav_support.Support2 & D3D12_FORMAT_SUPPORT2_UAV_ATOMIC_ADD)) { // Check a basic atomic at least.
+				ERR_FAIL_V_MSG(RID(), "Format " + format_text + " does not support usage as atomic storage image.");
+			}
+
+			if ((p_format.usage_bits & TEXTURE_USAGE_VRS_ATTACHMENT_BIT) && d3d12_formats[curr_format].general_format != DXGI_FORMAT_R8_UINT) {
+				ERR_FAIL_V_MSG(RID(), "Format " + format_text + " does not support usage as VRS attachment.");
+			}
+		}
+	}
+
+	if (cross_family_sharing && !relaxed_casting_available) {
+		// At least guarantee the same layout among aliases.
+		resource_desc.Layout = D3D12_TEXTURE_LAYOUT_64KB_UNDEFINED_SWIZZLE;
+
+		// Per https://docs.microsoft.com/en-us/windows/win32/api/d3d12/ne-d3d12-d3d12_texture_layout.
+		if (p_format.texture_type == TEXTURE_TYPE_1D) {
+			ERR_FAIL_V_MSG(RID(), "This texture's views require aliasing, but that's not supported for a 1D texture.");
+		}
+		if (p_format.samples != TEXTURE_SAMPLES_1) {
+			ERR_FAIL_V_MSG(RID(), "This texture's views require aliasing, but that's not supported for a multi-sample texture.");
+		}
+		if ((p_format.usage_bits & TEXTURE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT)) {
+			ERR_FAIL_V_MSG(RID(), "This texture's views require aliasing, but that's not supported for a depth-stencil texture.");
+		}
+		if (d3d12_formats[p_format.format].family == DXGI_FORMAT_R32G32B32_TYPELESS) {
+			ERR_FAIL_V_MSG(RID(), "This texture's views require aliasing, but that's not supported for an R32G32B32 texture.");
+		}
+	} else {
+		resource_desc.Layout = D3D12_TEXTURE_LAYOUT_UNKNOWN;
+	}
+
+	if ((p_format.usage_bits & TEXTURE_USAGE_VRS_ATTACHMENT_BIT)) {
+		// For VRS images we can't use the typeless format.
+		resource_desc.Format = DXGI_FORMAT_R8_UINT;
+	}
+
+	// Some view validation.
+
+	if (p_view.format_override != DATA_FORMAT_MAX) {
+		ERR_FAIL_INDEX_V(p_view.format_override, DATA_FORMAT_MAX, RID());
+	}
+	ERR_FAIL_INDEX_V(p_view.swizzle_r, TEXTURE_SWIZZLE_MAX, RID());
+	ERR_FAIL_INDEX_V(p_view.swizzle_g, TEXTURE_SWIZZLE_MAX, RID());
+	ERR_FAIL_INDEX_V(p_view.swizzle_b, TEXTURE_SWIZZLE_MAX, RID());
+	ERR_FAIL_INDEX_V(p_view.swizzle_a, TEXTURE_SWIZZLE_MAX, RID());
+
+	// Allocate memory.
+
+	D3D12MA::ALLOCATION_DESC allocation_desc = {};
+	if (cross_family_sharing && !relaxed_casting_available) {
+		allocation_desc.Flags = D3D12MA::ALLOCATION_FLAG_CAN_ALIAS;
+	}
+	allocation_desc.HeapType = (p_format.usage_bits & TEXTURE_USAGE_CPU_READ_BIT) ? D3D12_HEAP_TYPE_READBACK : D3D12_HEAP_TYPE_DEFAULT;
+	if ((resource_desc.Flags & (D3D12_RESOURCE_FLAG_ALLOW_RENDER_TARGET | D3D12_RESOURCE_FLAG_ALLOW_DEPTH_STENCIL))) {
+		if (!(accum_forbidden_flags & (D3D12_RESOURCE_FLAG_ALLOW_RENDER_TARGET | D3D12_RESOURCE_FLAG_ALLOW_DEPTH_STENCIL))) {
+			allocation_desc.ExtraHeapFlags = D3D12_HEAP_FLAG_ALLOW_ONLY_RT_DS_TEXTURES;
+		}
+	} else {
+		allocation_desc.ExtraHeapFlags = D3D12_HEAP_FLAG_ALLOW_ONLY_NON_RT_DS_TEXTURES;
+	}
+	if ((resource_desc.Flags & D3D12_RESOURCE_FLAG_ALLOW_UNORDERED_ACCESS)) {
+		if (!(accum_forbidden_flags & D3D12_RESOURCE_FLAG_ALLOW_UNORDERED_ACCESS)) {
+			allocation_desc.ExtraHeapFlags |= D3D12_HEAP_FLAG_ALLOW_SHADER_ATOMICS;
+		}
+	}
+
+#ifdef USE_SMALL_ALLOCS_POOL
+	uint32_t width, height;
+	uint32_t image_size = get_image_format_required_size(p_format.format, p_format.width, p_format.height, p_format.depth, p_format.mipmaps, &width, &height);
+	if (image_size <= SMALL_ALLOCATION_MAX_SIZE) {
+		allocation_desc.CustomPool = _find_or_create_small_allocs_pool(allocation_desc.HeapType, allocation_desc.ExtraHeapFlags);
+	}
+#endif
+
+	Texture texture;
+
+	D3D12_RESOURCE_STATES initial_state = p_data.size() || (p_format.usage_bits & TEXTURE_USAGE_CPU_READ_BIT) ? D3D12_RESOURCE_STATE_COPY_DEST : D3D12_RESOURCE_STATE_ALL_SHADER_RESOURCE;
+	FLOAT black[4] = {};
+	D3D12_CLEAR_VALUE clear_value = CD3DX12_CLEAR_VALUE(d3d12_formats[p_format.format].general_format, black);
+	D3D12_CLEAR_VALUE *clear_value_ptr = (resource_desc.Flags & D3D12_RESOURCE_FLAG_ALLOW_RENDER_TARGET) ? &clear_value : nullptr;
+	HRESULT res = {};
+	if (cross_family_sharing && relaxed_casting_available) {
+		res = context->get_allocator()->CreateResource3(
+				&allocation_desc,
+				&resource_desc,
+				D3D12_BARRIER_LAYOUT_COMMON, // Needed for barrier interop.
+				clear_value_ptr,
+				castable_formats.size(),
+				castable_formats.ptr(),
+				&texture.allocation,
+				IID_PPV_ARGS(&texture.owner_resource));
+		initial_state = D3D12_RESOURCE_STATE_COMMON; // Needed for barrier interop.
+	} else {
+		res = context->get_allocator()->CreateResource(
+				&allocation_desc,
+				(D3D12_RESOURCE_DESC *)&resource_desc,
+				initial_state,
+				clear_value_ptr,
+				&texture.allocation,
+				IID_PPV_ARGS(&texture.owner_resource));
+	}
+	ERR_FAIL_COND_V_MSG(res, RID(), "CreateResource failed with error " + vformat("0x%08ux", res) + ".");
+	texture.resource = texture.owner_resource;
+	image_memory += texture.allocation->GetSize();
+	texture.type = p_format.texture_type;
+	texture.format = p_format.format;
+	texture.planes = get_image_format_plane_count(p_format.format);
+	texture.width = p_format.width;
+	texture.height = p_format.height;
+	texture.depth = p_format.depth;
+	texture.layers = p_format.array_layers;
+	texture.mipmaps = p_format.mipmaps;
+	texture.owner_layers = texture.layers;
+	texture.owner_mipmaps = texture.mipmaps;
+	texture.base_mipmap = 0;
+	texture.base_layer = 0;
+	texture.is_resolve_buffer = p_format.is_resolve_buffer;
+	texture.usage_flags = p_format.usage_bits;
+	texture.samples = p_format.samples;
+	texture.allowed_shared_formats = p_format.shareable_formats;
+	texture.own_states.subresource_states.resize(texture.mipmaps * texture.layers);
+	for (uint32_t i = 0; i < texture.own_states.subresource_states.size(); i++) {
+		texture.own_states.subresource_states[i] = initial_state;
+	}
+	texture.bound = false;
+
+	// Describe view.
+
+	static const D3D12_SRV_DIMENSION view_dimensions[TEXTURE_TYPE_MAX] = {
+		D3D12_SRV_DIMENSION_TEXTURE1D,
+		D3D12_SRV_DIMENSION_TEXTURE2D,
+		D3D12_SRV_DIMENSION_TEXTURE3D,
+		D3D12_SRV_DIMENSION_TEXTURECUBE,
+		D3D12_SRV_DIMENSION_TEXTURE1DARRAY,
+		D3D12_SRV_DIMENSION_TEXTURE2DARRAY,
+		D3D12_SRV_DIMENSION_TEXTURECUBEARRAY,
+	};
+	static const D3D12_SRV_DIMENSION view_dimensions_ms[TEXTURE_TYPE_MAX] = {
+		D3D12_SRV_DIMENSION_UNKNOWN,
+		D3D12_SRV_DIMENSION_TEXTURE2DMS,
+		D3D12_SRV_DIMENSION_UNKNOWN,
+		D3D12_SRV_DIMENSION_UNKNOWN,
+		D3D12_SRV_DIMENSION_UNKNOWN,
+		D3D12_SRV_DIMENSION_TEXTURE2DMSARRAY,
+		D3D12_SRV_DIMENSION_UNKNOWN,
+	};
+	static const D3D12_UAV_DIMENSION uav_dimensions[TEXTURE_TYPE_MAX] = {
+		D3D12_UAV_DIMENSION_TEXTURE1D,
+		D3D12_UAV_DIMENSION_TEXTURE2D,
+		D3D12_UAV_DIMENSION_TEXTURE3D,
+		D3D12_UAV_DIMENSION_TEXTURE2DARRAY,
+		D3D12_UAV_DIMENSION_TEXTURE1DARRAY,
+		D3D12_UAV_DIMENSION_TEXTURE2DARRAY,
+		D3D12_UAV_DIMENSION_TEXTURE2DARRAY,
+	};
+
+	texture.srv_desc.ViewDimension = p_format.samples == TEXTURE_SAMPLES_1 ? view_dimensions[p_format.texture_type] : view_dimensions_ms[p_format.texture_type];
+
+	texture.owner_uav_desc.Format = d3d12_formats[p_format.format].general_format;
+	texture.owner_uav_desc.ViewDimension = p_format.samples == TEXTURE_SAMPLES_1 ? uav_dimensions[p_format.texture_type] : D3D12_UAV_DIMENSION_UNKNOWN;
+
+	UINT base_swizzle = D3D12_DEFAULT_SHADER_4_COMPONENT_MAPPING;
+	if (p_view.format_override == DATA_FORMAT_MAX) {
+		texture.srv_desc.Format = d3d12_formats[p_format.format].general_format;
+		base_swizzle = d3d12_formats[p_format.format].swizzle;
+	} else {
+		texture.srv_desc.Format = d3d12_formats[p_view.format_override].general_format;
+		base_swizzle = d3d12_formats[p_view.format_override].swizzle;
+	}
+
+	// Apply requested swizzle (component mapping) on top of the one from the format database.
+
+	D3D12_SHADER_COMPONENT_MAPPING component_swizzles[TEXTURE_SWIZZLE_MAX] = {
+		D3D12_SHADER_COMPONENT_MAPPING_FORCE_VALUE_0, // Unused.
+		D3D12_SHADER_COMPONENT_MAPPING_FORCE_VALUE_0,
+		D3D12_SHADER_COMPONENT_MAPPING_FORCE_VALUE_1,
+		// These will be D3D12_SHADER_COMPONENT_MAPPING_FROM_MEMORY_COMPONENT_*.
+		D3D12_DECODE_SHADER_4_COMPONENT_MAPPING(0, base_swizzle),
+		D3D12_DECODE_SHADER_4_COMPONENT_MAPPING(1, base_swizzle),
+		D3D12_DECODE_SHADER_4_COMPONENT_MAPPING(2, base_swizzle),
+		D3D12_DECODE_SHADER_4_COMPONENT_MAPPING(3, base_swizzle),
+	};
+
+	texture.srv_desc.Shader4ComponentMapping = D3D12_ENCODE_SHADER_4_COMPONENT_MAPPING(
+			p_view.swizzle_r == TEXTURE_SWIZZLE_IDENTITY ? component_swizzles[TEXTURE_SWIZZLE_R] : component_swizzles[p_view.swizzle_r],
+			p_view.swizzle_g == TEXTURE_SWIZZLE_IDENTITY ? component_swizzles[TEXTURE_SWIZZLE_G] : component_swizzles[p_view.swizzle_g],
+			p_view.swizzle_b == TEXTURE_SWIZZLE_IDENTITY ? component_swizzles[TEXTURE_SWIZZLE_B] : component_swizzles[p_view.swizzle_b],
+			p_view.swizzle_a == TEXTURE_SWIZZLE_IDENTITY ? component_swizzles[TEXTURE_SWIZZLE_A] : component_swizzles[p_view.swizzle_a]);
+
+	switch (texture.srv_desc.ViewDimension) {
+		case D3D12_SRV_DIMENSION_TEXTURE1D: {
+			texture.srv_desc.Texture1D.MipLevels = p_format.mipmaps;
+		} break;
+		case D3D12_SRV_DIMENSION_TEXTURE1DARRAY: {
+			texture.srv_desc.Texture1DArray.MipLevels = p_format.mipmaps;
+			texture.srv_desc.Texture1DArray.ArraySize = p_format.array_layers;
+		} break;
+		case D3D12_SRV_DIMENSION_TEXTURE2D: {
+			texture.srv_desc.Texture2D.MipLevels = p_format.mipmaps;
+		} break;
+		case D3D12_SRV_DIMENSION_TEXTURE2DMS: {
+		} break;
+		case D3D12_SRV_DIMENSION_TEXTURE2DARRAY: {
+			texture.srv_desc.Texture2DArray.MipLevels = p_format.mipmaps;
+			texture.srv_desc.Texture2DArray.ArraySize = p_format.array_layers;
+		} break;
+		case D3D12_SRV_DIMENSION_TEXTURE2DMSARRAY: {
+			texture.srv_desc.Texture2DMSArray.ArraySize = p_format.array_layers;
+		} break;
+		case D3D12_SRV_DIMENSION_TEXTURECUBEARRAY: {
+			texture.srv_desc.TextureCubeArray.MipLevels = p_format.mipmaps;
+			texture.srv_desc.TextureCubeArray.NumCubes = p_format.array_layers / 6;
+		} break;
+		case D3D12_SRV_DIMENSION_TEXTURE3D: {
+			texture.srv_desc.Texture3D.MipLevels = p_format.mipmaps;
+		} break;
+		case D3D12_SRV_DIMENSION_TEXTURECUBE: {
+			texture.srv_desc.TextureCube.MipLevels = p_format.mipmaps;
+		} break;
+	}
+
+	switch (texture.owner_uav_desc.ViewDimension) {
+		case D3D12_UAV_DIMENSION_TEXTURE1DARRAY: {
+			texture.owner_uav_desc.Texture1DArray.ArraySize = p_format.array_layers;
+		} break;
+		case D3D12_UAV_DIMENSION_TEXTURE2DARRAY: {
+			// Either for an actual 2D texture array, cubemap or cubemap array.
+			texture.owner_uav_desc.Texture2DArray.ArraySize = p_format.array_layers;
+		} break;
+		case D3D12_UAV_DIMENSION_TEXTURE3D: {
+			texture.owner_uav_desc.Texture3D.WSize = p_format.depth;
+		} break;
+		default: {
+		}
+	}
+
+	texture.uav_desc = texture.owner_uav_desc;
+	if (p_view.format_override != DATA_FORMAT_MAX) {
+		texture.uav_desc.Format = d3d12_formats[p_view.format_override].general_format;
+	}
+
+	if (cross_family_sharing && !relaxed_casting_available) {
+		D3D12_RESOURCE_DESC resource_desc_backup = *(D3D12_RESOURCE_DESC *)&resource_desc;
+		D3D12MA::ALLOCATION_DESC allocation_desc_backup = allocation_desc;
+
+		texture.aliases.resize(texture.allowed_shared_formats.size());
+		for (int i = 0; i < texture.allowed_shared_formats.size(); i++) {
+			DataFormat curr_format = texture.allowed_shared_formats[i];
+
+			DXGI_FORMAT format_family = d3d12_formats[curr_format].family;
+			if (format_family == d3d12_formats[p_format.format].family) {
+				texture.aliases[i] = nullptr;
+				continue;
+			}
+
+			D3D12_RESOURCE_DESC alias_resource_desc = *(D3D12_RESOURCE_DESC *)&resource_desc;
+			alias_resource_desc.Format = format_family;
+			if (aliases_forbidden_flags.has(curr_format)) {
+				alias_resource_desc.Flags &= ~aliases_forbidden_flags[curr_format];
+			}
+			clear_value.Format = format_family;
+			res = context->get_allocator()->CreateAliasingResource(
+					texture.allocation,
+					0,
+					&alias_resource_desc,
+					initial_state,
+					(alias_resource_desc.Flags & D3D12_RESOURCE_FLAG_ALLOW_RENDER_TARGET) ? clear_value_ptr : nullptr,
+					IID_PPV_ARGS(&texture.aliases[i]));
+			ERR_FAIL_COND_V_MSG(res, RID(), "CreateAliasingResource failed with error " + vformat("0x%08ux", res) + ".");
+
+			if (curr_format == p_view.format_override) {
+				texture.resource = texture.aliases[i];
+			}
+		}
+	}
+
+	RID id = texture_owner.make_rid(texture);
+#ifdef DEV_ENABLED
+	set_resource_name(id, "RID:" + itos(id.get_id()));
+#endif
+
+	if (p_data.size()) {
+		Texture *texture_ptr = texture_owner.get_or_null(id);
+		ERR_FAIL_NULL_V(texture_ptr, RID());
+
+		ID3D12GraphicsCommandList *command_list = frames[frame].setup_command_list.Get();
+
+		for (uint32_t i = 0; i < p_format.array_layers; i++) {
+			_texture_update(texture_ptr, i, p_data[i], RD::BARRIER_MASK_ALL_BARRIERS, command_list);
+		}
+	}
+	return id;
+}
+
+RID RenderingDeviceD3D12::texture_create_shared(const TextureView &p_view, RID p_with_texture) {
+	_THREAD_SAFE_METHOD_
+
+	Texture *src_texture = texture_owner.get_or_null(p_with_texture);
+	ERR_FAIL_NULL_V(src_texture, RID());
+
+	if (src_texture->owner.is_valid()) { // Ahh this is a share.
+		p_with_texture = src_texture->owner;
+		src_texture = texture_owner.get_or_null(src_texture->owner);
+		ERR_FAIL_NULL_V(src_texture, RID()); // This is a bug.
+	}
+
+	// Describe view.
+
+	Texture texture = *src_texture;
+	texture.own_states.subresource_states.clear();
+	texture.states = &src_texture->own_states;
+
+	UINT base_swizzle = D3D12_DEFAULT_SHADER_4_COMPONENT_MAPPING;
+	if (p_view.format_override == DATA_FORMAT_MAX || p_view.format_override == texture.format) {
+		texture.srv_desc.Format = d3d12_formats[texture.format].general_format;
+		base_swizzle = d3d12_formats[texture.format].swizzle;
+		texture.uav_desc.Format = d3d12_formats[texture.format].general_format;
+	} else {
+		ERR_FAIL_INDEX_V(p_view.format_override, DATA_FORMAT_MAX, RID());
+
+		ERR_FAIL_COND_V_MSG(texture.allowed_shared_formats.find(p_view.format_override) == -1, RID(),
+				"Format override is not in the list of allowed shareable formats for original texture.");
+		texture.srv_desc.Format = d3d12_formats[p_view.format_override].general_format;
+		base_swizzle = d3d12_formats[p_view.format_override].swizzle;
+		texture.uav_desc.Format = d3d12_formats[p_view.format_override].general_format;
+
+		if (texture.aliases.size()) {
+			for (int i = 0; i < texture.allowed_shared_formats.size(); i++) {
+				if (texture.allowed_shared_formats[i] == p_view.format_override) {
+					texture.resource = texture.aliases[i];
+					break;
+				}
+			}
+		}
+	}
+
+	// Apply requested swizzle (component mapping) on top of the one from the format database.
+
+	D3D12_SHADER_COMPONENT_MAPPING component_swizzles[TEXTURE_SWIZZLE_MAX] = {
+		D3D12_SHADER_COMPONENT_MAPPING_FORCE_VALUE_0, // Unused.
+		D3D12_SHADER_COMPONENT_MAPPING_FORCE_VALUE_0,
+		D3D12_SHADER_COMPONENT_MAPPING_FORCE_VALUE_1,
+		// These will be D3D12_SHADER_COMPONENT_MAPPING_FROM_MEMORY_COMPONENT_*.
+		D3D12_DECODE_SHADER_4_COMPONENT_MAPPING(0, base_swizzle),
+		D3D12_DECODE_SHADER_4_COMPONENT_MAPPING(1, base_swizzle),
+		D3D12_DECODE_SHADER_4_COMPONENT_MAPPING(2, base_swizzle),
+		D3D12_DECODE_SHADER_4_COMPONENT_MAPPING(3, base_swizzle),
+	};
+
+	texture.srv_desc.Shader4ComponentMapping = D3D12_ENCODE_SHADER_4_COMPONENT_MAPPING(
+			p_view.swizzle_r == TEXTURE_SWIZZLE_IDENTITY ? component_swizzles[TEXTURE_SWIZZLE_R] : component_swizzles[p_view.swizzle_r],
+			p_view.swizzle_g == TEXTURE_SWIZZLE_IDENTITY ? component_swizzles[TEXTURE_SWIZZLE_G] : component_swizzles[p_view.swizzle_g],
+			p_view.swizzle_b == TEXTURE_SWIZZLE_IDENTITY ? component_swizzles[TEXTURE_SWIZZLE_B] : component_swizzles[p_view.swizzle_b],
+			p_view.swizzle_a == TEXTURE_SWIZZLE_IDENTITY ? component_swizzles[TEXTURE_SWIZZLE_A] : component_swizzles[p_view.swizzle_a]);
+
+	texture.owner = p_with_texture;
+	RID id = texture_owner.make_rid(texture);
+#ifdef DEV_ENABLED
+	set_resource_name(id, "RID:" + itos(id.get_id()));
+#endif
+	_add_dependency(id, p_with_texture);
+
+	return id;
+}
+
+RID RenderingDeviceD3D12::texture_create_from_extension(TextureType p_type, DataFormat p_format, TextureSamples p_samples, BitField<RenderingDevice::TextureUsageBits> p_flags, uint64_t p_image, uint64_t p_width, uint64_t p_height, uint64_t p_depth, uint64_t p_layers) {
+	ERR_FAIL_V_MSG(RID(), "Unimplemented!");
+}
+
+RID RenderingDeviceD3D12::texture_create_shared_from_slice(const TextureView &p_view, RID p_with_texture, uint32_t p_layer, uint32_t p_mipmap, uint32_t p_mipmaps, TextureSliceType p_slice_type, uint32_t p_layers) {
+	_THREAD_SAFE_METHOD_
+
+	Texture *src_texture = texture_owner.get_or_null(p_with_texture);
+	ERR_FAIL_NULL_V(src_texture, RID());
+
+	if (src_texture->owner.is_valid()) { // Ahh this is a share.
+		p_with_texture = src_texture->owner;
+		src_texture = texture_owner.get_or_null(src_texture->owner);
+		ERR_FAIL_NULL_V(src_texture, RID()); // This is a bug.
+	}
+
+	ERR_FAIL_COND_V_MSG(p_slice_type == TEXTURE_SLICE_CUBEMAP && (src_texture->type != TEXTURE_TYPE_CUBE && src_texture->type != TEXTURE_TYPE_CUBE_ARRAY), RID(),
+			"Can only create a cubemap slice from a cubemap or cubemap array mipmap");
+
+	ERR_FAIL_COND_V_MSG(p_slice_type == TEXTURE_SLICE_3D && src_texture->type != TEXTURE_TYPE_3D, RID(),
+			"Can only create a 3D slice from a 3D texture");
+
+	ERR_FAIL_COND_V_MSG(p_slice_type == TEXTURE_SLICE_2D_ARRAY && (src_texture->type != TEXTURE_TYPE_2D_ARRAY), RID(),
+			"Can only create an array slice from a 2D array mipmap");
+
+	// Describe view.
+
+	ERR_FAIL_UNSIGNED_INDEX_V(p_mipmap, src_texture->mipmaps, RID());
+	ERR_FAIL_COND_V(p_mipmap + p_mipmaps > src_texture->mipmaps, RID());
+	ERR_FAIL_UNSIGNED_INDEX_V(p_layer, src_texture->layers, RID());
+
+	int slice_layers = 1;
+	if (p_layers != 0) {
+		ERR_FAIL_COND_V_MSG(p_layers > 1 && p_slice_type != TEXTURE_SLICE_2D_ARRAY, RID(), "layer slicing only supported for 2D arrays");
+		ERR_FAIL_COND_V_MSG(p_layer + p_layers > src_texture->layers, RID(), "layer slice is out of bounds");
+		slice_layers = p_layers;
+	} else if (p_slice_type == TEXTURE_SLICE_2D_ARRAY) {
+		ERR_FAIL_COND_V_MSG(p_layer != 0, RID(), "layer must be 0 when obtaining a 2D array mipmap slice");
+		slice_layers = src_texture->layers;
+	} else if (p_slice_type == TEXTURE_SLICE_CUBEMAP) {
+		slice_layers = 6;
+	}
+
+	Texture texture = *src_texture;
+	get_image_format_required_size(texture.format, texture.width, texture.height, texture.depth, p_mipmap + 1, &texture.width, &texture.height);
+	texture.mipmaps = p_mipmaps;
+	texture.layers = slice_layers;
+	texture.base_mipmap = p_mipmap;
+	texture.base_layer = p_layer;
+	texture.own_states.subresource_states.clear();
+	texture.states = &src_texture->own_states;
+
+	UINT base_swizzle = D3D12_DEFAULT_SHADER_4_COMPONENT_MAPPING;
+	if (p_view.format_override == DATA_FORMAT_MAX || p_view.format_override == texture.format) {
+		texture.srv_desc.Format = d3d12_formats[texture.format].general_format;
+		base_swizzle = d3d12_formats[texture.format].swizzle;
+		texture.uav_desc.Format = d3d12_formats[texture.format].general_format;
+	} else {
+		ERR_FAIL_INDEX_V(p_view.format_override, DATA_FORMAT_MAX, RID());
+
+		ERR_FAIL_COND_V_MSG(texture.allowed_shared_formats.find(p_view.format_override) == -1, RID(),
+				"Format override is not in the list of allowed shareable formats for original texture.");
+		texture.srv_desc.Format = d3d12_formats[p_view.format_override].general_format;
+		base_swizzle = d3d12_formats[p_view.format_override].swizzle;
+		texture.uav_desc.Format = d3d12_formats[p_view.format_override].general_format;
+
+		if (texture.aliases.size()) {
+			for (int i = 0; i < texture.allowed_shared_formats.size(); i++) {
+				if (texture.allowed_shared_formats[i] == p_view.format_override) {
+					texture.resource = texture.aliases[i];
+					break;
+				}
+			}
+		}
+	}
+
+	// Apply requested swizzle (component mapping) on top of the one from the format database.
+
+	D3D12_SHADER_COMPONENT_MAPPING component_swizzles[TEXTURE_SWIZZLE_MAX] = {
+		D3D12_SHADER_COMPONENT_MAPPING_FORCE_VALUE_0, // Unused.
+		D3D12_SHADER_COMPONENT_MAPPING_FORCE_VALUE_0,
+		D3D12_SHADER_COMPONENT_MAPPING_FORCE_VALUE_1,
+		// These will be D3D12_SHADER_COMPONENT_MAPPING_FROM_MEMORY_COMPONENT_*.
+		D3D12_DECODE_SHADER_4_COMPONENT_MAPPING(0, base_swizzle),
+		D3D12_DECODE_SHADER_4_COMPONENT_MAPPING(1, base_swizzle),
+		D3D12_DECODE_SHADER_4_COMPONENT_MAPPING(2, base_swizzle),
+		D3D12_DECODE_SHADER_4_COMPONENT_MAPPING(3, base_swizzle),
+	};
+
+	texture.srv_desc.Shader4ComponentMapping = D3D12_ENCODE_SHADER_4_COMPONENT_MAPPING(
+			p_view.swizzle_r == TEXTURE_SWIZZLE_IDENTITY ? component_swizzles[TEXTURE_SWIZZLE_R] : component_swizzles[p_view.swizzle_r],
+			p_view.swizzle_g == TEXTURE_SWIZZLE_IDENTITY ? component_swizzles[TEXTURE_SWIZZLE_G] : component_swizzles[p_view.swizzle_g],
+			p_view.swizzle_b == TEXTURE_SWIZZLE_IDENTITY ? component_swizzles[TEXTURE_SWIZZLE_B] : component_swizzles[p_view.swizzle_b],
+			p_view.swizzle_a == TEXTURE_SWIZZLE_IDENTITY ? component_swizzles[TEXTURE_SWIZZLE_A] : component_swizzles[p_view.swizzle_a]);
+
+	if (p_slice_type == TEXTURE_SLICE_CUBEMAP) {
+		ERR_FAIL_COND_V_MSG(p_layer >= src_texture->layers, RID(),
+				"Specified layer is invalid for cubemap");
+		ERR_FAIL_COND_V_MSG((p_layer % 6) != 0, RID(),
+				"Specified layer must be a multiple of 6.");
+	}
+
+	// Leveraging aliasing in members of the union as much as possible.
+
+	texture.srv_desc.Texture1D.MostDetailedMip = p_mipmap;
+	texture.srv_desc.Texture1D.MipLevels = 1;
+
+	texture.uav_desc.Texture1D.MipSlice = p_mipmap;
+
+	switch (p_slice_type) {
+		case TEXTURE_SLICE_2D: {
+			if (texture.srv_desc.ViewDimension == D3D12_SRV_DIMENSION_TEXTURE2D && p_layer == 0) {
+				CRASH_COND(texture.uav_desc.ViewDimension != D3D12_UAV_DIMENSION_TEXTURE2D);
+			} else if (texture.srv_desc.ViewDimension == D3D12_SRV_DIMENSION_TEXTURE2DMS && p_layer == 0) {
+				CRASH_COND(texture.uav_desc.ViewDimension != D3D12_UAV_DIMENSION_UNKNOWN);
+			} else if ((texture.srv_desc.ViewDimension == D3D12_SRV_DIMENSION_TEXTURE2DARRAY || (texture.srv_desc.ViewDimension == D3D12_SRV_DIMENSION_TEXTURE2D && p_layer)) || texture.srv_desc.ViewDimension == D3D12_SRV_DIMENSION_TEXTURECUBE || texture.srv_desc.ViewDimension == D3D12_SRV_DIMENSION_TEXTURECUBEARRAY) {
+				texture.srv_desc.ViewDimension = D3D12_SRV_DIMENSION_TEXTURE2DARRAY;
+				texture.srv_desc.Texture2DArray.FirstArraySlice = p_layer;
+				texture.srv_desc.Texture2DArray.ArraySize = 1;
+				texture.srv_desc.Texture2DArray.PlaneSlice = 0;
+				texture.srv_desc.Texture2DArray.ResourceMinLODClamp = 0.0f;
+
+				texture.uav_desc.ViewDimension = D3D12_UAV_DIMENSION_TEXTURE2DARRAY;
+				texture.uav_desc.Texture2DArray.FirstArraySlice = p_layer;
+				texture.uav_desc.Texture2DArray.ArraySize = 1;
+				texture.uav_desc.Texture2DArray.PlaneSlice = 0;
+			} else if ((texture.srv_desc.ViewDimension == D3D12_SRV_DIMENSION_TEXTURE2DMSARRAY || (texture.srv_desc.ViewDimension == D3D12_SRV_DIMENSION_TEXTURE2DMS && p_layer))) {
+				texture.srv_desc.ViewDimension = D3D12_SRV_DIMENSION_TEXTURE2DARRAY;
+				texture.srv_desc.Texture2DMSArray.FirstArraySlice = p_layer;
+				texture.srv_desc.Texture2DMSArray.ArraySize = 1;
+
+				texture.uav_desc.ViewDimension = D3D12_UAV_DIMENSION_UNKNOWN;
+			} else {
+				CRASH_NOW();
+			}
+		} break;
+		case TEXTURE_SLICE_CUBEMAP: {
+			if (texture.srv_desc.ViewDimension == D3D12_SRV_DIMENSION_TEXTURECUBE) {
+				CRASH_COND(texture.uav_desc.ViewDimension != D3D12_UAV_DIMENSION_TEXTURE2DARRAY);
+			} else if (texture.srv_desc.ViewDimension == D3D12_SRV_DIMENSION_TEXTURECUBE || p_layer == 0) {
+				texture.srv_desc.ViewDimension = D3D12_SRV_DIMENSION_TEXTURECUBE;
+
+				CRASH_COND(texture.uav_desc.ViewDimension != D3D12_UAV_DIMENSION_TEXTURE2DARRAY);
+				texture.uav_desc.ViewDimension = D3D12_UAV_DIMENSION_TEXTURE2DARRAY;
+				texture.uav_desc.Texture2DArray.FirstArraySlice = 0;
+				texture.uav_desc.Texture2DArray.ArraySize = 6;
+				texture.uav_desc.Texture2DArray.PlaneSlice = 0;
+			} else if (texture.srv_desc.ViewDimension == D3D12_SRV_DIMENSION_TEXTURECUBEARRAY || p_layer != 0) {
+				texture.srv_desc.ViewDimension = D3D12_SRV_DIMENSION_TEXTURECUBEARRAY;
+				texture.srv_desc.TextureCubeArray.First2DArrayFace = p_layer;
+				texture.srv_desc.TextureCubeArray.NumCubes = 1;
+				texture.srv_desc.TextureCubeArray.ResourceMinLODClamp = 0.0f;
+
+				CRASH_COND(texture.uav_desc.ViewDimension != D3D12_UAV_DIMENSION_TEXTURE2DARRAY);
+				texture.uav_desc.ViewDimension = D3D12_UAV_DIMENSION_TEXTURE2DARRAY;
+				texture.uav_desc.Texture2DArray.FirstArraySlice = p_layer;
+				texture.uav_desc.Texture2DArray.ArraySize = 6;
+				texture.uav_desc.Texture2DArray.PlaneSlice = 0;
+			} else {
+				CRASH_NOW();
+			}
+		} break;
+		case TEXTURE_SLICE_3D: {
+			CRASH_COND(texture.srv_desc.ViewDimension != D3D12_SRV_DIMENSION_TEXTURE3D);
+			CRASH_COND(texture.uav_desc.ViewDimension != D3D12_UAV_DIMENSION_TEXTURE3D);
+			texture.uav_desc.Texture3D.WSize = -1;
+		} break;
+		case TEXTURE_SLICE_2D_ARRAY: {
+			CRASH_COND(texture.srv_desc.ViewDimension != D3D12_SRV_DIMENSION_TEXTURE2DARRAY);
+			texture.srv_desc.Texture2DArray.FirstArraySlice = p_layer;
+			texture.srv_desc.Texture2DArray.ArraySize = slice_layers;
+
+			CRASH_COND(texture.uav_desc.ViewDimension != D3D12_UAV_DIMENSION_TEXTURE2DARRAY);
+			texture.uav_desc.Texture2DArray.FirstArraySlice = p_layer;
+			texture.uav_desc.Texture2DArray.ArraySize = slice_layers;
+		} break;
+	}
+
+	texture.owner = p_with_texture;
+	RID id = texture_owner.make_rid(texture);
+#ifdef DEV_ENABLED
+	set_resource_name(id, "RID:" + itos(id.get_id()));
+#endif
+	_add_dependency(id, p_with_texture);
+
+	return id;
+}
+
+Error RenderingDeviceD3D12::texture_update(RID p_texture, uint32_t p_layer, const Vector<uint8_t> &p_data, BitField<BarrierMask> p_post_barrier) {
+	ERR_FAIL_COND_V_MSG((draw_list || compute_list), ERR_INVALID_PARAMETER,
+			"Updating textures is forbidden during creation of a draw or compute list");
+
+	Texture *texture = texture_owner.get_or_null(p_texture);
+	ERR_FAIL_NULL_V(texture, ERR_INVALID_PARAMETER);
+
+	if (texture->owner != RID()) {
+		texture = texture_owner.get_or_null(texture->owner);
+		ERR_FAIL_NULL_V(texture, ERR_BUG); // This is a bug.
+	}
+
+	ID3D12GraphicsCommandList *command_list = frames[frame].draw_command_list.Get();
+
+	uint32_t subresource = D3D12CalcSubresource(0, p_layer, 0, texture->mipmaps, texture->layers);
+	_resource_transition_batch(texture, subresource, texture->planes, D3D12_RESOURCE_STATE_COPY_DEST);
+	_resource_transitions_flush(command_list);
+	Error err = _texture_update(texture, p_layer, p_data, p_post_barrier, command_list);
+
+	return err;
+}
+
+static _ALWAYS_INLINE_ void _copy_region(uint8_t const *__restrict p_src, uint8_t *__restrict p_dst, uint32_t p_src_x, uint32_t p_src_y, uint32_t p_src_w, uint32_t p_src_h, uint32_t p_src_full_w, uint32_t p_dst_pitch, uint32_t p_unit_size) {
+	uint32_t src_offset = (p_src_y * p_src_full_w + p_src_x) * p_unit_size;
+	uint32_t dst_offset = 0;
+	for (uint32_t y = p_src_h; y > 0; y--) {
+		uint8_t const *__restrict src = p_src + src_offset;
+		uint8_t *__restrict dst = p_dst + dst_offset;
+		for (uint32_t x = p_src_w * p_unit_size; x > 0; x--) {
+			*dst = *src;
+			src++;
+			dst++;
+		}
+		src_offset += p_src_full_w * p_unit_size;
+		dst_offset += p_dst_pitch;
+	}
+}
+
+Error RenderingDeviceD3D12::_texture_update(Texture *p_texture, uint32_t p_layer, const Vector<uint8_t> &p_data, BitField<BarrierMask> p_post_barrier, ID3D12GraphicsCommandList *p_command_list) {
+	_THREAD_SAFE_METHOD_
+
+	ERR_FAIL_COND_V_MSG(p_texture->bound, ERR_CANT_ACQUIRE_RESOURCE,
+			"Texture can't be updated while a render pass that uses it is being created. Ensure render pass is finalized (and that it was created with RENDER_PASS_CONTENTS_FINISH) to unbind this texture.");
+
+	ERR_FAIL_COND_V_MSG(!(p_texture->usage_flags & TEXTURE_USAGE_CAN_UPDATE_BIT), ERR_INVALID_PARAMETER,
+			"Texture requires the TEXTURE_USAGE_CAN_UPDATE_BIT in order to be updatable.");
+
+	uint32_t layer_count = p_texture->layers;
+	if (p_texture->type == TEXTURE_TYPE_CUBE || p_texture->type == TEXTURE_TYPE_CUBE_ARRAY) {
+		layer_count *= 6;
+	}
+	ERR_FAIL_COND_V(p_layer >= layer_count, ERR_INVALID_PARAMETER);
+
+	uint32_t width, height;
+	uint32_t image_size = get_image_format_required_size(p_texture->format, p_texture->width, p_texture->height, p_texture->depth, p_texture->mipmaps, &width, &height);
+	uint32_t required_size = image_size;
+	uint32_t required_align = get_compressed_image_format_block_byte_size(p_texture->format);
+	if (required_align == 1) {
+		required_align = get_image_format_pixel_size(p_texture->format);
+	}
+	if ((required_align % 4) != 0) { // Alignment rules are really strange.
+		required_align *= 4;
+	}
+
+	required_align = ALIGN(required_align, D3D12_TEXTURE_DATA_PLACEMENT_ALIGNMENT);
+
+	ERR_FAIL_COND_V_MSG(required_size != (uint32_t)p_data.size(), ERR_INVALID_PARAMETER,
+			"Required size for texture update (" + itos(required_size) + ") does not match data supplied size (" + itos(p_data.size()) + ").");
+
+	uint32_t region_size = texture_upload_region_size_px;
+
+	const uint8_t *r = p_data.ptr();
+
+	uint32_t mipmap_offset = 0;
+
+	uint32_t logic_width = p_texture->width;
+	uint32_t logic_height = p_texture->height;
+
+	for (uint32_t mm_i = 0; mm_i < p_texture->mipmaps; mm_i++) {
+		uint32_t depth;
+		uint32_t image_total = get_image_format_required_size(p_texture->format, p_texture->width, p_texture->height, p_texture->depth, mm_i + 1, &width, &height, &depth);
+
+		const uint8_t *read_ptr_mipmap = r + mipmap_offset;
+		image_size = image_total - mipmap_offset;
+
+		UINT dst_subresource = D3D12CalcSubresource(mm_i, p_layer, 0, p_texture->mipmaps, p_texture->layers);
+		CD3DX12_TEXTURE_COPY_LOCATION copy_dst(p_texture->resource, dst_subresource);
+
+		for (uint32_t z = 0; z < depth; z++) { // For 3D textures, depth may be > 0.
+
+			const uint8_t *read_ptr = read_ptr_mipmap + image_size * z / depth;
+
+			for (uint32_t y = 0; y < height; y += region_size) {
+				for (uint32_t x = 0; x < width; x += region_size) {
+					uint32_t region_w = MIN(region_size, width - x);
+					uint32_t region_h = MIN(region_size, height - y);
+
+					uint32_t pixel_size = get_image_format_pixel_size(p_texture->format);
+					uint32_t block_w, block_h;
+					get_compressed_image_format_block_dimensions(p_texture->format, block_w, block_h);
+
+					uint32_t region_pitch = (region_w * pixel_size * block_w) >> get_compressed_image_format_pixel_rshift(p_texture->format);
+					region_pitch = ALIGN(region_pitch, D3D12_TEXTURE_DATA_PITCH_ALIGNMENT);
+					uint32_t to_allocate = region_pitch * region_h;
+
+					uint32_t alloc_offset, alloc_size;
+					Error err = _staging_buffer_allocate(to_allocate, required_align, alloc_offset, alloc_size, false);
+					ERR_FAIL_COND_V(err, ERR_CANT_CREATE);
+
+					uint8_t *write_ptr;
+
+					{ // Map.
+						void *data_ptr = nullptr;
+						HRESULT res = staging_buffer_blocks[staging_buffer_current].resource->Map(0, &VOID_RANGE, &data_ptr);
+						ERR_FAIL_COND_V_MSG(res, ERR_CANT_CREATE, "Map failed with error " + vformat("0x%08ux", res) + ".");
+						write_ptr = (uint8_t *)data_ptr;
+						write_ptr += alloc_offset;
+					}
+
+					ERR_FAIL_COND_V(region_w % block_w, ERR_BUG);
+					ERR_FAIL_COND_V(region_pitch % block_w, ERR_BUG);
+					ERR_FAIL_COND_V(region_h % block_h, ERR_BUG);
+
+					if (block_w != 1 || block_h != 1) {
+						// Compressed image (functions).
+						// Must copy a block region.
+
+						uint32_t block_size = get_compressed_image_format_block_byte_size(p_texture->format);
+						// Re-create current variables in blocky format.
+						uint32_t xb = x / block_w;
+						uint32_t yb = y / block_h;
+						uint32_t wb = width / block_w;
+						// Uint32_t hb = height / block_h;.
+						uint32_t region_wb = region_w / block_w;
+						uint32_t region_hb = region_h / block_h;
+						_copy_region(read_ptr, write_ptr, xb, yb, region_wb, region_hb, wb, region_pitch, block_size);
+					} else {
+						// Regular image (pixels).
+						// Must copy a pixel region.
+						_copy_region(read_ptr, write_ptr, x, y, region_w, region_h, width, region_pitch, pixel_size);
+					}
+
+					{ // Unmap.
+						staging_buffer_blocks[staging_buffer_current].resource->Unmap(0, &VOID_RANGE);
+					}
+
+					D3D12_PLACED_SUBRESOURCE_FOOTPRINT src_footprint = {};
+					src_footprint.Offset = alloc_offset;
+					src_footprint.Footprint = CD3DX12_SUBRESOURCE_FOOTPRINT(
+							d3d12_formats[p_texture->format].family,
+							region_w,
+							region_h,
+							1,
+							region_pitch);
+					CD3DX12_TEXTURE_COPY_LOCATION copy_src(staging_buffer_blocks[staging_buffer_current].resource, src_footprint);
+
+					CD3DX12_BOX src_box(0, 0, region_w, region_h);
+					p_command_list->CopyTextureRegion(&copy_dst, x, y, z, &copy_src, &src_box);
+
+					staging_buffer_blocks.write[staging_buffer_current].fill_amount = alloc_offset + alloc_size;
+				}
+			}
+		}
+
+		mipmap_offset = image_total;
+		logic_width = MAX(1u, logic_width >> 1);
+		logic_height = MAX(1u, logic_height >> 1);
+	}
+
+	return OK;
+}
+
+Vector<uint8_t> RenderingDeviceD3D12::_texture_get_data_from_image(Texture *tex, uint32_t p_layer, bool p_2d) {
+	uint32_t width, height, depth;
+	uint32_t image_size = get_image_format_required_size(tex->format, tex->width, tex->height, p_2d ? 1 : tex->depth, tex->mipmaps, &width, &height, &depth);
+
+	Vector<uint8_t> image_data;
+	image_data.resize(image_size);
+
+	D3D12_RESOURCE_DESC res_desc = tex->resource->GetDesc();
+
+	uint32_t blockw, blockh;
+	get_compressed_image_format_block_dimensions(tex->format, blockw, blockh);
+	uint32_t block_size = get_compressed_image_format_block_byte_size(tex->format);
+	uint32_t pixel_size = get_image_format_pixel_size(tex->format);
+
+	{
+		uint8_t *w = image_data.ptrw();
+
+		uint32_t mipmap_offset = 0;
+		for (uint32_t mm_i = 0; mm_i < tex->mipmaps; mm_i++) {
+			uint32_t image_total = get_image_format_required_size(tex->format, tex->width, tex->height, p_2d ? 1 : tex->depth, mm_i + 1, &width, &height, &depth);
+
+			uint8_t *write_ptr_mipmap = w + mipmap_offset;
+			image_size = image_total - mipmap_offset;
+
+			UINT subresource = 0;
+
+			uint64_t image_total_src = 0;
+			D3D12_PLACED_SUBRESOURCE_FOOTPRINT layout = {};
+			device->GetCopyableFootprints(
+					&res_desc,
+					subresource,
+					1,
+					0,
+					&layout,
+					nullptr,
+					nullptr,
+					&image_total_src);
+
+			void *img_mem;
+			HRESULT res = tex->resource->Map(subresource, nullptr, &img_mem);
+			ERR_FAIL_COND_V_MSG(res, Vector<uint8_t>(), "Map failed with error " + vformat("0x%08ux", res) + ".");
+
+			for (uint32_t z = 0; z < depth; z++) {
+				uint8_t *write_ptr = write_ptr_mipmap + z * image_size / depth;
+				const uint8_t *slice_read_ptr = ((uint8_t *)img_mem) + layout.Offset + z * image_total_src / depth;
+
+				if (block_size > 1) {
+					// Compressed.
+					uint32_t line_width = (block_size * (width / blockw));
+					for (uint32_t y = 0; y < height / blockh; y++) {
+						const uint8_t *rptr = slice_read_ptr + y * layout.Footprint.RowPitch;
+						uint8_t *wptr = write_ptr + y * line_width;
+
+						memcpy(wptr, rptr, line_width);
+					}
+
+				} else {
+					// Uncompressed.
+					for (uint32_t y = 0; y < height; y++) {
+						const uint8_t *rptr = slice_read_ptr + y * layout.Footprint.RowPitch;
+						uint8_t *wptr = write_ptr + y * pixel_size * width;
+						memcpy(wptr, rptr, (uint64_t)pixel_size * width);
+					}
+				}
+			}
+
+			tex->resource->Unmap(subresource, nullptr);
+
+			mipmap_offset = image_total;
+		}
+	}
+
+	return image_data;
+}
+
+Vector<uint8_t> RenderingDeviceD3D12::texture_get_data(RID p_texture, uint32_t p_layer) {
+	_THREAD_SAFE_METHOD_
+
+	Texture *tex = texture_owner.get_or_null(p_texture);
+	ERR_FAIL_NULL_V(tex, Vector<uint8_t>());
+
+	ERR_FAIL_COND_V_MSG(tex->bound, Vector<uint8_t>(),
+			"Texture can't be retrieved while a render pass that uses it is being created. Ensure render pass is finalized (and that it was created with RENDER_PASS_CONTENTS_FINISH) to unbind this texture.");
+	ERR_FAIL_COND_V_MSG(!(tex->usage_flags & TEXTURE_USAGE_CAN_COPY_FROM_BIT), Vector<uint8_t>(),
+			"Texture requires the TEXTURE_USAGE_CAN_COPY_FROM_BIT in order to be retrieved.");
+
+	uint32_t layer_count = tex->layers;
+	if (tex->type == TEXTURE_TYPE_CUBE || tex->type == TEXTURE_TYPE_CUBE_ARRAY) {
+		layer_count *= 6;
+	}
+	ERR_FAIL_COND_V(p_layer >= layer_count, Vector<uint8_t>());
+
+	if (tex->usage_flags & TEXTURE_USAGE_CPU_READ_BIT) {
+		// Does not need anything fancy, map and read.
+		return _texture_get_data_from_image(tex, p_layer);
+	} else {
+		// Compute total image size.
+		uint32_t width, height, depth;
+		uint32_t final_buffer_size = get_image_format_required_size(tex->format, tex->width, tex->height, tex->depth, tex->mipmaps, &width, &height, &depth);
+
+		uint32_t block_w, block_h;
+		get_compressed_image_format_block_dimensions(tex->format, block_w, block_h);
+		uint32_t alignment = D3D12_TEXTURE_DATA_PITCH_ALIGNMENT;
+
+		// We'll use a potentially bigger buffer to account for mip sizes in which we need to use a bigger pitch to keep D3D12 happy.
+		uint32_t buffer_size = 0;
+		{
+			uint32_t computed_h = tex->height;
+			uint32_t computed_d = tex->depth;
+
+			uint32_t prev_size = 0;
+			for (uint32_t i = 0; i < tex->mipmaps; i++) {
+				uint32_t image_size = get_image_format_required_size(tex->format, tex->width, tex->height, tex->depth, i + 1);
+				uint32_t inferred_row_pitch = image_size / (computed_h * computed_d) * block_h;
+				uint32_t adjusted_row_pitch = ALIGN(inferred_row_pitch, alignment);
+				uint32_t adjusted_image_size = adjusted_row_pitch / block_h * computed_h * tex->depth;
+				uint32_t size = adjusted_image_size - prev_size;
+				prev_size = image_size;
+
+				buffer_size = ALIGN(buffer_size + size, D3D12_TEXTURE_DATA_PLACEMENT_ALIGNMENT);
+
+				computed_h = MAX(1u, computed_h >> 1);
+				computed_d = MAX(1u, computed_d >> 1);
+			}
+		}
+
+		// Allocate buffer.
+		ID3D12GraphicsCommandList *command_list = frames[frame].draw_command_list.Get(); // Makes more sense to retrieve.
+
+		Buffer tmp_buffer;
+		Error err = _buffer_allocate(&tmp_buffer, buffer_size, D3D12_RESOURCE_STATE_COPY_DEST, D3D12_HEAP_TYPE_READBACK);
+		ERR_FAIL_COND_V(err != OK, Vector<uint8_t>());
+
+		for (uint32_t i = 0; i < tex->mipmaps; i++) {
+			uint32_t subresource = D3D12CalcSubresource(i, p_layer, 0, tex->owner_mipmaps, tex->owner_layers);
+			_resource_transition_batch(tex, subresource, tex->planes, D3D12_RESOURCE_STATE_COPY_SOURCE);
+		}
+		_resource_transitions_flush(command_list);
+
+		uint32_t computed_w = tex->width;
+		uint32_t computed_h = tex->height;
+		uint32_t computed_d = tex->depth;
+
+		uint32_t prev_size = 0;
+		uint32_t offset = 0;
+		for (uint32_t i = 0; i < tex->mipmaps; i++) {
+			uint32_t image_size = get_image_format_required_size(tex->format, tex->width, tex->height, tex->depth, i + 1);
+			uint32_t size = image_size - prev_size;
+			prev_size = image_size;
+
+			D3D12_PLACED_SUBRESOURCE_FOOTPRINT dst_footprint = {};
+			dst_footprint.Offset = offset;
+			dst_footprint.Footprint.Width = MAX(block_w, computed_w);
+			dst_footprint.Footprint.Height = MAX(block_h, computed_h);
+			dst_footprint.Footprint.Depth = computed_d;
+			uint32_t inferred_row_pitch = size / (dst_footprint.Footprint.Height * computed_d) * block_h;
+			dst_footprint.Footprint.RowPitch = inferred_row_pitch;
+			dst_footprint.Footprint.Format = d3d12_formats[tex->format].family;
+			CD3DX12_TEXTURE_COPY_LOCATION copy_dst(tmp_buffer.resource, dst_footprint);
+
+			UINT src_subresource = D3D12CalcSubresource(i, p_layer, 0, tex->owner_mipmaps, tex->owner_layers);
+			CD3DX12_TEXTURE_COPY_LOCATION copy_src(tex->resource, src_subresource);
+
+			if (dst_footprint.Footprint.RowPitch % alignment) {
+				// Dammit! Now we must copy with an imposed pitch and then adjust row by row.
+				copy_dst.PlacedFootprint.Offset = ALIGN(offset, D3D12_TEXTURE_DATA_PLACEMENT_ALIGNMENT);
+
+				uint32_t adjusted_row_pitch = ALIGN(inferred_row_pitch, alignment);
+				copy_dst.PlacedFootprint.Footprint.RowPitch = adjusted_row_pitch;
+				command_list->CopyTextureRegion(&copy_dst, 0, 0, 0, &copy_src, nullptr);
+				_flush(true);
+
+				void *buffer_mem;
+				uint32_t adjusted_size = adjusted_row_pitch / block_h * dst_footprint.Footprint.Height * computed_d;
+				CD3DX12_RANGE range(offset, copy_dst.PlacedFootprint.Offset + adjusted_size);
+				HRESULT res = tmp_buffer.resource->Map(0, &range, &buffer_mem);
+				ERR_FAIL_COND_V_MSG(res, Vector<uint8_t>(), "Map failed with error " + vformat("0x%08ux", res) + ".");
+
+				for (uint32_t j = 0; j < dst_footprint.Footprint.Height / block_h * computed_d; j++) {
+					memmove((uint8_t *)buffer_mem + offset + j * inferred_row_pitch, (uint8_t *)buffer_mem + copy_dst.PlacedFootprint.Offset + j * adjusted_row_pitch, inferred_row_pitch);
+				}
+
+				tmp_buffer.resource->Unmap(0, nullptr);
+			} else if (offset % D3D12_TEXTURE_DATA_PLACEMENT_ALIGNMENT) {
+				// Row pitch is fine, but offset alignment is not good.
+				copy_dst.PlacedFootprint.Offset = ALIGN(offset, D3D12_TEXTURE_DATA_PLACEMENT_ALIGNMENT);
+
+				command_list->CopyTextureRegion(&copy_dst, 0, 0, 0, &copy_src, nullptr);
+				_flush(true);
+
+				void *buffer_mem;
+				CD3DX12_RANGE range(copy_dst.PlacedFootprint.Offset, size);
+				HRESULT res = tmp_buffer.resource->Map(0, &range, &buffer_mem);
+				ERR_FAIL_COND_V_MSG(res, Vector<uint8_t>(), "Map failed with error " + vformat("0x%08ux", res) + ".");
+
+				memmove((uint8_t *)buffer_mem + offset, (uint8_t *)buffer_mem + copy_dst.PlacedFootprint.Offset, size);
+
+				tmp_buffer.resource->Unmap(0, nullptr);
+			} else {
+				command_list->CopyTextureRegion(&copy_dst, 0, 0, 0, &copy_src, nullptr);
+			}
+
+			computed_w = MAX(1u, computed_w >> 1);
+			computed_h = MAX(1u, computed_h >> 1);
+			computed_d = MAX(1u, computed_d >> 1);
+			offset += size;
+		}
+
+		_flush(true);
+
+		void *buffer_mem;
+		CD3DX12_RANGE range(0, final_buffer_size);
+		HRESULT res = tmp_buffer.resource->Map(0, &range, &buffer_mem);
+		ERR_FAIL_COND_V_MSG(res, Vector<uint8_t>(), "Map failed with error " + vformat("0x%08ux", res) + ".");
+
+		Vector<uint8_t> buffer_data;
+		buffer_data.resize(final_buffer_size);
+		{
+			uint8_t *w = buffer_data.ptrw();
+			memcpy(w, buffer_mem, final_buffer_size);
+		}
+
+		tmp_buffer.resource->Unmap(0, nullptr);
+
+		_buffer_free(&tmp_buffer);
+
+		return buffer_data;
+	}
+}
+
+bool RenderingDeviceD3D12::texture_is_shared(RID p_texture) {
+	_THREAD_SAFE_METHOD_
+
+	Texture *tex = texture_owner.get_or_null(p_texture);
+	ERR_FAIL_NULL_V(tex, false);
+	return tex->owner.is_valid();
+}
+
+bool RenderingDeviceD3D12::texture_is_valid(RID p_texture) {
+	return texture_owner.owns(p_texture);
+}
+
+RenderingDevice::TextureFormat RenderingDeviceD3D12::texture_get_format(RID p_texture) {
+	_THREAD_SAFE_METHOD_
+
+	Texture *tex = texture_owner.get_or_null(p_texture);
+	ERR_FAIL_NULL_V(tex, TextureFormat());
+
+	TextureFormat tf;
+
+	tf.format = tex->format;
+	tf.width = tex->width;
+	tf.height = tex->height;
+	tf.depth = tex->depth;
+	tf.array_layers = tex->layers;
+	tf.mipmaps = tex->mipmaps;
+	tf.texture_type = tex->type;
+	tf.samples = tex->samples;
+	tf.usage_bits = tex->usage_flags;
+	tf.shareable_formats = tex->allowed_shared_formats;
+	tf.is_resolve_buffer = tex->is_resolve_buffer;
+
+	return tf;
+}
+
+Size2i RenderingDeviceD3D12::texture_size(RID p_texture) {
+	_THREAD_SAFE_METHOD_
+
+	Texture *tex = texture_owner.get_or_null(p_texture);
+	ERR_FAIL_NULL_V(tex, Size2i());
+	return Size2i(tex->width, tex->height);
+}
+
+uint64_t RenderingDeviceD3D12::texture_get_native_handle(RID p_texture) {
+	_THREAD_SAFE_METHOD_
+
+	Texture *tex = texture_owner.get_or_null(p_texture);
+	ERR_FAIL_NULL_V(tex, 0);
+
+	return (uint64_t)tex->resource;
+}
+
+Error RenderingDeviceD3D12::texture_copy(RID p_from_texture, RID p_to_texture, const Vector3 &p_from, const Vector3 &p_to, const Vector3 &p_size, uint32_t p_src_mipmap, uint32_t p_dst_mipmap, uint32_t p_src_layer, uint32_t p_dst_layer, BitField<BarrierMask> p_post_barrier) {
+	_THREAD_SAFE_METHOD_
+
+	Texture *src_tex = texture_owner.get_or_null(p_from_texture);
+	ERR_FAIL_NULL_V(src_tex, ERR_INVALID_PARAMETER);
+
+	ERR_FAIL_COND_V_MSG(src_tex->bound, ERR_INVALID_PARAMETER,
+			"Source texture can't be copied while a render pass that uses it is being created. Ensure render pass is finalized (and that it was created with RENDER_PASS_CONTENTS_FINISH) to unbind this texture.");
+	ERR_FAIL_COND_V_MSG(!(src_tex->usage_flags & TEXTURE_USAGE_CAN_COPY_FROM_BIT), ERR_INVALID_PARAMETER,
+			"Source texture requires the TEXTURE_USAGE_CAN_COPY_FROM_BIT in order to be retrieved.");
+
+	uint32_t src_layer_count = src_tex->layers;
+	uint32_t src_width, src_height, src_depth;
+	get_image_format_required_size(src_tex->format, src_tex->width, src_tex->height, src_tex->depth, p_src_mipmap + 1, &src_width, &src_height, &src_depth);
+	if (src_tex->type == TEXTURE_TYPE_CUBE || src_tex->type == TEXTURE_TYPE_CUBE_ARRAY) {
+		src_layer_count *= 6;
+	}
+
+	ERR_FAIL_COND_V(p_from.x < 0 || p_from.x + p_size.x > src_width, ERR_INVALID_PARAMETER);
+	ERR_FAIL_COND_V(p_from.y < 0 || p_from.y + p_size.y > src_height, ERR_INVALID_PARAMETER);
+	ERR_FAIL_COND_V(p_from.z < 0 || p_from.z + p_size.z > src_depth, ERR_INVALID_PARAMETER);
+	ERR_FAIL_COND_V(p_src_mipmap >= src_tex->mipmaps, ERR_INVALID_PARAMETER);
+	ERR_FAIL_COND_V(p_src_layer >= src_layer_count, ERR_INVALID_PARAMETER);
+
+	Texture *dst_tex = texture_owner.get_or_null(p_to_texture);
+	ERR_FAIL_NULL_V(dst_tex, ERR_INVALID_PARAMETER);
+
+	ERR_FAIL_COND_V_MSG(dst_tex->bound, ERR_INVALID_PARAMETER,
+			"Destination texture can't be copied while a render pass that uses it is being created. Ensure render pass is finalized (and that it was created with RENDER_PASS_CONTENTS_FINISH) to unbind this texture.");
+	ERR_FAIL_COND_V_MSG(!(dst_tex->usage_flags & TEXTURE_USAGE_CAN_COPY_TO_BIT), ERR_INVALID_PARAMETER,
+			"Destination texture requires the TEXTURE_USAGE_CAN_COPY_TO_BIT in order to be retrieved.");
+
+	uint32_t dst_layer_count = dst_tex->layers;
+	uint32_t dst_width, dst_height, dst_depth;
+	get_image_format_required_size(dst_tex->format, dst_tex->width, dst_tex->height, dst_tex->depth, p_dst_mipmap + 1, &dst_width, &dst_height, &dst_depth);
+	if (dst_tex->type == TEXTURE_TYPE_CUBE || dst_tex->type == TEXTURE_TYPE_CUBE_ARRAY) {
+		dst_layer_count *= 6;
+	}
+
+	ERR_FAIL_COND_V(p_to.x < 0 || p_to.x + p_size.x > dst_width, ERR_INVALID_PARAMETER);
+	ERR_FAIL_COND_V(p_to.y < 0 || p_to.y + p_size.y > dst_height, ERR_INVALID_PARAMETER);
+	ERR_FAIL_COND_V(p_to.z < 0 || p_to.z + p_size.z > dst_depth, ERR_INVALID_PARAMETER);
+	ERR_FAIL_COND_V(p_dst_mipmap >= dst_tex->mipmaps, ERR_INVALID_PARAMETER);
+	ERR_FAIL_COND_V(p_dst_layer >= dst_layer_count, ERR_INVALID_PARAMETER);
+
+	ERR_FAIL_COND_V_MSG((src_tex->usage_flags & TEXTURE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT) != (dst_tex->usage_flags & TEXTURE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT), ERR_INVALID_PARAMETER,
+			"Source and destination texture must be of the same type (color or depth).");
+
+	ID3D12GraphicsCommandList *command_list = frames[frame].draw_command_list.Get();
+
+	uint32_t src_subresource = D3D12CalcSubresource(p_src_mipmap, p_src_layer, 0, src_tex->owner_mipmaps, src_tex->owner_layers);
+	_resource_transition_batch(src_tex, src_subresource, src_tex->planes, D3D12_RESOURCE_STATE_COPY_SOURCE);
+
+	uint32_t dst_subresource = D3D12CalcSubresource(p_dst_mipmap, p_dst_layer, 0, dst_tex->owner_mipmaps, dst_tex->owner_layers);
+	_resource_transition_batch(dst_tex, dst_subresource, dst_tex->planes, D3D12_RESOURCE_STATE_COPY_DEST);
+
+	_resource_transitions_flush(command_list);
+
+	{
+		CD3DX12_TEXTURE_COPY_LOCATION src_location(src_tex->resource, src_subresource);
+		CD3DX12_BOX src_box(p_from.x, p_from.y, p_from.z, p_from.x + p_size.x, p_from.y + p_size.y, p_from.z + p_size.z);
+		CD3DX12_TEXTURE_COPY_LOCATION dst_location(dst_tex->resource, dst_subresource);
+		command_list->CopyTextureRegion(
+				&dst_location,
+				p_to.x, p_to.y, p_to.z,
+				&src_location,
+				&src_box);
+	}
+
+	return OK;
+}
+
+Error RenderingDeviceD3D12::texture_resolve_multisample(RID p_from_texture, RID p_to_texture, BitField<BarrierMask> p_post_barrier) {
+	_THREAD_SAFE_METHOD_
+
+	Texture *src_tex = texture_owner.get_or_null(p_from_texture);
+	ERR_FAIL_NULL_V(src_tex, ERR_INVALID_PARAMETER);
+
+	ERR_FAIL_COND_V_MSG(src_tex->bound, ERR_INVALID_PARAMETER,
+			"Source texture can't be copied while a render pass that uses it is being created. Ensure render pass is finalized (and that it was created with RENDER_PASS_CONTENTS_FINISH) to unbind this texture.");
+	ERR_FAIL_COND_V_MSG(!(src_tex->usage_flags & TEXTURE_USAGE_CAN_COPY_FROM_BIT), ERR_INVALID_PARAMETER,
+			"Source texture requires the TEXTURE_USAGE_CAN_COPY_FROM_BIT in order to be retrieved.");
+
+	ERR_FAIL_COND_V_MSG(src_tex->type != TEXTURE_TYPE_2D, ERR_INVALID_PARAMETER, "Source texture must be 2D (or a slice of a 3D/Cube texture)");
+	ERR_FAIL_COND_V_MSG(src_tex->samples == TEXTURE_SAMPLES_1, ERR_INVALID_PARAMETER, "Source texture must be multisampled.");
+
+	Texture *dst_tex = texture_owner.get_or_null(p_to_texture);
+	ERR_FAIL_NULL_V(dst_tex, ERR_INVALID_PARAMETER);
+
+	ERR_FAIL_COND_V_MSG(dst_tex->bound, ERR_INVALID_PARAMETER,
+			"Destination texture can't be copied while a render pass that uses it is being created. Ensure render pass is finalized (and that it was created with RENDER_PASS_CONTENTS_FINISH) to unbind this texture.");
+	ERR_FAIL_COND_V_MSG(!(dst_tex->usage_flags & TEXTURE_USAGE_CAN_COPY_TO_BIT), ERR_INVALID_PARAMETER,
+			"Destination texture requires the TEXTURE_USAGE_CAN_COPY_TO_BIT in order to be retrieved.");
+
+	ERR_FAIL_COND_V_MSG(dst_tex->type != TEXTURE_TYPE_2D, ERR_INVALID_PARAMETER, "Destination texture must be 2D (or a slice of a 3D/Cube texture).");
+	ERR_FAIL_COND_V_MSG(dst_tex->samples != TEXTURE_SAMPLES_1, ERR_INVALID_PARAMETER, "Destination texture must not be multisampled.");
+
+	ERR_FAIL_COND_V_MSG(src_tex->format != dst_tex->format, ERR_INVALID_PARAMETER, "Source and Destination textures must be the same format.");
+	ERR_FAIL_COND_V_MSG(src_tex->width != dst_tex->width && src_tex->height != dst_tex->height && src_tex->depth != dst_tex->depth, ERR_INVALID_PARAMETER, "Source and Destination textures must have the same dimensions.");
+
+	ERR_FAIL_COND_V_MSG((src_tex->usage_flags & TEXTURE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT) != (dst_tex->usage_flags & TEXTURE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT), ERR_INVALID_PARAMETER,
+			"Source and destination texture must be of the same type (color or depth).");
+
+	ID3D12GraphicsCommandList *command_list = frames[frame].draw_command_list.Get();
+
+	uint32_t src_subresource = D3D12CalcSubresource(src_tex->base_mipmap, src_tex->base_layer, 0, src_tex->owner_mipmaps, src_tex->owner_layers);
+	_resource_transition_batch(src_tex, src_subresource, src_tex->planes, D3D12_RESOURCE_STATE_RESOLVE_SOURCE);
+
+	uint32_t dst_subresource = D3D12CalcSubresource(dst_tex->base_mipmap, dst_tex->base_layer, 0, dst_tex->owner_mipmaps, dst_tex->owner_layers);
+	_resource_transition_batch(dst_tex, dst_subresource, dst_tex->planes, D3D12_RESOURCE_STATE_RESOLVE_DEST);
+
+	_resource_transitions_flush(command_list);
+
+	command_list->ResolveSubresource(dst_tex->resource, dst_subresource, src_tex->resource, src_subresource, d3d12_formats[src_tex->format].general_format);
+
+	return OK;
+}
+
+Error RenderingDeviceD3D12::texture_clear(RID p_texture, const Color &p_color, uint32_t p_base_mipmap, uint32_t p_mipmaps, uint32_t p_base_layer, uint32_t p_layers, BitField<BarrierMask> p_post_barrier) {
+	_THREAD_SAFE_METHOD_
+
+	Texture *src_tex = texture_owner.get_or_null(p_texture);
+	ERR_FAIL_NULL_V(src_tex, ERR_INVALID_PARAMETER);
+
+	ERR_FAIL_COND_V_MSG(src_tex->bound, ERR_INVALID_PARAMETER,
+			"Source texture can't be cleared while a render pass that uses it is being created. Ensure render pass is finalized (and that it was created with RENDER_PASS_CONTENTS_FINISH) to unbind this texture.");
+
+	ERR_FAIL_COND_V(p_layers == 0, ERR_INVALID_PARAMETER);
+	ERR_FAIL_COND_V(p_mipmaps == 0, ERR_INVALID_PARAMETER);
+
+	ERR_FAIL_COND_V_MSG(!(src_tex->usage_flags & TEXTURE_USAGE_CAN_COPY_TO_BIT), ERR_INVALID_PARAMETER,
+			"Source texture requires the TEXTURE_USAGE_CAN_COPY_TO_BIT in order to be cleared.");
+
+	uint32_t src_layer_count = src_tex->layers;
+	if (src_tex->type == TEXTURE_TYPE_CUBE || src_tex->type == TEXTURE_TYPE_CUBE_ARRAY) {
+		src_layer_count *= 6;
+	}
+
+	ERR_FAIL_COND_V(p_base_mipmap + p_mipmaps > src_tex->mipmaps, ERR_INVALID_PARAMETER);
+	ERR_FAIL_COND_V(p_base_layer + p_layers > src_layer_count, ERR_INVALID_PARAMETER);
+
+	if ((src_tex->usage_flags & TEXTURE_USAGE_COLOR_ATTACHMENT_BIT)) {
+		// Clear via RTV.
+
+		if (frames[frame].desc_heap_walkers.rtv.is_at_eof()) {
+			if (!frames[frame].desc_heaps_exhausted_reported.rtv) {
+				frames[frame].desc_heaps_exhausted_reported.rtv = true;
+				ERR_FAIL_V_MSG(ERR_BUSY,
+						"Cannot clear texture because there's no enough room in current frame's RENDER TARGET descriptors heap.\n"
+						"Please increase the value of the rendering/rendering_device/d3d12/max_misc_descriptors_per_frame project setting.");
+			} else {
+				return ERR_BUSY;
+			}
+		}
+
+		D3D12_RENDER_TARGET_VIEW_DESC rtv_desc = _make_rtv_for_texture(src_tex, p_base_mipmap, p_base_layer, p_layers);
+		rtv_desc.Format = src_tex->owner_uav_desc.Format;
+
+		ID3D12GraphicsCommandList *command_list = frames[frame].draw_command_list.Get();
+
+		for (uint32_t i = 0; i < p_layers; i++) {
+			for (uint32_t j = 0; j < p_mipmaps; j++) {
+				uint32_t subresource = D3D12CalcSubresource(src_tex->base_mipmap + p_base_mipmap + j, src_tex->base_layer + p_base_layer + i, 0, src_tex->owner_mipmaps, src_tex->owner_layers);
+				_resource_transition_batch(src_tex, subresource, src_tex->planes, D3D12_RESOURCE_STATE_RENDER_TARGET, src_tex->owner_resource);
+			}
+		}
+		_resource_transitions_flush(command_list);
+
+		device->CreateRenderTargetView(
+				src_tex->owner_resource,
+				&rtv_desc,
+				frames[frame].desc_heap_walkers.rtv.get_curr_cpu_handle());
+		command_list->ClearRenderTargetView(
+				frames[frame].desc_heap_walkers.rtv.get_curr_cpu_handle(),
+				p_color.components,
+				0,
+				nullptr);
+		frames[frame].desc_heap_walkers.rtv.advance();
+	} else {
+		// Clear via UAV.
+
+		if (frames[frame].desc_heap_walkers.resources.is_at_eof()) {
+			if (!frames[frame].desc_heaps_exhausted_reported.resources) {
+				frames[frame].desc_heaps_exhausted_reported.resources = true;
+				ERR_FAIL_V_MSG(ERR_BUSY,
+						"Cannot clear texture because there's no enough room in current frame's RESOURCE descriptors heap.\n"
+						"Please increase the value of the rendering/rendering_device/d3d12/max_resource_descriptors_per_frame project setting.");
+			} else {
+				return ERR_BUSY;
+			}
+		}
+		if (frames[frame].desc_heap_walkers.aux.is_at_eof()) {
+			if (!frames[frame].desc_heaps_exhausted_reported.aux) {
+				frames[frame].desc_heaps_exhausted_reported.aux = true;
+				ERR_FAIL_V_MSG(ERR_BUSY,
+						"Cannot clear texture because there's no enough room in current frame's AUX descriptors heap.\n"
+						"Please increase the value of the rendering/rendering_device/d3d12/max_misc_descriptors_per_frame project setting.");
+			} else {
+				return ERR_BUSY;
+			}
+		}
+
+		ID3D12GraphicsCommandList *command_list = frames[frame].draw_command_list.Get();
+
+		for (uint32_t i = 0; i < p_layers; i++) {
+			for (uint32_t j = 0; j < p_mipmaps; j++) {
+				uint32_t subresource = D3D12CalcSubresource(src_tex->base_mipmap + p_base_mipmap + j, src_tex->base_layer + p_base_layer + i, 0, src_tex->owner_mipmaps, src_tex->owner_layers);
+				_resource_transition_batch(src_tex, subresource, src_tex->planes, D3D12_RESOURCE_STATE_UNORDERED_ACCESS, src_tex->owner_resource);
+			}
+		}
+		_resource_transitions_flush(command_list);
+
+		device->CreateUnorderedAccessView(
+				src_tex->owner_resource,
+				nullptr,
+				&src_tex->owner_uav_desc,
+				frames[frame].desc_heap_walkers.aux.get_curr_cpu_handle());
+
+		device->CopyDescriptorsSimple(
+				1,
+				frames[frame].desc_heap_walkers.resources.get_curr_cpu_handle(),
+				frames[frame].desc_heap_walkers.aux.get_curr_cpu_handle(),
+				D3D12_DESCRIPTOR_HEAP_TYPE_CBV_SRV_UAV);
+
+		UINT values[4] = {
+			(UINT)p_color.get_r8(),
+			(UINT)p_color.get_g8(),
+			(UINT)p_color.get_b8(),
+			(UINT)p_color.get_a8(),
+		};
+		command_list->ClearUnorderedAccessViewUint(
+				frames[frame].desc_heap_walkers.resources.get_curr_gpu_handle(),
+				frames[frame].desc_heap_walkers.aux.get_curr_cpu_handle(),
+				src_tex->owner_resource,
+				values,
+				0,
+				nullptr);
+
+		frames[frame].desc_heap_walkers.resources.advance();
+		frames[frame].desc_heap_walkers.aux.advance();
+	}
+
+	return OK;
+}
+
+bool RenderingDeviceD3D12::texture_is_format_supported_for_usage(DataFormat p_format, BitField<RenderingDevice::TextureUsageBits> p_usage) const {
+	ERR_FAIL_INDEX_V(p_format, DATA_FORMAT_MAX, false);
+
+	_THREAD_SAFE_METHOD_
+
+	D3D12_FEATURE_DATA_FORMAT_SUPPORT srv_rtv_support = {};
+	srv_rtv_support.Format = d3d12_formats[p_format].general_format;
+	HRESULT res = device->CheckFeatureSupport(D3D12_FEATURE_FORMAT_SUPPORT, &srv_rtv_support, sizeof(srv_rtv_support));
+	ERR_FAIL_COND_V_MSG(res, false, "CheckFeatureSupport failed with error " + vformat("0x%08ux", res) + ".");
+
+	D3D12_FEATURE_DATA_FORMAT_SUPPORT &uav_support = srv_rtv_support; // Fine for now.
+
+	D3D12_FEATURE_DATA_FORMAT_SUPPORT dsv_support = {};
+	dsv_support.Format = d3d12_formats[p_format].dsv_format;
+	res = device->CheckFeatureSupport(D3D12_FEATURE_FORMAT_SUPPORT, &dsv_support, sizeof(dsv_support));
+	ERR_FAIL_COND_V_MSG(res, false, "CheckFeatureSupport failed with error " + vformat("0x%08ux", res) + ".");
+
+	if ((p_usage & TEXTURE_USAGE_SAMPLING_BIT) && !(srv_rtv_support.Support1 & (D3D12_FORMAT_SUPPORT1_SHADER_LOAD | D3D12_FORMAT_SUPPORT1_SHADER_SAMPLE)) && d3d12_formats[p_format].general_format != DXGI_FORMAT_UNKNOWN) {
+		return false;
+	}
+
+	if ((p_usage & TEXTURE_USAGE_SAMPLING_BIT) && d3d12_formats[p_format].general_format == DXGI_FORMAT_UNKNOWN) {
+		return false;
+	}
+
+	if ((p_usage & TEXTURE_USAGE_COLOR_ATTACHMENT_BIT) && !(srv_rtv_support.Support1 & D3D12_FORMAT_SUPPORT1_RENDER_TARGET)) {
+		return false;
+	}
+
+	if ((p_usage & TEXTURE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT) && !(dsv_support.Support1 & D3D12_FORMAT_SUPPORT1_DEPTH_STENCIL)) {
+		printf("dxgiformat: %x\n", d3d12_formats[p_format].dsv_format);
+		return false;
+	}
+
+	if ((p_usage & TEXTURE_USAGE_STORAGE_BIT) && !(uav_support.Support1 & D3D12_FORMAT_SUPPORT1_TYPED_UNORDERED_ACCESS_VIEW)) { // Maybe check LOAD/STORE, too?
+		return false;
+	}
+
+	if ((p_usage & TEXTURE_USAGE_STORAGE_ATOMIC_BIT) && !(uav_support.Support2 & D3D12_FORMAT_SUPPORT2_UAV_ATOMIC_ADD)) { // Check a basic atomic at least.
+		return false;
+	}
+
+	if ((p_usage & TEXTURE_USAGE_VRS_ATTACHMENT_BIT) && d3d12_formats[p_format].general_format != DXGI_FORMAT_R8_UINT) {
+		return false;
+	}
+
+	return true;
+}
+
+/********************/
+/**** ATTACHMENT ****/
+/********************/
+
+bool RenderingDeviceD3D12::_framebuffer_format_preprocess(FramebufferFormat *p_fb_format, uint32_t p_view_count) {
+	const Vector<AttachmentFormat> &attachments = p_fb_format->attachments;
+
+	LocalVector<int32_t> attachment_last_pass;
+	attachment_last_pass.resize(attachments.size());
+
+	if (p_view_count > 1) {
+		const D3D12Context::MultiviewCapabilities &capabilities = context->get_multiview_capabilities();
+
+		// This only works with multiview!
+		ERR_FAIL_COND_V_MSG(!capabilities.is_supported, false, "Multiview not supported");
+
+		// Make sure we limit this to the number of views we support.
+		ERR_FAIL_COND_V_MSG(p_view_count > capabilities.max_view_count, false, "Hardware does not support requested number of views for Multiview render pass");
+	}
+
+	int attachment_count = 0;
+	HashSet<DXGI_FORMAT> ms_attachment_formats;
+	for (int i = 0; i < attachments.size(); i++) {
+		if (attachments[i].usage_flags == AttachmentFormat::UNUSED_ATTACHMENT) {
+			continue;
+		}
+
+		ERR_FAIL_INDEX_V(attachments[i].format, DATA_FORMAT_MAX, false);
+		ERR_FAIL_INDEX_V(attachments[i].samples, TEXTURE_SAMPLES_MAX, false);
+		ERR_FAIL_COND_V_MSG(!(attachments[i].usage_flags & (TEXTURE_USAGE_COLOR_ATTACHMENT_BIT | TEXTURE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT | TEXTURE_USAGE_INPUT_ATTACHMENT_BIT | TEXTURE_USAGE_VRS_ATTACHMENT_BIT)),
+				ERR_INVALID_PARAMETER, "Texture format for index (" + itos(i) + ") requires an attachment (color, depth-stencil, input or VRS) bit set.");
+
+		attachment_last_pass[i] = -1;
+		attachment_count++;
+
+		if (attachments[i].samples != TEXTURE_SAMPLES_1) {
+			if ((attachments[i].usage_flags & TEXTURE_USAGE_COLOR_ATTACHMENT_BIT)) {
+				ms_attachment_formats.insert(d3d12_formats[attachments[i].format].general_format);
+			} else if ((attachments[i].usage_flags & TEXTURE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT)) {
+				ms_attachment_formats.insert(d3d12_formats[attachments[i].format].dsv_format);
+			}
+		}
+	}
+
+	Vector<FramebufferPass> &passes = p_fb_format->passes;
+	for (int i = 0; i < passes.size(); i++) {
+		FramebufferPass *pass = &passes.write[i];
+
+		TextureSamples texture_samples = TEXTURE_SAMPLES_1;
+		bool is_multisample_first = true;
+
+		ERR_FAIL_COND_V(pass->color_attachments.size() > D3D12_SIMULTANEOUS_RENDER_TARGET_COUNT, false);
+		for (int j = 0; j < pass->color_attachments.size(); j++) {
+			int32_t attachment = pass->color_attachments[j];
+			if (attachment != FramebufferPass::ATTACHMENT_UNUSED) {
+				ERR_FAIL_INDEX_V_MSG(attachment, attachments.size(), false, "Invalid framebuffer format attachment(" + itos(attachment) + "), in pass (" + itos(i) + "), color attachment (" + itos(j) + ").");
+				ERR_FAIL_COND_V_MSG(!(attachments[attachment].usage_flags & TEXTURE_USAGE_COLOR_ATTACHMENT_BIT), false, "Invalid framebuffer format attachment(" + itos(attachment) + "), in pass (" + itos(i) + "), it's marked as depth, but it's not usable as color attachment.");
+				ERR_FAIL_COND_V_MSG(attachment_last_pass[attachment] == i, false, "Invalid framebuffer format attachment(" + itos(attachment) + "), in pass (" + itos(i) + "), it already was used for something else before in this pass.");
+
+				if (is_multisample_first) {
+					texture_samples = attachments[attachment].samples;
+					is_multisample_first = false;
+				} else {
+					ERR_FAIL_COND_V_MSG(texture_samples != attachments[attachment].samples, false, "Invalid framebuffer format attachment(" + itos(attachment) + "), in pass (" + itos(i) + "), if an attachment is marked as multisample, all of them should be multisample and use the same number of samples.");
+				}
+				attachment_last_pass[attachment] = i;
+			}
+		}
+
+		for (int j = 0; j < pass->input_attachments.size(); j++) {
+			int32_t attachment = pass->input_attachments[j];
+			if (attachment != FramebufferPass::ATTACHMENT_UNUSED) {
+				ERR_FAIL_INDEX_V_MSG(attachment, attachments.size(), false, "Invalid framebuffer format attachment(" + itos(attachment) + "), in pass (" + itos(i) + "), input attachment (" + itos(j) + ").");
+				ERR_FAIL_COND_V_MSG(!(attachments[attachment].usage_flags & TEXTURE_USAGE_INPUT_ATTACHMENT_BIT), false, "Invalid framebuffer format attachment(" + itos(attachment) + "), in pass (" + itos(i) + "), it isn't marked as an input texture.");
+				ERR_FAIL_COND_V_MSG(attachment_last_pass[attachment] == i, false, "Invalid framebuffer format attachment(" + itos(attachment) + "), in pass (" + itos(i) + "), it already was used for something else before in this pass.");
+
+				if ((attachments[attachment].usage_flags & TEXTURE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT)) {
+					ERR_FAIL_V_MSG(false, "Invalid framebuffer format attachment(" + itos(attachment) + "), in pass (" + itos(i) + "), the D3D12 driver doesn't yet support using depth-stencil targets as input attachments.");
+				}
+
+				attachment_last_pass[attachment] = i;
+			}
+		}
+
+		if (pass->resolve_attachments.size() > 0) {
+			ERR_FAIL_COND_V_MSG(pass->resolve_attachments.size() != pass->color_attachments.size(), false, "The amount of resolve attachments (" + itos(pass->resolve_attachments.size()) + ") must match the number of color attachments (" + itos(pass->color_attachments.size()) + ").");
+			ERR_FAIL_COND_V_MSG(texture_samples == TEXTURE_SAMPLES_1, false, "Resolve attachments specified, but color attachments are not multisample.");
+		}
+		for (int j = 0; j < pass->resolve_attachments.size(); j++) {
+			int32_t attachment = pass->resolve_attachments[j];
+			if (attachment != FramebufferPass::ATTACHMENT_UNUSED) {
+				ERR_FAIL_INDEX_V_MSG(attachment, attachments.size(), false, "Invalid framebuffer format attachment(" + itos(attachment) + "), in pass (" + itos(i) + "), resolve attachment (" + itos(j) + ").");
+				ERR_FAIL_COND_V_MSG(pass->color_attachments[j] == FramebufferPass::ATTACHMENT_UNUSED, false, "Invalid framebuffer format attachment(" + itos(attachment) + "), in pass (" + itos(i) + "), resolve attachment (" + itos(j) + "), the respective color attachment is marked as unused.");
+				ERR_FAIL_COND_V_MSG(!(attachments[attachment].usage_flags & TEXTURE_USAGE_COLOR_ATTACHMENT_BIT), false, "Invalid framebuffer format attachment(" + itos(attachment) + "), in pass (" + itos(i) + "), resolve attachment, it isn't marked as a color texture.");
+				ERR_FAIL_COND_V_MSG(attachment_last_pass[attachment] == i, false, "Invalid framebuffer format attachment(" + itos(attachment) + "), in pass (" + itos(i) + "), it already was used for something else before in this pass.");
+				bool multisample = attachments[attachment].samples > TEXTURE_SAMPLES_1;
+				ERR_FAIL_COND_V_MSG(multisample, false, "Invalid framebuffer format attachment(" + itos(attachment) + "), in pass (" + itos(i) + "), resolve attachments can't be multisample.");
+				attachment_last_pass[attachment] = i;
+			}
+		}
+
+		if (pass->depth_attachment != FramebufferPass::ATTACHMENT_UNUSED) {
+			int32_t attachment = pass->depth_attachment;
+			ERR_FAIL_INDEX_V_MSG(attachment, attachments.size(), false, "Invalid framebuffer depth format attachment(" + itos(attachment) + "), in pass (" + itos(i) + "), depth attachment.");
+			ERR_FAIL_COND_V_MSG(!(attachments[attachment].usage_flags & TEXTURE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT), false, "Invalid framebuffer depth format attachment(" + itos(attachment) + "), in pass (" + itos(i) + "), it's marked as depth, but it's not a depth attachment.");
+			ERR_FAIL_COND_V_MSG(attachment_last_pass[attachment] == i, false, "Invalid framebuffer depth format attachment(" + itos(attachment) + "), in pass (" + itos(i) + "), it already was used for something else before in this pass.");
+			attachment_last_pass[attachment] = i;
+
+			if (is_multisample_first) {
+				texture_samples = attachments[attachment].samples;
+				is_multisample_first = false;
+			} else {
+				ERR_FAIL_COND_V_MSG(texture_samples != attachments[attachment].samples, false, "Invalid framebuffer depth format attachment(" + itos(attachment) + "), in pass (" + itos(i) + "), if an attachment is marked as multisample, all of them should be multisample and use the same number of samples including the depth.");
+			}
+		}
+
+		if (context->get_vrs_capabilities().ss_image_supported && pass->vrs_attachment != FramebufferPass::ATTACHMENT_UNUSED) {
+			int32_t attachment = pass->vrs_attachment;
+			ERR_FAIL_INDEX_V_MSG(attachment, attachments.size(), false, "Invalid framebuffer VRS format attachment(" + itos(attachment) + "), in pass (" + itos(i) + "), VRS attachment.");
+			ERR_FAIL_COND_V_MSG(!(attachments[attachment].usage_flags & TEXTURE_USAGE_VRS_ATTACHMENT_BIT), false, "Invalid framebuffer VRS format attachment(" + itos(attachment) + "), in pass (" + itos(i) + "), it's marked as VRS, but it's not a VRS attachment.");
+			ERR_FAIL_COND_V_MSG(attachment_last_pass[attachment] == i, false, "Invalid framebuffer VRS attachment(" + itos(attachment) + "), in pass (" + itos(i) + "), it already was used for something else before in this pass.");
+			attachment_last_pass[attachment] = i;
+		}
+
+		for (int j = 0; j < pass->preserve_attachments.size(); j++) {
+			int32_t attachment = pass->preserve_attachments[j];
+
+			ERR_FAIL_COND_V_MSG(attachment == FramebufferPass::ATTACHMENT_UNUSED, false, "Invalid framebuffer format attachment(" + itos(attachment) + "), in pass (" + itos(i) + "), preserve attachment (" + itos(j) + "). Preserve attachments can't be unused.");
+
+			ERR_FAIL_INDEX_V_MSG(attachment, attachments.size(), false, "Invalid framebuffer format attachment(" + itos(attachment) + "), in pass (" + itos(i) + "), preserve attachment (" + itos(j) + ").");
+
+			if (attachment_last_pass[attachment] != i) {
+				// Preserve can still be used to keep depth or color from being discarded after use.
+				attachment_last_pass[attachment] = i;
+			}
+		}
+
+		p_fb_format->pass_samples.push_back(texture_samples);
+	}
+
+	if (p_fb_format->view_count > 1) {
+		const D3D12Context::MultiviewCapabilities capabilities = context->get_multiview_capabilities();
+
+		// For now this only works with multiview!
+		ERR_FAIL_COND_V_MSG(!capabilities.is_supported, ERR_UNAVAILABLE, "Multiview not supported");
+
+		// Make sure we limit this to the number of views we support.
+		ERR_FAIL_COND_V_MSG(p_fb_format->view_count > capabilities.max_view_count, ERR_UNAVAILABLE, "Hardware does not support requested number of views for Multiview render pass");
+	}
+
+	if (!ms_attachment_formats.is_empty()) {
+		LocalVector<DXGI_FORMAT> formats;
+		for (DXGI_FORMAT f : ms_attachment_formats) {
+			formats.push_back(f);
+		}
+		p_fb_format->max_supported_sample_count = _find_max_common_supported_sample_count(formats.ptr(), formats.size());
+	}
+
+	return true;
+}
+
+uint32_t RenderingDeviceD3D12::_find_max_common_supported_sample_count(const DXGI_FORMAT *p_formats, uint32_t p_num_formats) {
+	uint32_t common = UINT32_MAX;
+
+	for (uint32_t i = 0; i < p_num_formats; i++) {
+		if (format_sample_counts_mask_cache.has(p_formats[i])) {
+			common &= format_sample_counts_mask_cache[p_formats[i]];
+		} else {
+			D3D12_FEATURE_DATA_MULTISAMPLE_QUALITY_LEVELS msql = {};
+			msql.Format = p_formats[i];
+			uint32_t mask = 0;
+			for (int samples = 1 << (TEXTURE_SAMPLES_MAX - 1); samples >= 1; samples /= 2) {
+				msql.SampleCount = (UINT)samples;
+				HRESULT res = device->CheckFeatureSupport(D3D12_FEATURE_MULTISAMPLE_QUALITY_LEVELS, &msql, sizeof(msql));
+				if (SUCCEEDED(res) && msql.NumQualityLevels) {
+					int bit = get_shift_from_power_of_2(samples);
+					ERR_FAIL_COND_V(bit == -1, 1);
+					mask |= (uint32_t)(1 << bit);
+				}
+			}
+			format_sample_counts_mask_cache.insert(p_formats[i], mask);
+			common &= mask;
+		}
+	}
+	if (common == UINT32_MAX) {
+		return 1;
+	} else {
+		return (uint32_t)1 << nearest_shift(common);
+	}
+}
+
+RenderingDevice::FramebufferFormatID RenderingDeviceD3D12::framebuffer_format_create(const Vector<AttachmentFormat> &p_format, uint32_t p_view_count) {
+	FramebufferPass pass;
+	for (int i = 0; i < p_format.size(); i++) {
+		if (p_format[i].usage_flags & TEXTURE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT) {
+			pass.depth_attachment = i;
+		} else {
+			pass.color_attachments.push_back(i);
+		}
+	}
+
+	Vector<FramebufferPass> passes;
+	passes.push_back(pass);
+	return framebuffer_format_create_multipass(p_format, passes, p_view_count);
+}
+
+RenderingDevice::FramebufferFormatID RenderingDeviceD3D12::framebuffer_format_create_multipass(const Vector<AttachmentFormat> &p_attachments, const Vector<FramebufferPass> &p_passes, uint32_t p_view_count) {
+	_THREAD_SAFE_METHOD_
+
+	FramebufferFormat fb_format;
+	fb_format.attachments = p_attachments;
+	fb_format.passes = p_passes;
+	fb_format.view_count = p_view_count;
+	if (!_framebuffer_format_preprocess(&fb_format, p_view_count)) {
+		return INVALID_ID;
+	}
+
+	FramebufferFormatID id = FramebufferFormatID(framebuffer_formats.size()) | (FramebufferFormatID(ID_TYPE_FRAMEBUFFER_FORMAT) << FramebufferFormatID(ID_BASE_SHIFT));
+	framebuffer_formats[id] = fb_format;
+	return id;
+}
+
+RenderingDevice::FramebufferFormatID RenderingDeviceD3D12::framebuffer_format_create_empty(TextureSamples p_samples) {
+	_THREAD_SAFE_METHOD_
+
+	FramebufferFormat fb_format;
+	fb_format.passes.push_back(FramebufferPass());
+	fb_format.pass_samples.push_back(p_samples);
+
+	FramebufferFormatID id = FramebufferFormatID(framebuffer_formats.size()) | (FramebufferFormatID(ID_TYPE_FRAMEBUFFER_FORMAT) << FramebufferFormatID(ID_BASE_SHIFT));
+	framebuffer_formats[id] = fb_format;
+	return id;
+}
+
+RenderingDevice::TextureSamples RenderingDeviceD3D12::framebuffer_format_get_texture_samples(FramebufferFormatID p_format, uint32_t p_pass) {
+	HashMap<FramebufferFormatID, FramebufferFormat>::Iterator E = framebuffer_formats.find(p_format);
+	ERR_FAIL_NULL_V(E, TEXTURE_SAMPLES_1);
+	ERR_FAIL_COND_V(p_pass >= uint32_t(E->value.pass_samples.size()), TEXTURE_SAMPLES_1);
+
+	return E->value.pass_samples[p_pass];
+}
+
+/***********************/
+/**** RENDER TARGET ****/
+/***********************/
+
+RID RenderingDeviceD3D12::framebuffer_create_empty(const Size2i &p_size, TextureSamples p_samples, FramebufferFormatID p_format_check) {
+	_THREAD_SAFE_METHOD_
+	Framebuffer framebuffer;
+	framebuffer.format_id = framebuffer_format_create_empty(p_samples);
+	ERR_FAIL_COND_V(p_format_check != INVALID_FORMAT_ID && framebuffer.format_id != p_format_check, RID());
+	framebuffer.size = p_size;
+
+	return framebuffer_owner.make_rid(framebuffer);
+}
+
+RID RenderingDeviceD3D12::framebuffer_create(const Vector<RID> &p_texture_attachments, FramebufferFormatID p_format_check, uint32_t p_view_count) {
+	_THREAD_SAFE_METHOD_
+
+	FramebufferPass pass;
+
+	for (int i = 0; i < p_texture_attachments.size(); i++) {
+		Texture *texture = texture_owner.get_or_null(p_texture_attachments[i]);
+
+		ERR_FAIL_COND_V_MSG(texture && texture->layers != p_view_count, RID(), "Layers of our texture doesn't match view count for this framebuffer");
+
+		if (texture && texture->usage_flags & TEXTURE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT) {
+			pass.depth_attachment = i;
+		} else if (texture && texture->usage_flags & TEXTURE_USAGE_VRS_ATTACHMENT_BIT) {
+			pass.vrs_attachment = i;
+		} else {
+			if (texture && texture->is_resolve_buffer) {
+				pass.resolve_attachments.push_back(i);
+			} else {
+				pass.color_attachments.push_back(texture ? i : FramebufferPass::ATTACHMENT_UNUSED);
+			}
+		}
+	}
+
+	Vector<FramebufferPass> passes;
+	passes.push_back(pass);
+
+	return framebuffer_create_multipass(p_texture_attachments, passes, p_format_check, p_view_count);
+}
+
+D3D12_RENDER_TARGET_VIEW_DESC RenderingDeviceD3D12::_make_rtv_for_texture(const RenderingDeviceD3D12::Texture *p_texture, uint32_t p_mipmap_offset, uint32_t p_layer_offset, uint32_t p_layers) {
+	D3D12_RENDER_TARGET_VIEW_DESC rtv_desc = {};
+	rtv_desc.Format = p_texture->srv_desc.Format;
+
+	switch (p_texture->srv_desc.ViewDimension) {
+		case D3D12_SRV_DIMENSION_TEXTURE1D: {
+			rtv_desc.ViewDimension = D3D12_RTV_DIMENSION_TEXTURE1D;
+			rtv_desc.Texture1D.MipSlice = p_texture->srv_desc.Texture1D.MostDetailedMip + p_mipmap_offset;
+		} break;
+		case D3D12_SRV_DIMENSION_TEXTURE1DARRAY: {
+			rtv_desc.ViewDimension = D3D12_RTV_DIMENSION_TEXTURE1DARRAY;
+			rtv_desc.Texture1DArray.MipSlice = p_texture->srv_desc.Texture1DArray.MostDetailedMip + p_mipmap_offset;
+			rtv_desc.Texture1DArray.FirstArraySlice = p_texture->srv_desc.Texture1DArray.FirstArraySlice + p_layer_offset;
+			rtv_desc.Texture1DArray.ArraySize = p_layers == UINT32_MAX ? p_texture->srv_desc.Texture1DArray.ArraySize : p_layers;
+		} break;
+		case D3D12_SRV_DIMENSION_TEXTURE2D: {
+			rtv_desc.ViewDimension = D3D12_RTV_DIMENSION_TEXTURE2D;
+			rtv_desc.Texture2D.MipSlice = p_texture->srv_desc.Texture2D.MostDetailedMip + p_mipmap_offset;
+			rtv_desc.Texture2D.PlaneSlice = p_texture->srv_desc.Texture2D.PlaneSlice;
+		} break;
+		case D3D12_SRV_DIMENSION_TEXTURE2DARRAY: {
+			rtv_desc.ViewDimension = D3D12_RTV_DIMENSION_TEXTURE2DARRAY;
+			rtv_desc.Texture2DArray.MipSlice = p_texture->srv_desc.Texture2DArray.MostDetailedMip + p_mipmap_offset;
+			rtv_desc.Texture2DArray.FirstArraySlice = p_texture->srv_desc.Texture2DArray.FirstArraySlice + p_layer_offset;
+			rtv_desc.Texture2DArray.ArraySize = p_layers == UINT32_MAX ? p_texture->srv_desc.Texture2DArray.ArraySize : p_layers;
+			rtv_desc.Texture2DArray.PlaneSlice = p_texture->srv_desc.Texture2DArray.PlaneSlice;
+		} break;
+		case D3D12_SRV_DIMENSION_TEXTURE2DMS: {
+			rtv_desc.ViewDimension = D3D12_RTV_DIMENSION_TEXTURE2DMS;
+		} break;
+		case D3D12_SRV_DIMENSION_TEXTURE2DMSARRAY: {
+			rtv_desc.ViewDimension = D3D12_RTV_DIMENSION_TEXTURE2DMSARRAY;
+			rtv_desc.Texture2DMSArray.FirstArraySlice = p_texture->srv_desc.Texture2DMSArray.FirstArraySlice + p_layer_offset;
+			rtv_desc.Texture2DMSArray.ArraySize = p_layers == UINT32_MAX ? p_texture->srv_desc.Texture2DMSArray.ArraySize : p_layers;
+		} break;
+		case D3D12_SRV_DIMENSION_TEXTURE3D: {
+			rtv_desc.ViewDimension = D3D12_RTV_DIMENSION_TEXTURE3D;
+			rtv_desc.Texture3D.MipSlice = p_texture->srv_desc.Texture3D.MostDetailedMip + p_mipmap_offset;
+			rtv_desc.Texture3D.FirstWSlice = 0;
+			rtv_desc.Texture3D.WSize = p_texture->depth;
+		} break;
+		default: {
+			ERR_FAIL_V_MSG(D3D12_RENDER_TARGET_VIEW_DESC(), "Can't create an RTV from an SRV whose view dimension is " + itos(p_texture->srv_desc.ViewDimension) + ".");
+		}
+	}
+
+	return rtv_desc;
+}
+
+D3D12_DEPTH_STENCIL_VIEW_DESC RenderingDeviceD3D12::_make_dsv_for_texture(const RenderingDeviceD3D12::Texture *p_texture) {
+	D3D12_DEPTH_STENCIL_VIEW_DESC dsv_desc = {};
+	dsv_desc.Format = d3d12_formats[p_texture->format].dsv_format;
+	dsv_desc.Flags = D3D12_DSV_FLAG_NONE;
+
+	switch (p_texture->srv_desc.ViewDimension) {
+		case D3D12_SRV_DIMENSION_TEXTURE1D: {
+			dsv_desc.ViewDimension = D3D12_DSV_DIMENSION_TEXTURE1D;
+			dsv_desc.Texture1D.MipSlice = p_texture->srv_desc.Texture1D.MostDetailedMip;
+		} break;
+		case D3D12_SRV_DIMENSION_TEXTURE1DARRAY: {
+			dsv_desc.ViewDimension = D3D12_DSV_DIMENSION_TEXTURE1DARRAY;
+			dsv_desc.Texture1DArray.MipSlice = p_texture->srv_desc.Texture1DArray.MostDetailedMip;
+			dsv_desc.Texture1DArray.FirstArraySlice = p_texture->srv_desc.Texture1DArray.FirstArraySlice;
+			dsv_desc.Texture1DArray.ArraySize = p_texture->srv_desc.Texture1DArray.ArraySize;
+		} break;
+		case D3D12_SRV_DIMENSION_TEXTURE2D: {
+			dsv_desc.ViewDimension = D3D12_DSV_DIMENSION_TEXTURE2D;
+			dsv_desc.Texture2D.MipSlice = p_texture->srv_desc.Texture2D.MostDetailedMip;
+		} break;
+		case D3D12_SRV_DIMENSION_TEXTURE2DARRAY: {
+			dsv_desc.ViewDimension = D3D12_DSV_DIMENSION_TEXTURE2DARRAY;
+			dsv_desc.Texture2DArray.MipSlice = p_texture->srv_desc.Texture2DArray.MostDetailedMip;
+			dsv_desc.Texture2DArray.FirstArraySlice = p_texture->srv_desc.Texture2DArray.FirstArraySlice;
+			dsv_desc.Texture2DArray.ArraySize = p_texture->srv_desc.Texture2DArray.ArraySize;
+		} break;
+		case D3D12_SRV_DIMENSION_TEXTURE2DMS: {
+			dsv_desc.ViewDimension = D3D12_DSV_DIMENSION_TEXTURE2DMS;
+			dsv_desc.Texture2DMS.UnusedField_NothingToDefine = p_texture->srv_desc.Texture2DMS.UnusedField_NothingToDefine;
+		} break;
+		case D3D12_SRV_DIMENSION_TEXTURE2DMSARRAY: {
+			dsv_desc.ViewDimension = D3D12_DSV_DIMENSION_TEXTURE2DMSARRAY;
+			dsv_desc.Texture2DMSArray.FirstArraySlice = p_texture->srv_desc.Texture2DMSArray.FirstArraySlice;
+			dsv_desc.Texture2DMSArray.ArraySize = p_texture->srv_desc.Texture2DMSArray.ArraySize;
+		} break;
+		default: {
+			ERR_FAIL_V_MSG(D3D12_DEPTH_STENCIL_VIEW_DESC(), "Can't create an RTV from an SRV whose view dimension is " + itos(p_texture->srv_desc.ViewDimension) + ".");
+		}
+	}
+
+	return dsv_desc;
+}
+
+RID RenderingDeviceD3D12::framebuffer_create_multipass(const Vector<RID> &p_texture_attachments, const Vector<FramebufferPass> &p_passes, FramebufferFormatID p_format_check, uint32_t p_view_count) {
+	_THREAD_SAFE_METHOD_
+
+	Vector<AttachmentFormat> attachments;
+	attachments.resize(p_texture_attachments.size());
+	Vector<uint32_t> attachments_handle_inds;
+	attachments_handle_inds.resize(p_texture_attachments.size());
+	Size2i size;
+	bool size_set = false;
+	int num_color = 0;
+	int num_depth = 0;
+	for (int i = 0; i < p_texture_attachments.size(); i++) {
+		AttachmentFormat af;
+		Texture *texture = texture_owner.get_or_null(p_texture_attachments[i]);
+		if (!texture) {
+			af.usage_flags = AttachmentFormat::UNUSED_ATTACHMENT;
+			attachments_handle_inds.write[i] = UINT32_MAX;
+		} else {
+			ERR_FAIL_COND_V_MSG(texture->layers != p_view_count, RID(), "Layers of our texture doesn't match view count for this framebuffer");
+
+			if (!size_set) {
+				size.width = texture->width;
+				size.height = texture->height;
+				size_set = true;
+			} else if (texture->usage_flags & TEXTURE_USAGE_VRS_ATTACHMENT_BIT) {
+				// If this is not the first attachment we assume this is used as the VRS attachment.
+				// In this case this texture will be 1/16th the size of the color attachment.
+				// So we skip the size check.
+			} else {
+				ERR_FAIL_COND_V_MSG((uint32_t)size.width != texture->width || (uint32_t)size.height != texture->height, RID(),
+						"All textures in a framebuffer should be the same size.");
+			}
+
+			af.format = texture->format;
+			af.samples = texture->samples;
+			af.usage_flags = texture->usage_flags;
+
+			bool is_vrs = texture->usage_flags & TEXTURE_USAGE_VRS_ATTACHMENT_BIT && i == p_passes[0].vrs_attachment;
+			if (is_vrs) {
+			} else if ((texture->usage_flags & TEXTURE_USAGE_COLOR_ATTACHMENT_BIT)) {
+				attachments_handle_inds.write[i] = num_color;
+				num_color++;
+			} else if ((texture->usage_flags & TEXTURE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT)) {
+				attachments_handle_inds.write[i] = num_depth;
+				num_depth++;
+			} else {
+				attachments_handle_inds.write[i] = UINT32_MAX;
+			}
+		}
+		attachments.write[i] = af;
+	}
+
+	ERR_FAIL_COND_V_MSG(!size_set, RID(), "All attachments unused.");
+
+	FramebufferFormatID format_id = framebuffer_format_create_multipass(attachments, p_passes, p_view_count);
+	if (format_id == INVALID_ID) {
+		return RID();
+	}
+
+	ERR_FAIL_COND_V_MSG(p_format_check != INVALID_ID && format_id != p_format_check, RID(),
+			"The format used to check this framebuffer differs from the intended framebuffer format.");
+
+	Framebuffer framebuffer;
+	framebuffer.format_id = format_id;
+	framebuffer.texture_ids = p_texture_attachments;
+	framebuffer.attachments_handle_inds = attachments_handle_inds;
+	framebuffer.size = size;
+	framebuffer.view_count = p_view_count;
+
+	{
+		if (num_color) {
+			Error err = framebuffer.rtv_heap.allocate(device.Get(), D3D12_DESCRIPTOR_HEAP_TYPE_RTV, num_color, false);
+			ERR_FAIL_COND_V(err, RID());
+		}
+		DescriptorsHeap::Walker rtv_heap_walker = framebuffer.rtv_heap.make_walker();
+
+		if (num_depth) {
+			Error err = framebuffer.dsv_heap.allocate(device.Get(), D3D12_DESCRIPTOR_HEAP_TYPE_DSV, num_depth, false);
+			ERR_FAIL_COND_V(err, RID());
+		}
+		DescriptorsHeap::Walker dsv_heap_walker = framebuffer.dsv_heap.make_walker();
+
+		for (int i = 0; i < p_texture_attachments.size(); i++) {
+			Texture *texture = texture_owner.get_or_null(p_texture_attachments[i]);
+			if (!texture) {
+				continue;
+			}
+
+			bool is_vrs = texture->usage_flags & TEXTURE_USAGE_VRS_ATTACHMENT_BIT && i == p_passes[0].vrs_attachment;
+			if (is_vrs) {
+			} else if ((texture->usage_flags & TEXTURE_USAGE_COLOR_ATTACHMENT_BIT)) {
+				D3D12_RENDER_TARGET_VIEW_DESC rtv_desc = _make_rtv_for_texture(texture);
+				device->CreateRenderTargetView(texture->resource, &rtv_desc, rtv_heap_walker.get_curr_cpu_handle());
+				rtv_heap_walker.advance();
+			} else if ((texture->usage_flags & TEXTURE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT)) {
+				D3D12_DEPTH_STENCIL_VIEW_DESC dsv_desc = _make_dsv_for_texture(texture);
+				device->CreateDepthStencilView(texture->resource, &dsv_desc, dsv_heap_walker.get_curr_cpu_handle());
+				dsv_heap_walker.advance();
+			}
+		}
+
+		DEV_ASSERT(rtv_heap_walker.is_at_eof());
+		DEV_ASSERT(dsv_heap_walker.is_at_eof());
+	}
+
+	RID id = framebuffer_owner.make_rid(framebuffer);
+
+	for (int i = 0; i < p_texture_attachments.size(); i++) {
+		if (p_texture_attachments[i].is_valid()) {
+			_add_dependency(id, p_texture_attachments[i]);
+		}
+	}
+
+	return id;
+}
+
+RenderingDevice::FramebufferFormatID RenderingDeviceD3D12::framebuffer_get_format(RID p_framebuffer) {
+	_THREAD_SAFE_METHOD_
+
+	Framebuffer *framebuffer = framebuffer_owner.get_or_null(p_framebuffer);
+	ERR_FAIL_NULL_V(framebuffer, INVALID_ID);
+
+	return framebuffer->format_id;
+}
+
+bool RenderingDeviceD3D12::framebuffer_is_valid(RID p_framebuffer) const {
+	_THREAD_SAFE_METHOD_
+
+	return framebuffer_owner.owns(p_framebuffer);
+}
+
+void RenderingDeviceD3D12::framebuffer_set_invalidation_callback(RID p_framebuffer, InvalidationCallback p_callback, void *p_userdata) {
+	_THREAD_SAFE_METHOD_
+
+	Framebuffer *framebuffer = framebuffer_owner.get_or_null(p_framebuffer);
+	ERR_FAIL_NULL(framebuffer);
+
+	framebuffer->invalidated_callback = p_callback;
+	framebuffer->invalidated_callback_userdata = p_userdata;
+}
+
+/*****************/
+/**** SAMPLER ****/
+/*****************/
+
+RID RenderingDeviceD3D12::sampler_create(const SamplerState &p_state) {
+	_THREAD_SAFE_METHOD_
+
+	D3D12_SAMPLER_DESC sampler_desc = {};
+
+	if (p_state.use_anisotropy) {
+		sampler_desc.Filter = D3D12_ENCODE_ANISOTROPIC_FILTER(D3D12_FILTER_REDUCTION_TYPE_STANDARD);
+		sampler_desc.MaxAnisotropy = p_state.anisotropy_max;
+	} else {
+		static const D3D12_FILTER_TYPE d3d12_filter_types[] = {
+			D3D12_FILTER_TYPE_POINT, // SAMPLER_FILTER_NEAREST.
+			D3D12_FILTER_TYPE_LINEAR, // SAMPLER_FILTER_LINEAR.
+		};
+		sampler_desc.Filter = D3D12_ENCODE_BASIC_FILTER(
+				d3d12_filter_types[p_state.min_filter],
+				d3d12_filter_types[p_state.mag_filter],
+				d3d12_filter_types[p_state.mip_filter],
+				p_state.enable_compare ? D3D12_FILTER_REDUCTION_TYPE_COMPARISON : D3D12_FILTER_REDUCTION_TYPE_STANDARD);
+	}
+
+	ERR_FAIL_INDEX_V(p_state.repeat_u, SAMPLER_REPEAT_MODE_MAX, RID());
+	sampler_desc.AddressU = address_modes[p_state.repeat_u];
+	ERR_FAIL_INDEX_V(p_state.repeat_v, SAMPLER_REPEAT_MODE_MAX, RID());
+	sampler_desc.AddressV = address_modes[p_state.repeat_v];
+	ERR_FAIL_INDEX_V(p_state.repeat_w, SAMPLER_REPEAT_MODE_MAX, RID());
+	sampler_desc.AddressW = address_modes[p_state.repeat_w];
+
+	ERR_FAIL_INDEX_V(p_state.border_color, SAMPLER_BORDER_COLOR_MAX, RID());
+	for (int i = 0; i < 4; i++) {
+		sampler_desc.BorderColor[i] = sampler_border_colors[p_state.border_color][i];
+	}
+
+	sampler_desc.MinLOD = p_state.min_lod;
+	sampler_desc.MaxLOD = p_state.max_lod;
+	sampler_desc.MipLODBias = p_state.lod_bias;
+
+	ERR_FAIL_INDEX_V(p_state.compare_op, COMPARE_OP_MAX, RID());
+	sampler_desc.ComparisonFunc = p_state.enable_compare ? compare_operators[p_state.compare_op] : D3D12_COMPARISON_FUNC_NEVER;
+
+	// TODO: Emulate somehow?
+	if (p_state.unnormalized_uvw) {
+		WARN_PRINT("Creating a sampler with unnormalized UVW, which is not supported.");
+	}
+
+	return sampler_owner.make_rid(sampler_desc);
+}
+
+bool RenderingDeviceD3D12::sampler_is_format_supported_for_filter(DataFormat p_format, SamplerFilter p_sampler_filter) const {
+	ERR_FAIL_INDEX_V(p_format, DATA_FORMAT_MAX, false);
+
+	_THREAD_SAFE_METHOD_
+
+	D3D12_FEATURE_DATA_FORMAT_SUPPORT srv_rtv_support = {};
+	srv_rtv_support.Format = d3d12_formats[p_format].general_format;
+	HRESULT res = device->CheckFeatureSupport(D3D12_FEATURE_FORMAT_SUPPORT, &srv_rtv_support, sizeof(srv_rtv_support));
+	ERR_FAIL_COND_V_MSG(res, false, "CheckFeatureSupport failed with error " + vformat("0x%08ux", res) + ".");
+
+	return (srv_rtv_support.Support1 & D3D12_FORMAT_SUPPORT1_SHADER_SAMPLE);
+}
+
+/**********************/
+/**** VERTEX ARRAY ****/
+/**********************/
+
+RID RenderingDeviceD3D12::vertex_buffer_create(uint32_t p_size_bytes, const Vector<uint8_t> &p_data, bool p_use_as_storage) {
+	_THREAD_SAFE_METHOD_
+
+	ERR_FAIL_COND_V(p_data.size() && (uint32_t)p_data.size() != p_size_bytes, RID());
+
+	Buffer buffer;
+	D3D12_RESOURCE_STATES usage = D3D12_RESOURCE_STATE_VERTEX_AND_CONSTANT_BUFFER;
+	if (p_use_as_storage) {
+		usage |= D3D12_RESOURCE_STATE_UNORDERED_ACCESS;
+	}
+	Error err = _buffer_allocate(&buffer, p_size_bytes, usage, D3D12_HEAP_TYPE_DEFAULT);
+	ERR_FAIL_COND_V(err != OK, RID());
+
+	if (p_data.size()) {
+		uint64_t data_size = p_data.size();
+		const uint8_t *r = p_data.ptr();
+		_buffer_update(&buffer, 0, r, data_size);
+	}
+
+	RID id = vertex_buffer_owner.make_rid(buffer);
+#ifdef DEV_ENABLED
+	set_resource_name(id, "RID:" + itos(id.get_id()));
+#endif
+	return id;
+}
+
+// Internally reference counted, this ID is warranted to be unique for the same description, but needs to be freed as many times as it was allocated.
+RenderingDevice::VertexFormatID RenderingDeviceD3D12::vertex_format_create(const Vector<VertexAttribute> &p_vertex_formats) {
+	_THREAD_SAFE_METHOD_
+
+	VertexDescriptionKey key;
+	key.vertex_formats = p_vertex_formats;
+
+	VertexFormatID *idptr = vertex_format_cache.getptr(key);
+	if (idptr) {
+		return *idptr;
+	}
+
+	// Does not exist, create one and cache it.
+	VertexDescriptionCache vdcache;
+	vdcache.elements_desc.resize(p_vertex_formats.size());
+
+	HashSet<int> used_locations;
+	for (int i = 0; i < p_vertex_formats.size(); i++) {
+		ERR_CONTINUE(p_vertex_formats[i].format >= DATA_FORMAT_MAX);
+		ERR_FAIL_COND_V(used_locations.has(p_vertex_formats[i].location), INVALID_ID);
+
+		ERR_FAIL_COND_V_MSG(get_format_vertex_size(p_vertex_formats[i].format) == 0, INVALID_ID,
+				"Data format for attachment (" + itos(i) + "), '" + named_formats[p_vertex_formats[i].format] + "', is not valid for a vertex array.");
+
+		// SPIRV-Cross maps `layout(location = <N>) in` to `TEXCOORD<N>`.
+		vdcache.elements_desc.write[i].SemanticName = "TEXCOORD"; // SPIRV-Cross will apply TEXCOORD semantic to vertex attributes.
+		vdcache.elements_desc.write[i].SemanticIndex = p_vertex_formats[i].location;
+		vdcache.elements_desc.write[i].Format = d3d12_formats[p_vertex_formats[i].format].general_format;
+		vdcache.elements_desc.write[i].InputSlot = i; // TODO: Can the same slot be used if data comes from the same buffer (regardless format)?
+		vdcache.elements_desc.write[i].AlignedByteOffset = p_vertex_formats[i].offset;
+		if (p_vertex_formats[i].frequency == VERTEX_FREQUENCY_INSTANCE) {
+			vdcache.elements_desc.write[i].InputSlotClass = D3D12_INPUT_CLASSIFICATION_PER_INSTANCE_DATA;
+			vdcache.elements_desc.write[i].InstanceDataStepRate = 1;
+		} else {
+			vdcache.elements_desc.write[i].InputSlotClass = D3D12_INPUT_CLASSIFICATION_PER_VERTEX_DATA;
+			vdcache.elements_desc.write[i].InstanceDataStepRate = 0;
+		}
+		used_locations.insert(p_vertex_formats[i].location);
+	}
+
+	vdcache.vertex_formats = p_vertex_formats;
+
+	VertexFormatID id = VertexFormatID(vertex_format_cache.size()) | (VertexFormatID(ID_TYPE_VERTEX_FORMAT) << ID_BASE_SHIFT);
+	vertex_format_cache[key] = id;
+	vertex_formats[id] = vdcache;
+	return id;
+}
+
+RID RenderingDeviceD3D12::vertex_array_create(uint32_t p_vertex_count, VertexFormatID p_vertex_format, const Vector<RID> &p_src_buffers, const Vector<uint64_t> &p_offsets) {
+	_THREAD_SAFE_METHOD_
+
+	ERR_FAIL_COND_V(!vertex_formats.has(p_vertex_format), RID());
+	const VertexDescriptionCache &vd = vertex_formats[p_vertex_format];
+
+	ERR_FAIL_COND_V(vd.vertex_formats.size() != p_src_buffers.size(), RID());
+
+	for (int i = 0; i < p_src_buffers.size(); i++) {
+		ERR_FAIL_COND_V(!vertex_buffer_owner.owns(p_src_buffers[i]), RID());
+	}
+
+	VertexArray vertex_array;
+
+	if (!p_offsets.is_empty()) {
+		ERR_FAIL_COND_V(p_offsets.size() != p_src_buffers.size(), RID());
+	}
+
+	vertex_array.vertex_count = p_vertex_count;
+	vertex_array.description = p_vertex_format;
+	vertex_array.max_instances_allowed = 0xFFFFFFFF; // By default as many as you want.
+	HashSet<Buffer *> unique_buffers;
+	for (int i = 0; i < p_src_buffers.size(); i++) {
+		Buffer *buffer = vertex_buffer_owner.get_or_null(p_src_buffers[i]);
+
+		const VertexAttribute &atf = vd.vertex_formats[i];
+
+		// Validate with buffer.
+		{
+			uint32_t element_size = get_format_vertex_size(atf.format);
+			ERR_FAIL_COND_V(element_size == 0, RID()); // Should never happens since this was prevalidated.
+
+			if (atf.frequency == VERTEX_FREQUENCY_VERTEX) {
+				// Validate size for regular drawing.
+				uint64_t total_size = uint64_t(atf.stride) * (p_vertex_count - 1) + atf.offset + element_size;
+				ERR_FAIL_COND_V_MSG(total_size > buffer->size, RID(),
+						"Attachment (" + itos(i) + ") will read past the end of the buffer.");
+
+			} else {
+				// Validate size for instances drawing.
+				uint64_t available = buffer->size - atf.offset;
+				ERR_FAIL_COND_V_MSG(available < element_size, RID(),
+						"Attachment (" + itos(i) + ") uses instancing, but it's just too small.");
+
+				uint32_t instances_allowed = available / atf.stride;
+				vertex_array.max_instances_allowed = MIN(instances_allowed, vertex_array.max_instances_allowed);
+			}
+		}
+
+		unique_buffers.insert(buffer);
+
+		D3D12_VERTEX_BUFFER_VIEW view = {};
+		uint64_t data_offset = p_offsets.is_empty() ? 0 : p_offsets[i];
+		view.BufferLocation = buffer->resource->GetGPUVirtualAddress() + data_offset;
+		view.SizeInBytes = buffer->size;
+		view.StrideInBytes = atf.stride;
+		vertex_array.views.push_back(view);
+	}
+
+	for (Buffer *buffer : unique_buffers) {
+		vertex_array.unique_buffers.push_back(buffer);
+	}
+
+	RID id = vertex_array_owner.make_rid(vertex_array);
+	for (int i = 0; i < p_src_buffers.size(); i++) {
+		_add_dependency(id, p_src_buffers[i]);
+	}
+
+	return id;
+}
+
+RID RenderingDeviceD3D12::index_buffer_create(uint32_t p_index_count, IndexBufferFormat p_format, const Vector<uint8_t> &p_data, bool p_use_restart_indices) {
+	_THREAD_SAFE_METHOD_
+
+	ERR_FAIL_COND_V(p_index_count == 0, RID());
+
+	IndexBuffer index_buffer;
+	index_buffer.index_format = (p_format == INDEX_BUFFER_FORMAT_UINT16) ? DXGI_FORMAT_R16_UINT : DXGI_FORMAT_R32_UINT;
+	index_buffer.supports_restart_indices = p_use_restart_indices;
+	index_buffer.index_count = p_index_count;
+	uint32_t size_bytes = p_index_count * ((p_format == INDEX_BUFFER_FORMAT_UINT16) ? 2 : 4);
+#ifdef DEBUG_ENABLED
+	if (p_data.size()) {
+		index_buffer.max_index = 0;
+		ERR_FAIL_COND_V_MSG((uint32_t)p_data.size() != size_bytes, RID(),
+				"Default index buffer initializer array size (" + itos(p_data.size()) + ") does not match format required size (" + itos(size_bytes) + ").");
+		const uint8_t *r = p_data.ptr();
+		if (p_format == INDEX_BUFFER_FORMAT_UINT16) {
+			const uint16_t *index16 = (const uint16_t *)r;
+			for (uint32_t i = 0; i < p_index_count; i++) {
+				if (p_use_restart_indices && index16[i] == 0xFFFF) {
+					continue; // Restart index, ignore.
+				}
+				index_buffer.max_index = MAX(index16[i], index_buffer.max_index);
+			}
+		} else {
+			const uint32_t *index32 = (const uint32_t *)r;
+			for (uint32_t i = 0; i < p_index_count; i++) {
+				if (p_use_restart_indices && index32[i] == 0xFFFFFFFF) {
+					continue; // Restart index, ignore.
+				}
+				index_buffer.max_index = MAX(index32[i], index_buffer.max_index);
+			}
+		}
+	} else {
+		index_buffer.max_index = 0xFFFFFFFF;
+	}
+#else
+	index_buffer.max_index = 0xFFFFFFFF;
+#endif
+	Error err = _buffer_allocate(&index_buffer, size_bytes, D3D12_RESOURCE_STATE_INDEX_BUFFER, D3D12_HEAP_TYPE_DEFAULT);
+	ERR_FAIL_COND_V(err != OK, RID());
+
+	if (p_data.size()) {
+		uint64_t data_size = p_data.size();
+		const uint8_t *r = p_data.ptr();
+		_buffer_update(&index_buffer, 0, r, data_size);
+	}
+	RID id = index_buffer_owner.make_rid(index_buffer);
+#ifdef DEV_ENABLED
+	set_resource_name(id, "RID:" + itos(id.get_id()));
+#endif
+	return id;
+}
+
+RID RenderingDeviceD3D12::index_array_create(RID p_index_buffer, uint32_t p_index_offset, uint32_t p_index_count) {
+	_THREAD_SAFE_METHOD_
+
+	ERR_FAIL_COND_V(!index_buffer_owner.owns(p_index_buffer), RID());
+
+	IndexBuffer *index_buffer = index_buffer_owner.get_or_null(p_index_buffer);
+
+	ERR_FAIL_COND_V(p_index_count == 0, RID());
+	ERR_FAIL_COND_V(p_index_offset + p_index_count > index_buffer->index_count, RID());
+
+	IndexArray index_array;
+	index_array.buffer = index_buffer;
+	index_array.max_index = index_buffer->max_index;
+	index_array.offset = p_index_offset;
+	index_array.indices = p_index_count;
+	index_array.supports_restart_indices = index_buffer->supports_restart_indices;
+	index_array.view.BufferLocation = index_buffer->resource->GetGPUVirtualAddress();
+	index_array.view.SizeInBytes = p_index_count * (index_buffer->index_format == DXGI_FORMAT_R16_UINT ? 2 : 4);
+	index_array.view.Format = index_buffer->index_format;
+
+	RID id = index_array_owner.make_rid(index_array);
+	_add_dependency(id, p_index_buffer);
+	return id;
+}
+
+/****************/
+/**** SHADER ****/
+/****************/
+
+static const char *shader_uniform_names[RenderingDevice::UNIFORM_TYPE_MAX + 1] = {
+	"Sampler", "CombinedSampler", "Texture", "Image", "TextureBuffer", "SamplerTextureBuffer", "ImageBuffer", "UniformBuffer", "StorageBuffer", "InputAttachment", "N/A"
+};
+
+static uint32_t shader_stage_bit_offset_indices[RenderingDevice::SHADER_STAGE_MAX] = {
+	/* SHADER_STAGE_VERTEX */ 0,
+	/* SHADER_STAGE_FRAGMENT */ 1,
+	/* SHADER_STAGE_TESSELATION_CONTROL */ UINT32_MAX,
+	/* SHADER_STAGE_TESSELATION_EVALUATION */ UINT32_MAX,
+	/* SHADER_STAGE_COMPUTE */ 2,
+};
+
+String RenderingDeviceD3D12::_shader_uniform_debug(RID p_shader, int p_set) {
+	String ret;
+	const Shader *shader = shader_owner.get_or_null(p_shader);
+	ERR_FAIL_NULL_V(shader, String());
+	for (int i = 0; i < shader->sets.size(); i++) {
+		if (p_set >= 0 && i != p_set) {
+			continue;
+		}
+		for (int j = 0; j < shader->sets[i].uniforms.size(); j++) {
+			const UniformInfo &ui = shader->sets[i].uniforms[j].info;
+			if (!ret.is_empty()) {
+				ret += "\n";
+			}
+			ret += "Set: " + itos(i) + " Binding: " + itos(ui.binding) + " Type: " + shader_uniform_names[ui.type] + " Writable: " + (ui.writable ? "Y" : "N") + " Length: " + itos(ui.length);
+		}
+	}
+	return ret;
+}
+
+uint32_t RenderingDeviceD3D12::_shader_patch_dxil_specialization_constant(
+		PipelineSpecializationConstantType p_type,
+		const void *p_value,
+		const uint64_t (&p_stages_bit_offsets)[D3D12_BITCODE_OFFSETS_NUM_STAGES],
+		HashMap<ShaderStage, Vector<uint8_t>> &r_stages_bytecodes,
+		bool p_is_first_patch) {
+	uint32_t patch_val = 0;
+	switch (p_type) {
+		case PIPELINE_SPECIALIZATION_CONSTANT_TYPE_INT: {
+			uint32_t int_value = *((const int *)p_value);
+			ERR_FAIL_COND_V(int_value & (1 << 31), 0);
+			patch_val = int_value;
+		} break;
+		case PIPELINE_SPECIALIZATION_CONSTANT_TYPE_BOOL: {
+			bool bool_value = *((const bool *)p_value);
+			patch_val = (uint32_t)bool_value;
+		} break;
+		case PIPELINE_SPECIALIZATION_CONSTANT_TYPE_FLOAT: {
+			uint32_t int_value = *((const int *)p_value);
+			ERR_FAIL_COND_V(int_value & (1 << 31), 0);
+			patch_val = (int_value >> 1);
+		} break;
+	}
+	// For VBR encoding to encode the number of bits we expect (32), we need to set the MSB unconditionally.
+	// However, signed VBR moves the MSB to the LSB, so setting the MSB to 1 wouldn't help. Therefore,
+	// the bit we set to 1 is the one at index 30.
+	patch_val |= (1 << 30);
+	patch_val <<= 1; // What signed VBR does.
+
+	auto tamper_bits = [](uint8_t *p_start, uint64_t p_bit_offset, uint64_t p_value) -> uint64_t {
+		uint64_t original = 0;
+		uint32_t curr_input_byte = p_bit_offset / 8;
+		uint8_t curr_input_bit = p_bit_offset % 8;
+		auto get_curr_input_bit = [&]() -> bool {
+			return ((p_start[curr_input_byte] >> curr_input_bit) & 1);
+		};
+		auto move_to_next_input_bit = [&]() {
+			if (curr_input_bit == 7) {
+				curr_input_bit = 0;
+				curr_input_byte++;
+			} else {
+				curr_input_bit++;
+			}
+		};
+		auto tamper_input_bit = [&](bool p_new_bit) {
+			p_start[curr_input_byte] &= ~((uint8_t)1 << curr_input_bit);
+			if (p_new_bit) {
+				p_start[curr_input_byte] |= (uint8_t)1 << curr_input_bit;
+			}
+		};
+		uint8_t value_bit_idx = 0;
+		for (uint32_t i = 0; i < 5; i++) { // 32 bits take 5 full bytes in VBR.
+			for (uint32_t j = 0; j < 7; j++) {
+				bool input_bit = get_curr_input_bit();
+				original |= (uint64_t)(input_bit ? 1 : 0) << value_bit_idx;
+				tamper_input_bit((p_value >> value_bit_idx) & 1);
+				move_to_next_input_bit();
+				value_bit_idx++;
+			}
+#ifdef DEV_ENABLED
+			bool input_bit = get_curr_input_bit();
+			DEV_ASSERT(i < 4 && input_bit || i == 4 && !input_bit);
+#endif
+			move_to_next_input_bit();
+		}
+		return original;
+	};
+	uint32_t stages_patched_mask = 0;
+	for (int stage = 0; stage < SHADER_STAGE_MAX; stage++) {
+		if (!r_stages_bytecodes.has((ShaderStage)stage)) {
+			continue;
+		}
+
+		uint64_t offset = p_stages_bit_offsets[shader_stage_bit_offset_indices[stage]];
+		if (offset == 0) {
+			// This constant does not appear at this stage.
+			continue;
+		}
+
+		Vector<uint8_t> &bytecode = r_stages_bytecodes[(ShaderStage)stage];
+#ifdef DEV_ENABLED
+		uint64_t orig_patch_val = tamper_bits(bytecode.ptrw(), offset, patch_val);
+		// Checking against the value the NIR patch should have set.
+		DEV_ASSERT(!p_is_first_patch || ((orig_patch_val >> 1) & GODOT_NIR_SC_SENTINEL_MAGIC_MASK) == GODOT_NIR_SC_SENTINEL_MAGIC);
+		uint64_t readback_patch_val = tamper_bits(bytecode.ptrw(), offset, patch_val);
+		DEV_ASSERT(readback_patch_val == patch_val);
+#else
+		tamper_bits(bytecode.ptrw(), offset, patch_val);
+#endif
+
+		stages_patched_mask |= (1 << stage);
+	}
+	return stages_patched_mask;
+}
+
+bool RenderingDeviceD3D12::_shader_sign_dxil_bytecode(ShaderStage p_stage, Vector<uint8_t> &r_dxil_blob) {
+	dxil_validator *validator = get_dxil_validator_for_current_thread();
+
+	char *err = nullptr;
+	bool res = dxil_validate_module(validator, r_dxil_blob.ptrw(), r_dxil_blob.size(), &err);
+	if (!res) {
+		if (err) {
+			ERR_FAIL_COND_V_MSG(!res, false, "Shader signing invocation at stage " + String(shader_stage_names[p_stage]) + " failed:\n" + String(err));
+		} else {
+			ERR_FAIL_COND_V_MSG(!res, false, "Shader signing invocation at stage " + String(shader_stage_names[p_stage]) + " failed.");
+		}
+	}
+
+	return true;
+}
+
+// Version 1: Initial.
+// Version 2: 64-bit vertex input mask.
+#define SHADER_BINARY_VERSION 2
+
+String RenderingDeviceD3D12::shader_get_binary_cache_key() const {
+	return "D3D12-SV" + itos(SHADER_BINARY_VERSION);
+}
+
+enum RootSignatureLocationType {
+	RS_LOC_TYPE_RESOURCE,
+	RS_LOC_TYPE_SAMPLER,
+};
+
+enum ResourceClass {
+	RES_CLASS_INVALID,
+	RES_CLASS_CBV,
+	RES_CLASS_SRV,
+	RES_CLASS_UAV,
+};
+
+// Phase 1: SPIR-V reflection, where the Vulkan/RD interface of the shader is discovered.
+// Phase 2: SPIR-V to DXIL translation, where the DXIL interface is discovered, which may have gaps due to optimizations.
+
+struct RenderingDeviceD3D12ShaderBinaryDataBinding {
+	// - Phase 1.
+	uint32_t type;
+	uint32_t binding;
+	uint32_t stages;
+	uint32_t length; // Size of arrays (in total elements), or ubos (in bytes * total elements).
+	uint32_t writable;
+	// - Phase 2.
+	uint32_t res_class;
+	uint32_t has_sampler;
+	uint32_t dxil_stages;
+	struct RootSignatureLocation {
+		uint32_t root_param_idx = UINT32_MAX; // UINT32_MAX if unused.
+		uint32_t range_idx = UINT32_MAX; // UINT32_MAX if unused.
+	};
+	RootSignatureLocation root_sig_locations[2]; // Index is RootSignatureLocationType.
+
+	// We need to sort these to fill the root signature locations properly.
+	bool operator<(const RenderingDeviceD3D12ShaderBinaryDataBinding &p_other) const {
+		return binding < p_other.binding;
+	}
+};
+
+struct RenderingDeviceD3D12ShaderBinarySpecializationConstant {
+	// - Phase 1.
+	uint32_t type;
+	uint32_t constant_id;
+	union {
+		uint32_t int_value;
+		float float_value;
+		bool bool_value;
+	};
+	// - Phase 2.
+	uint64_t stages_bit_offsets[D3D12_BITCODE_OFFSETS_NUM_STAGES];
+};
+
+struct RenderingDeviceD3D12ShaderBinaryData {
+	uint64_t vertex_input_mask;
+	uint32_t fragment_output_mask;
+	uint32_t specialization_constants_count;
+	uint32_t spirv_specialization_constants_ids_mask;
+	uint32_t is_compute;
+	uint32_t compute_local_size[3];
+	uint32_t set_count;
+	uint32_t push_constant_size;
+	uint32_t dxil_push_constant_stages; // Phase 2.
+	uint32_t nir_runtime_data_root_param_idx; // Phase 2.
+	uint32_t stage_count;
+	uint32_t shader_name_len;
+	uint32_t root_signature_len;
+	uint32_t root_signature_crc;
+};
+
+Vector<uint8_t> RenderingDeviceD3D12::shader_compile_binary_from_spirv(const Vector<ShaderStageSPIRVData> &p_spirv, const String &p_shader_name) {
+	SpirvReflectionData spirv_data;
+	if (_reflect_spirv(p_spirv, spirv_data) != OK) {
+		return Vector<uint8_t>();
+	}
+
+	// Collect reflection data into binary data.
+	RenderingDeviceD3D12ShaderBinaryData binary_data = {};
+	Vector<Vector<RenderingDeviceD3D12ShaderBinaryDataBinding>> uniform_info;
+	Vector<RenderingDeviceD3D12ShaderBinarySpecializationConstant> specialization_constants;
+	{
+		binary_data.vertex_input_mask = spirv_data.vertex_input_mask;
+		binary_data.fragment_output_mask = spirv_data.fragment_output_mask;
+		binary_data.specialization_constants_count = spirv_data.specialization_constants.size();
+		binary_data.is_compute = spirv_data.is_compute;
+		binary_data.compute_local_size[0] = spirv_data.compute_local_size[0];
+		binary_data.compute_local_size[1] = spirv_data.compute_local_size[1];
+		binary_data.compute_local_size[2] = spirv_data.compute_local_size[2];
+		binary_data.set_count = spirv_data.uniforms.size();
+		binary_data.push_constant_size = spirv_data.push_constant_size;
+		binary_data.nir_runtime_data_root_param_idx = UINT32_MAX;
+		binary_data.stage_count = p_spirv.size();
+
+		for (const Vector<SpirvReflectionData::Uniform> &spirv_set : spirv_data.uniforms) {
+			Vector<RenderingDeviceD3D12ShaderBinaryDataBinding> set_bindings;
+			for (const SpirvReflectionData::Uniform &spirv_uniform : spirv_set) {
+				RenderingDeviceD3D12ShaderBinaryDataBinding binding{};
+				binding.type = (uint32_t)spirv_uniform.type;
+				binding.binding = spirv_uniform.binding;
+				binding.stages = (uint32_t)spirv_uniform.stages_mask;
+				binding.length = spirv_uniform.length;
+				binding.writable = (uint32_t)spirv_uniform.writable;
+				set_bindings.push_back(binding);
+			}
+			uniform_info.push_back(set_bindings);
+		}
+
+		for (const SpirvReflectionData::SpecializationConstant &spirv_sc : spirv_data.specialization_constants) {
+			RenderingDeviceD3D12ShaderBinarySpecializationConstant spec_constant{};
+			spec_constant.type = (uint32_t)spirv_sc.type;
+			spec_constant.constant_id = spirv_sc.constant_id;
+			spec_constant.int_value = spirv_sc.int_value;
+			specialization_constants.push_back(spec_constant);
+
+			binary_data.spirv_specialization_constants_ids_mask |= (1 << spirv_sc.constant_id);
+		}
+	}
+
+	// Translate SPIR-V shaders to DXIL, and collect shader info from the new representation.
+	HashMap<ShaderStage, Vector<uint8_t>> dxil_blobs;
+	BitField<ShaderStage> stages_processed;
+	{
+		HashMap<int, nir_shader *> stages_nir_shaders;
+
+		auto free_nir_shaders = [&]() {
+			for (KeyValue<int, nir_shader *> &E : stages_nir_shaders) {
+				ralloc_free(E.value);
+			}
+			stages_nir_shaders.clear();
+		};
+
+		// This is based on spirv2dxil.c. May need updates when it changes.
+		// Also, this has to stay around until after linking.
+		nir_shader_compiler_options nir_options = *dxil_get_nir_compiler_options();
+		nir_options.lower_base_vertex = false;
+
+		dxil_spirv_runtime_conf dxil_runtime_conf = {};
+		dxil_runtime_conf.runtime_data_cbv.register_space = RUNTIME_DATA_SPACE;
+		dxil_runtime_conf.runtime_data_cbv.base_shader_register = RUNTIME_DATA_REGISTER;
+		dxil_runtime_conf.push_constant_cbv.register_space = ROOT_CONSTANT_SPACE;
+		dxil_runtime_conf.push_constant_cbv.base_shader_register = ROOT_CONSTANT_REGISTER;
+		dxil_runtime_conf.zero_based_vertex_instance_id = true;
+		dxil_runtime_conf.zero_based_compute_workgroup_id = true;
+		dxil_runtime_conf.declared_read_only_images_as_srvs = true;
+		// Making this explicit to let maintainers know that in practice this didn't improve performance,
+		// probably because data generated by one shader and consumed by another one forces the resource
+		// to transition from UAV to SRV, and back, instead of being an UAV all the time.
+		// In case someone wants to try, care must be taken so in case of incompatible bindings across stages
+		// happen as a result, all the stages are re-translated. That can happen if, for instance, a stage only
+		// uses an allegedly writable resource only for reading but the next stage doesn't.
+		dxil_runtime_conf.inferred_read_only_images_as_srvs = false;
+
+		// - Translate SPIR-V to NIR.
+		for (int i = 0; i < p_spirv.size(); i++) {
+			ShaderStage stage = (ShaderStage)p_spirv[i].shader_stage;
+			ShaderStage stage_flag = (ShaderStage)(1 << p_spirv[i].shader_stage);
+
+			stages_processed.set_flag(stage_flag);
+
+			{
+				char *entry_point = "main";
+
+				static const gl_shader_stage SPIRV_TO_MESA_STAGES[SHADER_STAGE_MAX] = {
+					/* SHADER_STAGE_VERTEX */ MESA_SHADER_VERTEX,
+					/* SHADER_STAGE_FRAGMENT */ MESA_SHADER_FRAGMENT,
+					/* SHADER_STAGE_TESSELATION_CONTROL */ MESA_SHADER_TESS_CTRL,
+					/* SHADER_STAGE_TESSELATION_EVALUATION */ MESA_SHADER_TESS_EVAL,
+					/* SHADER_STAGE_COMPUTE */ MESA_SHADER_COMPUTE,
+				};
+
+				nir_shader *nir_shader = spirv_to_nir(
+						(const uint32_t *)p_spirv[i].spir_v.ptr(),
+						p_spirv[i].spir_v.size() / sizeof(uint32_t),
+						nullptr,
+						0,
+						SPIRV_TO_MESA_STAGES[stage],
+						entry_point,
+						dxil_spirv_nir_get_spirv_options(), &nir_options);
+				if (!nir_shader) {
+					free_nir_shaders();
+					ERR_FAIL_V_MSG(Vector<uint8_t>(), "Shader translation (step 1) at stage " + String(shader_stage_names[stage]) + " failed.");
+				}
+
+#ifdef DEV_ENABLED
+				nir_validate_shader(nir_shader, "Validate before feeding NIR to the DXIL compiler");
+#endif
+
+				if (stage == SHADER_STAGE_VERTEX) {
+					dxil_runtime_conf.yz_flip.y_mask = 0xffff;
+					dxil_runtime_conf.yz_flip.mode = DXIL_SPIRV_Y_FLIP_UNCONDITIONAL;
+				} else {
+					dxil_runtime_conf.yz_flip.y_mask = 0;
+					dxil_runtime_conf.yz_flip.mode = DXIL_SPIRV_YZ_FLIP_NONE;
+				}
+
+				// This is based on spirv2dxil.c. May need updates when it changes.
+				dxil_spirv_nir_prep(nir_shader);
+				bool requires_runtime_data = {};
+				dxil_spirv_nir_passes(nir_shader, &dxil_runtime_conf, &requires_runtime_data);
+
+				stages_nir_shaders[stage] = nir_shader;
+			}
+		}
+
+		// - Link NIR shaders.
+		for (int i = SHADER_STAGE_MAX - 1; i >= 0; i--) {
+			if (!stages_nir_shaders.has(i)) {
+				continue;
+			}
+			nir_shader *shader = stages_nir_shaders[i];
+			nir_shader *prev_shader = nullptr;
+			for (int j = i - 1; j >= 0; j--) {
+				if (stages_nir_shaders.has(j)) {
+					prev_shader = stages_nir_shaders[j];
+					break;
+				}
+			}
+			if (prev_shader) {
+				bool requires_runtime_data = {};
+				dxil_spirv_nir_link(shader, prev_shader, &dxil_runtime_conf, &requires_runtime_data);
+			}
+		}
+
+		// - Translate NIR to DXIL.
+		for (int i = 0; i < p_spirv.size(); i++) {
+			ShaderStage stage = (ShaderStage)p_spirv[i].shader_stage;
+
+			struct ShaderData {
+				ShaderStage stage;
+				RenderingDeviceD3D12ShaderBinaryData &binary_data;
+				Vector<Vector<RenderingDeviceD3D12ShaderBinaryDataBinding>> &uniform_info;
+				Vector<RenderingDeviceD3D12ShaderBinarySpecializationConstant> &specialization_constants;
+			} shader_data{ stage, binary_data, uniform_info, specialization_constants };
+
+			GodotNirCallbacks godot_nir_callbacks = {};
+			godot_nir_callbacks.data = &shader_data;
+
+			godot_nir_callbacks.report_resource = [](uint32_t p_register, uint32_t p_space, uint32_t p_dxil_type, void *p_data) {
+				ShaderData &shader_data = *(ShaderData *)p_data;
+
+				// Types based on Mesa's dxil_container.h.
+				static const uint32_t DXIL_RES_SAMPLER = 1;
+				static const ResourceClass DXIL_TYPE_TO_CLASS[] = {
+					/* DXIL_RES_INVALID */ RES_CLASS_INVALID,
+					/* DXIL_RES_SAMPLER */ RES_CLASS_INVALID, // Handling sampler as a flag.
+					/* DXIL_RES_CBV */ RES_CLASS_CBV,
+					/* DXIL_RES_SRV_TYPED */ RES_CLASS_SRV,
+					/* DXIL_RES_SRV_RAW */ RES_CLASS_SRV,
+					/* DXIL_RES_SRV_STRUCTURED */ RES_CLASS_SRV,
+					/* DXIL_RES_UAV_TYPED */ RES_CLASS_UAV,
+					/* DXIL_RES_UAV_RAW */ RES_CLASS_UAV,
+					/* DXIL_RES_UAV_STRUCTURED */ RES_CLASS_UAV,
+					/* DXIL_RES_UAV_STRUCTURED_WITH_COUNTER */ RES_CLASS_INVALID,
+				};
+				DEV_ASSERT(p_dxil_type < ARRAY_SIZE(DXIL_TYPE_TO_CLASS));
+				ResourceClass res_class = DXIL_TYPE_TO_CLASS[p_dxil_type];
+
+				if (p_register == ROOT_CONSTANT_REGISTER && p_space == ROOT_CONSTANT_SPACE) {
+					DEV_ASSERT(res_class == RES_CLASS_CBV);
+					shader_data.binary_data.dxil_push_constant_stages |= (1 << shader_data.stage);
+				} else if (p_register == RUNTIME_DATA_REGISTER && p_space == RUNTIME_DATA_SPACE) {
+					DEV_ASSERT(res_class == RES_CLASS_CBV);
+					shader_data.binary_data.nir_runtime_data_root_param_idx = 1; // Temporary, to be determined later.
+				} else {
+					DEV_ASSERT(p_space == 0);
+
+					uint32_t set = p_register / GODOT_NIR_DESCRIPTOR_SET_MULTIPLIER;
+					uint32_t binding = (p_register % GODOT_NIR_DESCRIPTOR_SET_MULTIPLIER) / GODOT_NIR_BINDING_MULTIPLIER;
+
+					DEV_ASSERT(set < (uint32_t)shader_data.uniform_info.size());
+					bool found = false;
+					for (int i = 0; i < shader_data.uniform_info[set].size(); i++) {
+						if (shader_data.uniform_info[set][i].binding != binding) {
+							continue;
+						}
+
+						RenderingDeviceD3D12ShaderBinaryDataBinding &binding_info = shader_data.uniform_info.write[set].write[i];
+
+						binding_info.dxil_stages |= (1 << shader_data.stage);
+
+						if (res_class != RES_CLASS_INVALID) {
+							DEV_ASSERT(binding_info.res_class == (uint32_t)RES_CLASS_INVALID || binding_info.res_class == (uint32_t)res_class);
+							binding_info.res_class = res_class;
+						} else if (p_dxil_type == DXIL_RES_SAMPLER) {
+							binding_info.has_sampler = (uint32_t) true;
+						} else {
+							CRASH_NOW();
+						}
+
+						found = true;
+						break;
+					}
+					DEV_ASSERT(found);
+				}
+			};
+
+			godot_nir_callbacks.report_sc_bit_offset_fn = [](uint32_t p_sc_id, uint64_t p_bit_offset, void *p_data) {
+				ShaderData &shader_data = *(ShaderData *)p_data;
+
+				bool found = false;
+				for (int i = 0; i < shader_data.specialization_constants.size(); i++) {
+					if (shader_data.specialization_constants[i].constant_id != p_sc_id) {
+						continue;
+					}
+
+					uint32_t offset_idx = shader_stage_bit_offset_indices[shader_data.stage];
+					DEV_ASSERT(shader_data.specialization_constants.write[i].stages_bit_offsets[offset_idx] == 0);
+					shader_data.specialization_constants.write[i].stages_bit_offsets[offset_idx] = p_bit_offset;
+
+					found = true;
+					break;
+				}
+				DEV_ASSERT(found);
+			};
+
+			godot_nir_callbacks.report_bitcode_bit_offset_fn = [](uint64_t p_bit_offset, void *p_data) {
+				DEV_ASSERT(p_bit_offset % 8 == 0);
+				ShaderData &shader_data = *(ShaderData *)p_data;
+				uint32_t offset_idx = shader_stage_bit_offset_indices[shader_data.stage];
+				for (int i = 0; i < shader_data.specialization_constants.size(); i++) {
+					if (shader_data.specialization_constants.write[i].stages_bit_offsets[offset_idx] == 0) {
+						// This SC has been optimized out from this stage.
+						continue;
+					}
+					shader_data.specialization_constants.write[i].stages_bit_offsets[offset_idx] += p_bit_offset;
+				}
+			};
+
+			auto shader_model_d3d_to_dxil = [](D3D_SHADER_MODEL p_d3d_shader_model) -> dxil_shader_model {
+				static_assert(SHADER_MODEL_6_0 == 0x60000);
+				static_assert(SHADER_MODEL_6_3 == 0x60003);
+				static_assert(D3D_SHADER_MODEL_6_0 == 0x60);
+				static_assert(D3D_SHADER_MODEL_6_3 == 0x63);
+				return (dxil_shader_model)((p_d3d_shader_model >> 4) * 0x10000 + (p_d3d_shader_model & 0xf));
+			};
+
+			nir_to_dxil_options nir_to_dxil_options = {};
+			nir_to_dxil_options.environment = DXIL_ENVIRONMENT_VULKAN;
+			nir_to_dxil_options.shader_model_max = shader_model_d3d_to_dxil(context->get_shader_capabilities().shader_model);
+			nir_to_dxil_options.validator_version_max = dxil_get_validator_version(get_dxil_validator_for_current_thread());
+			nir_to_dxil_options.godot_nir_callbacks = &godot_nir_callbacks;
+
+			dxil_logger logger = {};
+			logger.log = [](void *p_priv, const char *p_msg) {
+#ifdef DEBUG_ENABLED
+				print_verbose(p_msg);
+#endif
+			};
+
+			blob dxil_blob = {};
+			bool ok = nir_to_dxil(stages_nir_shaders[stage], &nir_to_dxil_options, &logger, &dxil_blob);
+			ralloc_free(stages_nir_shaders[stage]);
+			stages_nir_shaders.erase(stage);
+			if (!ok) {
+				free_nir_shaders();
+				ERR_FAIL_V_MSG(Vector<uint8_t>(), "Shader translation at stage " + String(shader_stage_names[stage]) + " failed.");
+			}
+
+			Vector<uint8_t> blob_copy;
+			blob_copy.resize(dxil_blob.size);
+			memcpy(blob_copy.ptrw(), dxil_blob.data, dxil_blob.size);
+			blob_finish(&dxil_blob);
+			dxil_blobs.insert(stage, blob_copy);
+		}
+	}
+
+#if 0
+	if (dxil_blobs.has(SHADER_STAGE_FRAGMENT)) {
+		Ref<FileAccess> f = FileAccess::open("res://1.dxil", FileAccess::WRITE);
+		f->store_buffer(dxil_blobs[SHADER_STAGE_FRAGMENT].ptr(), dxil_blobs[SHADER_STAGE_FRAGMENT].size());
+	}
+#endif
+
+	// Patch with default values of specialization constants.
+	if (specialization_constants.size()) {
+		for (const RenderingDeviceD3D12ShaderBinarySpecializationConstant &sc : specialization_constants) {
+			_shader_patch_dxil_specialization_constant((PipelineSpecializationConstantType)sc.type, &sc.int_value, sc.stages_bit_offsets, dxil_blobs, true);
+		}
+#if 0
+		if (dxil_blobs.has(SHADER_STAGE_FRAGMENT)) {
+			Ref<FileAccess> f = FileAccess::open("res://2.dxil", FileAccess::WRITE);
+			f->store_buffer(dxil_blobs[SHADER_STAGE_FRAGMENT].ptr(), dxil_blobs[SHADER_STAGE_FRAGMENT].size());
+		}
+#endif
+	}
+
+	// Sign.
+	for (KeyValue<ShaderStage, Vector<uint8_t>> &E : dxil_blobs) {
+		ShaderStage stage = E.key;
+		Vector<uint8_t> &dxil_blob = E.value;
+		bool sign_ok = _shader_sign_dxil_bytecode(stage, dxil_blob);
+		ERR_FAIL_COND_V(!sign_ok, Vector<uint8_t>());
+	}
+
+	// Build the root signature.
+	ComPtr<ID3DBlob> root_sig_blob;
+	{
+		auto stages_to_d3d12_visibility = [](uint32_t p_stages_mask) -> D3D12_SHADER_VISIBILITY {
+			switch (p_stages_mask) {
+				case SHADER_STAGE_VERTEX_BIT: {
+					return D3D12_SHADER_VISIBILITY_VERTEX;
+				}
+				case SHADER_STAGE_FRAGMENT_BIT: {
+					return D3D12_SHADER_VISIBILITY_PIXEL;
+				}
+				default: {
+					return D3D12_SHADER_VISIBILITY_ALL;
+				}
+			}
+		};
+
+		LocalVector<D3D12_ROOT_PARAMETER1> root_params;
+
+		// Root (push) constants.
+		if (binary_data.dxil_push_constant_stages) {
+			CD3DX12_ROOT_PARAMETER1 push_constant;
+			push_constant.InitAsConstants(
+					binary_data.push_constant_size / sizeof(uint32_t),
+					ROOT_CONSTANT_REGISTER,
+					ROOT_CONSTANT_SPACE,
+					stages_to_d3d12_visibility(binary_data.dxil_push_constant_stages));
+			root_params.push_back(push_constant);
+		}
+
+		// NIR-DXIL runtime data.
+		if (binary_data.nir_runtime_data_root_param_idx == 1) { // Set above to 1 when discovering runtime data is needed.
+			DEV_ASSERT(!binary_data.is_compute); // Could be supported if needed, but it's pointless as of now.
+			binary_data.nir_runtime_data_root_param_idx = root_params.size();
+			CD3DX12_ROOT_PARAMETER1 nir_runtime_data;
+			nir_runtime_data.InitAsConstants(
+					sizeof(dxil_spirv_vertex_runtime_data) / sizeof(uint32_t),
+					RUNTIME_DATA_REGISTER,
+					RUNTIME_DATA_SPACE,
+					D3D12_SHADER_VISIBILITY_VERTEX);
+			root_params.push_back(nir_runtime_data);
+		}
+
+		// Descriptor tables (up to two per uniform set, for resources and/or samplers).
+
+		// These have to stay around until serialization!
+		struct TraceableDescriptorTable {
+			uint32_t stages_mask = {};
+			Vector<D3D12_DESCRIPTOR_RANGE1> ranges;
+			Vector<RenderingDeviceD3D12ShaderBinaryDataBinding::RootSignatureLocation *> root_sig_locations;
+		};
+		Vector<TraceableDescriptorTable> resource_tables_maps;
+		Vector<TraceableDescriptorTable> sampler_tables_maps;
+
+		for (int set = 0; set < uniform_info.size(); set++) {
+			bool first_resource_in_set = true;
+			bool first_sampler_in_set = true;
+			uniform_info.write[set].sort();
+			for (int i = 0; i < uniform_info[set].size(); i++) {
+				const RenderingDeviceD3D12ShaderBinaryDataBinding &binding = uniform_info[set][i];
+
+				bool really_used = binding.dxil_stages != 0;
+#ifdef DEV_ENABLED
+				bool anybody_home = (ResourceClass)binding.res_class != RES_CLASS_INVALID || binding.has_sampler;
+				DEV_ASSERT(anybody_home == really_used);
+#endif
+				if (!really_used) {
+					continue; // Existed in SPIR-V; went away in DXIL.
+				}
+
+				auto insert_range = [](D3D12_DESCRIPTOR_RANGE_TYPE p_range_type,
+											uint32_t p_num_descriptors,
+											uint32_t p_dxil_register,
+											uint32_t p_dxil_stages_mask,
+											RenderingDeviceD3D12ShaderBinaryDataBinding::RootSignatureLocation(&p_root_sig_locations),
+											Vector<TraceableDescriptorTable> &r_tables,
+											bool &r_first_in_set) {
+					if (r_first_in_set) {
+						r_tables.resize(r_tables.size() + 1);
+						r_first_in_set = false;
+					}
+					TraceableDescriptorTable &table = r_tables.write[r_tables.size() - 1];
+					table.stages_mask |= p_dxil_stages_mask;
+
+					CD3DX12_DESCRIPTOR_RANGE1 range;
+					// Due to the aliasing hack for SRV-UAV of different families,
+					// we can be causing an unintended change of data (sometimes the validation layers catch it).
+					D3D12_DESCRIPTOR_RANGE_FLAGS flags = D3D12_DESCRIPTOR_RANGE_FLAG_NONE;
+					if (p_range_type == D3D12_DESCRIPTOR_RANGE_TYPE_SRV || p_range_type == D3D12_DESCRIPTOR_RANGE_TYPE_UAV) {
+						flags = D3D12_DESCRIPTOR_RANGE_FLAG_DATA_VOLATILE;
+					} else if (p_range_type == D3D12_DESCRIPTOR_RANGE_TYPE_CBV) {
+						flags = D3D12_DESCRIPTOR_RANGE_FLAG_DATA_STATIC_WHILE_SET_AT_EXECUTE;
+					}
+					range.Init(p_range_type, p_num_descriptors, p_dxil_register, 0, flags);
+
+					table.ranges.push_back(range);
+					table.root_sig_locations.push_back(&p_root_sig_locations);
+				};
+
+				uint32_t num_descriptors = 1;
+
+				D3D12_DESCRIPTOR_RANGE_TYPE resource_range_type = {};
+				switch ((ResourceClass)binding.res_class) {
+					case RES_CLASS_INVALID: {
+						num_descriptors = binding.length;
+						DEV_ASSERT(binding.has_sampler);
+					} break;
+					case RES_CLASS_CBV: {
+						resource_range_type = D3D12_DESCRIPTOR_RANGE_TYPE_CBV;
+						DEV_ASSERT(!binding.has_sampler);
+					} break;
+					case RES_CLASS_SRV: {
+						resource_range_type = D3D12_DESCRIPTOR_RANGE_TYPE_SRV;
+						num_descriptors = MAX(1u, binding.length); // An unbound R/O buffer is reflected as zero-size.
+					} break;
+					case RES_CLASS_UAV: {
+						resource_range_type = D3D12_DESCRIPTOR_RANGE_TYPE_UAV;
+						num_descriptors = MAX(1u, binding.length); // An unbound R/W buffer is reflected as zero-size.
+						DEV_ASSERT(!binding.has_sampler);
+					} break;
+				}
+
+				uint32_t dxil_register = set * GODOT_NIR_DESCRIPTOR_SET_MULTIPLIER + binding.binding * GODOT_NIR_BINDING_MULTIPLIER;
+
+				if (binding.res_class != RES_CLASS_INVALID) {
+					insert_range(
+							resource_range_type,
+							num_descriptors,
+							dxil_register,
+							uniform_info[set][i].dxil_stages,
+							uniform_info.write[set].write[i].root_sig_locations[RS_LOC_TYPE_RESOURCE],
+							resource_tables_maps,
+							first_resource_in_set);
+				}
+				if (binding.has_sampler) {
+					insert_range(
+							D3D12_DESCRIPTOR_RANGE_TYPE_SAMPLER,
+							num_descriptors,
+							dxil_register,
+							uniform_info[set][i].dxil_stages,
+							uniform_info.write[set].write[i].root_sig_locations[RS_LOC_TYPE_SAMPLER],
+							sampler_tables_maps,
+							first_sampler_in_set);
+				}
+			}
+		}
+
+		auto make_descriptor_tables = [&root_params, &stages_to_d3d12_visibility](const Vector<TraceableDescriptorTable> &p_tables) {
+			for (const TraceableDescriptorTable &table : p_tables) {
+				D3D12_SHADER_VISIBILITY visibility = stages_to_d3d12_visibility(table.stages_mask);
+				DEV_ASSERT(table.ranges.size() == table.root_sig_locations.size());
+				for (int i = 0; i < table.ranges.size(); i++) {
+					// By now we know very well which root signature location corresponds to the pointed uniform.
+					table.root_sig_locations[i]->root_param_idx = root_params.size();
+					table.root_sig_locations[i]->range_idx = i;
+				}
+
+				CD3DX12_ROOT_PARAMETER1 root_table;
+				root_table.InitAsDescriptorTable(table.ranges.size(), table.ranges.ptr(), visibility);
+				root_params.push_back(root_table);
+			}
+		};
+
+		make_descriptor_tables(resource_tables_maps);
+		make_descriptor_tables(sampler_tables_maps);
+
+		CD3DX12_VERSIONED_ROOT_SIGNATURE_DESC root_sig_desc = {};
+		D3D12_ROOT_SIGNATURE_FLAGS root_sig_flags =
+				D3D12_ROOT_SIGNATURE_FLAG_DENY_HULL_SHADER_ROOT_ACCESS |
+				D3D12_ROOT_SIGNATURE_FLAG_DENY_DOMAIN_SHADER_ROOT_ACCESS |
+				D3D12_ROOT_SIGNATURE_FLAG_DENY_GEOMETRY_SHADER_ROOT_ACCESS |
+				D3D12_ROOT_SIGNATURE_FLAG_DENY_AMPLIFICATION_SHADER_ROOT_ACCESS |
+				D3D12_ROOT_SIGNATURE_FLAG_DENY_MESH_SHADER_ROOT_ACCESS;
+		if (!stages_processed.has_flag(SHADER_STAGE_VERTEX_BIT)) {
+			root_sig_flags |= D3D12_ROOT_SIGNATURE_FLAG_DENY_VERTEX_SHADER_ROOT_ACCESS;
+		}
+		if (!stages_processed.has_flag(SHADER_STAGE_FRAGMENT_BIT)) {
+			root_sig_flags |= D3D12_ROOT_SIGNATURE_FLAG_DENY_PIXEL_SHADER_ROOT_ACCESS;
+		}
+		if (binary_data.vertex_input_mask) {
+			root_sig_flags |= D3D12_ROOT_SIGNATURE_FLAG_ALLOW_INPUT_ASSEMBLER_INPUT_LAYOUT;
+		}
+		root_sig_desc.Init_1_1(root_params.size(), root_params.ptr(), 0, nullptr, root_sig_flags);
+
+		ComPtr<ID3DBlob> error_blob;
+		HRESULT res = D3DX12SerializeVersionedRootSignature(&root_sig_desc, D3D_ROOT_SIGNATURE_VERSION_1_1, root_sig_blob.GetAddressOf(), error_blob.GetAddressOf());
+		ERR_FAIL_COND_V_MSG(res, Vector<uint8_t>(),
+				"Serialization of root signature failed with error " + vformat("0x%08ux", res) + " and the following message:\n" + String((char *)error_blob->GetBufferPointer(), error_blob->GetBufferSize()));
+
+		binary_data.root_signature_crc = crc32(0, nullptr, 0);
+		binary_data.root_signature_crc = crc32(binary_data.root_signature_crc, (const Bytef *)root_sig_blob->GetBufferPointer(), root_sig_blob->GetBufferSize());
+	}
+
+	Vector<Vector<uint8_t>> compressed_stages;
+	Vector<uint32_t> zstd_size;
+
+	uint32_t stages_binary_size = 0;
+
+	for (int i = 0; i < p_spirv.size(); i++) {
+		Vector<uint8_t> zstd;
+		Vector<uint8_t> &dxil_blob = dxil_blobs[p_spirv[i].shader_stage];
+		zstd.resize(Compression::get_max_compressed_buffer_size(dxil_blob.size(), Compression::MODE_ZSTD));
+		int dst_size = Compression::compress(zstd.ptrw(), dxil_blob.ptr(), dxil_blob.size(), Compression::MODE_ZSTD);
+
+		zstd_size.push_back(dst_size);
+		zstd.resize(dst_size);
+		compressed_stages.push_back(zstd);
+
+		uint32_t s = compressed_stages[i].size();
+		if (s % 4 != 0) {
+			s += 4 - (s % 4);
+		}
+		stages_binary_size += s;
+	}
+
+	CharString shader_name_utf = p_shader_name.utf8();
+
+	binary_data.shader_name_len = shader_name_utf.length();
+
+	uint32_t total_size = sizeof(uint32_t) * 3; // Header + version + main datasize;.
+	total_size += sizeof(RenderingDeviceD3D12ShaderBinaryData);
+
+	total_size += binary_data.shader_name_len;
+	if ((binary_data.shader_name_len % 4) != 0) { // Alignment rules are really strange.
+		total_size += 4 - (binary_data.shader_name_len % 4);
+	}
+
+	for (int i = 0; i < uniform_info.size(); i++) {
+		total_size += sizeof(uint32_t);
+		total_size += uniform_info[i].size() * sizeof(RenderingDeviceD3D12ShaderBinaryDataBinding);
+	}
+
+	total_size += sizeof(RenderingDeviceD3D12ShaderBinarySpecializationConstant) * specialization_constants.size();
+
+	total_size += compressed_stages.size() * sizeof(uint32_t) * 3; // Sizes.
+	total_size += stages_binary_size;
+
+	binary_data.root_signature_len = root_sig_blob->GetBufferSize();
+	total_size += binary_data.root_signature_len;
+
+	Vector<uint8_t> ret;
+	ret.resize(total_size);
+	{
+		uint32_t offset = 0;
+		uint8_t *binptr = ret.ptrw();
+		binptr[0] = 'G';
+		binptr[1] = 'S';
+		binptr[2] = 'B';
+		binptr[3] = 'D'; // Godot shader binary data.
+		offset += 4;
+		encode_uint32(SHADER_BINARY_VERSION, binptr + offset);
+		offset += sizeof(uint32_t);
+		encode_uint32(sizeof(RenderingDeviceD3D12ShaderBinaryData), binptr + offset);
+		offset += sizeof(uint32_t);
+		memcpy(binptr + offset, &binary_data, sizeof(RenderingDeviceD3D12ShaderBinaryData));
+		offset += sizeof(RenderingDeviceD3D12ShaderBinaryData);
+
+		if (binary_data.shader_name_len > 0) {
+			memcpy(binptr + offset, shader_name_utf.ptr(), binary_data.shader_name_len);
+			offset += binary_data.shader_name_len;
+
+			if ((binary_data.shader_name_len % 4) != 0) { // Alignment rules are really strange.
+				offset += 4 - (binary_data.shader_name_len % 4);
+			}
+		}
+
+		for (int i = 0; i < uniform_info.size(); i++) {
+			int count = uniform_info[i].size();
+			encode_uint32(count, binptr + offset);
+			offset += sizeof(uint32_t);
+			if (count > 0) {
+				memcpy(binptr + offset, uniform_info[i].ptr(), sizeof(RenderingDeviceD3D12ShaderBinaryDataBinding) * count);
+				offset += sizeof(RenderingDeviceD3D12ShaderBinaryDataBinding) * count;
+			}
+		}
+
+		if (specialization_constants.size()) {
+			memcpy(binptr + offset, specialization_constants.ptr(), sizeof(RenderingDeviceD3D12ShaderBinarySpecializationConstant) * specialization_constants.size());
+			offset += sizeof(RenderingDeviceD3D12ShaderBinarySpecializationConstant) * specialization_constants.size();
+		}
+
+		for (int i = 0; i < compressed_stages.size(); i++) {
+			encode_uint32(p_spirv[i].shader_stage, binptr + offset);
+			offset += sizeof(uint32_t);
+			encode_uint32(dxil_blobs[p_spirv[i].shader_stage].size(), binptr + offset);
+			offset += sizeof(uint32_t);
+			encode_uint32(zstd_size[i], binptr + offset);
+			offset += sizeof(uint32_t);
+			memcpy(binptr + offset, compressed_stages[i].ptr(), compressed_stages[i].size());
+
+			uint32_t s = compressed_stages[i].size();
+
+			if (s % 4 != 0) {
+				s += 4 - (s % 4);
+			}
+
+			offset += s;
+		}
+
+		memcpy(binptr + offset, root_sig_blob->GetBufferPointer(), root_sig_blob->GetBufferSize());
+		offset += root_sig_blob->GetBufferSize();
+
+		ERR_FAIL_COND_V(offset != (uint32_t)ret.size(), Vector<uint8_t>());
+	}
+
+	return ret;
+}
+
+RID RenderingDeviceD3D12::shader_create_from_bytecode(const Vector<uint8_t> &p_shader_binary, RID p_placeholder) {
+	const uint8_t *binptr = p_shader_binary.ptr();
+	uint32_t binsize = p_shader_binary.size();
+
+	uint32_t read_offset = 0;
+	// Consistency check.
+	ERR_FAIL_COND_V(binsize < sizeof(uint32_t) * 3 + sizeof(RenderingDeviceD3D12ShaderBinaryData), RID());
+	ERR_FAIL_COND_V(binptr[0] != 'G' || binptr[1] != 'S' || binptr[2] != 'B' || binptr[3] != 'D', RID());
+
+	uint32_t bin_version = decode_uint32(binptr + 4);
+	ERR_FAIL_COND_V(bin_version != SHADER_BINARY_VERSION, RID());
+
+	uint32_t bin_data_size = decode_uint32(binptr + 8);
+
+	const RenderingDeviceD3D12ShaderBinaryData &binary_data = *(reinterpret_cast<const RenderingDeviceD3D12ShaderBinaryData *>(binptr + 12));
+
+	uint64_t vertex_input_mask = binary_data.vertex_input_mask;
+
+	uint32_t fragment_output_mask = binary_data.fragment_output_mask;
+
+	bool is_compute = binary_data.is_compute;
+
+	const uint32_t compute_local_size[3] = { binary_data.compute_local_size[0], binary_data.compute_local_size[1], binary_data.compute_local_size[2] };
+
+	read_offset += sizeof(uint32_t) * 3 + bin_data_size;
+
+	String name;
+
+	if (binary_data.shader_name_len) {
+		name.parse_utf8((const char *)(binptr + read_offset), binary_data.shader_name_len);
+		read_offset += binary_data.shader_name_len;
+		if ((binary_data.shader_name_len % 4) != 0) { // Alignment rules are really strange.
+			read_offset += 4 - (binary_data.shader_name_len % 4);
+		}
+	}
+
+	Vector<Shader::Set> set_info;
+	set_info.resize(binary_data.set_count);
+
+	for (uint32_t i = 0; i < binary_data.set_count; i++) {
+		ERR_FAIL_COND_V(read_offset + sizeof(uint32_t) >= binsize, RID());
+		uint32_t set_count = decode_uint32(binptr + read_offset);
+		read_offset += sizeof(uint32_t);
+		const RenderingDeviceD3D12ShaderBinaryDataBinding *set_ptr = reinterpret_cast<const RenderingDeviceD3D12ShaderBinaryDataBinding *>(binptr + read_offset);
+		uint32_t set_size = set_count * sizeof(RenderingDeviceD3D12ShaderBinaryDataBinding);
+		ERR_FAIL_COND_V(read_offset + set_size >= binsize, RID());
+
+		for (uint32_t j = 0; j < set_count; j++) {
+			Shader::ShaderUniformInfo sui;
+
+			sui.info.type = UniformType(set_ptr[j].type);
+			sui.info.writable = set_ptr[j].writable;
+			sui.info.length = set_ptr[j].length;
+			sui.info.binding = set_ptr[j].binding;
+
+			sui.binding.stages = set_ptr[j].dxil_stages;
+			sui.binding.res_class = (ResourceClass)set_ptr[j].res_class;
+			static_assert(sizeof(UniformBindingInfo::root_sig_locations) == sizeof(RenderingDeviceD3D12ShaderBinaryDataBinding::root_sig_locations));
+			memcpy(&sui.binding.root_sig_locations, &set_ptr[j].root_sig_locations, sizeof(UniformBindingInfo::root_sig_locations));
+
+			set_info.write[i].uniforms.push_back(sui);
+
+			if (sui.binding.root_sig_locations.resource.root_param_idx != UINT32_MAX) {
+				set_info.write[i].num_root_params.resources++;
+			}
+			if (sui.binding.root_sig_locations.sampler.root_param_idx != UINT32_MAX) {
+				set_info.write[i].num_root_params.samplers++;
+			}
+		}
+
+		read_offset += set_size;
+	}
+
+	ERR_FAIL_COND_V(read_offset + binary_data.specialization_constants_count * sizeof(RenderingDeviceD3D12ShaderBinarySpecializationConstant) >= binsize, RID());
+
+	Vector<Shader::SpecializationConstant> specialization_constants;
+
+	for (uint32_t i = 0; i < binary_data.specialization_constants_count; i++) {
+		const RenderingDeviceD3D12ShaderBinarySpecializationConstant &src_sc = *(reinterpret_cast<const RenderingDeviceD3D12ShaderBinarySpecializationConstant *>(binptr + read_offset));
+		Shader::SpecializationConstant sc;
+		sc.constant.int_value = src_sc.int_value;
+		sc.constant.type = PipelineSpecializationConstantType(src_sc.type);
+		sc.constant.constant_id = src_sc.constant_id;
+		memcpy(sc.stages_bit_offsets, src_sc.stages_bit_offsets, sizeof(sc.stages_bit_offsets));
+		specialization_constants.push_back(sc);
+
+		read_offset += sizeof(RenderingDeviceD3D12ShaderBinarySpecializationConstant);
+	}
+
+	HashMap<ShaderStage, Vector<uint8_t>> stages_bytecode;
+
+	for (uint32_t i = 0; i < binary_data.stage_count; i++) {
+		ERR_FAIL_COND_V(read_offset + sizeof(uint32_t) * 3 >= binsize, RID());
+		uint32_t stage = decode_uint32(binptr + read_offset);
+		read_offset += sizeof(uint32_t);
+		uint32_t dxil_size = decode_uint32(binptr + read_offset);
+		read_offset += sizeof(uint32_t);
+		uint32_t zstd_size = decode_uint32(binptr + read_offset);
+		read_offset += sizeof(uint32_t);
+
+		// Decompress.
+		Vector<uint8_t> dxil;
+		dxil.resize(dxil_size);
+		int dec_dxil_size = Compression::decompress(dxil.ptrw(), dxil.size(), binptr + read_offset, zstd_size, Compression::MODE_ZSTD);
+		ERR_FAIL_COND_V(dec_dxil_size != (int32_t)dxil_size, RID());
+		stages_bytecode[ShaderStage(stage)] = dxil;
+
+		if (zstd_size % 4 != 0) {
+			zstd_size += 4 - (zstd_size % 4);
+		}
+
+		ERR_FAIL_COND_V(read_offset + zstd_size > binsize, RID());
+
+		read_offset += zstd_size;
+	}
+
+	const uint8_t *root_sig_data_ptr = binptr + read_offset;
+
+	ComPtr<ID3D12RootSignatureDeserializer> root_sig_deserializer;
+	HRESULT res = D3D12CreateRootSignatureDeserializer(root_sig_data_ptr, binary_data.root_signature_len, IID_PPV_ARGS(root_sig_deserializer.GetAddressOf()));
+	ERR_FAIL_COND_V_MSG(res, RID(), "D3D12CreateRootSignatureDeserializer failed with error " + vformat("0x%08ux", res) + ".");
+	read_offset += binary_data.root_signature_len;
+
+	ERR_FAIL_COND_V(read_offset != binsize, RID());
+
+	// TODO: Need to lock?
+	_THREAD_SAFE_METHOD_
+
+	ComPtr<ID3D12RootSignature> root_signature;
+	res = device->CreateRootSignature(0, root_sig_data_ptr, binary_data.root_signature_len, IID_PPV_ARGS(root_signature.GetAddressOf()));
+	ERR_FAIL_COND_V_MSG(res, RID(), "CreateRootSignature failed with error " + vformat("0x%08ux", res) + ".");
+
+	RID id;
+	if (p_placeholder.is_null()) {
+		id = shader_owner.make_rid();
+	} else {
+		id = p_placeholder;
+	}
+
+	Shader *shader = shader_owner.get_or_null(id);
+	ERR_FAIL_NULL_V(shader, RID());
+
+	shader->vertex_input_mask = vertex_input_mask;
+	shader->fragment_output_mask = fragment_output_mask;
+	shader->spirv_push_constant_size = binary_data.push_constant_size;
+	shader->dxil_push_constant_size = binary_data.dxil_push_constant_stages ? binary_data.push_constant_size : 0;
+	shader->nir_runtime_data_root_param_idx = binary_data.nir_runtime_data_root_param_idx;
+	shader->is_compute = is_compute;
+	shader->compute_local_size[0] = compute_local_size[0];
+	shader->compute_local_size[1] = compute_local_size[1];
+	shader->compute_local_size[2] = compute_local_size[2];
+	shader->specialization_constants = specialization_constants;
+	shader->spirv_specialization_constants_ids_mask = binary_data.spirv_specialization_constants_ids_mask;
+	shader->name = name;
+	shader->root_signature = root_signature;
+	shader->root_signature_deserializer = root_sig_deserializer;
+	shader->root_signature_desc = root_sig_deserializer->GetRootSignatureDesc();
+	shader->root_signature_crc = binary_data.root_signature_crc;
+	shader->stages_bytecode = stages_bytecode;
+
+	// Proceed to create descriptor sets.
+	for (uint32_t i = 0; i < binary_data.set_count; i++) {
+		uint32_t format = 0; // No format, default.
+
+		Shader::Set &set = set_info.write[i];
+		if (set.uniforms.size()) {
+			// Has data, needs an actual format;.
+			UniformSetFormat usformat;
+			usformat.uniform_info.resize(set.uniforms.size());
+			for (int j = 0; j < set.uniforms.size(); j++) {
+				usformat.uniform_info.write[j] = set.uniforms[j].info;
+			}
+			RBMap<UniformSetFormat, uint32_t>::Element *E = uniform_set_format_cache.find(usformat);
+			if (E) {
+				format = E->get();
+			} else {
+				format = uniform_set_format_cache.size() + 1;
+				E = uniform_set_format_cache.insert(usformat, format);
+				uniform_set_format_cache_reverse.push_back(E);
+				DEV_ASSERT(uniform_set_format_cache_reverse.size() == uniform_set_format_cache.size());
+			}
+		}
+
+		shader->sets.push_back(set);
+		shader->set_formats.push_back(format);
+	}
+
+#ifdef DEV_ENABLED
+	set_resource_name(id, "RID:" + itos(id.get_id()));
+#endif
+	return id;
+}
+
+RID RenderingDeviceD3D12::shader_create_placeholder() {
+	Shader shader;
+	return shader_owner.make_rid(shader);
+}
+
+uint64_t RenderingDeviceD3D12::shader_get_vertex_input_attribute_mask(RID p_shader) {
+	_THREAD_SAFE_METHOD_
+
+	const Shader *shader = shader_owner.get_or_null(p_shader);
+	ERR_FAIL_NULL_V(shader, 0);
+	return shader->vertex_input_mask;
+}
+
+/******************/
+/**** UNIFORMS ****/
+/******************/
+
+RID RenderingDeviceD3D12::uniform_buffer_create(uint32_t p_size_bytes, const Vector<uint8_t> &p_data) {
+	_THREAD_SAFE_METHOD_
+
+	ERR_FAIL_COND_V(p_data.size() && (uint32_t)p_data.size() != p_size_bytes, RID());
+
+	Buffer buffer;
+	Error err = _buffer_allocate(&buffer, p_size_bytes, D3D12_RESOURCE_STATE_VERTEX_AND_CONSTANT_BUFFER, D3D12_HEAP_TYPE_DEFAULT);
+	ERR_FAIL_COND_V(err != OK, RID());
+
+	if (p_data.size()) {
+		uint64_t data_size = p_data.size();
+		const uint8_t *r = p_data.ptr();
+		_buffer_update(&buffer, 0, r, data_size);
+	}
+	RID id = uniform_buffer_owner.make_rid(buffer);
+#ifdef DEV_ENABLED
+	set_resource_name(id, "RID:" + itos(id.get_id()));
+#endif
+	return id;
+}
+
+RID RenderingDeviceD3D12::storage_buffer_create(uint32_t p_size_bytes, const Vector<uint8_t> &p_data, BitField<StorageBufferUsage> p_usage) {
+	_THREAD_SAFE_METHOD_
+
+	ERR_FAIL_COND_V(p_data.size() && (uint32_t)p_data.size() != p_size_bytes, RID());
+
+	Buffer buffer;
+	D3D12_RESOURCE_STATES states = D3D12_RESOURCE_STATE_COPY_SOURCE | D3D12_RESOURCE_STATE_COPY_DEST | D3D12_RESOURCE_STATE_UNORDERED_ACCESS;
+	if (p_usage.has_flag(STORAGE_BUFFER_USAGE_DISPATCH_INDIRECT)) {
+		states |= D3D12_RESOURCE_STATE_INDIRECT_ARGUMENT;
+	}
+	Error err = _buffer_allocate(&buffer, p_size_bytes, states, D3D12_HEAP_TYPE_DEFAULT);
+	ERR_FAIL_COND_V(err != OK, RID());
+
+	if (p_data.size()) {
+		uint64_t data_size = p_data.size();
+		const uint8_t *r = p_data.ptr();
+		_buffer_update(&buffer, 0, r, data_size);
+	}
+	return storage_buffer_owner.make_rid(buffer);
+}
+
+RID RenderingDeviceD3D12::texture_buffer_create(uint32_t p_size_elements, DataFormat p_format, const Vector<uint8_t> &p_data) {
+	_THREAD_SAFE_METHOD_
+
+	uint32_t element_size = get_format_vertex_size(p_format);
+	ERR_FAIL_COND_V_MSG(element_size == 0, RID(), "Format requested is not supported for texture buffers");
+	uint64_t size_bytes = uint64_t(element_size) * p_size_elements;
+
+	ERR_FAIL_COND_V(p_data.size() && (uint32_t)p_data.size() != size_bytes, RID());
+
+	TextureBuffer texture_buffer;
+	Error err = _buffer_allocate(&texture_buffer.buffer, size_bytes, D3D12_RESOURCE_STATE_ALL_SHADER_RESOURCE, D3D12_HEAP_TYPE_DEFAULT);
+	ERR_FAIL_COND_V(err != OK, RID());
+
+	if (p_data.size()) {
+		uint64_t data_size = p_data.size();
+		const uint8_t *r = p_data.ptr();
+		_buffer_update(&texture_buffer.buffer, 0, r, data_size);
+	}
+
+	// Allocate the view.
+	RID id = texture_buffer_owner.make_rid(texture_buffer);
+#ifdef DEV_ENABLED
+	set_resource_name(id, "RID:" + itos(id.get_id()));
+#endif
+	return id;
+}
+
+Error RenderingDeviceD3D12::DescriptorsHeap::allocate(ID3D12Device *p_device, D3D12_DESCRIPTOR_HEAP_TYPE p_type, uint32_t p_descriptor_count, bool p_for_gpu) {
+	ERR_FAIL_COND_V(heap, ERR_ALREADY_EXISTS);
+	ERR_FAIL_COND_V(p_descriptor_count == 0, ERR_INVALID_PARAMETER);
+
+	handle_size = p_device->GetDescriptorHandleIncrementSize(p_type);
+
+	desc.Type = p_type;
+	desc.NumDescriptors = p_descriptor_count;
+	desc.Flags = p_for_gpu ? D3D12_DESCRIPTOR_HEAP_FLAG_SHADER_VISIBLE : D3D12_DESCRIPTOR_HEAP_FLAG_NONE;
+	HRESULT res = p_device->CreateDescriptorHeap(&desc, IID_PPV_ARGS(heap.GetAddressOf()));
+	ERR_FAIL_COND_V_MSG(res, ERR_CANT_CREATE, "CreateDescriptorHeap failed with error " + vformat("0x%08ux", res) + ".");
+
+	return OK;
+}
+
+RenderingDeviceD3D12::DescriptorsHeap::Walker RenderingDeviceD3D12::DescriptorsHeap::make_walker() const {
+	Walker walker;
+	walker.handle_size = handle_size;
+	walker.handle_count = desc.NumDescriptors;
+	if (heap) {
+		walker.first_cpu_handle = heap->GetCPUDescriptorHandleForHeapStart();
+		if ((desc.Flags & D3D12_DESCRIPTOR_HEAP_FLAG_SHADER_VISIBLE)) {
+			walker.first_gpu_handle = heap->GetGPUDescriptorHandleForHeapStart();
+		}
+	}
+	return walker;
+}
+
+void RenderingDeviceD3D12::DescriptorsHeap::Walker::advance(uint32_t p_count) {
+	ERR_FAIL_COND_MSG(handle_index + p_count > handle_count, "Would advance past EOF.");
+	handle_index += p_count;
+}
+
+D3D12_CPU_DESCRIPTOR_HANDLE RenderingDeviceD3D12::DescriptorsHeap::Walker::get_curr_cpu_handle() {
+	ERR_FAIL_COND_V_MSG(is_at_eof(), D3D12_CPU_DESCRIPTOR_HANDLE(), "Heap walker is at EOF.");
+	return D3D12_CPU_DESCRIPTOR_HANDLE{ first_cpu_handle.ptr + handle_index * handle_size };
+}
+
+D3D12_GPU_DESCRIPTOR_HANDLE RenderingDeviceD3D12::DescriptorsHeap::Walker::get_curr_gpu_handle() {
+	ERR_FAIL_COND_V_MSG(!first_gpu_handle.ptr, D3D12_GPU_DESCRIPTOR_HANDLE(), "Can't provide a GPU handle from a non-GPU descriptors heap.");
+	ERR_FAIL_COND_V_MSG(is_at_eof(), D3D12_GPU_DESCRIPTOR_HANDLE(), "Heap walker is at EOF.");
+	return D3D12_GPU_DESCRIPTOR_HANDLE{ first_gpu_handle.ptr + handle_index * handle_size };
+}
+
+static void _add_descriptor_count_for_uniform(RenderingDevice::UniformType p_type, uint32_t p_binding_length, bool p_dobule_srv_uav_ambiguous, uint32_t &r_num_resources, uint32_t &r_num_samplers, bool &r_srv_uav_ambiguity) {
+	r_srv_uav_ambiguity = false;
+
+	// Some resource types can be SRV or UAV, depending on what NIR-DXIL decided for a specific shader variant.
+	// The goal is to generate both SRV and UAV for the descriptor sets' heaps and copy only the relevant one
+	// to the frame descriptor heap at binding time.
+	// [[SRV_UAV_AMBIGUITY]]
+
+	switch (p_type) {
+		case RenderingDevice::UNIFORM_TYPE_SAMPLER: {
+			r_num_samplers += p_binding_length;
+		} break;
+		case RenderingDevice::UNIFORM_TYPE_SAMPLER_WITH_TEXTURE:
+		case RenderingDevice::UNIFORM_TYPE_SAMPLER_WITH_TEXTURE_BUFFER: {
+			r_num_resources += p_binding_length;
+			r_num_samplers += p_binding_length;
+		} break;
+		case RenderingDevice::UNIFORM_TYPE_UNIFORM_BUFFER: {
+			r_num_resources += 1;
+		} break;
+		case RenderingDevice::UNIFORM_TYPE_STORAGE_BUFFER: {
+			r_num_resources += p_dobule_srv_uav_ambiguous ? 2 : 1;
+			r_srv_uav_ambiguity = true;
+		} break;
+		case RenderingDevice::UNIFORM_TYPE_IMAGE: {
+			r_num_resources += p_binding_length * (p_dobule_srv_uav_ambiguous ? 2 : 1);
+			r_srv_uav_ambiguity = true;
+		} break;
+		default: {
+			r_num_resources += p_binding_length;
+		}
+	}
+}
+
+RID RenderingDeviceD3D12::uniform_set_create(const Vector<Uniform> &p_uniforms, RID p_shader, uint32_t p_shader_set) {
+	_THREAD_SAFE_METHOD_
+
+	ERR_FAIL_COND_V(p_uniforms.size() == 0, RID());
+
+	Shader *shader = shader_owner.get_or_null(p_shader);
+	ERR_FAIL_NULL_V(shader, RID());
+
+	ERR_FAIL_COND_V_MSG(p_shader_set >= (uint32_t)shader->sets.size() || shader->sets[p_shader_set].uniforms.size() == 0, RID(),
+			"Desired set (" + itos(p_shader_set) + ") not used by shader.");
+	// See that all sets in shader are satisfied.
+
+	const Shader::Set &set = shader->sets[p_shader_set];
+
+	uint32_t uniform_count = p_uniforms.size();
+	const Uniform *uniforms = p_uniforms.ptr();
+
+	uint32_t set_uniform_count = set.uniforms.size();
+	const Shader::ShaderUniformInfo *set_uniforms = set.uniforms.ptr();
+
+	// Do a first pass to count resources and samplers, and error checking.
+	uint32_t num_resource_descs = 0;
+	uint32_t num_sampler_descs = 0;
+	LocalVector<int> uniform_indices;
+	uniform_indices.resize(set_uniform_count);
+	for (uint32_t i = 0; i < set_uniform_count; i++) {
+		const UniformInfo &set_uniform = set_uniforms[i].info;
+		int uniform_idx = -1;
+		for (int j = 0; j < (int)uniform_count; j++) {
+			if (uniforms[j].binding == set_uniform.binding) {
+				uniform_idx = j;
+			}
+		}
+		ERR_FAIL_COND_V_MSG(uniform_idx == -1, RID(),
+				"All the shader bindings for the given set must be covered by the uniforms provided. Binding (" + itos(set_uniform.binding) + "), set (" + itos(p_shader_set) + ") was not provided.");
+		uniform_indices[i] = uniform_idx;
+
+		const Uniform &uniform = uniforms[uniform_idx];
+		ERR_FAIL_COND_V_MSG(uniform.uniform_type != set_uniform.type, RID(),
+				"Mismatch uniform type for binding (" + itos(set_uniform.binding) + "), set (" + itos(p_shader_set) + "). Expected '" + shader_uniform_names[set_uniform.type] + "', supplied: '" + shader_uniform_names[uniform.uniform_type] + "'.");
+
+		// Since the uniform set may be created for a shader different than the one that will be actually bound,
+		// which may have a different set of uniforms optimized out, the stages mask we can check now is not reliable.
+		// Therefore, we can't make any assumptions here about descriptors that we may not need to create,
+		// pixel or vertex-only shader resource states, etc.
+
+		bool srv_uav_ambiguity = false;
+		_add_descriptor_count_for_uniform(uniform.uniform_type, set_uniform.length, true, num_resource_descs, num_sampler_descs, srv_uav_ambiguity);
+	}
+
+	struct {
+		DescriptorsHeap resources;
+		DescriptorsHeap samplers;
+	} desc_heaps;
+#ifdef DEV_ENABLED
+	LocalVector<UniformSet::ResourceDescInfo> resources_desc_info;
+#endif
+
+	if (num_resource_descs) {
+		Error err = desc_heaps.resources.allocate(device.Get(), D3D12_DESCRIPTOR_HEAP_TYPE_CBV_SRV_UAV, num_resource_descs, false);
+		ERR_FAIL_COND_V(err, RID());
+	}
+	if (num_sampler_descs) {
+		Error err = desc_heaps.samplers.allocate(device.Get(), D3D12_DESCRIPTOR_HEAP_TYPE_SAMPLER, num_sampler_descs, false);
+		ERR_FAIL_COND_V(err, RID());
+	}
+	struct {
+		DescriptorsHeap::Walker resources;
+		DescriptorsHeap::Walker samplers;
+	} desc_heap_walkers;
+	desc_heap_walkers.resources = desc_heaps.resources.make_walker();
+	desc_heap_walkers.samplers = desc_heaps.samplers.make_walker();
+
+	// Used for verification to make sure a uniform set does not use a framebuffer bound texture.
+	LocalVector<UniformSet::AttachableTexture> attachable_textures;
+	struct RIDState {
+		bool is_buffer = false;
+		uint64_t shader_uniform_idx_mask = 0;
+		ResourceState state;
+	};
+	HashMap<Resource *, RIDState> resource_states;
+
+	for (uint32_t i = 0; i < set_uniform_count; i++) {
+		const Shader::ShaderUniformInfo &set_uniform = set_uniforms[i];
+		const Uniform &uniform = uniforms[uniform_indices[i]];
+
+		// Stages defined in the shader may be missing for a uniform due to the optimizer,
+		// but the opposite (extraneous stages present in the uniform stages mask) would be an error.
+		DEV_ASSERT(!(shader->is_compute && (set_uniform.binding.stages & (SHADER_STAGE_VERTEX_BIT | SHADER_STAGE_FRAGMENT_BIT))));
+		DEV_ASSERT(!(!shader->is_compute && (set_uniform.binding.stages & SHADER_STAGE_COMPUTE_BIT)));
+
+		switch (uniform.uniform_type) {
+			case UNIFORM_TYPE_SAMPLER: {
+				if (uniform.get_id_count() != (uint32_t)set_uniform.info.length) {
+					if (set_uniform.info.length > 1) {
+						ERR_FAIL_V_MSG(RID(), "Sampler (binding: " + itos(uniform.binding) + ") is an array of (" + itos(set_uniform.info.length) + ") sampler elements, so it should be provided equal number of sampler IDs to satisfy it (IDs provided: " + itos(uniform.get_id_count()) + ").");
+					} else {
+						ERR_FAIL_V_MSG(RID(), "Sampler (binding: " + itos(uniform.binding) + ") should provide one ID referencing a sampler (IDs provided: " + itos(uniform.get_id_count()) + ").");
+					}
+				}
+
+				for (uint32_t j = 0; j < uniform.get_id_count(); j++) {
+					D3D12_SAMPLER_DESC *sampler_desc = sampler_owner.get_or_null(uniform.get_id(j));
+					ERR_FAIL_COND_V_MSG(!sampler_desc, RID(), "Sampler (binding: " + itos(uniform.binding) + ", index " + itos(j) + ") is not a valid sampler.");
+
+					device->CreateSampler(sampler_desc, desc_heap_walkers.samplers.get_curr_cpu_handle());
+					desc_heap_walkers.samplers.advance();
+				}
+			} break;
+			case UNIFORM_TYPE_SAMPLER_WITH_TEXTURE: {
+				if (uniform.get_id_count() != (uint32_t)set_uniform.info.length * 2) {
+					if (set_uniform.info.length > 1) {
+						ERR_FAIL_V_MSG(RID(), "SamplerTexture (binding: " + itos(uniform.binding) + ") is an array of (" + itos(set_uniform.info.length) + ") sampler&texture elements, so it should provided twice the amount of IDs (sampler,texture pairs) to satisfy it (IDs provided: " + itos(uniform.get_id_count()) + ").");
+					} else {
+						ERR_FAIL_V_MSG(RID(), "SamplerTexture (binding: " + itos(uniform.binding) + ") should provide two IDs referencing a sampler and then a texture (IDs provided: " + itos(uniform.get_id_count()) + ").");
+					}
+				}
+
+				for (uint32_t j = 0; j < uniform.get_id_count(); j += 2) {
+					D3D12_SAMPLER_DESC *sampler_desc = sampler_owner.get_or_null(uniform.get_id(j));
+					ERR_FAIL_COND_V_MSG(!sampler_desc, RID(), "SamplerTexture (binding: " + itos(uniform.binding) + ", index " + itos(j) + ") is not a valid sampler.");
+
+					RID rid = uniform.get_id(j + 1);
+					Texture *texture = texture_owner.get_or_null(rid);
+					ERR_FAIL_COND_V_MSG(!texture, RID(), "SamplerTexture (binding: " + itos(uniform.binding) + ", index " + itos(j) + ") is not a valid texture.");
+
+					ERR_FAIL_COND_V_MSG(!(texture->usage_flags & TEXTURE_USAGE_SAMPLING_BIT), RID(),
+							"Texture (binding: " + itos(uniform.binding) + ", index " + itos(j) + ") needs the TEXTURE_USAGE_SAMPLING_BIT usage flag set in order to be used as uniform.");
+
+					device->CreateSampler(sampler_desc, desc_heap_walkers.samplers.get_curr_cpu_handle());
+					desc_heap_walkers.samplers.advance();
+					device->CreateShaderResourceView(texture->resource, &texture->srv_desc, desc_heap_walkers.resources.get_curr_cpu_handle());
+#ifdef DEV_ENABLED
+					resources_desc_info.push_back({ D3D12_DESCRIPTOR_RANGE_TYPE_SRV, texture->srv_desc.ViewDimension });
+#endif
+					desc_heap_walkers.resources.advance();
+
+					RIDState &rs = resource_states[texture];
+					rs.shader_uniform_idx_mask |= ((uint64_t)1 << i);
+					rs.state.extend(D3D12_RESOURCE_STATE_ALL_SHADER_RESOURCE);
+
+					if (texture->usage_flags & (TEXTURE_USAGE_COLOR_ATTACHMENT_BIT | TEXTURE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT | TEXTURE_USAGE_INPUT_ATTACHMENT_BIT)) {
+						UniformSet::AttachableTexture attachable_texture;
+						attachable_texture.bind = set_uniform.info.binding;
+						attachable_texture.texture = texture->owner.is_valid() ? texture->owner : uniform.get_id(j + 1);
+						attachable_textures.push_back(attachable_texture);
+					}
+
+					DEV_ASSERT(!texture->owner.is_valid() || texture_owner.get_or_null(texture->owner));
+				}
+			} break;
+			case UNIFORM_TYPE_TEXTURE: {
+				if (uniform.get_id_count() != (uint32_t)set_uniform.info.length) {
+					if (set_uniform.info.length > 1) {
+						ERR_FAIL_V_MSG(RID(), "Texture (binding: " + itos(uniform.binding) + ") is an array of (" + itos(set_uniform.info.length) + ") textures, so it should be provided equal number of texture IDs to satisfy it (IDs provided: " + itos(uniform.get_id_count()) + ").");
+					} else {
+						ERR_FAIL_V_MSG(RID(), "Texture (binding: " + itos(uniform.binding) + ") should provide one ID referencing a texture (IDs provided: " + itos(uniform.get_id_count()) + ").");
+					}
+				}
+
+				for (uint32_t j = 0; j < uniform.get_id_count(); j++) {
+					RID rid = uniform.get_id(j);
+					Texture *texture = texture_owner.get_or_null(rid);
+					ERR_FAIL_COND_V_MSG(!texture, RID(), "Texture (binding: " + itos(uniform.binding) + ", index " + itos(j) + ") is not a valid texture.");
+
+					ERR_FAIL_COND_V_MSG(!(texture->usage_flags & TEXTURE_USAGE_SAMPLING_BIT), RID(),
+							"Texture (binding: " + itos(uniform.binding) + ", index " + itos(j) + ") needs the TEXTURE_USAGE_SAMPLING_BIT usage flag set in order to be used as uniform.");
+
+					device->CreateShaderResourceView(texture->resource, &texture->srv_desc, desc_heap_walkers.resources.get_curr_cpu_handle());
+#ifdef DEV_ENABLED
+					resources_desc_info.push_back({ D3D12_DESCRIPTOR_RANGE_TYPE_SRV, texture->srv_desc.ViewDimension });
+#endif
+					desc_heap_walkers.resources.advance();
+
+					RIDState &rs = resource_states[texture];
+					rs.shader_uniform_idx_mask |= ((uint64_t)1 << i);
+					rs.state.extend(D3D12_RESOURCE_STATE_ALL_SHADER_RESOURCE);
+
+					if ((texture->usage_flags & (TEXTURE_USAGE_COLOR_ATTACHMENT_BIT | TEXTURE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT | TEXTURE_USAGE_INPUT_ATTACHMENT_BIT))) {
+						UniformSet::AttachableTexture attachable_texture;
+						attachable_texture.bind = set_uniform.info.binding;
+						attachable_texture.texture = texture->owner.is_valid() ? texture->owner : uniform.get_id(j);
+						attachable_textures.push_back(attachable_texture);
+					}
+
+					DEV_ASSERT(!texture->owner.is_valid() || texture_owner.get_or_null(texture->owner));
+				}
+			} break;
+			case UNIFORM_TYPE_IMAGE: {
+				if (uniform.get_id_count() != (uint32_t)set_uniform.info.length) {
+					if (set_uniform.info.length > 1) {
+						ERR_FAIL_V_MSG(RID(), "Image (binding: " + itos(uniform.binding) + ") is an array of (" + itos(set_uniform.info.length) + ") textures, so it should be provided equal number of texture IDs to satisfy it (IDs provided: " + itos(uniform.get_id_count()) + ").");
+					} else {
+						ERR_FAIL_V_MSG(RID(), "Image (binding: " + itos(uniform.binding) + ") should provide one ID referencing a texture (IDs provided: " + itos(uniform.get_id_count()) + ").");
+					}
+				}
+
+				for (uint32_t j = 0; j < uniform.get_id_count(); j++) {
+					RID rid = uniform.get_id(j);
+					Texture *texture = texture_owner.get_or_null(rid);
+
+					ERR_FAIL_COND_V_MSG(!texture, RID(),
+							"Image (binding: " + itos(uniform.binding) + ", index " + itos(j) + ") is not a valid texture.");
+
+					ERR_FAIL_COND_V_MSG(!(texture->usage_flags & TEXTURE_USAGE_STORAGE_BIT), RID(),
+							"Image (binding: " + itos(uniform.binding) + ", index " + itos(j) + ") needs the TEXTURE_USAGE_STORAGE_BIT usage flag set in order to be used as uniform.");
+
+					RIDState &rs = resource_states[texture];
+					rs.shader_uniform_idx_mask |= ((uint64_t)1 << i);
+					rs.state.extend(D3D12_RESOURCE_STATE_ALL_SHADER_RESOURCE | D3D12_RESOURCE_STATE_UNORDERED_ACCESS);
+				}
+
+				// SRVs first. [[SRV_UAV_AMBIGUITY]]
+				for (uint32_t j = 0; j < uniform.get_id_count(); j++) {
+					RID rid = uniform.get_id(j);
+					Texture *texture = texture_owner.get_or_null(rid);
+
+					ERR_FAIL_COND_V_MSG(!texture, RID(),
+							"Image (binding: " + itos(uniform.binding) + ", index " + itos(j) + ") is not a valid texture.");
+
+					ERR_FAIL_COND_V_MSG(!(texture->usage_flags & TEXTURE_USAGE_STORAGE_BIT), RID(),
+							"Image (binding: " + itos(uniform.binding) + ", index " + itos(j) + ") needs the TEXTURE_USAGE_STORAGE_BIT usage flag set in order to be used as uniform.");
+
+					device->CreateShaderResourceView(texture->resource, &texture->srv_desc, desc_heap_walkers.resources.get_curr_cpu_handle());
+#ifdef DEV_ENABLED
+					resources_desc_info.push_back({ D3D12_DESCRIPTOR_RANGE_TYPE_SRV, texture->srv_desc.ViewDimension });
+#endif
+					desc_heap_walkers.resources.advance();
+
+					DEV_ASSERT(!texture->owner.is_valid() || texture_owner.get_or_null(texture->owner));
+				}
+
+				// UAVs then. [[SRV_UAV_AMBIGUITY]]
+				for (uint32_t j = 0; j < uniform.get_id_count(); j++) {
+					RID rid = uniform.get_id(j);
+					Texture *texture = texture_owner.get_or_null(rid);
+
+					device->CreateUnorderedAccessView(texture->resource, nullptr, &texture->uav_desc, desc_heap_walkers.resources.get_curr_cpu_handle());
+#ifdef DEV_ENABLED
+					resources_desc_info.push_back({ D3D12_DESCRIPTOR_RANGE_TYPE_UAV, {} });
+#endif
+					desc_heap_walkers.resources.advance();
+				}
+			} break;
+			case UNIFORM_TYPE_TEXTURE_BUFFER: {
+				if (uniform.get_id_count() != (uint32_t)set_uniform.info.length) {
+					if (set_uniform.info.length > 1) {
+						ERR_FAIL_V_MSG(RID(), "Buffer (binding: " + itos(uniform.binding) + ") is an array of (" + itos(set_uniform.info.length) + ") texture buffer elements, so it should be provided equal number of texture buffer IDs to satisfy it (IDs provided: " + itos(uniform.get_id_count()) + ").");
+					} else {
+						ERR_FAIL_V_MSG(RID(), "Buffer (binding: " + itos(uniform.binding) + ") should provide one ID referencing a texture buffer (IDs provided: " + itos(uniform.get_id_count()) + ").");
+					}
+				}
+
+				for (uint32_t j = 0; j < uniform.get_id_count(); j++) {
+					TextureBuffer *buffer = texture_buffer_owner.get_or_null(uniform.get_id(j));
+					ERR_FAIL_COND_V_MSG(!buffer, RID(), "Texture Buffer (binding: " + itos(uniform.binding) + ", index " + itos(j) + ") is not a valid texture buffer.");
+
+					CRASH_NOW_MSG("Unimplemented!");
+				}
+			} break;
+			case UNIFORM_TYPE_SAMPLER_WITH_TEXTURE_BUFFER: {
+				CRASH_NOW();
+				if (uniform.get_id_count() != (uint32_t)set_uniform.info.length * 2) {
+					if (set_uniform.info.length > 1) {
+						ERR_FAIL_V_MSG(RID(), "SamplerBuffer (binding: " + itos(uniform.binding) + ") is an array of (" + itos(set_uniform.info.length) + ") sampler buffer elements, so it should provided twice the amount of IDs (sampler,buffer pairs) to satisfy it (IDs provided: " + itos(uniform.get_id_count()) + ").");
+					} else {
+						ERR_FAIL_V_MSG(RID(), "SamplerBuffer (binding: " + itos(uniform.binding) + ") should provide two IDs referencing a sampler and then a texture buffer (IDs provided: " + itos(uniform.get_id_count()) + ").");
+					}
+				}
+
+				for (uint32_t j = 0; j < uniform.get_id_count(); j += 2) {
+					D3D12_SAMPLER_DESC *sampler_desc = sampler_owner.get_or_null(uniform.get_id(j));
+					ERR_FAIL_COND_V_MSG(!sampler_desc, RID(), "SamplerBuffer (binding: " + itos(uniform.binding) + ", index " + itos(j + 1) + ") is not a valid sampler.");
+
+					TextureBuffer *buffer = texture_buffer_owner.get_or_null(uniform.get_id(j + 1));
+					ERR_FAIL_COND_V_MSG(!buffer, RID(), "SamplerBuffer (binding: " + itos(uniform.binding) + ", index " + itos(j + 1) + ") is not a valid texture buffer.");
+
+					device->CreateSampler(sampler_desc, desc_heap_walkers.samplers.get_curr_cpu_handle());
+					desc_heap_walkers.samplers.advance();
+
+					CRASH_NOW_MSG("Unimplemented!");
+				}
+			} break;
+			case UNIFORM_TYPE_IMAGE_BUFFER: {
+				// Todo.
+
+			} break;
+			case UNIFORM_TYPE_UNIFORM_BUFFER: {
+				ERR_FAIL_COND_V_MSG(uniform.get_id_count() != 1, RID(),
+						"Uniform buffer supplied (binding: " + itos(uniform.binding) + ") must provide one ID (" + itos(uniform.get_id_count()) + " provided).");
+
+				RID rid = uniform.get_id(0);
+				Buffer *buffer = uniform_buffer_owner.get_or_null(rid);
+				ERR_FAIL_COND_V_MSG(!buffer, RID(), "Uniform buffer supplied (binding: " + itos(uniform.binding) + ") is invalid.");
+
+				ERR_FAIL_COND_V_MSG(buffer->size < (uint32_t)set_uniform.info.length, RID(),
+						"Uniform buffer supplied (binding: " + itos(uniform.binding) + ") size (" + itos(buffer->size) + " is smaller than size of shader uniform: (" + itos(set_uniform.info.length) + ").");
+
+				D3D12_CONSTANT_BUFFER_VIEW_DESC cbv_desc = {};
+				cbv_desc.BufferLocation = buffer->resource->GetGPUVirtualAddress();
+				cbv_desc.SizeInBytes = ALIGN(buffer->size, 256);
+				device->CreateConstantBufferView(&cbv_desc, desc_heap_walkers.resources.get_curr_cpu_handle());
+				desc_heap_walkers.resources.advance();
+#ifdef DEV_ENABLED
+				resources_desc_info.push_back({ D3D12_DESCRIPTOR_RANGE_TYPE_CBV, {} });
+#endif
+
+				RIDState &rs = resource_states[buffer];
+				rs.is_buffer = true;
+				rs.shader_uniform_idx_mask |= ((uint64_t)1 << i);
+				rs.state.extend(D3D12_RESOURCE_STATE_VERTEX_AND_CONSTANT_BUFFER);
+			} break;
+			case UNIFORM_TYPE_STORAGE_BUFFER: {
+				ERR_FAIL_COND_V_MSG(uniform.get_id_count() != 1, RID(),
+						"Storage buffer supplied (binding: " + itos(uniform.binding) + ") must provide one ID (" + itos(uniform.get_id_count()) + " provided).");
+
+				RID rid = uniform.get_id(0);
+				Buffer *buffer = nullptr;
+
+				if (storage_buffer_owner.owns(rid)) {
+					buffer = storage_buffer_owner.get_or_null(rid);
+				} else if (vertex_buffer_owner.owns(rid)) {
+					buffer = vertex_buffer_owner.get_or_null(rid);
+					// Due to [[SRV_UAV_AMBIGUITY]] we can't make this check because it wouldn't make sense in the case of an SRV (r/o storage buffer).
+					//ERR_FAIL_COND_V_MSG(!(buffer->usage & D3D12_RESOURCE_STATE_UNORDERED_ACCESS), RID(), "Vertex buffer supplied (binding: " + itos(uniform.binding) + ") was not created with storage flag.");
+				}
+				ERR_FAIL_COND_V_MSG(!buffer, RID(), "Storage buffer supplied (binding: " + itos(uniform.binding) + ") is invalid.");
+
+				// If 0, then it's sized at link time.
+				ERR_FAIL_COND_V_MSG(set_uniform.info.length > 0 && buffer->size != (uint32_t)set_uniform.info.length, RID(),
+						"Storage buffer supplied (binding: " + itos(uniform.binding) + ") size (" + itos(buffer->size) + " does not match size of shader uniform: (" + itos(set_uniform.info.length) + ").");
+
+				RIDState &rs = resource_states[buffer];
+				rs.shader_uniform_idx_mask |= ((uint64_t)1 << i);
+				rs.is_buffer = true;
+				rs.state.extend(D3D12_RESOURCE_STATE_ALL_SHADER_RESOURCE | D3D12_RESOURCE_STATE_UNORDERED_ACCESS);
+
+				// SRV first. [[SRV_UAV_AMBIGUITY]]
+				{
+					D3D12_SHADER_RESOURCE_VIEW_DESC srv_desc = {};
+					srv_desc.Format = DXGI_FORMAT_R32_TYPELESS;
+					srv_desc.ViewDimension = D3D12_SRV_DIMENSION_BUFFER;
+					srv_desc.Shader4ComponentMapping = D3D12_DEFAULT_SHADER_4_COMPONENT_MAPPING;
+					srv_desc.Buffer.FirstElement = 0;
+					srv_desc.Buffer.NumElements = (buffer->size + 3) / 4;
+					srv_desc.Buffer.StructureByteStride = 0;
+					srv_desc.Buffer.Flags = D3D12_BUFFER_SRV_FLAG_RAW;
+					device->CreateShaderResourceView(buffer->resource, &srv_desc, desc_heap_walkers.resources.get_curr_cpu_handle());
+#ifdef DEV_ENABLED
+					resources_desc_info.push_back({ D3D12_DESCRIPTOR_RANGE_TYPE_SRV, srv_desc.ViewDimension });
+#endif
+					desc_heap_walkers.resources.advance();
+				}
+
+				// UAV then. [[SRV_UAV_AMBIGUITY]]
+				{
+					if ((buffer->usage & D3D12_RESOURCE_STATE_UNORDERED_ACCESS)) {
+						D3D12_UNORDERED_ACCESS_VIEW_DESC uav_desc = {};
+						uav_desc.Format = DXGI_FORMAT_R32_TYPELESS;
+						uav_desc.ViewDimension = D3D12_UAV_DIMENSION_BUFFER;
+						uav_desc.Buffer.FirstElement = 0;
+						uav_desc.Buffer.NumElements = (buffer->size + 3) / 4;
+						uav_desc.Buffer.StructureByteStride = 0;
+						uav_desc.Buffer.CounterOffsetInBytes = 0;
+						uav_desc.Buffer.Flags = D3D12_BUFFER_UAV_FLAG_RAW;
+						device->CreateUnorderedAccessView(buffer->resource, nullptr, &uav_desc, desc_heap_walkers.resources.get_curr_cpu_handle());
+#ifdef DEV_ENABLED
+						resources_desc_info.push_back({ D3D12_DESCRIPTOR_RANGE_TYPE_UAV, {} });
+#endif
+					} else {
+						// If can't transition to UAV, leave this one empty since it won't be
+						// used, and trying to create an UAV view would trigger a validation error.
+					}
+
+					desc_heap_walkers.resources.advance();
+				}
+			} break;
+			case UNIFORM_TYPE_INPUT_ATTACHMENT: {
+				ERR_FAIL_COND_V_MSG(shader->is_compute, RID(), "InputAttachment (binding: " + itos(uniform.binding) + ") supplied for compute shader (this is not allowed).");
+
+				if (uniform.get_id_count() != (uint32_t)set_uniform.info.length) {
+					if (set_uniform.info.length > 1) {
+						ERR_FAIL_V_MSG(RID(), "InputAttachment (binding: " + itos(uniform.binding) + ") is an array of (" + itos(set_uniform.info.length) + ") textures, so it should be provided equal number of texture IDs to satisfy it (IDs provided: " + itos(uniform.get_id_count()) + ").");
+					} else {
+						ERR_FAIL_V_MSG(RID(), "InputAttachment (binding: " + itos(uniform.binding) + ") should provide one ID referencing a texture (IDs provided: " + itos(uniform.get_id_count()) + ").");
+					}
+				}
+
+				for (uint32_t j = 0; j < uniform.get_id_count(); j++) {
+					RID rid = uniform.get_id(j);
+					Texture *texture = texture_owner.get_or_null(rid);
+					ERR_FAIL_COND_V_MSG(!texture, RID(),
+							"InputAttachment (binding: " + itos(uniform.binding) + ", index " + itos(j) + ") is not a valid texture.");
+
+					ERR_FAIL_COND_V_MSG(!(texture->usage_flags & TEXTURE_USAGE_SAMPLING_BIT), RID(),
+							"InputAttachment (binding: " + itos(uniform.binding) + ", index " + itos(j) + ") needs the TEXTURE_USAGE_SAMPLING_BIT usage flag set in order to be used as uniform.");
+
+					device->CreateShaderResourceView(texture->resource, &texture->srv_desc, desc_heap_walkers.resources.get_curr_cpu_handle());
+#ifdef DEV_ENABLED
+					resources_desc_info.push_back({ D3D12_DESCRIPTOR_RANGE_TYPE_SRV, texture->srv_desc.ViewDimension });
+#endif
+					desc_heap_walkers.resources.advance();
+
+					RIDState &rs = resource_states[texture];
+					rs.shader_uniform_idx_mask |= ((uint64_t)1 << i);
+					rs.state.extend(D3D12_RESOURCE_STATE_PIXEL_SHADER_RESOURCE);
+
+					DEV_ASSERT(!texture->owner.is_valid() || texture_owner.get_or_null(texture->owner));
+				}
+			} break;
+			default: {
+			}
+		}
+	}
+
+	DEV_ASSERT(desc_heap_walkers.resources.is_at_eof());
+	DEV_ASSERT(desc_heap_walkers.samplers.is_at_eof());
+
+	UniformSet uniform_set;
+	uniform_set.desc_heaps.resources = desc_heaps.resources;
+	uniform_set.desc_heaps.samplers = desc_heaps.samplers;
+	uniform_set.format = shader->set_formats[p_shader_set];
+	uniform_set.attachable_textures = attachable_textures;
+	uniform_set.shader_set = p_shader_set;
+	uniform_set.shader_id = p_shader;
+#ifdef DEV_ENABLED
+	uniform_set._resources_desc_info = resources_desc_info;
+	uniform_set._shader = shader;
+#endif
+
+	{
+		uniform_set.resource_states.resize(resource_states.size());
+		uint32_t i = 0;
+		for (const KeyValue<Resource *, RIDState> &E : resource_states) {
+			UniformSet::StateRequirement sr;
+			sr.resource = E.key;
+			sr.is_buffer = E.value.is_buffer;
+			sr.states = E.value.state.get_state_mask();
+			sr.shader_uniform_idx_mask = E.value.shader_uniform_idx_mask;
+			uniform_set.resource_states.write[i] = sr;
+			i++;
+		}
+	}
+
+	RID id = uniform_set_owner.make_rid(uniform_set);
+	// Add dependencies.
+	_add_dependency(id, p_shader);
+	for (uint32_t i = 0; i < uniform_count; i++) {
+		const Uniform &uniform = uniforms[i];
+		int id_count = uniform.get_id_count();
+		for (int j = 0; j < id_count; j++) {
+			_add_dependency(id, uniform.get_id(j));
+		}
+	}
+
+	return id;
+}
+
+bool RenderingDeviceD3D12::uniform_set_is_valid(RID p_uniform_set) {
+	return uniform_set_owner.owns(p_uniform_set);
+}
+
+void RenderingDeviceD3D12::uniform_set_set_invalidation_callback(RID p_uniform_set, InvalidationCallback p_callback, void *p_userdata) {
+	UniformSet *us = uniform_set_owner.get_or_null(p_uniform_set);
+	ERR_FAIL_NULL(us);
+	us->invalidated_callback = p_callback;
+	us->invalidated_callback_userdata = p_userdata;
+}
+
+Error RenderingDeviceD3D12::buffer_copy(RID p_src_buffer, RID p_dst_buffer, uint32_t p_src_offset, uint32_t p_dst_offset, uint32_t p_size, BitField<BarrierMask> p_post_barrier) {
+	_THREAD_SAFE_METHOD_
+
+	ERR_FAIL_COND_V_MSG(draw_list, ERR_INVALID_PARAMETER,
+			"Copying buffers is forbidden during creation of a draw list");
+	ERR_FAIL_COND_V_MSG(compute_list, ERR_INVALID_PARAMETER,
+			"Copying buffers is forbidden during creation of a compute list");
+
+	Buffer *src_buffer = _get_buffer_from_owner(p_src_buffer);
+	if (!src_buffer) {
+		ERR_FAIL_V_MSG(ERR_INVALID_PARAMETER, "Source buffer argument is not a valid buffer of any type.");
+	}
+
+	Buffer *dst_buffer = _get_buffer_from_owner(p_dst_buffer);
+	if (!dst_buffer) {
+		ERR_FAIL_V_MSG(ERR_INVALID_PARAMETER, "Destination buffer argument is not a valid buffer of any type.");
+	}
+
+	// Validate the copy's dimensions for both buffers.
+	ERR_FAIL_COND_V_MSG((p_size + p_src_offset) > src_buffer->size, ERR_INVALID_PARAMETER, "Size is larger than the source buffer.");
+	ERR_FAIL_COND_V_MSG((p_size + p_dst_offset) > dst_buffer->size, ERR_INVALID_PARAMETER, "Size is larger than the destination buffer.");
+
+	// Perform the copy.
+
+	ID3D12GraphicsCommandList *command_list = frames[frame].draw_command_list.Get();
+
+	_resource_transition_batch(src_buffer, 0, 1, D3D12_RESOURCE_STATE_COPY_SOURCE);
+	_resource_transition_batch(src_buffer, 0, 1, D3D12_RESOURCE_STATE_COPY_DEST);
+	_resource_transitions_flush(command_list);
+
+	command_list->CopyBufferRegion(dst_buffer->resource, p_dst_offset, src_buffer->resource, p_src_offset, p_size);
+
+	return OK;
+}
+
+Error RenderingDeviceD3D12::buffer_update(RID p_buffer, uint32_t p_offset, uint32_t p_size, const void *p_data, BitField<BarrierMask> p_post_barrier) {
+	_THREAD_SAFE_METHOD_
+
+	ERR_FAIL_COND_V_MSG(draw_list, ERR_INVALID_PARAMETER,
+			"Updating buffers is forbidden during creation of a draw list");
+	ERR_FAIL_COND_V_MSG(compute_list, ERR_INVALID_PARAMETER,
+			"Updating buffers is forbidden during creation of a compute list");
+
+	Buffer *buffer = _get_buffer_from_owner(p_buffer);
+	if (!buffer) {
+		ERR_FAIL_V_MSG(ERR_INVALID_PARAMETER, "Buffer argument is not a valid buffer of any type.");
+	}
+
+	ERR_FAIL_COND_V_MSG(p_offset + p_size > buffer->size, ERR_INVALID_PARAMETER,
+			"Attempted to write buffer (" + itos((p_offset + p_size) - buffer->size) + " bytes) past the end.");
+
+	ID3D12GraphicsCommandList *command_list = frames[frame].draw_command_list.Get();
+
+	_resource_transition_batch(buffer, 0, 1, D3D12_RESOURCE_STATE_COPY_DEST);
+	_resource_transitions_flush(command_list);
+
+	Error err = _buffer_update(buffer, p_offset, (uint8_t *)p_data, p_size, p_post_barrier);
+	if (err) {
+		return err;
+	}
+
+	return OK;
+}
+
+Error RenderingDeviceD3D12::buffer_clear(RID p_buffer, uint32_t p_offset, uint32_t p_size, BitField<BarrierMask> p_post_barrier) {
+	_THREAD_SAFE_METHOD_
+
+	ERR_FAIL_COND_V_MSG((p_size % 4) != 0, ERR_INVALID_PARAMETER,
+			"Size must be a multiple of four");
+	ERR_FAIL_COND_V_MSG(draw_list, ERR_INVALID_PARAMETER,
+			"Updating buffers in is forbidden during creation of a draw list");
+	ERR_FAIL_COND_V_MSG(compute_list, ERR_INVALID_PARAMETER,
+			"Updating buffers is forbidden during creation of a compute list");
+
+	Buffer *buffer = _get_buffer_from_owner(p_buffer);
+	if (!buffer) {
+		ERR_FAIL_V_MSG(ERR_INVALID_PARAMETER, "Buffer argument is not a valid buffer of any type.");
+	}
+
+	ERR_FAIL_COND_V_MSG(p_offset + p_size > buffer->size, ERR_INVALID_PARAMETER,
+			"Attempted to write buffer (" + itos((p_offset + p_size) - buffer->size) + " bytes) past the end.");
+
+	if (frames[frame].desc_heap_walkers.resources.is_at_eof()) {
+		if (!frames[frame].desc_heaps_exhausted_reported.resources) {
+			frames[frame].desc_heaps_exhausted_reported.resources = true;
+			ERR_FAIL_V_MSG(ERR_BUSY,
+					"Cannot clear buffer because there's no enough room in current frame's RESOURCE descriptors heap.\n"
+					"Please increase the value of the rendering/rendering_device/d3d12/max_resource_descriptors_per_frame project setting.");
+		} else {
+			return ERR_BUSY;
+		}
+	}
+	if (frames[frame].desc_heap_walkers.aux.is_at_eof()) {
+		if (!frames[frame].desc_heaps_exhausted_reported.aux) {
+			frames[frame].desc_heaps_exhausted_reported.aux = true;
+			ERR_FAIL_V_MSG(ERR_BUSY,
+					"Cannot clear buffer because there's no enough room in current frame's AUX descriptors heap.\n"
+					"Please increase the value of the rendering/rendering_device/d3d12/max_misc_descriptors_per_frame project setting.");
+		} else {
+			return ERR_BUSY;
+		}
+	}
+
+	ID3D12GraphicsCommandList *command_list = frames[frame].draw_command_list.Get();
+
+	_resource_transition_batch(buffer, 0, 1, D3D12_RESOURCE_STATE_UNORDERED_ACCESS);
+	_resource_transitions_flush(command_list);
+
+	D3D12_UNORDERED_ACCESS_VIEW_DESC uav_desc = {};
+	uav_desc.Format = DXGI_FORMAT_R32_TYPELESS;
+	uav_desc.ViewDimension = D3D12_UAV_DIMENSION_BUFFER;
+	uav_desc.Buffer.FirstElement = 0;
+	uav_desc.Buffer.NumElements = (buffer->size + 3) / 4;
+	uav_desc.Buffer.StructureByteStride = 0;
+	uav_desc.Buffer.CounterOffsetInBytes = 0;
+	uav_desc.Buffer.Flags = D3D12_BUFFER_UAV_FLAG_RAW;
+	device->CreateUnorderedAccessView(
+			buffer->resource,
+			nullptr,
+			&uav_desc,
+			frames[frame].desc_heap_walkers.aux.get_curr_cpu_handle());
+
+	device->CopyDescriptorsSimple(
+			1,
+			frames[frame].desc_heap_walkers.resources.get_curr_cpu_handle(),
+			frames[frame].desc_heap_walkers.aux.get_curr_cpu_handle(),
+			D3D12_DESCRIPTOR_HEAP_TYPE_CBV_SRV_UAV);
+
+	static const UINT values[4] = {};
+	command_list->ClearUnorderedAccessViewUint(
+			frames[frame].desc_heap_walkers.resources.get_curr_gpu_handle(),
+			frames[frame].desc_heap_walkers.aux.get_curr_cpu_handle(),
+			buffer->resource,
+			values,
+			0,
+			nullptr);
+
+	frames[frame].desc_heap_walkers.resources.advance();
+	frames[frame].desc_heap_walkers.aux.advance();
+
+	return OK;
+}
+
+Vector<uint8_t> RenderingDeviceD3D12::buffer_get_data(RID p_buffer, uint32_t p_offset, uint32_t p_size) {
+	_THREAD_SAFE_METHOD_
+
+	// Get the vulkan buffer and the potential stage/access possible.
+	Buffer *buffer = _get_buffer_from_owner(p_buffer);
+	if (!buffer) {
+		ERR_FAIL_V_MSG(Vector<uint8_t>(), "Buffer is either invalid or this type of buffer can't be retrieved. Only Index and Vertex buffers allow retrieving.");
+	}
+
+	ID3D12GraphicsCommandList *command_list = frames[frame].draw_command_list.Get();
+
+	// Size of buffer to retrieve.
+	if (!p_size) {
+		p_size = buffer->size;
+	} else {
+		ERR_FAIL_COND_V_MSG(p_size + p_offset > buffer->size, Vector<uint8_t>(),
+				"Size is larger than the buffer.");
+	}
+
+	_resource_transition_batch(buffer, 0, 1, D3D12_RESOURCE_STATE_COPY_SOURCE);
+	_resource_transitions_flush(command_list);
+
+	Buffer tmp_buffer;
+	Error err = _buffer_allocate(&tmp_buffer, p_size, D3D12_RESOURCE_STATE_COPY_DEST, D3D12_HEAP_TYPE_READBACK);
+	ERR_FAIL_COND_V(err != OK, Vector<uint8_t>());
+
+	command_list->CopyBufferRegion(tmp_buffer.resource, 0, buffer->resource, p_offset, p_size);
+
+	// Flush everything so memory can be safely mapped.
+	_flush(true);
+
+	void *buffer_mem;
+	HRESULT res = tmp_buffer.resource->Map(0, &VOID_RANGE, &buffer_mem);
+	ERR_FAIL_COND_V_MSG(res, Vector<uint8_t>(), "Map failed with error " + vformat("0x%08ux", res) + ".");
+
+	Vector<uint8_t> buffer_data;
+	{
+		buffer_data.resize(buffer->size);
+		uint8_t *w = buffer_data.ptrw();
+		memcpy(w, buffer_mem, buffer->size);
+	}
+
+	tmp_buffer.resource->Unmap(0, &VOID_RANGE);
+
+	_buffer_free(&tmp_buffer);
+
+	return buffer_data;
+}
+
+/*******************/
+/**** PIPELINES ****/
+/*******************/
+
+Error RenderingDeviceD3D12::_apply_specialization_constants(
+		const Shader *p_shader,
+		const Vector<PipelineSpecializationConstant> &p_specialization_constants,
+		HashMap<ShaderStage, Vector<uint8_t>> &r_final_stages_bytecode) {
+	// If something needs to be patched, COW will do the trick.
+	r_final_stages_bytecode = p_shader->stages_bytecode;
+	uint32_t stages_re_sign_mask = 0;
+	for (const PipelineSpecializationConstant &psc : p_specialization_constants) {
+		if (!(p_shader->spirv_specialization_constants_ids_mask & (1 << psc.constant_id))) {
+			// This SC wasn't even in the original SPIR-V shader.
+			continue;
+		}
+		for (const Shader::SpecializationConstant &sc : p_shader->specialization_constants) {
+			if (psc.constant_id == sc.constant.constant_id) {
+				ERR_FAIL_COND_V_MSG(psc.type != sc.constant.type, ERR_INVALID_PARAMETER, "Specialization constant provided for id (" + itos(sc.constant.constant_id) + ") is of the wrong type.");
+				if (psc.int_value != sc.constant.int_value) {
+					stages_re_sign_mask |= _shader_patch_dxil_specialization_constant(psc.type, &psc.int_value, sc.stages_bit_offsets, r_final_stages_bytecode, false);
+				}
+				break;
+			}
+		}
+	}
+	// Re-sign patched stages.
+	for (KeyValue<ShaderStage, Vector<uint8_t>> &E : r_final_stages_bytecode) {
+		ShaderStage stage = E.key;
+		if ((stages_re_sign_mask & (1 << stage))) {
+			Vector<uint8_t> &bytecode = E.value;
+			bool sign_ok = _shader_sign_dxil_bytecode(stage, bytecode);
+			ERR_FAIL_COND_V(!sign_ok, ERR_QUERY_FAILED);
+		}
+	}
+
+	return OK;
+}
+
+#ifdef DEV_ENABLED
+String RenderingDeviceD3D12::_build_pipeline_blob_filename(
+		const Vector<uint8_t> &p_blob,
+		const Shader *p_shader,
+		const Vector<PipelineSpecializationConstant> &p_specialization_constants,
+		const String &p_extra_name_suffix,
+		const String &p_forced_id) {
+	String id;
+	if (p_forced_id == "") {
+		HashingContext hc;
+		hc.start(HashingContext::HASH_MD5);
+		hc.update(p_blob);
+		Vector<uint8_t> hash_bin = hc.finish();
+		String hash_str = String::hex_encode_buffer(hash_bin.ptr(), hash_bin.size());
+	} else {
+		id = p_forced_id;
+	}
+
+	Vector<String> sc_str_pieces;
+	for (const Shader::SpecializationConstant &sc : p_shader->specialization_constants) {
+		uint32_t int_value = sc.constant.int_value;
+		for (const PipelineSpecializationConstant &psc : p_specialization_constants) {
+			if (psc.constant_id == sc.constant.constant_id) {
+				int_value = psc.int_value;
+				break;
+			}
+		}
+		sc_str_pieces.push_back(itos(sc.constant.constant_id) + "=" + itos(int_value));
+	}
+
+	String res = p_shader->name.replace(":", "-");
+	res += "." + id;
+	res += "." + String("_").join(sc_str_pieces);
+	if (p_extra_name_suffix != "") {
+		res += "." + p_extra_name_suffix;
+	}
+	return res;
+}
+
+void RenderingDeviceD3D12::_save_pso_blob(
+		ID3D12PipelineState *p_pso,
+		const Shader *p_shader,
+		const Vector<PipelineSpecializationConstant> &p_specialization_constants) {
+	ComPtr<ID3DBlob> pso_blob;
+	p_pso->GetCachedBlob(pso_blob.GetAddressOf());
+	Vector<uint8_t> pso_vector;
+	pso_vector.resize(pso_blob->GetBufferSize());
+	memcpy(pso_vector.ptrw(), pso_blob->GetBufferPointer(), pso_blob->GetBufferSize());
+
+	String base_filename = _build_pipeline_blob_filename(pso_vector, p_shader, p_specialization_constants);
+
+	Ref<FileAccess> fa = FileAccess::open("pso." + base_filename + ".bin", FileAccess::WRITE);
+	fa->store_buffer((const uint8_t *)pso_blob->GetBufferPointer(), pso_blob->GetBufferSize());
+}
+
+void RenderingDeviceD3D12::_save_stages_bytecode(
+		const HashMap<ShaderStage, Vector<uint8_t>> &p_stages_bytecode,
+		const Shader *p_shader,
+		const RID p_shader_rid,
+		const Vector<PipelineSpecializationConstant> &p_specialization_constants) {
+	for (const KeyValue<ShaderStage, Vector<uint8_t>> &E : p_stages_bytecode) {
+		ShaderStage stage = E.key;
+		const Vector<uint8_t> &bytecode = E.value;
+
+		String base_filename = _build_pipeline_blob_filename(bytecode, p_shader, p_specialization_constants, shader_stage_names[stage], itos(p_shader_rid.get_id()));
+
+		Ref<FileAccess> fa = FileAccess::open("dxil." + base_filename + ".bin", FileAccess::WRITE);
+		fa->store_buffer(bytecode.ptr(), bytecode.size());
+	}
+}
+#endif
+
+/*************************/
+/**** RENDER PIPELINE ****/
+/*************************/
+
+RID RenderingDeviceD3D12::render_pipeline_create(RID p_shader, FramebufferFormatID p_framebuffer_format, VertexFormatID p_vertex_format, RenderPrimitive p_render_primitive, const PipelineRasterizationState &p_rasterization_state, const PipelineMultisampleState &p_multisample_state, const PipelineDepthStencilState &p_depth_stencil_state, const PipelineColorBlendState &p_blend_state, BitField<PipelineDynamicStateFlags> p_dynamic_state_flags, uint32_t p_for_render_pass, const Vector<PipelineSpecializationConstant> &p_specialization_constants) {
+#ifdef DEV_ENABLED
+//#define DEBUG_CREATE_DEBUG_PSO
+//#define DEBUG_SAVE_PSO_BLOBS
+//#define DEBUG_SAVE_DXIL_BLOBS
+#endif
+	_THREAD_SAFE_METHOD_
+
+	// Needs a shader.
+	Shader *shader = shader_owner.get_or_null(p_shader);
+	ERR_FAIL_NULL_V(shader, RID());
+
+	ERR_FAIL_COND_V_MSG(shader->is_compute, RID(),
+			"Compute shaders can't be used in render pipelines");
+
+	if (p_framebuffer_format == INVALID_ID) {
+		// If nothing provided, use an empty one (no attachments).
+		p_framebuffer_format = framebuffer_format_create(Vector<AttachmentFormat>());
+	}
+	ERR_FAIL_COND_V(!framebuffer_formats.has(p_framebuffer_format), RID());
+	const FramebufferFormat &fb_format = framebuffer_formats[p_framebuffer_format];
+	const FramebufferPass &pass = fb_format.passes[p_for_render_pass];
+
+	{ // Validate shader vs framebuffer.
+
+		ERR_FAIL_COND_V_MSG(p_for_render_pass >= uint32_t(fb_format.passes.size()), RID(), "Render pass requested for pipeline creation (" + itos(p_for_render_pass) + ") is out of bounds");
+		uint32_t output_mask = 0;
+		for (int i = 0; i < pass.color_attachments.size(); i++) {
+			if (pass.color_attachments[i] != FramebufferPass::ATTACHMENT_UNUSED) {
+				output_mask |= 1 << i;
+			}
+		}
+		ERR_FAIL_COND_V_MSG(shader->fragment_output_mask != output_mask, RID(),
+				"Mismatch fragment shader output mask (" + itos(shader->fragment_output_mask) + ") and framebuffer color output mask (" + itos(output_mask) + ") when binding both in render pipeline.");
+	}
+
+	CD3DX12_PIPELINE_STATE_STREAM pipeline_desc;
+	RenderPipeline::DynamicParams dyn_params;
+
+	// Attachment formats.
+	{
+		for (int i = 0; i < pass.color_attachments.size(); i++) {
+			int32_t attachment = pass.color_attachments[i];
+			if (attachment == FramebufferPass::ATTACHMENT_UNUSED) {
+				(&pipeline_desc.RTVFormats)->RTFormats[i] = DXGI_FORMAT_UNKNOWN;
+			} else {
+				(&pipeline_desc.RTVFormats)->RTFormats[i] = d3d12_formats[fb_format.attachments[attachment].format].general_format;
+			}
+		}
+		(&pipeline_desc.RTVFormats)->NumRenderTargets = pass.color_attachments.size();
+
+		if (pass.depth_attachment == FramebufferPass::ATTACHMENT_UNUSED) {
+			pipeline_desc.DSVFormat = DXGI_FORMAT_UNKNOWN;
+		} else {
+			pipeline_desc.DSVFormat = d3d12_formats[fb_format.attachments[pass.depth_attachment].format].dsv_format;
+		}
+	}
+
+	// Vertex.
+	if (p_vertex_format != INVALID_ID) {
+		// Uses vertices, else it does not.
+		ERR_FAIL_COND_V(!vertex_formats.has(p_vertex_format), RID());
+		const VertexDescriptionCache &vd = vertex_formats[p_vertex_format];
+
+		(&pipeline_desc.InputLayout)->pInputElementDescs = vd.elements_desc.ptr();
+		(&pipeline_desc.InputLayout)->NumElements = vd.elements_desc.size();
+
+		// Validate with inputs.
+		for (uint32_t i = 0; i < 64; i++) {
+			if (!(shader->vertex_input_mask & (1ULL << i))) {
+				continue;
+			}
+			bool found = false;
+			for (int j = 0; j < vd.vertex_formats.size(); j++) {
+				if (vd.vertex_formats[j].location == i) {
+					found = true;
+				}
+			}
+
+			ERR_FAIL_COND_V_MSG(!found, RID(),
+					"Shader vertex input location (" + itos(i) + ") not provided in vertex input description for pipeline creation.");
+		}
+
+	} else {
+		// Does not use vertices.
+
+		ERR_FAIL_COND_V_MSG(shader->vertex_input_mask != 0, RID(),
+				"Shader contains vertex inputs, but no vertex input description was provided for pipeline creation.");
+	}
+
+	// Input assembly & tessellation.
+
+	ERR_FAIL_INDEX_V(p_render_primitive, RENDER_PRIMITIVE_MAX, RID());
+
+	static const D3D12_PRIMITIVE_TOPOLOGY_TYPE topology_types[RENDER_PRIMITIVE_MAX] = {
+		D3D12_PRIMITIVE_TOPOLOGY_TYPE_POINT,
+		D3D12_PRIMITIVE_TOPOLOGY_TYPE_LINE,
+		D3D12_PRIMITIVE_TOPOLOGY_TYPE_LINE,
+		D3D12_PRIMITIVE_TOPOLOGY_TYPE_LINE,
+		D3D12_PRIMITIVE_TOPOLOGY_TYPE_LINE,
+		D3D12_PRIMITIVE_TOPOLOGY_TYPE_TRIANGLE,
+		D3D12_PRIMITIVE_TOPOLOGY_TYPE_TRIANGLE,
+		D3D12_PRIMITIVE_TOPOLOGY_TYPE_TRIANGLE,
+		D3D12_PRIMITIVE_TOPOLOGY_TYPE_TRIANGLE,
+		D3D12_PRIMITIVE_TOPOLOGY_TYPE_TRIANGLE,
+		D3D12_PRIMITIVE_TOPOLOGY_TYPE_PATCH,
+	};
+
+	static const D3D12_PRIMITIVE_TOPOLOGY topologies[RENDER_PRIMITIVE_MAX] = {
+		D3D_PRIMITIVE_TOPOLOGY_POINTLIST,
+		D3D_PRIMITIVE_TOPOLOGY_LINELIST,
+		D3D_PRIMITIVE_TOPOLOGY_LINELIST_ADJ,
+		D3D_PRIMITIVE_TOPOLOGY_LINESTRIP,
+		D3D_PRIMITIVE_TOPOLOGY_LINESTRIP_ADJ,
+		D3D_PRIMITIVE_TOPOLOGY_TRIANGLELIST,
+		D3D_PRIMITIVE_TOPOLOGY_TRIANGLELIST_ADJ,
+		D3D_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP,
+		D3D_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP_ADJ,
+		D3D_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP,
+		D3D_PRIMITIVE_TOPOLOGY_1_CONTROL_POINT_PATCHLIST,
+	};
+
+	pipeline_desc.PrimitiveTopologyType = topology_types[p_render_primitive];
+	if (p_render_primitive == RENDER_PRIMITIVE_TESSELATION_PATCH) {
+		ERR_FAIL_COND_V(p_rasterization_state.patch_control_points < 1 || p_rasterization_state.patch_control_points > 32, RID()); // Is there any way to get the true point count limit?
+		dyn_params.primitive_topology = (D3D12_PRIMITIVE_TOPOLOGY)((int)D3D_PRIMITIVE_TOPOLOGY_1_CONTROL_POINT_PATCHLIST + p_rasterization_state.patch_control_points);
+	} else {
+		dyn_params.primitive_topology = topologies[p_render_primitive];
+	}
+	if (p_render_primitive == RENDER_PRIMITIVE_TRIANGLE_STRIPS_WITH_RESTART_INDEX) {
+		// TODO: This is right for 16-bit indices; for 32-bit there's a different enum value to set, but we don't know at this point.
+		pipeline_desc.IBStripCutValue = D3D12_INDEX_BUFFER_STRIP_CUT_VALUE_0xFFFF;
+	} else {
+		pipeline_desc.IBStripCutValue = D3D12_INDEX_BUFFER_STRIP_CUT_VALUE_DISABLED;
+	}
+
+	// Rasterization.
+	(&pipeline_desc.RasterizerState)->DepthClipEnable = !p_rasterization_state.enable_depth_clamp;
+	// In D3D12, discard can be supported with some extra effort (empty pixel shader + disable depth/stencil test); that said, unsupported by now.
+	ERR_FAIL_COND_V(p_rasterization_state.discard_primitives, RID());
+	(&pipeline_desc.RasterizerState)->FillMode = p_rasterization_state.wireframe ? D3D12_FILL_MODE_WIREFRAME : D3D12_FILL_MODE_SOLID;
+	static const D3D12_CULL_MODE cull_mode[3] = {
+		D3D12_CULL_MODE_NONE,
+		D3D12_CULL_MODE_FRONT,
+		D3D12_CULL_MODE_BACK,
+	};
+
+	ERR_FAIL_INDEX_V(p_rasterization_state.cull_mode, 3, RID());
+	(&pipeline_desc.RasterizerState)->CullMode = cull_mode[p_rasterization_state.cull_mode];
+	(&pipeline_desc.RasterizerState)->FrontCounterClockwise = p_rasterization_state.front_face == POLYGON_FRONT_FACE_COUNTER_CLOCKWISE;
+	// In D3D12, there's still a point in setting up depth bias with no depth buffer, but just zeroing (disabling) it all in such case is closer to Vulkan.
+	if (p_rasterization_state.depth_bias_enabled && fb_format.passes[p_for_render_pass].depth_attachment != FramebufferPass::ATTACHMENT_UNUSED) {
+		(&pipeline_desc.RasterizerState)->DepthBias = p_rasterization_state.depth_bias_constant_factor;
+		(&pipeline_desc.RasterizerState)->DepthBiasClamp = p_rasterization_state.depth_bias_clamp;
+		(&pipeline_desc.RasterizerState)->SlopeScaledDepthBias = p_rasterization_state.depth_bias_slope_factor;
+	} else {
+		(&pipeline_desc.RasterizerState)->DepthBias = 0;
+		(&pipeline_desc.RasterizerState)->DepthBiasClamp = 0.0f;
+		(&pipeline_desc.RasterizerState)->SlopeScaledDepthBias = 0.0f;
+	}
+
+	(&pipeline_desc.RasterizerState)->ForcedSampleCount = 0;
+	(&pipeline_desc.RasterizerState)->ConservativeRaster = D3D12_CONSERVATIVE_RASTERIZATION_MODE_OFF;
+	(&pipeline_desc.RasterizerState)->MultisampleEnable = rasterization_sample_count[p_multisample_state.sample_count] != 1;
+	(&pipeline_desc.RasterizerState)->AntialiasedLineEnable = true;
+
+	// In D3D12, there's no line width.
+	ERR_FAIL_COND_V(!Math::is_equal_approx(p_rasterization_state.line_width, 1.0f), RID());
+
+	// Multisample.
+	ERR_FAIL_COND_V(p_multisample_state.enable_sample_shading, RID()); // How one enables this in D3D12?
+	if ((&pipeline_desc.RTVFormats)->NumRenderTargets || pipeline_desc.DSVFormat != DXGI_FORMAT_UNKNOWN) {
+		uint32_t sample_count = MIN(
+				fb_format.max_supported_sample_count,
+				rasterization_sample_count[p_multisample_state.sample_count]);
+		(&pipeline_desc.SampleDesc)->Count = sample_count;
+	} else {
+		(&pipeline_desc.SampleDesc)->Count = 1;
+	}
+	if ((&pipeline_desc.SampleDesc)->Count > 1) {
+		(&pipeline_desc.SampleDesc)->Quality = DXGI_STANDARD_MULTISAMPLE_QUALITY_PATTERN;
+	} else {
+		(&pipeline_desc.SampleDesc)->Quality = 0;
+	}
+	if (p_multisample_state.sample_mask.size()) {
+		// Use sample mask.
+		ERR_FAIL_COND_V(rasterization_sample_count[p_multisample_state.sample_count] != (uint32_t)p_multisample_state.sample_mask.size(), RID());
+		for (int i = 1; i < p_multisample_state.sample_mask.size(); i++) {
+			// In D3D12 there's a single sample mask for every pixel.
+			ERR_FAIL_COND_V(p_multisample_state.sample_mask[i] != p_multisample_state.sample_mask[0], RID());
+		}
+		pipeline_desc.SampleMask = p_multisample_state.sample_mask[0];
+	} else {
+		pipeline_desc.SampleMask = 0xffffffff;
+	}
+
+	// Depth stencil.
+
+	if (pass.depth_attachment == FramebufferPass::ATTACHMENT_UNUSED) {
+		(&pipeline_desc.DepthStencilState)->DepthEnable = false;
+		(&pipeline_desc.DepthStencilState)->StencilEnable = false;
+	} else {
+		(&pipeline_desc.DepthStencilState)->DepthEnable = p_depth_stencil_state.enable_depth_test;
+		(&pipeline_desc.DepthStencilState)->DepthWriteMask = p_depth_stencil_state.enable_depth_write ? D3D12_DEPTH_WRITE_MASK_ALL : D3D12_DEPTH_WRITE_MASK_ZERO;
+		ERR_FAIL_INDEX_V(p_depth_stencil_state.depth_compare_operator, COMPARE_OP_MAX, RID());
+		(&pipeline_desc.DepthStencilState)->DepthFunc = compare_operators[p_depth_stencil_state.depth_compare_operator];
+		(&pipeline_desc.DepthStencilState)->DepthBoundsTestEnable = p_depth_stencil_state.enable_depth_range;
+		(&pipeline_desc.DepthStencilState)->StencilEnable = p_depth_stencil_state.enable_stencil;
+
+		// In D3D12 some elements can't be different across front and back.
+		ERR_FAIL_COND_V(p_depth_stencil_state.front_op.compare_mask != p_depth_stencil_state.back_op.compare_mask, RID());
+		ERR_FAIL_COND_V(p_depth_stencil_state.front_op.write_mask != p_depth_stencil_state.back_op.write_mask, RID());
+		ERR_FAIL_COND_V(p_depth_stencil_state.front_op.reference != p_depth_stencil_state.back_op.reference, RID());
+		(&pipeline_desc.DepthStencilState)->StencilReadMask = p_depth_stencil_state.front_op.compare_mask;
+		(&pipeline_desc.DepthStencilState)->StencilWriteMask = p_depth_stencil_state.front_op.write_mask;
+
+		ERR_FAIL_INDEX_V(p_depth_stencil_state.front_op.fail, STENCIL_OP_MAX, RID());
+		(&pipeline_desc.DepthStencilState)->FrontFace.StencilFailOp = stencil_operations[p_depth_stencil_state.front_op.fail];
+		ERR_FAIL_INDEX_V(p_depth_stencil_state.front_op.pass, STENCIL_OP_MAX, RID());
+		(&pipeline_desc.DepthStencilState)->FrontFace.StencilPassOp = stencil_operations[p_depth_stencil_state.front_op.pass];
+		ERR_FAIL_INDEX_V(p_depth_stencil_state.front_op.depth_fail, STENCIL_OP_MAX, RID());
+		(&pipeline_desc.DepthStencilState)->FrontFace.StencilDepthFailOp = stencil_operations[p_depth_stencil_state.front_op.depth_fail];
+		ERR_FAIL_INDEX_V(p_depth_stencil_state.front_op.compare, COMPARE_OP_MAX, RID());
+		(&pipeline_desc.DepthStencilState)->FrontFace.StencilFunc = compare_operators[p_depth_stencil_state.front_op.compare];
+
+		ERR_FAIL_INDEX_V(p_depth_stencil_state.back_op.fail, STENCIL_OP_MAX, RID());
+		(&pipeline_desc.DepthStencilState)->BackFace.StencilFailOp = stencil_operations[p_depth_stencil_state.back_op.fail];
+		ERR_FAIL_INDEX_V(p_depth_stencil_state.back_op.pass, STENCIL_OP_MAX, RID());
+		(&pipeline_desc.DepthStencilState)->BackFace.StencilPassOp = stencil_operations[p_depth_stencil_state.back_op.pass];
+		ERR_FAIL_INDEX_V(p_depth_stencil_state.back_op.depth_fail, STENCIL_OP_MAX, RID());
+		(&pipeline_desc.DepthStencilState)->BackFace.StencilDepthFailOp = stencil_operations[p_depth_stencil_state.back_op.depth_fail];
+		ERR_FAIL_INDEX_V(p_depth_stencil_state.back_op.compare, COMPARE_OP_MAX, RID());
+		(&pipeline_desc.DepthStencilState)->BackFace.StencilFunc = compare_operators[p_depth_stencil_state.back_op.compare];
+
+		dyn_params.depth_bounds_min = p_depth_stencil_state.enable_depth_range ? p_depth_stencil_state.depth_range_min : 0.0f;
+		dyn_params.depth_bounds_max = p_depth_stencil_state.enable_depth_range ? p_depth_stencil_state.depth_range_max : 1.0f;
+		dyn_params.stencil_reference = p_depth_stencil_state.front_op.reference;
+	}
+
+	// Blend state.
+	(&pipeline_desc.BlendState)->AlphaToCoverageEnable = p_multisample_state.enable_alpha_to_coverage;
+	{
+		ERR_FAIL_COND_V(p_blend_state.attachments.size() < pass.color_attachments.size(), RID());
+
+		bool all_attachments_same_blend = true;
+		for (int i = 0; i < pass.color_attachments.size(); i++) {
+			const PipelineColorBlendState::Attachment &bs = p_blend_state.attachments[i];
+			D3D12_RENDER_TARGET_BLEND_DESC &bd = (&pipeline_desc.BlendState)->RenderTarget[i];
+
+			bd.BlendEnable = bs.enable_blend;
+			bd.LogicOpEnable = p_blend_state.enable_logic_op;
+			bd.LogicOp = logic_operations[p_blend_state.logic_op];
+
+			ERR_FAIL_INDEX_V(bs.src_color_blend_factor, BLEND_FACTOR_MAX, RID());
+			bd.SrcBlend = blend_factors[bs.src_color_blend_factor];
+			ERR_FAIL_INDEX_V(bs.dst_color_blend_factor, BLEND_FACTOR_MAX, RID());
+			bd.DestBlend = blend_factors[bs.dst_color_blend_factor];
+			ERR_FAIL_INDEX_V(bs.color_blend_op, BLEND_OP_MAX, RID());
+			bd.BlendOp = blend_operations[bs.color_blend_op];
+
+			ERR_FAIL_INDEX_V(bs.src_alpha_blend_factor, BLEND_FACTOR_MAX, RID());
+			bd.SrcBlendAlpha = blend_factors[bs.src_alpha_blend_factor];
+			ERR_FAIL_INDEX_V(bs.dst_alpha_blend_factor, BLEND_FACTOR_MAX, RID());
+			bd.DestBlendAlpha = blend_factors[bs.dst_alpha_blend_factor];
+			ERR_FAIL_INDEX_V(bs.alpha_blend_op, BLEND_OP_MAX, RID());
+			bd.BlendOpAlpha = blend_operations[bs.alpha_blend_op];
+
+			if (bs.write_r) {
+				bd.RenderTargetWriteMask |= D3D12_COLOR_WRITE_ENABLE_RED;
+			}
+			if (bs.write_g) {
+				bd.RenderTargetWriteMask |= D3D12_COLOR_WRITE_ENABLE_GREEN;
+			}
+			if (bs.write_b) {
+				bd.RenderTargetWriteMask |= D3D12_COLOR_WRITE_ENABLE_BLUE;
+			}
+			if (bs.write_a) {
+				bd.RenderTargetWriteMask |= D3D12_COLOR_WRITE_ENABLE_ALPHA;
+			}
+
+			if (i > 0 && all_attachments_same_blend) {
+				all_attachments_same_blend = &(&pipeline_desc.BlendState)->RenderTarget[i] == &(&pipeline_desc.BlendState)->RenderTarget[0];
+			}
+		}
+
+		// Per D3D12 docs, if logic op used, independent blending is not supported.
+		ERR_FAIL_COND_V(p_blend_state.enable_logic_op && !all_attachments_same_blend, RID());
+
+		(&pipeline_desc.BlendState)->IndependentBlendEnable = !all_attachments_same_blend;
+	}
+
+	dyn_params.blend_constant = p_blend_state.blend_constant;
+
+	// Stages bytecodes + specialization constants.
+
+	pipeline_desc.pRootSignature = shader->root_signature.Get();
+
+#ifdef DEBUG_CREATE_DEBUG_PSO
+	pipeline_desc.Flags = D3D12_PIPELINE_STATE_FLAG_TOOL_DEBUG;
+#endif
+
+	HashMap<ShaderStage, Vector<uint8_t>> final_stages_bytecode;
+	Error err = _apply_specialization_constants(shader, p_specialization_constants, final_stages_bytecode);
+	ERR_FAIL_COND_V(err, RID());
+
+#ifdef DEV_ENABLED
+	// Ensure signing worked.
+	for (KeyValue<ShaderStage, Vector<uint8_t>> &E : final_stages_bytecode) {
+		bool any_non_zero = false;
+		for (int j = 0; j < 16; j++) {
+			if (E.value.ptr()[4 + j]) {
+				any_non_zero = true;
+				break;
+			}
+		}
+		DEV_ASSERT(any_non_zero);
+	}
+#endif
+
+	if (shader->stages_bytecode.has(SHADER_STAGE_VERTEX)) {
+		pipeline_desc.VS = D3D12_SHADER_BYTECODE{
+			final_stages_bytecode[SHADER_STAGE_VERTEX].ptr(),
+			(SIZE_T)final_stages_bytecode[SHADER_STAGE_VERTEX].size()
+		};
+	}
+	if (shader->stages_bytecode.has(SHADER_STAGE_FRAGMENT)) {
+		pipeline_desc.PS = D3D12_SHADER_BYTECODE{
+			final_stages_bytecode[SHADER_STAGE_FRAGMENT].ptr(),
+			(SIZE_T)final_stages_bytecode[SHADER_STAGE_FRAGMENT].size()
+		};
+	}
+
+	RenderPipeline pipeline;
+	{
+		ComPtr<ID3D12Device2> device2;
+		device.As(&device2);
+		HRESULT res = {};
+		if (device2) {
+			D3D12_PIPELINE_STATE_STREAM_DESC pssd = {};
+			pssd.pPipelineStateSubobjectStream = &pipeline_desc;
+			pssd.SizeInBytes = sizeof(pipeline_desc);
+			res = device2->CreatePipelineState(&pssd, IID_PPV_ARGS(pipeline.pso.GetAddressOf()));
+		} else {
+			// Some features won't be available (like depth bounds).
+			// TODO: Check and/or report error then?
+			D3D12_GRAPHICS_PIPELINE_STATE_DESC desc = pipeline_desc.GraphicsDescV0();
+			res = device->CreateGraphicsPipelineState(&desc, IID_PPV_ARGS(pipeline.pso.GetAddressOf()));
+		}
+		ERR_FAIL_COND_V_MSG(res, RID(), "CreateGraphicsPipelineState failed with error " + vformat("0x%08ux", res) + " for shader '" + shader->name + "'.");
+
+#ifdef DEBUG_SAVE_PSO_BLOBS
+		_save_pso_blob(pipeline.pso.Get(), shader, p_specialization_constants);
+#endif
+#ifdef DEBUG_SAVE_DXIL_BLOBS
+		_save_stages_bytecode(final_stages_bytecode, shader, p_shader, p_specialization_constants);
+#endif
+	}
+
+	{
+		Vector<Vector<UniformBindingInfo>> bindings;
+		bindings.resize(shader->sets.size());
+		for (int i = 0; i < shader->sets.size(); i++) {
+			bindings.write[i].resize(shader->sets[i].uniforms.size());
+			for (int j = 0; j < shader->sets[i].uniforms.size(); j++) {
+				bindings.write[i].write[j] = shader->sets[i].uniforms[j].binding;
+			}
+		}
+		pipeline_bindings[next_pipeline_binding_id] = bindings;
+		pipeline.bindings_id = next_pipeline_binding_id;
+		next_pipeline_binding_id++;
+	}
+
+	pipeline.root_signature_crc = shader->root_signature_crc;
+	pipeline.set_formats = shader->set_formats;
+	pipeline.shader = p_shader;
+	pipeline.spirv_push_constant_size = shader->spirv_push_constant_size;
+	pipeline.dxil_push_constant_size = shader->dxil_push_constant_size;
+	pipeline.nir_runtime_data_root_param_idx = shader->nir_runtime_data_root_param_idx;
+	pipeline.dyn_params = dyn_params;
+
+#ifdef DEBUG_ENABLED
+	pipeline.validation.dynamic_state = p_dynamic_state_flags;
+	pipeline.validation.framebuffer_format = p_framebuffer_format;
+	pipeline.validation.render_pass = p_for_render_pass;
+	pipeline.validation.vertex_format = p_vertex_format;
+	pipeline.validation.uses_restart_indices = pipeline_desc.IBStripCutValue != D3D12_INDEX_BUFFER_STRIP_CUT_VALUE_DISABLED;
+
+	static const uint32_t primitive_divisor[RENDER_PRIMITIVE_MAX] = {
+		1, 2, 1, 1, 1, 3, 1, 1, 1, 1, 1
+	};
+	pipeline.validation.primitive_divisor = primitive_divisor[p_render_primitive];
+	static const uint32_t primitive_minimum[RENDER_PRIMITIVE_MAX] = {
+		1,
+		2,
+		2,
+		2,
+		2,
+		3,
+		3,
+		3,
+		3,
+		3,
+		1,
+	};
+	pipeline.validation.primitive_minimum = primitive_minimum[p_render_primitive];
+#endif
+	// Create ID to associate with this pipeline.
+	RID id = render_pipeline_owner.make_rid(pipeline);
+#ifdef DEV_ENABLED
+	set_resource_name(id, "RID:" + itos(id.get_id()));
+#endif
+	// Now add all the dependencies.
+	_add_dependency(id, p_shader);
+	return id;
+}
+
+bool RenderingDeviceD3D12::render_pipeline_is_valid(RID p_pipeline) {
+	_THREAD_SAFE_METHOD_
+	return render_pipeline_owner.owns(p_pipeline);
+}
+
+/**************************/
+/**** COMPUTE PIPELINE ****/
+/**************************/
+
+RID RenderingDeviceD3D12::compute_pipeline_create(RID p_shader, const Vector<PipelineSpecializationConstant> &p_specialization_constants) {
+#ifdef DEV_ENABLED
+//#define DEBUG_CREATE_DEBUG_PSO
+//#define DEBUG_SAVE_PSO_BLOBS
+//#define DEBUG_SAVE_DXIL_BLOBS
+#endif
+	_THREAD_SAFE_METHOD_
+
+	// Needs a shader.
+	Shader *shader = shader_owner.get_or_null(p_shader);
+	ERR_FAIL_NULL_V(shader, RID());
+
+	ERR_FAIL_COND_V_MSG(!shader->is_compute, RID(),
+			"Non-compute shaders can't be used in compute pipelines");
+
+	CD3DX12_PIPELINE_STATE_STREAM pipeline_desc = {};
+
+	// Stages bytecodes + specialization constants.
+
+	pipeline_desc.pRootSignature = shader->root_signature.Get();
+
+#ifdef DEBUG_CREATE_DEBUG_PSO
+	pipeline_desc.Flags = D3D12_PIPELINE_STATE_FLAG_TOOL_DEBUG;
+#endif
+
+	HashMap<ShaderStage, Vector<uint8_t>> final_stages_bytecode;
+	Error err = _apply_specialization_constants(shader, p_specialization_constants, final_stages_bytecode);
+	ERR_FAIL_COND_V(err, RID());
+
+	pipeline_desc.CS = D3D12_SHADER_BYTECODE{
+		final_stages_bytecode[SHADER_STAGE_COMPUTE].ptr(),
+		(SIZE_T)final_stages_bytecode[SHADER_STAGE_COMPUTE].size()
+	};
+
+	ComputePipeline pipeline;
+	{
+		ComPtr<ID3D12Device2> device2;
+		device.As(&device2);
+		HRESULT res = {};
+		if (device2) {
+			D3D12_PIPELINE_STATE_STREAM_DESC pssd = {};
+			pssd.pPipelineStateSubobjectStream = &pipeline_desc;
+			pssd.SizeInBytes = sizeof(pipeline_desc);
+			res = device2->CreatePipelineState(&pssd, IID_PPV_ARGS(pipeline.pso.GetAddressOf()));
+		} else {
+			D3D12_COMPUTE_PIPELINE_STATE_DESC desc = pipeline_desc.ComputeDescV0();
+			res = device->CreateComputePipelineState(&desc, IID_PPV_ARGS(pipeline.pso.GetAddressOf()));
+		}
+		ERR_FAIL_COND_V_MSG(res, RID(), "CreateComputePipelineState failed with error " + vformat("0x%08ux", res) + " for shader '" + shader->name + "'.");
+
+#ifdef DEBUG_SAVE_PSO_BLOBS
+		_save_pso_blob(pipeline.pso.Get(), shader, p_specialization_constants);
+#endif
+#ifdef DEBUG_SAVE_DXIL_BLOBS
+		_save_stages_bytecode(final_stages_bytecode, shader, p_shader, p_specialization_constants);
+#endif
+	}
+
+	{
+		Vector<Vector<UniformBindingInfo>> bindings;
+		bindings.resize(shader->sets.size());
+		for (int i = 0; i < shader->sets.size(); i++) {
+			bindings.write[i].resize(shader->sets[i].uniforms.size());
+			for (int j = 0; j < shader->sets[i].uniforms.size(); j++) {
+				bindings.write[i].write[j] = shader->sets[i].uniforms[j].binding;
+			}
+		}
+		pipeline_bindings[next_pipeline_binding_id] = bindings;
+		pipeline.bindings_id = next_pipeline_binding_id;
+		next_pipeline_binding_id++;
+	}
+
+	pipeline.root_signature_crc = shader->root_signature_crc;
+	pipeline.set_formats = shader->set_formats;
+	pipeline.shader = p_shader;
+	pipeline.spirv_push_constant_size = shader->spirv_push_constant_size;
+	pipeline.dxil_push_constant_size = shader->dxil_push_constant_size;
+	pipeline.local_group_size[0] = shader->compute_local_size[0];
+	pipeline.local_group_size[1] = shader->compute_local_size[1];
+	pipeline.local_group_size[2] = shader->compute_local_size[2];
+
+	// Create ID to associate with this pipeline.
+	RID id = compute_pipeline_owner.make_rid(pipeline);
+#ifdef DEV_ENABLED
+	set_resource_name(id, "RID:" + itos(id.get_id()));
+#endif
+	// Now add all the dependencies.
+	_add_dependency(id, p_shader);
+	return id;
+}
+
+bool RenderingDeviceD3D12::compute_pipeline_is_valid(RID p_pipeline) {
+	return compute_pipeline_owner.owns(p_pipeline);
+}
+
+/****************/
+/**** SCREEN ****/
+/****************/
+
+int RenderingDeviceD3D12::screen_get_width(DisplayServer::WindowID p_screen) const {
+	_THREAD_SAFE_METHOD_
+	ERR_FAIL_COND_V_MSG(local_device.is_valid(), -1, "Local devices have no screen");
+	return context->window_get_width(p_screen);
+}
+
+int RenderingDeviceD3D12::screen_get_height(DisplayServer::WindowID p_screen) const {
+	_THREAD_SAFE_METHOD_
+	ERR_FAIL_COND_V_MSG(local_device.is_valid(), -1, "Local devices have no screen");
+
+	return context->window_get_height(p_screen);
+}
+
+RenderingDevice::FramebufferFormatID RenderingDeviceD3D12::screen_get_framebuffer_format() const {
+	_THREAD_SAFE_METHOD_
+	ERR_FAIL_COND_V_MSG(local_device.is_valid(), INVALID_ID, "Local devices have no screen");
+
+	// Very hacky, but not used often per frame so I guess ok.
+	DXGI_FORMAT d3d12_format = context->get_screen_format();
+	DataFormat format = DATA_FORMAT_MAX;
+	for (int i = 0; i < DATA_FORMAT_MAX; i++) {
+		if (d3d12_format == d3d12_formats[i].general_format) {
+			format = DataFormat(i);
+			break;
+		}
+	}
+
+	ERR_FAIL_COND_V(format == DATA_FORMAT_MAX, INVALID_ID);
+
+	AttachmentFormat attachment;
+	attachment.format = format;
+	attachment.samples = TEXTURE_SAMPLES_1;
+	attachment.usage_flags = TEXTURE_USAGE_COLOR_ATTACHMENT_BIT;
+	Vector<AttachmentFormat> screen_attachment;
+	screen_attachment.push_back(attachment);
+	return const_cast<RenderingDeviceD3D12 *>(this)->framebuffer_format_create(screen_attachment);
+}
+
+/*******************/
+/**** DRAW LIST ****/
+/*******************/
+
+RenderingDevice::DrawListID RenderingDeviceD3D12::draw_list_begin_for_screen(DisplayServer::WindowID p_screen, const Color &p_clear_color) {
+	_THREAD_SAFE_METHOD_
+	ERR_FAIL_COND_V_MSG(local_device.is_valid(), INVALID_ID, "Local devices have no screen");
+
+	ERR_FAIL_COND_V_MSG(draw_list != nullptr, INVALID_ID, "Only one draw list can be active at the same time.");
+	ERR_FAIL_COND_V_MSG(compute_list != nullptr, INVALID_ID, "Only one draw/compute list can be active at the same time.");
+
+	if (!context->window_is_valid_swapchain(p_screen)) {
+		return INVALID_ID;
+	}
+
+	Size2i size = Size2i(context->window_get_width(p_screen), context->window_get_height(p_screen));
+
+	_draw_list_allocate(Rect2i(Vector2i(), size), 0, 0);
+
+	Vector<Color> clear_colors;
+	clear_colors.push_back(p_clear_color);
+
+	curr_screen_framebuffer = Framebuffer();
+	curr_screen_framebuffer.window_id = p_screen;
+	curr_screen_framebuffer.format_id = screen_get_framebuffer_format();
+	curr_screen_framebuffer.size = size;
+	curr_screen_framebuffer.screen_rtv_handle = context->window_get_framebuffer_rtv_handle(p_screen);
+
+	ID3D12GraphicsCommandList *command_list = frames[frame].draw_command_list.Get();
+	Error err = _draw_list_render_pass_begin(&curr_screen_framebuffer, INITIAL_ACTION_CLEAR, FINAL_ACTION_READ, INITIAL_ACTION_DROP, FINAL_ACTION_DISCARD, clear_colors, 0.0f, 0, Rect2i(), Point2i(), size, command_list, Vector<RID>());
+
+	if (err != OK) {
+		return INVALID_ID;
+	}
+
+	return int64_t(ID_TYPE_DRAW_LIST) << ID_BASE_SHIFT;
+}
+
+Error RenderingDeviceD3D12::_draw_list_render_pass_begin(Framebuffer *framebuffer, InitialAction p_initial_color_action, FinalAction p_final_color_action, InitialAction p_initial_depth_action, FinalAction p_final_depth_action, const Vector<Color> &p_clear_colors, float p_clear_depth, uint32_t p_clear_stencil, const Rect2 &p_region, Point2i viewport_offset, Point2i viewport_size, ID3D12GraphicsCommandList *command_list, const Vector<RID> &p_storage_textures) {
+	const FramebufferFormat &fb_format = framebuffer_formats[framebuffer->format_id];
+
+	bool is_screen = framebuffer->window_id != DisplayServer::INVALID_WINDOW_ID;
+	if (!is_screen) {
+		ERR_FAIL_COND_V(fb_format.attachments.size() != framebuffer->texture_ids.size(), ERR_BUG);
+	}
+
+	CD3DX12_RECT region_rect(0, 0, framebuffer->size.x, framebuffer->size.y);
+	if (p_region != Rect2() && p_region != Rect2(Vector2(), viewport_size)) { // Check custom region.
+		Rect2i viewport(viewport_offset, viewport_size);
+		Rect2i regioni = p_region;
+		if (!viewport.encloses(regioni)) {
+			ERR_FAIL_V_MSG(ERR_INVALID_PARAMETER, "When supplying a custom region, it must be contained within the framebuffer rectangle");
+		}
+		viewport_offset = regioni.position;
+		viewport_size = regioni.size;
+
+		region_rect = CD3DX12_RECT(
+				p_region.position.x,
+				p_region.position.y,
+				p_region.position.x + p_region.size.x,
+				p_region.position.y + p_region.size.y);
+	}
+
+	if (p_initial_color_action == INITIAL_ACTION_CLEAR) { // Check clear values.
+		int color_count = 0;
+		if (is_screen) {
+			color_count = 1;
+
+		} else {
+			for (int i = 0; i < framebuffer->texture_ids.size(); i++) {
+				Texture *texture = texture_owner.get_or_null(framebuffer->texture_ids[i]);
+				if (!texture || (!(texture->usage_flags & TEXTURE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT) && !(i != 0 && texture->usage_flags & TEXTURE_USAGE_VRS_ATTACHMENT_BIT))) {
+					if (!texture || !texture->is_resolve_buffer) {
+						color_count++;
+					}
+				}
+			}
+		}
+		ERR_FAIL_COND_V_MSG(p_clear_colors.size() != color_count, ERR_INVALID_PARAMETER,
+				"Clear color values supplied (" + itos(p_clear_colors.size()) + ") differ from the amount required for framebuffer color attachments (" + itos(color_count) + ").");
+	}
+
+	struct SetupInfo {
+		enum {
+			ACTION_NONE,
+			ACTION_DISCARD,
+			ACTION_CLEAR,
+		} action = ACTION_NONE;
+		UINT num_rects = 0;
+		D3D12_RECT *rect_ptr = nullptr;
+		D3D12_RESOURCE_STATES new_state = {};
+
+		SetupInfo(InitialAction p_action, D3D12_RECT *p_region_rect, bool p_is_color) {
+			switch (p_action) {
+				case INITIAL_ACTION_CLEAR: {
+					action = ACTION_CLEAR;
+				} break;
+				case INITIAL_ACTION_CLEAR_REGION: {
+					action = ACTION_CLEAR;
+					num_rects = 1;
+					rect_ptr = p_region_rect;
+				} break;
+				case INITIAL_ACTION_CLEAR_REGION_CONTINUE: {
+					action = ACTION_CLEAR;
+					num_rects = 1;
+					rect_ptr = p_region_rect;
+				} break;
+				case INITIAL_ACTION_KEEP: {
+				} break;
+				case INITIAL_ACTION_DROP: {
+					action = ACTION_DISCARD; // TODO: Are we really intended to do a resource Discard() as initial action, when final action can already do?
+				} break;
+				case INITIAL_ACTION_CONTINUE: {
+				} break;
+			}
+		}
+	};
+
+	SetupInfo setup_color(p_initial_color_action, &region_rect, true);
+	SetupInfo setup_depth(p_initial_depth_action, &region_rect, false);
+
+	draw_list_bound_textures.clear();
+	draw_list_unbind_color_textures = p_final_color_action != FINAL_ACTION_CONTINUE;
+	draw_list_unbind_depth_textures = p_final_depth_action != FINAL_ACTION_CONTINUE;
+
+	ID3D12Resource **discards = (ID3D12Resource **)alloca(sizeof(ID3D12Resource *) * fb_format.attachments.size());
+	uint32_t num_discards = 0;
+
+	struct RTVClear {
+		D3D12_CPU_DESCRIPTOR_HANDLE handle;
+		Color color;
+	};
+	RTVClear *rtv_clears = (RTVClear *)alloca(sizeof(RTVClear) * fb_format.attachments.size());
+	uint32_t num_rtv_clears = 0;
+
+	bool dsv_clear = false;
+
+	DescriptorsHeap::Walker rtv_heap_walker = framebuffer->rtv_heap.make_walker();
+
+	int color_index = 0;
+	for (int i = 0; i < fb_format.attachments.size(); i++) {
+		RID texture_rid;
+		Texture *texture = nullptr;
+		if (!is_screen) {
+			texture_rid = framebuffer->texture_ids[i];
+			if (texture_rid.is_null()) {
+				color_index++;
+				continue;
+			}
+
+			texture = texture_owner.get_or_null(texture_rid);
+			ERR_FAIL_NULL_V(texture, ERR_BUG);
+
+			texture->bound = true;
+			draw_list_bound_textures.push_back(texture_rid);
+		}
+
+		// We can setup a framebuffer where we write to our VRS texture to set it up.
+		// We make the assumption here that if our texture is actually used as our VRS attachment,
+		// it is used as such for each subpass. This is fairly certain seeing the restrictions on subpasses (in Vulkan).
+		// [[VRS_EVERY_SUBPASS_OR_NONE]]
+		bool is_vrs = fb_format.attachments[i].usage_flags & TEXTURE_USAGE_VRS_ATTACHMENT_BIT && i == fb_format.passes[0].vrs_attachment;
+		if (is_vrs) {
+			DEV_ASSERT(!is_screen);
+
+			DEV_ASSERT(texture->owner_mipmaps == 1);
+			DEV_ASSERT(texture->owner_layers == 1);
+			_resource_transition_batch(texture, 0, texture->planes, D3D12_RESOURCE_STATE_SHADING_RATE_SOURCE);
+		} else {
+			if ((fb_format.attachments[i].usage_flags & TEXTURE_USAGE_COLOR_ATTACHMENT_BIT)) {
+				if (!is_screen) { // Screen backbuffers are transitioned in prepare_buffers().
+					for (uint32_t j = 0; j < texture->layers; j++) {
+						for (uint32_t k = 0; k < texture->mipmaps; k++) {
+							uint32_t subresource = D3D12CalcSubresource(texture->base_mipmap + k, texture->base_layer + j, 0, texture->owner_mipmaps, texture->owner_layers);
+							_resource_transition_batch(texture, subresource, texture->planes, D3D12_RESOURCE_STATE_RENDER_TARGET);
+						}
+					}
+				}
+
+				if (setup_color.action == SetupInfo::ACTION_DISCARD) {
+					ID3D12Resource *resource = is_screen ? context->window_get_framebuffer_texture(framebuffer->window_id) : texture->resource;
+					discards[num_discards++] = resource;
+				} else if (setup_color.action == SetupInfo::ACTION_CLEAR) {
+					D3D12_CPU_DESCRIPTOR_HANDLE handle = is_screen ? framebuffer->screen_rtv_handle : rtv_heap_walker.get_curr_cpu_handle();
+					Color clear_color = color_index < p_clear_colors.size() ? p_clear_colors[color_index] : Color();
+					rtv_clears[num_rtv_clears++] = RTVClear{ handle, clear_color };
+				}
+
+				color_index++;
+				if (!is_screen) {
+					rtv_heap_walker.advance();
+				}
+			} else if ((fb_format.attachments[i].usage_flags & TEXTURE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT)) {
+				DEV_ASSERT(!is_screen);
+
+				for (uint32_t j = 0; j < texture->layers; j++) {
+					for (uint32_t k = 0; k < texture->mipmaps; k++) {
+						uint32_t subresource = D3D12CalcSubresource(texture->base_mipmap + k, texture->base_layer + j, 0, texture->owner_mipmaps, texture->owner_layers);
+						_resource_transition_batch(texture, subresource, texture->planes, D3D12_RESOURCE_STATE_DEPTH_WRITE);
+					}
+				}
+
+				if (setup_depth.action == SetupInfo::ACTION_DISCARD) {
+					discards[num_discards++] = texture->resource;
+				} else if (setup_depth.action == SetupInfo::ACTION_CLEAR) {
+					dsv_clear = true;
+				}
+			}
+		}
+	}
+
+	for (int i = 0; i < p_storage_textures.size(); i++) {
+		Texture *texture = texture_owner.get_or_null(p_storage_textures[i]);
+		if (!texture) {
+			continue;
+		}
+		ERR_CONTINUE_MSG(!(texture->usage_flags & TEXTURE_USAGE_STORAGE_BIT), "Supplied storage texture " + itos(i) + " for draw list is not set to be used for storage.");
+	}
+
+	_resource_transitions_flush(frames[frame].draw_command_list.Get());
+
+	for (uint32_t i = 0; i < num_discards; i++) {
+		command_list->DiscardResource(discards[i], nullptr);
+	}
+	for (uint32_t i = 0; i < num_rtv_clears; i++) {
+		command_list->ClearRenderTargetView(
+				rtv_clears[i].handle,
+				rtv_clears[i].color.components,
+				setup_color.num_rects,
+				setup_color.rect_ptr);
+	}
+
+	if (dsv_clear) {
+		command_list->ClearDepthStencilView(
+				framebuffer->dsv_heap.get_heap()->GetCPUDescriptorHandleForHeapStart(),
+				D3D12_CLEAR_FLAG_DEPTH | D3D12_CLEAR_FLAG_STENCIL,
+				p_clear_depth,
+				p_clear_stencil,
+				setup_depth.num_rects,
+				setup_depth.rect_ptr);
+	}
+
+	{
+		CD3DX12_VIEWPORT viewport(
+				viewport_offset.x,
+				viewport_offset.y,
+				viewport_size.x,
+				viewport_size.y,
+				0.0f,
+				1.0f);
+		command_list->RSSetViewports(1, &viewport);
+
+		CD3DX12_RECT scissor(
+				viewport_offset.x,
+				viewport_offset.y,
+				viewport_offset.x + viewport_size.x,
+				viewport_offset.y + viewport_size.y);
+		command_list->RSSetScissorRects(1, &scissor);
+	}
+
+	draw_list_subpass_count = fb_format.passes.size();
+	draw_list_current_subpass = 0;
+	draw_list_final_color_action = p_final_color_action;
+	draw_list_final_depth_action = p_final_depth_action;
+	draw_list_framebuffer = framebuffer;
+	draw_list_viewport_size = viewport_size;
+
+	_draw_list_subpass_begin();
+
+	return OK;
+}
+
+RenderingDevice::DrawListID RenderingDeviceD3D12::draw_list_begin(RID p_framebuffer, InitialAction p_initial_color_action, FinalAction p_final_color_action, InitialAction p_initial_depth_action, FinalAction p_final_depth_action, const Vector<Color> &p_clear_color_values, float p_clear_depth, uint32_t p_clear_stencil, const Rect2 &p_region, const Vector<RID> &p_storage_textures) {
+	_THREAD_SAFE_METHOD_
+
+	ERR_FAIL_COND_V_MSG(draw_list != nullptr, INVALID_ID, "Only one draw list can be active at the same time.");
+	ERR_FAIL_COND_V_MSG(compute_list != nullptr && !compute_list->state.allow_draw_overlap, INVALID_ID, "Only one draw/compute list can be active at the same time.");
+
+	Framebuffer *framebuffer = framebuffer_owner.get_or_null(p_framebuffer);
+	ERR_FAIL_NULL_V(framebuffer, INVALID_ID);
+
+	ID3D12GraphicsCommandList *command_list = frames[frame].draw_command_list.Get();
+	Error err = _draw_list_render_pass_begin(framebuffer, p_initial_color_action, p_final_color_action, p_initial_depth_action, p_final_depth_action, p_clear_color_values, p_clear_depth, p_clear_stencil, p_region, Point2i(), framebuffer->size, command_list, p_storage_textures);
+
+	if (err != OK) {
+		return INVALID_ID;
+	}
+
+	_draw_list_allocate(Rect2i(Point2i(), framebuffer->size), 0, 0);
+
+	return int64_t(ID_TYPE_DRAW_LIST) << ID_BASE_SHIFT;
+}
+
+Error RenderingDeviceD3D12::draw_list_begin_split(RID p_framebuffer, uint32_t p_splits, DrawListID *r_split_ids, InitialAction p_initial_color_action, FinalAction p_final_color_action, InitialAction p_initial_depth_action, FinalAction p_final_depth_action, const Vector<Color> &p_clear_color_values, float p_clear_depth, uint32_t p_clear_stencil, const Rect2 &p_region, const Vector<RID> &p_storage_textures) {
+	_THREAD_SAFE_METHOD_
+
+	ERR_FAIL_COND_V_MSG(draw_list != nullptr, ERR_BUSY, "Only one draw list can be active at the same time.");
+	ERR_FAIL_COND_V_MSG(compute_list != nullptr && !compute_list->state.allow_draw_overlap, ERR_BUSY, "Only one draw/compute list can be active at the same time.");
+
+	ERR_FAIL_COND_V(p_splits < 1, ERR_INVALID_DECLARATION);
+
+	Framebuffer *framebuffer = framebuffer_owner.get_or_null(p_framebuffer);
+	ERR_FAIL_NULL_V(framebuffer, ERR_INVALID_DECLARATION);
+
+	ID3D12GraphicsCommandList *frame_command_list = frames[frame].draw_command_list.Get();
+	Error err = _draw_list_render_pass_begin(framebuffer, p_initial_color_action, p_final_color_action, p_initial_depth_action, p_final_depth_action, p_clear_color_values, p_clear_depth, p_clear_stencil, p_region, Point2i(), framebuffer->size, frame_command_list, p_storage_textures);
+
+	if (err != OK) {
+		return ERR_CANT_CREATE;
+	}
+
+	err = _draw_list_allocate(Rect2i(Point2i(), framebuffer->size), p_splits, 0);
+	if (err != OK) {
+		return err;
+	}
+
+	for (uint32_t i = 0; i < p_splits; i++) {
+		// In Vulkan, we'd be setting viewports and scissors for each split here;
+		// D3D12 doesn't need it (it's even forbidden, for that matter).
+
+		r_split_ids[i] = (int64_t(ID_TYPE_SPLIT_DRAW_LIST) << ID_BASE_SHIFT) + i;
+	}
+
+	return OK;
+}
+
+RenderingDeviceD3D12::DrawList *RenderingDeviceD3D12::_get_draw_list_ptr(DrawListID p_id) {
+	if (p_id < 0) {
+		return nullptr;
+	}
+
+	if (!draw_list) {
+		return nullptr;
+	} else if (p_id == (int64_t(ID_TYPE_DRAW_LIST) << ID_BASE_SHIFT)) {
+		if (draw_list_split) {
+			return nullptr;
+		}
+		return draw_list;
+	} else if (p_id >> DrawListID(ID_BASE_SHIFT) == ID_TYPE_SPLIT_DRAW_LIST) {
+		if (!draw_list_split) {
+			return nullptr;
+		}
+
+		uint64_t index = p_id & ((DrawListID(1) << DrawListID(ID_BASE_SHIFT)) - 1); // Mask.
+
+		if (index >= draw_list_count) {
+			return nullptr;
+		}
+
+		return &draw_list[index];
+	} else {
+		return nullptr;
+	}
+}
+
+void RenderingDeviceD3D12::draw_list_set_blend_constants(DrawListID p_list, const Color &p_color) {
+	DrawList *dl = _get_draw_list_ptr(p_list);
+	ERR_FAIL_NULL(dl);
+#ifdef DEBUG_ENABLED
+	ERR_FAIL_COND_MSG(!dl->validation.active, "Submitted Draw Lists can no longer be modified.");
+#endif
+
+	dl->command_list->OMSetBlendFactor(p_color.components);
+}
+
+void RenderingDeviceD3D12::draw_list_bind_render_pipeline(DrawListID p_list, RID p_render_pipeline) {
+	DrawList *dl = _get_draw_list_ptr(p_list);
+	ERR_FAIL_NULL(dl);
+#ifdef DEBUG_ENABLED
+	ERR_FAIL_COND_MSG(!dl->validation.active, "Submitted Draw Lists can no longer be modified.");
+#endif
+
+	const RenderPipeline *pipeline = render_pipeline_owner.get_or_null(p_render_pipeline);
+	ERR_FAIL_NULL(pipeline);
+#ifdef DEBUG_ENABLED
+	ERR_FAIL_COND(pipeline->validation.framebuffer_format != draw_list_framebuffer->format_id && pipeline->validation.render_pass != draw_list_current_subpass);
+#endif
+
+	if (p_render_pipeline == dl->state.pipeline) {
+		return; // Redundant state, return.
+	}
+
+	dl->state.pipeline = p_render_pipeline;
+	dl->state.pso = pipeline->pso.Get();
+
+	dl->command_list->IASetPrimitiveTopology(pipeline->dyn_params.primitive_topology);
+	dl->command_list->OMSetBlendFactor(pipeline->dyn_params.blend_constant.components);
+	dl->command_list->OMSetStencilRef(pipeline->dyn_params.stencil_reference);
+
+	ID3D12GraphicsCommandList1 *command_list_1 = nullptr;
+	dl->command_list->QueryInterface<ID3D12GraphicsCommandList1>(&command_list_1);
+	if (command_list_1) {
+		command_list_1->OMSetDepthBounds(pipeline->dyn_params.depth_bounds_min, pipeline->dyn_params.depth_bounds_max);
+		command_list_1->Release();
+	}
+
+	Shader *shader = shader_owner.get_or_null(pipeline->shader);
+
+	if (dl->state.pipeline_shader != pipeline->shader) {
+		if (dl->state.root_signature_crc != pipeline->root_signature_crc) {
+			dl->command_list->SetGraphicsRootSignature(shader->root_signature.Get());
+			dl->state.root_signature_crc = pipeline->root_signature_crc;
+
+			// Root signature changed, so current descriptor set bindings become invalid.
+			for (uint32_t i = 0; i < dl->state.set_count; i++) {
+				dl->state.sets[i].bound = false;
+			}
+
+			if (pipeline->nir_runtime_data_root_param_idx != UINT32_MAX) {
+				// Set the viewport size part of the DXIL-NIR runtime data, which is the only we know to need currently.
+				constexpr dxil_spirv_vertex_runtime_data dummy_data = {};
+				uint32_t offset = constexpr((char *)&dummy_data.viewport_width - (char *)&dummy_data) / 4;
+				dl->command_list->SetGraphicsRoot32BitConstants(pipeline->nir_runtime_data_root_param_idx, 2, &draw_list_viewport_size, offset);
+			}
+		}
+
+		const uint32_t *pformats = pipeline->set_formats.ptr(); // Pipeline set formats.
+		dl->state.set_count = pipeline->set_formats.size(); // Update set count.
+		for (uint32_t i = 0; i < dl->state.set_count; i++) {
+			dl->state.sets[i].pipeline_expected_format = pformats[i];
+#ifdef DEV_ENABLED
+			dl->state.sets[i]._pipeline_expected_format = pformats[i] ? &uniform_set_format_cache_reverse[pformats[i] - 1]->key().uniform_info : nullptr;
+#endif
+		}
+
+		if (pipeline->spirv_push_constant_size) {
+#ifdef DEBUG_ENABLED
+			dl->validation.pipeline_push_constant_supplied = false;
+#endif
+		}
+
+		dl->state.pipeline_shader = pipeline->shader;
+		dl->state.pipeline_dxil_push_constant_size = pipeline->dxil_push_constant_size;
+		dl->state.pipeline_bindings_id = pipeline->bindings_id;
+#ifdef DEV_ENABLED
+		dl->state._shader = shader;
+#endif
+	}
+
+#ifdef DEBUG_ENABLED
+	// Update render pass pipeline info.
+	dl->validation.pipeline_active = true;
+	dl->validation.pipeline_dynamic_state = pipeline->validation.dynamic_state;
+	dl->validation.pipeline_vertex_format = pipeline->validation.vertex_format;
+	dl->validation.pipeline_uses_restart_indices = pipeline->validation.uses_restart_indices;
+	dl->validation.pipeline_primitive_divisor = pipeline->validation.primitive_divisor;
+	dl->validation.pipeline_primitive_minimum = pipeline->validation.primitive_minimum;
+	dl->validation.pipeline_spirv_push_constant_size = pipeline->spirv_push_constant_size;
+#endif
+}
+
+void RenderingDeviceD3D12::draw_list_bind_uniform_set(DrawListID p_list, RID p_uniform_set, uint32_t p_index) {
+	DrawList *dl = _get_draw_list_ptr(p_list);
+	ERR_FAIL_NULL(dl);
+
+#ifdef DEBUG_ENABLED
+	ERR_FAIL_COND_MSG(!dl->validation.active, "Submitted Draw Lists can no longer be modified.");
+#endif
+
+	const UniformSet *uniform_set = uniform_set_owner.get_or_null(p_uniform_set);
+	ERR_FAIL_NULL(uniform_set);
+
+	if (p_index > dl->state.set_count) {
+		dl->state.set_count = p_index;
+	}
+
+	dl->state.sets[p_index].bound = false; // Needs rebind.
+	dl->state.sets[p_index].uniform_set_format = uniform_set->format;
+	dl->state.sets[p_index].uniform_set = p_uniform_set;
+#ifdef DEV_ENABLED
+	dl->state.sets[p_index]._uniform_set = uniform_set_owner.get_or_null(p_uniform_set);
+#endif
+
+#ifdef DEBUG_ENABLED
+	{ // Validate that textures bound are not attached as framebuffer bindings.
+		uint32_t attachable_count = uniform_set->attachable_textures.size();
+		const UniformSet::AttachableTexture *attachable_ptr = uniform_set->attachable_textures.ptr();
+		uint32_t bound_count = draw_list_bound_textures.size();
+		const RID *bound_ptr = draw_list_bound_textures.ptr();
+		for (uint32_t i = 0; i < attachable_count; i++) {
+			for (uint32_t j = 0; j < bound_count; j++) {
+				ERR_FAIL_COND_MSG(attachable_ptr[i].texture == bound_ptr[j],
+						"Attempted to use the same texture in framebuffer attachment and a uniform (set: " + itos(p_index) + ", binding: " + itos(attachable_ptr[i].bind) + "), this is not allowed.");
+			}
+		}
+	}
+#endif
+}
+
+void RenderingDeviceD3D12::draw_list_bind_vertex_array(DrawListID p_list, RID p_vertex_array) {
+	DrawList *dl = _get_draw_list_ptr(p_list);
+	ERR_FAIL_NULL(dl);
+#ifdef DEBUG_ENABLED
+	ERR_FAIL_COND_MSG(!dl->validation.active, "Submitted Draw Lists can no longer be modified.");
+#endif
+
+	const VertexArray *vertex_array = vertex_array_owner.get_or_null(p_vertex_array);
+	ERR_FAIL_NULL(vertex_array);
+
+	if (dl->state.vertex_array == p_vertex_array) {
+		return; // Already set.
+	}
+
+	dl->state.vertex_array = p_vertex_array;
+
+#ifdef DEBUG_ENABLED
+	dl->validation.vertex_format = vertex_array->description;
+	dl->validation.vertex_max_instances_allowed = vertex_array->max_instances_allowed;
+#endif
+	dl->validation.vertex_array_size = vertex_array->vertex_count;
+
+	for (Buffer *buffer : vertex_array->unique_buffers) {
+		_resource_transition_batch(buffer, 0, 1, D3D12_RESOURCE_STATE_VERTEX_AND_CONSTANT_BUFFER);
+	}
+	_resource_transitions_flush(dl->command_list);
+
+	dl->command_list->IASetVertexBuffers(0, vertex_array->views.size(), vertex_array->views.ptr());
+}
+
+void RenderingDeviceD3D12::draw_list_bind_index_array(DrawListID p_list, RID p_index_array) {
+	DrawList *dl = _get_draw_list_ptr(p_list);
+	ERR_FAIL_NULL(dl);
+#ifdef DEBUG_ENABLED
+	ERR_FAIL_COND_MSG(!dl->validation.active, "Submitted Draw Lists can no longer be modified.");
+#endif
+
+	const IndexArray *index_array = index_array_owner.get_or_null(p_index_array);
+	ERR_FAIL_NULL(index_array);
+
+	if (dl->state.index_array == p_index_array) {
+		return; // Already set.
+	}
+
+	dl->state.index_array = p_index_array;
+#ifdef DEBUG_ENABLED
+	dl->validation.index_array_max_index = index_array->max_index;
+#endif
+	dl->validation.index_array_size = index_array->indices;
+	dl->validation.index_array_offset = index_array->offset;
+
+	_resource_transition_batch(index_array->buffer, 0, 1, D3D12_RESOURCE_STATE_INDEX_BUFFER);
+	_resource_transitions_flush(dl->command_list);
+
+	dl->command_list->IASetIndexBuffer(&index_array->view);
+}
+
+void RenderingDeviceD3D12::draw_list_set_line_width(DrawListID p_list, float p_width) {
+	DrawList *dl = _get_draw_list_ptr(p_list);
+	ERR_FAIL_NULL(dl);
+#ifdef DEBUG_ENABLED
+	ERR_FAIL_COND_MSG(!dl->validation.active, "Submitted Draw Lists can no longer be modified.");
+#endif
+
+	if (!Math::is_equal_approx(p_width, 1.0f)) {
+		ERR_FAIL_MSG("Setting line widths other than 1.0 is not supported by the Direct3D 12 rendering driver.");
+	}
+}
+
+void RenderingDeviceD3D12::_bind_uniform_set(UniformSet *p_uniform_set, const Shader::Set &p_shader_set, const Vector<UniformBindingInfo> &p_bindings, ID3D12GraphicsCommandList *p_command_list, bool p_for_compute) {
+	using SetRootDescriptorTableFn = void (STDMETHODCALLTYPE ID3D12GraphicsCommandList::*)(UINT, D3D12_GPU_DESCRIPTOR_HANDLE);
+	SetRootDescriptorTableFn set_root_desc_table_fn = p_for_compute ? &ID3D12GraphicsCommandList::SetComputeRootDescriptorTable : &ID3D12GraphicsCommandList1::SetGraphicsRootDescriptorTable;
+
+	// If this set's descriptors have already been set for the current execution and a compatible root signature, reuse!
+	uint32_t root_sig_crc = p_for_compute ? compute_list->state.root_signature_crc : draw_list->state.root_signature_crc;
+	UniformSet::RecentBind *last_bind = nullptr;
+	for (int i = 0; i < ARRAY_SIZE(p_uniform_set->recent_binds); i++) {
+		if (p_uniform_set->recent_binds[i].execution_index == frames[frame].execution_index) {
+			if (p_uniform_set->recent_binds[i].root_signature_crc == root_sig_crc) {
+				for (const RootDescriptorTable &table : p_uniform_set->recent_binds[i].root_tables.resources) {
+					(p_command_list->*set_root_desc_table_fn)(table.root_param_idx, table.start_gpu_handle);
+				}
+				for (const RootDescriptorTable &table : p_uniform_set->recent_binds[i].root_tables.samplers) {
+					(p_command_list->*set_root_desc_table_fn)(table.root_param_idx, table.start_gpu_handle);
+				}
+#ifdef DEV_ENABLED
+				p_uniform_set->recent_binds[i].uses++;
+				frames[frame].uniform_set_reused++;
+#endif
+				return;
+			} else {
+				if (!last_bind || p_uniform_set->recent_binds[i].uses < last_bind->uses) {
+					// Prefer this one since it's been used less or we still haven't a better option.
+					last_bind = &p_uniform_set->recent_binds[i];
+				}
+			}
+		} else {
+			// Prefer this one since it's unused.
+			last_bind = &p_uniform_set->recent_binds[i];
+			last_bind->uses = 0;
+		}
+	}
+
+	struct {
+		DescriptorsHeap::Walker *resources = nullptr;
+		DescriptorsHeap::Walker *samplers = nullptr;
+	} frame_heap_walkers;
+	frame_heap_walkers.resources = &frames[frame].desc_heap_walkers.resources;
+	frame_heap_walkers.samplers = &frames[frame].desc_heap_walkers.samplers;
+
+	struct {
+		DescriptorsHeap::Walker resources;
+		DescriptorsHeap::Walker samplers;
+	} set_heap_walkers;
+	set_heap_walkers.resources = p_uniform_set->desc_heaps.resources.make_walker();
+	set_heap_walkers.samplers = p_uniform_set->desc_heaps.samplers.make_walker();
+
+#ifdef DEV_ENABLED
+	// Whether we have stages where the uniform is actually used should match
+	// whether we have any root signature locations for it.
+	for (int i = 0; i < p_shader_set.uniforms.size(); i++) {
+		bool has_rs_locations = false;
+		if (p_bindings[i].root_sig_locations.resource.root_param_idx != UINT32_MAX ||
+				p_bindings[i].root_sig_locations.sampler.root_param_idx != UINT32_MAX) {
+			has_rs_locations = true;
+			break;
+		}
+
+		bool has_stages = p_bindings[i].stages;
+
+		DEV_ASSERT(has_rs_locations == has_stages);
+	}
+#endif
+
+	last_bind->root_tables.resources.reserve(p_shader_set.num_root_params.resources);
+	last_bind->root_tables.resources.clear();
+	last_bind->root_tables.samplers.reserve(p_shader_set.num_root_params.samplers);
+	last_bind->root_tables.samplers.clear();
+	last_bind->uses++;
+
+	struct {
+		RootDescriptorTable *resources = nullptr;
+		RootDescriptorTable *samplers = nullptr;
+	} tables;
+	for (int i = 0; i < p_shader_set.uniforms.size(); i++) {
+		const Shader::ShaderUniformInfo &uniform_info = p_shader_set.uniforms[i];
+
+		uint32_t num_resource_descs = 0;
+		uint32_t num_sampler_descs = 0;
+		bool srv_uav_ambiguity = false;
+		_add_descriptor_count_for_uniform(uniform_info.info.type, uniform_info.info.length, false, num_resource_descs, num_sampler_descs, srv_uav_ambiguity);
+
+		bool resource_used = false;
+		if (p_bindings[i].stages) {
+			{
+				const UniformBindingInfo::RootSignatureLocation &rs_loc_resource = p_bindings[i].root_sig_locations.resource;
+				if (rs_loc_resource.root_param_idx != UINT32_MAX) { // Location used?
+					DEV_ASSERT(num_resource_descs);
+					DEV_ASSERT(!(srv_uav_ambiguity && (p_bindings[i].res_class != RES_CLASS_SRV && p_bindings[i].res_class != RES_CLASS_UAV))); // [[SRV_UAV_AMBIGUITY]]
+
+					bool must_flush_table = tables.resources && rs_loc_resource.root_param_idx != tables.resources->root_param_idx;
+					if (must_flush_table) {
+						// Check the root signature data has been filled ordered.
+						DEV_ASSERT(rs_loc_resource.root_param_idx > tables.resources->root_param_idx);
+
+						(p_command_list->*set_root_desc_table_fn)(tables.resources->root_param_idx, tables.resources->start_gpu_handle);
+						tables.resources = nullptr;
+					}
+
+					if (unlikely(frame_heap_walkers.resources->get_free_handles() < num_resource_descs)) {
+						if (!frames[frame].desc_heaps_exhausted_reported.resources) {
+							frames[frame].desc_heaps_exhausted_reported.resources = true;
+							ERR_FAIL_MSG("Cannot bind uniform set because there's no enough room in current frame's RESOURCES descriptor heap.\n"
+										 "Please increase the value of the rendering/rendering_device/d3d12/max_resource_descriptors_per_frame project setting.");
+						} else {
+							return;
+						}
+					}
+
+					if (!tables.resources) {
+						DEV_ASSERT(last_bind->root_tables.resources.size() < last_bind->root_tables.resources.get_capacity());
+						last_bind->root_tables.resources.resize(last_bind->root_tables.resources.size() + 1);
+						tables.resources = &last_bind->root_tables.resources[last_bind->root_tables.resources.size() - 1];
+						tables.resources->root_param_idx = rs_loc_resource.root_param_idx;
+						tables.resources->start_gpu_handle = frame_heap_walkers.resources->get_curr_gpu_handle();
+					}
+
+					// If there is ambiguity and it didn't clarify as SRVs, skip them, which come first. [[SRV_UAV_AMBIGUITY]]
+					if (srv_uav_ambiguity && p_bindings[i].res_class != RES_CLASS_SRV) {
+						set_heap_walkers.resources.advance(num_resource_descs);
+					}
+
+					// TODO: Batch to avoid multiple calls where possible (in any case, flush before setting root descriptor tables, or even batch that as well).
+					device->CopyDescriptorsSimple(
+							num_resource_descs,
+							frame_heap_walkers.resources->get_curr_cpu_handle(),
+							set_heap_walkers.resources.get_curr_cpu_handle(),
+							D3D12_DESCRIPTOR_HEAP_TYPE_CBV_SRV_UAV);
+					frame_heap_walkers.resources->advance(num_resource_descs);
+
+					// If there is ambiguity and it didn't clarify as UAVs, skip them, which come later. [[SRV_UAV_AMBIGUITY]]
+					if (srv_uav_ambiguity && p_bindings[i].res_class != RES_CLASS_UAV) {
+						set_heap_walkers.resources.advance(num_resource_descs);
+					}
+
+					resource_used = true;
+				}
+			}
+
+			{
+				const UniformBindingInfo::RootSignatureLocation &rs_loc_sampler = p_bindings[i].root_sig_locations.sampler;
+				if (rs_loc_sampler.root_param_idx != UINT32_MAX) { // Location used?
+					DEV_ASSERT(num_sampler_descs);
+					DEV_ASSERT(!srv_uav_ambiguity); // [[SRV_UAV_AMBIGUITY]]
+
+					bool must_flush_table = tables.samplers && rs_loc_sampler.root_param_idx != tables.samplers->root_param_idx;
+					if (must_flush_table) {
+						// Check the root signature data has been filled ordered.
+						DEV_ASSERT(rs_loc_sampler.root_param_idx > tables.samplers->root_param_idx);
+
+						(p_command_list->*set_root_desc_table_fn)(tables.samplers->root_param_idx, tables.samplers->start_gpu_handle);
+						tables.samplers = nullptr;
+					}
+
+					if (unlikely(frame_heap_walkers.samplers->get_free_handles() < num_sampler_descs)) {
+						if (!frames[frame].desc_heaps_exhausted_reported.samplers) {
+							frames[frame].desc_heaps_exhausted_reported.samplers = true;
+							ERR_FAIL_MSG("Cannot bind uniform set because there's no enough room in current frame's SAMPLERS descriptors heap.\n"
+										 "Please increase the value of the rendering/rendering_device/d3d12/max_sampler_descriptors_per_frame project setting.");
+						} else {
+							return;
+						}
+					}
+
+					if (!tables.samplers) {
+						DEV_ASSERT(last_bind->root_tables.samplers.size() < last_bind->root_tables.samplers.get_capacity());
+						last_bind->root_tables.samplers.resize(last_bind->root_tables.samplers.size() + 1);
+						tables.samplers = &last_bind->root_tables.samplers[last_bind->root_tables.samplers.size() - 1];
+						tables.samplers->root_param_idx = rs_loc_sampler.root_param_idx;
+						tables.samplers->start_gpu_handle = frame_heap_walkers.samplers->get_curr_gpu_handle();
+					}
+
+					// TODO: Batch to avoid multiple calls where possible (in any case, flush before setting root descriptor tables, or even batch that as well).
+					device->CopyDescriptorsSimple(
+							num_sampler_descs,
+							frame_heap_walkers.samplers->get_curr_cpu_handle(),
+							set_heap_walkers.samplers.get_curr_cpu_handle(),
+							D3D12_DESCRIPTOR_HEAP_TYPE_SAMPLER);
+					frame_heap_walkers.samplers->advance(num_sampler_descs);
+				}
+			}
+		}
+
+		// Uniform set descriptor heaps are always full (descriptors are created for every uniform in them) despite
+		// the shader variant a given set is created upon may not need all of them due to DXC optimizations.
+		// Therefore, at this point we have to advance through the descriptor set descriptor's heap unconditionally.
+
+		set_heap_walkers.resources.advance(num_resource_descs);
+		if (srv_uav_ambiguity) {
+			DEV_ASSERT(num_resource_descs);
+			if (!resource_used) {
+				set_heap_walkers.resources.advance(num_resource_descs); // Additional skip, since both SRVs and UAVs have to be bypassed.
+			}
+		}
+
+		set_heap_walkers.samplers.advance(num_sampler_descs);
+	}
+
+	DEV_ASSERT(set_heap_walkers.resources.is_at_eof());
+	DEV_ASSERT(set_heap_walkers.samplers.is_at_eof());
+
+	{
+		bool must_flush_table = tables.resources;
+		if (must_flush_table) {
+			(p_command_list->*set_root_desc_table_fn)(tables.resources->root_param_idx, tables.resources->start_gpu_handle);
+		}
+	}
+	{
+		bool must_flush_table = tables.samplers;
+		if (must_flush_table) {
+			(p_command_list->*set_root_desc_table_fn)(tables.samplers->root_param_idx, tables.samplers->start_gpu_handle);
+		}
+	}
+
+	last_bind->root_signature_crc = root_sig_crc;
+	last_bind->execution_index = frames[frame].execution_index;
+}
+
+void RenderingDeviceD3D12::_apply_uniform_set_resource_states(const UniformSet *p_uniform_set, const Shader::Set &p_shader_set) {
+	for (const UniformSet::StateRequirement &sr : p_uniform_set->resource_states) {
+#ifdef DEV_ENABLED
+		{
+			uint32_t stages = 0;
+			D3D12_RESOURCE_STATES wanted_state = {};
+			bool writable = false;
+			// Doing the full loop for debugging since the real one below may break early,
+			// but we want an exhaustive check
+			uint64_t inv_uniforms_mask = ~sr.shader_uniform_idx_mask; // Inverting the mask saves operations.
+			for (uint8_t bit = 0; inv_uniforms_mask != UINT64_MAX; bit++) {
+				uint64_t bit_mask = ((uint64_t)1 << bit);
+				if (likely((inv_uniforms_mask & bit_mask))) {
+					continue;
+				}
+				inv_uniforms_mask |= bit_mask;
+
+				const Shader::ShaderUniformInfo &info = p_shader_set.uniforms[bit];
+				if (unlikely(!info.binding.stages)) {
+					continue;
+				}
+
+				D3D12_RESOURCE_STATES required_states = sr.states;
+
+				// Resolve a case of SRV/UAV ambiguity now. [[SRV_UAV_AMBIGUITY]]
+				if ((required_states & D3D12_RESOURCE_STATE_ALL_SHADER_RESOURCE) && (required_states & D3D12_RESOURCE_STATE_UNORDERED_ACCESS)) {
+					if (info.binding.res_class == RES_CLASS_SRV) {
+						required_states &= ~D3D12_RESOURCE_STATE_UNORDERED_ACCESS;
+					} else {
+						required_states = D3D12_RESOURCE_STATE_UNORDERED_ACCESS;
+					}
+				}
+
+				if (stages) { // Second occurrence at least?
+					CRASH_COND_MSG(info.info.writable != writable, "A resource is used in the same uniform set both as R/O and R/W. That's not supported and shouldn't happen.");
+					CRASH_COND_MSG(required_states != wanted_state, "A resource is used in the same uniform set with different resource states. The code needs to be enhanced to support that.");
+				} else {
+					wanted_state = required_states;
+					stages |= info.binding.stages;
+					writable = info.info.writable;
+				}
+
+				DEV_ASSERT((wanted_state == D3D12_RESOURCE_STATE_UNORDERED_ACCESS) == (bool)(wanted_state & D3D12_RESOURCE_STATE_UNORDERED_ACCESS));
+
+				if (wanted_state == D3D12_RESOURCE_STATE_UNORDERED_ACCESS || wanted_state == D3D12_RESOURCE_STATE_RENDER_TARGET) {
+					if (!sr.is_buffer) {
+						Texture *texture = (Texture *)sr.resource;
+						CRASH_COND_MSG(texture->resource != texture->owner_resource, "The texture format used for UAV or RTV must be the main one.");
+					}
+				}
+			}
+		}
+#endif
+
+		// We may have assumed D3D12_RESOURCE_STATE_ALL_SHADER_RESOURCE for a resource,
+		// because at uniform set creation time we couldn't know for sure which stages
+		// it would be used in (due to the fact that a set can be created against a different,
+		// albeit compatible, shader, which may make a different usage in the end).
+		// However, now we know and can exclude up to one unneeded state.
+
+		// TODO: If subresources involved already in the needed state, or scheduled for it,
+		// maybe it's more optimal not to do anything here
+
+		uint32_t stages = 0;
+		D3D12_RESOURCE_STATES wanted_state = {};
+		uint64_t inv_uniforms_mask = ~sr.shader_uniform_idx_mask; // Inverting the mask saves operations.
+		for (uint8_t bit = 0; inv_uniforms_mask != UINT64_MAX; bit++) {
+			uint64_t bit_mask = ((uint64_t)1 << bit);
+			if (likely((inv_uniforms_mask & bit_mask))) {
+				continue;
+			}
+			inv_uniforms_mask |= bit_mask;
+
+			const Shader::ShaderUniformInfo &info = p_shader_set.uniforms[bit];
+			if (unlikely(!info.binding.stages)) {
+				continue;
+			}
+
+			if (!stages) {
+				D3D12_RESOURCE_STATES required_states = sr.states;
+
+				// Resolve a case of SRV/UAV ambiguity now. [[SRV_UAV_AMBIGUITY]]
+				if ((required_states & D3D12_RESOURCE_STATE_ALL_SHADER_RESOURCE) && (required_states & D3D12_RESOURCE_STATE_UNORDERED_ACCESS)) {
+					if (info.binding.res_class == RES_CLASS_SRV) {
+						required_states &= ~D3D12_RESOURCE_STATE_UNORDERED_ACCESS;
+					} else {
+						required_states = D3D12_RESOURCE_STATE_UNORDERED_ACCESS;
+					}
+				}
+
+				wanted_state = required_states;
+
+				if (!(wanted_state & D3D12_RESOURCE_STATE_ALL_SHADER_RESOURCE)) {
+					// By now, we already know the resource is used, and with no PS/NON_PS disjuntive; no need to check further.
+					break;
+				}
+			}
+
+			stages |= info.binding.stages;
+
+			if (stages == (SHADER_STAGE_VERTEX_BIT | SHADER_STAGE_FRAGMENT_BIT) || stages == SHADER_STAGE_COMPUTE_BIT) {
+				// By now, we already know the resource is used, and as both PS/NON_PS; no need to check further.
+				break;
+			}
+		}
+
+		if (likely(wanted_state)) {
+			if ((wanted_state & D3D12_RESOURCE_STATE_ALL_SHADER_RESOURCE)) {
+				if (stages == SHADER_STAGE_VERTEX_BIT || stages == SHADER_STAGE_COMPUTE_BIT) {
+					D3D12_RESOURCE_STATES unneeded_states = D3D12_RESOURCE_STATE_PIXEL_SHADER_RESOURCE;
+					wanted_state &= ~unneeded_states;
+				} else if (stages == SHADER_STAGE_FRAGMENT_BIT) {
+					D3D12_RESOURCE_STATES unneeded_states = D3D12_RESOURCE_STATE_NON_PIXEL_SHADER_RESOURCE;
+					wanted_state &= ~unneeded_states;
+				}
+			}
+
+			if (likely(wanted_state)) {
+				if (sr.is_buffer) {
+					_resource_transition_batch(sr.resource, 0, 1, wanted_state);
+				} else {
+					Texture *texture = (Texture *)sr.resource;
+					for (uint32_t i = 0; i < texture->layers; i++) {
+						for (uint32_t j = 0; j < texture->mipmaps; j++) {
+							uint32_t subresource = D3D12CalcSubresource(texture->base_mipmap + j, texture->base_layer + i, 0, texture->owner_mipmaps, texture->owner_layers);
+							_resource_transition_batch(texture, subresource, texture->planes, wanted_state, texture->owner_resource);
+						}
+					}
+				}
+			}
+		}
+	}
+}
+
+void RenderingDeviceD3D12::draw_list_set_push_constant(DrawListID p_list, const void *p_data, uint32_t p_data_size) {
+	DrawList *dl = _get_draw_list_ptr(p_list);
+	ERR_FAIL_NULL(dl);
+
+#ifdef DEBUG_ENABLED
+	ERR_FAIL_COND_MSG(!dl->validation.active, "Submitted Draw Lists can no longer be modified.");
+#endif
+
+#ifdef DEBUG_ENABLED
+	ERR_FAIL_COND_MSG(p_data_size != dl->validation.pipeline_spirv_push_constant_size,
+			"This render pipeline requires (" + itos(dl->validation.pipeline_spirv_push_constant_size) + ") bytes of push constant data, supplied: (" + itos(p_data_size) + ")");
+#endif
+	if (dl->state.pipeline_dxil_push_constant_size) {
+		dl->command_list->SetGraphicsRoot32BitConstants(0, p_data_size / sizeof(uint32_t), p_data, 0);
+	}
+#ifdef DEBUG_ENABLED
+	dl->validation.pipeline_push_constant_supplied = true;
+#endif
+}
+
+void RenderingDeviceD3D12::draw_list_draw(DrawListID p_list, bool p_use_indices, uint32_t p_instances, uint32_t p_procedural_vertices) {
+	DrawList *dl = _get_draw_list_ptr(p_list);
+	ERR_FAIL_NULL(dl);
+#ifdef DEBUG_ENABLED
+	ERR_FAIL_COND_MSG(!dl->validation.active, "Submitted Draw Lists can no longer be modified.");
+#endif
+
+#ifdef DEBUG_ENABLED
+	ERR_FAIL_COND_MSG(!dl->validation.pipeline_active,
+			"No render pipeline was set before attempting to draw.");
+	if (dl->validation.pipeline_vertex_format != INVALID_ID) {
+		// Pipeline uses vertices, validate format.
+		ERR_FAIL_COND_MSG(dl->validation.vertex_format == INVALID_ID,
+				"No vertex array was bound, and render pipeline expects vertices.");
+		// Make sure format is right.
+		ERR_FAIL_COND_MSG(dl->validation.pipeline_vertex_format != dl->validation.vertex_format,
+				"The vertex format used to create the pipeline does not match the vertex format bound.");
+		// Make sure number of instances is valid.
+		ERR_FAIL_COND_MSG(p_instances > dl->validation.vertex_max_instances_allowed,
+				"Number of instances requested (" + itos(p_instances) + " is larger than the maximum number supported by the bound vertex array (" + itos(dl->validation.vertex_max_instances_allowed) + ").");
+	}
+
+	if (dl->validation.pipeline_spirv_push_constant_size) {
+		// Using push constants, check that they were supplied.
+		ERR_FAIL_COND_MSG(!dl->validation.pipeline_push_constant_supplied,
+				"The shader in this pipeline requires a push constant to be set before drawing, but it's not present.");
+	}
+#endif
+
+	// Bind descriptor sets.
+
+	Shader *shader = shader_owner.get_or_null(dl->state.pipeline_shader);
+	struct SetToBind {
+		uint32_t set;
+		UniformSet *uniform_set;
+		const Shader::Set *shader_set;
+	};
+	SetToBind *sets_to_bind = (SetToBind *)alloca(sizeof(SetToBind) * dl->state.set_count);
+	uint32_t num_sets_to_bind = 0;
+	for (uint32_t i = 0; i < dl->state.set_count; i++) {
+		if (dl->state.sets[i].pipeline_expected_format == 0) {
+			continue; // Nothing expected by this pipeline.
+		}
+#ifdef DEBUG_ENABLED
+		if (dl->state.sets[i].pipeline_expected_format != dl->state.sets[i].uniform_set_format) {
+			if (dl->state.sets[i].uniform_set_format == 0) {
+				ERR_FAIL_MSG("Uniforms were never supplied for set (" + itos(i) + ") at the time of drawing, which are required by the pipeline");
+			} else if (uniform_set_owner.owns(dl->state.sets[i].uniform_set)) {
+				UniformSet *us = uniform_set_owner.get_or_null(dl->state.sets[i].uniform_set);
+				ERR_FAIL_MSG("Uniforms supplied for set (" + itos(i) + "):\n" + _shader_uniform_debug(us->shader_id, us->shader_set) + "\nare not the same format as required by the pipeline shader. Pipeline shader requires the following bindings:\n" + _shader_uniform_debug(dl->state.pipeline_shader));
+			} else {
+				ERR_FAIL_MSG("Uniforms supplied for set (" + itos(i) + ", which was was just freed) are not the same format as required by the pipeline shader. Pipeline shader requires the following bindings:\n" + _shader_uniform_debug(dl->state.pipeline_shader));
+			}
+		}
+#endif
+		UniformSet *uniform_set = uniform_set_owner.get_or_null(dl->state.sets[i].uniform_set);
+		const Shader::Set &shader_set = shader->sets[i];
+		_apply_uniform_set_resource_states(uniform_set, shader_set);
+		if (!dl->state.sets[i].bound) {
+			sets_to_bind[num_sets_to_bind].set = i;
+			sets_to_bind[num_sets_to_bind].uniform_set = uniform_set;
+			sets_to_bind[num_sets_to_bind].shader_set = &shader_set;
+			num_sets_to_bind++;
+			dl->state.sets[i].bound = true;
+		}
+	}
+
+	_resource_transitions_flush(dl->command_list);
+
+	for (uint32_t i = 0; i < num_sets_to_bind; i++) {
+		_bind_uniform_set(sets_to_bind[i].uniform_set, *sets_to_bind[i].shader_set, pipeline_bindings[dl->state.pipeline_bindings_id][sets_to_bind[i].set], dl->command_list, false);
+	}
+
+	if (dl->state.bound_pso != dl->state.pso) {
+		dl->command_list->SetPipelineState(dl->state.pso);
+		dl->state.bound_pso = dl->state.pso;
+	}
+	if (p_use_indices) {
+#ifdef DEBUG_ENABLED
+		ERR_FAIL_COND_MSG(p_procedural_vertices > 0,
+				"Procedural vertices can't be used together with indices.");
+
+		ERR_FAIL_COND_MSG(!dl->validation.index_array_size,
+				"Draw command requested indices, but no index buffer was set.");
+
+		ERR_FAIL_COND_MSG(dl->validation.pipeline_uses_restart_indices != dl->validation.index_buffer_uses_restart_indices,
+				"The usage of restart indices in index buffer does not match the render primitive in the pipeline.");
+#endif
+		uint32_t to_draw = dl->validation.index_array_size;
+
+#ifdef DEBUG_ENABLED
+		ERR_FAIL_COND_MSG(to_draw < dl->validation.pipeline_primitive_minimum,
+				"Too few indices (" + itos(to_draw) + ") for the render primitive set in the render pipeline (" + itos(dl->validation.pipeline_primitive_minimum) + ").");
+
+		ERR_FAIL_COND_MSG((to_draw % dl->validation.pipeline_primitive_divisor) != 0,
+				"Index amount (" + itos(to_draw) + ") must be a multiple of the amount of indices required by the render primitive (" + itos(dl->validation.pipeline_primitive_divisor) + ").");
+#endif
+
+		dl->command_list->DrawIndexedInstanced(to_draw, p_instances, dl->validation.index_array_offset, 0, 0);
+	} else {
+		uint32_t to_draw;
+
+		if (p_procedural_vertices > 0) {
+#ifdef DEBUG_ENABLED
+			ERR_FAIL_COND_MSG(dl->validation.pipeline_vertex_format != INVALID_ID,
+					"Procedural vertices requested, but pipeline expects a vertex array.");
+#endif
+			to_draw = p_procedural_vertices;
+		} else {
+#ifdef DEBUG_ENABLED
+			ERR_FAIL_COND_MSG(dl->validation.pipeline_vertex_format == INVALID_ID,
+					"Draw command lacks indices, but pipeline format does not use vertices.");
+#endif
+			to_draw = dl->validation.vertex_array_size;
+		}
+
+#ifdef DEBUG_ENABLED
+		ERR_FAIL_COND_MSG(to_draw < dl->validation.pipeline_primitive_minimum,
+				"Too few vertices (" + itos(to_draw) + ") for the render primitive set in the render pipeline (" + itos(dl->validation.pipeline_primitive_minimum) + ").");
+
+		ERR_FAIL_COND_MSG((to_draw % dl->validation.pipeline_primitive_divisor) != 0,
+				"Vertex amount (" + itos(to_draw) + ") must be a multiple of the amount of vertices required by the render primitive (" + itos(dl->validation.pipeline_primitive_divisor) + ").");
+#endif
+
+		dl->command_list->DrawInstanced(to_draw, p_instances, 0, 0);
+	}
+}
+
+void RenderingDeviceD3D12::draw_list_enable_scissor(DrawListID p_list, const Rect2 &p_rect) {
+	DrawList *dl = _get_draw_list_ptr(p_list);
+
+	ERR_FAIL_NULL(dl);
+#ifdef DEBUG_ENABLED
+	ERR_FAIL_COND_MSG(!dl->validation.active, "Submitted Draw Lists can no longer be modified.");
+#endif
+	Rect2i rect = p_rect;
+	rect.position += dl->viewport.position;
+
+	rect = dl->viewport.intersection(rect);
+
+	if (rect.get_area() == 0) {
+		return;
+	}
+	CD3DX12_RECT scissor(
+			rect.position.x,
+			rect.position.y,
+			rect.position.x + rect.size.width,
+			rect.position.y + rect.size.height);
+
+	dl->command_list->RSSetScissorRects(1, &scissor);
+}
+
+void RenderingDeviceD3D12::draw_list_disable_scissor(DrawListID p_list) {
+	DrawList *dl = _get_draw_list_ptr(p_list);
+	ERR_FAIL_NULL(dl);
+#ifdef DEBUG_ENABLED
+	ERR_FAIL_COND_MSG(!dl->validation.active, "Submitted Draw Lists can no longer be modified.");
+#endif
+
+	CD3DX12_RECT scissor(
+			dl->viewport.position.x,
+			dl->viewport.position.y,
+			dl->viewport.position.x + dl->viewport.size.width,
+			dl->viewport.position.y + dl->viewport.size.height);
+	dl->command_list->RSSetScissorRects(1, &scissor);
+}
+
+uint32_t RenderingDeviceD3D12::draw_list_get_current_pass() {
+	return draw_list_current_subpass;
+}
+
+void RenderingDeviceD3D12::_draw_list_subpass_begin() { // [[MANUAL_SUBPASSES]]
+	const FramebufferFormat &fb_format = framebuffer_formats[draw_list_framebuffer->format_id];
+	const FramebufferPass &pass = fb_format.passes[draw_list_current_subpass];
+
+	ID3D12GraphicsCommandList *command_list = frames[frame].draw_command_list.Get();
+
+	bool is_screen = draw_list_framebuffer->window_id != DisplayServer::INVALID_WINDOW_ID;
+
+	if (is_screen) {
+		DEV_ASSERT(!draw_list_framebuffer->dsv_heap.get_descriptor_count());
+		command_list->OMSetRenderTargets(1, &draw_list_framebuffer->screen_rtv_handle, true, nullptr);
+	} else {
+		D3D12_CPU_DESCRIPTOR_HANDLE *rtv_handles = (D3D12_CPU_DESCRIPTOR_HANDLE *)alloca(sizeof(D3D12_CPU_DESCRIPTOR_HANDLE) * pass.color_attachments.size());
+		DescriptorsHeap::Walker rtv_heap_walker = draw_list_framebuffer->rtv_heap.make_walker();
+		for (int i = 0; i < pass.color_attachments.size(); i++) {
+			uint32_t attachment = pass.color_attachments[i];
+			if (attachment == FramebufferPass::ATTACHMENT_UNUSED) {
+				if (!frames[frame].null_rtv_handle.ptr) {
+					// No null descriptor-handle created for this frame yet.
+
+					if (frames[frame].desc_heap_walkers.rtv.is_at_eof()) {
+						if (!frames[frame].desc_heaps_exhausted_reported.rtv) {
+							frames[frame].desc_heaps_exhausted_reported.rtv = true;
+							ERR_FAIL_MSG("Cannot begin subpass because there's no enough room in current frame's RENDER TARGET descriptors heap.\n"
+										 "Please increase the value of the rendering/rendering_device/d3d12/max_misc_descriptors_per_frame project setting.");
+						} else {
+							return;
+						}
+					}
+
+					D3D12_RENDER_TARGET_VIEW_DESC rtv_desc_null = {};
+					rtv_desc_null.Format = DXGI_FORMAT_R8_UINT;
+					rtv_desc_null.ViewDimension = D3D12_RTV_DIMENSION_TEXTURE2D;
+					frames[frame].null_rtv_handle = frames[frame].desc_heap_walkers.rtv.get_curr_cpu_handle();
+					device->CreateRenderTargetView(nullptr, &rtv_desc_null, frames[frame].null_rtv_handle);
+					frames[frame].desc_heap_walkers.rtv.advance();
+				}
+				rtv_handles[i] = frames[frame].null_rtv_handle;
+			} else {
+				uint32_t rt_index = draw_list_framebuffer->attachments_handle_inds[attachment];
+				rtv_heap_walker.rewind();
+				rtv_heap_walker.advance(rt_index);
+				rtv_handles[i] = rtv_heap_walker.get_curr_cpu_handle();
+			}
+		}
+
+		D3D12_CPU_DESCRIPTOR_HANDLE dsv_handle = {};
+		{
+			DescriptorsHeap::Walker dsv_heap_walker = draw_list_framebuffer->dsv_heap.make_walker();
+			if (pass.depth_attachment != FramebufferPass::ATTACHMENT_UNUSED) {
+				uint32_t ds_index = draw_list_framebuffer->attachments_handle_inds[pass.depth_attachment];
+				dsv_heap_walker.rewind();
+				dsv_heap_walker.advance(ds_index);
+				dsv_handle = dsv_heap_walker.get_curr_cpu_handle();
+			}
+		}
+
+		command_list->OMSetRenderTargets(pass.color_attachments.size(), rtv_handles, false, dsv_handle.ptr ? &dsv_handle : nullptr);
+
+		// [[VRS_EVERY_SUBPASS_OR_NONE]]
+		if (context->get_vrs_capabilities().ss_image_supported && draw_list_current_subpass == 0) {
+			if (execution_index != vrs_state_execution_index) {
+				vrs_state = {};
+			}
+
+			Texture *vrs_texture = nullptr;
+			RID vrs_texture_id;
+			if (pass.vrs_attachment != FramebufferPass::ATTACHMENT_UNUSED) {
+				vrs_texture_id = draw_list_framebuffer->texture_ids[pass.vrs_attachment];
+				vrs_texture = texture_owner.get_or_null(vrs_texture_id);
+				if (!vrs_texture) {
+					vrs_texture_id = RID();
+				}
+			}
+
+			if (vrs_texture_id != vrs_state.texture_bound) {
+				ID3D12GraphicsCommandList5 *command_list_5 = nullptr;
+				command_list->QueryInterface<ID3D12GraphicsCommandList5>(&command_list_5);
+				DEV_ASSERT(command_list_5);
+
+				if (vrs_texture_id.is_valid()) {
+					if (!vrs_state.configured) {
+						static const D3D12_SHADING_RATE_COMBINER combiners[D3D12_RS_SET_SHADING_RATE_COMBINER_COUNT] = {
+							D3D12_SHADING_RATE_COMBINER_PASSTHROUGH,
+							D3D12_SHADING_RATE_COMBINER_OVERRIDE,
+						};
+						command_list_5->RSSetShadingRate(D3D12_SHADING_RATE_1X1, combiners);
+						vrs_state.configured = true;
+
+						command_list_5->RSSetShadingRateImage(vrs_texture->resource);
+						vrs_state.texture_bound = vrs_texture_id;
+					}
+				} else {
+					command_list_5->RSSetShadingRateImage(nullptr);
+					vrs_state.texture_bound = RID();
+				}
+
+				command_list_5->Release();
+			}
+
+			vrs_state_execution_index = execution_index;
+		}
+	}
+}
+
+void RenderingDeviceD3D12::_draw_list_subpass_end() { // [[MANUAL_SUBPASSES]]
+	const FramebufferFormat &fb_format = framebuffer_formats[draw_list_framebuffer->format_id];
+	const FramebufferPass &pass = fb_format.passes[draw_list_current_subpass];
+
+	ID3D12GraphicsCommandList *command_list = frames[frame].draw_command_list.Get();
+
+	struct Resolve {
+		ID3D12Resource *src_res;
+		uint32_t src_subres;
+		ID3D12Resource *dst_res;
+		uint32_t dst_subres;
+		DXGI_FORMAT format;
+	};
+	Resolve *resolves = (Resolve *)alloca(sizeof(Resolve) * pass.resolve_attachments.size());
+	uint32_t num_resolves = 0;
+
+	for (int i = 0; i < pass.resolve_attachments.size(); i++) {
+		int32_t color_index = pass.color_attachments[i];
+		int32_t resolve_index = pass.resolve_attachments[i];
+		DEV_ASSERT((color_index == FramebufferPass::ATTACHMENT_UNUSED) == (resolve_index == FramebufferPass::ATTACHMENT_UNUSED));
+		if (color_index == FramebufferPass::ATTACHMENT_UNUSED || draw_list_framebuffer->texture_ids[color_index].is_null()) {
+			continue;
+		}
+
+		Texture *src_tex = texture_owner.get_or_null(draw_list_framebuffer->texture_ids[color_index]);
+		uint32_t src_subresource = D3D12CalcSubresource(src_tex->base_mipmap, src_tex->base_layer, 0, src_tex->owner_mipmaps, src_tex->owner_layers);
+		_resource_transition_batch(src_tex, src_subresource, src_tex->planes, D3D12_RESOURCE_STATE_RESOLVE_SOURCE);
+
+		Texture *dst_tex = texture_owner.get_or_null(draw_list_framebuffer->texture_ids[resolve_index]);
+		uint32_t dst_subresource = D3D12CalcSubresource(dst_tex->base_mipmap, dst_tex->base_layer, 0, dst_tex->owner_mipmaps, dst_tex->owner_layers);
+		_resource_transition_batch(dst_tex, dst_subresource, dst_tex->planes, D3D12_RESOURCE_STATE_RESOLVE_DEST);
+
+		resolves[num_resolves].src_res = src_tex->resource;
+		resolves[num_resolves].src_subres = src_subresource;
+		resolves[num_resolves].dst_res = dst_tex->resource;
+		resolves[num_resolves].dst_subres = dst_subresource;
+		resolves[num_resolves].format = d3d12_formats[src_tex->format].general_format;
+		num_resolves++;
+	}
+
+	_resource_transitions_flush(command_list);
+
+	for (uint32_t i = 0; i < num_resolves; i++) {
+		command_list->ResolveSubresource(resolves[i].dst_res, resolves[i].dst_subres, resolves[i].src_res, resolves[i].src_subres, resolves[i].format);
+	}
+}
+
+RenderingDevice::DrawListID RenderingDeviceD3D12::draw_list_switch_to_next_pass() {
+	_THREAD_SAFE_METHOD_
+	ERR_FAIL_COND_V(draw_list == nullptr, INVALID_ID);
+	ERR_FAIL_COND_V(draw_list_current_subpass >= draw_list_subpass_count - 1, INVALID_FORMAT_ID);
+
+	_draw_list_subpass_end();
+	draw_list_current_subpass++;
+	_draw_list_subpass_begin();
+
+	Rect2i viewport;
+	_draw_list_free(&viewport);
+
+	_draw_list_allocate(viewport, 0, draw_list_current_subpass);
+
+	return int64_t(ID_TYPE_DRAW_LIST) << ID_BASE_SHIFT;
+}
+
+Error RenderingDeviceD3D12::draw_list_switch_to_next_pass_split(uint32_t p_splits, DrawListID *r_split_ids) {
+	_THREAD_SAFE_METHOD_
+	ERR_FAIL_COND_V(draw_list == nullptr, ERR_INVALID_PARAMETER);
+	ERR_FAIL_COND_V(draw_list_current_subpass >= draw_list_subpass_count - 1, ERR_INVALID_PARAMETER);
+
+	_draw_list_subpass_end();
+	draw_list_current_subpass++;
+	_draw_list_subpass_begin();
+
+	Rect2i viewport;
+	_draw_list_free(&viewport);
+
+	_draw_list_allocate(viewport, p_splits, draw_list_current_subpass);
+
+	for (uint32_t i = 0; i < p_splits; i++) {
+		r_split_ids[i] = (int64_t(ID_TYPE_SPLIT_DRAW_LIST) << ID_BASE_SHIFT) + i;
+	}
+
+	return OK;
+}
+
+Error RenderingDeviceD3D12::_draw_list_allocate(const Rect2i &p_viewport, uint32_t p_splits, uint32_t p_subpass) {
+	if (p_splits == 0) {
+		draw_list = memnew(DrawList);
+		draw_list->command_list = frames[frame].draw_command_list.Get();
+		draw_list->viewport = p_viewport;
+		draw_list_count = 0;
+		draw_list_split = false;
+	} else {
+		if (p_splits > (uint32_t)split_draw_list_allocators.size()) {
+			uint32_t from = split_draw_list_allocators.size();
+			split_draw_list_allocators.resize(p_splits);
+			for (uint32_t i = from; i < p_splits; i++) {
+				HRESULT res = device->CreateCommandAllocator(D3D12_COMMAND_LIST_TYPE_BUNDLE, IID_PPV_ARGS(&split_draw_list_allocators.write[i].command_allocator));
+				ERR_FAIL_COND_V_MSG(res, ERR_CANT_CREATE, "CreateCommandAllocator failed with error " + vformat("0x%08ux", res) + ".");
+
+				for (int j = 0; j < frame_count; j++) {
+					ID3D12GraphicsCommandList *command_list = nullptr;
+
+					res = device->CreateCommandList(0, D3D12_COMMAND_LIST_TYPE_BUNDLE, split_draw_list_allocators[i].command_allocator, nullptr, IID_PPV_ARGS(&command_list));
+					ERR_FAIL_COND_V_MSG(res, ERR_CANT_CREATE, "CreateCommandList failed with error " + vformat("0x%08ux", res) + ".");
+
+					split_draw_list_allocators.write[i].command_lists.push_back(command_list);
+				}
+			}
+		}
+		draw_list = memnew_arr(DrawList, p_splits);
+		draw_list_count = p_splits;
+		draw_list_split = true;
+
+		for (uint32_t i = 0; i < p_splits; i++) {
+			ID3D12GraphicsCommandList *command_list = split_draw_list_allocators[i].command_lists[frame];
+
+			HRESULT res = frames[frame].setup_command_allocator->Reset();
+			ERR_FAIL_COND_V_MSG(ERR_CANT_CREATE, ERR_CANT_CREATE, "Command allocator Reset failed with error " + vformat("0x%08ux", res) + ".");
+			res = command_list->Reset(split_draw_list_allocators[i].command_allocator, nullptr);
+			if (res) {
+				memdelete_arr(draw_list);
+				draw_list = nullptr;
+				ERR_FAIL_V_MSG(ERR_CANT_CREATE, "Command allocator Reset failed with error " + vformat("0x%08ux", res) + ".");
+			}
+
+			draw_list[i].command_list = command_list;
+			draw_list[i].viewport = p_viewport;
+		}
+	}
+
+	return OK;
+}
+
+void RenderingDeviceD3D12::_draw_list_free(Rect2i *r_last_viewport) {
+	if (draw_list_split) {
+		// Send all command buffers.
+		for (uint32_t i = 0; i < draw_list_count; i++) {
+			draw_list[i].command_list->Close();
+			frames[frame].draw_command_list->ExecuteBundle(draw_list[i].command_list);
+			if (r_last_viewport) {
+				if (i == 0 || draw_list[i].viewport_set) {
+					*r_last_viewport = draw_list[i].viewport;
+				}
+			}
+		}
+
+		memdelete_arr(draw_list);
+		draw_list = nullptr;
+
+	} else {
+		if (r_last_viewport) {
+			*r_last_viewport = draw_list->viewport;
+		}
+		// Just end the list.
+		memdelete(draw_list);
+		draw_list = nullptr;
+	}
+
+	draw_list_count = 0;
+}
+
+void RenderingDeviceD3D12::draw_list_end(BitField<BarrierMask> p_post_barrier) {
+	_THREAD_SAFE_METHOD_
+
+	ERR_FAIL_COND_MSG(!draw_list, "Immediate draw list is already inactive.");
+
+	_draw_list_subpass_end();
+
+	const FramebufferFormat &fb_format = framebuffer_formats[draw_list_framebuffer->format_id];
+	bool is_screen = draw_list_framebuffer->window_id != DisplayServer::INVALID_WINDOW_ID;
+
+	ID3D12GraphicsCommandList *command_list = frames[frame].draw_command_list.Get();
+
+	for (int i = 0; i < fb_format.attachments.size(); i++) {
+		Texture *texture = nullptr;
+		if (!is_screen) {
+			texture = texture_owner.get_or_null(draw_list_framebuffer->texture_ids[i]);
+		}
+		if ((fb_format.attachments[i].usage_flags & TEXTURE_USAGE_COLOR_ATTACHMENT_BIT)) {
+			switch (draw_list_final_color_action) {
+				case FINAL_ACTION_READ: {
+					// Nothing to do now.
+				} break;
+				case FINAL_ACTION_DISCARD: {
+					ID3D12Resource *resource = is_screen ? context->window_get_framebuffer_texture(draw_list_framebuffer->window_id) : texture->resource;
+					command_list->DiscardResource(resource, nullptr);
+				} break;
+				case FINAL_ACTION_CONTINUE: {
+					ERR_FAIL_COND(draw_list_unbind_color_textures); // Bug!
+				} break;
+			}
+		} else if ((fb_format.attachments[i].usage_flags & TEXTURE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT)) {
+			ERR_FAIL_COND(is_screen); // Bug!
+			switch (draw_list_final_depth_action) {
+				case FINAL_ACTION_READ: {
+					// Nothing to do now.
+				} break;
+				case FINAL_ACTION_DISCARD: {
+					ID3D12Resource *resource = is_screen ? context->window_get_framebuffer_texture(draw_list_framebuffer->window_id) : texture->resource;
+					command_list->DiscardResource(resource, nullptr);
+				} break;
+				case FINAL_ACTION_CONTINUE: {
+					ERR_FAIL_COND(draw_list_unbind_depth_textures); // Bug!
+				} break;
+			}
+		}
+	}
+
+	draw_list_subpass_count = 0;
+	draw_list_current_subpass = 0;
+	draw_list_framebuffer = nullptr;
+
+	_draw_list_free();
+
+	for (int i = 0; i < draw_list_bound_textures.size(); i++) {
+		Texture *texture = texture_owner.get_or_null(draw_list_bound_textures[i]);
+		ERR_CONTINUE(!texture); // Wtf.
+		if (draw_list_unbind_color_textures && (texture->usage_flags & TEXTURE_USAGE_COLOR_ATTACHMENT_BIT)) {
+			texture->bound = false;
+		}
+		if (draw_list_unbind_depth_textures && (texture->usage_flags & TEXTURE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT)) {
+			texture->bound = false;
+		}
+	}
+	draw_list_bound_textures.clear();
+}
+
+/***********************/
+/**** COMPUTE LISTS ****/
+/***********************/
+
+RenderingDevice::ComputeListID RenderingDeviceD3D12::compute_list_begin(bool p_allow_draw_overlap) {
+	_THREAD_SAFE_METHOD_
+
+	ERR_FAIL_COND_V_MSG(!p_allow_draw_overlap && draw_list != nullptr, INVALID_ID, "Only one draw list can be active at the same time.");
+	ERR_FAIL_COND_V_MSG(compute_list != nullptr, INVALID_ID, "Only one draw/compute list can be active at the same time.");
+
+	compute_list = memnew(ComputeList);
+	compute_list->command_list = frames[frame].draw_command_list.Get();
+	compute_list->state.allow_draw_overlap = p_allow_draw_overlap;
+
+	return ID_TYPE_COMPUTE_LIST;
+}
+
+void RenderingDeviceD3D12::compute_list_bind_compute_pipeline(ComputeListID p_list, RID p_compute_pipeline) {
+	// Must be called within a compute list, the class mutex is locked during that time
+
+	ERR_FAIL_COND(p_list != ID_TYPE_COMPUTE_LIST);
+	ERR_FAIL_NULL(compute_list);
+
+	ComputeList *cl = compute_list;
+
+	const ComputePipeline *pipeline = compute_pipeline_owner.get_or_null(p_compute_pipeline);
+	ERR_FAIL_NULL(pipeline);
+
+	if (p_compute_pipeline == cl->state.pipeline) {
+		return; // Redundant state, return.
+	}
+
+	cl->state.pipeline = p_compute_pipeline;
+	cl->state.pso = pipeline->pso.Get();
+
+	Shader *shader = shader_owner.get_or_null(pipeline->shader);
+
+	if (cl->state.pipeline_shader != pipeline->shader) {
+		if (cl->state.root_signature_crc != pipeline->root_signature_crc) {
+			cl->command_list->SetComputeRootSignature(shader->root_signature.Get());
+			cl->state.root_signature_crc = pipeline->root_signature_crc;
+			// Root signature changed, so current descriptor set bindings become invalid.
+			for (uint32_t i = 0; i < cl->state.set_count; i++) {
+				cl->state.sets[i].bound = false;
+			}
+		}
+
+		const uint32_t *pformats = pipeline->set_formats.ptr(); // Pipeline set formats.
+		cl->state.set_count = pipeline->set_formats.size(); // Update set count.
+		for (uint32_t i = 0; i < cl->state.set_count; i++) {
+			cl->state.sets[i].pipeline_expected_format = pformats[i];
+#ifdef DEV_ENABLED
+			cl->state.sets[i]._pipeline_expected_format = pformats[i] ? &uniform_set_format_cache_reverse[pformats[i] - 1]->key().uniform_info : nullptr;
+#endif
+		}
+
+		if (pipeline->spirv_push_constant_size) {
+#ifdef DEBUG_ENABLED
+			cl->validation.pipeline_push_constant_supplied = false;
+#endif
+		}
+
+		cl->state.pipeline_shader = pipeline->shader;
+		cl->state.pipeline_dxil_push_constant_size = pipeline->dxil_push_constant_size;
+		cl->state.pipeline_bindings_id = pipeline->bindings_id;
+		cl->state.local_group_size[0] = pipeline->local_group_size[0];
+		cl->state.local_group_size[1] = pipeline->local_group_size[1];
+		cl->state.local_group_size[2] = pipeline->local_group_size[2];
+#ifdef DEV_ENABLED
+		cl->state._shader = shader;
+#endif
+	}
+
+#ifdef DEBUG_ENABLED
+	// Update compute pass pipeline info.
+	cl->validation.pipeline_active = true;
+	cl->validation.pipeline_spirv_push_constant_size = pipeline->spirv_push_constant_size;
+#endif
+}
+
+void RenderingDeviceD3D12::compute_list_bind_uniform_set(ComputeListID p_list, RID p_uniform_set, uint32_t p_index) {
+	// Must be called within a compute list, the class mutex is locked during that time
+
+	ERR_FAIL_COND(p_list != ID_TYPE_COMPUTE_LIST);
+	ERR_FAIL_NULL(compute_list);
+
+	ComputeList *cl = compute_list;
+
+#ifdef DEBUG_ENABLED
+	ERR_FAIL_COND_MSG(!cl->validation.active, "Submitted Compute Lists can no longer be modified.");
+#endif
+
+	UniformSet *uniform_set = uniform_set_owner.get_or_null(p_uniform_set);
+	ERR_FAIL_NULL(uniform_set);
+
+	if (p_index > cl->state.set_count) {
+		cl->state.set_count = p_index;
+	}
+
+	cl->state.sets[p_index].bound = false; // Needs rebind.
+	cl->state.sets[p_index].uniform_set_format = uniform_set->format;
+	cl->state.sets[p_index].uniform_set = p_uniform_set;
+#ifdef DEV_ENABLED
+	cl->state.sets[p_index]._uniform_set = uniform_set_owner.get_or_null(p_uniform_set);
+#endif
+}
+
+void RenderingDeviceD3D12::compute_list_set_push_constant(ComputeListID p_list, const void *p_data, uint32_t p_data_size) {
+	ERR_FAIL_COND(p_list != ID_TYPE_COMPUTE_LIST);
+	ERR_FAIL_NULL(compute_list);
+
+	ComputeList *cl = compute_list;
+
+#ifdef DEBUG_ENABLED
+	ERR_FAIL_COND_MSG(!cl->validation.active, "Submitted Compute Lists can no longer be modified.");
+#endif
+
+#ifdef DEBUG_ENABLED
+	ERR_FAIL_COND_MSG(p_data_size != cl->validation.pipeline_spirv_push_constant_size,
+			"This render pipeline requires (" + itos(cl->validation.pipeline_spirv_push_constant_size) + ") bytes of push constant data, supplied: (" + itos(p_data_size) + ")");
+#endif
+	if (cl->state.pipeline_dxil_push_constant_size) {
+		cl->command_list->SetComputeRoot32BitConstants(0, p_data_size / sizeof(uint32_t), p_data, 0);
+	}
+#ifdef DEBUG_ENABLED
+	cl->validation.pipeline_push_constant_supplied = true;
+#endif
+}
+
+void RenderingDeviceD3D12::compute_list_dispatch(ComputeListID p_list, uint32_t p_x_groups, uint32_t p_y_groups, uint32_t p_z_groups) {
+	// Must be called within a compute list, the class mutex is locked during that time
+
+	ERR_FAIL_COND(p_list != ID_TYPE_COMPUTE_LIST);
+	ERR_FAIL_NULL(compute_list);
+
+	ComputeList *cl = compute_list;
+
+#ifdef DEBUG_ENABLED
+	ERR_FAIL_COND_MSG(p_x_groups == 0, "Dispatch amount of X compute groups (" + itos(p_x_groups) + ") is zero.");
+	ERR_FAIL_COND_MSG(p_z_groups == 0, "Dispatch amount of Z compute groups (" + itos(p_z_groups) + ") is zero.");
+	ERR_FAIL_COND_MSG(p_y_groups == 0, "Dispatch amount of Y compute groups (" + itos(p_y_groups) + ") is zero.");
+	ERR_FAIL_COND_MSG(p_x_groups > D3D12_CS_DISPATCH_MAX_THREAD_GROUPS_PER_DIMENSION,
+			"Dispatch amount of X compute groups (" + itos(p_x_groups) + ") is larger than device limit (" + itos(D3D12_CS_DISPATCH_MAX_THREAD_GROUPS_PER_DIMENSION) + ")");
+	ERR_FAIL_COND_MSG(p_y_groups > D3D12_CS_DISPATCH_MAX_THREAD_GROUPS_PER_DIMENSION,
+			"Dispatch amount of Y compute groups (" + itos(p_x_groups) + ") is larger than device limit (" + itos(D3D12_CS_DISPATCH_MAX_THREAD_GROUPS_PER_DIMENSION) + ")");
+	ERR_FAIL_COND_MSG(p_z_groups > D3D12_CS_DISPATCH_MAX_THREAD_GROUPS_PER_DIMENSION,
+			"Dispatch amount of Z compute groups (" + itos(p_x_groups) + ") is larger than device limit (" + itos(D3D12_CS_DISPATCH_MAX_THREAD_GROUPS_PER_DIMENSION) + ")");
+
+	ERR_FAIL_COND_MSG(!cl->validation.active, "Submitted Compute Lists can no longer be modified.");
+#endif
+
+#ifdef DEBUG_ENABLED
+
+	ERR_FAIL_COND_MSG(!cl->validation.pipeline_active, "No compute pipeline was set before attempting to draw.");
+
+	if (cl->validation.pipeline_spirv_push_constant_size) {
+		// Using push constants, check that they were supplied.
+		ERR_FAIL_COND_MSG(!cl->validation.pipeline_push_constant_supplied,
+				"The shader in this pipeline requires a push constant to be set before drawing, but it's not present.");
+	}
+
+#endif
+
+	// Bind descriptor sets.
+	Shader *shader = shader_owner.get_or_null(cl->state.pipeline_shader);
+	struct SetToBind {
+		uint32_t set;
+		UniformSet *uniform_set;
+		const Shader::Set *shader_set;
+	};
+	SetToBind *sets_to_bind = (SetToBind *)alloca(sizeof(SetToBind) * cl->state.set_count);
+	uint32_t num_sets_to_bind = 0;
+	for (uint32_t i = 0; i < cl->state.set_count; i++) {
+		if (cl->state.sets[i].pipeline_expected_format == 0) {
+			continue; // Nothing expected by this pipeline.
+		}
+#ifdef DEBUG_ENABLED
+		if (cl->state.sets[i].pipeline_expected_format != cl->state.sets[i].uniform_set_format) {
+			if (cl->state.sets[i].uniform_set_format == 0) {
+				ERR_FAIL_MSG("Uniforms were never supplied for set (" + itos(i) + ") at the time of drawing, which are required by the pipeline");
+			} else if (uniform_set_owner.owns(cl->state.sets[i].uniform_set)) {
+				UniformSet *us = uniform_set_owner.get_or_null(cl->state.sets[i].uniform_set);
+				ERR_FAIL_MSG("Uniforms supplied for set (" + itos(i) + "):\n" + _shader_uniform_debug(us->shader_id, us->shader_set) + "\nare not the same format as required by the pipeline shader. Pipeline shader requires the following bindings:\n" + _shader_uniform_debug(cl->state.pipeline_shader));
+			} else {
+				ERR_FAIL_MSG("Uniforms supplied for set (" + itos(i) + ", which was was just freed) are not the same format as required by the pipeline shader. Pipeline shader requires the following bindings:\n" + _shader_uniform_debug(cl->state.pipeline_shader));
+			}
+		}
+#endif
+		UniformSet *uniform_set = uniform_set_owner.get_or_null(cl->state.sets[i].uniform_set);
+		const Shader::Set &shader_set = shader->sets[i];
+		_apply_uniform_set_resource_states(uniform_set, shader_set);
+		if (!cl->state.sets[i].bound) {
+			sets_to_bind[num_sets_to_bind].set = i;
+			sets_to_bind[num_sets_to_bind].uniform_set = uniform_set;
+			sets_to_bind[num_sets_to_bind].shader_set = &shader_set;
+			num_sets_to_bind++;
+			cl->state.sets[i].bound = true;
+		}
+	}
+
+	_resource_transitions_flush(cl->command_list);
+
+	for (uint32_t i = 0; i < num_sets_to_bind; i++) {
+		_bind_uniform_set(sets_to_bind[i].uniform_set, *sets_to_bind[i].shader_set, pipeline_bindings[cl->state.pipeline_bindings_id][sets_to_bind[i].set], cl->command_list, true);
+	}
+
+	if (cl->state.bound_pso != cl->state.pso) {
+		cl->command_list->SetPipelineState(cl->state.pso);
+		cl->state.bound_pso = cl->state.pso;
+	}
+	cl->command_list->Dispatch(p_x_groups, p_y_groups, p_z_groups);
+}
+
+void RenderingDeviceD3D12::compute_list_dispatch_threads(ComputeListID p_list, uint32_t p_x_threads, uint32_t p_y_threads, uint32_t p_z_threads) {
+	ERR_FAIL_COND(p_list != ID_TYPE_COMPUTE_LIST);
+	ERR_FAIL_NULL(compute_list);
+
+#ifdef DEBUG_ENABLED
+	ERR_FAIL_COND_MSG(p_x_threads == 0, "Dispatch amount of X compute threads (" + itos(p_x_threads) + ") is zero.");
+	ERR_FAIL_COND_MSG(p_y_threads == 0, "Dispatch amount of Y compute threads (" + itos(p_y_threads) + ") is zero.");
+	ERR_FAIL_COND_MSG(p_z_threads == 0, "Dispatch amount of Z compute threads (" + itos(p_z_threads) + ") is zero.");
+#endif
+
+	ComputeList *cl = compute_list;
+
+#ifdef DEBUG_ENABLED
+
+	ERR_FAIL_COND_MSG(!cl->validation.pipeline_active, "No compute pipeline was set before attempting to draw.");
+
+	if (cl->validation.pipeline_spirv_push_constant_size) {
+		// Using push constants, check that they were supplied.
+		ERR_FAIL_COND_MSG(!cl->validation.pipeline_push_constant_supplied,
+				"The shader in this pipeline requires a push constant to be set before drawing, but it's not present.");
+	}
+
+#endif
+
+	compute_list_dispatch(p_list, (p_x_threads - 1) / cl->state.local_group_size[0] + 1, (p_y_threads - 1) / cl->state.local_group_size[1] + 1, (p_z_threads - 1) / cl->state.local_group_size[2] + 1);
+}
+
+void RenderingDeviceD3D12::compute_list_dispatch_indirect(ComputeListID p_list, RID p_buffer, uint32_t p_offset) {
+	ERR_FAIL_COND(p_list != ID_TYPE_COMPUTE_LIST);
+	ERR_FAIL_NULL(compute_list);
+
+	ComputeList *cl = compute_list;
+	Buffer *buffer = storage_buffer_owner.get_or_null(p_buffer);
+	ERR_FAIL_NULL(buffer);
+
+	ERR_FAIL_COND_MSG(!(buffer->usage & D3D12_RESOURCE_STATE_INDIRECT_ARGUMENT), "Buffer provided was not created to do indirect dispatch.");
+
+	ERR_FAIL_COND_MSG(p_offset + 12 > buffer->size, "Offset provided (+12) is past the end of buffer.");
+
+#ifdef DEBUG_ENABLED
+
+	ERR_FAIL_COND_MSG(!cl->validation.pipeline_active, "No compute pipeline was set before attempting to draw.");
+
+	if (cl->validation.pipeline_spirv_push_constant_size) {
+		// Using push constants, check that they were supplied.
+		ERR_FAIL_COND_MSG(!cl->validation.pipeline_push_constant_supplied,
+				"The shader in this pipeline requires a push constant to be set before drawing, but it's not present.");
+	}
+
+#endif
+
+	// Bind descriptor sets.
+
+	Shader *shader = shader_owner.get_or_null(cl->state.pipeline_shader);
+	struct SetToBind {
+		uint32_t set;
+		UniformSet *uniform_set;
+		const Shader::Set *shader_set;
+	};
+	SetToBind *sets_to_bind = (SetToBind *)alloca(sizeof(SetToBind) * cl->state.set_count);
+	uint32_t num_sets_to_bind = 0;
+	for (uint32_t i = 0; i < cl->state.set_count; i++) {
+		if (cl->state.sets[i].pipeline_expected_format == 0) {
+			continue; // Nothing expected by this pipeline.
+		}
+#ifdef DEBUG_ENABLED
+		if (cl->state.sets[i].pipeline_expected_format != cl->state.sets[i].uniform_set_format) {
+			if (cl->state.sets[i].uniform_set_format == 0) {
+				ERR_FAIL_MSG("Uniforms were never supplied for set (" + itos(i) + ") at the time of drawing, which are required by the pipeline");
+			} else if (uniform_set_owner.owns(cl->state.sets[i].uniform_set)) {
+				UniformSet *us = uniform_set_owner.get_or_null(cl->state.sets[i].uniform_set);
+				ERR_FAIL_MSG("Uniforms supplied for set (" + itos(i) + "):\n" + _shader_uniform_debug(us->shader_id, us->shader_set) + "\nare not the same format as required by the pipeline shader. Pipeline shader requires the following bindings:\n" + _shader_uniform_debug(cl->state.pipeline_shader));
+			} else {
+				ERR_FAIL_MSG("Uniforms supplied for set (" + itos(i) + ", which was was just freed) are not the same format as required by the pipeline shader. Pipeline shader requires the following bindings:\n" + _shader_uniform_debug(cl->state.pipeline_shader));
+			}
+		}
+#endif
+		UniformSet *uniform_set = uniform_set_owner.get_or_null(cl->state.sets[i].uniform_set);
+		const Shader::Set &shader_set = shader->sets[i];
+		_apply_uniform_set_resource_states(uniform_set, shader_set);
+		if (!cl->state.sets[i].bound) {
+			sets_to_bind[num_sets_to_bind].set = i;
+			sets_to_bind[num_sets_to_bind].uniform_set = uniform_set;
+			sets_to_bind[num_sets_to_bind].shader_set = &shader_set;
+			num_sets_to_bind++;
+			cl->state.sets[i].bound = true;
+		}
+	}
+
+	_resource_transition_batch(buffer, 0, 1, D3D12_RESOURCE_STATE_INDIRECT_ARGUMENT);
+
+	_resource_transitions_flush(cl->command_list);
+
+	for (uint32_t i = 0; i < num_sets_to_bind; i++) {
+		_bind_uniform_set(sets_to_bind[i].uniform_set, *sets_to_bind[i].shader_set, pipeline_bindings[cl->state.pipeline_bindings_id][sets_to_bind[i].set], cl->command_list, true);
+	}
+
+	if (cl->state.bound_pso != cl->state.pso) {
+		cl->command_list->SetPipelineState(cl->state.pso);
+		cl->state.bound_pso = cl->state.pso;
+	}
+	cl->command_list->ExecuteIndirect(indirect_dispatch_cmd_sig.Get(), 1, buffer->resource, p_offset, nullptr, 0);
+}
+
+void RenderingDeviceD3D12::compute_list_add_barrier(ComputeListID p_list) {
+	// Must be called within a compute list, the class mutex is locked during that time
+
+#ifdef FORCE_FULL_BARRIER
+	full_barrier();
+#else
+	// Due to D3D12 resource-wise barriers, this is no op.
+#endif
+}
+
+void RenderingDeviceD3D12::compute_list_end(BitField<BarrierMask> p_post_barrier) {
+	ERR_FAIL_NULL(compute_list);
+
+#ifdef FORCE_FULL_BARRIER
+	full_barrier();
+#endif
+
+	memdelete(compute_list);
+	compute_list = nullptr;
+}
+
+void RenderingDeviceD3D12::barrier(BitField<BarrierMask> p_from, BitField<BarrierMask> p_to) {
+	// Due to D3D12 resource-wise barriers, this is no op.
+}
+
+void RenderingDeviceD3D12::full_barrier() {
+#ifndef DEBUG_ENABLED
+	ERR_PRINT("Full barrier is debug-only, should not be used in production");
+#endif
+
+	// In the resource barriers world, we can force a full barrier by discarding some resource, as per
+	// https://microsoft.github.io/DirectX-Specs/d3d/D3D12EnhancedBarriers.html#synchronous-copy-discard-and-resolve.
+	frames[frame].draw_command_list->DiscardResource(texture_owner.get_or_null(aux_resource)->resource, nullptr);
+}
+
+void RenderingDeviceD3D12::_free_internal(RID p_id) {
+#ifdef DEV_ENABLED
+	String resource_name;
+	if (resource_names.has(p_id)) {
+		resource_name = resource_names[p_id];
+		resource_names.erase(p_id);
+	}
+#endif
+
+	// Push everything so it's disposed of next time this frame index is processed (means, it's safe to do it).
+	if (texture_owner.owns(p_id)) {
+		Texture *texture = texture_owner.get_or_null(p_id);
+		frames[frame].textures_to_dispose_of.push_back(*texture);
+		texture_owner.free(p_id);
+	} else if (framebuffer_owner.owns(p_id)) {
+		Framebuffer *framebuffer = framebuffer_owner.get_or_null(p_id);
+		frames[frame].framebuffers_to_dispose_of.push_back(*framebuffer);
+
+		if (framebuffer->invalidated_callback != nullptr) {
+			framebuffer->invalidated_callback(framebuffer->invalidated_callback_userdata);
+		}
+		framebuffer_owner.free(p_id);
+	} else if (sampler_owner.owns(p_id)) {
+		sampler_owner.free(p_id);
+	} else if (vertex_buffer_owner.owns(p_id)) {
+		Buffer *vertex_buffer = vertex_buffer_owner.get_or_null(p_id);
+		frames[frame].buffers_to_dispose_of.push_back(*vertex_buffer);
+		vertex_buffer_owner.free(p_id);
+	} else if (vertex_array_owner.owns(p_id)) {
+		vertex_array_owner.free(p_id);
+	} else if (index_buffer_owner.owns(p_id)) {
+		IndexBuffer *index_buffer = index_buffer_owner.get_or_null(p_id);
+		frames[frame].buffers_to_dispose_of.push_back(*index_buffer);
+		index_buffer_owner.free(p_id);
+	} else if (index_array_owner.owns(p_id)) {
+		index_array_owner.free(p_id);
+	} else if (shader_owner.owns(p_id)) {
+		Shader *shader = shader_owner.get_or_null(p_id);
+		frames[frame].shaders_to_dispose_of.push_back(*shader);
+		shader_owner.free(p_id);
+	} else if (uniform_buffer_owner.owns(p_id)) {
+		Buffer *uniform_buffer = uniform_buffer_owner.get_or_null(p_id);
+		frames[frame].buffers_to_dispose_of.push_back(*uniform_buffer);
+		uniform_buffer_owner.free(p_id);
+	} else if (texture_buffer_owner.owns(p_id)) {
+		TextureBuffer *texture_buffer = texture_buffer_owner.get_or_null(p_id);
+		frames[frame].buffers_to_dispose_of.push_back(texture_buffer->buffer);
+		texture_buffer_owner.free(p_id);
+	} else if (storage_buffer_owner.owns(p_id)) {
+		Buffer *storage_buffer = storage_buffer_owner.get_or_null(p_id);
+		frames[frame].buffers_to_dispose_of.push_back(*storage_buffer);
+		storage_buffer_owner.free(p_id);
+	} else if (uniform_set_owner.owns(p_id)) {
+		UniformSet *uniform_set = uniform_set_owner.get_or_null(p_id);
+		uniform_set_owner.free(p_id);
+
+		if (uniform_set->invalidated_callback != nullptr) {
+			uniform_set->invalidated_callback(uniform_set->invalidated_callback_userdata);
+		}
+	} else if (render_pipeline_owner.owns(p_id)) {
+		RenderPipeline *pipeline = render_pipeline_owner.get_or_null(p_id);
+		frames[frame].render_pipelines_to_dispose_of.push_back(*pipeline);
+		render_pipeline_owner.free(p_id);
+	} else if (compute_pipeline_owner.owns(p_id)) {
+		ComputePipeline *pipeline = compute_pipeline_owner.get_or_null(p_id);
+		frames[frame].compute_pipelines_to_dispose_of.push_back(*pipeline);
+		compute_pipeline_owner.free(p_id);
+	} else {
+#ifdef DEV_ENABLED
+		ERR_PRINT("Attempted to free invalid ID: " + itos(p_id.get_id()) + " " + resource_name);
+#else
+		ERR_PRINT("Attempted to free invalid ID: " + itos(p_id.get_id()));
+#endif
+	}
+}
+
+void RenderingDeviceD3D12::free(RID p_id) {
+	_THREAD_SAFE_METHOD_
+
+	_free_dependencies(p_id); // Recursively erase dependencies first, to avoid potential API problems.
+	_free_internal(p_id);
+}
+
+void RenderingDeviceD3D12::set_resource_name(RID p_id, const String p_name) {
+	if (texture_owner.owns(p_id)) {
+		Texture *texture = texture_owner.get_or_null(p_id);
+		// Don't set the source texture's name when calling on a texture view.
+		if (texture->owner.is_null()) {
+			context->set_object_name(texture->resource, p_name);
+		}
+	} else if (framebuffer_owner.owns(p_id)) {
+		// No D3D12 object to name.
+	} else if (sampler_owner.owns(p_id)) {
+		// No D3D12 object to name.
+	} else if (shader_owner.owns(p_id)) {
+		Shader *shader = shader_owner.get_or_null(p_id);
+		context->set_object_name(shader->root_signature.Get(), p_name + " Root Signature");
+	} else if (uniform_set_owner.owns(p_id)) {
+		// No D3D12 object to name.
+	} else if (render_pipeline_owner.owns(p_id)) {
+		RenderPipeline *pipeline = render_pipeline_owner.get_or_null(p_id);
+		context->set_object_name(pipeline->pso.Get(), p_name);
+	} else if (compute_pipeline_owner.owns(p_id)) {
+		ComputePipeline *pipeline = compute_pipeline_owner.get_or_null(p_id);
+		context->set_object_name(pipeline->pso.Get(), p_name);
+	} else {
+		Buffer *buffer = _get_buffer_from_owner(p_id);
+		if (buffer) {
+			context->set_object_name(buffer->resource, p_name);
+		} else {
+			ERR_PRINT("Attempted to name invalid ID: " + itos(p_id.get_id()));
+			return;
+		}
+	}
+#ifdef DEV_ENABLED
+	resource_names[p_id] = p_name;
+#endif
+}
+
+void RenderingDeviceD3D12::draw_command_begin_label(String p_label_name, const Color p_color) {
+	_THREAD_SAFE_METHOD_
+	context->command_begin_label(frames[frame].draw_command_list.Get(), p_label_name, p_color);
+}
+
+void RenderingDeviceD3D12::draw_command_insert_label(String p_label_name, const Color p_color) {
+	_THREAD_SAFE_METHOD_
+	context->command_insert_label(frames[frame].draw_command_list.Get(), p_label_name, p_color);
+}
+
+void RenderingDeviceD3D12::draw_command_end_label() {
+	_THREAD_SAFE_METHOD_
+	context->command_end_label(frames[frame].draw_command_list.Get());
+}
+
+String RenderingDeviceD3D12::get_device_vendor_name() const {
+	return context->get_device_vendor_name();
+}
+
+String RenderingDeviceD3D12::get_device_name() const {
+	return context->get_device_name();
+}
+
+RenderingDevice::DeviceType RenderingDeviceD3D12::get_device_type() const {
+	return context->get_device_type();
+}
+
+String RenderingDeviceD3D12::get_device_api_version() const {
+	return context->get_device_api_version();
+}
+
+String RenderingDeviceD3D12::get_device_pipeline_cache_uuid() const {
+	return context->get_device_pipeline_cache_uuid();
+}
+
+void RenderingDeviceD3D12::_finalize_command_bufers() {
+	if (draw_list) {
+		ERR_PRINT("Found open draw list at the end of the frame, this should never happen (further drawing will likely not work).");
+	}
+
+	if (compute_list) {
+		ERR_PRINT("Found open compute list at the end of the frame, this should never happen (further compute will likely not work).");
+	}
+
+	{ // Complete the setup buffer (that needs to be processed before anything else).
+		frames[frame].setup_command_list->Close();
+		frames[frame].draw_command_list->Close();
+	}
+}
+
+void RenderingDeviceD3D12::_begin_frame() {
+	// Erase pending resources.
+	_free_pending_resources(frame);
+
+	HRESULT res = frames[frame].setup_command_allocator->Reset();
+	ERR_FAIL_COND_MSG(res, "Command allocator Reset failed with error " + vformat("0x%08ux", res) + ".");
+	res = frames[frame].setup_command_list->Reset(frames[frame].setup_command_allocator.Get(), nullptr);
+	ERR_FAIL_COND_MSG(res, "Command list Reset failed with error " + vformat("0x%08ux", res) + ".");
+	res = frames[frame].draw_command_allocator->Reset();
+	ERR_FAIL_COND_MSG(res, "Command allocator Reset failed with error " + vformat("0x%08ux", res) + ".");
+	res = frames[frame].draw_command_list->Reset(frames[frame].draw_command_allocator.Get(), nullptr);
+	ERR_FAIL_COND_MSG(res, "Command list Reset failed with error " + vformat("0x%08ux", res) + ".");
+
+	ID3D12DescriptorHeap *heaps[] = {
+		frames[frame].desc_heaps.resources.get_heap(),
+		frames[frame].desc_heaps.samplers.get_heap(),
+	};
+	frames[frame].draw_command_list->SetDescriptorHeaps(2, heaps);
+
+	frames[frame].desc_heap_walkers.resources.rewind();
+	frames[frame].desc_heap_walkers.samplers.rewind();
+	frames[frame].desc_heap_walkers.aux.rewind();
+	frames[frame].desc_heap_walkers.rtv.rewind();
+	frames[frame].desc_heaps_exhausted_reported = {};
+	frames[frame].null_rtv_handle = {};
+
+#ifdef DEBUG_COUNT_BARRIERS
+	print_verbose(vformat("Last frame: %d barriers (%d batches); %.1f ms", frame_barriers_count, frame_barriers_batches_count, frame_barriers_cpu_time * 0.001f));
+	frame_barriers_count = 0;
+	frame_barriers_batches_count = 0;
+	frame_barriers_cpu_time = 0;
+#endif
+
+	if (local_device.is_null()) {
+		context->append_command_list(frames[frame].draw_command_list.Get());
+		context->set_setup_list(frames[frame].setup_command_list.Get()); // Append now so it's added before everything else.
+	}
+
+	// Advance current frame.
+	frames_drawn++;
+	// Advance staging buffer if used.
+	if (staging_buffer_used) {
+		staging_buffer_current = (staging_buffer_current + 1) % staging_buffer_blocks.size();
+		staging_buffer_used = false;
+	}
+
+	context->get_allocator()->SetCurrentFrameIndex(Engine::get_singleton()->get_frames_drawn());
+	if (frames[frame].timestamp_count) {
+		frames[frame].setup_command_list->ResolveQueryData(frames[frame].timestamp_heap.Get(), D3D12_QUERY_TYPE_TIMESTAMP, 0, frames[frame].timestamp_count, frames[frame].timestamp_result_values_buffer.resource, 0);
+		uint64_t *gpu_timestamps = nullptr;
+		res = frames[frame].timestamp_result_values_buffer.resource->Map(0, nullptr, (void **)&gpu_timestamps);
+		if (SUCCEEDED(res)) {
+			memcpy(frames[frame].timestamp_result_values.ptr(), gpu_timestamps, sizeof(uint64_t) * frames[frame].timestamp_count);
+			frames[frame].timestamp_result_values_buffer.resource->Unmap(0, nullptr);
+		}
+		SWAP(frames[frame].timestamp_names, frames[frame].timestamp_result_names);
+		SWAP(frames[frame].timestamp_cpu_values, frames[frame].timestamp_cpu_result_values);
+	}
+
+	frames[frame].timestamp_result_count = frames[frame].timestamp_count;
+	frames[frame].timestamp_count = 0;
+	frames[frame].index = Engine::get_singleton()->get_frames_drawn();
+	frames[frame].execution_index = execution_index;
+#ifdef DEV_ENABLED
+	frames[frame].uniform_set_reused = 0;
+#endif
+}
+
+void RenderingDeviceD3D12::swap_buffers() {
+	ERR_FAIL_COND_MSG(local_device.is_valid(), "Local devices can't swap buffers.");
+	_THREAD_SAFE_METHOD_
+
+	context->postpare_buffers(frames[frame].draw_command_list.Get());
+	screen_prepared = false;
+
+	_finalize_command_bufers();
+
+	context->swap_buffers();
+	execution_index++;
+
+	frame = (frame + 1) % frame_count;
+
+	_begin_frame();
+}
+
+void RenderingDeviceD3D12::submit() {
+	_THREAD_SAFE_METHOD_
+
+	ERR_FAIL_COND_MSG(local_device.is_null(), "Only local devices can submit and sync.");
+	ERR_FAIL_COND_MSG(local_device_processing, "device already submitted, call sync to wait until done.");
+
+	_finalize_command_bufers();
+
+	ID3D12CommandList *command_lists[2] = { frames[frame].setup_command_list.Get(), frames[frame].draw_command_list.Get() };
+	context->local_device_push_command_lists(local_device, command_lists, 2);
+	execution_index++;
+
+	local_device_processing = true;
+}
+
+void RenderingDeviceD3D12::sync() {
+	_THREAD_SAFE_METHOD_
+
+	ERR_FAIL_COND_MSG(local_device.is_null(), "Only local devices can submit and sync.");
+	ERR_FAIL_COND_MSG(!local_device_processing, "sync can only be called after a submit");
+
+	context->local_device_sync(local_device);
+	_begin_frame();
+	local_device_processing = false;
+}
+
+#ifdef USE_SMALL_ALLOCS_POOL
+D3D12MA::Pool *RenderingDeviceD3D12::_find_or_create_small_allocs_pool(D3D12_HEAP_TYPE p_heap_type, D3D12_HEAP_FLAGS p_heap_flags) {
+	D3D12_HEAP_FLAGS effective_heap_flags = p_heap_flags;
+	if (context->get_allocator()->GetD3D12Options().ResourceHeapTier != D3D12_RESOURCE_HEAP_TIER_1) {
+		// Heap tier 2 allows mixing resource types liberally.
+		effective_heap_flags &= ~(D3D12_HEAP_FLAG_ALLOW_ONLY_BUFFERS | D3D12_HEAP_FLAG_ALLOW_ONLY_NON_RT_DS_TEXTURES | D3D12_HEAP_FLAG_ALLOW_ONLY_RT_DS_TEXTURES);
+	}
+
+	AllocPoolKey pool_key;
+	pool_key.heap_type = p_heap_type;
+	pool_key.heap_flags = effective_heap_flags;
+	if (small_allocs_pools.has(pool_key.key)) {
+		return small_allocs_pools[pool_key.key].Get();
+	}
+
+#ifdef DEV_ENABLED
+	print_verbose("Creating D3D12MA small objects pool for heap type " + itos(p_heap_type) + " and heap flags " + itos(p_heap_flags));
+#endif
+
+	D3D12MA::POOL_DESC poolDesc = {};
+	poolDesc.HeapProperties.Type = p_heap_type;
+	poolDesc.HeapFlags = effective_heap_flags;
+
+	ComPtr<D3D12MA::Pool> pool;
+	HRESULT res = context->get_allocator()->CreatePool(&poolDesc, pool.GetAddressOf());
+	small_allocs_pools[pool_key.key] = pool; // Don't try to create it again if failed the first time.
+	ERR_FAIL_COND_V_MSG(res, nullptr, "CreatePool failed with error " + vformat("0x%08ux", res) + ".");
+
+	return pool.Get();
+}
+#endif
+
+void RenderingDeviceD3D12::_free_pending_resources(int p_frame) {
+	// Free in dependency usage order, so nothing weird happens.
+	// Pipelines.
+	while (frames[p_frame].render_pipelines_to_dispose_of.front()) {
+		RenderPipeline *rp = &frames[p_frame].render_pipelines_to_dispose_of.front()->get();
+		pipeline_bindings.erase(rp->bindings_id);
+		frames[p_frame].render_pipelines_to_dispose_of.pop_front();
+	}
+	while (frames[p_frame].compute_pipelines_to_dispose_of.front()) {
+		ComputePipeline *cp = &frames[p_frame].compute_pipelines_to_dispose_of.front()->get();
+		pipeline_bindings.erase(cp->bindings_id);
+		frames[p_frame].compute_pipelines_to_dispose_of.pop_front();
+	}
+
+	// Shaders.
+	frames[p_frame].shaders_to_dispose_of.clear();
+
+	// Framebuffers.
+	frames[p_frame].framebuffers_to_dispose_of.clear();
+
+	// Textures.
+	while (frames[p_frame].textures_to_dispose_of.front()) {
+		Texture *texture = &frames[p_frame].textures_to_dispose_of.front()->get();
+
+		if (texture->bound) {
+			WARN_PRINT("Deleted a texture while it was bound.");
+		}
+		if (texture->owner.is_null()) {
+			// Actually owns the image and the allocation too.
+			image_memory -= texture->allocation->GetSize();
+			for (uint32_t i = 0; i < texture->aliases.size(); i++) {
+				if (texture->aliases[i]) {
+					texture->aliases[i]->Release();
+				}
+			}
+			texture->resource->Release();
+			texture->resource = nullptr;
+			texture->allocation->Release();
+			texture->allocation = nullptr;
+		}
+		frames[p_frame].textures_to_dispose_of.pop_front();
+	}
+
+	// Buffers.
+	while (frames[p_frame].buffers_to_dispose_of.front()) {
+		_buffer_free(&frames[p_frame].buffers_to_dispose_of.front()->get());
+
+		frames[p_frame].buffers_to_dispose_of.pop_front();
+	}
+}
+
+void RenderingDeviceD3D12::prepare_screen_for_drawing() {
+	_THREAD_SAFE_METHOD_
+	context->prepare_buffers(frames[frame].draw_command_list.Get());
+	screen_prepared = true;
+}
+
+uint32_t RenderingDeviceD3D12::get_frame_delay() const {
+	return frame_count;
+}
+
+uint64_t RenderingDeviceD3D12::get_memory_usage(MemoryType p_type) const {
+	if (p_type == MEMORY_BUFFERS) {
+		return buffer_memory;
+	} else if (p_type == MEMORY_TEXTURES) {
+		return image_memory;
+	} else {
+		D3D12MA::TotalStatistics stats;
+		context->get_allocator()->CalculateStatistics(&stats);
+		return stats.Total.Stats.BlockBytes;
+	}
+}
+
+void RenderingDeviceD3D12::_flush(bool p_flush_current_frame) {
+	if (local_device.is_valid() && !p_flush_current_frame) {
+		return; // Flushing previous frames has no effect with local device.
+	}
+
+	if (p_flush_current_frame) {
+		frames[frame].setup_command_list->Close();
+		frames[frame].draw_command_list->Close();
+	}
+
+	if (local_device.is_valid()) {
+		ID3D12CommandList *command_lists[2] = { frames[frame].setup_command_list.Get(), frames[frame].draw_command_list.Get() };
+		context->local_device_push_command_lists(local_device, command_lists, 2);
+		execution_index++;
+		context->local_device_sync(local_device);
+
+		HRESULT res = frames[frame].setup_command_allocator->Reset();
+		ERR_FAIL_COND_MSG(res, "Command allocator Reset failed with error " + vformat("0x%08ux", res) + ".");
+		res = frames[frame].setup_command_list->Reset(frames[frame].setup_command_allocator.Get(), nullptr);
+		ERR_FAIL_COND_MSG(res, "Command allocator Reset failed with error " + vformat("0x%08ux", res) + ".");
+		res = frames[frame].draw_command_allocator->Reset();
+		ERR_FAIL_COND_MSG(res, "Command allocator Reset failed with error " + vformat("0x%08ux", res) + ".");
+		res = frames[frame].draw_command_list->Reset(frames[frame].draw_command_allocator.Get(), nullptr);
+		ERR_FAIL_COND_MSG(res, "Command allocator Reset failed with error " + vformat("0x%08ux", res) + ".");
+
+		ID3D12DescriptorHeap *heaps[] = {
+			frames[frame].desc_heaps.resources.get_heap(),
+			frames[frame].desc_heaps.samplers.get_heap(),
+		};
+		frames[frame].draw_command_list->SetDescriptorHeaps(2, heaps);
+		frames[frame].desc_heap_walkers.resources.rewind();
+		frames[frame].desc_heap_walkers.samplers.rewind();
+		frames[frame].desc_heap_walkers.aux.rewind();
+		frames[frame].desc_heap_walkers.rtv.rewind();
+		frames[frame].desc_heaps_exhausted_reported = {};
+		frames[frame].null_rtv_handle = {};
+		frames[frame].execution_index = execution_index;
+	} else {
+		context->flush(p_flush_current_frame, p_flush_current_frame);
+		// Re-create the setup command.
+		if (p_flush_current_frame) {
+			execution_index++;
+
+			HRESULT res = frames[frame].setup_command_allocator->Reset();
+			ERR_FAIL_COND_MSG(res, "Command allocator Reset failed with error " + vformat("0x%08ux", res) + ".");
+			res = frames[frame].draw_command_allocator->Reset();
+			ERR_FAIL_COND_MSG(res, "Command allocator Reset failed with error " + vformat("0x%08ux", res) + ".");
+			res = frames[frame].setup_command_list->Reset(frames[frame].setup_command_allocator.Get(), nullptr);
+			ERR_FAIL_COND_MSG(res, "Command list Reset failed with error " + vformat("0x%08ux", res) + ".");
+			res = frames[frame].draw_command_list->Reset(frames[frame].draw_command_allocator.Get(), nullptr);
+			ERR_FAIL_COND_MSG(res, "Command list Reset failed with error " + vformat("0x%08ux", res) + ".");
+
+			ID3D12DescriptorHeap *heaps[] = {
+				frames[frame].desc_heaps.resources.get_heap(),
+				frames[frame].desc_heaps.samplers.get_heap(),
+			};
+			frames[frame].draw_command_list->SetDescriptorHeaps(2, heaps);
+
+			frames[frame].desc_heap_walkers.resources.rewind();
+			frames[frame].desc_heap_walkers.samplers.rewind();
+			frames[frame].desc_heap_walkers.aux.rewind();
+			frames[frame].desc_heap_walkers.rtv.rewind();
+			frames[frame].desc_heaps_exhausted_reported = {};
+			frames[frame].null_rtv_handle = {};
+			frames[frame].execution_index = execution_index;
+
+			context->set_setup_list(frames[frame].setup_command_list.Get()); // Append now so it's added before everything else.
+			context->append_command_list(frames[frame].draw_command_list.Get());
+		}
+	}
+}
+
+void RenderingDeviceD3D12::initialize(D3D12Context *p_context, bool p_local_device) {
+	// Get our device capabilities.
+	{
+		device_capabilities.version_major = p_context->get_feat_level_major();
+		device_capabilities.version_minor = p_context->get_feat_level_minor();
+	}
+
+	context = p_context;
+	device = p_context->get_device();
+	if (p_local_device) {
+		frame_count = 1;
+		local_device = p_context->local_device_create();
+		device = p_context->local_device_get_d3d12_device(local_device);
+	} else {
+		frame_count = p_context->get_swapchain_image_count() + 1;
+	}
+	limits = p_context->get_device_limits();
+	max_timestamp_query_elements = 256;
+
+	{ // Create command signature for indirect dispatch.
+		D3D12_INDIRECT_ARGUMENT_DESC iarg_desc = {};
+		iarg_desc.Type = D3D12_INDIRECT_ARGUMENT_TYPE_DISPATCH;
+		D3D12_COMMAND_SIGNATURE_DESC cs_desc = {};
+		cs_desc.ByteStride = sizeof(D3D12_DISPATCH_ARGUMENTS);
+		cs_desc.NumArgumentDescs = 1;
+		cs_desc.pArgumentDescs = &iarg_desc;
+		cs_desc.NodeMask = 0;
+		HRESULT res = device->CreateCommandSignature(&cs_desc, nullptr, IID_PPV_ARGS(indirect_dispatch_cmd_sig.GetAddressOf()));
+		ERR_FAIL_COND_MSG(res, "CreateCommandSignature failed with error " + vformat("0x%08ux", res) + ".");
+	}
+
+	uint32_t resource_descriptors_per_frame = GLOBAL_DEF("rendering/rendering_device/d3d12/max_resource_descriptors_per_frame", 16384);
+	uint32_t sampler_descriptors_per_frame = GLOBAL_DEF("rendering/rendering_device/d3d12/max_sampler_descriptors_per_frame", 1024);
+	uint32_t misc_descriptors_per_frame = GLOBAL_DEF("rendering/rendering_device/d3d12/max_misc_descriptors_per_frame", 512);
+
+	frames.resize(frame_count);
+	frame = 0;
+	// Create setup and frame buffers.
+	for (int i = 0; i < frame_count; i++) {
+		frames[i].index = 0;
+
+		{ // Create descriptor heaps.
+			Error err = frames[i].desc_heaps.resources.allocate(device.Get(), D3D12_DESCRIPTOR_HEAP_TYPE_CBV_SRV_UAV, resource_descriptors_per_frame, true);
+			ERR_FAIL_COND_MSG(err, "Creating the frame's RESOURCE descriptors heap failed.");
+
+			err = frames[i].desc_heaps.samplers.allocate(device.Get(), D3D12_DESCRIPTOR_HEAP_TYPE_SAMPLER, sampler_descriptors_per_frame, true);
+			ERR_FAIL_COND_MSG(err, "Creating the frame's SAMPLER descriptors heap failed.");
+
+			err = frames[i].desc_heaps.aux.allocate(device.Get(), D3D12_DESCRIPTOR_HEAP_TYPE_CBV_SRV_UAV, misc_descriptors_per_frame, false);
+			ERR_FAIL_COND_MSG(err, "Creating the frame's AUX descriptors heap failed.");
+
+			err = frames[i].desc_heaps.rtv.allocate(device.Get(), D3D12_DESCRIPTOR_HEAP_TYPE_RTV, misc_descriptors_per_frame, false);
+			ERR_FAIL_COND_MSG(err, "Creating the frame's RENDER TARGET descriptors heap failed.");
+
+			frames[i].desc_heap_walkers.resources = frames[i].desc_heaps.resources.make_walker();
+			frames[i].desc_heap_walkers.samplers = frames[i].desc_heaps.samplers.make_walker();
+			frames[i].desc_heap_walkers.aux = frames[i].desc_heaps.aux.make_walker();
+			frames[i].desc_heap_walkers.rtv = frames[i].desc_heaps.rtv.make_walker();
+		}
+
+		{ // Create command allocators.
+			HRESULT res = device->CreateCommandAllocator(D3D12_COMMAND_LIST_TYPE_DIRECT, IID_PPV_ARGS(frames[i].setup_command_allocator.GetAddressOf()));
+			ERR_CONTINUE_MSG(res, "CreateCommandAllocator failed with error " + vformat("0x%08ux", res) + ".");
+
+			res = device->CreateCommandAllocator(D3D12_COMMAND_LIST_TYPE_DIRECT, IID_PPV_ARGS(frames[i].draw_command_allocator.GetAddressOf()));
+			ERR_CONTINUE_MSG(res, "CreateCommandAllocator failed with error " + vformat("0x%08ux", res) + ".");
+		}
+
+		{ // Create command lists.
+			HRESULT res = device->CreateCommandList(0, D3D12_COMMAND_LIST_TYPE_DIRECT, frames[i].setup_command_allocator.Get(), nullptr, IID_PPV_ARGS(frames[i].setup_command_list.GetAddressOf()));
+			ERR_CONTINUE_MSG(res, "CreateCommandList failed with error " + vformat("0x%08ux", res) + ".");
+
+			res = device->CreateCommandList(0, D3D12_COMMAND_LIST_TYPE_DIRECT, frames[i].draw_command_allocator.Get(), nullptr, IID_PPV_ARGS(frames[i].draw_command_list.GetAddressOf()));
+			ERR_CONTINUE_MSG(res, "CreateCommandList failed with error " + vformat("0x%08ux", res) + ".");
+
+			if (i > 0) {
+				frames[i].setup_command_list->Close();
+				frames[i].draw_command_list->Close();
+			}
+		}
+
+		if (i == 0) {
+			ID3D12DescriptorHeap *heaps[] = {
+				frames[frame].desc_heaps.resources.get_heap(),
+				frames[frame].desc_heaps.samplers.get_heap(),
+			};
+			frames[frame].draw_command_list->SetDescriptorHeaps(2, heaps);
+		}
+
+		{
+			// Create query heap.
+			D3D12_QUERY_HEAP_DESC qh_desc = {};
+			qh_desc.Type = D3D12_QUERY_HEAP_TYPE_TIMESTAMP;
+			qh_desc.Count = max_timestamp_query_elements;
+			qh_desc.NodeMask = 0;
+			HRESULT res = device->CreateQueryHeap(&qh_desc, IID_PPV_ARGS(frames[i].timestamp_heap.GetAddressOf()));
+			ERR_CONTINUE_MSG(res, "CreateQueryHeap failed with error " + vformat("0x%08ux", res) + ".");
+
+			frames[i].timestamp_names.resize(max_timestamp_query_elements);
+			frames[i].timestamp_cpu_values.resize(max_timestamp_query_elements);
+			frames[i].timestamp_count = 0;
+			frames[i].timestamp_result_names.resize(max_timestamp_query_elements);
+			frames[i].timestamp_cpu_result_values.resize(max_timestamp_query_elements);
+			frames[i].timestamp_result_values.resize(max_timestamp_query_elements);
+			Error err = _buffer_allocate(&frames[i].timestamp_result_values_buffer, sizeof(uint64_t) * max_timestamp_query_elements, D3D12_RESOURCE_STATE_COMMON, D3D12_HEAP_TYPE_READBACK);
+			ERR_CONTINUE(err);
+			frames[i].timestamp_result_count = 0;
+		}
+	}
+
+	if (local_device.is_null()) {
+		context->set_setup_list(frames[0].setup_command_list.Get()); // Append now so it's added before everything else.
+		context->append_command_list(frames[0].draw_command_list.Get());
+	}
+
+	staging_buffer_block_size = GLOBAL_GET("rendering/rendering_device/staging_buffer/block_size_kb");
+	staging_buffer_block_size = MAX(4u, staging_buffer_block_size);
+	staging_buffer_block_size *= 1024; // Kb -> bytes.
+	staging_buffer_max_size = GLOBAL_GET("rendering/rendering_device/staging_buffer/max_size_mb");
+	staging_buffer_max_size = MAX(1u, staging_buffer_max_size);
+	staging_buffer_max_size *= 1024 * 1024;
+
+	if (staging_buffer_max_size < staging_buffer_block_size * 4) {
+		// Validate enough functions.
+		staging_buffer_max_size = staging_buffer_block_size * 4;
+	}
+	texture_upload_region_size_px = GLOBAL_GET("rendering/rendering_device/staging_buffer/texture_upload_region_size_px");
+	texture_upload_region_size_px = nearest_power_of_2_templated(texture_upload_region_size_px);
+
+	frames_drawn = frame_count; // Start from frame count, so everything else is immediately old.
+	execution_index = 1;
+
+	// Ensure current staging block is valid and at least one per frame exists.
+	staging_buffer_current = 0;
+	staging_buffer_used = false;
+
+	for (int i = 0; i < frame_count; i++) {
+		// Staging was never used, create a block.
+		Error err = _insert_staging_block();
+		ERR_CONTINUE(err != OK);
+	}
+
+	{
+		aux_resource = texture_create(TextureFormat(), TextureView());
+		ERR_FAIL_COND(!aux_resource.is_valid());
+	}
+
+	draw_list = nullptr;
+	draw_list_count = 0;
+	draw_list_split = false;
+
+	vrs_state_execution_index = 0;
+	vrs_state = {};
+
+	compute_list = nullptr;
+
+	glsl_type_singleton_init_or_ref();
+}
+
+dxil_validator *RenderingDeviceD3D12::get_dxil_validator_for_current_thread() {
+	MutexLock lock(dxil_mutex);
+
+	int thread_idx = WorkerThreadPool::get_singleton()->get_thread_index();
+	if (dxil_validators.has(thread_idx)) {
+		return dxil_validators[thread_idx];
+	}
+
+#ifdef DEV_ENABLED
+	print_verbose("Creating DXIL validator for worker thread index " + itos(thread_idx));
+#endif
+
+	dxil_validator *dxil_validator = dxil_create_validator(nullptr);
+	CRASH_COND(!dxil_validator);
+
+	dxil_validators.insert(thread_idx, dxil_validator);
+	return dxil_validator;
+}
+
+template <class T>
+void RenderingDeviceD3D12::_free_rids(T &p_owner, const char *p_type) {
+	List<RID> owned;
+	p_owner.get_owned_list(&owned);
+	if (owned.size()) {
+		if (owned.size() == 1) {
+			WARN_PRINT(vformat("1 RID of type \"%s\" was leaked.", p_type));
+		} else {
+			WARN_PRINT(vformat("%d RIDs of type \"%s\" were leaked.", owned.size(), p_type));
+		}
+		for (const RID &E : owned) {
+#ifdef DEV_ENABLED
+			if (resource_names.has(E)) {
+				print_line(String(" - ") + resource_names[E]);
+			}
+#endif
+			free(E);
+		}
+	}
+}
+
+void RenderingDeviceD3D12::capture_timestamp(const String &p_name) {
+	ERR_FAIL_COND_MSG(draw_list != nullptr, "Capturing timestamps during draw list creation is not allowed. Offending timestamp was: " + p_name);
+	ERR_FAIL_COND(frames[frame].timestamp_count >= max_timestamp_query_elements);
+
+	// This should be optional for profiling, else it will slow things down.
+	full_barrier();
+
+	frames[frame].draw_command_list->EndQuery(frames[frame].timestamp_heap.Get(), D3D12_QUERY_TYPE_TIMESTAMP, frames[frame].timestamp_count);
+	frames[frame].timestamp_names[frames[frame].timestamp_count] = p_name;
+	frames[frame].timestamp_cpu_values[frames[frame].timestamp_count] = OS::get_singleton()->get_ticks_usec();
+	frames[frame].timestamp_count++;
+}
+
+uint64_t RenderingDeviceD3D12::get_driver_resource(DriverResource p_resource, RID p_rid, uint64_t p_index) {
+	_THREAD_SAFE_METHOD_
+	return 0;
+}
+
+uint32_t RenderingDeviceD3D12::get_captured_timestamps_count() const {
+	return frames[frame].timestamp_result_count;
+}
+
+uint64_t RenderingDeviceD3D12::get_captured_timestamps_frame() const {
+	return frames[frame].index;
+}
+
+uint64_t RenderingDeviceD3D12::get_captured_timestamp_gpu_time(uint32_t p_index) const {
+	ERR_FAIL_UNSIGNED_INDEX_V(p_index, frames[frame].timestamp_result_count, 0);
+
+	return frames[frame].timestamp_result_values[p_index] / (double)limits.timestamp_frequency * 1000000000.0;
+}
+
+uint64_t RenderingDeviceD3D12::get_captured_timestamp_cpu_time(uint32_t p_index) const {
+	ERR_FAIL_UNSIGNED_INDEX_V(p_index, frames[frame].timestamp_result_count, 0);
+	return frames[frame].timestamp_cpu_result_values[p_index];
+}
+
+String RenderingDeviceD3D12::get_captured_timestamp_name(uint32_t p_index) const {
+	ERR_FAIL_UNSIGNED_INDEX_V(p_index, frames[frame].timestamp_result_count, String());
+	return frames[frame].timestamp_result_names[p_index];
+}
+
+uint64_t RenderingDeviceD3D12::limit_get(Limit p_limit) const {
+	switch (p_limit) {
+		case LIMIT_MAX_TEXTURES_PER_SHADER_STAGE:
+			return limits.max_srvs_per_shader_stage;
+		case LIMIT_MAX_UNIFORM_BUFFER_SIZE:
+			return 65536;
+		case LIMIT_MAX_VIEWPORT_DIMENSIONS_X:
+		case LIMIT_MAX_VIEWPORT_DIMENSIONS_Y:
+			return 16384; // Based on max. texture size. Maybe not correct.
+		case LIMIT_MAX_COMPUTE_WORKGROUP_COUNT_X:
+			return D3D12_CS_DISPATCH_MAX_THREAD_GROUPS_PER_DIMENSION;
+		case LIMIT_MAX_COMPUTE_WORKGROUP_COUNT_Y:
+			return D3D12_CS_DISPATCH_MAX_THREAD_GROUPS_PER_DIMENSION;
+		case LIMIT_MAX_COMPUTE_WORKGROUP_COUNT_Z:
+			return D3D12_CS_DISPATCH_MAX_THREAD_GROUPS_PER_DIMENSION;
+		case LIMIT_MAX_COMPUTE_WORKGROUP_SIZE_X:
+			return D3D12_CS_THREAD_GROUP_MAX_X;
+		case LIMIT_MAX_COMPUTE_WORKGROUP_SIZE_Y:
+			return D3D12_CS_THREAD_GROUP_MAX_Y;
+		case LIMIT_MAX_COMPUTE_WORKGROUP_SIZE_Z:
+			return D3D12_CS_THREAD_GROUP_MAX_Z;
+		case LIMIT_SUBGROUP_SIZE:
+		// Note in min/max. Shader model 6.6 supports it (see https://microsoft.github.io/DirectX-Specs/d3d/HLSL_SM_6_6_WaveSize.html),
+		// but at this time I don't know the implications on the transpilation to DXIL, etc.
+		case LIMIT_SUBGROUP_MIN_SIZE:
+		case LIMIT_SUBGROUP_MAX_SIZE: {
+			D3D12Context::SubgroupCapabilities subgroup_capabilities = context->get_subgroup_capabilities();
+			return subgroup_capabilities.size;
+		}
+		case LIMIT_SUBGROUP_IN_SHADERS: {
+			D3D12Context::SubgroupCapabilities subgroup_capabilities = context->get_subgroup_capabilities();
+			return subgroup_capabilities.supported_stages_flags_rd();
+		}
+		case LIMIT_SUBGROUP_OPERATIONS: {
+			D3D12Context::SubgroupCapabilities subgroup_capabilities = context->get_subgroup_capabilities();
+			return subgroup_capabilities.supported_operations_flags_rd();
+		}
+		case LIMIT_VRS_TEXEL_WIDTH:
+		case LIMIT_VRS_TEXEL_HEIGHT: {
+			return context->get_vrs_capabilities().ss_image_tile_size;
+		}
+		default:
+			// It's important to return a number that at least won't overflow any typical integer type.
+#ifdef DEV_ENABLED
+			WARN_PRINT("Returning maximum value for unknown limit " + itos(p_limit) + ".");
+#endif
+			return (uint64_t)1 << 30;
+	}
+}
+
+bool RenderingDeviceD3D12::has_feature(const Features p_feature) const {
+	switch (p_feature) {
+		case SUPPORTS_MULTIVIEW: {
+			D3D12Context::MultiviewCapabilities multiview_capabilies = context->get_multiview_capabilities();
+			return multiview_capabilies.is_supported && multiview_capabilies.max_view_count > 1;
+		} break;
+		case SUPPORTS_FSR_HALF_FLOAT: {
+			return context->get_shader_capabilities().native_16bit_ops && context->get_storage_buffer_capabilities().storage_buffer_16_bit_access_is_supported;
+		} break;
+		case SUPPORTS_ATTACHMENT_VRS: {
+			D3D12Context::VRSCapabilities vrs_capabilities = context->get_vrs_capabilities();
+			return vrs_capabilities.ss_image_supported;
+		} break;
+		case SUPPORTS_FRAGMENT_SHADER_WITH_ONLY_SIDE_EFFECTS: {
+			return true;
+		} break;
+		default: {
+			return false;
+		}
+	}
+}
+
+void RenderingDeviceD3D12::finalize() {
+	// Free all resources.
+
+	_flush(false);
+
+	free(aux_resource);
+
+	_free_rids(render_pipeline_owner, "Pipeline");
+	_free_rids(compute_pipeline_owner, "Compute");
+	_free_rids(uniform_set_owner, "UniformSet");
+	_free_rids(texture_buffer_owner, "TextureBuffer");
+	_free_rids(storage_buffer_owner, "StorageBuffer");
+	_free_rids(uniform_buffer_owner, "UniformBuffer");
+	_free_rids(shader_owner, "Shader");
+	_free_rids(index_array_owner, "IndexArray");
+	_free_rids(index_buffer_owner, "IndexBuffer");
+	_free_rids(vertex_array_owner, "VertexArray");
+	_free_rids(vertex_buffer_owner, "VertexBuffer");
+	_free_rids(framebuffer_owner, "Framebuffer");
+	_free_rids(sampler_owner, "Sampler");
+	{
+		// For textures it's a bit more difficult because they may be shared.
+		List<RID> owned;
+		texture_owner.get_owned_list(&owned);
+		if (owned.size()) {
+			if (owned.size() == 1) {
+				WARN_PRINT("1 RID of type \"Texture\" was leaked.");
+			} else {
+				WARN_PRINT(vformat("%d RIDs of type \"Texture\" were leaked.", owned.size()));
+			}
+			// Free shared first.
+			for (List<RID>::Element *E = owned.front(); E;) {
+				List<RID>::Element *N = E->next();
+				if (texture_is_shared(E->get())) {
+#ifdef DEV_ENABLED
+					if (resource_names.has(E->get())) {
+						print_line(String(" - ") + resource_names[E->get()]);
+					}
+#endif
+					free(E->get());
+					owned.erase(E);
+				}
+				E = N;
+			}
+			// Free non shared second, this will avoid an error trying to free unexisting textures due to dependencies.
+			for (const RID &E : owned) {
+#ifdef DEV_ENABLED
+				if (resource_names.has(E)) {
+					print_line(String(" - ") + resource_names[E]);
+				}
+#endif
+				free(E);
+			}
+		}
+	}
+
+	// Free everything pending.
+	for (int i = 0; i < frame_count; i++) {
+		int f = (frame + i) % frame_count;
+		_free_pending_resources(f);
+		frames[i].timestamp_result_values_buffer.allocation->Release();
+		frames[i].timestamp_result_values_buffer.resource->Release();
+	}
+
+	frames.clear();
+
+	pipeline_bindings.clear();
+	next_pipeline_binding_id = 1;
+
+	for (int i = 0; i < split_draw_list_allocators.size(); i++) {
+		for (int j = 0; i < split_draw_list_allocators[i].command_lists.size(); j++) {
+			split_draw_list_allocators[i].command_lists[j]->Release();
+		}
+		split_draw_list_allocators[i].command_allocator->Release();
+	}
+
+	res_barriers_requests.clear();
+	res_barriers.clear();
+
+	for (int i = 0; i < staging_buffer_blocks.size(); i++) {
+		staging_buffer_blocks[i].allocation->Release();
+		staging_buffer_blocks[i].resource->Release();
+	}
+#ifdef USE_SMALL_ALLOCS_POOL
+	small_allocs_pools.clear();
+#endif
+
+	indirect_dispatch_cmd_sig.Reset();
+
+	vertex_formats.clear();
+
+	framebuffer_formats.clear();
+
+	// All these should be clear at this point.
+	ERR_FAIL_COND(dependency_map.size());
+	ERR_FAIL_COND(reverse_dependency_map.size());
+
+	{
+		MutexLock lock(dxil_mutex);
+		for (const KeyValue<int, dxil_validator *> &E : dxil_validators) {
+			dxil_destroy_validator(E.value);
+		}
+	}
+
+	glsl_type_singleton_decref();
+}
+
+RenderingDevice *RenderingDeviceD3D12::create_local_device() {
+	RenderingDeviceD3D12 *rd = memnew(RenderingDeviceD3D12);
+	rd->initialize(context, true);
+	return rd;
+}
+
+RenderingDeviceD3D12::RenderingDeviceD3D12() {
+	device_capabilities.device_family = DEVICE_DIRECTX;
+}
+
+RenderingDeviceD3D12::~RenderingDeviceD3D12() {
+	if (local_device.is_valid()) {
+		finalize();
+		context->local_device_free(local_device);
+	}
+}
diff --git a/drivers/d3d12/rendering_device_d3d12.h b/drivers/d3d12/rendering_device_d3d12.h
new file mode 100644
index 0000000000..92ae2f78fb
--- /dev/null
+++ b/drivers/d3d12/rendering_device_d3d12.h
@@ -0,0 +1,1277 @@
+/**************************************************************************/
+/*  rendering_device_d3d12.h                                              */
+/**************************************************************************/
+/*                         This file is part of:                          */
+/*                             GODOT ENGINE                               */
+/*                        https://godotengine.org                         */
+/**************************************************************************/
+/* Copyright (c) 2014-present Godot Engine contributors (see AUTHORS.md). */
+/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur.                  */
+/*                                                                        */
+/* Permission is hereby granted, free of charge, to any person obtaining  */
+/* a copy of this software and associated documentation files (the        */
+/* "Software"), to deal in the Software without restriction, including    */
+/* without limitation the rights to use, copy, modify, merge, publish,    */
+/* distribute, sublicense, and/or sell copies of the Software, and to     */
+/* permit persons to whom the Software is furnished to do so, subject to  */
+/* the following conditions:                                              */
+/*                                                                        */
+/* The above copyright notice and this permission notice shall be         */
+/* included in all copies or substantial portions of the Software.        */
+/*                                                                        */
+/* 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. */
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY   */
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,   */
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE      */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                 */
+/**************************************************************************/
+
+#ifndef RENDERING_DEVICE_D3D12_H
+#define RENDERING_DEVICE_D3D12_H
+
+#include "core/os/thread_safe.h"
+#include "core/templates/local_vector.h"
+#include "core/templates/oa_hash_map.h"
+#include "core/templates/rid_owner.h"
+#include "drivers/d3d12/d3d12_context.h"
+#include "servers/rendering/rendering_device.h"
+
+#include <wrl/client.h>
+
+using Microsoft::WRL::ComPtr;
+
+#define D3D12_BITCODE_OFFSETS_NUM_STAGES 3
+
+struct dxil_validator;
+
+class RenderingDeviceD3D12 : public RenderingDevice {
+	_THREAD_SAFE_CLASS_
+	// Miscellaneous tables that map
+	// our enums to enums used
+	// by DXGI/D3D12.
+
+	D3D12Context::DeviceLimits limits = {};
+	struct D3D12Format {
+		DXGI_FORMAT family = DXGI_FORMAT_UNKNOWN;
+		DXGI_FORMAT general_format = DXGI_FORMAT_UNKNOWN;
+		UINT swizzle = D3D12_DEFAULT_SHADER_4_COMPONENT_MAPPING;
+		DXGI_FORMAT dsv_format = DXGI_FORMAT_UNKNOWN;
+	};
+	static const D3D12Format d3d12_formats[DATA_FORMAT_MAX];
+	static const char *named_formats[DATA_FORMAT_MAX];
+	static const D3D12_COMPARISON_FUNC compare_operators[COMPARE_OP_MAX];
+	static const D3D12_STENCIL_OP stencil_operations[STENCIL_OP_MAX];
+	static const UINT rasterization_sample_count[TEXTURE_SAMPLES_MAX];
+	static const D3D12_LOGIC_OP logic_operations[RenderingDevice::LOGIC_OP_MAX];
+	static const D3D12_BLEND blend_factors[RenderingDevice::BLEND_FACTOR_MAX];
+	static const D3D12_BLEND_OP blend_operations[RenderingDevice::BLEND_OP_MAX];
+	static const D3D12_TEXTURE_ADDRESS_MODE address_modes[SAMPLER_REPEAT_MODE_MAX];
+	static const FLOAT sampler_border_colors[SAMPLER_BORDER_COLOR_MAX][4];
+	static const D3D12_RESOURCE_DIMENSION d3d12_texture_dimension[TEXTURE_TYPE_MAX];
+
+	// Functions used for format
+	// validation, and ensures the
+	// user passes valid data.
+
+	static int get_format_vertex_size(DataFormat p_format);
+	static uint32_t get_image_format_pixel_size(DataFormat p_format);
+	static void get_compressed_image_format_block_dimensions(DataFormat p_format, uint32_t &r_w, uint32_t &r_h);
+	uint32_t get_compressed_image_format_block_byte_size(DataFormat p_format);
+	static uint32_t get_compressed_image_format_pixel_rshift(DataFormat p_format);
+	static uint32_t get_image_format_plane_count(DataFormat p_format);
+	static uint32_t get_image_format_required_size(DataFormat p_format, uint32_t p_width, uint32_t p_height, uint32_t p_depth, uint32_t p_mipmaps, uint32_t *r_blockw = nullptr, uint32_t *r_blockh = nullptr, uint32_t *r_depth = nullptr);
+	static uint32_t get_image_required_mipmaps(uint32_t p_width, uint32_t p_height, uint32_t p_depth);
+	static bool format_has_stencil(DataFormat p_format);
+
+	Mutex dxil_mutex;
+	HashMap<int, dxil_validator *> dxil_validators; // One per WorkerThreadPool thread used for shader compilation, plus one (-1) for all the other.
+
+	dxil_validator *get_dxil_validator_for_current_thread();
+
+	class DescriptorsHeap {
+		D3D12_DESCRIPTOR_HEAP_DESC desc = {};
+		ComPtr<ID3D12DescriptorHeap> heap;
+		uint32_t handle_size = 0;
+
+	public:
+		class Walker { // Texas Ranger.
+			friend class DescriptorsHeap;
+
+			uint32_t handle_size = 0;
+			uint32_t handle_count = 0;
+			D3D12_CPU_DESCRIPTOR_HANDLE first_cpu_handle = {};
+			D3D12_GPU_DESCRIPTOR_HANDLE first_gpu_handle = {};
+			uint32_t handle_index = 0;
+
+		public:
+			D3D12_CPU_DESCRIPTOR_HANDLE get_curr_cpu_handle();
+			D3D12_GPU_DESCRIPTOR_HANDLE get_curr_gpu_handle();
+			_FORCE_INLINE_ void rewind() { handle_index = 0; }
+			void advance(uint32_t p_count = 1);
+			uint32_t get_current_handle_index() const { return handle_index; }
+			uint32_t get_free_handles() { return handle_count - handle_index; }
+			bool is_at_eof() { return handle_index == handle_count; }
+		};
+
+		Error allocate(ID3D12Device *m_device, D3D12_DESCRIPTOR_HEAP_TYPE m_type, uint32_t m_descriptor_count, bool p_for_gpu);
+		uint32_t get_descriptor_count() const { return desc.NumDescriptors; }
+		ID3D12DescriptorHeap *get_heap() const { return heap.Get(); }
+
+		Walker make_walker() const;
+	};
+
+	/***************************/
+	/**** ID INFRASTRUCTURE ****/
+	/***************************/
+
+	enum IDType {
+		ID_TYPE_FRAMEBUFFER_FORMAT,
+		ID_TYPE_VERTEX_FORMAT,
+		ID_TYPE_DRAW_LIST,
+		ID_TYPE_SPLIT_DRAW_LIST,
+		ID_TYPE_COMPUTE_LIST,
+		ID_TYPE_MAX,
+		ID_BASE_SHIFT = 58 // 5 bits for ID types.
+	};
+
+	ComPtr<ID3D12Device> device;
+
+	HashMap<RID, HashSet<RID>> dependency_map; // IDs to IDs that depend on it.
+	HashMap<RID, HashSet<RID>> reverse_dependency_map; // Same as above, but in reverse.
+
+	void _add_dependency(RID p_id, RID p_depends_on);
+	void _free_dependencies(RID p_id);
+
+	/******************/
+	/**** RESOURCE ****/
+	/******************/
+
+	class ResourceState {
+		D3D12_RESOURCE_STATES states = D3D12_RESOURCE_STATE_COMMON;
+
+	public:
+		void extend(D3D12_RESOURCE_STATES p_states_to_add);
+		D3D12_RESOURCE_STATES get_state_mask() const { return states; }
+
+		ResourceState() {}
+		ResourceState(D3D12_RESOURCE_STATES p_states) :
+				states(p_states) {}
+	};
+
+	struct Resource {
+		struct States {
+			// As many subresources as mipmaps * layers; planes (for depth-stencil) are tracked together.
+			LocalVector<D3D12_RESOURCE_STATES> subresource_states; // Used only if not a view.
+			uint32_t last_batch_transitioned_to_uav = 0;
+			uint32_t last_batch_with_uav_barrier = 0;
+		};
+
+		ID3D12Resource *resource = nullptr;
+		D3D12MA::Allocation *allocation = nullptr;
+
+		States own_states; // Used only if not a view.
+		States *states = nullptr; // Non-null only if a view.
+
+		States *get_states_ptr() { return states ? states : &own_states; }
+	};
+
+	struct BarrierRequest {
+		static const uint32_t MAX_GROUPS = 4;
+		// Maybe this is too much data to have it locally. Benchmarking may reveal that
+		// cache would be used better by having a maximum of local subresource masks and beyond
+		// that have an allocated vector with the rest.
+		static const uint32_t MAX_SUBRESOURCES = 4096; // Must be multiple of 64.
+		ID3D12Resource *dx_resource;
+		uint8_t subres_mask_qwords;
+		uint8_t planes;
+		struct Group {
+			ResourceState state;
+			uint64_t subres_mask[MAX_SUBRESOURCES / 64];
+		} groups[MAX_GROUPS];
+		uint8_t groups_count;
+		static const D3D12_RESOURCE_STATES DELETED_GROUP = D3D12_RESOURCE_STATE_COMMON;
+	};
+	HashMap<Resource::States *, BarrierRequest> res_barriers_requests;
+
+	LocalVector<D3D12_RESOURCE_BARRIER> res_barriers;
+	uint32_t res_barriers_count = 0;
+	uint32_t res_barriers_batch = 0;
+#ifdef DEV_ENABLED
+	int frame_barriers_count = 0;
+	int frame_barriers_batches_count = 0;
+	uint64_t frame_barriers_cpu_time = 0;
+#endif
+
+	void _resource_transition_batch(Resource *p_resource, uint32_t p_subresource, uint32_t p_num_planes, D3D12_RESOURCE_STATES p_new_state, ID3D12Resource *p_resource_override = nullptr);
+	void _resource_transitions_flush(ID3D12GraphicsCommandList *p_command_list);
+
+	/*****************/
+	/**** TEXTURE ****/
+	/*****************/
+
+	struct Texture : Resource {
+		D3D12_SHADER_RESOURCE_VIEW_DESC srv_desc = {};
+		D3D12_UNORDERED_ACCESS_VIEW_DESC uav_desc = {};
+		D3D12_UNORDERED_ACCESS_VIEW_DESC owner_uav_desc = {}; // [[CROSS_FAMILY_ALIASING]].
+
+		TextureType type;
+		DataFormat format;
+		uint32_t planes = 1;
+		TextureSamples samples;
+		uint32_t width = 0;
+		uint32_t height = 0;
+		uint32_t depth = 0;
+		uint32_t layers = 0;
+		uint32_t mipmaps = 0;
+		uint32_t owner_layers = 0;
+		uint32_t owner_mipmaps = 0;
+		uint32_t usage_flags = 0;
+		uint32_t base_mipmap = 0;
+		uint32_t base_layer = 0;
+
+		Vector<DataFormat> allowed_shared_formats;
+		TightLocalVector<ID3D12Resource *> aliases; // [[CROSS_FAMILY_ALIASING]].
+		ID3D12Resource *owner_resource = nullptr; // Always the one of the main format passed to creation. [[CROSS_FAMILY_ALIASING]].
+
+		bool is_resolve_buffer = false;
+
+		bool bound = false; // Bound to framebffer.
+		RID owner;
+	};
+
+	RID_Owner<Texture, true> texture_owner;
+	uint32_t texture_upload_region_size_px = 0;
+
+	Vector<uint8_t> _texture_get_data_from_image(Texture *tex, uint32_t p_layer, bool p_2d = false);
+	Error _texture_update(Texture *p_texture, uint32_t p_layer, const Vector<uint8_t> &p_data, BitField<BarrierMask> p_post_barrier, ID3D12GraphicsCommandList *p_command_list);
+
+	/*****************/
+	/**** SAMPLER ****/
+	/*****************/
+
+	RID_Owner<D3D12_SAMPLER_DESC> sampler_owner;
+
+	/***************************/
+	/**** BUFFER MANAGEMENT ****/
+	/***************************/
+
+	// These are temporary buffers on CPU memory that hold
+	// the information until the CPU fetches it and places it
+	// either on GPU buffers, or images (textures). It ensures
+	// updates are properly synchronized with whatever the
+	// GPU is doing.
+	//
+	// The logic here is as follows, only 3 of these
+	// blocks are created at the beginning (one per frame)
+	// they can each belong to a frame (assigned to current when
+	// used) and they can only be reused after the same frame is
+	// recycled.
+	//
+	// When CPU requires to allocate more than what is available,
+	// more of these buffers are created. If a limit is reached,
+	// then a fence will ensure will wait for blocks allocated
+	// in previous frames are processed. If that fails, then
+	// another fence will ensure everything pending for the current
+	// frame is processed (effectively stalling).
+	//
+	// See the comments in the code to understand better how it works.
+
+	struct StagingBufferBlock {
+		ID3D12Resource *resource = nullptr; // Owned, but ComPtr would have too much overhead in a Vector.
+		D3D12MA::Allocation *allocation = nullptr;
+		uint64_t frame_used = 0;
+		uint32_t fill_amount = 0;
+	};
+
+	Vector<StagingBufferBlock> staging_buffer_blocks;
+	int staging_buffer_current = 0;
+	uint32_t staging_buffer_block_size = 0;
+	uint64_t staging_buffer_max_size = 0;
+	bool staging_buffer_used = false;
+
+	Error _staging_buffer_allocate(uint32_t p_amount, uint32_t p_required_align, uint32_t &r_alloc_offset, uint32_t &r_alloc_size, bool p_can_segment = true);
+	Error _insert_staging_block();
+
+	struct Buffer : Resource {
+		uint32_t size = 0;
+		D3D12_RESOURCE_STATES usage = {};
+		uint32_t last_execution = 0;
+	};
+
+	Error _buffer_allocate(Buffer *p_buffer, uint32_t p_size, D3D12_RESOURCE_STATES p_usage, D3D12_HEAP_TYPE p_heap_type);
+	Error _buffer_free(Buffer *p_buffer);
+	Error _buffer_update(Buffer *p_buffer, size_t p_offset, const uint8_t *p_data, size_t p_data_size, bool p_use_draw_command_list = false, uint32_t p_required_align = 32);
+
+	/*********************/
+	/**** FRAMEBUFFER ****/
+	/*********************/
+
+	static D3D12_RENDER_TARGET_VIEW_DESC _make_rtv_for_texture(const RenderingDeviceD3D12::Texture *p_texture, uint32_t p_mipmap_offset = 0, uint32_t p_layer_offset = 0, uint32_t p_layers = UINT32_MAX);
+	static D3D12_DEPTH_STENCIL_VIEW_DESC _make_dsv_for_texture(const RenderingDeviceD3D12::Texture *p_texture);
+
+	// In Vulkan we'd create some structures the driver uses for render pass based rendering.
+	// (Dynamic rendering is supported on Vulkan 1.3+, though, but Godot is not using it.)
+	// In contrast, in D3D12 we'll go the dynamic rendering way, since it's more convenient
+	// and render pass based render setup is not available on every version.
+	// Therefore, we just need to keep the data at hand and use it where appropriate.
+
+	struct FramebufferFormat {
+		Vector<AttachmentFormat> attachments;
+		Vector<FramebufferPass> passes;
+		Vector<TextureSamples> pass_samples;
+		uint32_t view_count = 1;
+		uint32_t max_supported_sample_count = 1;
+	};
+
+	bool _framebuffer_format_preprocess(FramebufferFormat *p_fb_format, uint32_t p_view_count);
+
+	HashMap<FramebufferFormatID, FramebufferFormat> framebuffer_formats;
+
+	struct Framebuffer {
+		DisplayServer::WindowID window_id = DisplayServer::INVALID_WINDOW_ID;
+		FramebufferFormatID format_id = 0;
+		Vector<RID> texture_ids; // Empty if for screen.
+		InvalidationCallback invalidated_callback = nullptr;
+		void *invalidated_callback_userdata = nullptr;
+		Vector<uint32_t> attachments_handle_inds; // RTV heap index for color; DSV heap index for DSV.
+		Size2 size;
+		uint32_t view_count = 1;
+		DescriptorsHeap rtv_heap; // Used only if not for screen and some color attachments.
+		D3D12_CPU_DESCRIPTOR_HANDLE screen_rtv_handle = {}; // Used only if for screen.
+		DescriptorsHeap dsv_heap; // Used only if not for screen and some depth-stencil attachments.
+	};
+
+	RID_Owner<Framebuffer, true> framebuffer_owner;
+
+	/***********************/
+	/**** VERTEX BUFFER ****/
+	/***********************/
+
+	RID_Owner<Buffer, true> vertex_buffer_owner;
+
+	struct VertexDescriptionKey {
+		Vector<VertexAttribute> vertex_formats;
+		bool operator==(const VertexDescriptionKey &p_key) const {
+			int vdc = vertex_formats.size();
+			int vdck = p_key.vertex_formats.size();
+
+			if (vdc != vdck) {
+				return false;
+			} else {
+				const VertexAttribute *a_ptr = vertex_formats.ptr();
+				const VertexAttribute *b_ptr = p_key.vertex_formats.ptr();
+				for (int i = 0; i < vdc; i++) {
+					const VertexAttribute &a = a_ptr[i];
+					const VertexAttribute &b = b_ptr[i];
+
+					if (a.location != b.location) {
+						return false;
+					}
+					if (a.offset != b.offset) {
+						return false;
+					}
+					if (a.format != b.format) {
+						return false;
+					}
+					if (a.stride != b.stride) {
+						return false;
+					}
+					if (a.frequency != b.frequency) {
+						return false;
+					}
+				}
+				return true; // They are equal.
+			}
+		}
+
+		uint32_t hash() const {
+			int vdc = vertex_formats.size();
+			uint32_t h = hash_murmur3_one_32(vdc);
+			const VertexAttribute *ptr = vertex_formats.ptr();
+			for (int i = 0; i < vdc; i++) {
+				const VertexAttribute &vd = ptr[i];
+				h = hash_murmur3_one_32(vd.location, h);
+				h = hash_murmur3_one_32(vd.offset, h);
+				h = hash_murmur3_one_32(vd.format, h);
+				h = hash_murmur3_one_32(vd.stride, h);
+				h = hash_murmur3_one_32(vd.frequency, h);
+			}
+			return hash_fmix32(h);
+		}
+	};
+
+	struct VertexDescriptionHash {
+		static _FORCE_INLINE_ uint32_t hash(const VertexDescriptionKey &p_key) {
+			return p_key.hash();
+		}
+	};
+
+	// This is a cache and it's never freed, it ensures that
+	// ID used for a specific format always remain the same.
+	HashMap<VertexDescriptionKey, VertexFormatID, VertexDescriptionHash> vertex_format_cache;
+
+	struct VertexDescriptionCache {
+		Vector<VertexAttribute> vertex_formats;
+		Vector<D3D12_INPUT_ELEMENT_DESC> elements_desc;
+	};
+
+	HashMap<VertexFormatID, VertexDescriptionCache> vertex_formats;
+
+	struct VertexArray {
+		Vector<Buffer *> unique_buffers;
+		VertexFormatID description = 0;
+		int vertex_count = 0;
+		uint32_t max_instances_allowed = 0;
+		Vector<D3D12_VERTEX_BUFFER_VIEW> views;
+	};
+
+	RID_Owner<VertexArray, true> vertex_array_owner;
+
+	struct IndexBuffer : public Buffer {
+		uint32_t max_index = 0; // Used for validation.
+		uint32_t index_count = 0;
+		DXGI_FORMAT index_format = {};
+		bool supports_restart_indices = false;
+	};
+
+	RID_Owner<IndexBuffer, true> index_buffer_owner;
+
+	struct IndexArray {
+		IndexBuffer *buffer = nullptr;
+		uint32_t max_index = 0; // Remember the maximum index here too, for validation.
+		uint32_t offset = 0;
+		uint32_t indices = 0;
+		bool supports_restart_indices = false;
+		D3D12_INDEX_BUFFER_VIEW view = {};
+	};
+
+	RID_Owner<IndexArray, true> index_array_owner;
+
+	/****************/
+	/**** SHADER ****/
+	/****************/
+
+	static const uint32_t ROOT_SIGNATURE_SIZE = 256;
+	static const uint32_t PUSH_CONSTANT_SIZE = 128; // Mimicking Vulkan.
+
+	enum {
+		// We can only aim to set a maximum here, since depending on the shader
+		// there may be more or less root signature free for descriptor tables.
+		// Therefore, we'll have to rely on the final check at runtime, when building
+		// the root signature structure for a given shader.
+		// To be precise, these may be present or not, and their size vary statically:
+		// - Push constant (we'll assume this is always present to avoid reserving much
+		//   more space for descriptor sets than needed for almost any imaginable case,
+		//   given that most shader templates feature push constants).
+		// - NIR-DXIL runtime data.
+		MAX_UNIFORM_SETS = (ROOT_SIGNATURE_SIZE - PUSH_CONSTANT_SIZE) / sizeof(uint32_t),
+	};
+
+	enum ResourceClass {
+		RES_CLASS_INVALID,
+		RES_CLASS_CBV,
+		RES_CLASS_SRV,
+		RES_CLASS_UAV,
+	};
+
+	struct UniformBindingInfo {
+		uint32_t stages = 0; // Actual shader stages using the uniform (0 if totally optimized out).
+		ResourceClass res_class = RES_CLASS_INVALID;
+		struct RootSignatureLocation {
+			uint32_t root_param_idx = UINT32_MAX;
+			uint32_t range_idx = UINT32_MAX;
+		};
+		struct {
+			RootSignatureLocation resource;
+			RootSignatureLocation sampler;
+		} root_sig_locations;
+	};
+
+	struct UniformInfo {
+		UniformType type = UniformType::UNIFORM_TYPE_MAX;
+		bool writable = false;
+		int binding = 0;
+		int length = 0; // Size of arrays (in total elements), or ubos (in bytes * total elements).
+
+		bool operator!=(const UniformInfo &p_info) const {
+			return (binding != p_info.binding || type != p_info.type || writable != p_info.writable || length != p_info.length);
+		}
+
+		bool operator<(const UniformInfo &p_info) const {
+			if (binding != p_info.binding) {
+				return binding < p_info.binding;
+			}
+			if (type != p_info.type) {
+				return type < p_info.type;
+			}
+			if (writable != p_info.writable) {
+				return writable < p_info.writable;
+			}
+			return length < p_info.length;
+		}
+	};
+
+	struct UniformSetFormat {
+		Vector<UniformInfo> uniform_info;
+		bool operator<(const UniformSetFormat &p_format) const {
+			uint32_t size = uniform_info.size();
+			uint32_t psize = p_format.uniform_info.size();
+
+			if (size != psize) {
+				return size < psize;
+			}
+
+			const UniformInfo *infoptr = uniform_info.ptr();
+			const UniformInfo *pinfoptr = p_format.uniform_info.ptr();
+
+			for (uint32_t i = 0; i < size; i++) {
+				if (infoptr[i] != pinfoptr[i]) {
+					return infoptr[i] < pinfoptr[i];
+				}
+			}
+
+			return false;
+		}
+	};
+
+	// Always grows, never shrinks, ensuring unique IDs, but we assume
+	// the amount of formats will never be a problem, as the amount of shaders
+	// in a game is limited.
+	RBMap<UniformSetFormat, uint32_t> uniform_set_format_cache;
+	Vector<RBMap<UniformSetFormat, uint32_t>::Element *> uniform_set_format_cache_reverse;
+
+	struct Shader {
+		struct ShaderUniformInfo {
+			UniformInfo info;
+			UniformBindingInfo binding;
+
+			bool operator<(const ShaderUniformInfo &p_info) const {
+				return *((UniformInfo *)this) < (const UniformInfo &)p_info;
+			}
+		};
+		struct Set {
+			Vector<ShaderUniformInfo> uniforms;
+			struct {
+				uint32_t resources = 0;
+				uint32_t samplers = 0;
+			} num_root_params;
+		};
+
+		uint64_t vertex_input_mask = 0; // Inputs used, this is mostly for validation.
+		uint32_t fragment_output_mask = 0;
+
+		uint32_t spirv_push_constant_size = 0;
+		uint32_t dxil_push_constant_size = 0;
+		uint32_t nir_runtime_data_root_param_idx = UINT32_MAX;
+
+		uint32_t compute_local_size[3] = { 0, 0, 0 };
+
+		struct SpecializationConstant {
+			PipelineSpecializationConstant constant;
+			uint64_t stages_bit_offsets[D3D12_BITCODE_OFFSETS_NUM_STAGES];
+		};
+
+		bool is_compute = false;
+		Vector<Set> sets;
+		Vector<uint32_t> set_formats;
+		Vector<SpecializationConstant> specialization_constants;
+		uint32_t spirv_specialization_constants_ids_mask = 0;
+		HashMap<ShaderStage, Vector<uint8_t>> stages_bytecode;
+		String name; // Used for debug.
+
+		ComPtr<ID3D12RootSignature> root_signature;
+		ComPtr<ID3D12RootSignatureDeserializer> root_signature_deserializer;
+		const D3D12_ROOT_SIGNATURE_DESC *root_signature_desc = nullptr; // Owned by the deserializer.
+		uint32_t root_signature_crc = 0;
+	};
+
+	String _shader_uniform_debug(RID p_shader, int p_set = -1);
+
+	RID_Owner<Shader, true> shader_owner;
+
+	uint32_t _shader_patch_dxil_specialization_constant(
+			PipelineSpecializationConstantType p_type,
+			const void *p_value,
+			const uint64_t (&p_stages_bit_offsets)[D3D12_BITCODE_OFFSETS_NUM_STAGES],
+			HashMap<ShaderStage, Vector<uint8_t>> &r_stages_bytecodes,
+			bool p_is_first_patch);
+	bool _shader_sign_dxil_bytecode(ShaderStage p_stage, Vector<uint8_t> &r_dxil_blob);
+
+	/******************/
+	/**** UNIFORMS ****/
+	/******************/
+
+	RID_Owner<Buffer, true> uniform_buffer_owner;
+	RID_Owner<Buffer, true> storage_buffer_owner;
+
+	// Texture buffer needs a view.
+	struct TextureBuffer {
+		Buffer buffer;
+	};
+
+	RID_Owner<TextureBuffer, true> texture_buffer_owner;
+
+	struct RootDescriptorTable {
+		uint32_t root_param_idx = UINT32_MAX;
+		D3D12_GPU_DESCRIPTOR_HANDLE start_gpu_handle = {};
+	};
+
+	// This structure contains the descriptor set. They _need_ to be allocated
+	// for a shader (and will be erased when this shader is erased), but should
+	// work for other shaders as long as the hash matches. This covers using
+	// them in shader variants.
+	//
+	// Keep also in mind that you can share buffers between descriptor sets, so
+	// the above restriction is not too serious.
+
+	struct UniformSet {
+		uint32_t format = 0;
+		RID shader_id;
+		uint32_t shader_set = 0;
+		struct {
+			DescriptorsHeap resources;
+			DescriptorsHeap samplers;
+		} desc_heaps;
+		struct StateRequirement {
+			Resource *resource;
+			bool is_buffer;
+			D3D12_RESOURCE_STATES states;
+			uint64_t shader_uniform_idx_mask;
+		};
+		struct AttachableTexture {
+			uint32_t bind;
+			RID texture;
+		};
+
+		struct RecentBind {
+			uint64_t execution_index = 0;
+			uint32_t root_signature_crc = 0;
+			struct {
+				LocalVector<RootDescriptorTable> resources;
+				LocalVector<RootDescriptorTable> samplers;
+			} root_tables;
+			int uses = 0;
+		} recent_binds[4]; // A better amount may be empirically found.
+
+		LocalVector<AttachableTexture> attachable_textures; // Used for validation.
+		Vector<StateRequirement> resource_states;
+		InvalidationCallback invalidated_callback = nullptr;
+		void *invalidated_callback_userdata = nullptr;
+
+#ifdef DEV_ENABLED
+		// Filthy, but useful for dev.
+		struct ResourceDescInfo {
+			D3D12_DESCRIPTOR_RANGE_TYPE type;
+			D3D12_SRV_DIMENSION srv_dimension;
+		};
+		LocalVector<ResourceDescInfo> _resources_desc_info;
+		const Shader *_shader = nullptr;
+#endif
+	};
+
+	RID_Owner<UniformSet, true> uniform_set_owner;
+
+	void _bind_uniform_set(UniformSet *p_uniform_set, const Shader::Set &p_shader_set, const Vector<UniformBindingInfo> &p_bindings, ID3D12GraphicsCommandList *p_command_list, bool p_for_compute);
+	void _apply_uniform_set_resource_states(const UniformSet *p_uniform_set, const Shader::Set &p_shader_set);
+
+	/*******************/
+	/**** PIPELINES ****/
+	/*******************/
+
+	Error _apply_specialization_constants(
+			const Shader *p_shader,
+			const Vector<PipelineSpecializationConstant> &p_specialization_constants,
+			HashMap<ShaderStage, Vector<uint8_t>> &r_final_stages_bytecode);
+#ifdef DEV_ENABLED
+	String _build_pipeline_blob_filename(
+			const Vector<uint8_t> &p_blob,
+			const Shader *p_shader,
+			const Vector<PipelineSpecializationConstant> &p_specialization_constants,
+			const String &p_extra_name_suffix = "",
+			const String &p_forced_id = "");
+	void _save_pso_blob(
+			ID3D12PipelineState *p_pso,
+			const Shader *p_shader,
+			const Vector<PipelineSpecializationConstant> &p_specialization_constants);
+	void _save_stages_bytecode(
+			const HashMap<ShaderStage, Vector<uint8_t>> &p_stages_bytecode,
+			const Shader *p_shader,
+			const RID p_shader_rid,
+			const Vector<PipelineSpecializationConstant> &p_specialization_constants);
+#endif
+
+	// Render pipeline contains ALL the
+	// information required for drawing.
+	// This includes all the rasterizer state
+	// as well as shader used, framebuffer format,
+	// etc.
+	// Some parameters aren't fixed in D3D12,
+	// so they are stored in an ancillary
+	// dynamic parameters structure to be set
+	// on pipeline activation via several calls.
+
+	struct RenderPipeline {
+		// Cached values for validation.
+#ifdef DEBUG_ENABLED
+		struct Validation {
+			FramebufferFormatID framebuffer_format = 0;
+			uint32_t render_pass = 0;
+			uint32_t dynamic_state = 0;
+			VertexFormatID vertex_format = 0;
+			bool uses_restart_indices = false;
+			uint32_t primitive_minimum = 0;
+			uint32_t primitive_divisor = 0;
+		} validation;
+#endif
+		RID shader;
+		Vector<uint32_t> set_formats;
+		uint32_t bindings_id = 0;
+		ComPtr<ID3D12PipelineState> pso;
+		uint32_t root_signature_crc = 0;
+		uint32_t spirv_push_constant_size = 0;
+		uint32_t dxil_push_constant_size = 0;
+		uint32_t nir_runtime_data_root_param_idx = UINT32_MAX;
+		struct DynamicParams {
+			D3D12_PRIMITIVE_TOPOLOGY primitive_topology = {};
+			Color blend_constant;
+			float depth_bounds_min = 0.0f;
+			float depth_bounds_max = 0.0f;
+			uint32_t stencil_reference = 0;
+		} dyn_params;
+	};
+
+	HashMap<uint32_t, Vector<Vector<UniformBindingInfo>>> pipeline_bindings;
+	uint32_t next_pipeline_binding_id = 1;
+
+	RID_Owner<RenderPipeline, true> render_pipeline_owner;
+
+	struct ComputePipeline {
+		RID shader;
+		Vector<uint32_t> set_formats;
+		uint32_t bindings_id = 0;
+		ComPtr<ID3D12PipelineState> pso;
+		uint32_t root_signature_crc = 0;
+		uint32_t spirv_push_constant_size = 0;
+		uint32_t dxil_push_constant_size = 0;
+		uint32_t local_group_size[3] = { 0, 0, 0 };
+	};
+
+	RID_Owner<ComputePipeline, true> compute_pipeline_owner;
+
+	/*******************/
+	/**** DRAW LIST ****/
+	/*******************/
+
+	// Draw list contains both the command buffer
+	// used for drawing as well as a LOT of
+	// information used for validation. This
+	// validation is cheap so most of it can
+	// also run in release builds.
+
+	// When using split command lists, this is
+	// implemented internally using bundles.
+	// As they can be created in threads,
+	// each needs its own command allocator.
+
+	struct SplitDrawListAllocator {
+		// All pointers are owned, but not using ComPtr to avoid overhead in the vector.
+		ID3D12CommandAllocator *command_allocator = nullptr;
+		Vector<ID3D12GraphicsCommandList *> command_lists; // One for each frame.
+	};
+
+	Vector<SplitDrawListAllocator> split_draw_list_allocators;
+
+	struct DrawList {
+		ID3D12GraphicsCommandList *command_list = nullptr; // If persistent, this is owned, otherwise it's shared with the ringbuffer.
+		Rect2i viewport;
+		bool viewport_set = false;
+
+		struct SetState {
+			uint32_t pipeline_expected_format = 0;
+			uint32_t uniform_set_format = 0;
+			RID uniform_set;
+			bool bound = false;
+#ifdef DEV_ENABLED
+			// Filthy, but useful for dev.
+			const Vector<UniformInfo> *_pipeline_expected_format = nullptr;
+			const UniformSet *_uniform_set = nullptr;
+#endif
+		};
+
+		struct State {
+			SetState sets[MAX_UNIFORM_SETS];
+			uint32_t set_count = 0;
+			RID pipeline;
+			ID3D12PipelineState *pso = nullptr;
+			ID3D12PipelineState *bound_pso = nullptr;
+			RID pipeline_shader;
+			uint32_t pipeline_dxil_push_constant_size = 0;
+			uint32_t pipeline_bindings_id = 0;
+			uint32_t root_signature_crc = 0;
+			RID vertex_array;
+			RID index_array;
+#ifdef DEV_ENABLED
+			// Filthy, but useful for dev.
+			Shader *_shader = nullptr;
+#endif
+		} state;
+
+#ifdef DEBUG_ENABLED
+		struct Validation {
+			bool active = true; // Means command buffer was not closed, so you can keep adding things.
+			// Actual render pass values.
+			uint32_t dynamic_state = 0;
+			VertexFormatID vertex_format = INVALID_ID;
+			uint32_t vertex_array_size = 0;
+			uint32_t vertex_max_instances_allowed = 0xFFFFFFFF;
+			bool index_buffer_uses_restart_indices = false;
+			uint32_t index_array_size = 0;
+			uint32_t index_array_max_index = 0;
+			uint32_t index_array_offset = 0;
+			Vector<uint32_t> set_formats;
+			Vector<bool> set_bound;
+			Vector<RID> set_rids;
+			// Last pipeline set values.
+			bool pipeline_active = false;
+			uint32_t pipeline_dynamic_state = 0;
+			VertexFormatID pipeline_vertex_format = INVALID_ID;
+			RID pipeline_shader;
+			bool pipeline_uses_restart_indices = false;
+			uint32_t pipeline_primitive_divisor = 0;
+			uint32_t pipeline_primitive_minimum = 0;
+			uint32_t pipeline_spirv_push_constant_size = 0;
+			bool pipeline_push_constant_supplied = false;
+		} validation;
+#else
+		struct Validation {
+			uint32_t vertex_array_size = 0;
+			uint32_t index_array_size = 0;
+			uint32_t index_array_offset;
+		} validation;
+#endif
+	};
+
+	DrawList *draw_list = nullptr; // One for regular draw lists, multiple for split.
+	uint32_t draw_list_subpass_count = 0;
+	uint32_t draw_list_count = 0;
+	Framebuffer curr_screen_framebuffer; // Only valid while a screen draw list is open.
+	Framebuffer *draw_list_framebuffer = nullptr;
+	FinalAction draw_list_final_color_action = FINAL_ACTION_DISCARD;
+	FinalAction draw_list_final_depth_action = FINAL_ACTION_DISCARD;
+	Vector2 draw_list_viewport_size = {};
+	uint32_t draw_list_current_subpass = 0;
+
+	bool draw_list_split = false;
+	Vector<RID> draw_list_bound_textures;
+	bool draw_list_unbind_color_textures = false;
+	bool draw_list_unbind_depth_textures = false;
+
+	struct {
+		RID texture_bound;
+		bool configured = false;
+	} vrs_state;
+	uint32_t vrs_state_execution_index = 0;
+
+	Error _draw_list_render_pass_begin(Framebuffer *framebuffer, InitialAction p_initial_color_action, FinalAction p_final_color_action, InitialAction p_initial_depth_action, FinalAction p_final_depth_action, const Vector<Color> &p_clear_colors, float p_clear_depth, uint32_t p_clear_stencil, const Rect2 &p_region, Point2i viewport_offset, Point2i viewport_size, ID3D12GraphicsCommandList *command_list, const Vector<RID> &p_storage_textures);
+	_FORCE_INLINE_ DrawList *_get_draw_list_ptr(DrawListID p_id);
+	Buffer *_get_buffer_from_owner(RID p_buffer);
+	Error _draw_list_allocate(const Rect2i &p_viewport, uint32_t p_splits, uint32_t p_subpass);
+	void _draw_list_free(Rect2i *r_last_viewport = nullptr);
+	void _draw_list_subpass_begin();
+	void _draw_list_subpass_end();
+
+	/**********************/
+	/**** COMPUTE LIST ****/
+	/**********************/
+
+	struct ComputeList {
+		ID3D12GraphicsCommandList *command_list = nullptr; // If persistent, this is owned, otherwise it's shared with the ringbuffer.
+
+		struct SetState {
+			uint32_t pipeline_expected_format = 0;
+			uint32_t uniform_set_format = 0;
+			RID uniform_set;
+			bool bound = false;
+#ifdef DEV_ENABLED
+			// Filthy, but useful for dev.
+			const Vector<UniformInfo> *_pipeline_expected_format = nullptr;
+			const UniformSet *_uniform_set = nullptr;
+#endif
+		};
+
+		struct State {
+			HashSet<Texture *> textures_to_sampled_layout;
+			SetState sets[MAX_UNIFORM_SETS];
+			uint32_t set_count = 0;
+			RID pipeline;
+			ID3D12PipelineState *pso = nullptr;
+			ID3D12PipelineState *bound_pso = nullptr;
+			RID pipeline_shader;
+			uint32_t pipeline_dxil_push_constant_size = 0;
+			uint32_t pipeline_bindings_id = 0;
+			uint32_t root_signature_crc = 0;
+			uint32_t local_group_size[3] = { 0, 0, 0 };
+			bool allow_draw_overlap;
+#ifdef DEV_ENABLED
+			// Filthy, but useful for dev.
+			Shader *_shader = nullptr;
+#endif
+		} state;
+
+#ifdef DEBUG_ENABLED
+		struct Validation {
+			bool active = true; // Means command buffer was not closed, so you can keep adding things.
+			Vector<uint32_t> set_formats;
+			Vector<bool> set_bound;
+			Vector<RID> set_rids;
+			// Last pipeline set values.
+			bool pipeline_active = false;
+			RID pipeline_shader;
+			uint32_t pipeline_spirv_push_constant_size = 0;
+			bool pipeline_push_constant_supplied = false;
+		} validation;
+#endif
+	};
+
+	ComputeList *compute_list = nullptr;
+
+	/**************************/
+	/**** FRAME MANAGEMENT ****/
+	/**************************/
+
+	// This is the frame structure. There are normally
+	// 3 of these (used for triple buffering), or 2
+	// (double buffering). They are cycled constantly.
+	//
+	// It contains two command buffers, one that is
+	// used internally for setting up (creating stuff)
+	// and another used mostly for drawing.
+	//
+	// They also contains a list of things that need
+	// to be disposed of when deleted, which can't
+	// happen immediately due to the asynchronous
+	// nature of the GPU. They will get deleted
+	// when the frame is cycled.
+
+	struct Frame {
+		// List in usage order, from last to free to first to free.
+		List<Buffer> buffers_to_dispose_of;
+		List<Texture> textures_to_dispose_of;
+		List<Framebuffer> framebuffers_to_dispose_of;
+		List<Shader> shaders_to_dispose_of;
+		List<RenderPipeline> render_pipelines_to_dispose_of;
+		List<ComputePipeline> compute_pipelines_to_dispose_of;
+		struct {
+			DescriptorsHeap resources;
+			DescriptorsHeap samplers;
+			DescriptorsHeap aux;
+			DescriptorsHeap rtv;
+		} desc_heaps;
+		struct {
+			DescriptorsHeap::Walker resources;
+			DescriptorsHeap::Walker samplers;
+			DescriptorsHeap::Walker aux;
+			DescriptorsHeap::Walker rtv;
+		} desc_heap_walkers;
+		struct {
+			bool resources;
+			bool samplers;
+			bool aux;
+			bool rtv;
+		} desc_heaps_exhausted_reported;
+		CD3DX12_CPU_DESCRIPTOR_HANDLE null_rtv_handle = {}; // For [[MANUAL_SUBPASSES]].
+
+		ComPtr<ID3D12CommandAllocator> setup_command_allocator;
+		ComPtr<ID3D12CommandAllocator> draw_command_allocator;
+		ComPtr<ID3D12GraphicsCommandList> setup_command_list; // Used at the beginning of every frame for set-up.
+		ComPtr<ID3D12GraphicsCommandList> draw_command_list;
+
+		struct Timestamp {
+			String description;
+			uint64_t value = 0;
+		};
+
+		ComPtr<ID3D12QueryHeap> timestamp_heap;
+
+		TightLocalVector<String> timestamp_names;
+		TightLocalVector<uint64_t> timestamp_cpu_values;
+		uint32_t timestamp_count = 0;
+		TightLocalVector<String> timestamp_result_names;
+		TightLocalVector<uint64_t> timestamp_cpu_result_values;
+		Buffer timestamp_result_values_buffer;
+		TightLocalVector<uint64_t> timestamp_result_values;
+		uint32_t timestamp_result_count = 0;
+		uint64_t index = 0;
+		uint64_t execution_index = 0;
+#ifdef DEV_ENABLED
+		uint32_t uniform_set_reused = 0;
+#endif
+	};
+
+	uint32_t max_timestamp_query_elements = 0;
+
+	TightLocalVector<Frame> frames; // Frames available, for main device they are cycled (usually 3), for local devices only 1.
+	int frame = 0; // Current frame.
+	int frame_count = 0; // Total amount of frames.
+	uint64_t frames_drawn = 0;
+	uint32_t execution_index = 0; // Gets incremented on every call to ExecuteCommandLists (each frame and each flush).
+	RID local_device;
+	bool local_device_processing = false;
+
+	void _free_pending_resources(int p_frame);
+
+//#define USE_SMALL_ALLOCS_POOL // Disabled by now; seems not to be beneficial as it is in Vulkan.
+#ifdef USE_SMALL_ALLOCS_POOL
+	union AllocPoolKey {
+		struct {
+			D3D12_HEAP_TYPE heap_type;
+			D3D12_HEAP_FLAGS heap_flags;
+		};
+		uint64_t key;
+	};
+	HashMap<uint64_t, ComPtr<D3D12MA::Pool>> small_allocs_pools;
+	D3D12MA::Pool *_find_or_create_small_allocs_pool(D3D12_HEAP_TYPE p_heap_type, D3D12_HEAP_FLAGS p_heap_flags);
+#endif
+
+	ComPtr<ID3D12CommandSignature> indirect_dispatch_cmd_sig;
+	RID aux_resource; // Used for causing full barriers.
+
+	D3D12Context *context = nullptr;
+
+	uint64_t image_memory = 0;
+	uint64_t buffer_memory = 0;
+
+	void _free_internal(RID p_id);
+	void _flush(bool p_flush_current_frame);
+
+	bool screen_prepared = false;
+
+	template <class T>
+	void _free_rids(T &p_owner, const char *p_type);
+
+	void _finalize_command_bufers();
+	void _begin_frame();
+
+#ifdef DEV_ENABLED
+	HashMap<RID, String> resource_names;
+#endif
+
+	HashMap<DXGI_FORMAT, uint32_t> format_sample_counts_mask_cache;
+	uint32_t _find_max_common_supported_sample_count(const DXGI_FORMAT *p_formats, uint32_t p_num_formats);
+
+public:
+	virtual RID texture_create(const TextureFormat &p_format, const TextureView &p_view, const Vector<Vector<uint8_t>> &p_data = Vector<Vector<uint8_t>>());
+	virtual RID texture_create_shared(const TextureView &p_view, RID p_with_texture);
+	virtual RID texture_create_from_extension(TextureType p_type, DataFormat p_format, TextureSamples p_samples, BitField<RenderingDevice::TextureUsageBits> p_flags, uint64_t p_image, uint64_t p_width, uint64_t p_height, uint64_t p_depth, uint64_t p_layers);
+
+	virtual RID texture_create_shared_from_slice(const TextureView &p_view, RID p_with_texture, uint32_t p_layer, uint32_t p_mipmap, uint32_t p_mipmaps = 1, TextureSliceType p_slice_type = TEXTURE_SLICE_2D, uint32_t p_layers = 0);
+	virtual Error texture_update(RID p_texture, uint32_t p_layer, const Vector<uint8_t> &p_data, BitField<BarrierMask> p_post_barrier = BARRIER_MASK_ALL_BARRIERS);
+	virtual Vector<uint8_t> texture_get_data(RID p_texture, uint32_t p_layer);
+
+	virtual bool texture_is_format_supported_for_usage(DataFormat p_format, BitField<RenderingDevice::TextureUsageBits> p_usage) const;
+	virtual bool texture_is_shared(RID p_texture);
+	virtual bool texture_is_valid(RID p_texture);
+	virtual TextureFormat texture_get_format(RID p_texture);
+	virtual Size2i texture_size(RID p_texture);
+	virtual uint64_t texture_get_native_handle(RID p_texture);
+
+	virtual Error texture_copy(RID p_from_texture, RID p_to_texture, const Vector3 &p_from, const Vector3 &p_to, const Vector3 &p_size, uint32_t p_src_mipmap, uint32_t p_dst_mipmap, uint32_t p_src_layer, uint32_t p_dst_layer, BitField<BarrierMask> p_post_barrier = BARRIER_MASK_ALL_BARRIERS);
+	virtual Error texture_clear(RID p_texture, const Color &p_color, uint32_t p_base_mipmap, uint32_t p_mipmaps, uint32_t p_base_layer, uint32_t p_layers, BitField<BarrierMask> p_post_barrier = BARRIER_MASK_ALL_BARRIERS);
+	virtual Error texture_resolve_multisample(RID p_from_texture, RID p_to_texture, BitField<BarrierMask> p_post_barrier = BARRIER_MASK_ALL_BARRIERS);
+
+	/*********************/
+	/**** FRAMEBUFFER ****/
+	/*********************/
+
+	virtual FramebufferFormatID framebuffer_format_create(const Vector<AttachmentFormat> &p_format, uint32_t p_view_count = 1);
+	virtual FramebufferFormatID framebuffer_format_create_multipass(const Vector<AttachmentFormat> &p_attachments, const Vector<FramebufferPass> &p_passes, uint32_t p_view_count = 1);
+	virtual FramebufferFormatID framebuffer_format_create_empty(TextureSamples p_samples = TEXTURE_SAMPLES_1);
+	virtual TextureSamples framebuffer_format_get_texture_samples(FramebufferFormatID p_format, uint32_t p_pass = 0);
+
+	virtual RID framebuffer_create(const Vector<RID> &p_texture_attachments, FramebufferFormatID p_format_check = INVALID_ID, uint32_t p_view_count = 1);
+	virtual RID framebuffer_create_multipass(const Vector<RID> &p_texture_attachments, const Vector<FramebufferPass> &p_passes, FramebufferFormatID p_format_check = INVALID_ID, uint32_t p_view_count = 1);
+	virtual RID framebuffer_create_empty(const Size2i &p_size, TextureSamples p_samples = TEXTURE_SAMPLES_1, FramebufferFormatID p_format_check = INVALID_ID);
+	virtual bool framebuffer_is_valid(RID p_framebuffer) const;
+	virtual void framebuffer_set_invalidation_callback(RID p_framebuffer, InvalidationCallback p_callback, void *p_userdata);
+
+	virtual FramebufferFormatID framebuffer_get_format(RID p_framebuffer);
+
+	/*****************/
+	/**** SAMPLER ****/
+	/*****************/
+
+	virtual RID sampler_create(const SamplerState &p_state);
+	virtual bool sampler_is_format_supported_for_filter(DataFormat p_format, SamplerFilter p_sampler_filter) const;
+
+	/**********************/
+	/**** VERTEX ARRAY ****/
+	/**********************/
+
+	virtual RID vertex_buffer_create(uint32_t p_size_bytes, const Vector<uint8_t> &p_data = Vector<uint8_t>(), bool p_use_as_storage = false);
+
+	// Internally reference counted, this ID is warranted to be unique for the same description, but needs to be freed as many times as it was allocated.
+	virtual VertexFormatID vertex_format_create(const Vector<VertexAttribute> &p_vertex_formats);
+	virtual RID vertex_array_create(uint32_t p_vertex_count, VertexFormatID p_vertex_format, const Vector<RID> &p_src_buffers, const Vector<uint64_t> &p_offsets = Vector<uint64_t>());
+
+	virtual RID index_buffer_create(uint32_t p_size_indices, IndexBufferFormat p_format, const Vector<uint8_t> &p_data = Vector<uint8_t>(), bool p_use_restart_indices = false);
+
+	virtual RID index_array_create(RID p_index_buffer, uint32_t p_index_offset, uint32_t p_index_count);
+
+	/****************/
+	/**** SHADER ****/
+	/****************/
+
+	virtual String shader_get_binary_cache_key() const;
+	virtual Vector<uint8_t> shader_compile_binary_from_spirv(const Vector<ShaderStageSPIRVData> &p_spirv, const String &p_shader_name = "");
+
+	virtual RID shader_create_from_bytecode(const Vector<uint8_t> &p_shader_binary, RID p_placeholder = RID());
+	virtual RID shader_create_placeholder();
+
+	virtual uint64_t shader_get_vertex_input_attribute_mask(RID p_shader);
+
+	/*****************/
+	/**** UNIFORM ****/
+	/*****************/
+
+	virtual RID uniform_buffer_create(uint32_t p_size_bytes, const Vector<uint8_t> &p_data = Vector<uint8_t>());
+	virtual RID storage_buffer_create(uint32_t p_size_bytes, const Vector<uint8_t> &p_data = Vector<uint8_t>(), BitField<StorageBufferUsage> p_usage = 0);
+	virtual RID texture_buffer_create(uint32_t p_size_elements, DataFormat p_format, const Vector<uint8_t> &p_data = Vector<uint8_t>());
+
+	virtual RID uniform_set_create(const Vector<Uniform> &p_uniforms, RID p_shader, uint32_t p_shader_set);
+	virtual bool uniform_set_is_valid(RID p_uniform_set);
+	virtual void uniform_set_set_invalidation_callback(RID p_uniform_set, InvalidationCallback p_callback, void *p_userdata);
+
+	virtual Error buffer_copy(RID p_src_buffer, RID p_dst_buffer, uint32_t p_src_offset, uint32_t p_dst_offset, uint32_t p_size, BitField<BarrierMask> p_post_barrier = BARRIER_MASK_ALL_BARRIERS);
+	virtual Error buffer_update(RID p_buffer, uint32_t p_offset, uint32_t p_size, const void *p_data, BitField<BarrierMask> p_post_barrier = BARRIER_MASK_ALL_BARRIERS); // Works for any buffer.
+	virtual Error buffer_clear(RID p_buffer, uint32_t p_offset, uint32_t p_size, BitField<BarrierMask> p_post_barrier = BARRIER_MASK_ALL_BARRIERS);
+	virtual Vector<uint8_t> buffer_get_data(RID p_buffer, uint32_t p_offset = 0, uint32_t p_size = 0);
+
+	/*************************/
+	/**** RENDER PIPELINE ****/
+	/*************************/
+
+	virtual RID render_pipeline_create(RID p_shader, FramebufferFormatID p_framebuffer_format, VertexFormatID p_vertex_format, RenderPrimitive p_render_primitive, const PipelineRasterizationState &p_rasterization_state, const PipelineMultisampleState &p_multisample_state, const PipelineDepthStencilState &p_depth_stencil_state, const PipelineColorBlendState &p_blend_state, BitField<PipelineDynamicStateFlags> p_dynamic_state_flags = 0, uint32_t p_for_render_pass = 0, const Vector<PipelineSpecializationConstant> &p_specialization_constants = Vector<PipelineSpecializationConstant>());
+	virtual bool render_pipeline_is_valid(RID p_pipeline);
+
+	/**************************/
+	/**** COMPUTE PIPELINE ****/
+	/**************************/
+
+	virtual RID compute_pipeline_create(RID p_shader, const Vector<PipelineSpecializationConstant> &p_specialization_constants = Vector<PipelineSpecializationConstant>());
+	virtual bool compute_pipeline_is_valid(RID p_pipeline);
+
+	/****************/
+	/**** SCREEN ****/
+	/****************/
+
+	virtual int screen_get_width(DisplayServer::WindowID p_screen = 0) const;
+	virtual int screen_get_height(DisplayServer::WindowID p_screen = 0) const;
+	virtual FramebufferFormatID screen_get_framebuffer_format() const;
+
+	/********************/
+	/**** DRAW LISTS ****/
+	/********************/
+
+	virtual DrawListID draw_list_begin_for_screen(DisplayServer::WindowID p_screen = 0, const Color &p_clear_color = Color());
+	virtual DrawListID draw_list_begin(RID p_framebuffer, InitialAction p_initial_color_action, FinalAction p_final_color_action, InitialAction p_initial_depth_action, FinalAction p_final_depth_action, const Vector<Color> &p_clear_color_values = Vector<Color>(), float p_clear_depth = 1.0, uint32_t p_clear_stencil = 0, const Rect2 &p_region = Rect2(), const Vector<RID> &p_storage_textures = Vector<RID>());
+	virtual Error draw_list_begin_split(RID p_framebuffer, uint32_t p_splits, DrawListID *r_split_ids, InitialAction p_initial_color_action, FinalAction p_final_color_action, InitialAction p_initial_depth_action, FinalAction p_final_depth_action, const Vector<Color> &p_clear_color_values = Vector<Color>(), float p_clear_depth = 1.0, uint32_t p_clear_stencil = 0, const Rect2 &p_region = Rect2(), const Vector<RID> &p_storage_textures = Vector<RID>());
+
+	virtual void draw_list_set_blend_constants(DrawListID p_list, const Color &p_color);
+	virtual void draw_list_bind_render_pipeline(DrawListID p_list, RID p_render_pipeline);
+	virtual void draw_list_bind_uniform_set(DrawListID p_list, RID p_uniform_set, uint32_t p_index);
+	virtual void draw_list_bind_vertex_array(DrawListID p_list, RID p_vertex_array);
+	virtual void draw_list_bind_index_array(DrawListID p_list, RID p_index_array);
+	virtual void draw_list_set_line_width(DrawListID p_list, float p_width);
+	virtual void draw_list_set_push_constant(DrawListID p_list, const void *p_data, uint32_t p_data_size);
+
+	virtual void draw_list_draw(DrawListID p_list, bool p_use_indices, uint32_t p_instances = 1, uint32_t p_procedural_vertices = 0);
+
+	virtual void draw_list_enable_scissor(DrawListID p_list, const Rect2 &p_rect);
+	virtual void draw_list_disable_scissor(DrawListID p_list);
+
+	virtual uint32_t draw_list_get_current_pass();
+	virtual DrawListID draw_list_switch_to_next_pass();
+	virtual Error draw_list_switch_to_next_pass_split(uint32_t p_splits, DrawListID *r_split_ids);
+
+	virtual void draw_list_end(BitField<BarrierMask> p_post_barrier = BARRIER_MASK_ALL_BARRIERS);
+
+	/***********************/
+	/**** COMPUTE LISTS ****/
+	/***********************/
+
+	virtual ComputeListID compute_list_begin(bool p_allow_draw_overlap = false);
+	virtual void compute_list_bind_compute_pipeline(ComputeListID p_list, RID p_compute_pipeline);
+	virtual void compute_list_bind_uniform_set(ComputeListID p_list, RID p_uniform_set, uint32_t p_index);
+	virtual void compute_list_set_push_constant(ComputeListID p_list, const void *p_data, uint32_t p_data_size);
+	virtual void compute_list_add_barrier(ComputeListID p_list);
+
+	virtual void compute_list_dispatch(ComputeListID p_list, uint32_t p_x_groups, uint32_t p_y_groups, uint32_t p_z_groups);
+	virtual void compute_list_dispatch_threads(ComputeListID p_list, uint32_t p_x_threads, uint32_t p_y_threads, uint32_t p_z_threads);
+	virtual void compute_list_dispatch_indirect(ComputeListID p_list, RID p_buffer, uint32_t p_offset);
+	virtual void compute_list_end(BitField<BarrierMask> p_post_barrier = BARRIER_MASK_ALL_BARRIERS);
+
+	virtual void barrier(BitField<BarrierMask> p_from = BARRIER_MASK_ALL_BARRIERS, BitField<BarrierMask> p_to = BARRIER_MASK_ALL_BARRIERS);
+	virtual void full_barrier();
+
+	/**************/
+	/**** FREE ****/
+	/**************/
+
+	virtual void free(RID p_id);
+
+	/****************/
+	/**** Timing ****/
+	/****************/
+
+	virtual void capture_timestamp(const String &p_name);
+	virtual uint32_t get_captured_timestamps_count() const;
+	virtual uint64_t get_captured_timestamps_frame() const;
+	virtual uint64_t get_captured_timestamp_gpu_time(uint32_t p_index) const;
+	virtual uint64_t get_captured_timestamp_cpu_time(uint32_t p_index) const;
+	virtual String get_captured_timestamp_name(uint32_t p_index) const;
+
+	/****************/
+	/**** Limits ****/
+	/****************/
+
+	virtual uint64_t limit_get(Limit p_limit) const;
+
+	virtual void prepare_screen_for_drawing();
+
+	void initialize(D3D12Context *p_context, bool p_local_device = false);
+	void finalize();
+
+	virtual void swap_buffers(); // For main device.
+
+	virtual void submit(); // For local device.
+	virtual void sync(); // For local device.
+
+	virtual uint32_t get_frame_delay() const;
+
+	virtual RenderingDevice *create_local_device();
+
+	virtual uint64_t get_memory_usage(MemoryType p_type) const;
+
+	virtual void set_resource_name(RID p_id, const String p_name);
+
+	virtual void draw_command_begin_label(String p_label_name, const Color p_color = Color(1, 1, 1, 1));
+	virtual void draw_command_insert_label(String p_label_name, const Color p_color = Color(1, 1, 1, 1));
+	virtual void draw_command_end_label();
+
+	virtual String get_device_vendor_name() const;
+	virtual String get_device_name() const;
+	virtual RenderingDevice::DeviceType get_device_type() const;
+	virtual String get_device_api_version() const;
+	virtual String get_device_pipeline_cache_uuid() const;
+
+	virtual uint64_t get_driver_resource(DriverResource p_resource, RID p_rid = RID(), uint64_t p_index = 0);
+
+	virtual bool has_feature(const Features p_feature) const;
+
+	RenderingDeviceD3D12();
+	~RenderingDeviceD3D12();
+};
+
+#endif // RENDERING_DEVICE_D3D12_H
diff --git a/main/main.cpp b/main/main.cpp
index 281ef9a0d6..a36ac63f07 100644
--- a/main/main.cpp
+++ b/main/main.cpp
@@ -1732,15 +1732,27 @@ Error Main::setup(const char *execpath, int argc, char *argv[], bool p_second_ph
 
 	{
 		String driver_hints = "";
+		String driver_hints_with_d3d12 = "";
+
+		{
+			Vector<String> driver_hints_arr;
 #ifdef VULKAN_ENABLED
-		driver_hints = "vulkan";
+			driver_hints_arr.push_back("vulkan");
+#endif
+			driver_hints = String(",").join(driver_hints_arr);
+
+#ifdef D3D12_ENABLED
+			driver_hints_arr.push_back("d3d12");
 #endif
+			driver_hints_with_d3d12 = String(",").join(driver_hints_arr);
+		}
 
 		String default_driver = driver_hints.get_slice(",", 0);
+		String default_driver_with_d3d12 = driver_hints_with_d3d12.get_slice(",", 0);
 
 		// For now everything defaults to vulkan when available. This can change in future updates.
 		GLOBAL_DEF_RST_NOVAL("rendering/rendering_device/driver", default_driver);
-		GLOBAL_DEF_RST_NOVAL(PropertyInfo(Variant::STRING, "rendering/rendering_device/driver.windows", PROPERTY_HINT_ENUM, driver_hints), default_driver);
+		GLOBAL_DEF_RST_NOVAL(PropertyInfo(Variant::STRING, "rendering/rendering_device/driver.windows", PROPERTY_HINT_ENUM, driver_hints_with_d3d12), default_driver_with_d3d12);
 		GLOBAL_DEF_RST_NOVAL(PropertyInfo(Variant::STRING, "rendering/rendering_device/driver.linuxbsd", PROPERTY_HINT_ENUM, driver_hints), default_driver);
 		GLOBAL_DEF_RST_NOVAL(PropertyInfo(Variant::STRING, "rendering/rendering_device/driver.android", PROPERTY_HINT_ENUM, driver_hints), default_driver);
 		GLOBAL_DEF_RST_NOVAL(PropertyInfo(Variant::STRING, "rendering/rendering_device/driver.ios", PROPERTY_HINT_ENUM, driver_hints), default_driver);
@@ -1798,7 +1810,7 @@ Error Main::setup(const char *execpath, int argc, char *argv[], bool p_second_ph
 	}
 
 	// Start with RenderingDevice-based backends. Should be included if any RD driver present.
-#ifdef VULKAN_ENABLED
+#if defined(VULKAN_ENABLED) || defined(D3D12_ENABLED)
 	renderer_hints = "forward_plus,mobile";
 	default_renderer_mobile = "mobile";
 #endif
@@ -1878,11 +1890,14 @@ Error Main::setup(const char *execpath, int argc, char *argv[], bool p_second_ph
 		// Now validate whether the selected driver matches with the renderer.
 		bool valid_combination = false;
 		Vector<String> available_drivers;
-#ifdef VULKAN_ENABLED
 		if (rendering_method == "forward_plus" || rendering_method == "mobile") {
+#ifdef VULKAN_ENABLED
 			available_drivers.push_back("vulkan");
-		}
 #endif
+#ifdef D3D12_ENABLED
+			available_drivers.push_back("d3d12");
+#endif
+		}
 #ifdef GLES3_ENABLED
 		if (rendering_method == "gl_compatibility") {
 			available_drivers.push_back("opengl3");
diff --git a/modules/glslang/register_types.cpp b/modules/glslang/register_types.cpp
index 7fe3a57880..d7e5ddd32c 100644
--- a/modules/glslang/register_types.cpp
+++ b/modules/glslang/register_types.cpp
@@ -67,6 +67,13 @@ static Vector<uint8_t> _compile_shader_glsl(RenderingDevice::ShaderStage p_stage
 		} else {
 			// use defaults
 		}
+	} else if (capabilities->device_family == RenderingDevice::DeviceFamily::DEVICE_DIRECTX) {
+		// NIR-DXIL is Vulkan 1.1-conformant.
+		ClientVersion = glslang::EShTargetVulkan_1_1;
+		// The SPIR-V part of Mesa supports 1.6, but:
+		// - SPIRV-Reflect won't be able to parse the compute workgroup size.
+		// - We want to play it safe with NIR-DXIL.
+		TargetVersion = glslang::EShTargetSpv_1_3;
 	} else {
 		// once we support other backends we'll need to do something here
 		if (r_error) {
diff --git a/platform/android/display_server_android.cpp b/platform/android/display_server_android.cpp
index dd5ab46bd7..9529e0e683 100644
--- a/platform/android/display_server_android.cpp
+++ b/platform/android/display_server_android.cpp
@@ -486,6 +486,9 @@ Vector<String> DisplayServerAndroid::get_rendering_drivers_func() {
 #ifdef GLES3_ENABLED
 	drivers.push_back("opengl3");
 #endif
+#ifdef D3D12_ENABLED
+	drivers.push_back("d3d12");
+#endif
 #ifdef VULKAN_ENABLED
 	drivers.push_back("vulkan");
 #endif
diff --git a/platform/windows/SCsub b/platform/windows/SCsub
index 1b6908d2bb..d880a69d22 100644
--- a/platform/windows/SCsub
+++ b/platform/windows/SCsub
@@ -29,7 +29,9 @@ res_file = "godot_res.rc"
 res_target = "godot_res" + env["OBJSUFFIX"]
 res_obj = env.RES(res_target, res_file)
 
-prog = env.add_program("#bin/godot", common_win + res_obj, PROGSUFFIX=env["PROGSUFFIX"])
+sources = common_win + res_obj
+
+prog = env.add_program("#bin/godot", sources, PROGSUFFIX=env["PROGSUFFIX"])
 
 # Build console wrapper app.
 if env["windows_subsystem"] == "gui":
@@ -58,6 +60,40 @@ if env["vsproj"]:
         for x in common_win_wrap:
             env.vs_srcs += ["platform/windows/" + str(x)]
 
+if env["d3d12"]:
+    arch_subdir = "arm64" if env["arch"] == "arm64" else "x64"
+    # Used in cases where we can have multiple archs side-by-side.
+    arch_bin_dir = "#bin/arm64" if env["arch"] == "arm64" else "#bin/x86_64"
+
+    # DXC
+    if env["dxc_path"] != "":
+        dxc_dll = "dxil.dll"
+        # Whether this one is loaded from arch-specific directory or not can be determined at runtime.
+        # Let's copy to both and let the user decide the distribution model.
+        for v in ["#bin", arch_bin_dir]:
+            env.Command(
+                v + "/" + dxc_dll, env["dxc_path"] + "/bin/" + arch_subdir + "/" + dxc_dll, Copy("$TARGET", "$SOURCE")
+            )
+
+    # Agility SDK
+    if env["agility_sdk_path"] != "":
+        agility_dlls = ["D3D12Core.dll", "d3d12SDKLayers.dll"]
+        # Whether these are loaded from arch-specific directory or not has to be known at build time.
+        target_dir = arch_bin_dir if env["agility_sdk_multiarch"] else "#bin"
+        for dll in agility_dlls:
+            env.Command(
+                target_dir + "/" + dll,
+                env["agility_sdk_path"] + "/build/native/bin/" + arch_subdir + "/" + dll,
+                Copy("$TARGET", "$SOURCE"),
+            )
+
+    # PIX
+    if env["pix_path"] != "":
+        pix_dll = "WinPixEventRuntime.dll"
+        env.Command(
+            "#bin/" + pix_dll, env["pix_path"] + "/bin/" + arch_subdir + "/" + pix_dll, Copy("$TARGET", "$SOURCE")
+        )
+
 if not os.getenv("VCINSTALLDIR"):
     if env["debug_symbols"] and env["separate_debug_symbols"]:
         env.AddPostAction(prog, run_in_subprocess(platform_windows_builders.make_debug_mingw))
diff --git a/platform/windows/detect.py b/platform/windows/detect.py
index bdacdbb9ba..8c6e8a86ab 100644
--- a/platform/windows/detect.py
+++ b/platform/windows/detect.py
@@ -187,6 +187,12 @@ def get_opts():
         BoolVariable("debug_crt", "Compile with MSVC's debug CRT (/MDd)", False),
         BoolVariable("incremental_link", "Use MSVC incremental linking. May increase or decrease build times.", False),
         ("angle_libs", "Path to the ANGLE static libraries", ""),
+        # Direct3D 12 support.
+        ("mesa_libs", "Path to the MESA/NIR static libraries (required for D3D12)", ""),
+        ("dxc_path", "Path to the DirectX Shader Compiler distribution (required for D3D12)", ""),
+        ("agility_sdk_path", "Path to the Agility SDK distribution (optional for D3D12)", ""),
+        ("agility_sdk_multiarch", "Whether the Agility SDK DLLs will be stored in arch-specific subdirectories", False),
+        ("pix_path", "Path to the PIX runtime distribution (optional for D3D12)", ""),
     ]
 
 
@@ -430,6 +436,34 @@ def configure_msvc(env, vcvars_msvc_config):
         if not env["use_volk"]:
             LIBS += ["vulkan"]
 
+    if env["d3d12"]:
+        if env["dxc_path"] == "":
+            print("The Direct3D 12 rendering driver requires dxc_path to be set.")
+            sys.exit(255)
+
+        env.AppendUnique(CPPDEFINES=["D3D12_ENABLED"])
+        LIBS += ["d3d12", "dxgi", "dxguid"]
+        LIBS += ["version"]  # Mesa dependency.
+
+        # Needed for avoiding C1128.
+        if env["target"] == "release_debug":
+            env.Append(CXXFLAGS=["/bigobj"])
+
+        arch_subdir = "arm64" if env["arch"] == "arm64" else "x64"
+
+        # PIX
+        if env["pix_path"] != "":
+            env.Append(LIBPATH=[env["pix_path"] + "/bin/" + arch_subdir])
+            LIBS += ["WinPixEventRuntime"]
+
+        # Mesa
+        if env["mesa_libs"] == "":
+            print("The Direct3D 12 rendering driver requires mesa_libs to be set.")
+            sys.exit(255)
+
+        env.Append(LIBPATH=[env["mesa_libs"] + "/bin"])
+        LIBS += ["libNIR.windows." + env["arch"]]
+
     if env["opengl3"]:
         env.AppendUnique(CPPDEFINES=["GLES3_ENABLED"])
         if env["angle_libs"] != "":
@@ -623,6 +657,26 @@ def configure_mingw(env):
         if not env["use_volk"]:
             env.Append(LIBS=["vulkan"])
 
+    if env["d3d12"]:
+        env.AppendUnique(CPPDEFINES=["D3D12_ENABLED"])
+        env.Append(LIBS=["d3d12", "dxgi", "dxguid"])
+        env.Append(LIBS=["version"])  # Mesa dependency.
+
+        arch_subdir = "arm64" if env["arch"] == "arm64" else "x64"
+
+        # PIX
+        if env["pix_path"] != "":
+            print("PIX runtime is not supported with MinGW.")
+            sys.exit(255)
+
+        # Mesa
+        if env["mesa_libs"] == "":
+            print("The Direct3D 12 rendering driver requires mesa_libs to be set.")
+            sys.exit(255)
+
+        env.Append(LIBPATH=[env["mesa_libs"] + "/bin"])
+        env.Append(LIBS=["libNIR.windows." + env["arch"]])
+
     if env["opengl3"]:
         env.Append(CPPDEFINES=["GLES3_ENABLED"])
         if env["angle_libs"] != "":
diff --git a/platform/windows/display_server_windows.cpp b/platform/windows/display_server_windows.cpp
index e8d81405f0..9e398473c1 100644
--- a/platform/windows/display_server_windows.cpp
+++ b/platform/windows/display_server_windows.cpp
@@ -1107,6 +1107,11 @@ void DisplayServerWindows::delete_sub_window(WindowID p_window) {
 		context_vulkan->window_destroy(p_window);
 	}
 #endif
+#ifdef D3D12_ENABLED
+	if (context_d3d12) {
+		context_d3d12->window_destroy(p_window);
+	}
+#endif
 #ifdef GLES3_ENABLED
 	if (gl_manager_angle) {
 		gl_manager_angle->window_destroy(p_window);
@@ -1539,6 +1544,11 @@ void DisplayServerWindows::window_set_size(const Size2i p_size, WindowID p_windo
 		context_vulkan->window_resize(p_window, w, h);
 	}
 #endif
+#if defined(D3D12_ENABLED)
+	if (context_d3d12) {
+		context_d3d12->window_resize(p_window, w, h);
+	}
+#endif
 #if defined(GLES3_ENABLED)
 	if (gl_manager_native) {
 		gl_manager_native->window_resize(p_window, w, h);
@@ -2590,6 +2600,12 @@ void DisplayServerWindows::window_set_vsync_mode(DisplayServer::VSyncMode p_vsyn
 	}
 #endif
 
+#if defined(D3D12_ENABLED)
+	if (context_d3d12) {
+		context_d3d12->set_vsync_mode(p_window, p_vsync_mode);
+	}
+#endif
+
 #if defined(GLES3_ENABLED)
 	if (gl_manager_native) {
 		gl_manager_native->set_use_vsync(p_window, p_vsync_mode != DisplayServer::VSYNC_DISABLED);
@@ -2608,6 +2624,12 @@ DisplayServer::VSyncMode DisplayServerWindows::window_get_vsync_mode(WindowID p_
 	}
 #endif
 
+#if defined(D3D12_ENABLED)
+	if (context_d3d12) {
+		return context_d3d12->get_vsync_mode(p_window);
+	}
+#endif
+
 #if defined(GLES3_ENABLED)
 	if (gl_manager_native) {
 		return gl_manager_native->is_using_vsync(p_window) ? DisplayServer::VSYNC_ENABLED : DisplayServer::VSYNC_DISABLED;
@@ -2616,7 +2638,6 @@ DisplayServer::VSyncMode DisplayServerWindows::window_get_vsync_mode(WindowID p_
 		return gl_manager_angle->is_using_vsync() ? DisplayServer::VSYNC_ENABLED : DisplayServer::VSYNC_DISABLED;
 	}
 #endif
-
 	return DisplayServer::VSYNC_ENABLED;
 }
 
@@ -3769,12 +3790,19 @@ LRESULT DisplayServerWindows::WndProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARA
 
 					rect_changed = true;
 				}
+				// Note: Trigger resize event to update swapchains when window is minimized/restored, even if size is not changed.
+				if (window_created && window.context_created) {
 #if defined(VULKAN_ENABLED)
-				if (context_vulkan && window.context_created) {
-					// Note: Trigger resize event to update swapchains when window is minimized/restored, even if size is not changed.
-					context_vulkan->window_resize(window_id, window.width, window.height);
-				}
+					if (context_vulkan) {
+						context_vulkan->window_resize(window_id, window.width, window.height);
+					}
+#endif
+#if defined(D3D12_ENABLED)
+					if (context_d3d12) {
+						context_d3d12->window_resize(window_id, window.width, window.height);
+					}
 #endif
+				}
 			}
 
 			if (!window.minimized && (!(window_pos_params->flags & SWP_NOMOVE) || window_pos_params->flags & SWP_FRAMECHANGED)) {
@@ -4338,6 +4366,18 @@ DisplayServer::WindowID DisplayServerWindows::_create_window(WindowMode p_mode,
 		}
 #endif
 
+#ifdef D3D12_ENABLED
+		if (context_d3d12) {
+			if (context_d3d12->window_create(id, p_vsync_mode, wd.hWnd, hInstance, WindowRect.right - WindowRect.left, WindowRect.bottom - WindowRect.top) != OK) {
+				memdelete(context_d3d12);
+				context_d3d12 = nullptr;
+				windows.erase(id);
+				ERR_FAIL_V_MSG(INVALID_WINDOW_ID, "Failed to create D3D12 Window.");
+			}
+			wd.context_created = true;
+		}
+#endif
+
 #ifdef GLES3_ENABLED
 		if (gl_manager_native) {
 			if (gl_manager_native->window_create(id, wd.hWnd, hInstance, WindowRect.right - WindowRect.left, WindowRect.bottom - WindowRect.top) != OK) {
@@ -4646,6 +4686,17 @@ DisplayServerWindows::DisplayServerWindows(const String &p_rendering_driver, Win
 		}
 	}
 #endif
+#if defined(D3D12_ENABLED)
+	if (rendering_driver == "d3d12") {
+		context_d3d12 = memnew(D3D12Context);
+		if (context_d3d12->initialize() != OK) {
+			memdelete(context_d3d12);
+			context_d3d12 = nullptr;
+			r_error = ERR_UNAVAILABLE;
+			return;
+		}
+	}
+#endif
 	// Init context and rendering device
 #if defined(GLES3_ENABLED)
 
@@ -4722,7 +4773,6 @@ DisplayServerWindows::DisplayServerWindows(const String &p_rendering_driver, Win
 	show_window(MAIN_WINDOW_ID);
 
 #if defined(VULKAN_ENABLED)
-
 	if (rendering_driver == "vulkan") {
 		rendering_device_vulkan = memnew(RenderingDeviceVulkan);
 		rendering_device_vulkan->initialize(context_vulkan);
@@ -4730,6 +4780,14 @@ DisplayServerWindows::DisplayServerWindows(const String &p_rendering_driver, Win
 		RendererCompositorRD::make_current();
 	}
 #endif
+#if defined(D3D12_ENABLED)
+	if (rendering_driver == "d3d12") {
+		rendering_device_d3d12 = memnew(RenderingDeviceD3D12);
+		rendering_device_d3d12->initialize(context_d3d12);
+
+		RendererCompositorRD::make_current();
+	}
+#endif
 
 	if (!Engine::get_singleton()->is_editor_hint() && !OS::get_singleton()->is_in_low_processor_usage_mode()) {
 		// Increase priority for projects that are not in low-processor mode (typically games)
@@ -4764,6 +4822,9 @@ Vector<String> DisplayServerWindows::get_rendering_drivers_func() {
 #ifdef VULKAN_ENABLED
 	drivers.push_back("vulkan");
 #endif
+#ifdef D3D12_ENABLED
+	drivers.push_back("d3d12");
+#endif
 #ifdef GLES3_ENABLED
 	drivers.push_back("opengl3");
 	drivers.push_back("opengl3_angle");
@@ -4828,6 +4889,11 @@ DisplayServerWindows::~DisplayServerWindows() {
 			context_vulkan->window_destroy(MAIN_WINDOW_ID);
 		}
 #endif
+#ifdef D3D12_ENABLED
+		if (context_d3d12) {
+			context_d3d12->window_destroy(MAIN_WINDOW_ID);
+		}
+#endif
 		if (wintab_available && windows[MAIN_WINDOW_ID].wtctx) {
 			wintab_WTClose(windows[MAIN_WINDOW_ID].wtctx);
 			windows[MAIN_WINDOW_ID].wtctx = 0;
@@ -4848,6 +4914,19 @@ DisplayServerWindows::~DisplayServerWindows() {
 	}
 #endif
 
+#if defined(D3D12_ENABLED)
+	if (rendering_device_d3d12) {
+		rendering_device_d3d12->finalize();
+		memdelete(rendering_device_d3d12);
+		rendering_device_d3d12 = nullptr;
+	}
+
+	if (context_d3d12) {
+		memdelete(context_d3d12);
+		context_d3d12 = nullptr;
+	}
+#endif
+
 	if (restore_mouse_trails > 1) {
 		SystemParametersInfoA(SPI_SETMOUSETRAILS, restore_mouse_trails, 0, 0);
 	}
diff --git a/platform/windows/display_server_windows.h b/platform/windows/display_server_windows.h
index 48c8c20280..1e61462e95 100644
--- a/platform/windows/display_server_windows.h
+++ b/platform/windows/display_server_windows.h
@@ -58,6 +58,10 @@
 #include "drivers/vulkan/rendering_device_vulkan.h"
 #endif
 
+#if defined(D3D12_ENABLED)
+#include "drivers/d3d12/rendering_device_d3d12.h"
+#endif
+
 #if defined(GLES3_ENABLED)
 #include "gl_manager_windows_angle.h"
 #include "gl_manager_windows_native.h"
@@ -347,6 +351,11 @@ class DisplayServerWindows : public DisplayServer {
 	RenderingDeviceVulkan *rendering_device_vulkan = nullptr;
 #endif
 
+#if defined(D3D12_ENABLED)
+	D3D12Context *context_d3d12 = nullptr;
+	RenderingDeviceD3D12 *rendering_device_d3d12 = nullptr;
+#endif
+
 	RBMap<int, Vector2> touch_state;
 
 	int pressrc;
diff --git a/platform/windows/os_windows.h b/platform/windows/os_windows.h
index e873fb8a13..02f062f2de 100644
--- a/platform/windows/os_windows.h
+++ b/platform/windows/os_windows.h
@@ -52,6 +52,10 @@
 #include "drivers/vulkan/rendering_device_vulkan.h"
 #endif
 
+#if defined(D3D12_ENABLED)
+#include "drivers/d3d12/rendering_device_d3d12.h"
+#endif
+
 #include <io.h>
 #include <shellapi.h>
 #include <stdio.h>
diff --git a/thirdparty/README.md b/thirdparty/README.md
index 387308a4ff..824d5d98f7 100644
--- a/thirdparty/README.md
+++ b/thirdparty/README.md
@@ -120,6 +120,31 @@ have been removed as they caused massive quality regressions. Apply the patches
 in the `patches/` folder when syncing on newer upstream commits.
 
 
+## d3d12ma
+
+- Upstream: https://github.com/GPUOpen-LibrariesAndSDKs/D3D12MemoryAllocator
+- Version: 2.1.0-development (4d16e802e0b9451c9d3c27cd308928c13b73acd6, 2023)
+- License: MIT
+
+Files extracted from upstream source:
+
+- `src/D3D12MemAlloc.cpp`, `src/D3D12MemAlloc.natvis`
+- `include/D3D12MemAlloc.h`
+- `LICENSE.txt`, `NOTICES.txt`
+
+
+## directx_headers
+
+- Upstream: https://github.com/microsoft/DirectX-Headers
+- Version: 1.606.3 (fd329244e62201bf959331d28514928fc1d45005, 2022)
+- License: MIT
+
+Files extracted from upstream source:
+
+- `include/directx/*.h`
+- `LICENSE`
+
+
 ## doctest
 
 - Upstream: https://github.com/onqtam/doctest
diff --git a/thirdparty/d3d12ma/D3D12MemAlloc.cpp b/thirdparty/d3d12ma/D3D12MemAlloc.cpp
new file mode 100644
index 0000000000..8e2488091a
--- /dev/null
+++ b/thirdparty/d3d12ma/D3D12MemAlloc.cpp
@@ -0,0 +1,10544 @@
+//
+// Copyright (c) 2019-2022 Advanced Micro Devices, Inc. All rights reserved.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// 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.  IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+//
+
+#include "D3D12MemAlloc.h"
+
+#include <combaseapi.h>
+#include <mutex>
+#include <algorithm>
+#include <utility>
+#include <cstdlib>
+#include <cstdint>
+#include <malloc.h> // for _aligned_malloc, _aligned_free
+#ifndef _WIN32
+    #include <shared_mutex>
+#endif
+
+////////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////
+//
+// Configuration Begin
+//
+////////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////
+#ifndef _D3D12MA_CONFIGURATION
+
+#ifdef _WIN32
+    #if !defined(WINVER) || WINVER < 0x0600
+        #error Required at least WinAPI version supporting: client = Windows Vista, server = Windows Server 2008.
+    #endif
+#endif
+
+#ifndef D3D12MA_SORT
+    #define D3D12MA_SORT(beg, end, cmp)  std::sort(beg, end, cmp)
+#endif
+
+#ifndef D3D12MA_D3D12_HEADERS_ALREADY_INCLUDED
+    #include <dxgi.h>
+    #if D3D12MA_DXGI_1_4
+        #include <dxgi1_4.h>
+    #endif
+#endif
+
+#ifndef D3D12MA_ASSERT
+    #include <cassert>
+    #define D3D12MA_ASSERT(cond) assert(cond)
+#endif
+
+// Assert that will be called very often, like inside data structures e.g. operator[].
+// Making it non-empty can make program slow.
+#ifndef D3D12MA_HEAVY_ASSERT
+    #ifdef _DEBUG
+        #define D3D12MA_HEAVY_ASSERT(expr)   //D3D12MA_ASSERT(expr)
+    #else
+        #define D3D12MA_HEAVY_ASSERT(expr)
+    #endif
+#endif
+
+#ifndef D3D12MA_DEBUG_ALIGNMENT
+    /*
+    Minimum alignment of all allocations, in bytes.
+    Set to more than 1 for debugging purposes only. Must be power of two.
+    */
+    #define D3D12MA_DEBUG_ALIGNMENT (1)
+#endif
+
+#ifndef D3D12MA_DEBUG_MARGIN
+    // Minimum margin before and after every allocation, in bytes.
+    // Set nonzero for debugging purposes only.
+    #define D3D12MA_DEBUG_MARGIN (0)
+#endif
+
+#ifndef D3D12MA_DEBUG_GLOBAL_MUTEX
+    /*
+    Set this to 1 for debugging purposes only, to enable single mutex protecting all
+    entry calls to the library. Can be useful for debugging multithreading issues.
+    */
+    #define D3D12MA_DEBUG_GLOBAL_MUTEX (0)
+#endif
+
+/*
+Define this macro for debugging purposes only to force specific D3D12_RESOURCE_HEAP_TIER,
+especially to test compatibility with D3D12_RESOURCE_HEAP_TIER_1 on modern GPUs.
+*/
+//#define D3D12MA_FORCE_RESOURCE_HEAP_TIER D3D12_RESOURCE_HEAP_TIER_1
+
+#ifndef D3D12MA_DEFAULT_BLOCK_SIZE
+   /// Default size of a block allocated as single ID3D12Heap.
+   #define D3D12MA_DEFAULT_BLOCK_SIZE (64ull * 1024 * 1024)
+#endif
+
+#ifndef D3D12MA_DEBUG_LOG
+   #define D3D12MA_DEBUG_LOG(format, ...)
+   /*
+   #define D3D12MA_DEBUG_LOG(format, ...) do { \
+       wprintf(format, __VA_ARGS__); \
+       wprintf(L"\n"); \
+   } while(false)
+   */
+#endif
+
+#endif // _D3D12MA_CONFIGURATION
+////////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////
+//
+// Configuration End
+//
+////////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////
+
+#define D3D12MA_IID_PPV_ARGS(ppType)   __uuidof(**(ppType)), reinterpret_cast<void**>(ppType)
+
+#ifdef __ID3D12Device8_INTERFACE_DEFINED__
+    #define D3D12MA_CREATE_NOT_ZEROED_AVAILABLE 1
+#endif
+
+namespace D3D12MA
+{
+static constexpr UINT HEAP_TYPE_COUNT = 4;
+static constexpr UINT STANDARD_HEAP_TYPE_COUNT = 3; // Only DEFAULT, UPLOAD, READBACK.
+static constexpr UINT DEFAULT_POOL_MAX_COUNT = 9;
+static const UINT NEW_BLOCK_SIZE_SHIFT_MAX = 3;
+// Minimum size of a free suballocation to register it in the free suballocation collection.
+static const UINT64 MIN_FREE_SUBALLOCATION_SIZE_TO_REGISTER = 16;
+
+static const WCHAR* const HeapTypeNames[] =
+{
+    L"DEFAULT",
+    L"UPLOAD",
+    L"READBACK",
+    L"CUSTOM",
+};
+
+static const D3D12_HEAP_FLAGS RESOURCE_CLASS_HEAP_FLAGS =
+    D3D12_HEAP_FLAG_DENY_BUFFERS | D3D12_HEAP_FLAG_DENY_RT_DS_TEXTURES | D3D12_HEAP_FLAG_DENY_NON_RT_DS_TEXTURES;
+
+static const D3D12_RESIDENCY_PRIORITY D3D12_RESIDENCY_PRIORITY_NONE = D3D12_RESIDENCY_PRIORITY(0);
+
+#ifndef _D3D12MA_ENUM_DECLARATIONS
+
+// Local copy of this enum, as it is provided only by <dxgi1_4.h>, so it may not be available.
+enum DXGI_MEMORY_SEGMENT_GROUP_COPY
+{
+    DXGI_MEMORY_SEGMENT_GROUP_LOCAL_COPY = 0,
+    DXGI_MEMORY_SEGMENT_GROUP_NON_LOCAL_COPY = 1,
+    DXGI_MEMORY_SEGMENT_GROUP_COUNT
+};
+
+enum class ResourceClass
+{
+    Unknown, Buffer, Non_RT_DS_Texture, RT_DS_Texture
+};
+
+enum SuballocationType
+{
+    SUBALLOCATION_TYPE_FREE = 0,
+    SUBALLOCATION_TYPE_ALLOCATION = 1,
+};
+
+#endif // _D3D12MA_ENUM_DECLARATIONS
+
+
+#ifndef _D3D12MA_FUNCTIONS
+
+static void* DefaultAllocate(size_t Size, size_t Alignment, void* /*pPrivateData*/)
+{
+#ifdef _WIN32
+    return _aligned_malloc(Size, Alignment);
+#else
+    return aligned_alloc(Alignment, Size);
+#endif
+}
+static void DefaultFree(void* pMemory, void* /*pPrivateData*/)
+{
+#ifdef _WIN32
+    return _aligned_free(pMemory);
+#else
+    return free(pMemory);
+#endif
+}
+
+static void* Malloc(const ALLOCATION_CALLBACKS& allocs, size_t size, size_t alignment)
+{
+    void* const result = (*allocs.pAllocate)(size, alignment, allocs.pPrivateData);
+    D3D12MA_ASSERT(result);
+    return result;
+}
+static void Free(const ALLOCATION_CALLBACKS& allocs, void* memory)
+{
+    (*allocs.pFree)(memory, allocs.pPrivateData);
+}
+
+template<typename T>
+static T* Allocate(const ALLOCATION_CALLBACKS& allocs)
+{
+    return (T*)Malloc(allocs, sizeof(T), __alignof(T));
+}
+template<typename T>
+static T* AllocateArray(const ALLOCATION_CALLBACKS& allocs, size_t count)
+{
+    return (T*)Malloc(allocs, sizeof(T) * count, __alignof(T));
+}
+
+#define D3D12MA_NEW(allocs, type) new(D3D12MA::Allocate<type>(allocs))(type)
+#define D3D12MA_NEW_ARRAY(allocs, type, count) new(D3D12MA::AllocateArray<type>((allocs), (count)))(type)
+
+template<typename T>
+void D3D12MA_DELETE(const ALLOCATION_CALLBACKS& allocs, T* memory)
+{
+    if (memory)
+    {
+        memory->~T();
+        Free(allocs, memory);
+    }
+}
+template<typename T>
+void D3D12MA_DELETE_ARRAY(const ALLOCATION_CALLBACKS& allocs, T* memory, size_t count)
+{
+    if (memory)
+    {
+        for (size_t i = count; i--; )
+        {
+            memory[i].~T();
+        }
+        Free(allocs, memory);
+    }
+}
+
+static void SetupAllocationCallbacks(ALLOCATION_CALLBACKS& outAllocs, const ALLOCATION_CALLBACKS* allocationCallbacks)
+{
+    if (allocationCallbacks)
+    {
+        outAllocs = *allocationCallbacks;
+        D3D12MA_ASSERT(outAllocs.pAllocate != NULL && outAllocs.pFree != NULL);
+    }
+    else
+    {
+        outAllocs.pAllocate = &DefaultAllocate;
+        outAllocs.pFree = &DefaultFree;
+        outAllocs.pPrivateData = NULL;
+    }
+}
+
+#define SAFE_RELEASE(ptr)   do { if(ptr) { (ptr)->Release(); (ptr) = NULL; } } while(false)
+
+#define D3D12MA_VALIDATE(cond) do { if(!(cond)) { \
+    D3D12MA_ASSERT(0 && "Validation failed: " #cond); \
+    return false; \
+} } while(false)
+
+template<typename T>
+static T D3D12MA_MIN(const T& a, const T& b) { return a <= b ? a : b; }
+template<typename T>
+static T D3D12MA_MAX(const T& a, const T& b) { return a <= b ? b : a; }
+
+template<typename T>
+static void D3D12MA_SWAP(T& a, T& b) { T tmp = a; a = b; b = tmp; }
+
+// Scans integer for index of first nonzero bit from the Least Significant Bit (LSB). If mask is 0 then returns UINT8_MAX
+static UINT8 BitScanLSB(UINT64 mask)
+{
+#if defined(_MSC_VER) && defined(_WIN64)
+    unsigned long pos;
+    if (_BitScanForward64(&pos, mask))
+        return static_cast<UINT8>(pos);
+    return UINT8_MAX;
+#elif defined __GNUC__ || defined __clang__
+    return static_cast<UINT8>(__builtin_ffsll(mask)) - 1U;
+#else
+    UINT8 pos = 0;
+    UINT64 bit = 1;
+    do
+    {
+        if (mask & bit)
+            return pos;
+        bit <<= 1;
+    } while (pos++ < 63);
+    return UINT8_MAX;
+#endif
+}
+// Scans integer for index of first nonzero bit from the Least Significant Bit (LSB). If mask is 0 then returns UINT8_MAX
+static UINT8 BitScanLSB(UINT32 mask)
+{
+#ifdef _MSC_VER
+    unsigned long pos;
+    if (_BitScanForward(&pos, mask))
+        return static_cast<UINT8>(pos);
+    return UINT8_MAX;
+#elif defined __GNUC__ || defined __clang__
+    return static_cast<UINT8>(__builtin_ffs(mask)) - 1U;
+#else
+    UINT8 pos = 0;
+    UINT32 bit = 1;
+    do
+    {
+        if (mask & bit)
+            return pos;
+        bit <<= 1;
+    } while (pos++ < 31);
+    return UINT8_MAX;
+#endif
+}
+
+// Scans integer for index of first nonzero bit from the Most Significant Bit (MSB). If mask is 0 then returns UINT8_MAX
+static UINT8 BitScanMSB(UINT64 mask)
+{
+#if defined(_MSC_VER) && defined(_WIN64)
+    unsigned long pos;
+    if (_BitScanReverse64(&pos, mask))
+        return static_cast<UINT8>(pos);
+#elif defined __GNUC__ || defined __clang__
+    if (mask)
+        return 63 - static_cast<UINT8>(__builtin_clzll(mask));
+#else
+    UINT8 pos = 63;
+    UINT64 bit = 1ULL << 63;
+    do
+    {
+        if (mask & bit)
+            return pos;
+        bit >>= 1;
+    } while (pos-- > 0);
+#endif
+    return UINT8_MAX;
+}
+// Scans integer for index of first nonzero bit from the Most Significant Bit (MSB). If mask is 0 then returns UINT8_MAX
+static UINT8 BitScanMSB(UINT32 mask)
+{
+#ifdef _MSC_VER
+    unsigned long pos;
+    if (_BitScanReverse(&pos, mask))
+        return static_cast<UINT8>(pos);
+#elif defined __GNUC__ || defined __clang__
+    if (mask)
+        return 31 - static_cast<UINT8>(__builtin_clz(mask));
+#else
+    UINT8 pos = 31;
+    UINT32 bit = 1UL << 31;
+    do
+    {
+        if (mask & bit)
+            return pos;
+        bit >>= 1;
+    } while (pos-- > 0);
+#endif
+    return UINT8_MAX;
+}
+
+/*
+Returns true if given number is a power of two.
+T must be unsigned integer number or signed integer but always nonnegative.
+For 0 returns true.
+*/
+template <typename T>
+static bool IsPow2(T x) { return (x & (x - 1)) == 0; }
+
+// Aligns given value up to nearest multiply of align value. For example: AlignUp(11, 8) = 16.
+// Use types like UINT, uint64_t as T.
+template <typename T>
+static T AlignUp(T val, T alignment)
+{
+    D3D12MA_HEAVY_ASSERT(IsPow2(alignment));
+    return (val + alignment - 1) & ~(alignment - 1);
+}
+// Aligns given value down to nearest multiply of align value. For example: AlignUp(11, 8) = 8.
+// Use types like UINT, uint64_t as T.
+template <typename T>
+static T AlignDown(T val, T alignment)
+{
+    D3D12MA_HEAVY_ASSERT(IsPow2(alignment));
+    return val & ~(alignment - 1);
+}
+
+// Division with mathematical rounding to nearest number.
+template <typename T>
+static T RoundDiv(T x, T y) { return (x + (y / (T)2)) / y; }
+template <typename T>
+static T DivideRoundingUp(T x, T y) { return (x + y - 1) / y; }
+
+static WCHAR HexDigitToChar(UINT8 digit)
+{
+    if(digit < 10)
+        return L'0' + digit;
+    else
+        return L'A' + (digit - 10);
+}
+
+/*
+Performs binary search and returns iterator to first element that is greater or
+equal to `key`, according to comparison `cmp`.
+
+Cmp should return true if first argument is less than second argument.
+
+Returned value is the found element, if present in the collection or place where
+new element with value (key) should be inserted.
+*/
+template <typename CmpLess, typename IterT, typename KeyT>
+static IterT BinaryFindFirstNotLess(IterT beg, IterT end, const KeyT& key, const CmpLess& cmp)
+{
+    size_t down = 0, up = (end - beg);
+    while (down < up)
+    {
+        const size_t mid = (down + up) / 2;
+        if (cmp(*(beg + mid), key))
+        {
+            down = mid + 1;
+        }
+        else
+        {
+            up = mid;
+        }
+    }
+    return beg + down;
+}
+
+/*
+Performs binary search and returns iterator to an element that is equal to `key`,
+according to comparison `cmp`.
+
+Cmp should return true if first argument is less than second argument.
+
+Returned value is the found element, if present in the collection or end if not
+found.
+*/
+template<typename CmpLess, typename IterT, typename KeyT>
+static IterT BinaryFindSorted(const IterT& beg, const IterT& end, const KeyT& value, const CmpLess& cmp)
+{
+    IterT it = BinaryFindFirstNotLess<CmpLess, IterT, KeyT>(beg, end, value, cmp);
+    if (it == end ||
+        (!cmp(*it, value) && !cmp(value, *it)))
+    {
+        return it;
+    }
+    return end;
+}
+
+static UINT HeapTypeToIndex(D3D12_HEAP_TYPE type)
+{
+    switch (type)
+    {
+    case D3D12_HEAP_TYPE_DEFAULT:  return 0;
+    case D3D12_HEAP_TYPE_UPLOAD:   return 1;
+    case D3D12_HEAP_TYPE_READBACK: return 2;
+    case D3D12_HEAP_TYPE_CUSTOM:   return 3;
+    default: D3D12MA_ASSERT(0); return UINT_MAX;
+    }
+}
+
+static D3D12_HEAP_TYPE IndexToHeapType(UINT heapTypeIndex)
+{
+    D3D12MA_ASSERT(heapTypeIndex < 4);
+    // D3D12_HEAP_TYPE_DEFAULT starts at 1.
+    return (D3D12_HEAP_TYPE)(heapTypeIndex + 1);
+}
+
+static UINT64 HeapFlagsToAlignment(D3D12_HEAP_FLAGS flags, bool denyMsaaTextures)
+{
+    /*
+    Documentation of D3D12_HEAP_DESC structure says:
+
+    - D3D12_DEFAULT_RESOURCE_PLACEMENT_ALIGNMENT   defined as 64KB.
+    - D3D12_DEFAULT_MSAA_RESOURCE_PLACEMENT_ALIGNMENT   defined as 4MB. An
+    application must decide whether the heap will contain multi-sample
+    anti-aliasing (MSAA), in which case, the application must choose [this flag].
+
+    https://docs.microsoft.com/en-us/windows/desktop/api/d3d12/ns-d3d12-d3d12_heap_desc
+    */
+
+    if (denyMsaaTextures)
+        return D3D12_DEFAULT_RESOURCE_PLACEMENT_ALIGNMENT;
+
+    const D3D12_HEAP_FLAGS denyAllTexturesFlags =
+        D3D12_HEAP_FLAG_DENY_NON_RT_DS_TEXTURES | D3D12_HEAP_FLAG_DENY_RT_DS_TEXTURES;
+    const bool canContainAnyTextures =
+        (flags & denyAllTexturesFlags) != denyAllTexturesFlags;
+    return canContainAnyTextures ?
+        D3D12_DEFAULT_MSAA_RESOURCE_PLACEMENT_ALIGNMENT : D3D12_DEFAULT_RESOURCE_PLACEMENT_ALIGNMENT;
+}
+
+static ResourceClass HeapFlagsToResourceClass(D3D12_HEAP_FLAGS heapFlags)
+{
+    const bool allowBuffers = (heapFlags & D3D12_HEAP_FLAG_DENY_BUFFERS) == 0;
+    const bool allowRtDsTextures = (heapFlags & D3D12_HEAP_FLAG_DENY_RT_DS_TEXTURES) == 0;
+    const bool allowNonRtDsTextures = (heapFlags & D3D12_HEAP_FLAG_DENY_NON_RT_DS_TEXTURES) == 0;
+
+    const uint8_t allowedGroupCount = (allowBuffers ? 1 : 0) + (allowRtDsTextures ? 1 : 0) + (allowNonRtDsTextures ? 1 : 0);
+    if (allowedGroupCount != 1)
+        return ResourceClass::Unknown;
+
+    if (allowRtDsTextures)
+        return ResourceClass::RT_DS_Texture;
+    if (allowNonRtDsTextures)
+        return ResourceClass::Non_RT_DS_Texture;
+    return ResourceClass::Buffer;
+}
+
+static bool IsHeapTypeStandard(D3D12_HEAP_TYPE type)
+{
+    return type == D3D12_HEAP_TYPE_DEFAULT ||
+        type == D3D12_HEAP_TYPE_UPLOAD ||
+        type == D3D12_HEAP_TYPE_READBACK;
+}
+
+static D3D12_HEAP_PROPERTIES StandardHeapTypeToHeapProperties(D3D12_HEAP_TYPE type)
+{
+    D3D12MA_ASSERT(IsHeapTypeStandard(type));
+    D3D12_HEAP_PROPERTIES result = {};
+    result.Type = type;
+    return result;
+}
+
+static bool IsFormatCompressed(DXGI_FORMAT format)
+{
+    switch (format)
+    {
+    case DXGI_FORMAT_BC1_TYPELESS:
+    case DXGI_FORMAT_BC1_UNORM:
+    case DXGI_FORMAT_BC1_UNORM_SRGB:
+    case DXGI_FORMAT_BC2_TYPELESS:
+    case DXGI_FORMAT_BC2_UNORM:
+    case DXGI_FORMAT_BC2_UNORM_SRGB:
+    case DXGI_FORMAT_BC3_TYPELESS:
+    case DXGI_FORMAT_BC3_UNORM:
+    case DXGI_FORMAT_BC3_UNORM_SRGB:
+    case DXGI_FORMAT_BC4_TYPELESS:
+    case DXGI_FORMAT_BC4_UNORM:
+    case DXGI_FORMAT_BC4_SNORM:
+    case DXGI_FORMAT_BC5_TYPELESS:
+    case DXGI_FORMAT_BC5_UNORM:
+    case DXGI_FORMAT_BC5_SNORM:
+    case DXGI_FORMAT_BC6H_TYPELESS:
+    case DXGI_FORMAT_BC6H_UF16:
+    case DXGI_FORMAT_BC6H_SF16:
+    case DXGI_FORMAT_BC7_TYPELESS:
+    case DXGI_FORMAT_BC7_UNORM:
+    case DXGI_FORMAT_BC7_UNORM_SRGB:
+        return true;
+    default:
+        return false;
+    }
+}
+
+// Only some formats are supported. For others it returns 0.
+static UINT GetBitsPerPixel(DXGI_FORMAT format)
+{
+    switch (format)
+    {
+    case DXGI_FORMAT_R32G32B32A32_TYPELESS:
+    case DXGI_FORMAT_R32G32B32A32_FLOAT:
+    case DXGI_FORMAT_R32G32B32A32_UINT:
+    case DXGI_FORMAT_R32G32B32A32_SINT:
+        return 128;
+    case DXGI_FORMAT_R32G32B32_TYPELESS:
+    case DXGI_FORMAT_R32G32B32_FLOAT:
+    case DXGI_FORMAT_R32G32B32_UINT:
+    case DXGI_FORMAT_R32G32B32_SINT:
+        return 96;
+    case DXGI_FORMAT_R16G16B16A16_TYPELESS:
+    case DXGI_FORMAT_R16G16B16A16_FLOAT:
+    case DXGI_FORMAT_R16G16B16A16_UNORM:
+    case DXGI_FORMAT_R16G16B16A16_UINT:
+    case DXGI_FORMAT_R16G16B16A16_SNORM:
+    case DXGI_FORMAT_R16G16B16A16_SINT:
+        return 64;
+    case DXGI_FORMAT_R32G32_TYPELESS:
+    case DXGI_FORMAT_R32G32_FLOAT:
+    case DXGI_FORMAT_R32G32_UINT:
+    case DXGI_FORMAT_R32G32_SINT:
+        return 64;
+    case DXGI_FORMAT_R32G8X24_TYPELESS:
+    case DXGI_FORMAT_D32_FLOAT_S8X24_UINT:
+    case DXGI_FORMAT_R32_FLOAT_X8X24_TYPELESS:
+    case DXGI_FORMAT_X32_TYPELESS_G8X24_UINT:
+        return 64;
+    case DXGI_FORMAT_R10G10B10A2_TYPELESS:
+    case DXGI_FORMAT_R10G10B10A2_UNORM:
+    case DXGI_FORMAT_R10G10B10A2_UINT:
+    case DXGI_FORMAT_R11G11B10_FLOAT:
+        return 32;
+    case DXGI_FORMAT_R8G8B8A8_TYPELESS:
+    case DXGI_FORMAT_R8G8B8A8_UNORM:
+    case DXGI_FORMAT_R8G8B8A8_UNORM_SRGB:
+    case DXGI_FORMAT_R8G8B8A8_UINT:
+    case DXGI_FORMAT_R8G8B8A8_SNORM:
+    case DXGI_FORMAT_R8G8B8A8_SINT:
+        return 32;
+    case DXGI_FORMAT_R16G16_TYPELESS:
+    case DXGI_FORMAT_R16G16_FLOAT:
+    case DXGI_FORMAT_R16G16_UNORM:
+    case DXGI_FORMAT_R16G16_UINT:
+    case DXGI_FORMAT_R16G16_SNORM:
+    case DXGI_FORMAT_R16G16_SINT:
+        return 32;
+    case DXGI_FORMAT_R32_TYPELESS:
+    case DXGI_FORMAT_D32_FLOAT:
+    case DXGI_FORMAT_R32_FLOAT:
+    case DXGI_FORMAT_R32_UINT:
+    case DXGI_FORMAT_R32_SINT:
+        return 32;
+    case DXGI_FORMAT_R24G8_TYPELESS:
+    case DXGI_FORMAT_D24_UNORM_S8_UINT:
+    case DXGI_FORMAT_R24_UNORM_X8_TYPELESS:
+    case DXGI_FORMAT_X24_TYPELESS_G8_UINT:
+        return 32;
+    case DXGI_FORMAT_R8G8_TYPELESS:
+    case DXGI_FORMAT_R8G8_UNORM:
+    case DXGI_FORMAT_R8G8_UINT:
+    case DXGI_FORMAT_R8G8_SNORM:
+    case DXGI_FORMAT_R8G8_SINT:
+        return 16;
+    case DXGI_FORMAT_R16_TYPELESS:
+    case DXGI_FORMAT_R16_FLOAT:
+    case DXGI_FORMAT_D16_UNORM:
+    case DXGI_FORMAT_R16_UNORM:
+    case DXGI_FORMAT_R16_UINT:
+    case DXGI_FORMAT_R16_SNORM:
+    case DXGI_FORMAT_R16_SINT:
+        return 16;
+    case DXGI_FORMAT_R8_TYPELESS:
+    case DXGI_FORMAT_R8_UNORM:
+    case DXGI_FORMAT_R8_UINT:
+    case DXGI_FORMAT_R8_SNORM:
+    case DXGI_FORMAT_R8_SINT:
+    case DXGI_FORMAT_A8_UNORM:
+        return 8;
+    case DXGI_FORMAT_BC1_TYPELESS:
+    case DXGI_FORMAT_BC1_UNORM:
+    case DXGI_FORMAT_BC1_UNORM_SRGB:
+        return 4;
+    case DXGI_FORMAT_BC2_TYPELESS:
+    case DXGI_FORMAT_BC2_UNORM:
+    case DXGI_FORMAT_BC2_UNORM_SRGB:
+        return 8;
+    case DXGI_FORMAT_BC3_TYPELESS:
+    case DXGI_FORMAT_BC3_UNORM:
+    case DXGI_FORMAT_BC3_UNORM_SRGB:
+        return 8;
+    case DXGI_FORMAT_BC4_TYPELESS:
+    case DXGI_FORMAT_BC4_UNORM:
+    case DXGI_FORMAT_BC4_SNORM:
+        return 4;
+    case DXGI_FORMAT_BC5_TYPELESS:
+    case DXGI_FORMAT_BC5_UNORM:
+    case DXGI_FORMAT_BC5_SNORM:
+        return 8;
+    case DXGI_FORMAT_BC6H_TYPELESS:
+    case DXGI_FORMAT_BC6H_UF16:
+    case DXGI_FORMAT_BC6H_SF16:
+        return 8;
+    case DXGI_FORMAT_BC7_TYPELESS:
+    case DXGI_FORMAT_BC7_UNORM:
+    case DXGI_FORMAT_BC7_UNORM_SRGB:
+        return 8;
+    default:
+        return 0;
+    }
+}
+    
+template<typename D3D12_RESOURCE_DESC_T>
+static ResourceClass ResourceDescToResourceClass(const D3D12_RESOURCE_DESC_T& resDesc)
+{
+    if (resDesc.Dimension == D3D12_RESOURCE_DIMENSION_BUFFER)
+        return ResourceClass::Buffer;
+    // Else: it's surely a texture.
+    const bool isRenderTargetOrDepthStencil =
+        (resDesc.Flags & (D3D12_RESOURCE_FLAG_ALLOW_RENDER_TARGET | D3D12_RESOURCE_FLAG_ALLOW_DEPTH_STENCIL)) != 0;
+    return isRenderTargetOrDepthStencil ? ResourceClass::RT_DS_Texture : ResourceClass::Non_RT_DS_Texture;
+}
+    
+// This algorithm is overly conservative.
+template<typename D3D12_RESOURCE_DESC_T>
+static bool CanUseSmallAlignment(const D3D12_RESOURCE_DESC_T& resourceDesc)
+{
+    if (resourceDesc.Dimension != D3D12_RESOURCE_DIMENSION_TEXTURE2D)
+        return false;
+    if ((resourceDesc.Flags & (D3D12_RESOURCE_FLAG_ALLOW_RENDER_TARGET | D3D12_RESOURCE_FLAG_ALLOW_DEPTH_STENCIL)) != 0)
+        return false;
+    if (resourceDesc.SampleDesc.Count > 1)
+        return false;
+    if (resourceDesc.DepthOrArraySize != 1)
+        return false;
+
+    UINT sizeX = (UINT)resourceDesc.Width;
+    UINT sizeY = resourceDesc.Height;
+    UINT bitsPerPixel = GetBitsPerPixel(resourceDesc.Format);
+    if (bitsPerPixel == 0)
+        return false;
+
+    if (IsFormatCompressed(resourceDesc.Format))
+    {
+        sizeX = DivideRoundingUp(sizeX, 4u);
+        sizeY = DivideRoundingUp(sizeY, 4u);
+        bitsPerPixel *= 16;
+    }
+
+    UINT tileSizeX = 0, tileSizeY = 0;
+    switch (bitsPerPixel)
+    {
+    case   8: tileSizeX = 64; tileSizeY = 64; break;
+    case  16: tileSizeX = 64; tileSizeY = 32; break;
+    case  32: tileSizeX = 32; tileSizeY = 32; break;
+    case  64: tileSizeX = 32; tileSizeY = 16; break;
+    case 128: tileSizeX = 16; tileSizeY = 16; break;
+    default: return false;
+    }
+
+    const UINT tileCount = DivideRoundingUp(sizeX, tileSizeX) * DivideRoundingUp(sizeY, tileSizeY);
+    return tileCount <= 16;
+}
+    
+static bool ValidateAllocateMemoryParameters(
+    const ALLOCATION_DESC* pAllocDesc,
+    const D3D12_RESOURCE_ALLOCATION_INFO* pAllocInfo,
+    Allocation** ppAllocation)
+{
+    return pAllocDesc &&
+        pAllocInfo &&
+        ppAllocation &&
+        (pAllocInfo->Alignment == 0 ||
+            pAllocInfo->Alignment == D3D12_DEFAULT_RESOURCE_PLACEMENT_ALIGNMENT ||
+            pAllocInfo->Alignment == D3D12_DEFAULT_MSAA_RESOURCE_PLACEMENT_ALIGNMENT) &&
+        pAllocInfo->SizeInBytes != 0 &&
+        pAllocInfo->SizeInBytes % (64ull * 1024) == 0;
+}
+
+#endif // _D3D12MA_FUNCTIONS
+    
+#ifndef _D3D12MA_STATISTICS_FUNCTIONS
+
+static void ClearStatistics(Statistics& outStats)
+{
+    outStats.BlockCount = 0;
+    outStats.AllocationCount = 0;
+    outStats.BlockBytes = 0;
+    outStats.AllocationBytes = 0;
+}
+
+static void ClearDetailedStatistics(DetailedStatistics& outStats)
+{
+    ClearStatistics(outStats.Stats);
+    outStats.UnusedRangeCount = 0;
+    outStats.AllocationSizeMin = UINT64_MAX;
+    outStats.AllocationSizeMax = 0;
+    outStats.UnusedRangeSizeMin = UINT64_MAX;
+    outStats.UnusedRangeSizeMax = 0;
+}
+
+static void AddStatistics(Statistics& inoutStats, const Statistics& src)
+{
+    inoutStats.BlockCount += src.BlockCount;
+    inoutStats.AllocationCount += src.AllocationCount;
+    inoutStats.BlockBytes += src.BlockBytes;
+    inoutStats.AllocationBytes += src.AllocationBytes;
+}
+
+static void AddDetailedStatistics(DetailedStatistics& inoutStats, const DetailedStatistics& src)
+{
+    AddStatistics(inoutStats.Stats, src.Stats);
+    inoutStats.UnusedRangeCount += src.UnusedRangeCount;
+    inoutStats.AllocationSizeMin = D3D12MA_MIN(inoutStats.AllocationSizeMin, src.AllocationSizeMin);
+    inoutStats.AllocationSizeMax = D3D12MA_MAX(inoutStats.AllocationSizeMax, src.AllocationSizeMax);
+    inoutStats.UnusedRangeSizeMin = D3D12MA_MIN(inoutStats.UnusedRangeSizeMin, src.UnusedRangeSizeMin);
+    inoutStats.UnusedRangeSizeMax = D3D12MA_MAX(inoutStats.UnusedRangeSizeMax, src.UnusedRangeSizeMax);
+}
+
+static void AddDetailedStatisticsAllocation(DetailedStatistics& inoutStats, UINT64 size)
+{
+    inoutStats.Stats.AllocationCount++;
+    inoutStats.Stats.AllocationBytes += size;
+    inoutStats.AllocationSizeMin = D3D12MA_MIN(inoutStats.AllocationSizeMin, size);
+    inoutStats.AllocationSizeMax = D3D12MA_MAX(inoutStats.AllocationSizeMax, size);
+}
+
+static void AddDetailedStatisticsUnusedRange(DetailedStatistics& inoutStats, UINT64 size)
+{
+    inoutStats.UnusedRangeCount++;
+    inoutStats.UnusedRangeSizeMin = D3D12MA_MIN(inoutStats.UnusedRangeSizeMin, size);
+    inoutStats.UnusedRangeSizeMax = D3D12MA_MAX(inoutStats.UnusedRangeSizeMax, size);
+}
+    
+#endif // _D3D12MA_STATISTICS_FUNCTIONS
+
+
+#ifndef _D3D12MA_MUTEX
+
+#ifndef D3D12MA_MUTEX
+    class Mutex
+    {
+    public:
+        void Lock() { m_Mutex.lock(); }
+        void Unlock() { m_Mutex.unlock(); }
+    
+    private:
+        std::mutex m_Mutex;
+    };
+    #define D3D12MA_MUTEX Mutex
+#endif
+
+#ifndef D3D12MA_RW_MUTEX
+#ifdef _WIN32
+    class RWMutex
+    {
+    public:
+        RWMutex() { InitializeSRWLock(&m_Lock); }
+        void LockRead() { AcquireSRWLockShared(&m_Lock); }
+        void UnlockRead() { ReleaseSRWLockShared(&m_Lock); }
+        void LockWrite() { AcquireSRWLockExclusive(&m_Lock); }
+        void UnlockWrite() { ReleaseSRWLockExclusive(&m_Lock); }
+    
+    private:
+        SRWLOCK m_Lock;
+    };
+#else // #ifdef _WIN32
+    class RWMutex
+    {
+    public:
+        RWMutex() {}
+        void LockRead() { m_Mutex.lock_shared(); }
+        void UnlockRead() { m_Mutex.unlock_shared(); }
+        void LockWrite() { m_Mutex.lock(); }
+        void UnlockWrite() { m_Mutex.unlock(); }
+    
+    private:
+        std::shared_timed_mutex m_Mutex;
+    };
+#endif // #ifdef _WIN32
+    #define D3D12MA_RW_MUTEX RWMutex
+#endif // #ifndef D3D12MA_RW_MUTEX
+
+// Helper RAII class to lock a mutex in constructor and unlock it in destructor (at the end of scope).
+struct MutexLock
+{
+    D3D12MA_CLASS_NO_COPY(MutexLock);
+public:
+    MutexLock(D3D12MA_MUTEX& mutex, bool useMutex = true) :
+        m_pMutex(useMutex ? &mutex : NULL)
+    {
+        if (m_pMutex) m_pMutex->Lock(); 
+    }
+    ~MutexLock() { if (m_pMutex) m_pMutex->Unlock(); }
+
+private:
+    D3D12MA_MUTEX* m_pMutex;
+};
+
+// Helper RAII class to lock a RW mutex in constructor and unlock it in destructor (at the end of scope), for reading.
+struct MutexLockRead
+{
+    D3D12MA_CLASS_NO_COPY(MutexLockRead);
+public:
+    MutexLockRead(D3D12MA_RW_MUTEX& mutex, bool useMutex)
+        :  m_pMutex(useMutex ? &mutex : NULL)
+    {
+        if(m_pMutex)
+        {
+            m_pMutex->LockRead();
+        }
+    }
+    ~MutexLockRead() { if (m_pMutex) m_pMutex->UnlockRead(); }
+
+private:
+    D3D12MA_RW_MUTEX* m_pMutex;
+};
+
+// Helper RAII class to lock a RW mutex in constructor and unlock it in destructor (at the end of scope), for writing.
+struct MutexLockWrite
+{
+    D3D12MA_CLASS_NO_COPY(MutexLockWrite);
+public:
+    MutexLockWrite(D3D12MA_RW_MUTEX& mutex, bool useMutex)
+        : m_pMutex(useMutex ? &mutex : NULL)
+    {
+        if (m_pMutex) m_pMutex->LockWrite(); 
+    }
+    ~MutexLockWrite() { if (m_pMutex) m_pMutex->UnlockWrite(); }
+
+private:
+    D3D12MA_RW_MUTEX* m_pMutex;
+};
+
+#if D3D12MA_DEBUG_GLOBAL_MUTEX
+    static D3D12MA_MUTEX g_DebugGlobalMutex;
+    #define D3D12MA_DEBUG_GLOBAL_MUTEX_LOCK MutexLock debugGlobalMutexLock(g_DebugGlobalMutex, true);
+#else
+    #define D3D12MA_DEBUG_GLOBAL_MUTEX_LOCK
+#endif
+#endif // _D3D12MA_MUTEX
+
+#ifndef _D3D12MA_VECTOR
+/*
+Dynamically resizing continuous array. Class with interface similar to std::vector.
+T must be POD because constructors and destructors are not called and memcpy is
+used for these objects.
+*/
+template<typename T>
+class Vector
+{
+public:
+    using value_type = T;
+    using iterator = T*;
+    using const_iterator = const T*;
+
+    // allocationCallbacks externally owned, must outlive this object.
+    Vector(const ALLOCATION_CALLBACKS& allocationCallbacks);
+    Vector(size_t count, const ALLOCATION_CALLBACKS& allocationCallbacks);
+    Vector(const Vector<T>& src);
+    ~Vector();
+
+    const ALLOCATION_CALLBACKS& GetAllocs() const { return m_AllocationCallbacks; }
+    bool empty() const { return m_Count == 0; }
+    size_t size() const { return m_Count; }
+    T* data() { return m_pArray; }
+    const T* data() const { return m_pArray; }
+    void clear(bool freeMemory = false) { resize(0, freeMemory); }
+
+    iterator begin() { return m_pArray; }
+    iterator end() { return m_pArray + m_Count; }
+    const_iterator cbegin() const { return m_pArray; }
+    const_iterator cend() const { return m_pArray + m_Count; }
+    const_iterator begin() const { return cbegin(); }
+    const_iterator end() const { return cend(); }
+
+    void push_front(const T& src) { insert(0, src); }
+    void push_back(const T& src);
+    void pop_front();
+    void pop_back();
+
+    T& front();
+    T& back();
+    const T& front() const;
+    const T& back() const;
+
+    void reserve(size_t newCapacity, bool freeMemory = false);
+    void resize(size_t newCount, bool freeMemory = false);
+    void insert(size_t index, const T& src);
+    void remove(size_t index);
+
+    template<typename CmpLess>
+    size_t InsertSorted(const T& value, const CmpLess& cmp);
+    template<typename CmpLess>
+    bool RemoveSorted(const T& value, const CmpLess& cmp);
+
+    Vector& operator=(const Vector<T>& rhs);
+    T& operator[](size_t index);
+    const T& operator[](size_t index) const;
+
+private:
+    const ALLOCATION_CALLBACKS& m_AllocationCallbacks;
+    T* m_pArray;
+    size_t m_Count;
+    size_t m_Capacity;
+};
+
+#ifndef _D3D12MA_VECTOR_FUNCTIONS
+template<typename T>
+Vector<T>::Vector(const ALLOCATION_CALLBACKS& allocationCallbacks)
+    : m_AllocationCallbacks(allocationCallbacks),
+    m_pArray(NULL),
+    m_Count(0),
+    m_Capacity(0) {}
+
+template<typename T>
+Vector<T>::Vector(size_t count, const ALLOCATION_CALLBACKS& allocationCallbacks)
+    : m_AllocationCallbacks(allocationCallbacks),
+    m_pArray(count ? AllocateArray<T>(allocationCallbacks, count) : NULL),
+    m_Count(count),
+    m_Capacity(count) {}
+
+template<typename T>
+Vector<T>::Vector(const Vector<T>& src)
+    : m_AllocationCallbacks(src.m_AllocationCallbacks),
+    m_pArray(src.m_Count ? AllocateArray<T>(src.m_AllocationCallbacks, src.m_Count) : NULL),
+    m_Count(src.m_Count),
+    m_Capacity(src.m_Count)
+{
+    if (m_Count > 0)
+    {
+        memcpy(m_pArray, src.m_pArray, m_Count * sizeof(T));
+    }
+}
+
+template<typename T>
+Vector<T>::~Vector()
+{
+    Free(m_AllocationCallbacks, m_pArray);
+}
+
+template<typename T>
+void Vector<T>::push_back(const T& src)
+{
+    const size_t newIndex = size();
+    resize(newIndex + 1);
+    m_pArray[newIndex] = src;
+}
+
+template<typename T>
+void Vector<T>::pop_front()
+{
+    D3D12MA_HEAVY_ASSERT(m_Count > 0);
+    remove(0);
+}
+
+template<typename T>
+void Vector<T>::pop_back()
+{
+    D3D12MA_HEAVY_ASSERT(m_Count > 0);
+    resize(size() - 1);
+}
+
+template<typename T>
+T& Vector<T>::front()
+{
+    D3D12MA_HEAVY_ASSERT(m_Count > 0);
+    return m_pArray[0];
+}
+
+template<typename T>
+T& Vector<T>::back()
+{
+    D3D12MA_HEAVY_ASSERT(m_Count > 0);
+    return m_pArray[m_Count - 1];
+}
+
+template<typename T>
+const T& Vector<T>::front() const
+{
+    D3D12MA_HEAVY_ASSERT(m_Count > 0);
+    return m_pArray[0];
+}
+
+template<typename T>
+const T& Vector<T>::back() const
+{
+    D3D12MA_HEAVY_ASSERT(m_Count > 0);
+    return m_pArray[m_Count - 1];
+}
+
+template<typename T>
+void Vector<T>::reserve(size_t newCapacity, bool freeMemory)
+{
+    newCapacity = D3D12MA_MAX(newCapacity, m_Count);
+
+    if ((newCapacity < m_Capacity) && !freeMemory)
+    {
+        newCapacity = m_Capacity;
+    }
+
+    if (newCapacity != m_Capacity)
+    {
+        T* const newArray = newCapacity ? AllocateArray<T>(m_AllocationCallbacks, newCapacity) : NULL;
+        if (m_Count != 0)
+        {
+            memcpy(newArray, m_pArray, m_Count * sizeof(T));
+        }
+        Free(m_AllocationCallbacks, m_pArray);
+        m_Capacity = newCapacity;
+        m_pArray = newArray;
+    }
+}
+
+template<typename T>
+void Vector<T>::resize(size_t newCount, bool freeMemory)
+{
+    size_t newCapacity = m_Capacity;
+    if (newCount > m_Capacity)
+    {
+        newCapacity = D3D12MA_MAX(newCount, D3D12MA_MAX(m_Capacity * 3 / 2, (size_t)8));
+    }
+    else if (freeMemory)
+    {
+        newCapacity = newCount;
+    }
+
+    if (newCapacity != m_Capacity)
+    {
+        T* const newArray = newCapacity ? AllocateArray<T>(m_AllocationCallbacks, newCapacity) : NULL;
+        const size_t elementsToCopy = D3D12MA_MIN(m_Count, newCount);
+        if (elementsToCopy != 0)
+        {
+            memcpy(newArray, m_pArray, elementsToCopy * sizeof(T));
+        }
+        Free(m_AllocationCallbacks, m_pArray);
+        m_Capacity = newCapacity;
+        m_pArray = newArray;
+    }
+
+    m_Count = newCount;
+}
+
+template<typename T>
+void Vector<T>::insert(size_t index, const T& src)
+{
+    D3D12MA_HEAVY_ASSERT(index <= m_Count);
+    const size_t oldCount = size();
+    resize(oldCount + 1);
+    if (index < oldCount)
+    {
+        memmove(m_pArray + (index + 1), m_pArray + index, (oldCount - index) * sizeof(T));
+    }
+    m_pArray[index] = src;
+}
+
+template<typename T>
+void Vector<T>::remove(size_t index)
+{
+    D3D12MA_HEAVY_ASSERT(index < m_Count);
+    const size_t oldCount = size();
+    if (index < oldCount - 1)
+    {
+        memmove(m_pArray + index, m_pArray + (index + 1), (oldCount - index - 1) * sizeof(T));
+    }
+    resize(oldCount - 1);
+}
+
+template<typename T> template<typename CmpLess>
+size_t Vector<T>::InsertSorted(const T& value, const CmpLess& cmp)
+{
+    const size_t indexToInsert = BinaryFindFirstNotLess<CmpLess, iterator, T>(
+        m_pArray,
+        m_pArray + m_Count,
+        value,
+        cmp) - m_pArray;
+    insert(indexToInsert, value);
+    return indexToInsert;
+}
+
+template<typename T> template<typename CmpLess>
+bool Vector<T>::RemoveSorted(const T& value, const CmpLess& cmp)
+{
+    const iterator it = BinaryFindFirstNotLess(
+        m_pArray,
+        m_pArray + m_Count,
+        value,
+        cmp);
+    if ((it != end()) && !cmp(*it, value) && !cmp(value, *it))
+    {
+        size_t indexToRemove = it - begin();
+        remove(indexToRemove);
+        return true;
+    }
+    return false;
+}
+
+template<typename T>
+Vector<T>& Vector<T>::operator=(const Vector<T>& rhs)
+{
+    if (&rhs != this)
+    {
+        resize(rhs.m_Count);
+        if (m_Count != 0)
+        {
+            memcpy(m_pArray, rhs.m_pArray, m_Count * sizeof(T));
+        }
+    }
+    return *this;
+}
+
+template<typename T>
+T& Vector<T>::operator[](size_t index)
+{
+    D3D12MA_HEAVY_ASSERT(index < m_Count);
+    return m_pArray[index];
+}
+
+template<typename T>
+const T& Vector<T>::operator[](size_t index) const
+{
+    D3D12MA_HEAVY_ASSERT(index < m_Count);
+    return m_pArray[index];
+}
+#endif // _D3D12MA_VECTOR_FUNCTIONS
+#endif // _D3D12MA_VECTOR
+
+#ifndef _D3D12MA_STRING_BUILDER
+class StringBuilder
+{
+public:
+    StringBuilder(const ALLOCATION_CALLBACKS& allocationCallbacks) : m_Data(allocationCallbacks) {}
+
+    size_t GetLength() const { return m_Data.size(); }
+    LPCWSTR GetData() const { return m_Data.data(); }
+
+    void Add(WCHAR ch) { m_Data.push_back(ch); }
+    void Add(LPCWSTR str);
+    void AddNewLine() { Add(L'\n'); }
+    void AddNumber(UINT num);
+    void AddNumber(UINT64 num);
+    void AddPointer(const void* ptr);
+
+private:
+    Vector<WCHAR> m_Data;
+};
+
+#ifndef _D3D12MA_STRING_BUILDER_FUNCTIONS
+void StringBuilder::Add(LPCWSTR str)
+{
+    const size_t len = wcslen(str);
+    if (len > 0)
+    {
+        const size_t oldCount = m_Data.size();
+        m_Data.resize(oldCount + len);
+        memcpy(m_Data.data() + oldCount, str, len * sizeof(WCHAR));
+    }
+}
+
+void StringBuilder::AddNumber(UINT num)
+{
+    WCHAR buf[11];
+    buf[10] = L'\0';
+    WCHAR *p = &buf[10];
+    do
+    {
+        *--p = L'0' + (num % 10);
+        num /= 10;
+    }
+    while (num);
+    Add(p);
+}
+
+void StringBuilder::AddNumber(UINT64 num)
+{
+    WCHAR buf[21];
+    buf[20] = L'\0';
+    WCHAR *p = &buf[20];
+    do
+    {
+        *--p = L'0' + (num % 10);
+        num /= 10;
+    }
+    while (num);
+    Add(p);
+}
+
+void StringBuilder::AddPointer(const void* ptr)
+{
+    WCHAR buf[21];
+    uintptr_t num = (uintptr_t)ptr;
+    buf[20] = L'\0';
+    WCHAR *p = &buf[20];
+    do
+    {
+        *--p = HexDigitToChar((UINT8)(num & 0xF));
+        num >>= 4;
+    }
+    while (num);
+    Add(p);
+}
+
+#endif // _D3D12MA_STRING_BUILDER_FUNCTIONS
+#endif // _D3D12MA_STRING_BUILDER
+
+#ifndef _D3D12MA_JSON_WRITER
+/*
+Allows to conveniently build a correct JSON document to be written to the
+StringBuilder passed to the constructor.
+*/
+class JsonWriter
+{
+public:
+    // stringBuilder - string builder to write the document to. Must remain alive for the whole lifetime of this object.
+    JsonWriter(const ALLOCATION_CALLBACKS& allocationCallbacks, StringBuilder& stringBuilder);
+    ~JsonWriter();
+
+    // Begins object by writing "{".
+    // Inside an object, you must call pairs of WriteString and a value, e.g.:
+    // j.BeginObject(true); j.WriteString("A"); j.WriteNumber(1); j.WriteString("B"); j.WriteNumber(2); j.EndObject();
+    // Will write: { "A": 1, "B": 2 }
+    void BeginObject(bool singleLine = false);
+    // Ends object by writing "}".
+    void EndObject();
+
+    // Begins array by writing "[".
+    // Inside an array, you can write a sequence of any values.
+    void BeginArray(bool singleLine = false);
+    // Ends array by writing "[".
+    void EndArray();
+
+    // Writes a string value inside "".
+    // pStr can contain any UTF-16 characters, including '"', new line etc. - they will be properly escaped.
+    void WriteString(LPCWSTR pStr);
+
+    // Begins writing a string value.
+    // Call BeginString, ContinueString, ContinueString, ..., EndString instead of
+    // WriteString to conveniently build the string content incrementally, made of
+    // parts including numbers.
+    void BeginString(LPCWSTR pStr = NULL);
+    // Posts next part of an open string.
+    void ContinueString(LPCWSTR pStr);
+    // Posts next part of an open string. The number is converted to decimal characters.
+    void ContinueString(UINT num);
+    void ContinueString(UINT64 num);
+    void ContinueString_Pointer(const void* ptr);
+    // Posts next part of an open string. Pointer value is converted to characters
+    // using "%p" formatting - shown as hexadecimal number, e.g.: 000000081276Ad00
+    // void ContinueString_Pointer(const void* ptr);
+    // Ends writing a string value by writing '"'.
+    void EndString(LPCWSTR pStr = NULL);
+
+    // Writes a number value.
+    void WriteNumber(UINT num);
+    void WriteNumber(UINT64 num);
+    // Writes a boolean value - false or true.
+    void WriteBool(bool b);
+    // Writes a null value.
+    void WriteNull();
+
+    void AddAllocationToObject(const Allocation& alloc);
+    void AddDetailedStatisticsInfoObject(const DetailedStatistics& stats);
+
+private:
+    static const WCHAR* const INDENT;
+
+    enum CollectionType
+    {
+        COLLECTION_TYPE_OBJECT,
+        COLLECTION_TYPE_ARRAY,
+    };
+    struct StackItem
+    {
+        CollectionType type;
+        UINT valueCount;
+        bool singleLineMode;
+    };
+
+    StringBuilder& m_SB;
+    Vector<StackItem> m_Stack;
+    bool m_InsideString;
+
+    void BeginValue(bool isString);
+    void WriteIndent(bool oneLess = false);
+};
+
+#ifndef _D3D12MA_JSON_WRITER_FUNCTIONS
+const WCHAR* const JsonWriter::INDENT = L"  ";
+
+JsonWriter::JsonWriter(const ALLOCATION_CALLBACKS& allocationCallbacks, StringBuilder& stringBuilder)
+    : m_SB(stringBuilder),
+    m_Stack(allocationCallbacks),
+    m_InsideString(false) {}
+
+JsonWriter::~JsonWriter()
+{
+    D3D12MA_ASSERT(!m_InsideString);
+    D3D12MA_ASSERT(m_Stack.empty());
+}
+
+void JsonWriter::BeginObject(bool singleLine)
+{
+    D3D12MA_ASSERT(!m_InsideString);
+
+    BeginValue(false);
+    m_SB.Add(L'{');
+
+    StackItem stackItem;
+    stackItem.type = COLLECTION_TYPE_OBJECT;
+    stackItem.valueCount = 0;
+    stackItem.singleLineMode = singleLine;
+    m_Stack.push_back(stackItem);
+}
+
+void JsonWriter::EndObject()
+{
+    D3D12MA_ASSERT(!m_InsideString);
+    D3D12MA_ASSERT(!m_Stack.empty() && m_Stack.back().type == COLLECTION_TYPE_OBJECT);
+    D3D12MA_ASSERT(m_Stack.back().valueCount % 2 == 0);
+
+    WriteIndent(true);
+    m_SB.Add(L'}');
+
+    m_Stack.pop_back();
+}
+
+void JsonWriter::BeginArray(bool singleLine)
+{
+    D3D12MA_ASSERT(!m_InsideString);
+
+    BeginValue(false);
+    m_SB.Add(L'[');
+
+    StackItem stackItem;
+    stackItem.type = COLLECTION_TYPE_ARRAY;
+    stackItem.valueCount = 0;
+    stackItem.singleLineMode = singleLine;
+    m_Stack.push_back(stackItem);
+}
+
+void JsonWriter::EndArray()
+{
+    D3D12MA_ASSERT(!m_InsideString);
+    D3D12MA_ASSERT(!m_Stack.empty() && m_Stack.back().type == COLLECTION_TYPE_ARRAY);
+
+    WriteIndent(true);
+    m_SB.Add(L']');
+
+    m_Stack.pop_back();
+}
+
+void JsonWriter::WriteString(LPCWSTR pStr)
+{
+    BeginString(pStr);
+    EndString();
+}
+
+void JsonWriter::BeginString(LPCWSTR pStr)
+{
+    D3D12MA_ASSERT(!m_InsideString);
+
+    BeginValue(true);
+    m_InsideString = true;
+    m_SB.Add(L'"');
+    if (pStr != NULL)
+    {
+        ContinueString(pStr);
+    }
+}
+
+void JsonWriter::ContinueString(LPCWSTR pStr)
+{
+    D3D12MA_ASSERT(m_InsideString);
+    D3D12MA_ASSERT(pStr);
+
+    for (const WCHAR *p = pStr; *p; ++p)
+    {
+        // the strings we encode are assumed to be in UTF-16LE format, the native
+        // windows wide character Unicode format. In this encoding Unicode code
+        // points U+0000 to U+D7FF and U+E000 to U+FFFF are encoded in two bytes,
+        // and everything else takes more than two bytes. We will reject any
+        // multi wchar character encodings for simplicity.
+        UINT val = (UINT)*p;
+        D3D12MA_ASSERT(((val <= 0xD7FF) || (0xE000 <= val && val <= 0xFFFF)) &&
+            "Character not currently supported.");
+        switch (*p)
+        {
+        case L'"':  m_SB.Add(L'\\'); m_SB.Add(L'"');  break;
+        case L'\\': m_SB.Add(L'\\'); m_SB.Add(L'\\'); break;
+        case L'/':  m_SB.Add(L'\\'); m_SB.Add(L'/');  break;
+        case L'\b': m_SB.Add(L'\\'); m_SB.Add(L'b');  break;
+        case L'\f': m_SB.Add(L'\\'); m_SB.Add(L'f');  break;
+        case L'\n': m_SB.Add(L'\\'); m_SB.Add(L'n');  break;
+        case L'\r': m_SB.Add(L'\\'); m_SB.Add(L'r');  break;
+        case L'\t': m_SB.Add(L'\\'); m_SB.Add(L't');  break;
+        default:
+            // conservatively use encoding \uXXXX for any Unicode character
+            // requiring more than one byte.
+            if (32 <= val && val < 256)
+                m_SB.Add(*p);
+            else
+            {
+                m_SB.Add(L'\\');
+                m_SB.Add(L'u');
+                for (UINT i = 0; i < 4; ++i)
+                {
+                    UINT hexDigit = (val & 0xF000) >> 12;
+                    val <<= 4;
+                    if (hexDigit < 10)
+                        m_SB.Add(L'0' + (WCHAR)hexDigit);
+                    else
+                        m_SB.Add(L'A' + (WCHAR)hexDigit);
+                }
+            }
+            break;
+        }
+    }
+}
+
+void JsonWriter::ContinueString(UINT num)
+{
+    D3D12MA_ASSERT(m_InsideString);
+    m_SB.AddNumber(num);
+}
+
+void JsonWriter::ContinueString(UINT64 num)
+{
+    D3D12MA_ASSERT(m_InsideString);
+    m_SB.AddNumber(num);
+}
+
+void JsonWriter::ContinueString_Pointer(const void* ptr)
+{
+    D3D12MA_ASSERT(m_InsideString);
+    m_SB.AddPointer(ptr);
+}
+
+void JsonWriter::EndString(LPCWSTR pStr)
+{
+    D3D12MA_ASSERT(m_InsideString);
+
+    if (pStr)
+        ContinueString(pStr);
+    m_SB.Add(L'"');
+    m_InsideString = false;
+}
+
+void JsonWriter::WriteNumber(UINT num)
+{
+    D3D12MA_ASSERT(!m_InsideString);
+    BeginValue(false);
+    m_SB.AddNumber(num);
+}
+
+void JsonWriter::WriteNumber(UINT64 num)
+{
+    D3D12MA_ASSERT(!m_InsideString);
+    BeginValue(false);
+    m_SB.AddNumber(num);
+}
+
+void JsonWriter::WriteBool(bool b)
+{
+    D3D12MA_ASSERT(!m_InsideString);
+    BeginValue(false);
+    if (b)
+        m_SB.Add(L"true");
+    else
+        m_SB.Add(L"false");
+}
+
+void JsonWriter::WriteNull()
+{
+    D3D12MA_ASSERT(!m_InsideString);
+    BeginValue(false);
+    m_SB.Add(L"null");
+}
+
+void JsonWriter::AddAllocationToObject(const Allocation& alloc)
+{
+    WriteString(L"Type");
+    switch (alloc.m_PackedData.GetResourceDimension()) {
+    case D3D12_RESOURCE_DIMENSION_UNKNOWN:
+        WriteString(L"UNKNOWN");
+        break;
+    case D3D12_RESOURCE_DIMENSION_BUFFER:
+        WriteString(L"BUFFER");
+        break;
+    case D3D12_RESOURCE_DIMENSION_TEXTURE1D:
+        WriteString(L"TEXTURE1D");
+        break;
+    case D3D12_RESOURCE_DIMENSION_TEXTURE2D:
+        WriteString(L"TEXTURE2D");
+        break;
+    case D3D12_RESOURCE_DIMENSION_TEXTURE3D:
+        WriteString(L"TEXTURE3D");
+        break;
+    default: D3D12MA_ASSERT(0); break;
+    }
+
+    WriteString(L"Size");
+    WriteNumber(alloc.GetSize());
+    WriteString(L"Usage");
+    WriteNumber((UINT)alloc.m_PackedData.GetResourceFlags());
+
+    void* privateData = alloc.GetPrivateData();
+    if (privateData)
+    {
+        WriteString(L"CustomData");
+        BeginString();
+        ContinueString_Pointer(privateData);
+        EndString();
+    }
+
+    LPCWSTR name = alloc.GetName();
+    if (name != NULL)
+    {
+        WriteString(L"Name");
+        WriteString(name);
+    }
+    if (alloc.m_PackedData.GetTextureLayout())
+    {
+        WriteString(L"Layout");
+        WriteNumber((UINT)alloc.m_PackedData.GetTextureLayout());
+    }
+}
+
+void JsonWriter::AddDetailedStatisticsInfoObject(const DetailedStatistics& stats)
+{
+    BeginObject();
+
+    WriteString(L"BlockCount");
+    WriteNumber(stats.Stats.BlockCount);
+    WriteString(L"BlockBytes");
+    WriteNumber(stats.Stats.BlockBytes);
+    WriteString(L"AllocationCount");
+    WriteNumber(stats.Stats.AllocationCount);
+    WriteString(L"AllocationBytes");
+    WriteNumber(stats.Stats.AllocationBytes);
+    WriteString(L"UnusedRangeCount");
+    WriteNumber(stats.UnusedRangeCount);
+
+    if (stats.Stats.AllocationCount > 1)
+    {
+        WriteString(L"AllocationSizeMin");
+        WriteNumber(stats.AllocationSizeMin);
+        WriteString(L"AllocationSizeMax");
+        WriteNumber(stats.AllocationSizeMax);
+    }
+    if (stats.UnusedRangeCount > 1)
+    {
+        WriteString(L"UnusedRangeSizeMin");
+        WriteNumber(stats.UnusedRangeSizeMin);
+        WriteString(L"UnusedRangeSizeMax");
+        WriteNumber(stats.UnusedRangeSizeMax);
+    }
+    EndObject();
+}
+
+void JsonWriter::BeginValue(bool isString)
+{
+    if (!m_Stack.empty())
+    {
+        StackItem& currItem = m_Stack.back();
+        if (currItem.type == COLLECTION_TYPE_OBJECT && currItem.valueCount % 2 == 0)
+        {
+            D3D12MA_ASSERT(isString);
+        }
+
+        if (currItem.type == COLLECTION_TYPE_OBJECT && currItem.valueCount % 2 == 1)
+        {
+            m_SB.Add(L':'); m_SB.Add(L' ');
+        }
+        else if (currItem.valueCount > 0)
+        {
+            m_SB.Add(L','); m_SB.Add(L' ');
+            WriteIndent();
+        }
+        else
+        {
+            WriteIndent();
+        }
+        ++currItem.valueCount;
+    }
+}
+
+void JsonWriter::WriteIndent(bool oneLess)
+{
+    if (!m_Stack.empty() && !m_Stack.back().singleLineMode)
+    {
+        m_SB.AddNewLine();
+
+        size_t count = m_Stack.size();
+        if (count > 0 && oneLess)
+        {
+            --count;
+        }
+        for (size_t i = 0; i < count; ++i)
+        {
+            m_SB.Add(INDENT);
+        }
+    }
+}
+#endif // _D3D12MA_JSON_WRITER_FUNCTIONS
+#endif // _D3D12MA_JSON_WRITER
+
+#ifndef _D3D12MA_POOL_ALLOCATOR
+/*
+Allocator for objects of type T using a list of arrays (pools) to speed up
+allocation. Number of elements that can be allocated is not bounded because
+allocator can create multiple blocks.
+T should be POD because constructor and destructor is not called in Alloc or
+Free.
+*/
+template<typename T>
+class PoolAllocator
+{
+    D3D12MA_CLASS_NO_COPY(PoolAllocator)
+public:
+    // allocationCallbacks externally owned, must outlive this object.
+    PoolAllocator(const ALLOCATION_CALLBACKS& allocationCallbacks, UINT firstBlockCapacity);
+    ~PoolAllocator() { Clear(); }
+
+    void Clear();
+    template<typename... Types>
+    T* Alloc(Types... args);
+    void Free(T* ptr);
+
+private:
+    union Item
+    {
+        UINT NextFreeIndex; // UINT32_MAX means end of list.
+        alignas(T) char Value[sizeof(T)];
+    };
+
+    struct ItemBlock
+    {
+        Item* pItems;
+        UINT Capacity;
+        UINT FirstFreeIndex;
+    };
+
+    const ALLOCATION_CALLBACKS& m_AllocationCallbacks;
+    const UINT m_FirstBlockCapacity;
+    Vector<ItemBlock> m_ItemBlocks;
+
+    ItemBlock& CreateNewBlock();
+};
+
+#ifndef _D3D12MA_POOL_ALLOCATOR_FUNCTIONS
+template<typename T>
+PoolAllocator<T>::PoolAllocator(const ALLOCATION_CALLBACKS& allocationCallbacks, UINT firstBlockCapacity)
+    : m_AllocationCallbacks(allocationCallbacks),
+    m_FirstBlockCapacity(firstBlockCapacity),
+    m_ItemBlocks(allocationCallbacks)
+{
+    D3D12MA_ASSERT(m_FirstBlockCapacity > 1);
+}
+
+template<typename T>
+void PoolAllocator<T>::Clear()
+{
+    for(size_t i = m_ItemBlocks.size(); i--; )
+    {
+        D3D12MA_DELETE_ARRAY(m_AllocationCallbacks, m_ItemBlocks[i].pItems, m_ItemBlocks[i].Capacity);
+    }
+    m_ItemBlocks.clear(true);
+}
+
+template<typename T> template<typename... Types>
+T* PoolAllocator<T>::Alloc(Types... args)
+{
+    for(size_t i = m_ItemBlocks.size(); i--; )
+    {
+        ItemBlock& block = m_ItemBlocks[i];
+        // This block has some free items: Use first one.
+        if(block.FirstFreeIndex != UINT32_MAX)
+        {
+            Item* const pItem = &block.pItems[block.FirstFreeIndex];
+            block.FirstFreeIndex = pItem->NextFreeIndex;
+            T* result = (T*)&pItem->Value;
+            new(result)T(std::forward<Types>(args)...); // Explicit constructor call.
+            return result;
+        }
+    }
+
+    // No block has free item: Create new one and use it.
+    ItemBlock& newBlock = CreateNewBlock();
+    Item* const pItem = &newBlock.pItems[0];
+    newBlock.FirstFreeIndex = pItem->NextFreeIndex;
+    T* result = (T*)pItem->Value;
+    new(result)T(std::forward<Types>(args)...); // Explicit constructor call.
+    return result;
+}
+
+template<typename T>
+void PoolAllocator<T>::Free(T* ptr)
+{
+    // Search all memory blocks to find ptr.
+    for(size_t i = m_ItemBlocks.size(); i--; )
+    {
+        ItemBlock& block = m_ItemBlocks[i];
+
+        Item* pItemPtr;
+        memcpy(&pItemPtr, &ptr, sizeof(pItemPtr));
+
+        // Check if pItemPtr is in address range of this block.
+        if((pItemPtr >= block.pItems) && (pItemPtr < block.pItems + block.Capacity))
+        {
+            ptr->~T(); // Explicit destructor call.
+            const UINT index = static_cast<UINT>(pItemPtr - block.pItems);
+            pItemPtr->NextFreeIndex = block.FirstFreeIndex;
+            block.FirstFreeIndex = index;
+            return;
+        }
+    }
+    D3D12MA_ASSERT(0 && "Pointer doesn't belong to this memory pool.");
+}
+
+template<typename T>
+typename PoolAllocator<T>::ItemBlock& PoolAllocator<T>::CreateNewBlock()
+{
+    const UINT newBlockCapacity = m_ItemBlocks.empty() ?
+        m_FirstBlockCapacity : m_ItemBlocks.back().Capacity * 3 / 2;
+
+    const ItemBlock newBlock = {
+        D3D12MA_NEW_ARRAY(m_AllocationCallbacks, Item, newBlockCapacity),
+        newBlockCapacity,
+        0 };
+
+    m_ItemBlocks.push_back(newBlock);
+
+    // Setup singly-linked list of all free items in this block.
+    for(UINT i = 0; i < newBlockCapacity - 1; ++i)
+    {
+        newBlock.pItems[i].NextFreeIndex = i + 1;
+    }
+    newBlock.pItems[newBlockCapacity - 1].NextFreeIndex = UINT32_MAX;
+    return m_ItemBlocks.back();
+}
+#endif // _D3D12MA_POOL_ALLOCATOR_FUNCTIONS
+#endif // _D3D12MA_POOL_ALLOCATOR
+
+#ifndef _D3D12MA_LIST
+/*
+Doubly linked list, with elements allocated out of PoolAllocator.
+Has custom interface, as well as STL-style interface, including iterator and
+const_iterator.
+*/
+template<typename T>
+class List
+{
+    D3D12MA_CLASS_NO_COPY(List)
+public:
+    struct Item
+    {
+        Item* pPrev;
+        Item* pNext;
+        T Value;
+    };
+
+    class reverse_iterator;
+    class const_reverse_iterator;
+    class iterator
+    {
+        friend class List<T>;
+        friend class const_iterator;
+
+    public:
+        iterator() = default;
+        iterator(const reverse_iterator& src)
+            : m_pList(src.m_pList), m_pItem(src.m_pItem) {}
+
+        T& operator*() const;
+        T* operator->() const;
+
+        iterator& operator++();
+        iterator& operator--();
+        iterator operator++(int);
+        iterator operator--(int);
+
+        bool operator==(const iterator& rhs) const;
+        bool operator!=(const iterator& rhs) const;
+
+    private:
+        List<T>* m_pList = NULL;
+        Item* m_pItem = NULL;
+
+        iterator(List<T>* pList, Item* pItem) : m_pList(pList), m_pItem(pItem) {}
+    };
+
+    class reverse_iterator
+    {
+        friend class List<T>;
+        friend class const_reverse_iterator;
+
+    public:
+        reverse_iterator() = default;
+        reverse_iterator(const iterator& src)
+            : m_pList(src.m_pList), m_pItem(src.m_pItem) {}
+
+        T& operator*() const;
+        T* operator->() const;
+
+        reverse_iterator& operator++();
+        reverse_iterator& operator--();
+        reverse_iterator operator++(int);
+        reverse_iterator operator--(int);
+
+        bool operator==(const reverse_iterator& rhs) const;
+        bool operator!=(const reverse_iterator& rhs) const;
+
+    private:
+        List<T>* m_pList = NULL;
+        Item* m_pItem = NULL;
+
+        reverse_iterator(List<T>* pList, Item* pItem)
+            : m_pList(pList), m_pItem(pItem) {}
+    };
+
+    class const_iterator
+    {
+        friend class List<T>;
+
+    public:
+        const_iterator() = default;
+        const_iterator(const iterator& src)
+            : m_pList(src.m_pList), m_pItem(src.m_pItem) {}
+        const_iterator(const reverse_iterator& src)
+            : m_pList(src.m_pList), m_pItem(src.m_pItem) {}
+        const_iterator(const const_reverse_iterator& src)
+            : m_pList(src.m_pList), m_pItem(src.m_pItem) {}
+
+        iterator dropConst() const;
+        const T& operator*() const;
+        const T* operator->() const;
+
+        const_iterator& operator++();
+        const_iterator& operator--();
+        const_iterator operator++(int);
+        const_iterator operator--(int);
+
+        bool operator==(const const_iterator& rhs) const;
+        bool operator!=(const const_iterator& rhs) const;
+
+    private:
+        const List<T>* m_pList = NULL;
+        const Item* m_pItem = NULL;
+
+        const_iterator(const List<T>* pList, const Item* pItem)
+            : m_pList(pList), m_pItem(pItem) {}
+    };
+
+    class const_reverse_iterator
+    {
+        friend class List<T>;
+
+    public:
+        const_reverse_iterator() = default;
+        const_reverse_iterator(const iterator& src)
+            : m_pList(src.m_pList), m_pItem(src.m_pItem) {}
+        const_reverse_iterator(const reverse_iterator& src)
+            : m_pList(src.m_pList), m_pItem(src.m_pItem) {}
+        const_reverse_iterator(const const_iterator& src)
+            : m_pList(src.m_pList), m_pItem(src.m_pItem) {}
+
+        reverse_iterator dropConst() const;
+        const T& operator*() const;
+        const T* operator->() const;
+
+        const_reverse_iterator& operator++();
+        const_reverse_iterator& operator--();
+        const_reverse_iterator operator++(int);
+        const_reverse_iterator operator--(int);
+
+        bool operator==(const const_reverse_iterator& rhs) const;
+        bool operator!=(const const_reverse_iterator& rhs) const;
+
+    private:
+        const List<T>* m_pList = NULL;
+        const Item* m_pItem = NULL;
+
+        const_reverse_iterator(const List<T>* pList, const Item* pItem)
+            : m_pList(pList), m_pItem(pItem) {}
+    };
+
+    // allocationCallbacks externally owned, must outlive this object.
+    List(const ALLOCATION_CALLBACKS& allocationCallbacks);
+    // Intentionally not calling Clear, because that would be unnecessary
+    // computations to return all items to m_ItemAllocator as free.
+    ~List() = default;
+    
+    size_t GetCount() const { return m_Count; }
+    bool IsEmpty() const { return m_Count == 0; }
+
+    Item* Front() { return m_pFront; }
+    const Item* Front() const { return m_pFront; }
+    Item* Back() { return m_pBack; }
+    const Item* Back() const { return m_pBack; }
+
+    bool empty() const { return IsEmpty(); }
+    size_t size() const { return GetCount(); }
+    void push_back(const T& value) { PushBack(value); }
+    iterator insert(iterator it, const T& value) { return iterator(this, InsertBefore(it.m_pItem, value)); }
+    void clear() { Clear(); }
+    void erase(iterator it) { Remove(it.m_pItem); }
+
+    iterator begin() { return iterator(this, Front()); }
+    iterator end() { return iterator(this, NULL); }
+    reverse_iterator rbegin() { return reverse_iterator(this, Back()); }
+    reverse_iterator rend() { return reverse_iterator(this, NULL); }
+
+    const_iterator cbegin() const { return const_iterator(this, Front()); }
+    const_iterator cend() const { return const_iterator(this, NULL); }
+    const_iterator begin() const { return cbegin(); }
+    const_iterator end() const { return cend(); }
+
+    const_reverse_iterator crbegin() const { return const_reverse_iterator(this, Back()); }
+    const_reverse_iterator crend() const { return const_reverse_iterator(this, NULL); }
+    const_reverse_iterator rbegin() const { return crbegin(); }
+    const_reverse_iterator rend() const { return crend(); }
+
+    Item* PushBack();
+    Item* PushFront();
+    Item* PushBack(const T& value);
+    Item* PushFront(const T& value);
+    void PopBack();
+    void PopFront();
+
+    // Item can be null - it means PushBack.
+    Item* InsertBefore(Item* pItem);
+    // Item can be null - it means PushFront.
+    Item* InsertAfter(Item* pItem);
+    Item* InsertBefore(Item* pItem, const T& value);
+    Item* InsertAfter(Item* pItem, const T& value);
+
+    void Clear();
+    void Remove(Item* pItem);
+
+private:
+    const ALLOCATION_CALLBACKS& m_AllocationCallbacks;
+    PoolAllocator<Item> m_ItemAllocator;
+    Item* m_pFront;
+    Item* m_pBack;
+    size_t m_Count;
+};
+
+#ifndef _D3D12MA_LIST_ITERATOR_FUNCTIONS
+template<typename T>
+T& List<T>::iterator::operator*() const
+{
+    D3D12MA_HEAVY_ASSERT(m_pItem != NULL);
+    return m_pItem->Value;
+}
+
+template<typename T>
+T* List<T>::iterator::operator->() const
+{
+    D3D12MA_HEAVY_ASSERT(m_pItem != NULL);
+    return &m_pItem->Value;
+}
+
+template<typename T>
+typename List<T>::iterator& List<T>::iterator::operator++()
+{
+    D3D12MA_HEAVY_ASSERT(m_pItem != NULL);
+    m_pItem = m_pItem->pNext;
+    return *this;
+}
+
+template<typename T>
+typename List<T>::iterator& List<T>::iterator::operator--()
+{
+    if (m_pItem != NULL)
+    {
+        m_pItem = m_pItem->pPrev;
+    }
+    else
+    {
+        D3D12MA_HEAVY_ASSERT(!m_pList->IsEmpty());
+        m_pItem = m_pList->Back();
+    }
+    return *this;
+}
+
+template<typename T>
+typename List<T>::iterator List<T>::iterator::operator++(int)
+{
+    iterator result = *this;
+    ++* this;
+    return result;
+}
+
+template<typename T>
+typename List<T>::iterator List<T>::iterator::operator--(int)
+{
+    iterator result = *this;
+    --* this;
+    return result;
+}
+
+template<typename T>
+bool List<T>::iterator::operator==(const iterator& rhs) const
+{
+    D3D12MA_HEAVY_ASSERT(m_pList == rhs.m_pList);
+    return m_pItem == rhs.m_pItem;
+}
+
+template<typename T>
+bool List<T>::iterator::operator!=(const iterator& rhs) const
+{
+    D3D12MA_HEAVY_ASSERT(m_pList == rhs.m_pList);
+    return m_pItem != rhs.m_pItem;
+}
+#endif // _D3D12MA_LIST_ITERATOR_FUNCTIONS
+
+#ifndef _D3D12MA_LIST_REVERSE_ITERATOR_FUNCTIONS
+template<typename T>
+T& List<T>::reverse_iterator::operator*() const
+{
+    D3D12MA_HEAVY_ASSERT(m_pItem != NULL);
+    return m_pItem->Value;
+}
+
+template<typename T>
+T* List<T>::reverse_iterator::operator->() const
+{
+    D3D12MA_HEAVY_ASSERT(m_pItem != NULL);
+    return &m_pItem->Value;
+}
+
+template<typename T>
+typename List<T>::reverse_iterator& List<T>::reverse_iterator::operator++()
+{
+    D3D12MA_HEAVY_ASSERT(m_pItem != NULL);
+    m_pItem = m_pItem->pPrev;
+    return *this;
+}
+
+template<typename T>
+typename List<T>::reverse_iterator& List<T>::reverse_iterator::operator--()
+{
+    if (m_pItem != NULL)
+    {
+        m_pItem = m_pItem->pNext;
+    }
+    else
+    {
+        D3D12MA_HEAVY_ASSERT(!m_pList->IsEmpty());
+        m_pItem = m_pList->Front();
+    }
+    return *this;
+}
+
+template<typename T>
+typename List<T>::reverse_iterator List<T>::reverse_iterator::operator++(int)
+{
+    reverse_iterator result = *this;
+    ++* this;
+    return result;
+}
+
+template<typename T>
+typename List<T>::reverse_iterator List<T>::reverse_iterator::operator--(int)
+{
+    reverse_iterator result = *this;
+    --* this;
+    return result;
+}
+
+template<typename T>
+bool List<T>::reverse_iterator::operator==(const reverse_iterator& rhs) const
+{
+    D3D12MA_HEAVY_ASSERT(m_pList == rhs.m_pList);
+    return m_pItem == rhs.m_pItem;
+}
+
+template<typename T>
+bool List<T>::reverse_iterator::operator!=(const reverse_iterator& rhs) const
+{
+    D3D12MA_HEAVY_ASSERT(m_pList == rhs.m_pList);
+    return m_pItem != rhs.m_pItem;
+}
+#endif // _D3D12MA_LIST_REVERSE_ITERATOR_FUNCTIONS
+
+#ifndef _D3D12MA_LIST_CONST_ITERATOR_FUNCTIONS
+template<typename T>
+typename List<T>::iterator List<T>::const_iterator::dropConst() const
+{
+    return iterator(const_cast<List<T>*>(m_pList), const_cast<Item*>(m_pItem));
+}
+
+template<typename T>
+const T& List<T>::const_iterator::operator*() const
+{
+    D3D12MA_HEAVY_ASSERT(m_pItem != NULL);
+    return m_pItem->Value;
+}
+
+template<typename T>
+const T* List<T>::const_iterator::operator->() const
+{
+    D3D12MA_HEAVY_ASSERT(m_pItem != NULL);
+    return &m_pItem->Value;
+}
+
+template<typename T>
+typename List<T>::const_iterator& List<T>::const_iterator::operator++()
+{
+    D3D12MA_HEAVY_ASSERT(m_pItem != NULL);
+    m_pItem = m_pItem->pNext;
+    return *this;
+}
+
+template<typename T>
+typename List<T>::const_iterator& List<T>::const_iterator::operator--()
+{
+    if (m_pItem != NULL)
+    {
+        m_pItem = m_pItem->pPrev;
+    }
+    else
+    {
+        D3D12MA_HEAVY_ASSERT(!m_pList->IsEmpty());
+        m_pItem = m_pList->Back();
+    }
+    return *this;
+}
+
+template<typename T>
+typename List<T>::const_iterator List<T>::const_iterator::operator++(int)
+{
+    const_iterator result = *this;
+    ++* this;
+    return result;
+}
+
+template<typename T>
+typename List<T>::const_iterator List<T>::const_iterator::operator--(int)
+{
+    const_iterator result = *this;
+    --* this;
+    return result;
+}
+
+template<typename T>
+bool List<T>::const_iterator::operator==(const const_iterator& rhs) const
+{
+    D3D12MA_HEAVY_ASSERT(m_pList == rhs.m_pList);
+    return m_pItem == rhs.m_pItem;
+}
+
+template<typename T>
+bool List<T>::const_iterator::operator!=(const const_iterator& rhs) const
+{
+    D3D12MA_HEAVY_ASSERT(m_pList == rhs.m_pList);
+    return m_pItem != rhs.m_pItem;
+}
+#endif // _D3D12MA_LIST_CONST_ITERATOR_FUNCTIONS
+
+#ifndef _D3D12MA_LIST_CONST_REVERSE_ITERATOR_FUNCTIONS
+template<typename T>
+typename List<T>::reverse_iterator List<T>::const_reverse_iterator::dropConst() const
+{
+    return reverse_iterator(const_cast<List<T>*>(m_pList), const_cast<Item*>(m_pItem));
+}
+
+template<typename T>
+const T& List<T>::const_reverse_iterator::operator*() const
+{
+    D3D12MA_HEAVY_ASSERT(m_pItem != NULL);
+    return m_pItem->Value;
+}
+
+template<typename T>
+const T* List<T>::const_reverse_iterator::operator->() const
+{
+    D3D12MA_HEAVY_ASSERT(m_pItem != NULL);
+    return &m_pItem->Value;
+}
+
+template<typename T>
+typename List<T>::const_reverse_iterator& List<T>::const_reverse_iterator::operator++()
+{
+    D3D12MA_HEAVY_ASSERT(m_pItem != NULL);
+    m_pItem = m_pItem->pPrev;
+    return *this;
+}
+
+template<typename T>
+typename List<T>::const_reverse_iterator& List<T>::const_reverse_iterator::operator--()
+{
+    if (m_pItem != NULL)
+    {
+        m_pItem = m_pItem->pNext;
+    }
+    else
+    {
+        D3D12MA_HEAVY_ASSERT(!m_pList->IsEmpty());
+        m_pItem = m_pList->Front();
+    }
+    return *this;
+}
+
+template<typename T>
+typename List<T>::const_reverse_iterator List<T>::const_reverse_iterator::operator++(int)
+{
+    const_reverse_iterator result = *this;
+    ++* this;
+    return result;
+}
+
+template<typename T>
+typename List<T>::const_reverse_iterator List<T>::const_reverse_iterator::operator--(int)
+{
+    const_reverse_iterator result = *this;
+    --* this;
+    return result;
+}
+
+template<typename T>
+bool List<T>::const_reverse_iterator::operator==(const const_reverse_iterator& rhs) const
+{
+    D3D12MA_HEAVY_ASSERT(m_pList == rhs.m_pList);
+    return m_pItem == rhs.m_pItem;
+}
+
+template<typename T>
+bool List<T>::const_reverse_iterator::operator!=(const const_reverse_iterator& rhs) const
+{
+    D3D12MA_HEAVY_ASSERT(m_pList == rhs.m_pList);
+    return m_pItem != rhs.m_pItem;
+}
+#endif // _D3D12MA_LIST_CONST_REVERSE_ITERATOR_FUNCTIONS
+
+#ifndef _D3D12MA_LIST_FUNCTIONS
+template<typename T>
+List<T>::List(const ALLOCATION_CALLBACKS& allocationCallbacks)
+    : m_AllocationCallbacks(allocationCallbacks),
+    m_ItemAllocator(allocationCallbacks, 128),
+    m_pFront(NULL),
+    m_pBack(NULL),
+    m_Count(0) {}
+
+template<typename T>
+void List<T>::Clear()
+{
+    if(!IsEmpty())
+    {
+        Item* pItem = m_pBack;
+        while(pItem != NULL)
+        {
+            Item* const pPrevItem = pItem->pPrev;
+            m_ItemAllocator.Free(pItem);
+            pItem = pPrevItem;
+        }
+        m_pFront = NULL;
+        m_pBack = NULL;
+        m_Count = 0;
+    }
+}
+
+template<typename T>
+typename List<T>::Item* List<T>::PushBack()
+{
+    Item* const pNewItem = m_ItemAllocator.Alloc();
+    pNewItem->pNext = NULL;
+    if(IsEmpty())
+    {
+        pNewItem->pPrev = NULL;
+        m_pFront = pNewItem;
+        m_pBack = pNewItem;
+        m_Count = 1;
+    }
+    else
+    {
+        pNewItem->pPrev = m_pBack;
+        m_pBack->pNext = pNewItem;
+        m_pBack = pNewItem;
+        ++m_Count;
+    }
+    return pNewItem;
+}
+
+template<typename T>
+typename List<T>::Item* List<T>::PushFront()
+{
+    Item* const pNewItem = m_ItemAllocator.Alloc();
+    pNewItem->pPrev = NULL;
+    if(IsEmpty())
+    {
+        pNewItem->pNext = NULL;
+        m_pFront = pNewItem;
+        m_pBack = pNewItem;
+        m_Count = 1;
+    }
+    else
+    {
+        pNewItem->pNext = m_pFront;
+        m_pFront->pPrev = pNewItem;
+        m_pFront = pNewItem;
+        ++m_Count;
+    }
+    return pNewItem;
+}
+
+template<typename T>
+typename List<T>::Item* List<T>::PushBack(const T& value)
+{
+    Item* const pNewItem = PushBack();
+    pNewItem->Value = value;
+    return pNewItem;
+}
+
+template<typename T>
+typename List<T>::Item* List<T>::PushFront(const T& value)
+{
+    Item* const pNewItem = PushFront();
+    pNewItem->Value = value;
+    return pNewItem;
+}
+
+template<typename T>
+void List<T>::PopBack()
+{
+    D3D12MA_HEAVY_ASSERT(m_Count > 0);
+    Item* const pBackItem = m_pBack;
+    Item* const pPrevItem = pBackItem->pPrev;
+    if(pPrevItem != NULL)
+    {
+        pPrevItem->pNext = NULL;
+    }
+    m_pBack = pPrevItem;
+    m_ItemAllocator.Free(pBackItem);
+    --m_Count;
+}
+
+template<typename T>
+void List<T>::PopFront()
+{
+    D3D12MA_HEAVY_ASSERT(m_Count > 0);
+    Item* const pFrontItem = m_pFront;
+    Item* const pNextItem = pFrontItem->pNext;
+    if(pNextItem != NULL)
+    {
+        pNextItem->pPrev = NULL;
+    }
+    m_pFront = pNextItem;
+    m_ItemAllocator.Free(pFrontItem);
+    --m_Count;
+}
+
+template<typename T>
+void List<T>::Remove(Item* pItem)
+{
+    D3D12MA_HEAVY_ASSERT(pItem != NULL);
+    D3D12MA_HEAVY_ASSERT(m_Count > 0);
+
+    if(pItem->pPrev != NULL)
+    {
+        pItem->pPrev->pNext = pItem->pNext;
+    }
+    else
+    {
+        D3D12MA_HEAVY_ASSERT(m_pFront == pItem);
+        m_pFront = pItem->pNext;
+    }
+
+    if(pItem->pNext != NULL)
+    {
+        pItem->pNext->pPrev = pItem->pPrev;
+    }
+    else
+    {
+        D3D12MA_HEAVY_ASSERT(m_pBack == pItem);
+        m_pBack = pItem->pPrev;
+    }
+
+    m_ItemAllocator.Free(pItem);
+    --m_Count;
+}
+
+template<typename T>
+typename List<T>::Item* List<T>::InsertBefore(Item* pItem)
+{
+    if(pItem != NULL)
+    {
+        Item* const prevItem = pItem->pPrev;
+        Item* const newItem = m_ItemAllocator.Alloc();
+        newItem->pPrev = prevItem;
+        newItem->pNext = pItem;
+        pItem->pPrev = newItem;
+        if(prevItem != NULL)
+        {
+            prevItem->pNext = newItem;
+        }
+        else
+        {
+            D3D12MA_HEAVY_ASSERT(m_pFront == pItem);
+            m_pFront = newItem;
+        }
+        ++m_Count;
+        return newItem;
+    }
+    else
+    {
+        return PushBack();
+    }
+}
+
+template<typename T>
+typename List<T>::Item* List<T>::InsertAfter(Item* pItem)
+{
+    if(pItem != NULL)
+    {
+        Item* const nextItem = pItem->pNext;
+        Item* const newItem = m_ItemAllocator.Alloc();
+        newItem->pNext = nextItem;
+        newItem->pPrev = pItem;
+        pItem->pNext = newItem;
+        if(nextItem != NULL)
+        {
+            nextItem->pPrev = newItem;
+        }
+        else
+        {
+            D3D12MA_HEAVY_ASSERT(m_pBack == pItem);
+            m_pBack = newItem;
+        }
+        ++m_Count;
+        return newItem;
+    }
+    else
+        return PushFront();
+}
+
+template<typename T>
+typename List<T>::Item* List<T>::InsertBefore(Item* pItem, const T& value)
+{
+    Item* const newItem = InsertBefore(pItem);
+    newItem->Value = value;
+    return newItem;
+}
+
+template<typename T>
+typename List<T>::Item* List<T>::InsertAfter(Item* pItem, const T& value)
+{
+    Item* const newItem = InsertAfter(pItem);
+    newItem->Value = value;
+    return newItem;
+}
+#endif // _D3D12MA_LIST_FUNCTIONS
+#endif // _D3D12MA_LIST
+
+#ifndef _D3D12MA_INTRUSIVE_LINKED_LIST
+/*
+Expected interface of ItemTypeTraits:
+struct MyItemTypeTraits
+{
+    using ItemType = MyItem;
+    static ItemType* GetPrev(const ItemType* item) { return item->myPrevPtr; }
+    static ItemType* GetNext(const ItemType* item) { return item->myNextPtr; }
+    static ItemType*& AccessPrev(ItemType* item) { return item->myPrevPtr; }
+    static ItemType*& AccessNext(ItemType* item) { return item->myNextPtr; }
+};
+*/
+template<typename ItemTypeTraits>
+class IntrusiveLinkedList
+{
+public:
+    using ItemType = typename ItemTypeTraits::ItemType;
+    static ItemType* GetPrev(const ItemType* item) { return ItemTypeTraits::GetPrev(item); }
+    static ItemType* GetNext(const ItemType* item) { return ItemTypeTraits::GetNext(item); }
+
+    // Movable, not copyable.
+    IntrusiveLinkedList() = default;
+    IntrusiveLinkedList(const IntrusiveLinkedList&) = delete;
+    IntrusiveLinkedList(IntrusiveLinkedList&& src);
+    IntrusiveLinkedList& operator=(const IntrusiveLinkedList&) = delete;
+    IntrusiveLinkedList& operator=(IntrusiveLinkedList&& src);
+    ~IntrusiveLinkedList() { D3D12MA_HEAVY_ASSERT(IsEmpty()); }
+
+    size_t GetCount() const { return m_Count; }
+    bool IsEmpty() const { return m_Count == 0; }
+
+    ItemType* Front() { return m_Front; }
+    ItemType* Back() { return m_Back; }
+    const ItemType* Front() const { return m_Front; }
+    const ItemType* Back() const { return m_Back; }
+
+    void PushBack(ItemType* item);
+    void PushFront(ItemType* item);
+    ItemType* PopBack();
+    ItemType* PopFront();
+
+    // MyItem can be null - it means PushBack.
+    void InsertBefore(ItemType* existingItem, ItemType* newItem);
+    // MyItem can be null - it means PushFront.
+    void InsertAfter(ItemType* existingItem, ItemType* newItem);
+
+    void Remove(ItemType* item);
+    void RemoveAll();
+
+private:
+    ItemType* m_Front = NULL;
+    ItemType* m_Back = NULL;
+    size_t m_Count = 0;
+};
+
+#ifndef _D3D12MA_INTRUSIVE_LINKED_LIST_FUNCTIONS
+template<typename ItemTypeTraits>
+IntrusiveLinkedList<ItemTypeTraits>::IntrusiveLinkedList(IntrusiveLinkedList&& src)
+    : m_Front(src.m_Front), m_Back(src.m_Back), m_Count(src.m_Count)
+{
+    src.m_Front = src.m_Back = NULL;
+    src.m_Count = 0;
+}
+
+template<typename ItemTypeTraits>
+IntrusiveLinkedList<ItemTypeTraits>& IntrusiveLinkedList<ItemTypeTraits>::operator=(IntrusiveLinkedList&& src)
+{
+    if (&src != this)
+    {
+        D3D12MA_HEAVY_ASSERT(IsEmpty());
+        m_Front = src.m_Front;
+        m_Back = src.m_Back;
+        m_Count = src.m_Count;
+        src.m_Front = src.m_Back = NULL;
+        src.m_Count = 0;
+    }
+    return *this;
+}
+
+template<typename ItemTypeTraits>
+void IntrusiveLinkedList<ItemTypeTraits>::PushBack(ItemType* item)
+{
+    D3D12MA_HEAVY_ASSERT(ItemTypeTraits::GetPrev(item) == NULL && ItemTypeTraits::GetNext(item) == NULL);
+    if (IsEmpty())
+    {
+        m_Front = item;
+        m_Back = item;
+        m_Count = 1;
+    }
+    else
+    {
+        ItemTypeTraits::AccessPrev(item) = m_Back;
+        ItemTypeTraits::AccessNext(m_Back) = item;
+        m_Back = item;
+        ++m_Count;
+    }
+}
+
+template<typename ItemTypeTraits>
+void IntrusiveLinkedList<ItemTypeTraits>::PushFront(ItemType* item)
+{
+    D3D12MA_HEAVY_ASSERT(ItemTypeTraits::GetPrev(item) == NULL && ItemTypeTraits::GetNext(item) == NULL);
+    if (IsEmpty())
+    {
+        m_Front = item;
+        m_Back = item;
+        m_Count = 1;
+    }
+    else
+    {
+        ItemTypeTraits::AccessNext(item) = m_Front;
+        ItemTypeTraits::AccessPrev(m_Front) = item;
+        m_Front = item;
+        ++m_Count;
+    }
+}
+
+template<typename ItemTypeTraits>
+typename IntrusiveLinkedList<ItemTypeTraits>::ItemType* IntrusiveLinkedList<ItemTypeTraits>::PopBack()
+{
+    D3D12MA_HEAVY_ASSERT(m_Count > 0);
+    ItemType* const backItem = m_Back;
+    ItemType* const prevItem = ItemTypeTraits::GetPrev(backItem);
+    if (prevItem != NULL)
+    {
+        ItemTypeTraits::AccessNext(prevItem) = NULL;
+    }
+    m_Back = prevItem;
+    --m_Count;
+    ItemTypeTraits::AccessPrev(backItem) = NULL;
+    ItemTypeTraits::AccessNext(backItem) = NULL;
+    return backItem;
+}
+
+template<typename ItemTypeTraits>
+typename IntrusiveLinkedList<ItemTypeTraits>::ItemType* IntrusiveLinkedList<ItemTypeTraits>::PopFront()
+{
+    D3D12MA_HEAVY_ASSERT(m_Count > 0);
+    ItemType* const frontItem = m_Front;
+    ItemType* const nextItem = ItemTypeTraits::GetNext(frontItem);
+    if (nextItem != NULL)
+    {
+        ItemTypeTraits::AccessPrev(nextItem) = NULL;
+    }
+    m_Front = nextItem;
+    --m_Count;
+    ItemTypeTraits::AccessPrev(frontItem) = NULL;
+    ItemTypeTraits::AccessNext(frontItem) = NULL;
+    return frontItem;
+}
+
+template<typename ItemTypeTraits>
+void IntrusiveLinkedList<ItemTypeTraits>::InsertBefore(ItemType* existingItem, ItemType* newItem)
+{
+    D3D12MA_HEAVY_ASSERT(newItem != NULL && ItemTypeTraits::GetPrev(newItem) == NULL && ItemTypeTraits::GetNext(newItem) == NULL);
+    if (existingItem != NULL)
+    {
+        ItemType* const prevItem = ItemTypeTraits::GetPrev(existingItem);
+        ItemTypeTraits::AccessPrev(newItem) = prevItem;
+        ItemTypeTraits::AccessNext(newItem) = existingItem;
+        ItemTypeTraits::AccessPrev(existingItem) = newItem;
+        if (prevItem != NULL)
+        {
+            ItemTypeTraits::AccessNext(prevItem) = newItem;
+        }
+        else
+        {
+            D3D12MA_HEAVY_ASSERT(m_Front == existingItem);
+            m_Front = newItem;
+        }
+        ++m_Count;
+    }
+    else
+        PushBack(newItem);
+}
+
+template<typename ItemTypeTraits>
+void IntrusiveLinkedList<ItemTypeTraits>::InsertAfter(ItemType* existingItem, ItemType* newItem)
+{
+    D3D12MA_HEAVY_ASSERT(newItem != NULL && ItemTypeTraits::GetPrev(newItem) == NULL && ItemTypeTraits::GetNext(newItem) == NULL);
+    if (existingItem != NULL)
+    {
+        ItemType* const nextItem = ItemTypeTraits::GetNext(existingItem);
+        ItemTypeTraits::AccessNext(newItem) = nextItem;
+        ItemTypeTraits::AccessPrev(newItem) = existingItem;
+        ItemTypeTraits::AccessNext(existingItem) = newItem;
+        if (nextItem != NULL)
+        {
+            ItemTypeTraits::AccessPrev(nextItem) = newItem;
+        }
+        else
+        {
+            D3D12MA_HEAVY_ASSERT(m_Back == existingItem);
+            m_Back = newItem;
+        }
+        ++m_Count;
+    }
+    else
+        return PushFront(newItem);
+}
+
+template<typename ItemTypeTraits>
+void IntrusiveLinkedList<ItemTypeTraits>::Remove(ItemType* item)
+{
+    D3D12MA_HEAVY_ASSERT(item != NULL && m_Count > 0);
+    if (ItemTypeTraits::GetPrev(item) != NULL)
+    {
+        ItemTypeTraits::AccessNext(ItemTypeTraits::AccessPrev(item)) = ItemTypeTraits::GetNext(item);
+    }
+    else
+    {
+        D3D12MA_HEAVY_ASSERT(m_Front == item);
+        m_Front = ItemTypeTraits::GetNext(item);
+    }
+
+    if (ItemTypeTraits::GetNext(item) != NULL)
+    {
+        ItemTypeTraits::AccessPrev(ItemTypeTraits::AccessNext(item)) = ItemTypeTraits::GetPrev(item);
+    }
+    else
+    {
+        D3D12MA_HEAVY_ASSERT(m_Back == item);
+        m_Back = ItemTypeTraits::GetPrev(item);
+    }
+    ItemTypeTraits::AccessPrev(item) = NULL;
+    ItemTypeTraits::AccessNext(item) = NULL;
+    --m_Count;
+}
+
+template<typename ItemTypeTraits>
+void IntrusiveLinkedList<ItemTypeTraits>::RemoveAll()
+{
+    if (!IsEmpty())
+    {
+        ItemType* item = m_Back;
+        while (item != NULL)
+        {
+            ItemType* const prevItem = ItemTypeTraits::AccessPrev(item);
+            ItemTypeTraits::AccessPrev(item) = NULL;
+            ItemTypeTraits::AccessNext(item) = NULL;
+            item = prevItem;
+        }
+        m_Front = NULL;
+        m_Back = NULL;
+        m_Count = 0;
+    }
+}
+#endif // _D3D12MA_INTRUSIVE_LINKED_LIST_FUNCTIONS
+#endif // _D3D12MA_INTRUSIVE_LINKED_LIST
+
+#ifndef _D3D12MA_ALLOCATION_OBJECT_ALLOCATOR
+/*
+Thread-safe wrapper over PoolAllocator free list, for allocation of Allocation objects.
+*/
+class AllocationObjectAllocator
+{
+    D3D12MA_CLASS_NO_COPY(AllocationObjectAllocator);
+public:
+    AllocationObjectAllocator(const ALLOCATION_CALLBACKS& allocationCallbacks)
+        : m_Allocator(allocationCallbacks, 1024) {}
+
+    template<typename... Types>
+    Allocation* Allocate(Types... args);
+    void Free(Allocation* alloc);
+
+private:
+    D3D12MA_MUTEX m_Mutex;
+    PoolAllocator<Allocation> m_Allocator;
+};
+
+#ifndef _D3D12MA_ALLOCATION_OBJECT_ALLOCATOR_FUNCTIONS
+template<typename... Types>
+Allocation* AllocationObjectAllocator::Allocate(Types... args)
+{
+    MutexLock mutexLock(m_Mutex);
+    return m_Allocator.Alloc(std::forward<Types>(args)...);
+}
+
+void AllocationObjectAllocator::Free(Allocation* alloc)
+{
+    MutexLock mutexLock(m_Mutex);
+    m_Allocator.Free(alloc);
+}
+#endif // _D3D12MA_ALLOCATION_OBJECT_ALLOCATOR_FUNCTIONS
+#endif // _D3D12MA_ALLOCATION_OBJECT_ALLOCATOR
+
+#ifndef _D3D12MA_SUBALLOCATION
+/*
+Represents a region of NormalBlock that is either assigned and returned as
+allocated memory block or free.
+*/
+struct Suballocation
+{
+    UINT64 offset;
+    UINT64 size;
+    void* privateData;
+    SuballocationType type;
+};
+using SuballocationList = List<Suballocation>;
+
+// Comparator for offsets.
+struct SuballocationOffsetLess
+{
+    bool operator()(const Suballocation& lhs, const Suballocation& rhs) const
+    {
+        return lhs.offset < rhs.offset;
+    }
+};
+
+struct SuballocationOffsetGreater
+{
+    bool operator()(const Suballocation& lhs, const Suballocation& rhs) const
+    {
+        return lhs.offset > rhs.offset;
+    }
+};
+
+struct SuballocationItemSizeLess
+{
+    bool operator()(const SuballocationList::iterator lhs, const SuballocationList::iterator rhs) const
+    {
+        return lhs->size < rhs->size;
+    }
+    bool operator()(const SuballocationList::iterator lhs, UINT64 rhsSize) const
+    {
+        return lhs->size < rhsSize;
+    }
+};
+#endif // _D3D12MA_SUBALLOCATION
+
+#ifndef _D3D12MA_ALLOCATION_REQUEST
+/*
+Parameters of planned allocation inside a NormalBlock.
+*/
+struct AllocationRequest
+{
+    AllocHandle allocHandle;
+    UINT64 size;
+    UINT64 algorithmData;
+    UINT64 sumFreeSize; // Sum size of free items that overlap with proposed allocation.
+    UINT64 sumItemSize; // Sum size of items to make lost that overlap with proposed allocation.
+    SuballocationList::iterator item;
+    BOOL zeroInitialized = FALSE; // TODO Implement proper handling in TLSF and Linear, using ZeroInitializedRange class.
+};
+#endif // _D3D12MA_ALLOCATION_REQUEST
+
+#ifndef _D3D12MA_ZERO_INITIALIZED_RANGE
+/*
+Keeps track of the range of bytes that are surely initialized with zeros.
+Everything outside of it is considered uninitialized memory that may contain
+garbage data.
+
+The range is left-inclusive.
+*/
+class ZeroInitializedRange
+{
+public:
+    void Reset(UINT64 size);
+    BOOL IsRangeZeroInitialized(UINT64 beg, UINT64 end) const;
+    void MarkRangeAsUsed(UINT64 usedBeg, UINT64 usedEnd);
+
+private:
+    UINT64 m_ZeroBeg = 0, m_ZeroEnd = 0;
+};
+
+#ifndef _D3D12MA_ZERO_INITIALIZED_RANGE_FUNCTIONS
+void ZeroInitializedRange::Reset(UINT64 size)
+{
+    D3D12MA_ASSERT(size > 0);
+    m_ZeroBeg = 0;
+    m_ZeroEnd = size;
+}
+
+BOOL ZeroInitializedRange::IsRangeZeroInitialized(UINT64 beg, UINT64 end) const
+{
+    D3D12MA_ASSERT(beg < end);
+    return m_ZeroBeg <= beg && end <= m_ZeroEnd;
+}
+
+void ZeroInitializedRange::MarkRangeAsUsed(UINT64 usedBeg, UINT64 usedEnd)
+{
+    D3D12MA_ASSERT(usedBeg < usedEnd);
+    // No new bytes marked.
+    if (usedEnd <= m_ZeroBeg || m_ZeroEnd <= usedBeg)
+    {
+        return;
+    }
+    // All bytes marked.
+    if (usedBeg <= m_ZeroBeg && m_ZeroEnd <= usedEnd)
+    {
+        m_ZeroBeg = m_ZeroEnd = 0;
+    }
+    // Some bytes marked.
+    else
+    {
+        const UINT64 remainingZeroBefore = usedBeg > m_ZeroBeg ? usedBeg - m_ZeroBeg : 0;
+        const UINT64 remainingZeroAfter = usedEnd < m_ZeroEnd ? m_ZeroEnd - usedEnd : 0;
+        D3D12MA_ASSERT(remainingZeroBefore > 0 || remainingZeroAfter > 0);
+        if (remainingZeroBefore > remainingZeroAfter)
+        {
+            m_ZeroEnd = usedBeg;
+        }
+        else
+        {
+            m_ZeroBeg = usedEnd;
+        }
+    }
+}
+#endif // _D3D12MA_ZERO_INITIALIZED_RANGE_FUNCTIONS
+#endif // _D3D12MA_ZERO_INITIALIZED_RANGE
+
+#ifndef _D3D12MA_BLOCK_METADATA
+/*
+Data structure used for bookkeeping of allocations and unused ranges of memory
+in a single ID3D12Heap memory block.
+*/
+class BlockMetadata
+{
+public:
+    BlockMetadata(const ALLOCATION_CALLBACKS* allocationCallbacks, bool isVirtual);
+    virtual ~BlockMetadata() = default;
+
+    virtual void Init(UINT64 size) { m_Size = size; }
+    // Validates all data structures inside this object. If not valid, returns false.
+    virtual bool Validate() const = 0;
+    UINT64 GetSize() const { return m_Size; }
+    bool IsVirtual() const { return m_IsVirtual; }
+    virtual size_t GetAllocationCount() const = 0;
+    virtual size_t GetFreeRegionsCount() const = 0;
+    virtual UINT64 GetSumFreeSize() const = 0;
+    virtual UINT64 GetAllocationOffset(AllocHandle allocHandle) const = 0;
+    // Returns true if this block is empty - contains only single free suballocation.
+    virtual bool IsEmpty() const = 0;
+
+    virtual void GetAllocationInfo(AllocHandle allocHandle, VIRTUAL_ALLOCATION_INFO& outInfo) const = 0;
+
+    // Tries to find a place for suballocation with given parameters inside this block.
+    // If succeeded, fills pAllocationRequest and returns true.
+    // If failed, returns false.
+    virtual bool CreateAllocationRequest(
+        UINT64 allocSize,
+        UINT64 allocAlignment,
+        bool upperAddress,
+        UINT32 strategy,
+        AllocationRequest* pAllocationRequest) = 0;
+
+    // Makes actual allocation based on request. Request must already be checked and valid.
+    virtual void Alloc(
+        const AllocationRequest& request,
+        UINT64 allocSize,
+        void* PrivateData) = 0;
+
+    virtual void Free(AllocHandle allocHandle) = 0;
+    // Frees all allocations.
+    // Careful! Don't call it if there are Allocation objects owned by pPrivateData of of cleared allocations!
+    virtual void Clear() = 0;
+
+    virtual AllocHandle GetAllocationListBegin() const = 0;
+    virtual AllocHandle GetNextAllocation(AllocHandle prevAlloc) const = 0;
+    virtual UINT64 GetNextFreeRegionSize(AllocHandle alloc) const = 0;
+    virtual void* GetAllocationPrivateData(AllocHandle allocHandle) const = 0;
+    virtual void SetAllocationPrivateData(AllocHandle allocHandle, void* privateData) = 0;
+
+    virtual void AddStatistics(Statistics& inoutStats) const = 0;
+    virtual void AddDetailedStatistics(DetailedStatistics& inoutStats) const = 0;
+    virtual void WriteAllocationInfoToJson(JsonWriter& json) const = 0;
+    virtual void DebugLogAllAllocations() const = 0;
+
+protected:
+    const ALLOCATION_CALLBACKS* GetAllocs() const { return m_pAllocationCallbacks; }
+    UINT64 GetDebugMargin() const { return IsVirtual() ? 0 : D3D12MA_DEBUG_MARGIN; }
+
+    void DebugLogAllocation(UINT64 offset, UINT64 size, void* privateData) const;
+    void PrintDetailedMap_Begin(JsonWriter& json,
+        UINT64 unusedBytes,
+        size_t allocationCount,
+        size_t unusedRangeCount) const;
+    void PrintDetailedMap_Allocation(JsonWriter& json,
+        UINT64 offset, UINT64 size, void* privateData) const;
+    void PrintDetailedMap_UnusedRange(JsonWriter& json,
+        UINT64 offset, UINT64 size) const;
+    void PrintDetailedMap_End(JsonWriter& json) const;
+
+private:
+    UINT64 m_Size;
+    bool m_IsVirtual;
+    const ALLOCATION_CALLBACKS* m_pAllocationCallbacks;
+
+    D3D12MA_CLASS_NO_COPY(BlockMetadata);
+};
+
+#ifndef _D3D12MA_BLOCK_METADATA_FUNCTIONS
+BlockMetadata::BlockMetadata(const ALLOCATION_CALLBACKS* allocationCallbacks, bool isVirtual)
+    : m_Size(0),
+    m_IsVirtual(isVirtual),
+    m_pAllocationCallbacks(allocationCallbacks)
+{
+    D3D12MA_ASSERT(allocationCallbacks);
+}
+
+void BlockMetadata::DebugLogAllocation(UINT64 offset, UINT64 size, void* privateData) const
+{
+    if (IsVirtual())
+    {
+        D3D12MA_DEBUG_LOG(L"UNFREED VIRTUAL ALLOCATION; Offset: %llu; Size: %llu; PrivateData: %p", offset, size, privateData);
+    }
+    else
+    {
+        D3D12MA_ASSERT(privateData != NULL);
+        Allocation* allocation = reinterpret_cast<Allocation*>(privateData);
+
+        privateData = allocation->GetPrivateData();
+        LPCWSTR name = allocation->GetName();
+
+        D3D12MA_DEBUG_LOG(L"UNFREED ALLOCATION; Offset: %llu; Size: %llu; PrivateData: %p; Name: %s",
+            offset, size, privateData, name ? name : L"D3D12MA_Empty");
+    }
+}
+
+void BlockMetadata::PrintDetailedMap_Begin(JsonWriter& json,
+    UINT64 unusedBytes, size_t allocationCount, size_t unusedRangeCount) const
+{
+    json.WriteString(L"TotalBytes");
+    json.WriteNumber(GetSize());
+
+    json.WriteString(L"UnusedBytes");
+    json.WriteNumber(unusedBytes);
+
+    json.WriteString(L"Allocations");
+    json.WriteNumber((UINT64)allocationCount);
+
+    json.WriteString(L"UnusedRanges");
+    json.WriteNumber((UINT64)unusedRangeCount);
+
+    json.WriteString(L"Suballocations");
+    json.BeginArray();
+}
+
+void BlockMetadata::PrintDetailedMap_Allocation(JsonWriter& json,
+    UINT64 offset, UINT64 size, void* privateData) const
+{
+    json.BeginObject(true);
+
+    json.WriteString(L"Offset");
+    json.WriteNumber(offset);
+
+    if (IsVirtual())
+    {
+        json.WriteString(L"Size");
+        json.WriteNumber(size);
+        if (privateData)
+        {
+            json.WriteString(L"CustomData");
+            json.WriteNumber((uintptr_t)privateData);
+        }
+    }
+    else
+    {
+        const Allocation* const alloc = (const Allocation*)privateData;
+        D3D12MA_ASSERT(alloc);
+        json.AddAllocationToObject(*alloc);
+    }
+    json.EndObject();
+}
+
+void BlockMetadata::PrintDetailedMap_UnusedRange(JsonWriter& json,
+    UINT64 offset, UINT64 size) const
+{
+    json.BeginObject(true);
+
+    json.WriteString(L"Offset");
+    json.WriteNumber(offset);
+
+    json.WriteString(L"Type");
+    json.WriteString(L"FREE");
+
+    json.WriteString(L"Size");
+    json.WriteNumber(size);
+
+    json.EndObject();
+}
+
+void BlockMetadata::PrintDetailedMap_End(JsonWriter& json) const
+{
+    json.EndArray();
+}
+#endif // _D3D12MA_BLOCK_METADATA_FUNCTIONS
+#endif // _D3D12MA_BLOCK_METADATA
+
+#if 0
+#ifndef _D3D12MA_BLOCK_METADATA_GENERIC
+class BlockMetadata_Generic : public BlockMetadata
+{
+public:
+    BlockMetadata_Generic(const ALLOCATION_CALLBACKS* allocationCallbacks, bool isVirtual);
+    virtual ~BlockMetadata_Generic() = default;
+
+    size_t GetAllocationCount() const override { return m_Suballocations.size() - m_FreeCount; }
+    UINT64 GetSumFreeSize() const override { return m_SumFreeSize; }
+    UINT64 GetAllocationOffset(AllocHandle allocHandle) const override { return (UINT64)allocHandle - 1; }
+
+    void Init(UINT64 size) override;
+    bool Validate() const override;
+    bool IsEmpty() const override;
+    void GetAllocationInfo(AllocHandle allocHandle, VIRTUAL_ALLOCATION_INFO& outInfo) const override;
+
+    bool CreateAllocationRequest(
+        UINT64 allocSize,
+        UINT64 allocAlignment,
+        bool upperAddress,
+        AllocationRequest* pAllocationRequest) override;
+
+    void Alloc(
+        const AllocationRequest& request,
+        UINT64 allocSize,
+        void* privateData) override;
+
+    void Free(AllocHandle allocHandle) override;
+    void Clear() override;
+
+    void SetAllocationPrivateData(AllocHandle allocHandle, void* privateData) override;
+
+    void AddStatistics(Statistics& inoutStats) const override;
+    void AddDetailedStatistics(DetailedStatistics& inoutStats) const override;
+    void WriteAllocationInfoToJson(JsonWriter& json) const override;
+
+private:
+    UINT m_FreeCount;
+    UINT64 m_SumFreeSize;
+    SuballocationList m_Suballocations;
+    // Suballocations that are free and have size greater than certain threshold.
+    // Sorted by size, ascending.
+    Vector<SuballocationList::iterator> m_FreeSuballocationsBySize;
+    ZeroInitializedRange m_ZeroInitializedRange;
+
+    SuballocationList::const_iterator FindAtOffset(UINT64 offset) const;
+    bool ValidateFreeSuballocationList() const;
+
+    // Checks if requested suballocation with given parameters can be placed in given pFreeSuballocItem.
+    // If yes, fills pOffset and returns true. If no, returns false.
+    bool CheckAllocation(
+        UINT64 allocSize,
+        UINT64 allocAlignment,
+        SuballocationList::const_iterator suballocItem,
+        AllocHandle* pAllocHandle,
+        UINT64* pSumFreeSize,
+        UINT64* pSumItemSize,
+        BOOL *pZeroInitialized) const;
+    // Given free suballocation, it merges it with following one, which must also be free.
+    void MergeFreeWithNext(SuballocationList::iterator item);
+    // Releases given suballocation, making it free.
+    // Merges it with adjacent free suballocations if applicable.
+    // Returns iterator to new free suballocation at this place.
+    SuballocationList::iterator FreeSuballocation(SuballocationList::iterator suballocItem);
+    // Given free suballocation, it inserts it into sorted list of
+    // m_FreeSuballocationsBySize if it's suitable.
+    void RegisterFreeSuballocation(SuballocationList::iterator item);
+    // Given free suballocation, it removes it from sorted list of
+    // m_FreeSuballocationsBySize if it's suitable.
+    void UnregisterFreeSuballocation(SuballocationList::iterator item);
+
+    D3D12MA_CLASS_NO_COPY(BlockMetadata_Generic)
+};
+
+#ifndef _D3D12MA_BLOCK_METADATA_GENERIC_FUNCTIONS
+BlockMetadata_Generic::BlockMetadata_Generic(const ALLOCATION_CALLBACKS* allocationCallbacks, bool isVirtual)
+    : BlockMetadata(allocationCallbacks, isVirtual),
+    m_FreeCount(0),
+    m_SumFreeSize(0),
+    m_Suballocations(*allocationCallbacks),
+    m_FreeSuballocationsBySize(*allocationCallbacks)
+{
+    D3D12MA_ASSERT(allocationCallbacks);
+}
+
+void BlockMetadata_Generic::Init(UINT64 size)
+{
+    BlockMetadata::Init(size);
+    m_ZeroInitializedRange.Reset(size);
+
+    m_FreeCount = 1;
+    m_SumFreeSize = size;
+
+    Suballocation suballoc = {};
+    suballoc.offset = 0;
+    suballoc.size = size;
+    suballoc.type = SUBALLOCATION_TYPE_FREE;
+    suballoc.privateData = NULL;
+
+    D3D12MA_ASSERT(size > MIN_FREE_SUBALLOCATION_SIZE_TO_REGISTER);
+    m_Suballocations.push_back(suballoc);
+    SuballocationList::iterator suballocItem = m_Suballocations.end();
+    --suballocItem;
+    m_FreeSuballocationsBySize.push_back(suballocItem);
+}
+
+bool BlockMetadata_Generic::Validate() const
+{
+    D3D12MA_VALIDATE(!m_Suballocations.empty());
+
+    // Expected offset of new suballocation as calculated from previous ones.
+    UINT64 calculatedOffset = 0;
+    // Expected number of free suballocations as calculated from traversing their list.
+    UINT calculatedFreeCount = 0;
+    // Expected sum size of free suballocations as calculated from traversing their list.
+    UINT64 calculatedSumFreeSize = 0;
+    // Expected number of free suballocations that should be registered in
+    // m_FreeSuballocationsBySize calculated from traversing their list.
+    size_t freeSuballocationsToRegister = 0;
+    // True if previous visited suballocation was free.
+    bool prevFree = false;
+
+    for (const auto& subAlloc : m_Suballocations)
+    {
+        // Actual offset of this suballocation doesn't match expected one.
+        D3D12MA_VALIDATE(subAlloc.offset == calculatedOffset);
+
+        const bool currFree = (subAlloc.type == SUBALLOCATION_TYPE_FREE);
+        // Two adjacent free suballocations are invalid. They should be merged.
+        D3D12MA_VALIDATE(!prevFree || !currFree);
+
+        const Allocation* const alloc = (Allocation*)subAlloc.privateData;
+        if (!IsVirtual())
+        {
+            D3D12MA_VALIDATE(currFree == (alloc == NULL));
+        }
+
+        if (currFree)
+        {
+            calculatedSumFreeSize += subAlloc.size;
+            ++calculatedFreeCount;
+            if (subAlloc.size >= MIN_FREE_SUBALLOCATION_SIZE_TO_REGISTER)
+            {
+                ++freeSuballocationsToRegister;
+            }
+
+            // Margin required between allocations - every free space must be at least that large.
+            D3D12MA_VALIDATE(subAlloc.size >= GetDebugMargin());
+        }
+        else
+        {
+            if (!IsVirtual())
+            {
+                D3D12MA_VALIDATE(alloc->GetOffset() == subAlloc.offset);
+                D3D12MA_VALIDATE(alloc->GetSize() == subAlloc.size);
+            }
+
+            // Margin required between allocations - previous allocation must be free.
+            D3D12MA_VALIDATE(GetDebugMargin() == 0 || prevFree);
+        }
+
+        calculatedOffset += subAlloc.size;
+        prevFree = currFree;
+    }
+
+    // Number of free suballocations registered in m_FreeSuballocationsBySize doesn't
+    // match expected one.
+    D3D12MA_VALIDATE(m_FreeSuballocationsBySize.size() == freeSuballocationsToRegister);
+
+    UINT64 lastSize = 0;
+    for (size_t i = 0; i < m_FreeSuballocationsBySize.size(); ++i)
+    {
+        SuballocationList::iterator suballocItem = m_FreeSuballocationsBySize[i];
+
+        // Only free suballocations can be registered in m_FreeSuballocationsBySize.
+        D3D12MA_VALIDATE(suballocItem->type == SUBALLOCATION_TYPE_FREE);
+        // They must be sorted by size ascending.
+        D3D12MA_VALIDATE(suballocItem->size >= lastSize);
+
+        lastSize = suballocItem->size;
+    }
+
+    // Check if totals match calculacted values.
+    D3D12MA_VALIDATE(ValidateFreeSuballocationList());
+    D3D12MA_VALIDATE(calculatedOffset == GetSize());
+    D3D12MA_VALIDATE(calculatedSumFreeSize == m_SumFreeSize);
+    D3D12MA_VALIDATE(calculatedFreeCount == m_FreeCount);
+
+    return true;
+}
+
+bool BlockMetadata_Generic::IsEmpty() const
+{
+    return (m_Suballocations.size() == 1) && (m_FreeCount == 1);
+}
+
+void BlockMetadata_Generic::GetAllocationInfo(AllocHandle allocHandle, VIRTUAL_ALLOCATION_INFO& outInfo) const
+{
+    Suballocation& suballoc = *FindAtOffset((UINT64)allocHandle - 1).dropConst();
+    outInfo.Offset = suballoc.offset;
+    outInfo.Size = suballoc.size;
+    outInfo.pPrivateData = suballoc.privateData;
+}
+
+bool BlockMetadata_Generic::CreateAllocationRequest(
+    UINT64 allocSize,
+    UINT64 allocAlignment,
+    bool upperAddress,
+    AllocationRequest* pAllocationRequest)
+{
+    D3D12MA_ASSERT(allocSize > 0);
+    D3D12MA_ASSERT(!upperAddress && "ALLOCATION_FLAG_UPPER_ADDRESS can be used only with linear algorithm.");
+    D3D12MA_ASSERT(pAllocationRequest != NULL);
+    D3D12MA_HEAVY_ASSERT(Validate());
+
+    // There is not enough total free space in this block to fullfill the request: Early return.
+    if (m_SumFreeSize < allocSize + GetDebugMargin())
+    {
+        return false;
+    }
+
+    // New algorithm, efficiently searching freeSuballocationsBySize.
+    const size_t freeSuballocCount = m_FreeSuballocationsBySize.size();
+    if (freeSuballocCount > 0)
+    {
+        // Find first free suballocation with size not less than allocSize + GetDebugMargin().
+        SuballocationList::iterator* const it = BinaryFindFirstNotLess(
+            m_FreeSuballocationsBySize.data(),
+            m_FreeSuballocationsBySize.data() + freeSuballocCount,
+            allocSize + GetDebugMargin(),
+            SuballocationItemSizeLess());
+        size_t index = it - m_FreeSuballocationsBySize.data();
+        for (; index < freeSuballocCount; ++index)
+        {
+            if (CheckAllocation(
+                allocSize,
+                allocAlignment,
+                m_FreeSuballocationsBySize[index],
+                &pAllocationRequest->allocHandle,
+                &pAllocationRequest->sumFreeSize,
+                &pAllocationRequest->sumItemSize,
+                &pAllocationRequest->zeroInitialized))
+            {
+                pAllocationRequest->item = m_FreeSuballocationsBySize[index];
+                return true;
+            }
+        }
+    }
+
+    return false;
+}
+
+void BlockMetadata_Generic::Alloc(
+    const AllocationRequest& request,
+    UINT64 allocSize,
+    void* privateData)
+{
+    D3D12MA_ASSERT(request.item != m_Suballocations.end());
+    Suballocation& suballoc = *request.item;
+    // Given suballocation is a free block.
+    D3D12MA_ASSERT(suballoc.type == SUBALLOCATION_TYPE_FREE);
+    // Given offset is inside this suballocation.
+    UINT64 offset = (UINT64)request.allocHandle - 1;
+    D3D12MA_ASSERT(offset >= suballoc.offset);
+    const UINT64 paddingBegin = offset - suballoc.offset;
+    D3D12MA_ASSERT(suballoc.size >= paddingBegin + allocSize);
+    const UINT64 paddingEnd = suballoc.size - paddingBegin - allocSize;
+
+    // Unregister this free suballocation from m_FreeSuballocationsBySize and update
+    // it to become used.
+    UnregisterFreeSuballocation(request.item);
+
+    suballoc.offset = offset;
+    suballoc.size = allocSize;
+    suballoc.type = SUBALLOCATION_TYPE_ALLOCATION;
+    suballoc.privateData = privateData;
+
+    // If there are any free bytes remaining at the end, insert new free suballocation after current one.
+    if (paddingEnd)
+    {
+        Suballocation paddingSuballoc = {};
+        paddingSuballoc.offset = offset + allocSize;
+        paddingSuballoc.size = paddingEnd;
+        paddingSuballoc.type = SUBALLOCATION_TYPE_FREE;
+        SuballocationList::iterator next = request.item;
+        ++next;
+        const SuballocationList::iterator paddingEndItem =
+            m_Suballocations.insert(next, paddingSuballoc);
+        RegisterFreeSuballocation(paddingEndItem);
+    }
+
+    // If there are any free bytes remaining at the beginning, insert new free suballocation before current one.
+    if (paddingBegin)
+    {
+        Suballocation paddingSuballoc = {};
+        paddingSuballoc.offset = offset - paddingBegin;
+        paddingSuballoc.size = paddingBegin;
+        paddingSuballoc.type = SUBALLOCATION_TYPE_FREE;
+        const SuballocationList::iterator paddingBeginItem =
+            m_Suballocations.insert(request.item, paddingSuballoc);
+        RegisterFreeSuballocation(paddingBeginItem);
+    }
+
+    // Update totals.
+    m_FreeCount = m_FreeCount - 1;
+    if (paddingBegin > 0)
+    {
+        ++m_FreeCount;
+    }
+    if (paddingEnd > 0)
+    {
+        ++m_FreeCount;
+    }
+    m_SumFreeSize -= allocSize;
+
+    m_ZeroInitializedRange.MarkRangeAsUsed(offset, offset + allocSize);
+}
+
+void BlockMetadata_Generic::Free(AllocHandle allocHandle)
+{
+    FreeSuballocation(FindAtOffset((UINT64)allocHandle - 1).dropConst());
+}
+
+void BlockMetadata_Generic::Clear()
+{
+    m_FreeCount = 1;
+    m_SumFreeSize = GetSize();
+
+    m_Suballocations.clear();
+    Suballocation suballoc = {};
+    suballoc.offset = 0;
+    suballoc.size = GetSize();
+    suballoc.type = SUBALLOCATION_TYPE_FREE;
+    m_Suballocations.push_back(suballoc);
+
+    m_FreeSuballocationsBySize.clear();
+    m_FreeSuballocationsBySize.push_back(m_Suballocations.begin());
+}
+
+SuballocationList::const_iterator BlockMetadata_Generic::FindAtOffset(UINT64 offset) const
+{
+    const UINT64 last = m_Suballocations.crbegin()->offset;
+    if (last == offset)
+        return m_Suballocations.crbegin();
+    const UINT64 first = m_Suballocations.cbegin()->offset;
+    if (first == offset)
+        return m_Suballocations.cbegin();
+
+    const size_t suballocCount = m_Suballocations.size();
+    const UINT64 step = (last - first + m_Suballocations.cbegin()->size) / suballocCount;
+    auto findSuballocation = [&](auto begin, auto end) -> SuballocationList::const_iterator
+    {
+        for (auto suballocItem = begin;
+            suballocItem != end;
+            ++suballocItem)
+        {
+            const Suballocation& suballoc = *suballocItem;
+            if (suballoc.offset == offset)
+                return suballocItem;
+        }
+        D3D12MA_ASSERT(false && "Not found!");
+        return m_Suballocations.end();
+    };
+    // If requested offset is closer to the end of range, search from the end
+    if ((offset - first) > suballocCount * step / 2)
+    {
+        return findSuballocation(m_Suballocations.crbegin(), m_Suballocations.crend());
+    }
+    return findSuballocation(m_Suballocations.cbegin(), m_Suballocations.cend());
+}
+
+bool BlockMetadata_Generic::ValidateFreeSuballocationList() const
+{
+    UINT64 lastSize = 0;
+    for (size_t i = 0, count = m_FreeSuballocationsBySize.size(); i < count; ++i)
+    {
+        const SuballocationList::iterator it = m_FreeSuballocationsBySize[i];
+
+        D3D12MA_VALIDATE(it->type == SUBALLOCATION_TYPE_FREE);
+        D3D12MA_VALIDATE(it->size >= MIN_FREE_SUBALLOCATION_SIZE_TO_REGISTER);
+        D3D12MA_VALIDATE(it->size >= lastSize);
+        lastSize = it->size;
+    }
+    return true;
+}
+
+bool BlockMetadata_Generic::CheckAllocation(
+    UINT64 allocSize,
+    UINT64 allocAlignment,
+    SuballocationList::const_iterator suballocItem,
+    AllocHandle* pAllocHandle,
+    UINT64* pSumFreeSize,
+    UINT64* pSumItemSize,
+    BOOL* pZeroInitialized) const
+{
+    D3D12MA_ASSERT(allocSize > 0);
+    D3D12MA_ASSERT(suballocItem != m_Suballocations.cend());
+    D3D12MA_ASSERT(pAllocHandle != NULL && pZeroInitialized != NULL);
+
+    *pSumFreeSize = 0;
+    *pSumItemSize = 0;
+    *pZeroInitialized = FALSE;
+
+    const Suballocation& suballoc = *suballocItem;
+    D3D12MA_ASSERT(suballoc.type == SUBALLOCATION_TYPE_FREE);
+
+    *pSumFreeSize = suballoc.size;
+
+    // Size of this suballocation is too small for this request: Early return.
+    if (suballoc.size < allocSize)
+    {
+        return false;
+    }
+
+    // Start from offset equal to beginning of this suballocation and debug margin of previous allocation if present.
+    UINT64 offset = suballoc.offset + (suballocItem == m_Suballocations.cbegin() ? 0 : GetDebugMargin());
+
+    // Apply alignment.
+    offset = AlignUp(offset, allocAlignment);
+
+    // Calculate padding at the beginning based on current offset.
+    const UINT64 paddingBegin = offset - suballoc.offset;
+
+    // Fail if requested size plus margin after is bigger than size of this suballocation.
+    if (paddingBegin + allocSize + GetDebugMargin() > suballoc.size)
+    {
+        return false;
+    }
+
+    // All tests passed: Success. Offset is already filled.
+    *pZeroInitialized = m_ZeroInitializedRange.IsRangeZeroInitialized(offset, offset + allocSize);
+    *pAllocHandle = (AllocHandle)(offset + 1);
+    return true;
+}
+
+void BlockMetadata_Generic::MergeFreeWithNext(SuballocationList::iterator item)
+{
+    D3D12MA_ASSERT(item != m_Suballocations.end());
+    D3D12MA_ASSERT(item->type == SUBALLOCATION_TYPE_FREE);
+
+    SuballocationList::iterator nextItem = item;
+    ++nextItem;
+    D3D12MA_ASSERT(nextItem != m_Suballocations.end());
+    D3D12MA_ASSERT(nextItem->type == SUBALLOCATION_TYPE_FREE);
+
+    item->size += nextItem->size;
+    --m_FreeCount;
+    m_Suballocations.erase(nextItem);
+}
+
+SuballocationList::iterator BlockMetadata_Generic::FreeSuballocation(SuballocationList::iterator suballocItem)
+{
+    // Change this suballocation to be marked as free.
+    Suballocation& suballoc = *suballocItem;
+    suballoc.type = SUBALLOCATION_TYPE_FREE;
+    suballoc.privateData = NULL;
+
+    // Update totals.
+    ++m_FreeCount;
+    m_SumFreeSize += suballoc.size;
+
+    // Merge with previous and/or next suballocation if it's also free.
+    bool mergeWithNext = false;
+    bool mergeWithPrev = false;
+
+    SuballocationList::iterator nextItem = suballocItem;
+    ++nextItem;
+    if ((nextItem != m_Suballocations.end()) && (nextItem->type == SUBALLOCATION_TYPE_FREE))
+    {
+        mergeWithNext = true;
+    }
+
+    SuballocationList::iterator prevItem = suballocItem;
+    if (suballocItem != m_Suballocations.begin())
+    {
+        --prevItem;
+        if (prevItem->type == SUBALLOCATION_TYPE_FREE)
+        {
+            mergeWithPrev = true;
+        }
+    }
+
+    if (mergeWithNext)
+    {
+        UnregisterFreeSuballocation(nextItem);
+        MergeFreeWithNext(suballocItem);
+    }
+
+    if (mergeWithPrev)
+    {
+        UnregisterFreeSuballocation(prevItem);
+        MergeFreeWithNext(prevItem);
+        RegisterFreeSuballocation(prevItem);
+        return prevItem;
+    }
+    else
+    {
+        RegisterFreeSuballocation(suballocItem);
+        return suballocItem;
+    }
+}
+
+void BlockMetadata_Generic::RegisterFreeSuballocation(SuballocationList::iterator item)
+{
+    D3D12MA_ASSERT(item->type == SUBALLOCATION_TYPE_FREE);
+    D3D12MA_ASSERT(item->size > 0);
+
+    // You may want to enable this validation at the beginning or at the end of
+    // this function, depending on what do you want to check.
+    D3D12MA_HEAVY_ASSERT(ValidateFreeSuballocationList());
+
+    if (item->size >= MIN_FREE_SUBALLOCATION_SIZE_TO_REGISTER)
+    {
+        if (m_FreeSuballocationsBySize.empty())
+        {
+            m_FreeSuballocationsBySize.push_back(item);
+        }
+        else
+        {
+            m_FreeSuballocationsBySize.InsertSorted(item, SuballocationItemSizeLess());
+        }
+    }
+
+    //D3D12MA_HEAVY_ASSERT(ValidateFreeSuballocationList());
+}
+
+void BlockMetadata_Generic::UnregisterFreeSuballocation(SuballocationList::iterator item)
+{
+    D3D12MA_ASSERT(item->type == SUBALLOCATION_TYPE_FREE);
+    D3D12MA_ASSERT(item->size > 0);
+
+    // You may want to enable this validation at the beginning or at the end of
+    // this function, depending on what do you want to check.
+    D3D12MA_HEAVY_ASSERT(ValidateFreeSuballocationList());
+
+    if (item->size >= MIN_FREE_SUBALLOCATION_SIZE_TO_REGISTER)
+    {
+        SuballocationList::iterator* const it = BinaryFindFirstNotLess(
+            m_FreeSuballocationsBySize.data(),
+            m_FreeSuballocationsBySize.data() + m_FreeSuballocationsBySize.size(),
+            item,
+            SuballocationItemSizeLess());
+        for (size_t index = it - m_FreeSuballocationsBySize.data();
+            index < m_FreeSuballocationsBySize.size();
+            ++index)
+        {
+            if (m_FreeSuballocationsBySize[index] == item)
+            {
+                m_FreeSuballocationsBySize.remove(index);
+                return;
+            }
+            D3D12MA_ASSERT((m_FreeSuballocationsBySize[index]->size == item->size) && "Not found.");
+        }
+        D3D12MA_ASSERT(0 && "Not found.");
+    }
+
+    //D3D12MA_HEAVY_ASSERT(ValidateFreeSuballocationList());
+}
+
+void BlockMetadata_Generic::SetAllocationPrivateData(AllocHandle allocHandle, void* privateData)
+{
+    Suballocation& suballoc = *FindAtOffset((UINT64)allocHandle - 1).dropConst();
+    suballoc.privateData = privateData;
+}
+
+void BlockMetadata_Generic::AddStatistics(Statistics& inoutStats) const
+{
+    inoutStats.BlockCount++;
+    inoutStats.AllocationCount += (UINT)m_Suballocations.size() - m_FreeCount;
+    inoutStats.BlockBytes += GetSize();
+    inoutStats.AllocationBytes += GetSize() - m_SumFreeSize;
+}
+
+void BlockMetadata_Generic::AddDetailedStatistics(DetailedStatistics& inoutStats) const
+{
+    inoutStats.Stats.BlockCount++;
+    inoutStats.Stats.BlockBytes += GetSize();
+
+    for (const auto& suballoc : m_Suballocations)
+    {
+        if (suballoc.type == SUBALLOCATION_TYPE_FREE)
+            AddDetailedStatisticsUnusedRange(inoutStats, suballoc.size);
+        else
+            AddDetailedStatisticsAllocation(inoutStats, suballoc.size);
+    }
+}
+
+void BlockMetadata_Generic::WriteAllocationInfoToJson(JsonWriter& json) const
+{
+    PrintDetailedMap_Begin(json, GetSumFreeSize(), GetAllocationCount(), m_FreeCount);
+    for (const auto& suballoc : m_Suballocations)
+    {
+        if (suballoc.type == SUBALLOCATION_TYPE_FREE)
+            PrintDetailedMap_UnusedRange(json, suballoc.offset, suballoc.size);
+        else
+            PrintDetailedMap_Allocation(json, suballoc.offset, suballoc.size, suballoc.privateData);
+    }
+    PrintDetailedMap_End(json);
+}
+#endif // _D3D12MA_BLOCK_METADATA_GENERIC_FUNCTIONS
+#endif // _D3D12MA_BLOCK_METADATA_GENERIC
+#endif // #if 0
+
+#ifndef _D3D12MA_BLOCK_METADATA_LINEAR
+class BlockMetadata_Linear : public BlockMetadata
+{
+public:
+    BlockMetadata_Linear(const ALLOCATION_CALLBACKS* allocationCallbacks, bool isVirtual);
+    virtual ~BlockMetadata_Linear() = default;
+
+    UINT64 GetSumFreeSize() const override { return m_SumFreeSize; }
+    bool IsEmpty() const override { return GetAllocationCount() == 0; }
+    UINT64 GetAllocationOffset(AllocHandle allocHandle) const override { return (UINT64)allocHandle - 1; };
+
+    void Init(UINT64 size) override;
+    bool Validate() const override;
+    size_t GetAllocationCount() const override;
+    size_t GetFreeRegionsCount() const override;
+    void GetAllocationInfo(AllocHandle allocHandle, VIRTUAL_ALLOCATION_INFO& outInfo) const override;
+
+    bool CreateAllocationRequest(
+        UINT64 allocSize,
+        UINT64 allocAlignment,
+        bool upperAddress,
+        UINT32 strategy,
+        AllocationRequest* pAllocationRequest) override;
+
+    void Alloc(
+        const AllocationRequest& request,
+        UINT64 allocSize,
+        void* privateData) override;
+
+    void Free(AllocHandle allocHandle) override;
+    void Clear() override;
+
+    AllocHandle GetAllocationListBegin() const override;
+    AllocHandle GetNextAllocation(AllocHandle prevAlloc) const override;
+    UINT64 GetNextFreeRegionSize(AllocHandle alloc) const override;
+    void* GetAllocationPrivateData(AllocHandle allocHandle) const override;
+    void SetAllocationPrivateData(AllocHandle allocHandle, void* privateData) override;
+
+    void AddStatistics(Statistics& inoutStats) const override;
+    void AddDetailedStatistics(DetailedStatistics& inoutStats) const override;
+    void WriteAllocationInfoToJson(JsonWriter& json) const override;
+    void DebugLogAllAllocations() const override;
+
+private:
+    /*
+    There are two suballocation vectors, used in ping-pong way.
+    The one with index m_1stVectorIndex is called 1st.
+    The one with index (m_1stVectorIndex ^ 1) is called 2nd.
+    2nd can be non-empty only when 1st is not empty.
+    When 2nd is not empty, m_2ndVectorMode indicates its mode of operation.
+    */
+    typedef Vector<Suballocation> SuballocationVectorType;
+
+    enum ALLOC_REQUEST_TYPE
+    {
+        ALLOC_REQUEST_UPPER_ADDRESS,
+        ALLOC_REQUEST_END_OF_1ST,
+        ALLOC_REQUEST_END_OF_2ND,
+    };
+
+    enum SECOND_VECTOR_MODE
+    {
+        SECOND_VECTOR_EMPTY,
+        /*
+        Suballocations in 2nd vector are created later than the ones in 1st, but they
+        all have smaller offset.
+        */
+        SECOND_VECTOR_RING_BUFFER,
+        /*
+        Suballocations in 2nd vector are upper side of double stack.
+        They all have offsets higher than those in 1st vector.
+        Top of this stack means smaller offsets, but higher indices in this vector.
+        */
+        SECOND_VECTOR_DOUBLE_STACK,
+    };
+
+    UINT64 m_SumFreeSize;
+    SuballocationVectorType m_Suballocations0, m_Suballocations1;
+    UINT32 m_1stVectorIndex;
+    SECOND_VECTOR_MODE m_2ndVectorMode;
+    // Number of items in 1st vector with hAllocation = null at the beginning.
+    size_t m_1stNullItemsBeginCount;
+    // Number of other items in 1st vector with hAllocation = null somewhere in the middle.
+    size_t m_1stNullItemsMiddleCount;
+    // Number of items in 2nd vector with hAllocation = null.
+    size_t m_2ndNullItemsCount;
+
+    SuballocationVectorType& AccessSuballocations1st() { return m_1stVectorIndex ? m_Suballocations1 : m_Suballocations0; }
+    SuballocationVectorType& AccessSuballocations2nd() { return m_1stVectorIndex ? m_Suballocations0 : m_Suballocations1; }
+    const SuballocationVectorType& AccessSuballocations1st() const { return m_1stVectorIndex ? m_Suballocations1 : m_Suballocations0; }
+    const SuballocationVectorType& AccessSuballocations2nd() const { return m_1stVectorIndex ? m_Suballocations0 : m_Suballocations1; }
+
+    Suballocation& FindSuballocation(UINT64 offset) const;
+    bool ShouldCompact1st() const;
+    void CleanupAfterFree();
+
+    bool CreateAllocationRequest_LowerAddress(
+        UINT64 allocSize,
+        UINT64 allocAlignment,
+        AllocationRequest* pAllocationRequest);
+    bool CreateAllocationRequest_UpperAddress(
+        UINT64 allocSize,
+        UINT64 allocAlignment,
+        AllocationRequest* pAllocationRequest);
+
+    D3D12MA_CLASS_NO_COPY(BlockMetadata_Linear)
+};
+
+#ifndef _D3D12MA_BLOCK_METADATA_LINEAR_FUNCTIONS
+BlockMetadata_Linear::BlockMetadata_Linear(const ALLOCATION_CALLBACKS* allocationCallbacks, bool isVirtual)
+    : BlockMetadata(allocationCallbacks, isVirtual),
+    m_SumFreeSize(0),
+    m_Suballocations0(*allocationCallbacks),
+    m_Suballocations1(*allocationCallbacks),
+    m_1stVectorIndex(0),
+    m_2ndVectorMode(SECOND_VECTOR_EMPTY),
+    m_1stNullItemsBeginCount(0),
+    m_1stNullItemsMiddleCount(0),
+    m_2ndNullItemsCount(0)
+{
+    D3D12MA_ASSERT(allocationCallbacks);
+}
+
+void BlockMetadata_Linear::Init(UINT64 size)
+{
+    BlockMetadata::Init(size);
+    m_SumFreeSize = size;
+}
+
+bool BlockMetadata_Linear::Validate() const
+{
+    D3D12MA_VALIDATE(GetSumFreeSize() <= GetSize());
+    const SuballocationVectorType& suballocations1st = AccessSuballocations1st();
+    const SuballocationVectorType& suballocations2nd = AccessSuballocations2nd();
+
+    D3D12MA_VALIDATE(suballocations2nd.empty() == (m_2ndVectorMode == SECOND_VECTOR_EMPTY));
+    D3D12MA_VALIDATE(!suballocations1st.empty() ||
+        suballocations2nd.empty() ||
+        m_2ndVectorMode != SECOND_VECTOR_RING_BUFFER);
+
+    if (!suballocations1st.empty())
+    {
+        // Null item at the beginning should be accounted into m_1stNullItemsBeginCount.
+        D3D12MA_VALIDATE(suballocations1st[m_1stNullItemsBeginCount].type != SUBALLOCATION_TYPE_FREE);
+        // Null item at the end should be just pop_back().
+        D3D12MA_VALIDATE(suballocations1st.back().type != SUBALLOCATION_TYPE_FREE);
+    }
+    if (!suballocations2nd.empty())
+    {
+        // Null item at the end should be just pop_back().
+        D3D12MA_VALIDATE(suballocations2nd.back().type != SUBALLOCATION_TYPE_FREE);
+    }
+
+    D3D12MA_VALIDATE(m_1stNullItemsBeginCount + m_1stNullItemsMiddleCount <= suballocations1st.size());
+    D3D12MA_VALIDATE(m_2ndNullItemsCount <= suballocations2nd.size());
+
+    UINT64 sumUsedSize = 0;
+    const size_t suballoc1stCount = suballocations1st.size();
+    UINT64 offset = 0;
+
+    if (m_2ndVectorMode == SECOND_VECTOR_RING_BUFFER)
+    {
+        const size_t suballoc2ndCount = suballocations2nd.size();
+        size_t nullItem2ndCount = 0;
+        for (size_t i = 0; i < suballoc2ndCount; ++i)
+        {
+            const Suballocation& suballoc = suballocations2nd[i];
+            const bool currFree = (suballoc.type == SUBALLOCATION_TYPE_FREE);
+
+            const Allocation* alloc = (Allocation*)suballoc.privateData;
+            if (!IsVirtual())
+            {
+                D3D12MA_VALIDATE(currFree == (alloc == NULL));
+            }
+            D3D12MA_VALIDATE(suballoc.offset >= offset);
+
+            if (!currFree)
+            {
+                if (!IsVirtual())
+                {
+                    D3D12MA_VALIDATE(GetAllocationOffset(alloc->GetAllocHandle()) == suballoc.offset);
+                    D3D12MA_VALIDATE(alloc->GetSize() == suballoc.size);
+                }
+                sumUsedSize += suballoc.size;
+            }
+            else
+            {
+                ++nullItem2ndCount;
+            }
+
+            offset = suballoc.offset + suballoc.size + GetDebugMargin();
+        }
+
+        D3D12MA_VALIDATE(nullItem2ndCount == m_2ndNullItemsCount);
+    }
+
+    for (size_t i = 0; i < m_1stNullItemsBeginCount; ++i)
+    {
+        const Suballocation& suballoc = suballocations1st[i];
+        D3D12MA_VALIDATE(suballoc.type == SUBALLOCATION_TYPE_FREE &&
+            suballoc.privateData == NULL);
+    }
+
+    size_t nullItem1stCount = m_1stNullItemsBeginCount;
+
+    for (size_t i = m_1stNullItemsBeginCount; i < suballoc1stCount; ++i)
+    {
+        const Suballocation& suballoc = suballocations1st[i];
+        const bool currFree = (suballoc.type == SUBALLOCATION_TYPE_FREE);
+
+        const Allocation* alloc = (Allocation*)suballoc.privateData;
+        if (!IsVirtual())
+        {
+            D3D12MA_VALIDATE(currFree == (alloc == NULL));
+        }
+        D3D12MA_VALIDATE(suballoc.offset >= offset);
+        D3D12MA_VALIDATE(i >= m_1stNullItemsBeginCount || currFree);
+
+        if (!currFree)
+        {
+            if (!IsVirtual())
+            {
+                D3D12MA_VALIDATE(GetAllocationOffset(alloc->GetAllocHandle()) == suballoc.offset);
+                D3D12MA_VALIDATE(alloc->GetSize() == suballoc.size);
+            }
+            sumUsedSize += suballoc.size;
+        }
+        else
+        {
+            ++nullItem1stCount;
+        }
+
+        offset = suballoc.offset + suballoc.size + GetDebugMargin();
+    }
+    D3D12MA_VALIDATE(nullItem1stCount == m_1stNullItemsBeginCount + m_1stNullItemsMiddleCount);
+
+    if (m_2ndVectorMode == SECOND_VECTOR_DOUBLE_STACK)
+    {
+        const size_t suballoc2ndCount = suballocations2nd.size();
+        size_t nullItem2ndCount = 0;
+        for (size_t i = suballoc2ndCount; i--; )
+        {
+            const Suballocation& suballoc = suballocations2nd[i];
+            const bool currFree = (suballoc.type == SUBALLOCATION_TYPE_FREE);
+
+            const Allocation* alloc = (Allocation*)suballoc.privateData;
+            if (!IsVirtual())
+            {
+                D3D12MA_VALIDATE(currFree == (alloc == NULL));
+            }
+            D3D12MA_VALIDATE(suballoc.offset >= offset);
+
+            if (!currFree)
+            {
+                if (!IsVirtual())
+                {
+                    D3D12MA_VALIDATE(GetAllocationOffset(alloc->GetAllocHandle()) == suballoc.offset);
+                    D3D12MA_VALIDATE(alloc->GetSize() == suballoc.size);
+                }
+                sumUsedSize += suballoc.size;
+            }
+            else
+            {
+                ++nullItem2ndCount;
+            }
+
+            offset = suballoc.offset + suballoc.size + GetDebugMargin();
+        }
+
+        D3D12MA_VALIDATE(nullItem2ndCount == m_2ndNullItemsCount);
+    }
+
+    D3D12MA_VALIDATE(offset <= GetSize());
+    D3D12MA_VALIDATE(m_SumFreeSize == GetSize() - sumUsedSize);
+
+    return true;
+}
+
+size_t BlockMetadata_Linear::GetAllocationCount() const
+{
+    return AccessSuballocations1st().size() - m_1stNullItemsBeginCount - m_1stNullItemsMiddleCount +
+        AccessSuballocations2nd().size() - m_2ndNullItemsCount;
+}
+
+size_t BlockMetadata_Linear::GetFreeRegionsCount() const
+{
+    // Function only used for defragmentation, which is disabled for this algorithm
+    D3D12MA_ASSERT(0);
+    return SIZE_MAX;
+}
+
+void BlockMetadata_Linear::GetAllocationInfo(AllocHandle allocHandle, VIRTUAL_ALLOCATION_INFO& outInfo) const
+{
+    const Suballocation& suballoc = FindSuballocation((UINT64)allocHandle - 1);
+    outInfo.Offset = suballoc.offset;
+    outInfo.Size = suballoc.size;
+    outInfo.pPrivateData = suballoc.privateData;
+}
+
+bool BlockMetadata_Linear::CreateAllocationRequest(
+    UINT64 allocSize,
+    UINT64 allocAlignment,
+    bool upperAddress,
+    UINT32 strategy,
+    AllocationRequest* pAllocationRequest)
+{
+    D3D12MA_ASSERT(allocSize > 0 && "Cannot allocate empty block!");
+    D3D12MA_ASSERT(pAllocationRequest != NULL);
+    D3D12MA_HEAVY_ASSERT(Validate());
+    pAllocationRequest->size = allocSize;
+    return upperAddress ?
+        CreateAllocationRequest_UpperAddress(
+            allocSize, allocAlignment, pAllocationRequest) :
+        CreateAllocationRequest_LowerAddress(
+            allocSize, allocAlignment, pAllocationRequest);
+}
+
+void BlockMetadata_Linear::Alloc(
+    const AllocationRequest& request,
+    UINT64 allocSize,
+    void* privateData)
+{
+    UINT64 offset = (UINT64)request.allocHandle - 1;
+    const Suballocation newSuballoc = { offset, request.size, privateData, SUBALLOCATION_TYPE_ALLOCATION };
+
+    switch (request.algorithmData)
+    {
+    case ALLOC_REQUEST_UPPER_ADDRESS:
+    {
+        D3D12MA_ASSERT(m_2ndVectorMode != SECOND_VECTOR_RING_BUFFER &&
+            "CRITICAL ERROR: Trying to use linear allocator as double stack while it was already used as ring buffer.");
+        SuballocationVectorType& suballocations2nd = AccessSuballocations2nd();
+        suballocations2nd.push_back(newSuballoc);
+        m_2ndVectorMode = SECOND_VECTOR_DOUBLE_STACK;
+        break;
+    }
+    case ALLOC_REQUEST_END_OF_1ST:
+    {
+        SuballocationVectorType& suballocations1st = AccessSuballocations1st();
+
+        D3D12MA_ASSERT(suballocations1st.empty() ||
+            offset >= suballocations1st.back().offset + suballocations1st.back().size);
+        // Check if it fits before the end of the block.
+        D3D12MA_ASSERT(offset + request.size <= GetSize());
+
+        suballocations1st.push_back(newSuballoc);
+        break;
+    }
+    case ALLOC_REQUEST_END_OF_2ND:
+    {
+        SuballocationVectorType& suballocations1st = AccessSuballocations1st();
+        // New allocation at the end of 2-part ring buffer, so before first allocation from 1st vector.
+        D3D12MA_ASSERT(!suballocations1st.empty() &&
+            offset + request.size <= suballocations1st[m_1stNullItemsBeginCount].offset);
+        SuballocationVectorType& suballocations2nd = AccessSuballocations2nd();
+
+        switch (m_2ndVectorMode)
+        {
+        case SECOND_VECTOR_EMPTY:
+            // First allocation from second part ring buffer.
+            D3D12MA_ASSERT(suballocations2nd.empty());
+            m_2ndVectorMode = SECOND_VECTOR_RING_BUFFER;
+            break;
+        case SECOND_VECTOR_RING_BUFFER:
+            // 2-part ring buffer is already started.
+            D3D12MA_ASSERT(!suballocations2nd.empty());
+            break;
+        case SECOND_VECTOR_DOUBLE_STACK:
+            D3D12MA_ASSERT(0 && "CRITICAL ERROR: Trying to use linear allocator as ring buffer while it was already used as double stack.");
+            break;
+        default:
+            D3D12MA_ASSERT(0);
+        }
+
+        suballocations2nd.push_back(newSuballoc);
+        break;
+    }
+    default:
+        D3D12MA_ASSERT(0 && "CRITICAL INTERNAL ERROR.");
+    }
+    m_SumFreeSize -= newSuballoc.size;
+}
+
+void BlockMetadata_Linear::Free(AllocHandle allocHandle)
+{
+    SuballocationVectorType& suballocations1st = AccessSuballocations1st();
+    SuballocationVectorType& suballocations2nd = AccessSuballocations2nd();
+    UINT64 offset = (UINT64)allocHandle - 1;
+
+    if (!suballocations1st.empty())
+    {
+        // First allocation: Mark it as next empty at the beginning.
+        Suballocation& firstSuballoc = suballocations1st[m_1stNullItemsBeginCount];
+        if (firstSuballoc.offset == offset)
+        {
+            firstSuballoc.type = SUBALLOCATION_TYPE_FREE;
+            firstSuballoc.privateData = NULL;
+            m_SumFreeSize += firstSuballoc.size;
+            ++m_1stNullItemsBeginCount;
+            CleanupAfterFree();
+            return;
+        }
+    }
+
+    // Last allocation in 2-part ring buffer or top of upper stack (same logic).
+    if (m_2ndVectorMode == SECOND_VECTOR_RING_BUFFER ||
+        m_2ndVectorMode == SECOND_VECTOR_DOUBLE_STACK)
+    {
+        Suballocation& lastSuballoc = suballocations2nd.back();
+        if (lastSuballoc.offset == offset)
+        {
+            m_SumFreeSize += lastSuballoc.size;
+            suballocations2nd.pop_back();
+            CleanupAfterFree();
+            return;
+        }
+    }
+    // Last allocation in 1st vector.
+    else if (m_2ndVectorMode == SECOND_VECTOR_EMPTY)
+    {
+        Suballocation& lastSuballoc = suballocations1st.back();
+        if (lastSuballoc.offset == offset)
+        {
+            m_SumFreeSize += lastSuballoc.size;
+            suballocations1st.pop_back();
+            CleanupAfterFree();
+            return;
+        }
+    }
+
+    Suballocation refSuballoc;
+    refSuballoc.offset = offset;
+    // Rest of members stays uninitialized intentionally for better performance.
+
+    // Item from the middle of 1st vector.
+    {
+        const SuballocationVectorType::iterator it = BinaryFindSorted(
+            suballocations1st.begin() + m_1stNullItemsBeginCount,
+            suballocations1st.end(),
+            refSuballoc,
+            SuballocationOffsetLess());
+        if (it != suballocations1st.end())
+        {
+            it->type = SUBALLOCATION_TYPE_FREE;
+            it->privateData = NULL;
+            ++m_1stNullItemsMiddleCount;
+            m_SumFreeSize += it->size;
+            CleanupAfterFree();
+            return;
+        }
+    }
+
+    if (m_2ndVectorMode != SECOND_VECTOR_EMPTY)
+    {
+        // Item from the middle of 2nd vector.
+        const SuballocationVectorType::iterator it = m_2ndVectorMode == SECOND_VECTOR_RING_BUFFER ?
+            BinaryFindSorted(suballocations2nd.begin(), suballocations2nd.end(), refSuballoc, SuballocationOffsetLess()) :
+            BinaryFindSorted(suballocations2nd.begin(), suballocations2nd.end(), refSuballoc, SuballocationOffsetGreater());
+        if (it != suballocations2nd.end())
+        {
+            it->type = SUBALLOCATION_TYPE_FREE;
+            it->privateData = NULL;
+            ++m_2ndNullItemsCount;
+            m_SumFreeSize += it->size;
+            CleanupAfterFree();
+            return;
+        }
+    }
+
+    D3D12MA_ASSERT(0 && "Allocation to free not found in linear allocator!");
+}
+
+void BlockMetadata_Linear::Clear()
+{
+    m_SumFreeSize = GetSize();
+    m_Suballocations0.clear();
+    m_Suballocations1.clear();
+    // Leaving m_1stVectorIndex unchanged - it doesn't matter.
+    m_2ndVectorMode = SECOND_VECTOR_EMPTY;
+    m_1stNullItemsBeginCount = 0;
+    m_1stNullItemsMiddleCount = 0;
+    m_2ndNullItemsCount = 0;
+}
+
+AllocHandle BlockMetadata_Linear::GetAllocationListBegin() const
+{
+    // Function only used for defragmentation, which is disabled for this algorithm
+    D3D12MA_ASSERT(0);
+    return (AllocHandle)0;
+}
+
+AllocHandle BlockMetadata_Linear::GetNextAllocation(AllocHandle prevAlloc) const
+{
+    // Function only used for defragmentation, which is disabled for this algorithm
+    D3D12MA_ASSERT(0);
+    return (AllocHandle)0;
+}
+
+UINT64 BlockMetadata_Linear::GetNextFreeRegionSize(AllocHandle alloc) const
+{
+    // Function only used for defragmentation, which is disabled for this algorithm
+    D3D12MA_ASSERT(0);
+    return 0;
+}
+
+void* BlockMetadata_Linear::GetAllocationPrivateData(AllocHandle allocHandle) const
+{
+    return FindSuballocation((UINT64)allocHandle - 1).privateData;
+}
+
+void BlockMetadata_Linear::SetAllocationPrivateData(AllocHandle allocHandle, void* privateData)
+{
+    Suballocation& suballoc = FindSuballocation((UINT64)allocHandle - 1);
+    suballoc.privateData = privateData;
+}
+
+void BlockMetadata_Linear::AddStatistics(Statistics& inoutStats) const
+{
+    inoutStats.BlockCount++;
+    inoutStats.AllocationCount += (UINT)GetAllocationCount();
+    inoutStats.BlockBytes += GetSize();
+    inoutStats.AllocationBytes += GetSize() - m_SumFreeSize;
+}
+
+void BlockMetadata_Linear::AddDetailedStatistics(DetailedStatistics& inoutStats) const
+{
+    inoutStats.Stats.BlockCount++;
+    inoutStats.Stats.BlockBytes += GetSize();
+
+    const UINT64 size = GetSize();
+    const SuballocationVectorType& suballocations1st = AccessSuballocations1st();
+    const SuballocationVectorType& suballocations2nd = AccessSuballocations2nd();
+    const size_t suballoc1stCount = suballocations1st.size();
+    const size_t suballoc2ndCount = suballocations2nd.size();
+
+    UINT64 lastOffset = 0;
+    if (m_2ndVectorMode == SECOND_VECTOR_RING_BUFFER)
+    {
+        const UINT64 freeSpace2ndTo1stEnd = suballocations1st[m_1stNullItemsBeginCount].offset;
+        size_t nextAlloc2ndIndex = 0;
+        while (lastOffset < freeSpace2ndTo1stEnd)
+        {
+            // Find next non-null allocation or move nextAllocIndex to the end.
+            while (nextAlloc2ndIndex < suballoc2ndCount &&
+                suballocations2nd[nextAlloc2ndIndex].privateData == NULL)
+            {
+                ++nextAlloc2ndIndex;
+            }
+
+            // Found non-null allocation.
+            if (nextAlloc2ndIndex < suballoc2ndCount)
+            {
+                const Suballocation& suballoc = suballocations2nd[nextAlloc2ndIndex];
+
+                // 1. Process free space before this allocation.
+                if (lastOffset < suballoc.offset)
+                {
+                    // There is free space from lastOffset to suballoc.offset.
+                    const UINT64 unusedRangeSize = suballoc.offset - lastOffset;
+                    AddDetailedStatisticsUnusedRange(inoutStats, unusedRangeSize);
+                }
+
+                // 2. Process this allocation.
+                // There is allocation with suballoc.offset, suballoc.size.
+                AddDetailedStatisticsAllocation(inoutStats, suballoc.size);
+
+                // 3. Prepare for next iteration.
+                lastOffset = suballoc.offset + suballoc.size;
+                ++nextAlloc2ndIndex;
+            }
+            // We are at the end.
+            else
+            {
+                // There is free space from lastOffset to freeSpace2ndTo1stEnd.
+                if (lastOffset < freeSpace2ndTo1stEnd)
+                {
+                    const UINT64 unusedRangeSize = freeSpace2ndTo1stEnd - lastOffset;
+                    AddDetailedStatisticsUnusedRange(inoutStats, unusedRangeSize);
+                }
+
+                // End of loop.
+                lastOffset = freeSpace2ndTo1stEnd;
+            }
+        }
+    }
+
+    size_t nextAlloc1stIndex = m_1stNullItemsBeginCount;
+    const UINT64 freeSpace1stTo2ndEnd =
+        m_2ndVectorMode == SECOND_VECTOR_DOUBLE_STACK ? suballocations2nd.back().offset : size;
+    while (lastOffset < freeSpace1stTo2ndEnd)
+    {
+        // Find next non-null allocation or move nextAllocIndex to the end.
+        while (nextAlloc1stIndex < suballoc1stCount &&
+            suballocations1st[nextAlloc1stIndex].privateData == NULL)
+        {
+            ++nextAlloc1stIndex;
+        }
+
+        // Found non-null allocation.
+        if (nextAlloc1stIndex < suballoc1stCount)
+        {
+            const Suballocation& suballoc = suballocations1st[nextAlloc1stIndex];
+
+            // 1. Process free space before this allocation.
+            if (lastOffset < suballoc.offset)
+            {
+                // There is free space from lastOffset to suballoc.offset.
+                const UINT64 unusedRangeSize = suballoc.offset - lastOffset;
+                AddDetailedStatisticsUnusedRange(inoutStats, unusedRangeSize);
+            }
+
+            // 2. Process this allocation.
+            // There is allocation with suballoc.offset, suballoc.size.
+            AddDetailedStatisticsAllocation(inoutStats, suballoc.size);
+
+            // 3. Prepare for next iteration.
+            lastOffset = suballoc.offset + suballoc.size;
+            ++nextAlloc1stIndex;
+        }
+        // We are at the end.
+        else
+        {
+            // There is free space from lastOffset to freeSpace1stTo2ndEnd.
+            if (lastOffset < freeSpace1stTo2ndEnd)
+            {
+                const UINT64 unusedRangeSize = freeSpace1stTo2ndEnd - lastOffset;
+                AddDetailedStatisticsUnusedRange(inoutStats, unusedRangeSize);
+            }
+
+            // End of loop.
+            lastOffset = freeSpace1stTo2ndEnd;
+        }
+    }
+
+    if (m_2ndVectorMode == SECOND_VECTOR_DOUBLE_STACK)
+    {
+        size_t nextAlloc2ndIndex = suballocations2nd.size() - 1;
+        while (lastOffset < size)
+        {
+            // Find next non-null allocation or move nextAllocIndex to the end.
+            while (nextAlloc2ndIndex != SIZE_MAX &&
+                suballocations2nd[nextAlloc2ndIndex].privateData == NULL)
+            {
+                --nextAlloc2ndIndex;
+            }
+
+            // Found non-null allocation.
+            if (nextAlloc2ndIndex != SIZE_MAX)
+            {
+                const Suballocation& suballoc = suballocations2nd[nextAlloc2ndIndex];
+
+                // 1. Process free space before this allocation.
+                if (lastOffset < suballoc.offset)
+                {
+                    // There is free space from lastOffset to suballoc.offset.
+                    const UINT64 unusedRangeSize = suballoc.offset - lastOffset;
+                    AddDetailedStatisticsUnusedRange(inoutStats, unusedRangeSize);
+                }
+
+                // 2. Process this allocation.
+                // There is allocation with suballoc.offset, suballoc.size.
+                AddDetailedStatisticsAllocation(inoutStats, suballoc.size);
+
+                // 3. Prepare for next iteration.
+                lastOffset = suballoc.offset + suballoc.size;
+                --nextAlloc2ndIndex;
+            }
+            // We are at the end.
+            else
+            {
+                // There is free space from lastOffset to size.
+                if (lastOffset < size)
+                {
+                    const UINT64 unusedRangeSize = size - lastOffset;
+                    AddDetailedStatisticsUnusedRange(inoutStats, unusedRangeSize);
+                }
+
+                // End of loop.
+                lastOffset = size;
+            }
+        }
+    }
+}
+
+void BlockMetadata_Linear::WriteAllocationInfoToJson(JsonWriter& json) const
+{
+    const UINT64 size = GetSize();
+    const SuballocationVectorType& suballocations1st = AccessSuballocations1st();
+    const SuballocationVectorType& suballocations2nd = AccessSuballocations2nd();
+    const size_t suballoc1stCount = suballocations1st.size();
+    const size_t suballoc2ndCount = suballocations2nd.size();
+
+    // FIRST PASS
+
+    size_t unusedRangeCount = 0;
+    UINT64 usedBytes = 0;
+
+    UINT64 lastOffset = 0;
+
+    size_t alloc2ndCount = 0;
+    if (m_2ndVectorMode == SECOND_VECTOR_RING_BUFFER)
+    {
+        const UINT64 freeSpace2ndTo1stEnd = suballocations1st[m_1stNullItemsBeginCount].offset;
+        size_t nextAlloc2ndIndex = 0;
+        while (lastOffset < freeSpace2ndTo1stEnd)
+        {
+            // Find next non-null allocation or move nextAlloc2ndIndex to the end.
+            while (nextAlloc2ndIndex < suballoc2ndCount &&
+                suballocations2nd[nextAlloc2ndIndex].privateData == NULL)
+            {
+                ++nextAlloc2ndIndex;
+            }
+
+            // Found non-null allocation.
+            if (nextAlloc2ndIndex < suballoc2ndCount)
+            {
+                const Suballocation& suballoc = suballocations2nd[nextAlloc2ndIndex];
+
+                // 1. Process free space before this allocation.
+                if (lastOffset < suballoc.offset)
+                {
+                    // There is free space from lastOffset to suballoc.offset.
+                    ++unusedRangeCount;
+                }
+
+                // 2. Process this allocation.
+                // There is allocation with suballoc.offset, suballoc.size.
+                ++alloc2ndCount;
+                usedBytes += suballoc.size;
+
+                // 3. Prepare for next iteration.
+                lastOffset = suballoc.offset + suballoc.size;
+                ++nextAlloc2ndIndex;
+            }
+            // We are at the end.
+            else
+            {
+                if (lastOffset < freeSpace2ndTo1stEnd)
+                {
+                    // There is free space from lastOffset to freeSpace2ndTo1stEnd.
+                    ++unusedRangeCount;
+                }
+
+                // End of loop.
+                lastOffset = freeSpace2ndTo1stEnd;
+            }
+        }
+    }
+
+    size_t nextAlloc1stIndex = m_1stNullItemsBeginCount;
+    size_t alloc1stCount = 0;
+    const UINT64 freeSpace1stTo2ndEnd =
+        m_2ndVectorMode == SECOND_VECTOR_DOUBLE_STACK ? suballocations2nd.back().offset : size;
+    while (lastOffset < freeSpace1stTo2ndEnd)
+    {
+        // Find next non-null allocation or move nextAllocIndex to the end.
+        while (nextAlloc1stIndex < suballoc1stCount &&
+            suballocations1st[nextAlloc1stIndex].privateData == NULL)
+        {
+            ++nextAlloc1stIndex;
+        }
+
+        // Found non-null allocation.
+        if (nextAlloc1stIndex < suballoc1stCount)
+        {
+            const Suballocation& suballoc = suballocations1st[nextAlloc1stIndex];
+
+            // 1. Process free space before this allocation.
+            if (lastOffset < suballoc.offset)
+            {
+                // There is free space from lastOffset to suballoc.offset.
+                ++unusedRangeCount;
+            }
+
+            // 2. Process this allocation.
+            // There is allocation with suballoc.offset, suballoc.size.
+            ++alloc1stCount;
+            usedBytes += suballoc.size;
+
+            // 3. Prepare for next iteration.
+            lastOffset = suballoc.offset + suballoc.size;
+            ++nextAlloc1stIndex;
+        }
+        // We are at the end.
+        else
+        {
+            if (lastOffset < size)
+            {
+                // There is free space from lastOffset to freeSpace1stTo2ndEnd.
+                ++unusedRangeCount;
+            }
+
+            // End of loop.
+            lastOffset = freeSpace1stTo2ndEnd;
+        }
+    }
+
+    if (m_2ndVectorMode == SECOND_VECTOR_DOUBLE_STACK)
+    {
+        size_t nextAlloc2ndIndex = suballocations2nd.size() - 1;
+        while (lastOffset < size)
+        {
+            // Find next non-null allocation or move nextAlloc2ndIndex to the end.
+            while (nextAlloc2ndIndex != SIZE_MAX &&
+                suballocations2nd[nextAlloc2ndIndex].privateData == NULL)
+            {
+                --nextAlloc2ndIndex;
+            }
+
+            // Found non-null allocation.
+            if (nextAlloc2ndIndex != SIZE_MAX)
+            {
+                const Suballocation& suballoc = suballocations2nd[nextAlloc2ndIndex];
+
+                // 1. Process free space before this allocation.
+                if (lastOffset < suballoc.offset)
+                {
+                    // There is free space from lastOffset to suballoc.offset.
+                    ++unusedRangeCount;
+                }
+
+                // 2. Process this allocation.
+                // There is allocation with suballoc.offset, suballoc.size.
+                ++alloc2ndCount;
+                usedBytes += suballoc.size;
+
+                // 3. Prepare for next iteration.
+                lastOffset = suballoc.offset + suballoc.size;
+                --nextAlloc2ndIndex;
+            }
+            // We are at the end.
+            else
+            {
+                if (lastOffset < size)
+                {
+                    // There is free space from lastOffset to size.
+                    ++unusedRangeCount;
+                }
+
+                // End of loop.
+                lastOffset = size;
+            }
+        }
+    }
+
+    const UINT64 unusedBytes = size - usedBytes;
+    PrintDetailedMap_Begin(json, unusedBytes, alloc1stCount + alloc2ndCount, unusedRangeCount);
+
+    // SECOND PASS
+    lastOffset = 0;
+    if (m_2ndVectorMode == SECOND_VECTOR_RING_BUFFER)
+    {
+        const UINT64 freeSpace2ndTo1stEnd = suballocations1st[m_1stNullItemsBeginCount].offset;
+        size_t nextAlloc2ndIndex = 0;
+        while (lastOffset < freeSpace2ndTo1stEnd)
+        {
+            // Find next non-null allocation or move nextAlloc2ndIndex to the end.
+            while (nextAlloc2ndIndex < suballoc2ndCount &&
+                suballocations2nd[nextAlloc2ndIndex].privateData == NULL)
+            {
+                ++nextAlloc2ndIndex;
+            }
+
+            // Found non-null allocation.
+            if (nextAlloc2ndIndex < suballoc2ndCount)
+            {
+                const Suballocation& suballoc = suballocations2nd[nextAlloc2ndIndex];
+
+                // 1. Process free space before this allocation.
+                if (lastOffset < suballoc.offset)
+                {
+                    // There is free space from lastOffset to suballoc.offset.
+                    const UINT64 unusedRangeSize = suballoc.offset - lastOffset;
+                    PrintDetailedMap_UnusedRange(json, lastOffset, unusedRangeSize);
+                }
+
+                // 2. Process this allocation.
+                // There is allocation with suballoc.offset, suballoc.size.
+                PrintDetailedMap_Allocation(json, suballoc.offset, suballoc.size, suballoc.privateData);
+
+                // 3. Prepare for next iteration.
+                lastOffset = suballoc.offset + suballoc.size;
+                ++nextAlloc2ndIndex;
+            }
+            // We are at the end.
+            else
+            {
+                if (lastOffset < freeSpace2ndTo1stEnd)
+                {
+                    // There is free space from lastOffset to freeSpace2ndTo1stEnd.
+                    const UINT64 unusedRangeSize = freeSpace2ndTo1stEnd - lastOffset;
+                    PrintDetailedMap_UnusedRange(json, lastOffset, unusedRangeSize);
+                }
+
+                // End of loop.
+                lastOffset = freeSpace2ndTo1stEnd;
+            }
+        }
+    }
+
+    nextAlloc1stIndex = m_1stNullItemsBeginCount;
+    while (lastOffset < freeSpace1stTo2ndEnd)
+    {
+        // Find next non-null allocation or move nextAllocIndex to the end.
+        while (nextAlloc1stIndex < suballoc1stCount &&
+            suballocations1st[nextAlloc1stIndex].privateData == NULL)
+        {
+            ++nextAlloc1stIndex;
+        }
+
+        // Found non-null allocation.
+        if (nextAlloc1stIndex < suballoc1stCount)
+        {
+            const Suballocation& suballoc = suballocations1st[nextAlloc1stIndex];
+
+            // 1. Process free space before this allocation.
+            if (lastOffset < suballoc.offset)
+            {
+                // There is free space from lastOffset to suballoc.offset.
+                const UINT64 unusedRangeSize = suballoc.offset - lastOffset;
+                PrintDetailedMap_UnusedRange(json, lastOffset, unusedRangeSize);
+            }
+
+            // 2. Process this allocation.
+            // There is allocation with suballoc.offset, suballoc.size.
+            PrintDetailedMap_Allocation(json, suballoc.offset, suballoc.size, suballoc.privateData);
+
+            // 3. Prepare for next iteration.
+            lastOffset = suballoc.offset + suballoc.size;
+            ++nextAlloc1stIndex;
+        }
+        // We are at the end.
+        else
+        {
+            if (lastOffset < freeSpace1stTo2ndEnd)
+            {
+                // There is free space from lastOffset to freeSpace1stTo2ndEnd.
+                const UINT64 unusedRangeSize = freeSpace1stTo2ndEnd - lastOffset;
+                PrintDetailedMap_UnusedRange(json, lastOffset, unusedRangeSize);
+            }
+
+            // End of loop.
+            lastOffset = freeSpace1stTo2ndEnd;
+        }
+    }
+
+    if (m_2ndVectorMode == SECOND_VECTOR_DOUBLE_STACK)
+    {
+        size_t nextAlloc2ndIndex = suballocations2nd.size() - 1;
+        while (lastOffset < size)
+        {
+            // Find next non-null allocation or move nextAlloc2ndIndex to the end.
+            while (nextAlloc2ndIndex != SIZE_MAX &&
+                suballocations2nd[nextAlloc2ndIndex].privateData == NULL)
+            {
+                --nextAlloc2ndIndex;
+            }
+
+            // Found non-null allocation.
+            if (nextAlloc2ndIndex != SIZE_MAX)
+            {
+                const Suballocation& suballoc = suballocations2nd[nextAlloc2ndIndex];
+
+                // 1. Process free space before this allocation.
+                if (lastOffset < suballoc.offset)
+                {
+                    // There is free space from lastOffset to suballoc.offset.
+                    const UINT64 unusedRangeSize = suballoc.offset - lastOffset;
+                    PrintDetailedMap_UnusedRange(json, lastOffset, unusedRangeSize);
+                }
+
+                // 2. Process this allocation.
+                // There is allocation with suballoc.offset, suballoc.size.
+                PrintDetailedMap_Allocation(json, suballoc.offset, suballoc.size, suballoc.privateData);
+
+                // 3. Prepare for next iteration.
+                lastOffset = suballoc.offset + suballoc.size;
+                --nextAlloc2ndIndex;
+            }
+            // We are at the end.
+            else
+            {
+                if (lastOffset < size)
+                {
+                    // There is free space from lastOffset to size.
+                    const UINT64 unusedRangeSize = size - lastOffset;
+                    PrintDetailedMap_UnusedRange(json, lastOffset, unusedRangeSize);
+                }
+
+                // End of loop.
+                lastOffset = size;
+            }
+        }
+    }
+
+    PrintDetailedMap_End(json);
+}
+
+void BlockMetadata_Linear::DebugLogAllAllocations() const
+{
+    const SuballocationVectorType& suballocations1st = AccessSuballocations1st();
+    for (auto it = suballocations1st.begin() + m_1stNullItemsBeginCount; it != suballocations1st.end(); ++it)
+        if (it->type != SUBALLOCATION_TYPE_FREE)
+            DebugLogAllocation(it->offset, it->size, it->privateData);
+
+    const SuballocationVectorType& suballocations2nd = AccessSuballocations2nd();
+    for (auto it = suballocations2nd.begin(); it != suballocations2nd.end(); ++it)
+        if (it->type != SUBALLOCATION_TYPE_FREE)
+            DebugLogAllocation(it->offset, it->size, it->privateData);
+}
+
+Suballocation& BlockMetadata_Linear::FindSuballocation(UINT64 offset) const
+{
+    const SuballocationVectorType& suballocations1st = AccessSuballocations1st();
+    const SuballocationVectorType& suballocations2nd = AccessSuballocations2nd();
+
+    Suballocation refSuballoc;
+    refSuballoc.offset = offset;
+    // Rest of members stays uninitialized intentionally for better performance.
+
+    // Item from the 1st vector.
+    {
+        const SuballocationVectorType::const_iterator it = BinaryFindSorted(
+            suballocations1st.begin() + m_1stNullItemsBeginCount,
+            suballocations1st.end(),
+            refSuballoc,
+            SuballocationOffsetLess());
+        if (it != suballocations1st.end())
+        {
+            return const_cast<Suballocation&>(*it);
+        }
+    }
+
+    if (m_2ndVectorMode != SECOND_VECTOR_EMPTY)
+    {
+        // Rest of members stays uninitialized intentionally for better performance.
+        const SuballocationVectorType::const_iterator it = m_2ndVectorMode == SECOND_VECTOR_RING_BUFFER ?
+            BinaryFindSorted(suballocations2nd.begin(), suballocations2nd.end(), refSuballoc, SuballocationOffsetLess()) :
+            BinaryFindSorted(suballocations2nd.begin(), suballocations2nd.end(), refSuballoc, SuballocationOffsetGreater());
+        if (it != suballocations2nd.end())
+        {
+            return const_cast<Suballocation&>(*it);
+        }
+    }
+
+    D3D12MA_ASSERT(0 && "Allocation not found in linear allocator!");
+    return const_cast<Suballocation&>(suballocations1st.back()); // Should never occur.
+}
+
+bool BlockMetadata_Linear::ShouldCompact1st() const
+{
+    const size_t nullItemCount = m_1stNullItemsBeginCount + m_1stNullItemsMiddleCount;
+    const size_t suballocCount = AccessSuballocations1st().size();
+    return suballocCount > 32 && nullItemCount * 2 >= (suballocCount - nullItemCount) * 3;
+}
+
+void BlockMetadata_Linear::CleanupAfterFree()
+{
+    SuballocationVectorType& suballocations1st = AccessSuballocations1st();
+    SuballocationVectorType& suballocations2nd = AccessSuballocations2nd();
+
+    if (IsEmpty())
+    {
+        suballocations1st.clear();
+        suballocations2nd.clear();
+        m_1stNullItemsBeginCount = 0;
+        m_1stNullItemsMiddleCount = 0;
+        m_2ndNullItemsCount = 0;
+        m_2ndVectorMode = SECOND_VECTOR_EMPTY;
+    }
+    else
+    {
+        const size_t suballoc1stCount = suballocations1st.size();
+        const size_t nullItem1stCount = m_1stNullItemsBeginCount + m_1stNullItemsMiddleCount;
+        D3D12MA_ASSERT(nullItem1stCount <= suballoc1stCount);
+
+        // Find more null items at the beginning of 1st vector.
+        while (m_1stNullItemsBeginCount < suballoc1stCount &&
+            suballocations1st[m_1stNullItemsBeginCount].type == SUBALLOCATION_TYPE_FREE)
+        {
+            ++m_1stNullItemsBeginCount;
+            --m_1stNullItemsMiddleCount;
+        }
+
+        // Find more null items at the end of 1st vector.
+        while (m_1stNullItemsMiddleCount > 0 &&
+            suballocations1st.back().type == SUBALLOCATION_TYPE_FREE)
+        {
+            --m_1stNullItemsMiddleCount;
+            suballocations1st.pop_back();
+        }
+
+        // Find more null items at the end of 2nd vector.
+        while (m_2ndNullItemsCount > 0 &&
+            suballocations2nd.back().type == SUBALLOCATION_TYPE_FREE)
+        {
+            --m_2ndNullItemsCount;
+            suballocations2nd.pop_back();
+        }
+
+        // Find more null items at the beginning of 2nd vector.
+        while (m_2ndNullItemsCount > 0 &&
+            suballocations2nd[0].type == SUBALLOCATION_TYPE_FREE)
+        {
+            --m_2ndNullItemsCount;
+            suballocations2nd.remove(0);
+        }
+
+        if (ShouldCompact1st())
+        {
+            const size_t nonNullItemCount = suballoc1stCount - nullItem1stCount;
+            size_t srcIndex = m_1stNullItemsBeginCount;
+            for (size_t dstIndex = 0; dstIndex < nonNullItemCount; ++dstIndex)
+            {
+                while (suballocations1st[srcIndex].type == SUBALLOCATION_TYPE_FREE)
+                {
+                    ++srcIndex;
+                }
+                if (dstIndex != srcIndex)
+                {
+                    suballocations1st[dstIndex] = suballocations1st[srcIndex];
+                }
+                ++srcIndex;
+            }
+            suballocations1st.resize(nonNullItemCount);
+            m_1stNullItemsBeginCount = 0;
+            m_1stNullItemsMiddleCount = 0;
+        }
+
+        // 2nd vector became empty.
+        if (suballocations2nd.empty())
+        {
+            m_2ndVectorMode = SECOND_VECTOR_EMPTY;
+        }
+
+        // 1st vector became empty.
+        if (suballocations1st.size() - m_1stNullItemsBeginCount == 0)
+        {
+            suballocations1st.clear();
+            m_1stNullItemsBeginCount = 0;
+
+            if (!suballocations2nd.empty() && m_2ndVectorMode == SECOND_VECTOR_RING_BUFFER)
+            {
+                // Swap 1st with 2nd. Now 2nd is empty.
+                m_2ndVectorMode = SECOND_VECTOR_EMPTY;
+                m_1stNullItemsMiddleCount = m_2ndNullItemsCount;
+                while (m_1stNullItemsBeginCount < suballocations2nd.size() &&
+                    suballocations2nd[m_1stNullItemsBeginCount].type == SUBALLOCATION_TYPE_FREE)
+                {
+                    ++m_1stNullItemsBeginCount;
+                    --m_1stNullItemsMiddleCount;
+                }
+                m_2ndNullItemsCount = 0;
+                m_1stVectorIndex ^= 1;
+            }
+        }
+    }
+
+    D3D12MA_HEAVY_ASSERT(Validate());
+}
+
+bool BlockMetadata_Linear::CreateAllocationRequest_LowerAddress(
+    UINT64 allocSize,
+    UINT64 allocAlignment,
+    AllocationRequest* pAllocationRequest)
+{
+    const UINT64 blockSize = GetSize();
+    SuballocationVectorType& suballocations1st = AccessSuballocations1st();
+    SuballocationVectorType& suballocations2nd = AccessSuballocations2nd();
+
+    if (m_2ndVectorMode == SECOND_VECTOR_EMPTY || m_2ndVectorMode == SECOND_VECTOR_DOUBLE_STACK)
+    {
+        // Try to allocate at the end of 1st vector.
+
+        UINT64 resultBaseOffset = 0;
+        if (!suballocations1st.empty())
+        {
+            const Suballocation& lastSuballoc = suballocations1st.back();
+            resultBaseOffset = lastSuballoc.offset + lastSuballoc.size + GetDebugMargin();
+        }
+
+        // Start from offset equal to beginning of free space.
+        UINT64 resultOffset = resultBaseOffset;
+        // Apply alignment.
+        resultOffset = AlignUp(resultOffset, allocAlignment);
+
+        const UINT64 freeSpaceEnd = m_2ndVectorMode == SECOND_VECTOR_DOUBLE_STACK ?
+            suballocations2nd.back().offset : blockSize;
+
+        // There is enough free space at the end after alignment.
+        if (resultOffset + allocSize + GetDebugMargin() <= freeSpaceEnd)
+        {
+            // All tests passed: Success.
+            pAllocationRequest->allocHandle = (AllocHandle)(resultOffset + 1);
+            // pAllocationRequest->item, customData unused.
+            pAllocationRequest->algorithmData = ALLOC_REQUEST_END_OF_1ST;
+            return true;
+        }
+    }
+
+    // Wrap-around to end of 2nd vector. Try to allocate there, watching for the
+    // beginning of 1st vector as the end of free space.
+    if (m_2ndVectorMode == SECOND_VECTOR_EMPTY || m_2ndVectorMode == SECOND_VECTOR_RING_BUFFER)
+    {
+        D3D12MA_ASSERT(!suballocations1st.empty());
+
+        UINT64 resultBaseOffset = 0;
+        if (!suballocations2nd.empty())
+        {
+            const Suballocation& lastSuballoc = suballocations2nd.back();
+            resultBaseOffset = lastSuballoc.offset + lastSuballoc.size + GetDebugMargin();
+        }
+
+        // Start from offset equal to beginning of free space.
+        UINT64 resultOffset = resultBaseOffset;
+
+        // Apply alignment.
+        resultOffset = AlignUp(resultOffset, allocAlignment);
+
+        size_t index1st = m_1stNullItemsBeginCount;
+        // There is enough free space at the end after alignment.
+        if ((index1st == suballocations1st.size() && resultOffset + allocSize + GetDebugMargin() <= blockSize) ||
+            (index1st < suballocations1st.size() && resultOffset + allocSize + GetDebugMargin() <= suballocations1st[index1st].offset))
+        {
+            // All tests passed: Success.
+            pAllocationRequest->allocHandle = (AllocHandle)(resultOffset + 1);
+            pAllocationRequest->algorithmData = ALLOC_REQUEST_END_OF_2ND;
+            // pAllocationRequest->item, customData unused.
+            return true;
+        }
+    }
+    return false;
+}
+
+bool BlockMetadata_Linear::CreateAllocationRequest_UpperAddress(
+    UINT64 allocSize,
+    UINT64 allocAlignment,
+    AllocationRequest* pAllocationRequest)
+{
+    const UINT64 blockSize = GetSize();
+    SuballocationVectorType& suballocations1st = AccessSuballocations1st();
+    SuballocationVectorType& suballocations2nd = AccessSuballocations2nd();
+
+    if (m_2ndVectorMode == SECOND_VECTOR_RING_BUFFER)
+    {
+        D3D12MA_ASSERT(0 && "Trying to use pool with linear algorithm as double stack, while it is already being used as ring buffer.");
+        return false;
+    }
+
+    // Try to allocate before 2nd.back(), or end of block if 2nd.empty().
+    if (allocSize > blockSize)
+    {
+        return false;
+    }
+    UINT64 resultBaseOffset = blockSize - allocSize;
+    if (!suballocations2nd.empty())
+    {
+        const Suballocation& lastSuballoc = suballocations2nd.back();
+        resultBaseOffset = lastSuballoc.offset - allocSize;
+        if (allocSize > lastSuballoc.offset)
+        {
+            return false;
+        }
+    }
+
+    // Start from offset equal to end of free space.
+    UINT64 resultOffset = resultBaseOffset;
+    // Apply debugMargin at the end.
+    if (GetDebugMargin() > 0)
+    {
+        if (resultOffset < GetDebugMargin())
+        {
+            return false;
+        }
+        resultOffset -= GetDebugMargin();
+    }
+
+    // Apply alignment.
+    resultOffset = AlignDown(resultOffset, allocAlignment);
+    // There is enough free space.
+    const UINT64 endOf1st = !suballocations1st.empty() ?
+        suballocations1st.back().offset + suballocations1st.back().size : 0;
+
+    if (endOf1st + GetDebugMargin() <= resultOffset)
+    {
+        // All tests passed: Success.
+        pAllocationRequest->allocHandle = (AllocHandle)(resultOffset + 1);
+        // pAllocationRequest->item unused.
+        pAllocationRequest->algorithmData = ALLOC_REQUEST_UPPER_ADDRESS;
+        return true;
+    }
+    return false;
+}
+#endif // _D3D12MA_BLOCK_METADATA_LINEAR_FUNCTIONS
+#endif // _D3D12MA_BLOCK_METADATA_LINEAR
+
+#ifndef _D3D12MA_BLOCK_METADATA_TLSF
+class BlockMetadata_TLSF : public BlockMetadata
+{
+public:
+    BlockMetadata_TLSF(const ALLOCATION_CALLBACKS* allocationCallbacks, bool isVirtual);
+    virtual ~BlockMetadata_TLSF();
+
+    size_t GetAllocationCount() const override { return m_AllocCount; }
+    size_t GetFreeRegionsCount() const override { return m_BlocksFreeCount + 1; }
+    UINT64 GetSumFreeSize() const override { return m_BlocksFreeSize + m_NullBlock->size; }
+    bool IsEmpty() const override { return m_NullBlock->offset == 0; }
+    UINT64 GetAllocationOffset(AllocHandle allocHandle) const override { return ((Block*)allocHandle)->offset; };
+
+    void Init(UINT64 size) override;
+    bool Validate() const override;
+    void GetAllocationInfo(AllocHandle allocHandle, VIRTUAL_ALLOCATION_INFO& outInfo) const override;
+
+    bool CreateAllocationRequest(
+        UINT64 allocSize,
+        UINT64 allocAlignment,
+        bool upperAddress,
+        UINT32 strategy,
+        AllocationRequest* pAllocationRequest) override;
+
+    void Alloc(
+        const AllocationRequest& request,
+        UINT64 allocSize,
+        void* privateData) override;
+
+    void Free(AllocHandle allocHandle) override;
+    void Clear() override;
+
+    AllocHandle GetAllocationListBegin() const override;
+    AllocHandle GetNextAllocation(AllocHandle prevAlloc) const override;
+    UINT64 GetNextFreeRegionSize(AllocHandle alloc) const override;
+    void* GetAllocationPrivateData(AllocHandle allocHandle) const override;
+    void SetAllocationPrivateData(AllocHandle allocHandle, void* privateData) override;
+
+    void AddStatistics(Statistics& inoutStats) const override;
+    void AddDetailedStatistics(DetailedStatistics& inoutStats) const override;
+    void WriteAllocationInfoToJson(JsonWriter& json) const override;
+    void DebugLogAllAllocations() const override;
+
+private:
+    // According to original paper it should be preferable 4 or 5:
+    // M. Masmano, I. Ripoll, A. Crespo, and J. Real "TLSF: a New Dynamic Memory Allocator for Real-Time Systems"
+    // http://www.gii.upv.es/tlsf/files/ecrts04_tlsf.pdf
+    static const UINT8 SECOND_LEVEL_INDEX = 5;
+    static const UINT16 SMALL_BUFFER_SIZE = 256;
+    static const UINT INITIAL_BLOCK_ALLOC_COUNT = 16;
+    static const UINT8 MEMORY_CLASS_SHIFT = 7;
+    static const UINT8 MAX_MEMORY_CLASSES = 65 - MEMORY_CLASS_SHIFT;
+
+    class Block
+    {
+    public:
+        UINT64 offset;
+        UINT64 size;
+        Block* prevPhysical;
+        Block* nextPhysical;
+
+        void MarkFree() { prevFree = NULL; }
+        void MarkTaken() { prevFree = this; }
+        bool IsFree() const { return prevFree != this; }
+        void*& PrivateData() { D3D12MA_HEAVY_ASSERT(!IsFree()); return privateData; }
+        Block*& PrevFree() { return prevFree; }
+        Block*& NextFree() { D3D12MA_HEAVY_ASSERT(IsFree()); return nextFree; }
+
+    private:
+        Block* prevFree; // Address of the same block here indicates that block is taken
+        union
+        {
+            Block* nextFree;
+            void* privateData;
+        };
+    };
+    
+    size_t m_AllocCount = 0;
+    // Total number of free blocks besides null block
+    size_t m_BlocksFreeCount = 0;
+    // Total size of free blocks excluding null block
+    UINT64 m_BlocksFreeSize = 0;
+    UINT32 m_IsFreeBitmap = 0;
+    UINT8 m_MemoryClasses = 0;
+    UINT32 m_InnerIsFreeBitmap[MAX_MEMORY_CLASSES];
+    UINT32 m_ListsCount = 0;
+    /*
+    * 0: 0-3 lists for small buffers
+    * 1+: 0-(2^SLI-1) lists for normal buffers
+    */
+    Block** m_FreeList = NULL;
+    PoolAllocator<Block> m_BlockAllocator;
+    Block* m_NullBlock = NULL;
+
+    UINT8 SizeToMemoryClass(UINT64 size) const;
+    UINT16 SizeToSecondIndex(UINT64 size, UINT8 memoryClass) const;
+    UINT32 GetListIndex(UINT8 memoryClass, UINT16 secondIndex) const;
+    UINT32 GetListIndex(UINT64 size) const;
+
+    void RemoveFreeBlock(Block* block);
+    void InsertFreeBlock(Block* block);
+    void MergeBlock(Block* block, Block* prev);
+
+    Block* FindFreeBlock(UINT64 size, UINT32& listIndex) const;
+    bool CheckBlock(
+        Block& block,
+        UINT32 listIndex,
+        UINT64 allocSize,
+        UINT64 allocAlignment,
+        AllocationRequest* pAllocationRequest);
+
+    D3D12MA_CLASS_NO_COPY(BlockMetadata_TLSF)
+};
+
+#ifndef _D3D12MA_BLOCK_METADATA_TLSF_FUNCTIONS
+BlockMetadata_TLSF::BlockMetadata_TLSF(const ALLOCATION_CALLBACKS* allocationCallbacks, bool isVirtual)
+    : BlockMetadata(allocationCallbacks, isVirtual),
+    m_BlockAllocator(*allocationCallbacks, INITIAL_BLOCK_ALLOC_COUNT)
+{
+    D3D12MA_ASSERT(allocationCallbacks);
+}
+
+BlockMetadata_TLSF::~BlockMetadata_TLSF()
+{
+    D3D12MA_DELETE_ARRAY(*GetAllocs(), m_FreeList, m_ListsCount);
+}
+
+void BlockMetadata_TLSF::Init(UINT64 size)
+{
+    BlockMetadata::Init(size);
+
+    m_NullBlock = m_BlockAllocator.Alloc();
+    m_NullBlock->size = size;
+    m_NullBlock->offset = 0;
+    m_NullBlock->prevPhysical = NULL;
+    m_NullBlock->nextPhysical = NULL;
+    m_NullBlock->MarkFree();
+    m_NullBlock->NextFree() = NULL;
+    m_NullBlock->PrevFree() = NULL;
+    UINT8 memoryClass = SizeToMemoryClass(size);
+    UINT16 sli = SizeToSecondIndex(size, memoryClass);
+    m_ListsCount = (memoryClass == 0 ? 0 : (memoryClass - 1) * (1UL << SECOND_LEVEL_INDEX) + sli) + 1;
+    if (IsVirtual())
+        m_ListsCount += 1UL << SECOND_LEVEL_INDEX;
+    else
+        m_ListsCount += 4;
+
+    m_MemoryClasses = memoryClass + 2;
+    memset(m_InnerIsFreeBitmap, 0, MAX_MEMORY_CLASSES * sizeof(UINT32));
+
+    m_FreeList = D3D12MA_NEW_ARRAY(*GetAllocs(), Block*, m_ListsCount);
+    memset(m_FreeList, 0, m_ListsCount * sizeof(Block*));
+}
+
+bool BlockMetadata_TLSF::Validate() const
+{
+    D3D12MA_VALIDATE(GetSumFreeSize() <= GetSize());
+
+    UINT64 calculatedSize = m_NullBlock->size;
+    UINT64 calculatedFreeSize = m_NullBlock->size;
+    size_t allocCount = 0;
+    size_t freeCount = 0;
+
+    // Check integrity of free lists
+    for (UINT32 list = 0; list < m_ListsCount; ++list)
+    {
+        Block* block = m_FreeList[list];
+        if (block != NULL)
+        {
+            D3D12MA_VALIDATE(block->IsFree());
+            D3D12MA_VALIDATE(block->PrevFree() == NULL);
+            while (block->NextFree())
+            {
+                D3D12MA_VALIDATE(block->NextFree()->IsFree());
+                D3D12MA_VALIDATE(block->NextFree()->PrevFree() == block);
+                block = block->NextFree();
+            }
+        }
+    }
+
+    D3D12MA_VALIDATE(m_NullBlock->nextPhysical == NULL);
+    if (m_NullBlock->prevPhysical)
+    {
+        D3D12MA_VALIDATE(m_NullBlock->prevPhysical->nextPhysical == m_NullBlock);
+    }
+
+    // Check all blocks
+    UINT64 nextOffset = m_NullBlock->offset;
+    for (Block* prev = m_NullBlock->prevPhysical; prev != NULL; prev = prev->prevPhysical)
+    {
+        D3D12MA_VALIDATE(prev->offset + prev->size == nextOffset);
+        nextOffset = prev->offset;
+        calculatedSize += prev->size;
+
+        UINT32 listIndex = GetListIndex(prev->size);
+        if (prev->IsFree())
+        {
+            ++freeCount;
+            // Check if free block belongs to free list
+            Block* freeBlock = m_FreeList[listIndex];
+            D3D12MA_VALIDATE(freeBlock != NULL);
+
+            bool found = false;
+            do
+            {
+                if (freeBlock == prev)
+                    found = true;
+
+                freeBlock = freeBlock->NextFree();
+            } while (!found && freeBlock != NULL);
+
+            D3D12MA_VALIDATE(found);
+            calculatedFreeSize += prev->size;
+        }
+        else
+        {
+            ++allocCount;
+            // Check if taken block is not on a free list
+            Block* freeBlock = m_FreeList[listIndex];
+            while (freeBlock)
+            {
+                D3D12MA_VALIDATE(freeBlock != prev);
+                freeBlock = freeBlock->NextFree();
+            }
+        }
+
+        if (prev->prevPhysical)
+        {
+            D3D12MA_VALIDATE(prev->prevPhysical->nextPhysical == prev);
+        }
+    }
+
+    D3D12MA_VALIDATE(nextOffset == 0);
+    D3D12MA_VALIDATE(calculatedSize == GetSize());
+    D3D12MA_VALIDATE(calculatedFreeSize == GetSumFreeSize());
+    D3D12MA_VALIDATE(allocCount == m_AllocCount);
+    D3D12MA_VALIDATE(freeCount == m_BlocksFreeCount);
+
+    return true;
+}
+
+void BlockMetadata_TLSF::GetAllocationInfo(AllocHandle allocHandle, VIRTUAL_ALLOCATION_INFO& outInfo) const
+{
+    Block* block = (Block*)allocHandle;
+    D3D12MA_ASSERT(!block->IsFree() && "Cannot get allocation info for free block!");
+    outInfo.Offset = block->offset;
+    outInfo.Size = block->size;
+    outInfo.pPrivateData = block->PrivateData();
+}
+
+bool BlockMetadata_TLSF::CreateAllocationRequest(
+    UINT64 allocSize,
+    UINT64 allocAlignment,
+    bool upperAddress,
+    UINT32 strategy,
+    AllocationRequest* pAllocationRequest)
+{
+    D3D12MA_ASSERT(allocSize > 0 && "Cannot allocate empty block!");
+    D3D12MA_ASSERT(!upperAddress && "ALLOCATION_FLAG_UPPER_ADDRESS can be used only with linear algorithm.");
+    D3D12MA_ASSERT(pAllocationRequest != NULL);
+    D3D12MA_HEAVY_ASSERT(Validate());
+
+    allocSize += GetDebugMargin();
+    // Quick check for too small pool
+    if (allocSize > GetSumFreeSize())
+        return false;
+
+    // If no free blocks in pool then check only null block
+    if (m_BlocksFreeCount == 0)
+        return CheckBlock(*m_NullBlock, m_ListsCount, allocSize, allocAlignment, pAllocationRequest);
+
+    // Round up to the next block
+    UINT64 sizeForNextList = allocSize;
+    UINT16 smallSizeStep = SMALL_BUFFER_SIZE / (IsVirtual() ? 1 << SECOND_LEVEL_INDEX : 4);
+    if (allocSize > SMALL_BUFFER_SIZE)
+    {
+        sizeForNextList += (1ULL << (BitScanMSB(allocSize) - SECOND_LEVEL_INDEX));
+    }
+    else if (allocSize > SMALL_BUFFER_SIZE - smallSizeStep)
+        sizeForNextList = SMALL_BUFFER_SIZE + 1;
+    else
+        sizeForNextList += smallSizeStep;
+
+    UINT32 nextListIndex = 0;
+    UINT32 prevListIndex = 0;
+    Block* nextListBlock = NULL;
+    Block* prevListBlock = NULL;
+
+    // Check blocks according to strategies
+    if (strategy & ALLOCATION_FLAG_STRATEGY_MIN_TIME)
+    {
+        // Quick check for larger block first
+        nextListBlock = FindFreeBlock(sizeForNextList, nextListIndex);
+        if (nextListBlock != NULL && CheckBlock(*nextListBlock, nextListIndex, allocSize, allocAlignment, pAllocationRequest))
+            return true;
+
+        // If not fitted then null block
+        if (CheckBlock(*m_NullBlock, m_ListsCount, allocSize, allocAlignment, pAllocationRequest))
+            return true;
+
+        // Null block failed, search larger bucket
+        while (nextListBlock)
+        {
+            if (CheckBlock(*nextListBlock, nextListIndex, allocSize, allocAlignment, pAllocationRequest))
+                return true;
+            nextListBlock = nextListBlock->NextFree();
+        }
+
+        // Failed again, check best fit bucket
+        prevListBlock = FindFreeBlock(allocSize, prevListIndex);
+        while (prevListBlock)
+        {
+            if (CheckBlock(*prevListBlock, prevListIndex, allocSize, allocAlignment, pAllocationRequest))
+                return true;
+            prevListBlock = prevListBlock->NextFree();
+        }
+    }
+    else if (strategy & ALLOCATION_FLAG_STRATEGY_MIN_MEMORY)
+    {
+        // Check best fit bucket
+        prevListBlock = FindFreeBlock(allocSize, prevListIndex);
+        while (prevListBlock)
+        {
+            if (CheckBlock(*prevListBlock, prevListIndex, allocSize, allocAlignment, pAllocationRequest))
+                return true;
+            prevListBlock = prevListBlock->NextFree();
+        }
+
+        // If failed check null block
+        if (CheckBlock(*m_NullBlock, m_ListsCount, allocSize, allocAlignment, pAllocationRequest))
+            return true;
+
+        // Check larger bucket
+        nextListBlock = FindFreeBlock(sizeForNextList, nextListIndex);
+        while (nextListBlock)
+        {
+            if (CheckBlock(*nextListBlock, nextListIndex, allocSize, allocAlignment, pAllocationRequest))
+                return true;
+            nextListBlock = nextListBlock->NextFree();
+        }
+    }
+    else if (strategy & ALLOCATION_FLAG_STRATEGY_MIN_OFFSET)
+    {
+        // Perform search from the start
+        Vector<Block*> blockList(m_BlocksFreeCount, *GetAllocs());
+
+        size_t i = m_BlocksFreeCount;
+        for (Block* block = m_NullBlock->prevPhysical; block != NULL; block = block->prevPhysical)
+        {
+            if (block->IsFree() && block->size >= allocSize)
+                blockList[--i] = block;
+        }
+
+        for (; i < m_BlocksFreeCount; ++i)
+        {
+            Block& block = *blockList[i];
+            if (CheckBlock(block, GetListIndex(block.size), allocSize, allocAlignment, pAllocationRequest))
+                return true;
+        }
+
+        // If failed check null block
+        if (CheckBlock(*m_NullBlock, m_ListsCount, allocSize, allocAlignment, pAllocationRequest))
+            return true;
+
+        // Whole range searched, no more memory
+        return false;
+    }
+    else
+    {
+        // Check larger bucket
+        nextListBlock = FindFreeBlock(sizeForNextList, nextListIndex);
+        while (nextListBlock)
+        {
+            if (CheckBlock(*nextListBlock, nextListIndex, allocSize, allocAlignment, pAllocationRequest))
+                return true;
+            nextListBlock = nextListBlock->NextFree();
+        }
+
+        // If failed check null block
+        if (CheckBlock(*m_NullBlock, m_ListsCount, allocSize, allocAlignment, pAllocationRequest))
+            return true;
+
+        // Check best fit bucket
+        prevListBlock = FindFreeBlock(allocSize, prevListIndex);
+        while (prevListBlock)
+        {
+            if (CheckBlock(*prevListBlock, prevListIndex, allocSize, allocAlignment, pAllocationRequest))
+                return true;
+            prevListBlock = prevListBlock->NextFree();
+        }
+    }
+
+    // Worst case, full search has to be done
+    while (++nextListIndex < m_ListsCount)
+    {
+        nextListBlock = m_FreeList[nextListIndex];
+        while (nextListBlock)
+        {
+            if (CheckBlock(*nextListBlock, nextListIndex, allocSize, allocAlignment, pAllocationRequest))
+                return true;
+            nextListBlock = nextListBlock->NextFree();
+        }
+    }
+
+    // No more memory sadly
+    return false;
+}
+
+void BlockMetadata_TLSF::Alloc(
+    const AllocationRequest& request,
+    UINT64 allocSize,
+    void* privateData)
+{
+    // Get block and pop it from the free list
+    Block* currentBlock = (Block*)request.allocHandle;
+    UINT64 offset = request.algorithmData;
+    D3D12MA_ASSERT(currentBlock != NULL);
+    D3D12MA_ASSERT(currentBlock->offset <= offset);
+
+    if (currentBlock != m_NullBlock)
+        RemoveFreeBlock(currentBlock);
+
+    // Append missing alignment to prev block or create new one
+    UINT64 misssingAlignment = offset - currentBlock->offset;
+    if (misssingAlignment)
+    {
+        Block* prevBlock = currentBlock->prevPhysical;
+        D3D12MA_ASSERT(prevBlock != NULL && "There should be no missing alignment at offset 0!");
+
+        if (prevBlock->IsFree() && prevBlock->size != GetDebugMargin())
+        {
+            UINT32 oldList = GetListIndex(prevBlock->size);
+            prevBlock->size += misssingAlignment;
+            // Check if new size crosses list bucket
+            if (oldList != GetListIndex(prevBlock->size))
+            {
+                prevBlock->size -= misssingAlignment;
+                RemoveFreeBlock(prevBlock);
+                prevBlock->size += misssingAlignment;
+                InsertFreeBlock(prevBlock);
+            }
+            else
+                m_BlocksFreeSize += misssingAlignment;
+        }
+        else
+        {
+            Block* newBlock = m_BlockAllocator.Alloc();
+            currentBlock->prevPhysical = newBlock;
+            prevBlock->nextPhysical = newBlock;
+            newBlock->prevPhysical = prevBlock;
+            newBlock->nextPhysical = currentBlock;
+            newBlock->size = misssingAlignment;
+            newBlock->offset = currentBlock->offset;
+            newBlock->MarkTaken();
+
+            InsertFreeBlock(newBlock);
+        }
+
+        currentBlock->size -= misssingAlignment;
+        currentBlock->offset += misssingAlignment;
+    }
+
+    UINT64 size = request.size + GetDebugMargin();
+    if (currentBlock->size == size)
+    {
+        if (currentBlock == m_NullBlock)
+        {
+            // Setup new null block
+            m_NullBlock = m_BlockAllocator.Alloc();
+            m_NullBlock->size = 0;
+            m_NullBlock->offset = currentBlock->offset + size;
+            m_NullBlock->prevPhysical = currentBlock;
+            m_NullBlock->nextPhysical = NULL;
+            m_NullBlock->MarkFree();
+            m_NullBlock->PrevFree() = NULL;
+            m_NullBlock->NextFree() = NULL;
+            currentBlock->nextPhysical = m_NullBlock;
+            currentBlock->MarkTaken();
+        }
+    }
+    else
+    {
+        D3D12MA_ASSERT(currentBlock->size > size && "Proper block already found, shouldn't find smaller one!");
+
+        // Create new free block
+        Block* newBlock = m_BlockAllocator.Alloc();
+        newBlock->size = currentBlock->size - size;
+        newBlock->offset = currentBlock->offset + size;
+        newBlock->prevPhysical = currentBlock;
+        newBlock->nextPhysical = currentBlock->nextPhysical;
+        currentBlock->nextPhysical = newBlock;
+        currentBlock->size = size;
+
+        if (currentBlock == m_NullBlock)
+        {
+            m_NullBlock = newBlock;
+            m_NullBlock->MarkFree();
+            m_NullBlock->NextFree() = NULL;
+            m_NullBlock->PrevFree() = NULL;
+            currentBlock->MarkTaken();
+        }
+        else
+        {
+            newBlock->nextPhysical->prevPhysical = newBlock;
+            newBlock->MarkTaken();
+            InsertFreeBlock(newBlock);
+        }
+    }
+    currentBlock->PrivateData() = privateData;
+
+    if (GetDebugMargin() > 0)
+    {
+        currentBlock->size -= GetDebugMargin();
+        Block* newBlock = m_BlockAllocator.Alloc();
+        newBlock->size = GetDebugMargin();
+        newBlock->offset = currentBlock->offset + currentBlock->size;
+        newBlock->prevPhysical = currentBlock;
+        newBlock->nextPhysical = currentBlock->nextPhysical;
+        newBlock->MarkTaken();
+        currentBlock->nextPhysical->prevPhysical = newBlock;
+        currentBlock->nextPhysical = newBlock;
+        InsertFreeBlock(newBlock);
+    }
+    ++m_AllocCount;
+}
+
+void BlockMetadata_TLSF::Free(AllocHandle allocHandle)
+{
+    Block* block = (Block*)allocHandle;
+    Block* next = block->nextPhysical;
+    D3D12MA_ASSERT(!block->IsFree() && "Block is already free!");
+
+    --m_AllocCount;
+    if (GetDebugMargin() > 0)
+    {
+        RemoveFreeBlock(next);
+        MergeBlock(next, block);
+        block = next;
+        next = next->nextPhysical;
+    }
+
+    // Try merging
+    Block* prev = block->prevPhysical;
+    if (prev != NULL && prev->IsFree() && prev->size != GetDebugMargin())
+    {
+        RemoveFreeBlock(prev);
+        MergeBlock(block, prev);
+    }
+
+    if (!next->IsFree())
+        InsertFreeBlock(block);
+    else if (next == m_NullBlock)
+        MergeBlock(m_NullBlock, block);
+    else
+    {
+        RemoveFreeBlock(next);
+        MergeBlock(next, block);
+        InsertFreeBlock(next);
+    }
+}
+
+void BlockMetadata_TLSF::Clear()
+{
+    m_AllocCount = 0;
+    m_BlocksFreeCount = 0;
+    m_BlocksFreeSize = 0;
+    m_IsFreeBitmap = 0;
+    m_NullBlock->offset = 0;
+    m_NullBlock->size = GetSize();
+    Block* block = m_NullBlock->prevPhysical;
+    m_NullBlock->prevPhysical = NULL;
+    while (block)
+    {
+        Block* prev = block->prevPhysical;
+        m_BlockAllocator.Free(block);
+        block = prev;
+    }
+    memset(m_FreeList, 0, m_ListsCount * sizeof(Block*));
+    memset(m_InnerIsFreeBitmap, 0, m_MemoryClasses * sizeof(UINT32));
+}
+
+AllocHandle BlockMetadata_TLSF::GetAllocationListBegin() const
+{
+    if (m_AllocCount == 0)
+        return (AllocHandle)0;
+
+    for (Block* block = m_NullBlock->prevPhysical; block; block = block->prevPhysical)
+    {
+        if (!block->IsFree())
+            return (AllocHandle)block;
+    }
+    D3D12MA_ASSERT(false && "If m_AllocCount > 0 then should find any allocation!");
+    return (AllocHandle)0;
+}
+
+AllocHandle BlockMetadata_TLSF::GetNextAllocation(AllocHandle prevAlloc) const
+{
+    Block* startBlock = (Block*)prevAlloc;
+    D3D12MA_ASSERT(!startBlock->IsFree() && "Incorrect block!");
+
+    for (Block* block = startBlock->prevPhysical; block; block = block->prevPhysical)
+    {
+        if (!block->IsFree())
+            return (AllocHandle)block;
+    }
+    return (AllocHandle)0;
+}
+
+UINT64 BlockMetadata_TLSF::GetNextFreeRegionSize(AllocHandle alloc) const
+{
+    Block* block = (Block*)alloc;
+    D3D12MA_ASSERT(!block->IsFree() && "Incorrect block!");
+
+    if (block->prevPhysical)
+        return block->prevPhysical->IsFree() ? block->prevPhysical->size : 0;
+    return 0;
+}
+
+void* BlockMetadata_TLSF::GetAllocationPrivateData(AllocHandle allocHandle) const
+{
+    Block* block = (Block*)allocHandle;
+    D3D12MA_ASSERT(!block->IsFree() && "Cannot get user data for free block!");
+    return block->PrivateData();
+}
+
+void BlockMetadata_TLSF::SetAllocationPrivateData(AllocHandle allocHandle, void* privateData)
+{
+    Block* block = (Block*)allocHandle;
+    D3D12MA_ASSERT(!block->IsFree() && "Trying to set user data for not allocated block!");
+    block->PrivateData() = privateData;
+}
+
+void BlockMetadata_TLSF::AddStatistics(Statistics& inoutStats) const
+{
+    inoutStats.BlockCount++;
+    inoutStats.AllocationCount += static_cast<UINT>(m_AllocCount);
+    inoutStats.BlockBytes += GetSize();
+    inoutStats.AllocationBytes += GetSize() - GetSumFreeSize();
+}
+
+void BlockMetadata_TLSF::AddDetailedStatistics(DetailedStatistics& inoutStats) const
+{
+    inoutStats.Stats.BlockCount++;
+    inoutStats.Stats.BlockBytes += GetSize();
+
+    for (Block* block = m_NullBlock->prevPhysical; block != NULL; block = block->prevPhysical)
+    {
+        if (block->IsFree())
+            AddDetailedStatisticsUnusedRange(inoutStats, block->size);
+        else
+            AddDetailedStatisticsAllocation(inoutStats, block->size);
+    }
+
+    if (m_NullBlock->size > 0)
+        AddDetailedStatisticsUnusedRange(inoutStats, m_NullBlock->size);
+}
+
+void BlockMetadata_TLSF::WriteAllocationInfoToJson(JsonWriter& json) const
+{
+    size_t blockCount = m_AllocCount + m_BlocksFreeCount;
+    Vector<Block*> blockList(blockCount, *GetAllocs());
+
+    size_t i = blockCount;
+    if (m_NullBlock->size > 0)
+    {
+        ++blockCount;
+        blockList.push_back(m_NullBlock);
+    }
+    for (Block* block = m_NullBlock->prevPhysical; block != NULL; block = block->prevPhysical)
+    {
+        blockList[--i] = block;
+    }
+    D3D12MA_ASSERT(i == 0);
+
+    PrintDetailedMap_Begin(json, GetSumFreeSize(), GetAllocationCount(), m_BlocksFreeCount + static_cast<bool>(m_NullBlock->size));
+    for (; i < blockCount; ++i)
+    {
+        Block* block = blockList[i];
+        if (block->IsFree())
+            PrintDetailedMap_UnusedRange(json, block->offset, block->size);
+        else
+            PrintDetailedMap_Allocation(json, block->offset, block->size, block->PrivateData());
+    }
+    PrintDetailedMap_End(json);
+}
+
+void BlockMetadata_TLSF::DebugLogAllAllocations() const
+{
+    for (Block* block = m_NullBlock->prevPhysical; block != NULL; block = block->prevPhysical)
+    {
+        if (!block->IsFree())
+        {
+            DebugLogAllocation(block->offset, block->size, block->PrivateData());
+        }
+    }
+}
+
+UINT8 BlockMetadata_TLSF::SizeToMemoryClass(UINT64 size) const
+{
+    if (size > SMALL_BUFFER_SIZE)
+        return BitScanMSB(size) - MEMORY_CLASS_SHIFT;
+    return 0;
+}
+
+UINT16 BlockMetadata_TLSF::SizeToSecondIndex(UINT64 size, UINT8 memoryClass) const
+{
+    if (memoryClass == 0)
+    {
+        if (IsVirtual())
+            return static_cast<UINT16>((size - 1) / 8);
+        else
+            return static_cast<UINT16>((size - 1) / 64);
+    }
+    return static_cast<UINT16>((size >> (memoryClass + MEMORY_CLASS_SHIFT - SECOND_LEVEL_INDEX)) ^ (1U << SECOND_LEVEL_INDEX));
+}
+
+UINT32 BlockMetadata_TLSF::GetListIndex(UINT8 memoryClass, UINT16 secondIndex) const
+{
+    if (memoryClass == 0)
+        return secondIndex;
+
+    const UINT32 index = static_cast<UINT32>(memoryClass - 1) * (1 << SECOND_LEVEL_INDEX) + secondIndex;
+    if (IsVirtual())
+        return index + (1 << SECOND_LEVEL_INDEX);
+    else
+        return index + 4;
+}
+
+UINT32 BlockMetadata_TLSF::GetListIndex(UINT64 size) const
+{
+    UINT8 memoryClass = SizeToMemoryClass(size);
+    return GetListIndex(memoryClass, SizeToSecondIndex(size, memoryClass));
+}
+
+void BlockMetadata_TLSF::RemoveFreeBlock(Block* block)
+{
+    D3D12MA_ASSERT(block != m_NullBlock);
+    D3D12MA_ASSERT(block->IsFree());
+
+    if (block->NextFree() != NULL)
+        block->NextFree()->PrevFree() = block->PrevFree();
+    if (block->PrevFree() != NULL)
+        block->PrevFree()->NextFree() = block->NextFree();
+    else
+    {
+        UINT8 memClass = SizeToMemoryClass(block->size);
+        UINT16 secondIndex = SizeToSecondIndex(block->size, memClass);
+        UINT32 index = GetListIndex(memClass, secondIndex);
+        m_FreeList[index] = block->NextFree();
+        if (block->NextFree() == NULL)
+        {
+            m_InnerIsFreeBitmap[memClass] &= ~(1U << secondIndex);
+            if (m_InnerIsFreeBitmap[memClass] == 0)
+                m_IsFreeBitmap &= ~(1UL << memClass);
+        }
+    }
+    block->MarkTaken();
+    block->PrivateData() = NULL;
+    --m_BlocksFreeCount;
+    m_BlocksFreeSize -= block->size;
+}
+
+void BlockMetadata_TLSF::InsertFreeBlock(Block* block)
+{
+    D3D12MA_ASSERT(block != m_NullBlock);
+    D3D12MA_ASSERT(!block->IsFree() && "Cannot insert block twice!");
+
+    UINT8 memClass = SizeToMemoryClass(block->size);
+    UINT16 secondIndex = SizeToSecondIndex(block->size, memClass);
+    UINT32 index = GetListIndex(memClass, secondIndex);
+    block->PrevFree() = NULL;
+    block->NextFree() = m_FreeList[index];
+    m_FreeList[index] = block;
+    if (block->NextFree() != NULL)
+        block->NextFree()->PrevFree() = block;
+    else
+    {
+        m_InnerIsFreeBitmap[memClass] |= 1U << secondIndex;
+        m_IsFreeBitmap |= 1UL << memClass;
+    }
+    ++m_BlocksFreeCount;
+    m_BlocksFreeSize += block->size;
+}
+
+void BlockMetadata_TLSF::MergeBlock(Block* block, Block* prev)
+{
+    D3D12MA_ASSERT(block->prevPhysical == prev && "Cannot merge seperate physical regions!");
+    D3D12MA_ASSERT(!prev->IsFree() && "Cannot merge block that belongs to free list!");
+
+    block->offset = prev->offset;
+    block->size += prev->size;
+    block->prevPhysical = prev->prevPhysical;
+    if (block->prevPhysical)
+        block->prevPhysical->nextPhysical = block;
+    m_BlockAllocator.Free(prev);
+}
+
+BlockMetadata_TLSF::Block* BlockMetadata_TLSF::FindFreeBlock(UINT64 size, UINT32& listIndex) const
+{
+    UINT8 memoryClass = SizeToMemoryClass(size);
+    UINT32 innerFreeMap = m_InnerIsFreeBitmap[memoryClass] & (~0U << SizeToSecondIndex(size, memoryClass));
+    if (!innerFreeMap)
+    {
+        // Check higher levels for avaiable blocks
+        UINT32 freeMap = m_IsFreeBitmap & (~0UL << (memoryClass + 1));
+        if (!freeMap)
+            return NULL; // No more memory avaible
+
+        // Find lowest free region
+        memoryClass = BitScanLSB(freeMap);
+        innerFreeMap = m_InnerIsFreeBitmap[memoryClass];
+        D3D12MA_ASSERT(innerFreeMap != 0);
+    }
+    // Find lowest free subregion
+    listIndex = GetListIndex(memoryClass, BitScanLSB(innerFreeMap));
+    return m_FreeList[listIndex];
+}
+
+bool BlockMetadata_TLSF::CheckBlock(
+    Block& block,
+    UINT32 listIndex,
+    UINT64 allocSize,
+    UINT64 allocAlignment,
+    AllocationRequest* pAllocationRequest)
+{
+    D3D12MA_ASSERT(block.IsFree() && "Block is already taken!");
+
+    UINT64 alignedOffset = AlignUp(block.offset, allocAlignment);
+    if (block.size < allocSize + alignedOffset - block.offset)
+        return false;
+
+    // Alloc successful
+    pAllocationRequest->allocHandle = (AllocHandle)&block;
+    pAllocationRequest->size = allocSize - GetDebugMargin();
+    pAllocationRequest->algorithmData = alignedOffset;
+
+    // Place block at the start of list if it's normal block
+    if (listIndex != m_ListsCount && block.PrevFree())
+    {
+        block.PrevFree()->NextFree() = block.NextFree();
+        if (block.NextFree())
+            block.NextFree()->PrevFree() = block.PrevFree();
+        block.PrevFree() = NULL;
+        block.NextFree() = m_FreeList[listIndex];
+        m_FreeList[listIndex] = &block;
+        if (block.NextFree())
+            block.NextFree()->PrevFree() = &block;
+    }
+
+    return true;
+}
+#endif // _D3D12MA_BLOCK_METADATA_TLSF_FUNCTIONS
+#endif // _D3D12MA_BLOCK_METADATA_TLSF
+
+#ifndef _D3D12MA_MEMORY_BLOCK
+/*
+Represents a single block of device memory (heap).
+Base class for inheritance.
+Thread-safety: This class must be externally synchronized.
+*/
+class MemoryBlock
+{
+public:
+    // Creates the ID3D12Heap.
+    MemoryBlock(
+        AllocatorPimpl* allocator,
+        const D3D12_HEAP_PROPERTIES& heapProps,
+        D3D12_HEAP_FLAGS heapFlags,
+        UINT64 size,
+        UINT id);
+    virtual ~MemoryBlock();
+
+    const D3D12_HEAP_PROPERTIES& GetHeapProperties() const { return m_HeapProps; }
+    D3D12_HEAP_FLAGS GetHeapFlags() const { return m_HeapFlags; }
+    UINT64 GetSize() const { return m_Size; }
+    UINT GetId() const { return m_Id; }
+    ID3D12Heap* GetHeap() const { return m_Heap; }
+
+protected:
+    AllocatorPimpl* const m_Allocator;
+    const D3D12_HEAP_PROPERTIES m_HeapProps;
+    const D3D12_HEAP_FLAGS m_HeapFlags;
+    const UINT64 m_Size;
+    const UINT m_Id;
+
+    HRESULT Init(ID3D12ProtectedResourceSession* pProtectedSession, bool denyMsaaTextures);
+
+private:
+    ID3D12Heap* m_Heap = NULL;
+
+    D3D12MA_CLASS_NO_COPY(MemoryBlock)
+};
+#endif // _D3D12MA_MEMORY_BLOCK
+
+#ifndef _D3D12MA_NORMAL_BLOCK
+/*
+Represents a single block of device memory (heap) with all the data about its
+regions (aka suballocations, Allocation), assigned and free.
+Thread-safety: This class must be externally synchronized.
+*/
+class NormalBlock : public MemoryBlock
+{
+public:
+    BlockMetadata* m_pMetadata;
+
+    NormalBlock(
+        AllocatorPimpl* allocator,
+        BlockVector* blockVector,
+        const D3D12_HEAP_PROPERTIES& heapProps,
+        D3D12_HEAP_FLAGS heapFlags,
+        UINT64 size,
+        UINT id);
+    virtual ~NormalBlock();
+
+    BlockVector* GetBlockVector() const { return m_BlockVector; }
+
+    // 'algorithm' should be one of the *_ALGORITHM_* flags in enums POOL_FLAGS or VIRTUAL_BLOCK_FLAGS
+    HRESULT Init(UINT32 algorithm, ID3D12ProtectedResourceSession* pProtectedSession, bool denyMsaaTextures);
+
+    // Validates all data structures inside this object. If not valid, returns false.
+    bool Validate() const;
+
+private:
+    BlockVector* m_BlockVector;
+
+    D3D12MA_CLASS_NO_COPY(NormalBlock)
+};
+#endif // _D3D12MA_NORMAL_BLOCK
+
+#ifndef _D3D12MA_COMMITTED_ALLOCATION_LIST_ITEM_TRAITS
+struct CommittedAllocationListItemTraits
+{
+    using ItemType = Allocation;
+
+    static ItemType* GetPrev(const ItemType* item)
+    {
+        D3D12MA_ASSERT(item->m_PackedData.GetType() == Allocation::TYPE_COMMITTED || item->m_PackedData.GetType() == Allocation::TYPE_HEAP);
+        return item->m_Committed.prev;
+    }
+    static ItemType* GetNext(const ItemType* item)
+    {
+        D3D12MA_ASSERT(item->m_PackedData.GetType() == Allocation::TYPE_COMMITTED || item->m_PackedData.GetType() == Allocation::TYPE_HEAP);
+        return item->m_Committed.next;
+    }
+    static ItemType*& AccessPrev(ItemType* item)
+    {
+        D3D12MA_ASSERT(item->m_PackedData.GetType() == Allocation::TYPE_COMMITTED || item->m_PackedData.GetType() == Allocation::TYPE_HEAP);
+        return item->m_Committed.prev;
+    }
+    static ItemType*& AccessNext(ItemType* item)
+    {
+        D3D12MA_ASSERT(item->m_PackedData.GetType() == Allocation::TYPE_COMMITTED || item->m_PackedData.GetType() == Allocation::TYPE_HEAP);
+        return item->m_Committed.next;
+    }
+};
+#endif // _D3D12MA_COMMITTED_ALLOCATION_LIST_ITEM_TRAITS
+
+#ifndef _D3D12MA_COMMITTED_ALLOCATION_LIST
+/*
+Stores linked list of Allocation objects that are of TYPE_COMMITTED or TYPE_HEAP.
+Thread-safe, synchronized internally.
+*/
+class CommittedAllocationList
+{
+public:
+    CommittedAllocationList() = default;
+    void Init(bool useMutex, D3D12_HEAP_TYPE heapType, PoolPimpl* pool);
+    ~CommittedAllocationList();
+
+    D3D12_HEAP_TYPE GetHeapType() const { return m_HeapType; }
+    PoolPimpl* GetPool() const { return m_Pool; }
+    UINT GetMemorySegmentGroup(AllocatorPimpl* allocator) const;
+    
+    void AddStatistics(Statistics& inoutStats);
+    void AddDetailedStatistics(DetailedStatistics& inoutStats);
+    // Writes JSON array with the list of allocations.
+    void BuildStatsString(JsonWriter& json);
+
+    void Register(Allocation* alloc);
+    void Unregister(Allocation* alloc);
+
+private:
+    using CommittedAllocationLinkedList = IntrusiveLinkedList<CommittedAllocationListItemTraits>;
+
+    bool m_UseMutex = true;
+    D3D12_HEAP_TYPE m_HeapType = D3D12_HEAP_TYPE_CUSTOM;
+    PoolPimpl* m_Pool = NULL;
+
+    D3D12MA_RW_MUTEX m_Mutex;
+    CommittedAllocationLinkedList m_AllocationList;
+};
+#endif // _D3D12MA_COMMITTED_ALLOCATION_LIST
+
+#ifndef _D3D12M_COMMITTED_ALLOCATION_PARAMETERS
+struct CommittedAllocationParameters
+{
+    CommittedAllocationList* m_List = NULL;
+    D3D12_HEAP_PROPERTIES m_HeapProperties = {};
+    D3D12_HEAP_FLAGS m_HeapFlags = D3D12_HEAP_FLAG_NONE;
+    ID3D12ProtectedResourceSession* m_ProtectedSession = NULL;
+    bool m_CanAlias = false;
+    D3D12_RESIDENCY_PRIORITY m_ResidencyPriority = D3D12_RESIDENCY_PRIORITY_NONE;
+
+    bool IsValid() const { return m_List != NULL; }
+};
+#endif // _D3D12M_COMMITTED_ALLOCATION_PARAMETERS
+
+// Simple variant data structure to hold all possible variations of ID3D12Device*::CreateCommittedResource* and ID3D12Device*::CreatePlacedResource* arguments
+struct CREATE_RESOURCE_PARAMS
+{
+    CREATE_RESOURCE_PARAMS() = delete;
+    CREATE_RESOURCE_PARAMS(
+        const D3D12_RESOURCE_DESC* pResourceDesc, 
+        D3D12_RESOURCE_STATES InitialResourceState, 
+        const D3D12_CLEAR_VALUE* pOptimizedClearValue)
+        : Variant(VARIANT_WITH_STATE)
+        , pResourceDesc(pResourceDesc)
+        , InitialResourceState(InitialResourceState)
+        , pOptimizedClearValue(pOptimizedClearValue)
+    {
+    }
+#ifdef __ID3D12Device8_INTERFACE_DEFINED__
+    CREATE_RESOURCE_PARAMS(
+        const D3D12_RESOURCE_DESC1* pResourceDesc, 
+        D3D12_RESOURCE_STATES InitialResourceState, 
+        const D3D12_CLEAR_VALUE* pOptimizedClearValue)
+        : Variant(VARIANT_WITH_STATE_AND_DESC1)
+        , pResourceDesc1(pResourceDesc)
+        , InitialResourceState(InitialResourceState)
+        , pOptimizedClearValue(pOptimizedClearValue)
+    {
+    }
+#endif
+#ifdef __ID3D12Device10_INTERFACE_DEFINED__
+    CREATE_RESOURCE_PARAMS(
+        const D3D12_RESOURCE_DESC1* pResourceDesc,
+        D3D12_BARRIER_LAYOUT InitialLayout,
+        const D3D12_CLEAR_VALUE* pOptimizedClearValue,
+        UINT32 NumCastableFormats,
+        DXGI_FORMAT* pCastableFormats)
+        : Variant(VARIANT_WITH_LAYOUT)
+        , pResourceDesc1(pResourceDesc)
+        , InitialLayout(InitialLayout)
+        , pOptimizedClearValue(pOptimizedClearValue)
+        , NumCastableFormats(NumCastableFormats)
+        , pCastableFormats(pCastableFormats)
+    {
+    }
+#endif
+
+    enum VARIANT
+    {
+        VARIANT_INVALID = 0,
+        VARIANT_WITH_STATE,
+        VARIANT_WITH_STATE_AND_DESC1,
+        VARIANT_WITH_LAYOUT
+    };
+
+    VARIANT Variant = VARIANT_INVALID;
+
+    const D3D12_RESOURCE_DESC* GetResourceDesc() const
+    {
+        D3D12MA_ASSERT(Variant == VARIANT_WITH_STATE);
+        return pResourceDesc;
+    }
+    const D3D12_RESOURCE_DESC*& AccessResourceDesc()
+    {
+        D3D12MA_ASSERT(Variant == VARIANT_WITH_STATE);
+        return pResourceDesc;
+    }
+    const D3D12_RESOURCE_DESC* GetBaseResourceDesc() const
+    {
+        // D3D12_RESOURCE_DESC1 can be cast to D3D12_RESOURCE_DESC by discarding the new members at the end.
+        return pResourceDesc;
+    }
+    D3D12_RESOURCE_STATES GetInitialResourceState() const
+    {
+        D3D12MA_ASSERT(Variant < VARIANT_WITH_LAYOUT);
+        return InitialResourceState;
+    }
+    const D3D12_CLEAR_VALUE* GetOptimizedClearValue() const
+    {
+        return pOptimizedClearValue;
+    }
+
+#ifdef __ID3D12Device8_INTERFACE_DEFINED__
+    const D3D12_RESOURCE_DESC1* GetResourceDesc1() const
+    {
+        D3D12MA_ASSERT(Variant >= VARIANT_WITH_STATE_AND_DESC1);
+        return pResourceDesc1;
+    }
+    const D3D12_RESOURCE_DESC1*& AccessResourceDesc1()
+    {
+        D3D12MA_ASSERT(Variant >= VARIANT_WITH_STATE_AND_DESC1);
+        return pResourceDesc1;
+    }
+#endif
+
+#ifdef __ID3D12Device10_INTERFACE_DEFINED__
+    D3D12_BARRIER_LAYOUT GetInitialLayout() const
+    {
+        D3D12MA_ASSERT(Variant >= VARIANT_WITH_LAYOUT);
+        return InitialLayout;
+    }
+    UINT32 GetNumCastableFormats() const
+    {
+        D3D12MA_ASSERT(Variant >= VARIANT_WITH_LAYOUT);
+        return NumCastableFormats;
+    }
+    DXGI_FORMAT* GetCastableFormats() const
+    {
+        D3D12MA_ASSERT(Variant >= VARIANT_WITH_LAYOUT);
+        return pCastableFormats;
+    }
+#endif
+
+private:
+    union
+    {
+        const D3D12_RESOURCE_DESC* pResourceDesc;
+#ifdef __ID3D12Device8_INTERFACE_DEFINED__
+        const D3D12_RESOURCE_DESC1* pResourceDesc1;
+#endif
+    };
+    union
+    {
+        D3D12_RESOURCE_STATES InitialResourceState;
+#ifdef __ID3D12Device10_INTERFACE_DEFINED__
+        D3D12_BARRIER_LAYOUT InitialLayout;
+#endif
+    };
+    const D3D12_CLEAR_VALUE* pOptimizedClearValue;
+#ifdef __ID3D12Device10_INTERFACE_DEFINED__
+    UINT32 NumCastableFormats;
+    DXGI_FORMAT* pCastableFormats;
+#endif
+};
+
+#ifndef _D3D12MA_BLOCK_VECTOR
+/*
+Sequence of NormalBlock. Represents memory blocks allocated for a specific
+heap type and possibly resource type (if only Tier 1 is supported).
+
+Synchronized internally with a mutex.
+*/
+class BlockVector
+{
+    friend class DefragmentationContextPimpl;
+    D3D12MA_CLASS_NO_COPY(BlockVector)
+public:
+    BlockVector(
+        AllocatorPimpl* hAllocator,
+        const D3D12_HEAP_PROPERTIES& heapProps,
+        D3D12_HEAP_FLAGS heapFlags,
+        UINT64 preferredBlockSize,
+        size_t minBlockCount,
+        size_t maxBlockCount,
+        bool explicitBlockSize,
+        UINT64 minAllocationAlignment,
+        UINT32 algorithm,
+        bool denyMsaaTextures,
+        ID3D12ProtectedResourceSession* pProtectedSession,
+        D3D12_RESIDENCY_PRIORITY residencyPriority);
+    ~BlockVector();
+    D3D12_RESIDENCY_PRIORITY GetResidencyPriority() const { return m_ResidencyPriority; }
+
+    const D3D12_HEAP_PROPERTIES& GetHeapProperties() const { return m_HeapProps; }
+    D3D12_HEAP_FLAGS GetHeapFlags() const { return m_HeapFlags; }
+    UINT64 GetPreferredBlockSize() const { return m_PreferredBlockSize; }
+    UINT32 GetAlgorithm() const { return m_Algorithm; }
+    bool DeniesMsaaTextures() const { return m_DenyMsaaTextures; }
+    // To be used only while the m_Mutex is locked. Used during defragmentation.
+    size_t GetBlockCount() const { return m_Blocks.size(); }
+    // To be used only while the m_Mutex is locked. Used during defragmentation.
+    NormalBlock* GetBlock(size_t index) const { return m_Blocks[index]; }
+    D3D12MA_RW_MUTEX& GetMutex() { return m_Mutex; }
+
+    HRESULT CreateMinBlocks();
+    bool IsEmpty();
+
+    HRESULT Allocate(
+        UINT64 size,
+        UINT64 alignment,
+        const ALLOCATION_DESC& allocDesc,
+        size_t allocationCount,
+        Allocation** pAllocations);
+
+    void Free(Allocation* hAllocation);
+
+    HRESULT CreateResource(
+        UINT64 size,
+        UINT64 alignment,
+        const ALLOCATION_DESC& allocDesc,
+        const CREATE_RESOURCE_PARAMS& createParams,
+        Allocation** ppAllocation,
+        REFIID riidResource,
+        void** ppvResource);
+
+    void AddStatistics(Statistics& inoutStats);
+    void AddDetailedStatistics(DetailedStatistics& inoutStats);
+
+    void WriteBlockInfoToJson(JsonWriter& json);
+
+private:
+    AllocatorPimpl* const m_hAllocator;
+    const D3D12_HEAP_PROPERTIES m_HeapProps;
+    const D3D12_HEAP_FLAGS m_HeapFlags;
+    const UINT64 m_PreferredBlockSize;
+    const size_t m_MinBlockCount;
+    const size_t m_MaxBlockCount;
+    const bool m_ExplicitBlockSize;
+    const UINT64 m_MinAllocationAlignment;
+    const UINT32 m_Algorithm;
+    const bool m_DenyMsaaTextures;
+    ID3D12ProtectedResourceSession* const m_ProtectedSession;
+    const D3D12_RESIDENCY_PRIORITY m_ResidencyPriority;
+    /* There can be at most one allocation that is completely empty - a
+    hysteresis to avoid pessimistic case of alternating creation and destruction
+    of a ID3D12Heap. */
+    bool m_HasEmptyBlock;
+    D3D12MA_RW_MUTEX m_Mutex;
+    // Incrementally sorted by sumFreeSize, ascending.
+    Vector<NormalBlock*> m_Blocks;
+    UINT m_NextBlockId;
+    bool m_IncrementalSort = true;
+
+    // Disable incremental sorting when freeing allocations
+    void SetIncrementalSort(bool val) { m_IncrementalSort = val; }
+
+    UINT64 CalcSumBlockSize() const;
+    UINT64 CalcMaxBlockSize() const;
+
+    // Finds and removes given block from vector.
+    void Remove(NormalBlock* pBlock);
+
+    // Performs single step in sorting m_Blocks. They may not be fully sorted
+    // after this call.
+    void IncrementallySortBlocks();
+    void SortByFreeSize();
+
+    HRESULT AllocatePage(
+        UINT64 size,
+        UINT64 alignment,
+        const ALLOCATION_DESC& allocDesc,
+        Allocation** pAllocation);
+
+    HRESULT AllocateFromBlock(
+        NormalBlock* pBlock,
+        UINT64 size,
+        UINT64 alignment,
+        ALLOCATION_FLAGS allocFlags,
+        void* pPrivateData,
+        UINT32 strategy,
+        Allocation** pAllocation);
+
+    HRESULT CommitAllocationRequest(
+        AllocationRequest& allocRequest,
+        NormalBlock* pBlock,
+        UINT64 size,
+        UINT64 alignment,
+        void* pPrivateData,
+        Allocation** pAllocation);
+
+    HRESULT CreateBlock(
+        UINT64 blockSize,
+        size_t* pNewBlockIndex);
+};
+#endif // _D3D12MA_BLOCK_VECTOR
+
+#ifndef _D3D12MA_CURRENT_BUDGET_DATA
+class CurrentBudgetData
+{
+public:
+    bool ShouldUpdateBudget() const { return m_OperationsSinceBudgetFetch >= 30; }
+
+    void GetStatistics(Statistics& outStats, UINT group) const;
+    void GetBudget(bool useMutex,
+        UINT64* outLocalUsage, UINT64* outLocalBudget,
+        UINT64* outNonLocalUsage, UINT64* outNonLocalBudget);
+
+#if D3D12MA_DXGI_1_4
+    HRESULT UpdateBudget(IDXGIAdapter3* adapter3, bool useMutex);
+#endif
+
+    void AddAllocation(UINT group, UINT64 allocationBytes);
+    void RemoveAllocation(UINT group, UINT64 allocationBytes);
+
+    void AddBlock(UINT group, UINT64 blockBytes);
+    void RemoveBlock(UINT group, UINT64 blockBytes);
+
+private:
+    D3D12MA_ATOMIC_UINT32 m_BlockCount[DXGI_MEMORY_SEGMENT_GROUP_COUNT] = {};
+    D3D12MA_ATOMIC_UINT32 m_AllocationCount[DXGI_MEMORY_SEGMENT_GROUP_COUNT] = {};
+    D3D12MA_ATOMIC_UINT64 m_BlockBytes[DXGI_MEMORY_SEGMENT_GROUP_COUNT] = {};
+    D3D12MA_ATOMIC_UINT64 m_AllocationBytes[DXGI_MEMORY_SEGMENT_GROUP_COUNT] = {};
+
+    D3D12MA_ATOMIC_UINT32 m_OperationsSinceBudgetFetch = {0};
+    D3D12MA_RW_MUTEX m_BudgetMutex;
+    UINT64 m_D3D12Usage[DXGI_MEMORY_SEGMENT_GROUP_COUNT] = {};
+    UINT64 m_D3D12Budget[DXGI_MEMORY_SEGMENT_GROUP_COUNT] = {};
+    UINT64 m_BlockBytesAtD3D12Fetch[DXGI_MEMORY_SEGMENT_GROUP_COUNT] = {};
+};
+
+#ifndef _D3D12MA_CURRENT_BUDGET_DATA_FUNCTIONS
+void CurrentBudgetData::GetStatistics(Statistics& outStats, UINT group) const
+{
+    outStats.BlockCount = m_BlockCount[group];
+    outStats.AllocationCount = m_AllocationCount[group];
+    outStats.BlockBytes = m_BlockBytes[group];
+    outStats.AllocationBytes = m_AllocationBytes[group];
+}
+
+void CurrentBudgetData::GetBudget(bool useMutex,
+    UINT64* outLocalUsage, UINT64* outLocalBudget,
+    UINT64* outNonLocalUsage, UINT64* outNonLocalBudget)
+{
+    MutexLockRead lockRead(m_BudgetMutex, useMutex);
+
+    if (outLocalUsage)
+    {
+        const UINT64 D3D12Usage = m_D3D12Usage[DXGI_MEMORY_SEGMENT_GROUP_LOCAL_COPY];
+        const UINT64 blockBytes = m_BlockBytes[DXGI_MEMORY_SEGMENT_GROUP_LOCAL_COPY];
+        const UINT64 blockBytesAtD3D12Fetch = m_BlockBytesAtD3D12Fetch[DXGI_MEMORY_SEGMENT_GROUP_LOCAL_COPY];
+        *outLocalUsage = D3D12Usage + blockBytes > blockBytesAtD3D12Fetch ?
+            D3D12Usage + blockBytes - blockBytesAtD3D12Fetch : 0;
+    }
+    if (outLocalBudget)
+        *outLocalBudget = m_D3D12Budget[DXGI_MEMORY_SEGMENT_GROUP_LOCAL_COPY];
+
+    if (outNonLocalUsage)
+    {
+        const UINT64 D3D12Usage = m_D3D12Usage[DXGI_MEMORY_SEGMENT_GROUP_NON_LOCAL_COPY];
+        const UINT64 blockBytes = m_BlockBytes[DXGI_MEMORY_SEGMENT_GROUP_NON_LOCAL_COPY];
+        const UINT64 blockBytesAtD3D12Fetch = m_BlockBytesAtD3D12Fetch[DXGI_MEMORY_SEGMENT_GROUP_NON_LOCAL_COPY];
+        *outNonLocalUsage = D3D12Usage + blockBytes > blockBytesAtD3D12Fetch ?
+            D3D12Usage + blockBytes - blockBytesAtD3D12Fetch : 0;
+    }
+    if (outNonLocalBudget)
+        *outNonLocalBudget = m_D3D12Budget[DXGI_MEMORY_SEGMENT_GROUP_NON_LOCAL_COPY];
+}
+
+#if D3D12MA_DXGI_1_4
+HRESULT CurrentBudgetData::UpdateBudget(IDXGIAdapter3* adapter3, bool useMutex)
+{
+    D3D12MA_ASSERT(adapter3);
+
+    DXGI_QUERY_VIDEO_MEMORY_INFO infoLocal = {};
+    DXGI_QUERY_VIDEO_MEMORY_INFO infoNonLocal = {};
+    const HRESULT hrLocal = adapter3->QueryVideoMemoryInfo(0, DXGI_MEMORY_SEGMENT_GROUP_LOCAL, &infoLocal);
+    const HRESULT hrNonLocal = adapter3->QueryVideoMemoryInfo(0, DXGI_MEMORY_SEGMENT_GROUP_NON_LOCAL, &infoNonLocal);
+
+    if (SUCCEEDED(hrLocal) || SUCCEEDED(hrNonLocal))
+    {
+        MutexLockWrite lockWrite(m_BudgetMutex, useMutex);
+
+        if (SUCCEEDED(hrLocal))
+        {
+            m_D3D12Usage[0] = infoLocal.CurrentUsage;
+            m_D3D12Budget[0] = infoLocal.Budget;
+        }
+        if (SUCCEEDED(hrNonLocal))
+        {
+            m_D3D12Usage[1] = infoNonLocal.CurrentUsage;
+            m_D3D12Budget[1] = infoNonLocal.Budget;
+        }
+
+        m_BlockBytesAtD3D12Fetch[0] = m_BlockBytes[0];
+        m_BlockBytesAtD3D12Fetch[1] = m_BlockBytes[1];
+        m_OperationsSinceBudgetFetch = 0;
+    }
+
+    return FAILED(hrLocal) ? hrLocal : hrNonLocal;
+}
+#endif // #if D3D12MA_DXGI_1_4
+
+void CurrentBudgetData::AddAllocation(UINT group, UINT64 allocationBytes)
+{
+    ++m_AllocationCount[group];
+    m_AllocationBytes[group] += allocationBytes;
+    ++m_OperationsSinceBudgetFetch;
+}
+
+void CurrentBudgetData::RemoveAllocation(UINT group, UINT64 allocationBytes)
+{
+    D3D12MA_ASSERT(m_AllocationBytes[group] >= allocationBytes);
+    D3D12MA_ASSERT(m_AllocationCount[group] > 0);
+    m_AllocationBytes[group] -= allocationBytes;
+    --m_AllocationCount[group];
+    ++m_OperationsSinceBudgetFetch;
+}
+
+void CurrentBudgetData::AddBlock(UINT group, UINT64 blockBytes)
+{
+    ++m_BlockCount[group];
+    m_BlockBytes[group] += blockBytes;
+    ++m_OperationsSinceBudgetFetch;
+}
+
+void CurrentBudgetData::RemoveBlock(UINT group, UINT64 blockBytes)
+{
+    D3D12MA_ASSERT(m_BlockBytes[group] >= blockBytes);
+    D3D12MA_ASSERT(m_BlockCount[group] > 0);
+    m_BlockBytes[group] -= blockBytes;
+    --m_BlockCount[group];
+    ++m_OperationsSinceBudgetFetch;
+}
+#endif // _D3D12MA_CURRENT_BUDGET_DATA_FUNCTIONS
+#endif // _D3D12MA_CURRENT_BUDGET_DATA
+
+#ifndef _D3D12MA_DEFRAGMENTATION_CONTEXT_PIMPL
+class DefragmentationContextPimpl
+{
+    D3D12MA_CLASS_NO_COPY(DefragmentationContextPimpl)
+public:
+    DefragmentationContextPimpl(
+        AllocatorPimpl* hAllocator,
+        const DEFRAGMENTATION_DESC& desc,
+        BlockVector* poolVector);
+    ~DefragmentationContextPimpl();
+
+    void GetStats(DEFRAGMENTATION_STATS& outStats) { outStats = m_GlobalStats; }
+    const ALLOCATION_CALLBACKS& GetAllocs() const { return m_Moves.GetAllocs(); }
+
+    HRESULT DefragmentPassBegin(DEFRAGMENTATION_PASS_MOVE_INFO& moveInfo);
+    HRESULT DefragmentPassEnd(DEFRAGMENTATION_PASS_MOVE_INFO& moveInfo);
+
+private:
+    // Max number of allocations to ignore due to size constraints before ending single pass
+    static const UINT8 MAX_ALLOCS_TO_IGNORE = 16;
+    enum class CounterStatus { Pass, Ignore, End };
+
+    struct FragmentedBlock
+    {
+        UINT32 data;
+        NormalBlock* block;
+    };
+    struct StateBalanced
+    {
+        UINT64 avgFreeSize = 0;
+        UINT64 avgAllocSize = UINT64_MAX;
+    };
+    struct MoveAllocationData
+    {
+        UINT64 size;
+        UINT64 alignment;
+        ALLOCATION_FLAGS flags;
+        DEFRAGMENTATION_MOVE move = {};
+    };
+
+    const UINT64 m_MaxPassBytes;
+    const UINT32 m_MaxPassAllocations;
+
+    Vector<DEFRAGMENTATION_MOVE> m_Moves;
+
+    UINT8 m_IgnoredAllocs = 0;
+    UINT32 m_Algorithm;
+    UINT32 m_BlockVectorCount;
+    BlockVector* m_PoolBlockVector;
+    BlockVector** m_pBlockVectors;
+    size_t m_ImmovableBlockCount = 0;
+    DEFRAGMENTATION_STATS m_GlobalStats = { 0 };
+    DEFRAGMENTATION_STATS m_PassStats = { 0 };
+    void* m_AlgorithmState = NULL;
+
+    static MoveAllocationData GetMoveData(AllocHandle handle, BlockMetadata* metadata);
+    CounterStatus CheckCounters(UINT64 bytes);
+    bool IncrementCounters(UINT64 bytes);
+    bool ReallocWithinBlock(BlockVector& vector, NormalBlock* block);
+    bool AllocInOtherBlock(size_t start, size_t end, MoveAllocationData& data, BlockVector& vector);
+
+    bool ComputeDefragmentation(BlockVector& vector, size_t index);
+    bool ComputeDefragmentation_Fast(BlockVector& vector);
+    bool ComputeDefragmentation_Balanced(BlockVector& vector, size_t index, bool update);
+    bool ComputeDefragmentation_Full(BlockVector& vector);
+
+    void UpdateVectorStatistics(BlockVector& vector, StateBalanced& state);
+};
+#endif // _D3D12MA_DEFRAGMENTATION_CONTEXT_PIMPL
+
+#ifndef _D3D12MA_POOL_PIMPL
+class PoolPimpl
+{
+    friend class Allocator;
+    friend struct PoolListItemTraits;
+public:
+    PoolPimpl(AllocatorPimpl* allocator, const POOL_DESC& desc);
+    ~PoolPimpl();
+
+    AllocatorPimpl* GetAllocator() const { return m_Allocator; }
+    const POOL_DESC& GetDesc() const { return m_Desc; }
+    bool SupportsCommittedAllocations() const { return m_Desc.BlockSize == 0; }
+    LPCWSTR GetName() const { return m_Name; }
+
+    BlockVector* GetBlockVector() { return m_BlockVector; }
+    CommittedAllocationList* GetCommittedAllocationList() { return SupportsCommittedAllocations() ? &m_CommittedAllocations : NULL; }
+
+    HRESULT Init();
+    void GetStatistics(Statistics& outStats);
+    void CalculateStatistics(DetailedStatistics& outStats);
+    void AddDetailedStatistics(DetailedStatistics& inoutStats);
+    void SetName(LPCWSTR Name);
+
+private:
+    AllocatorPimpl* m_Allocator; // Externally owned object.
+    POOL_DESC m_Desc;
+    BlockVector* m_BlockVector; // Owned object.
+    CommittedAllocationList m_CommittedAllocations;
+    wchar_t* m_Name;
+    PoolPimpl* m_PrevPool = NULL;
+    PoolPimpl* m_NextPool = NULL;
+
+    void FreeName();
+};
+
+struct PoolListItemTraits
+{
+    using ItemType = PoolPimpl;
+    static ItemType* GetPrev(const ItemType* item) { return item->m_PrevPool; }
+    static ItemType* GetNext(const ItemType* item) { return item->m_NextPool; }
+    static ItemType*& AccessPrev(ItemType* item) { return item->m_PrevPool; }
+    static ItemType*& AccessNext(ItemType* item) { return item->m_NextPool; }
+};
+#endif // _D3D12MA_POOL_PIMPL
+
+
+#ifndef _D3D12MA_ALLOCATOR_PIMPL
+class AllocatorPimpl
+{
+    friend class Allocator;
+    friend class Pool;
+public:
+    std::atomic_uint32_t m_RefCount = {1};
+    CurrentBudgetData m_Budget;
+
+    AllocatorPimpl(const ALLOCATION_CALLBACKS& allocationCallbacks, const ALLOCATOR_DESC& desc);
+    ~AllocatorPimpl();
+
+    ID3D12Device* GetDevice() const { return m_Device; }
+#ifdef __ID3D12Device1_INTERFACE_DEFINED__
+    ID3D12Device1* GetDevice1() const { return m_Device1; }
+#endif
+#ifdef __ID3D12Device4_INTERFACE_DEFINED__
+    ID3D12Device4* GetDevice4() const { return m_Device4; }
+#endif
+#ifdef __ID3D12Device8_INTERFACE_DEFINED__
+    ID3D12Device8* GetDevice8() const { return m_Device8; }
+#endif
+    // Shortcut for "Allocation Callbacks", because this function is called so often.
+    const ALLOCATION_CALLBACKS& GetAllocs() const { return m_AllocationCallbacks; }
+    const D3D12_FEATURE_DATA_D3D12_OPTIONS& GetD3D12Options() const { return m_D3D12Options; }
+    BOOL IsUMA() const { return m_D3D12Architecture.UMA; }
+    BOOL IsCacheCoherentUMA() const { return m_D3D12Architecture.CacheCoherentUMA; }
+    bool SupportsResourceHeapTier2() const { return m_D3D12Options.ResourceHeapTier >= D3D12_RESOURCE_HEAP_TIER_2; }
+    bool UseMutex() const { return m_UseMutex; }
+    AllocationObjectAllocator& GetAllocationObjectAllocator() { return m_AllocationObjectAllocator; }
+    UINT GetCurrentFrameIndex() const { return m_CurrentFrameIndex.load(); }
+    /*
+    If SupportsResourceHeapTier2():
+        0: D3D12_HEAP_TYPE_DEFAULT
+        1: D3D12_HEAP_TYPE_UPLOAD
+        2: D3D12_HEAP_TYPE_READBACK
+    else:
+        0: D3D12_HEAP_TYPE_DEFAULT + buffer
+        1: D3D12_HEAP_TYPE_DEFAULT + texture
+        2: D3D12_HEAP_TYPE_DEFAULT + texture RT or DS
+        3: D3D12_HEAP_TYPE_UPLOAD + buffer
+        4: D3D12_HEAP_TYPE_UPLOAD + texture
+        5: D3D12_HEAP_TYPE_UPLOAD + texture RT or DS
+        6: D3D12_HEAP_TYPE_READBACK + buffer
+        7: D3D12_HEAP_TYPE_READBACK + texture
+        8: D3D12_HEAP_TYPE_READBACK + texture RT or DS
+    */
+    UINT GetDefaultPoolCount() const { return SupportsResourceHeapTier2() ? 3 : 9; }
+    BlockVector** GetDefaultPools() { return m_BlockVectors; }
+
+    HRESULT Init(const ALLOCATOR_DESC& desc);
+    bool HeapFlagsFulfillResourceHeapTier(D3D12_HEAP_FLAGS flags) const;
+    UINT StandardHeapTypeToMemorySegmentGroup(D3D12_HEAP_TYPE heapType) const;
+    UINT HeapPropertiesToMemorySegmentGroup(const D3D12_HEAP_PROPERTIES& heapProps) const;
+    UINT64 GetMemoryCapacity(UINT memorySegmentGroup) const;
+
+    HRESULT CreatePlacedResourceWrap(
+        ID3D12Heap *pHeap,
+        UINT64 HeapOffset,
+        const CREATE_RESOURCE_PARAMS& createParams,
+        REFIID riidResource,
+        void** ppvResource);
+
+    HRESULT CreateResource(
+        const ALLOCATION_DESC* pAllocDesc,
+        const CREATE_RESOURCE_PARAMS& createParams,
+        Allocation** ppAllocation,
+        REFIID riidResource,
+        void** ppvResource);
+
+    HRESULT CreateAliasingResource(
+        Allocation* pAllocation,
+        UINT64 AllocationLocalOffset,
+        const CREATE_RESOURCE_PARAMS& createParams,
+        REFIID riidResource,
+        void** ppvResource);
+
+    HRESULT AllocateMemory(
+        const ALLOCATION_DESC* pAllocDesc,
+        const D3D12_RESOURCE_ALLOCATION_INFO* pAllocInfo,
+        Allocation** ppAllocation);
+
+    // Unregisters allocation from the collection of dedicated allocations.
+    // Allocation object must be deleted externally afterwards.
+    void FreeCommittedMemory(Allocation* allocation);
+    // Unregisters allocation from the collection of placed allocations.
+    // Allocation object must be deleted externally afterwards.
+    void FreePlacedMemory(Allocation* allocation);
+    // Unregisters allocation from the collection of dedicated allocations and destroys associated heap.
+    // Allocation object must be deleted externally afterwards.
+    void FreeHeapMemory(Allocation* allocation);
+
+    void SetResidencyPriority(ID3D12Pageable* obj, D3D12_RESIDENCY_PRIORITY priority) const;
+
+    void SetCurrentFrameIndex(UINT frameIndex);
+    // For more deailed stats use outCutomHeaps to access statistics divided into L0 and L1 group
+    void CalculateStatistics(TotalStatistics& outStats, DetailedStatistics outCutomHeaps[2] = NULL);
+
+    void GetBudget(Budget* outLocalBudget, Budget* outNonLocalBudget);
+    void GetBudgetForHeapType(Budget& outBudget, D3D12_HEAP_TYPE heapType);
+
+    void BuildStatsString(WCHAR** ppStatsString, BOOL detailedMap);
+    void FreeStatsString(WCHAR* pStatsString);
+
+private:
+    using PoolList = IntrusiveLinkedList<PoolListItemTraits>;
+
+    const bool m_UseMutex;
+    const bool m_AlwaysCommitted;
+    const bool m_MsaaAlwaysCommitted;
+    bool m_DefaultPoolsNotZeroed = false;
+    ID3D12Device* m_Device; // AddRef
+#ifdef __ID3D12Device1_INTERFACE_DEFINED__
+    ID3D12Device1* m_Device1 = NULL; // AddRef, optional
+#endif
+#ifdef __ID3D12Device4_INTERFACE_DEFINED__
+    ID3D12Device4* m_Device4 = NULL; // AddRef, optional
+#endif
+#ifdef __ID3D12Device8_INTERFACE_DEFINED__
+    ID3D12Device8* m_Device8 = NULL; // AddRef, optional
+#endif
+#ifdef __ID3D12Device10_INTERFACE_DEFINED__
+    ID3D12Device10* m_Device10 = NULL;  // AddRef, optional
+#endif
+    IDXGIAdapter* m_Adapter; // AddRef
+#if D3D12MA_DXGI_1_4
+    IDXGIAdapter3* m_Adapter3 = NULL; // AddRef, optional
+#endif
+    UINT64 m_PreferredBlockSize;
+    ALLOCATION_CALLBACKS m_AllocationCallbacks;
+    D3D12MA_ATOMIC_UINT32 m_CurrentFrameIndex;
+    DXGI_ADAPTER_DESC m_AdapterDesc;
+    D3D12_FEATURE_DATA_D3D12_OPTIONS m_D3D12Options;
+    D3D12_FEATURE_DATA_ARCHITECTURE m_D3D12Architecture;
+    AllocationObjectAllocator m_AllocationObjectAllocator;
+
+    D3D12MA_RW_MUTEX m_PoolsMutex[HEAP_TYPE_COUNT];
+    PoolList m_Pools[HEAP_TYPE_COUNT];
+    // Default pools.
+    BlockVector* m_BlockVectors[DEFAULT_POOL_MAX_COUNT];
+    CommittedAllocationList m_CommittedAllocations[STANDARD_HEAP_TYPE_COUNT];
+
+    /*
+    Heuristics that decides whether a resource should better be placed in its own,
+    dedicated allocation (committed resource rather than placed resource).
+    */
+    template<typename D3D12_RESOURCE_DESC_T>
+    static bool PrefersCommittedAllocation(const D3D12_RESOURCE_DESC_T& resourceDesc);
+
+    // Allocates and registers new committed resource with implicit heap, as dedicated allocation.
+    // Creates and returns Allocation object and optionally D3D12 resource.
+    HRESULT AllocateCommittedResource(
+        const CommittedAllocationParameters& committedAllocParams,
+        UINT64 resourceSize, bool withinBudget, void* pPrivateData,
+        const CREATE_RESOURCE_PARAMS& createParams,
+        Allocation** ppAllocation, REFIID riidResource, void** ppvResource);
+
+    // Allocates and registers new heap without any resources placed in it, as dedicated allocation.
+    // Creates and returns Allocation object.
+    HRESULT AllocateHeap(
+        const CommittedAllocationParameters& committedAllocParams,
+        const D3D12_RESOURCE_ALLOCATION_INFO& allocInfo, bool withinBudget,
+        void* pPrivateData, Allocation** ppAllocation);
+
+    template<typename D3D12_RESOURCE_DESC_T>
+    HRESULT CalcAllocationParams(const ALLOCATION_DESC& allocDesc, UINT64 allocSize,
+        const D3D12_RESOURCE_DESC_T* resDesc, // Optional
+        BlockVector*& outBlockVector, CommittedAllocationParameters& outCommittedAllocationParams, bool& outPreferCommitted);
+
+    // Returns UINT32_MAX if index cannot be calculcated.
+    UINT CalcDefaultPoolIndex(const ALLOCATION_DESC& allocDesc, ResourceClass resourceClass) const;
+    void CalcDefaultPoolParams(D3D12_HEAP_TYPE& outHeapType, D3D12_HEAP_FLAGS& outHeapFlags, UINT index) const;
+
+    // Registers Pool object in m_Pools.
+    void RegisterPool(Pool* pool, D3D12_HEAP_TYPE heapType);
+    // Unregisters Pool object from m_Pools.
+    void UnregisterPool(Pool* pool, D3D12_HEAP_TYPE heapType);
+
+    HRESULT UpdateD3D12Budget();
+    
+    D3D12_RESOURCE_ALLOCATION_INFO GetResourceAllocationInfoNative(const D3D12_RESOURCE_DESC& resourceDesc) const;
+#ifdef __ID3D12Device8_INTERFACE_DEFINED__
+    D3D12_RESOURCE_ALLOCATION_INFO GetResourceAllocationInfoNative(const D3D12_RESOURCE_DESC1& resourceDesc) const;
+#endif
+
+    template<typename D3D12_RESOURCE_DESC_T>
+    D3D12_RESOURCE_ALLOCATION_INFO GetResourceAllocationInfo(D3D12_RESOURCE_DESC_T& inOutResourceDesc) const;
+
+    bool NewAllocationWithinBudget(D3D12_HEAP_TYPE heapType, UINT64 size);
+
+    // Writes object { } with data of given budget.
+    static void WriteBudgetToJson(JsonWriter& json, const Budget& budget);
+};
+
+#ifndef _D3D12MA_ALLOCATOR_PIMPL_FUNCTINOS
+AllocatorPimpl::AllocatorPimpl(const ALLOCATION_CALLBACKS& allocationCallbacks, const ALLOCATOR_DESC& desc)
+    : m_UseMutex((desc.Flags & ALLOCATOR_FLAG_SINGLETHREADED) == 0),
+    m_AlwaysCommitted((desc.Flags & ALLOCATOR_FLAG_ALWAYS_COMMITTED) != 0),
+    m_MsaaAlwaysCommitted((desc.Flags & ALLOCATOR_FLAG_MSAA_TEXTURES_ALWAYS_COMMITTED) != 0),
+    m_Device(desc.pDevice),
+    m_Adapter(desc.pAdapter),
+    m_PreferredBlockSize(desc.PreferredBlockSize != 0 ? desc.PreferredBlockSize : D3D12MA_DEFAULT_BLOCK_SIZE),
+    m_AllocationCallbacks(allocationCallbacks),
+    m_CurrentFrameIndex(0),
+    // Below this line don't use allocationCallbacks but m_AllocationCallbacks!!!
+    m_AllocationObjectAllocator(m_AllocationCallbacks)
+{
+    // desc.pAllocationCallbacks intentionally ignored here, preprocessed by CreateAllocator.
+    ZeroMemory(&m_D3D12Options, sizeof(m_D3D12Options));
+    ZeroMemory(&m_D3D12Architecture, sizeof(m_D3D12Architecture));
+
+    ZeroMemory(m_BlockVectors, sizeof(m_BlockVectors));
+
+    for (UINT i = 0; i < STANDARD_HEAP_TYPE_COUNT; ++i)
+    {
+        m_CommittedAllocations[i].Init(
+            m_UseMutex,
+            (D3D12_HEAP_TYPE)(D3D12_HEAP_TYPE_DEFAULT + i),
+            NULL); // pool
+    }
+
+    m_Device->AddRef();
+    m_Adapter->AddRef();
+}
+
+HRESULT AllocatorPimpl::Init(const ALLOCATOR_DESC& desc)
+{
+#if D3D12MA_DXGI_1_4
+    desc.pAdapter->QueryInterface(D3D12MA_IID_PPV_ARGS(&m_Adapter3));
+#endif
+
+#ifdef __ID3D12Device1_INTERFACE_DEFINED__
+    m_Device->QueryInterface(D3D12MA_IID_PPV_ARGS(&m_Device1));
+#endif
+
+#ifdef __ID3D12Device4_INTERFACE_DEFINED__
+    m_Device->QueryInterface(D3D12MA_IID_PPV_ARGS(&m_Device4));
+#endif
+
+#ifdef __ID3D12Device8_INTERFACE_DEFINED__
+    m_Device->QueryInterface(D3D12MA_IID_PPV_ARGS(&m_Device8));
+    
+    if((desc.Flags & ALLOCATOR_FLAG_DEFAULT_POOLS_NOT_ZEROED) != 0)
+    {
+        D3D12_FEATURE_DATA_D3D12_OPTIONS7 options7 = {};
+        if(SUCCEEDED(m_Device->CheckFeatureSupport(D3D12_FEATURE_D3D12_OPTIONS7, &options7, sizeof(options7))))
+        {
+            // DEFAULT_POOLS_NOT_ZEROED both supported and enabled by the user.
+            m_DefaultPoolsNotZeroed = true;
+        }
+    }
+#endif
+
+#ifdef __ID3D12Device10_INTERFACE_DEFINED__
+    m_Device->QueryInterface(D3D12MA_IID_PPV_ARGS(&m_Device10));
+#endif
+
+    HRESULT hr = m_Adapter->GetDesc(&m_AdapterDesc);
+    if (FAILED(hr))
+    {
+        return hr;
+    }
+
+    hr = m_Device->CheckFeatureSupport(D3D12_FEATURE_D3D12_OPTIONS, &m_D3D12Options, sizeof(m_D3D12Options));
+    if (FAILED(hr))
+    {
+        return hr;
+    }
+#ifdef D3D12MA_FORCE_RESOURCE_HEAP_TIER
+    m_D3D12Options.ResourceHeapTier = (D3D12MA_FORCE_RESOURCE_HEAP_TIER);
+#endif
+
+    hr = m_Device->CheckFeatureSupport(D3D12_FEATURE_ARCHITECTURE, &m_D3D12Architecture, sizeof(m_D3D12Architecture));
+    if (FAILED(hr))
+    {
+        m_D3D12Architecture.UMA = FALSE;
+        m_D3D12Architecture.CacheCoherentUMA = FALSE;
+    }
+
+    D3D12_HEAP_PROPERTIES heapProps = {};
+    const UINT defaultPoolCount = GetDefaultPoolCount();
+    for (UINT i = 0; i < defaultPoolCount; ++i)
+    {
+        D3D12_HEAP_FLAGS heapFlags;
+        CalcDefaultPoolParams(heapProps.Type, heapFlags, i);
+
+#if D3D12MA_CREATE_NOT_ZEROED_AVAILABLE
+        if(m_DefaultPoolsNotZeroed)
+        {
+            heapFlags |= D3D12_HEAP_FLAG_CREATE_NOT_ZEROED;
+        }
+#endif
+
+        m_BlockVectors[i] = D3D12MA_NEW(GetAllocs(), BlockVector)(
+            this, // hAllocator
+            heapProps, // heapType
+            heapFlags, // heapFlags
+            m_PreferredBlockSize,
+            0, // minBlockCount
+            SIZE_MAX, // maxBlockCount
+            false, // explicitBlockSize
+            D3D12MA_DEBUG_ALIGNMENT, // minAllocationAlignment
+            0, // Default algorithm,
+            m_MsaaAlwaysCommitted,
+            NULL, // pProtectedSession
+            D3D12_RESIDENCY_PRIORITY_NONE); // residencyPriority
+        // No need to call m_pBlockVectors[i]->CreateMinBlocks here, becase minBlockCount is 0.
+    }
+
+#if D3D12MA_DXGI_1_4
+    UpdateD3D12Budget();
+#endif
+
+    return S_OK;
+}
+
+AllocatorPimpl::~AllocatorPimpl()
+{
+#ifdef __ID3D12Device10_INTERFACE_DEFINED__
+    SAFE_RELEASE(m_Device10);
+#endif
+#ifdef __ID3D12Device8_INTERFACE_DEFINED__
+    SAFE_RELEASE(m_Device8);
+#endif
+#ifdef __ID3D12Device4_INTERFACE_DEFINED__
+    SAFE_RELEASE(m_Device4);
+#endif
+#ifdef __ID3D12Device1_INTERFACE_DEFINED__
+    SAFE_RELEASE(m_Device1);
+#endif
+#if D3D12MA_DXGI_1_4
+    SAFE_RELEASE(m_Adapter3);
+#endif
+    SAFE_RELEASE(m_Adapter);
+    SAFE_RELEASE(m_Device);
+
+    for (UINT i = DEFAULT_POOL_MAX_COUNT; i--; )
+    {
+        D3D12MA_DELETE(GetAllocs(), m_BlockVectors[i]);
+    }
+
+    for (UINT i = HEAP_TYPE_COUNT; i--; )
+    {
+        if (!m_Pools[i].IsEmpty())
+        {
+            D3D12MA_ASSERT(0 && "Unfreed pools found!");
+        }
+    }
+}
+
+bool AllocatorPimpl::HeapFlagsFulfillResourceHeapTier(D3D12_HEAP_FLAGS flags) const
+{
+    if (SupportsResourceHeapTier2())
+    {
+        return true;
+    }
+    else
+    {
+        const bool allowBuffers = (flags & D3D12_HEAP_FLAG_DENY_BUFFERS) == 0;
+        const bool allowRtDsTextures = (flags & D3D12_HEAP_FLAG_DENY_RT_DS_TEXTURES) == 0;
+        const bool allowNonRtDsTextures = (flags & D3D12_HEAP_FLAG_DENY_NON_RT_DS_TEXTURES) == 0;
+        const uint8_t allowedGroupCount = (allowBuffers ? 1 : 0) + (allowRtDsTextures ? 1 : 0) + (allowNonRtDsTextures ? 1 : 0);
+        return allowedGroupCount == 1;
+    }
+}
+
+UINT AllocatorPimpl::StandardHeapTypeToMemorySegmentGroup(D3D12_HEAP_TYPE heapType) const
+{
+    D3D12MA_ASSERT(IsHeapTypeStandard(heapType));
+    if (IsUMA())
+        return DXGI_MEMORY_SEGMENT_GROUP_LOCAL_COPY;
+    return heapType == D3D12_HEAP_TYPE_DEFAULT ?
+        DXGI_MEMORY_SEGMENT_GROUP_LOCAL_COPY : DXGI_MEMORY_SEGMENT_GROUP_NON_LOCAL_COPY;
+}
+
+UINT AllocatorPimpl::HeapPropertiesToMemorySegmentGroup(const D3D12_HEAP_PROPERTIES& heapProps) const
+{
+    if (IsUMA())
+        return DXGI_MEMORY_SEGMENT_GROUP_LOCAL_COPY;
+    if (heapProps.MemoryPoolPreference == D3D12_MEMORY_POOL_UNKNOWN)
+        return StandardHeapTypeToMemorySegmentGroup(heapProps.Type);
+    return heapProps.MemoryPoolPreference == D3D12_MEMORY_POOL_L1 ?
+        DXGI_MEMORY_SEGMENT_GROUP_LOCAL_COPY : DXGI_MEMORY_SEGMENT_GROUP_NON_LOCAL_COPY;
+}
+
+UINT64 AllocatorPimpl::GetMemoryCapacity(UINT memorySegmentGroup) const
+{
+    switch (memorySegmentGroup)
+    {
+    case DXGI_MEMORY_SEGMENT_GROUP_LOCAL_COPY:
+        return IsUMA() ?
+            m_AdapterDesc.DedicatedVideoMemory + m_AdapterDesc.SharedSystemMemory : m_AdapterDesc.DedicatedVideoMemory;
+    case DXGI_MEMORY_SEGMENT_GROUP_NON_LOCAL_COPY:
+        return IsUMA() ? 0 : m_AdapterDesc.SharedSystemMemory;
+    default:
+        D3D12MA_ASSERT(0);
+        return UINT64_MAX;
+    }
+}
+
+HRESULT AllocatorPimpl::CreatePlacedResourceWrap(
+    ID3D12Heap *pHeap,
+    UINT64 HeapOffset,
+    const CREATE_RESOURCE_PARAMS& createParams,
+    REFIID riidResource,
+    void** ppvResource)
+{
+#ifdef __ID3D12Device10_INTERFACE_DEFINED__
+    if (createParams.Variant == CREATE_RESOURCE_PARAMS::VARIANT_WITH_LAYOUT)
+    {
+        if (!m_Device10)
+        {
+            return E_NOINTERFACE;
+        }
+        return m_Device10->CreatePlacedResource2(pHeap, HeapOffset,
+            createParams.GetResourceDesc1(), createParams.GetInitialLayout(),
+            createParams.GetOptimizedClearValue(), createParams.GetNumCastableFormats(),
+            createParams.GetCastableFormats(), riidResource, ppvResource);
+    } else
+#endif
+#ifdef __ID3D12Device8_INTERFACE_DEFINED__
+    if (createParams.Variant == CREATE_RESOURCE_PARAMS::VARIANT_WITH_STATE_AND_DESC1)
+    {
+        if (!m_Device8)
+        {
+            return E_NOINTERFACE;
+        }
+        return m_Device8->CreatePlacedResource1(pHeap, HeapOffset,
+            createParams.GetResourceDesc1(), createParams.GetInitialResourceState(),
+            createParams.GetOptimizedClearValue(), riidResource, ppvResource);
+    } else 
+#endif
+    if (createParams.Variant == CREATE_RESOURCE_PARAMS::VARIANT_WITH_STATE)
+    {
+        return m_Device->CreatePlacedResource(pHeap, HeapOffset,
+            createParams.GetResourceDesc(), createParams.GetInitialResourceState(),
+            createParams.GetOptimizedClearValue(), riidResource, ppvResource);
+    }
+    else
+    {
+        D3D12MA_ASSERT(0);
+        return E_INVALIDARG;
+    }
+}
+
+
+HRESULT AllocatorPimpl::CreateResource(
+    const ALLOCATION_DESC* pAllocDesc,
+    const CREATE_RESOURCE_PARAMS& createParams,
+    Allocation** ppAllocation,
+    REFIID riidResource,
+    void** ppvResource)
+{
+    D3D12MA_ASSERT(pAllocDesc && createParams.GetBaseResourceDesc() && ppAllocation);
+
+    *ppAllocation = NULL;
+    if (ppvResource)
+    {
+        *ppvResource = NULL;
+    }
+
+    CREATE_RESOURCE_PARAMS finalCreateParams = createParams;
+    D3D12_RESOURCE_DESC finalResourceDesc;
+#ifdef __ID3D12Device8_INTERFACE_DEFINED__
+    D3D12_RESOURCE_DESC1 finalResourceDesc1;
+#endif
+    D3D12_RESOURCE_ALLOCATION_INFO resAllocInfo;
+    if (createParams.Variant == CREATE_RESOURCE_PARAMS::VARIANT_WITH_STATE)
+    {
+        finalResourceDesc = *createParams.GetResourceDesc();
+        finalCreateParams.AccessResourceDesc() = &finalResourceDesc;
+        resAllocInfo = GetResourceAllocationInfo(finalResourceDesc);
+    }
+#ifdef __ID3D12Device8_INTERFACE_DEFINED__
+    else if (createParams.Variant == CREATE_RESOURCE_PARAMS::VARIANT_WITH_STATE_AND_DESC1)
+    {
+        if (!m_Device8)
+        {
+            return E_NOINTERFACE;
+        }
+        finalResourceDesc1 = *createParams.GetResourceDesc1();
+        finalCreateParams.AccessResourceDesc1() = &finalResourceDesc1;
+        resAllocInfo = GetResourceAllocationInfo(finalResourceDesc1);
+    }
+#endif
+#ifdef __ID3D12Device10_INTERFACE_DEFINED__
+    else if (createParams.Variant == CREATE_RESOURCE_PARAMS::VARIANT_WITH_LAYOUT)
+    {
+        if (!m_Device10)
+        {
+            return E_NOINTERFACE;
+        }
+        finalResourceDesc1 = *createParams.GetResourceDesc1();
+        finalCreateParams.AccessResourceDesc1() = &finalResourceDesc1;
+        resAllocInfo = GetResourceAllocationInfo(finalResourceDesc1);
+    }
+#endif
+    else
+    {
+        D3D12MA_ASSERT(0);
+        return E_INVALIDARG;
+    }
+    D3D12MA_ASSERT(IsPow2(resAllocInfo.Alignment));
+    D3D12MA_ASSERT(resAllocInfo.SizeInBytes > 0);
+
+    BlockVector* blockVector = NULL;
+    CommittedAllocationParameters committedAllocationParams = {};
+    bool preferCommitted = false;
+    
+    HRESULT hr;
+#ifdef __ID3D12Device8_INTERFACE_DEFINED__
+    if (createParams.Variant >= CREATE_RESOURCE_PARAMS::VARIANT_WITH_STATE_AND_DESC1)
+    {
+        hr = CalcAllocationParams<D3D12_RESOURCE_DESC1>(*pAllocDesc, resAllocInfo.SizeInBytes,
+            createParams.GetResourceDesc1(),
+            blockVector, committedAllocationParams, preferCommitted);
+    }
+    else
+#endif
+    {
+        hr = CalcAllocationParams<D3D12_RESOURCE_DESC>(*pAllocDesc, resAllocInfo.SizeInBytes,
+            createParams.GetResourceDesc(),
+            blockVector, committedAllocationParams, preferCommitted);
+    }
+    if (FAILED(hr))
+        return hr;
+
+    const bool withinBudget = (pAllocDesc->Flags & ALLOCATION_FLAG_WITHIN_BUDGET) != 0;
+    hr = E_INVALIDARG;
+    if (committedAllocationParams.IsValid() && preferCommitted)
+    {
+        hr = AllocateCommittedResource(committedAllocationParams,
+            resAllocInfo.SizeInBytes, withinBudget, pAllocDesc->pPrivateData,
+            finalCreateParams, ppAllocation, riidResource, ppvResource);
+        if (SUCCEEDED(hr))
+            return hr;
+    }
+    if (blockVector != NULL)
+    {
+        hr = blockVector->CreateResource(resAllocInfo.SizeInBytes, resAllocInfo.Alignment,
+            *pAllocDesc, finalCreateParams,
+            ppAllocation, riidResource, ppvResource);
+        if (SUCCEEDED(hr))
+            return hr;
+    }
+    if (committedAllocationParams.IsValid() && !preferCommitted)
+    {
+        hr = AllocateCommittedResource(committedAllocationParams,
+            resAllocInfo.SizeInBytes, withinBudget, pAllocDesc->pPrivateData,
+            finalCreateParams, ppAllocation, riidResource, ppvResource);
+        if (SUCCEEDED(hr))
+            return hr;
+    }
+    return hr;
+}
+
+HRESULT AllocatorPimpl::AllocateMemory(
+    const ALLOCATION_DESC* pAllocDesc,
+    const D3D12_RESOURCE_ALLOCATION_INFO* pAllocInfo,
+    Allocation** ppAllocation)
+{
+    *ppAllocation = NULL;
+
+    BlockVector* blockVector = NULL;
+    CommittedAllocationParameters committedAllocationParams = {};
+    bool preferCommitted = false;
+    HRESULT hr = CalcAllocationParams<D3D12_RESOURCE_DESC>(*pAllocDesc, pAllocInfo->SizeInBytes,
+        NULL, // pResDesc
+        blockVector, committedAllocationParams, preferCommitted);
+    if (FAILED(hr))
+        return hr;
+
+    const bool withinBudget = (pAllocDesc->Flags & ALLOCATION_FLAG_WITHIN_BUDGET) != 0;
+    hr = E_INVALIDARG;
+    if (committedAllocationParams.IsValid() && preferCommitted)
+    {
+        hr = AllocateHeap(committedAllocationParams, *pAllocInfo, withinBudget, pAllocDesc->pPrivateData, ppAllocation);
+        if (SUCCEEDED(hr))
+            return hr;
+    }
+    if (blockVector != NULL)
+    {
+        hr = blockVector->Allocate(pAllocInfo->SizeInBytes, pAllocInfo->Alignment,
+            *pAllocDesc, 1, (Allocation**)ppAllocation);
+        if (SUCCEEDED(hr))
+            return hr;
+    }
+    if (committedAllocationParams.IsValid() && !preferCommitted)
+    {
+        hr = AllocateHeap(committedAllocationParams, *pAllocInfo, withinBudget, pAllocDesc->pPrivateData, ppAllocation);
+        if (SUCCEEDED(hr))
+            return hr;
+    }
+    return hr;
+}
+
+HRESULT AllocatorPimpl::CreateAliasingResource(
+    Allocation* pAllocation,
+    UINT64 AllocationLocalOffset,
+    const CREATE_RESOURCE_PARAMS& createParams,
+    REFIID riidResource,
+    void** ppvResource)
+{
+    *ppvResource = NULL;
+
+    CREATE_RESOURCE_PARAMS finalCreateParams = createParams;
+    D3D12_RESOURCE_DESC finalResourceDesc;
+#ifdef __ID3D12Device8_INTERFACE_DEFINED__
+    D3D12_RESOURCE_DESC1 finalResourceDesc1;
+#endif
+    D3D12_RESOURCE_ALLOCATION_INFO resAllocInfo;
+    if (createParams.Variant == CREATE_RESOURCE_PARAMS::VARIANT_WITH_STATE)
+    {
+        finalResourceDesc = *createParams.GetResourceDesc();
+        finalCreateParams.AccessResourceDesc() = &finalResourceDesc;
+        resAllocInfo = GetResourceAllocationInfo(finalResourceDesc);
+    }
+#ifdef __ID3D12Device8_INTERFACE_DEFINED__
+    else if (createParams.Variant == CREATE_RESOURCE_PARAMS::VARIANT_WITH_STATE_AND_DESC1)
+    {
+        if (!m_Device8)
+        {
+            return E_NOINTERFACE;
+        }
+        finalResourceDesc1 = *createParams.GetResourceDesc1();
+        finalCreateParams.AccessResourceDesc1() = &finalResourceDesc1;
+        resAllocInfo = GetResourceAllocationInfo(finalResourceDesc1);
+    }
+#endif
+#ifdef __ID3D12Device10_INTERFACE_DEFINED__
+    else if (createParams.Variant == CREATE_RESOURCE_PARAMS::VARIANT_WITH_LAYOUT)
+    {
+        if (!m_Device10)
+        {
+            return E_NOINTERFACE;
+        }
+        finalResourceDesc1 = *createParams.GetResourceDesc1();
+        finalCreateParams.AccessResourceDesc1() = &finalResourceDesc1;
+        resAllocInfo = GetResourceAllocationInfo(finalResourceDesc1);
+    }
+#endif
+    else
+    {
+        D3D12MA_ASSERT(0);
+        return E_INVALIDARG;
+    }
+    D3D12MA_ASSERT(IsPow2(resAllocInfo.Alignment));
+    D3D12MA_ASSERT(resAllocInfo.SizeInBytes > 0);
+
+    ID3D12Heap* const existingHeap = pAllocation->GetHeap();
+    const UINT64 existingOffset = pAllocation->GetOffset();
+    const UINT64 existingSize = pAllocation->GetSize();
+    const UINT64 newOffset = existingOffset + AllocationLocalOffset;
+
+    if (existingHeap == NULL ||
+        AllocationLocalOffset + resAllocInfo.SizeInBytes > existingSize ||
+        newOffset % resAllocInfo.Alignment != 0)
+    {
+        return E_INVALIDARG;
+    }
+
+    return CreatePlacedResourceWrap(existingHeap, newOffset, finalCreateParams, riidResource, ppvResource);
+}
+
+void AllocatorPimpl::FreeCommittedMemory(Allocation* allocation)
+{
+    D3D12MA_ASSERT(allocation && allocation->m_PackedData.GetType() == Allocation::TYPE_COMMITTED);
+
+    CommittedAllocationList* const allocList = allocation->m_Committed.list;
+    allocList->Unregister(allocation);
+
+    const UINT memSegmentGroup = allocList->GetMemorySegmentGroup(this);
+    const UINT64 allocSize = allocation->GetSize();
+    m_Budget.RemoveAllocation(memSegmentGroup, allocSize);
+    m_Budget.RemoveBlock(memSegmentGroup, allocSize);
+}
+
+void AllocatorPimpl::FreePlacedMemory(Allocation* allocation)
+{
+    D3D12MA_ASSERT(allocation && allocation->m_PackedData.GetType() == Allocation::TYPE_PLACED);
+
+    NormalBlock* const block = allocation->m_Placed.block;
+    D3D12MA_ASSERT(block);
+    BlockVector* const blockVector = block->GetBlockVector();
+    D3D12MA_ASSERT(blockVector);
+    m_Budget.RemoveAllocation(HeapPropertiesToMemorySegmentGroup(block->GetHeapProperties()), allocation->GetSize());
+    blockVector->Free(allocation);
+}
+
+void AllocatorPimpl::FreeHeapMemory(Allocation* allocation)
+{
+    D3D12MA_ASSERT(allocation && allocation->m_PackedData.GetType() == Allocation::TYPE_HEAP);
+
+    CommittedAllocationList* const allocList = allocation->m_Committed.list;
+    allocList->Unregister(allocation);
+    SAFE_RELEASE(allocation->m_Heap.heap);
+
+    const UINT memSegmentGroup = allocList->GetMemorySegmentGroup(this);
+    const UINT64 allocSize = allocation->GetSize();
+    m_Budget.RemoveAllocation(memSegmentGroup, allocSize);
+    m_Budget.RemoveBlock(memSegmentGroup, allocSize);
+}
+
+void AllocatorPimpl::SetResidencyPriority(ID3D12Pageable* obj, D3D12_RESIDENCY_PRIORITY priority) const
+{
+#ifdef __ID3D12Device1_INTERFACE_DEFINED__
+    if (priority != D3D12_RESIDENCY_PRIORITY_NONE && m_Device1)
+    {
+        // Intentionally ignoring the result.
+        m_Device1->SetResidencyPriority(1, &obj, &priority);
+    }
+#endif
+}
+
+void AllocatorPimpl::SetCurrentFrameIndex(UINT frameIndex)
+{
+    m_CurrentFrameIndex.store(frameIndex);
+
+#if D3D12MA_DXGI_1_4
+    UpdateD3D12Budget();
+#endif
+}
+
+void AllocatorPimpl::CalculateStatistics(TotalStatistics& outStats, DetailedStatistics outCutomHeaps[2])
+{
+    // Init stats
+    for (size_t i = 0; i < HEAP_TYPE_COUNT; i++)
+        ClearDetailedStatistics(outStats.HeapType[i]);
+    for (size_t i = 0; i < DXGI_MEMORY_SEGMENT_GROUP_COUNT; i++)
+        ClearDetailedStatistics(outStats.MemorySegmentGroup[i]);
+    ClearDetailedStatistics(outStats.Total);
+    if (outCutomHeaps)
+    {
+        ClearDetailedStatistics(outCutomHeaps[0]);
+        ClearDetailedStatistics(outCutomHeaps[1]);
+    }
+
+    // Process default pools. 3 standard heap types only. Add them to outStats.HeapType[i].
+    if (SupportsResourceHeapTier2())
+    {
+        // DEFAULT, UPLOAD, READBACK.
+        for (size_t heapTypeIndex = 0; heapTypeIndex < STANDARD_HEAP_TYPE_COUNT; ++heapTypeIndex)
+        {
+            BlockVector* const pBlockVector = m_BlockVectors[heapTypeIndex];
+            D3D12MA_ASSERT(pBlockVector);
+            pBlockVector->AddDetailedStatistics(outStats.HeapType[heapTypeIndex]);
+        }
+    }
+    else
+    {
+        // DEFAULT, UPLOAD, READBACK.
+        for (size_t heapTypeIndex = 0; heapTypeIndex < STANDARD_HEAP_TYPE_COUNT; ++heapTypeIndex)
+        {
+            for (size_t heapSubType = 0; heapSubType < 3; ++heapSubType)
+            {
+                BlockVector* const pBlockVector = m_BlockVectors[heapTypeIndex * 3 + heapSubType];
+                D3D12MA_ASSERT(pBlockVector);
+                pBlockVector->AddDetailedStatistics(outStats.HeapType[heapTypeIndex]);
+            }
+        }
+    }
+
+    // Sum them up to memory segment groups.
+    AddDetailedStatistics(
+        outStats.MemorySegmentGroup[StandardHeapTypeToMemorySegmentGroup(D3D12_HEAP_TYPE_DEFAULT)],
+        outStats.HeapType[0]);
+    AddDetailedStatistics(
+        outStats.MemorySegmentGroup[StandardHeapTypeToMemorySegmentGroup(D3D12_HEAP_TYPE_UPLOAD)],
+        outStats.HeapType[1]);
+    AddDetailedStatistics(
+        outStats.MemorySegmentGroup[StandardHeapTypeToMemorySegmentGroup(D3D12_HEAP_TYPE_READBACK)],
+        outStats.HeapType[2]);
+
+    // Process custom pools.
+    DetailedStatistics tmpStats;
+    for (size_t heapTypeIndex = 0; heapTypeIndex < HEAP_TYPE_COUNT; ++heapTypeIndex)
+    {
+        MutexLockRead lock(m_PoolsMutex[heapTypeIndex], m_UseMutex);
+        PoolList& poolList = m_Pools[heapTypeIndex];
+        for (PoolPimpl* pool = poolList.Front(); pool != NULL; pool = poolList.GetNext(pool))
+        {
+            const D3D12_HEAP_PROPERTIES& poolHeapProps = pool->GetDesc().HeapProperties;
+            ClearDetailedStatistics(tmpStats);
+            pool->AddDetailedStatistics(tmpStats);
+            AddDetailedStatistics(
+                outStats.HeapType[heapTypeIndex], tmpStats);
+
+            UINT memorySegment = HeapPropertiesToMemorySegmentGroup(poolHeapProps);
+            AddDetailedStatistics(
+                outStats.MemorySegmentGroup[memorySegment], tmpStats);
+
+            if (outCutomHeaps)
+                AddDetailedStatistics(outCutomHeaps[memorySegment], tmpStats);
+        }
+    }
+
+    // Process committed allocations. 3 standard heap types only.
+    for (UINT heapTypeIndex = 0; heapTypeIndex < STANDARD_HEAP_TYPE_COUNT; ++heapTypeIndex)
+    {
+        ClearDetailedStatistics(tmpStats);
+        m_CommittedAllocations[heapTypeIndex].AddDetailedStatistics(tmpStats);
+        AddDetailedStatistics(
+            outStats.HeapType[heapTypeIndex], tmpStats);
+        AddDetailedStatistics(
+            outStats.MemorySegmentGroup[StandardHeapTypeToMemorySegmentGroup(IndexToHeapType(heapTypeIndex))], tmpStats);
+    }
+
+    // Sum up memory segment groups to totals.
+    AddDetailedStatistics(outStats.Total, outStats.MemorySegmentGroup[0]);
+    AddDetailedStatistics(outStats.Total, outStats.MemorySegmentGroup[1]);
+
+    D3D12MA_ASSERT(outStats.Total.Stats.BlockCount ==
+        outStats.MemorySegmentGroup[0].Stats.BlockCount + outStats.MemorySegmentGroup[1].Stats.BlockCount);
+    D3D12MA_ASSERT(outStats.Total.Stats.AllocationCount ==
+        outStats.MemorySegmentGroup[0].Stats.AllocationCount + outStats.MemorySegmentGroup[1].Stats.AllocationCount);
+    D3D12MA_ASSERT(outStats.Total.Stats.BlockBytes ==
+        outStats.MemorySegmentGroup[0].Stats.BlockBytes + outStats.MemorySegmentGroup[1].Stats.BlockBytes);
+    D3D12MA_ASSERT(outStats.Total.Stats.AllocationBytes ==
+        outStats.MemorySegmentGroup[0].Stats.AllocationBytes + outStats.MemorySegmentGroup[1].Stats.AllocationBytes);
+    D3D12MA_ASSERT(outStats.Total.UnusedRangeCount ==
+        outStats.MemorySegmentGroup[0].UnusedRangeCount + outStats.MemorySegmentGroup[1].UnusedRangeCount);
+
+    D3D12MA_ASSERT(outStats.Total.Stats.BlockCount ==
+        outStats.HeapType[0].Stats.BlockCount + outStats.HeapType[1].Stats.BlockCount +
+        outStats.HeapType[2].Stats.BlockCount + outStats.HeapType[3].Stats.BlockCount);
+    D3D12MA_ASSERT(outStats.Total.Stats.AllocationCount ==
+        outStats.HeapType[0].Stats.AllocationCount + outStats.HeapType[1].Stats.AllocationCount +
+        outStats.HeapType[2].Stats.AllocationCount + outStats.HeapType[3].Stats.AllocationCount);
+    D3D12MA_ASSERT(outStats.Total.Stats.BlockBytes ==
+        outStats.HeapType[0].Stats.BlockBytes + outStats.HeapType[1].Stats.BlockBytes +
+        outStats.HeapType[2].Stats.BlockBytes + outStats.HeapType[3].Stats.BlockBytes);
+    D3D12MA_ASSERT(outStats.Total.Stats.AllocationBytes ==
+        outStats.HeapType[0].Stats.AllocationBytes + outStats.HeapType[1].Stats.AllocationBytes +
+        outStats.HeapType[2].Stats.AllocationBytes + outStats.HeapType[3].Stats.AllocationBytes);
+    D3D12MA_ASSERT(outStats.Total.UnusedRangeCount ==
+        outStats.HeapType[0].UnusedRangeCount + outStats.HeapType[1].UnusedRangeCount +
+        outStats.HeapType[2].UnusedRangeCount + outStats.HeapType[3].UnusedRangeCount);
+}
+
+void AllocatorPimpl::GetBudget(Budget* outLocalBudget, Budget* outNonLocalBudget)
+{
+    if (outLocalBudget)
+        m_Budget.GetStatistics(outLocalBudget->Stats, DXGI_MEMORY_SEGMENT_GROUP_LOCAL_COPY);
+    if (outNonLocalBudget)
+        m_Budget.GetStatistics(outNonLocalBudget->Stats, DXGI_MEMORY_SEGMENT_GROUP_NON_LOCAL_COPY);
+
+#if D3D12MA_DXGI_1_4
+    if (m_Adapter3)
+    {
+        if (!m_Budget.ShouldUpdateBudget())
+        {
+            m_Budget.GetBudget(m_UseMutex,
+                outLocalBudget ? &outLocalBudget->UsageBytes : NULL,
+                outLocalBudget ? &outLocalBudget->BudgetBytes : NULL,
+                outNonLocalBudget ? &outNonLocalBudget->UsageBytes : NULL,
+                outNonLocalBudget ? &outNonLocalBudget->BudgetBytes : NULL);
+        }
+        else
+        {
+            UpdateD3D12Budget();
+            GetBudget(outLocalBudget, outNonLocalBudget); // Recursion
+        }
+    }
+    else
+#endif
+    {
+        if (outLocalBudget)
+        {
+            outLocalBudget->UsageBytes = outLocalBudget->Stats.BlockBytes;
+            outLocalBudget->BudgetBytes = GetMemoryCapacity(DXGI_MEMORY_SEGMENT_GROUP_LOCAL_COPY) * 8 / 10; // 80% heuristics.
+        }
+        if (outNonLocalBudget)
+        {
+            outNonLocalBudget->UsageBytes = outNonLocalBudget->Stats.BlockBytes;
+            outNonLocalBudget->BudgetBytes = GetMemoryCapacity(DXGI_MEMORY_SEGMENT_GROUP_NON_LOCAL_COPY) * 8 / 10; // 80% heuristics.
+        }
+    }
+}
+
+void AllocatorPimpl::GetBudgetForHeapType(Budget& outBudget, D3D12_HEAP_TYPE heapType)
+{
+    switch (heapType)
+    {
+    case D3D12_HEAP_TYPE_DEFAULT:
+        GetBudget(&outBudget, NULL);
+        break;
+    case D3D12_HEAP_TYPE_UPLOAD:
+    case D3D12_HEAP_TYPE_READBACK:
+        GetBudget(NULL, &outBudget);
+        break;
+    default: D3D12MA_ASSERT(0);
+    }
+}
+
+void AllocatorPimpl::BuildStatsString(WCHAR** ppStatsString, BOOL detailedMap)
+{
+    StringBuilder sb(GetAllocs());
+    {
+        Budget localBudget = {}, nonLocalBudget = {};
+        GetBudget(&localBudget, &nonLocalBudget);
+
+        TotalStatistics stats;
+        DetailedStatistics customHeaps[2];
+        CalculateStatistics(stats, customHeaps);
+
+        JsonWriter json(GetAllocs(), sb);
+        json.BeginObject();
+        {
+            json.WriteString(L"General");
+            json.BeginObject();
+            {
+                json.WriteString(L"API");
+                json.WriteString(L"Direct3D 12");
+
+                json.WriteString(L"GPU");
+                json.WriteString(m_AdapterDesc.Description);
+
+                json.WriteString(L"DedicatedVideoMemory");
+                json.WriteNumber((UINT64)m_AdapterDesc.DedicatedVideoMemory);
+                json.WriteString(L"DedicatedSystemMemory");
+                json.WriteNumber((UINT64)m_AdapterDesc.DedicatedSystemMemory);
+                json.WriteString(L"SharedSystemMemory");
+                json.WriteNumber((UINT64)m_AdapterDesc.SharedSystemMemory);
+                
+                json.WriteString(L"ResourceHeapTier");
+                json.WriteNumber(static_cast<UINT>(m_D3D12Options.ResourceHeapTier));
+
+                json.WriteString(L"ResourceBindingTier");
+                json.WriteNumber(static_cast<UINT>(m_D3D12Options.ResourceBindingTier));
+
+                json.WriteString(L"TiledResourcesTier");
+                json.WriteNumber(static_cast<UINT>(m_D3D12Options.TiledResourcesTier));
+
+                json.WriteString(L"TileBasedRenderer");
+                json.WriteBool(m_D3D12Architecture.TileBasedRenderer);
+
+                json.WriteString(L"UMA");
+                json.WriteBool(m_D3D12Architecture.UMA);
+                json.WriteString(L"CacheCoherentUMA");
+                json.WriteBool(m_D3D12Architecture.CacheCoherentUMA);
+            }
+            json.EndObject();
+        }
+        {
+            json.WriteString(L"Total");
+            json.AddDetailedStatisticsInfoObject(stats.Total);
+        }
+        {
+            json.WriteString(L"MemoryInfo");
+            json.BeginObject();
+            {
+                json.WriteString(L"L0");
+                json.BeginObject();
+                {
+                    json.WriteString(L"Budget");
+                    WriteBudgetToJson(json, IsUMA() ? localBudget : nonLocalBudget); // When UMA device only L0 present as local
+
+                    json.WriteString(L"Stats");
+                    json.AddDetailedStatisticsInfoObject(stats.MemorySegmentGroup[!IsUMA()]);
+
+                    json.WriteString(L"MemoryPools");
+                    json.BeginObject();
+                    {
+                        if (IsUMA())
+                        {
+                            json.WriteString(L"DEFAULT");
+                            json.BeginObject();
+                            {
+                                json.WriteString(L"Stats");
+                                json.AddDetailedStatisticsInfoObject(stats.HeapType[0]);
+                            }
+                            json.EndObject();
+                        }
+                        json.WriteString(L"UPLOAD");
+                        json.BeginObject();
+                        {
+                            json.WriteString(L"Stats");
+                            json.AddDetailedStatisticsInfoObject(stats.HeapType[1]);
+                        }
+                        json.EndObject();
+
+                        json.WriteString(L"READBACK");
+                        json.BeginObject();
+                        {
+                            json.WriteString(L"Stats");
+                            json.AddDetailedStatisticsInfoObject(stats.HeapType[2]);
+                        }
+                        json.EndObject();
+
+                        json.WriteString(L"CUSTOM");
+                        json.BeginObject();
+                        {
+                            json.WriteString(L"Stats");
+                            json.AddDetailedStatisticsInfoObject(customHeaps[!IsUMA()]);
+                        }
+                        json.EndObject();
+                    }
+                    json.EndObject();
+                }
+                json.EndObject();
+                if (!IsUMA())
+                {
+                    json.WriteString(L"L1");
+                    json.BeginObject();
+                    {
+                        json.WriteString(L"Budget");
+                        WriteBudgetToJson(json, localBudget);
+
+                        json.WriteString(L"Stats");
+                        json.AddDetailedStatisticsInfoObject(stats.MemorySegmentGroup[0]);
+
+                        json.WriteString(L"MemoryPools");
+                        json.BeginObject();
+                        {
+                            json.WriteString(L"DEFAULT");
+                            json.BeginObject();
+                            {
+                                json.WriteString(L"Stats");
+                                json.AddDetailedStatisticsInfoObject(stats.HeapType[0]);
+                            }
+                            json.EndObject();
+
+                            json.WriteString(L"CUSTOM");
+                            json.BeginObject();
+                            {
+                                json.WriteString(L"Stats");
+                                json.AddDetailedStatisticsInfoObject(customHeaps[0]);
+                            }
+                            json.EndObject();
+                        }
+                        json.EndObject();
+                    }
+                    json.EndObject();
+                }
+            }
+            json.EndObject();
+        }
+
+        if (detailedMap)
+        {
+            const auto writeHeapInfo = [&](BlockVector* blockVector, CommittedAllocationList* committedAllocs, bool customHeap)
+            {
+                D3D12MA_ASSERT(blockVector);
+
+                D3D12_HEAP_FLAGS flags = blockVector->GetHeapFlags();
+                json.WriteString(L"Flags");
+                json.BeginArray(true);
+                {
+                    if (flags & D3D12_HEAP_FLAG_SHARED)
+                        json.WriteString(L"HEAP_FLAG_SHARED");
+                    if (flags & D3D12_HEAP_FLAG_ALLOW_DISPLAY)
+                        json.WriteString(L"HEAP_FLAG_ALLOW_DISPLAY");
+                    if (flags & D3D12_HEAP_FLAG_SHARED_CROSS_ADAPTER)
+                        json.WriteString(L"HEAP_FLAG_CROSS_ADAPTER");
+                    if (flags & D3D12_HEAP_FLAG_HARDWARE_PROTECTED)
+                        json.WriteString(L"HEAP_FLAG_HARDWARE_PROTECTED");
+                    if (flags & D3D12_HEAP_FLAG_ALLOW_WRITE_WATCH)
+                        json.WriteString(L"HEAP_FLAG_ALLOW_WRITE_WATCH");
+                    if (flags & D3D12_HEAP_FLAG_ALLOW_SHADER_ATOMICS)
+                        json.WriteString(L"HEAP_FLAG_ALLOW_SHADER_ATOMICS");
+#ifdef __ID3D12Device8_INTERFACE_DEFINED__
+                    if (flags & D3D12_HEAP_FLAG_CREATE_NOT_RESIDENT)
+                        json.WriteString(L"HEAP_FLAG_CREATE_NOT_RESIDENT");
+                    if (flags & D3D12_HEAP_FLAG_CREATE_NOT_ZEROED)
+                        json.WriteString(L"HEAP_FLAG_CREATE_NOT_ZEROED");
+#endif
+
+                    if (flags & D3D12_HEAP_FLAG_DENY_BUFFERS)
+                        json.WriteString(L"HEAP_FLAG_DENY_BUFFERS");
+                    if (flags & D3D12_HEAP_FLAG_DENY_RT_DS_TEXTURES)
+                        json.WriteString(L"HEAP_FLAG_DENY_RT_DS_TEXTURES");
+                    if (flags & D3D12_HEAP_FLAG_DENY_NON_RT_DS_TEXTURES)
+                        json.WriteString(L"HEAP_FLAG_DENY_NON_RT_DS_TEXTURES");
+
+                    flags &= ~(D3D12_HEAP_FLAG_SHARED
+                        | D3D12_HEAP_FLAG_DENY_BUFFERS
+                        | D3D12_HEAP_FLAG_ALLOW_DISPLAY
+                        | D3D12_HEAP_FLAG_SHARED_CROSS_ADAPTER
+                        | D3D12_HEAP_FLAG_DENY_RT_DS_TEXTURES
+                        | D3D12_HEAP_FLAG_DENY_NON_RT_DS_TEXTURES
+                        | D3D12_HEAP_FLAG_HARDWARE_PROTECTED
+                        | D3D12_HEAP_FLAG_ALLOW_WRITE_WATCH
+                        | D3D12_HEAP_FLAG_ALLOW_SHADER_ATOMICS);
+#ifdef __ID3D12Device8_INTERFACE_DEFINED__
+                    flags &= ~(D3D12_HEAP_FLAG_CREATE_NOT_RESIDENT
+                        | D3D12_HEAP_FLAG_CREATE_NOT_ZEROED);
+#endif
+                    if (flags != 0)
+                        json.WriteNumber((UINT)flags);
+
+                    if (customHeap)
+                    {
+                        const D3D12_HEAP_PROPERTIES& properties = blockVector->GetHeapProperties();
+                        switch (properties.MemoryPoolPreference)
+                        {
+                        default:
+                            D3D12MA_ASSERT(0);
+                        case D3D12_MEMORY_POOL_UNKNOWN:
+                            json.WriteString(L"MEMORY_POOL_UNKNOWN");
+                            break;
+                        case D3D12_MEMORY_POOL_L0:
+                            json.WriteString(L"MEMORY_POOL_L0");
+                            break;
+                        case D3D12_MEMORY_POOL_L1:
+                            json.WriteString(L"MEMORY_POOL_L1");
+                            break;
+                        }
+                        switch (properties.CPUPageProperty)
+                        {
+                        default:
+                            D3D12MA_ASSERT(0);
+                        case D3D12_CPU_PAGE_PROPERTY_UNKNOWN:
+                            json.WriteString(L"CPU_PAGE_PROPERTY_UNKNOWN");
+                            break;
+                        case D3D12_CPU_PAGE_PROPERTY_NOT_AVAILABLE:
+                            json.WriteString(L"CPU_PAGE_PROPERTY_NOT_AVAILABLE");
+                            break;
+                        case D3D12_CPU_PAGE_PROPERTY_WRITE_COMBINE:
+                            json.WriteString(L"CPU_PAGE_PROPERTY_WRITE_COMBINE");
+                            break;
+                        case D3D12_CPU_PAGE_PROPERTY_WRITE_BACK:
+                            json.WriteString(L"CPU_PAGE_PROPERTY_WRITE_BACK");
+                            break;
+                        }
+                    }
+                }
+                json.EndArray();
+
+                json.WriteString(L"PreferredBlockSize");
+                json.WriteNumber(blockVector->GetPreferredBlockSize());
+
+                json.WriteString(L"Blocks");
+                blockVector->WriteBlockInfoToJson(json);
+
+                json.WriteString(L"DedicatedAllocations");
+                json.BeginArray();
+                if (committedAllocs)
+                    committedAllocs->BuildStatsString(json);
+                json.EndArray();
+            };
+
+            json.WriteString(L"DefaultPools");
+            json.BeginObject();
+            {
+                if (SupportsResourceHeapTier2())
+                {
+                    for (uint8_t heapType = 0; heapType < STANDARD_HEAP_TYPE_COUNT; ++heapType)
+                    {
+                        json.WriteString(HeapTypeNames[heapType]);
+                        json.BeginObject();
+                        writeHeapInfo(m_BlockVectors[heapType], m_CommittedAllocations + heapType, false);
+                        json.EndObject();
+                    }
+                }
+                else
+                {
+                    for (uint8_t heapType = 0; heapType < STANDARD_HEAP_TYPE_COUNT; ++heapType)
+                    {
+                        for (uint8_t heapSubType = 0; heapSubType < 3; ++heapSubType)
+                        {
+                            static const WCHAR* const heapSubTypeName[] = {
+                                L" - Buffers",
+                                L" - Textures",
+                                L" - Textures RT/DS",
+                            };
+                            json.BeginString(HeapTypeNames[heapType]);
+                            json.EndString(heapSubTypeName[heapSubType]);
+
+                            json.BeginObject();
+                            writeHeapInfo(m_BlockVectors[heapType + heapSubType], m_CommittedAllocations + heapType, false);
+                            json.EndObject();
+                        }
+                    }
+                }
+            }
+            json.EndObject();
+
+            json.WriteString(L"CustomPools");
+            json.BeginObject();
+            for (uint8_t heapTypeIndex = 0; heapTypeIndex < HEAP_TYPE_COUNT; ++heapTypeIndex)
+            {
+                MutexLockRead mutex(m_PoolsMutex[heapTypeIndex], m_UseMutex);
+                auto* item = m_Pools[heapTypeIndex].Front();
+                if (item != NULL)
+                {
+                    size_t index = 0;
+                    json.WriteString(HeapTypeNames[heapTypeIndex]);
+                    json.BeginArray();
+                    do
+                    {
+                        json.BeginObject();
+                        json.WriteString(L"Name");
+                        json.BeginString();
+                        json.ContinueString(index++);
+                        if (item->GetName())
+                        {
+                            json.ContinueString(L" - ");
+                            json.ContinueString(item->GetName());
+                        }
+                        json.EndString();
+
+                        writeHeapInfo(item->GetBlockVector(), item->GetCommittedAllocationList(), heapTypeIndex == 3);
+                        json.EndObject();
+                    } while ((item = PoolList::GetNext(item)) != NULL);
+                    json.EndArray();
+                }
+            }
+            json.EndObject();
+        }
+        json.EndObject();
+    }
+
+    const size_t length = sb.GetLength();
+    WCHAR* result = AllocateArray<WCHAR>(GetAllocs(), length + 2);
+    result[0] = 0xFEFF;
+    memcpy(result + 1, sb.GetData(), length * sizeof(WCHAR));
+    result[length + 1] = L'\0';
+    *ppStatsString = result;
+}
+
+void AllocatorPimpl::FreeStatsString(WCHAR* pStatsString)
+{
+    D3D12MA_ASSERT(pStatsString);
+    Free(GetAllocs(), pStatsString);
+}
+
+template<typename D3D12_RESOURCE_DESC_T>
+bool AllocatorPimpl::PrefersCommittedAllocation(const D3D12_RESOURCE_DESC_T& resourceDesc)
+{
+    // Intentional. It may change in the future.
+    return false;
+}
+
+HRESULT AllocatorPimpl::AllocateCommittedResource(
+    const CommittedAllocationParameters& committedAllocParams,
+    UINT64 resourceSize, bool withinBudget, void* pPrivateData,
+    const CREATE_RESOURCE_PARAMS& createParams,
+    Allocation** ppAllocation, REFIID riidResource, void** ppvResource)
+{
+    D3D12MA_ASSERT(committedAllocParams.IsValid());
+
+    HRESULT hr;
+    ID3D12Resource* res = NULL;
+    // Allocate aliasing memory with explicit heap
+    if (committedAllocParams.m_CanAlias)
+    {
+        D3D12_RESOURCE_ALLOCATION_INFO heapAllocInfo = {};
+        heapAllocInfo.SizeInBytes = resourceSize;
+        heapAllocInfo.Alignment = HeapFlagsToAlignment(committedAllocParams.m_HeapFlags, m_MsaaAlwaysCommitted);
+        hr = AllocateHeap(committedAllocParams, heapAllocInfo, withinBudget, pPrivateData, ppAllocation);
+        if (SUCCEEDED(hr))
+        {
+            hr = CreatePlacedResourceWrap((*ppAllocation)->GetHeap(), 0, 
+                    createParams, D3D12MA_IID_PPV_ARGS(&res));
+            if (SUCCEEDED(hr))
+            {
+                if (ppvResource != NULL)
+                    hr = res->QueryInterface(riidResource, ppvResource);
+                if (SUCCEEDED(hr))
+                {
+                    (*ppAllocation)->SetResourcePointer(res, createParams.GetBaseResourceDesc());
+                    return hr;
+                }
+                res->Release();
+            }
+            FreeHeapMemory(*ppAllocation);
+        }
+        return hr;
+    }
+
+    if (withinBudget &&
+        !NewAllocationWithinBudget(committedAllocParams.m_HeapProperties.Type, resourceSize))
+    {
+        return E_OUTOFMEMORY;
+    }
+
+    /* D3D12 ERROR:
+     * ID3D12Device::CreateCommittedResource:
+     * When creating a committed resource, D3D12_HEAP_FLAGS must not have either
+     *      D3D12_HEAP_FLAG_DENY_NON_RT_DS_TEXTURES,
+     *      D3D12_HEAP_FLAG_DENY_RT_DS_TEXTURES,
+     *      nor D3D12_HEAP_FLAG_DENY_BUFFERS set.
+     * These flags will be set automatically to correspond with the committed resource type.
+     *
+     * [ STATE_CREATION ERROR #640: CREATERESOURCEANDHEAP_INVALIDHEAPMISCFLAGS]
+    */
+
+#ifdef __ID3D12Device10_INTERFACE_DEFINED__
+    if (createParams.Variant == CREATE_RESOURCE_PARAMS::VARIANT_WITH_LAYOUT)
+    {
+        if (!m_Device10)
+        {
+            return E_NOINTERFACE;
+        }
+        hr = m_Device10->CreateCommittedResource3(
+                &committedAllocParams.m_HeapProperties,
+                committedAllocParams.m_HeapFlags & ~RESOURCE_CLASS_HEAP_FLAGS,
+                createParams.GetResourceDesc1(), createParams.GetInitialLayout(),
+                createParams.GetOptimizedClearValue(), committedAllocParams.m_ProtectedSession,
+                createParams.GetNumCastableFormats(), createParams.GetCastableFormats(),
+                D3D12MA_IID_PPV_ARGS(&res));
+    } else
+#endif
+#ifdef __ID3D12Device8_INTERFACE_DEFINED__
+    if (createParams.Variant == CREATE_RESOURCE_PARAMS::VARIANT_WITH_STATE_AND_DESC1)
+    {
+        if (!m_Device8)
+        {
+            return E_NOINTERFACE;
+        }
+        hr = m_Device8->CreateCommittedResource2(
+                &committedAllocParams.m_HeapProperties,
+                committedAllocParams.m_HeapFlags & ~RESOURCE_CLASS_HEAP_FLAGS,
+                createParams.GetResourceDesc1(), createParams.GetInitialResourceState(),
+                createParams.GetOptimizedClearValue(), committedAllocParams.m_ProtectedSession,
+                D3D12MA_IID_PPV_ARGS(&res));
+    } else
+#endif
+    if (createParams.Variant == CREATE_RESOURCE_PARAMS::VARIANT_WITH_STATE)
+    {
+#ifdef __ID3D12Device4_INTERFACE_DEFINED__
+        if (m_Device4)
+        {
+                hr = m_Device4->CreateCommittedResource1(
+                    &committedAllocParams.m_HeapProperties,
+                    committedAllocParams.m_HeapFlags & ~RESOURCE_CLASS_HEAP_FLAGS,
+                    createParams.GetResourceDesc(), createParams.GetInitialResourceState(),
+                    createParams.GetOptimizedClearValue(), committedAllocParams.m_ProtectedSession,
+                    D3D12MA_IID_PPV_ARGS(&res));
+        }
+        else
+#endif
+        {
+            if (committedAllocParams.m_ProtectedSession == NULL)
+            {
+                hr = m_Device->CreateCommittedResource(
+                    &committedAllocParams.m_HeapProperties,
+                    committedAllocParams.m_HeapFlags & ~RESOURCE_CLASS_HEAP_FLAGS,
+                    createParams.GetResourceDesc(), createParams.GetInitialResourceState(),
+                    createParams.GetOptimizedClearValue(), D3D12MA_IID_PPV_ARGS(&res));
+            }
+            else
+                hr = E_NOINTERFACE;
+        }
+    }
+    else
+    {
+        D3D12MA_ASSERT(0);
+        return E_INVALIDARG;
+    }
+
+    if (SUCCEEDED(hr))
+    {
+        SetResidencyPriority(res, committedAllocParams.m_ResidencyPriority);
+
+        if (ppvResource != NULL)
+        {
+            hr = res->QueryInterface(riidResource, ppvResource);
+        }
+        if (SUCCEEDED(hr))
+        {
+            BOOL wasZeroInitialized = TRUE;
+#if D3D12MA_CREATE_NOT_ZEROED_AVAILABLE
+            if((committedAllocParams.m_HeapFlags & D3D12_HEAP_FLAG_CREATE_NOT_ZEROED) != 0)
+            {
+                wasZeroInitialized = FALSE;
+            }
+#endif
+
+            Allocation* alloc = m_AllocationObjectAllocator.Allocate(
+                this, resourceSize, createParams.GetBaseResourceDesc()->Alignment, wasZeroInitialized);
+            alloc->InitCommitted(committedAllocParams.m_List);
+            alloc->SetResourcePointer(res, createParams.GetBaseResourceDesc());
+            alloc->SetPrivateData(pPrivateData);
+
+            *ppAllocation = alloc;
+
+            committedAllocParams.m_List->Register(alloc);
+
+            const UINT memSegmentGroup = HeapPropertiesToMemorySegmentGroup(committedAllocParams.m_HeapProperties);
+            m_Budget.AddBlock(memSegmentGroup, resourceSize);
+            m_Budget.AddAllocation(memSegmentGroup, resourceSize);
+        }
+        else
+        {
+            res->Release();
+        }
+    }
+    return hr;
+}
+
+HRESULT AllocatorPimpl::AllocateHeap(
+    const CommittedAllocationParameters& committedAllocParams,
+    const D3D12_RESOURCE_ALLOCATION_INFO& allocInfo, bool withinBudget,
+    void* pPrivateData, Allocation** ppAllocation)
+{
+    D3D12MA_ASSERT(committedAllocParams.IsValid());
+
+    *ppAllocation = nullptr;
+
+    if (withinBudget &&
+        !NewAllocationWithinBudget(committedAllocParams.m_HeapProperties.Type, allocInfo.SizeInBytes))
+    {
+        return E_OUTOFMEMORY;
+    }
+
+    D3D12_HEAP_DESC heapDesc = {};
+    heapDesc.SizeInBytes = allocInfo.SizeInBytes;
+    heapDesc.Properties = committedAllocParams.m_HeapProperties;
+    heapDesc.Alignment = allocInfo.Alignment;
+    heapDesc.Flags = committedAllocParams.m_HeapFlags;
+
+    HRESULT hr;
+    ID3D12Heap* heap = nullptr;
+#ifdef __ID3D12Device4_INTERFACE_DEFINED__
+    if (m_Device4)
+        hr = m_Device4->CreateHeap1(&heapDesc, committedAllocParams.m_ProtectedSession, D3D12MA_IID_PPV_ARGS(&heap));
+    else
+#endif
+    {
+        if (committedAllocParams.m_ProtectedSession == NULL)
+            hr = m_Device->CreateHeap(&heapDesc, D3D12MA_IID_PPV_ARGS(&heap));
+        else
+            hr = E_NOINTERFACE;
+    }
+
+    if (SUCCEEDED(hr))
+    {
+        SetResidencyPriority(heap, committedAllocParams.m_ResidencyPriority);
+
+        BOOL wasZeroInitialized = TRUE;
+#if D3D12MA_CREATE_NOT_ZEROED_AVAILABLE
+        if((heapDesc.Flags & D3D12_HEAP_FLAG_CREATE_NOT_ZEROED) != 0)
+        {
+            wasZeroInitialized = FALSE;
+        }
+#endif
+
+        (*ppAllocation) = m_AllocationObjectAllocator.Allocate(this, allocInfo.SizeInBytes, allocInfo.Alignment, wasZeroInitialized);
+        (*ppAllocation)->InitHeap(committedAllocParams.m_List, heap);
+        (*ppAllocation)->SetPrivateData(pPrivateData);
+        committedAllocParams.m_List->Register(*ppAllocation);
+
+        const UINT memSegmentGroup = HeapPropertiesToMemorySegmentGroup(committedAllocParams.m_HeapProperties);
+        m_Budget.AddBlock(memSegmentGroup, allocInfo.SizeInBytes);
+        m_Budget.AddAllocation(memSegmentGroup, allocInfo.SizeInBytes);
+    }
+    return hr;
+}
+
+template<typename D3D12_RESOURCE_DESC_T>
+HRESULT AllocatorPimpl::CalcAllocationParams(const ALLOCATION_DESC& allocDesc, UINT64 allocSize,
+    const D3D12_RESOURCE_DESC_T* resDesc,
+    BlockVector*& outBlockVector, CommittedAllocationParameters& outCommittedAllocationParams, bool& outPreferCommitted)
+{
+    outBlockVector = NULL;
+    outCommittedAllocationParams = CommittedAllocationParameters();
+    outPreferCommitted = false;
+
+    bool msaaAlwaysCommitted;
+    if (allocDesc.CustomPool != NULL)
+    {
+        PoolPimpl* const pool = allocDesc.CustomPool->m_Pimpl;
+
+        msaaAlwaysCommitted = pool->GetBlockVector()->DeniesMsaaTextures();
+        outBlockVector = pool->GetBlockVector();
+
+        const auto& desc = pool->GetDesc();
+        outCommittedAllocationParams.m_ProtectedSession = desc.pProtectedSession;
+        outCommittedAllocationParams.m_HeapProperties = desc.HeapProperties;
+        outCommittedAllocationParams.m_HeapFlags = desc.HeapFlags;
+        outCommittedAllocationParams.m_List = pool->GetCommittedAllocationList();
+        outCommittedAllocationParams.m_ResidencyPriority = pool->GetDesc().ResidencyPriority;
+    }
+    else
+    {
+        if (!IsHeapTypeStandard(allocDesc.HeapType))
+        {
+            return E_INVALIDARG;
+        }
+        msaaAlwaysCommitted = m_MsaaAlwaysCommitted;
+
+        outCommittedAllocationParams.m_HeapProperties = StandardHeapTypeToHeapProperties(allocDesc.HeapType);
+        outCommittedAllocationParams.m_HeapFlags = allocDesc.ExtraHeapFlags;
+        outCommittedAllocationParams.m_List = &m_CommittedAllocations[HeapTypeToIndex(allocDesc.HeapType)];
+        // outCommittedAllocationParams.m_ResidencyPriority intentionally left with default value.
+
+        const ResourceClass resourceClass = (resDesc != NULL) ?
+            ResourceDescToResourceClass(*resDesc) : HeapFlagsToResourceClass(allocDesc.ExtraHeapFlags);
+        const UINT defaultPoolIndex = CalcDefaultPoolIndex(allocDesc, resourceClass);
+        if (defaultPoolIndex != UINT32_MAX)
+        {
+            outBlockVector = m_BlockVectors[defaultPoolIndex];
+            const UINT64 preferredBlockSize = outBlockVector->GetPreferredBlockSize();
+            if (allocSize > preferredBlockSize)
+            {
+                outBlockVector = NULL;
+            }
+            else if (allocSize > preferredBlockSize / 2)
+            {
+                // Heuristics: Allocate committed memory if requested size if greater than half of preferred block size.
+                outPreferCommitted = true;
+            }
+        }
+
+        const D3D12_HEAP_FLAGS extraHeapFlags = allocDesc.ExtraHeapFlags & ~RESOURCE_CLASS_HEAP_FLAGS;
+        if (outBlockVector != NULL && extraHeapFlags != 0)
+        {
+            outBlockVector = NULL;
+        }
+    }
+
+    if ((allocDesc.Flags & ALLOCATION_FLAG_COMMITTED) != 0 ||
+        m_AlwaysCommitted)
+    {
+        outBlockVector = NULL;
+    }
+    if ((allocDesc.Flags & ALLOCATION_FLAG_NEVER_ALLOCATE) != 0)
+    {
+        outCommittedAllocationParams.m_List = NULL;
+    }
+    outCommittedAllocationParams.m_CanAlias = allocDesc.Flags & ALLOCATION_FLAG_CAN_ALIAS;
+
+    if (resDesc != NULL)
+    {
+        if (resDesc->SampleDesc.Count > 1 && msaaAlwaysCommitted)
+            outBlockVector = NULL;
+        if (!outPreferCommitted && PrefersCommittedAllocation(*resDesc))
+            outPreferCommitted = true;
+    }
+
+    return (outBlockVector != NULL || outCommittedAllocationParams.m_List != NULL) ? S_OK : E_INVALIDARG;
+}
+
+UINT AllocatorPimpl::CalcDefaultPoolIndex(const ALLOCATION_DESC& allocDesc, ResourceClass resourceClass) const
+{
+    D3D12_HEAP_FLAGS extraHeapFlags = allocDesc.ExtraHeapFlags & ~RESOURCE_CLASS_HEAP_FLAGS;
+
+#if D3D12MA_CREATE_NOT_ZEROED_AVAILABLE
+    // If allocator was created with ALLOCATOR_FLAG_DEFAULT_POOLS_NOT_ZEROED, also ignore
+    // D3D12_HEAP_FLAG_CREATE_NOT_ZEROED.
+    if(m_DefaultPoolsNotZeroed)
+    {
+        extraHeapFlags &= ~D3D12_HEAP_FLAG_CREATE_NOT_ZEROED;
+    }
+#endif
+
+    if (extraHeapFlags != 0)
+    {
+        return UINT32_MAX;
+    }
+
+    UINT poolIndex = UINT_MAX;
+    switch (allocDesc.HeapType)
+    {
+    case D3D12_HEAP_TYPE_DEFAULT:  poolIndex = 0; break;
+    case D3D12_HEAP_TYPE_UPLOAD:   poolIndex = 1; break;
+    case D3D12_HEAP_TYPE_READBACK: poolIndex = 2; break;
+    default: D3D12MA_ASSERT(0);
+    }
+
+    if (SupportsResourceHeapTier2())
+        return poolIndex;
+    else
+    {
+        switch (resourceClass)
+        {
+        case ResourceClass::Buffer:
+            return poolIndex * 3;
+        case ResourceClass::Non_RT_DS_Texture:
+            return poolIndex * 3 + 1;
+        case ResourceClass::RT_DS_Texture:
+            return poolIndex * 3 + 2;
+        default:
+            return UINT32_MAX;
+        }
+    }
+}
+
+void AllocatorPimpl::CalcDefaultPoolParams(D3D12_HEAP_TYPE& outHeapType, D3D12_HEAP_FLAGS& outHeapFlags, UINT index) const
+{
+    outHeapType = D3D12_HEAP_TYPE_DEFAULT;
+    outHeapFlags = D3D12_HEAP_FLAG_NONE;
+
+    if (!SupportsResourceHeapTier2())
+    {
+        switch (index % 3)
+        {
+        case 0:
+            outHeapFlags = D3D12_HEAP_FLAG_DENY_RT_DS_TEXTURES | D3D12_HEAP_FLAG_DENY_NON_RT_DS_TEXTURES;
+            break;
+        case 1:
+            outHeapFlags = D3D12_HEAP_FLAG_DENY_BUFFERS | D3D12_HEAP_FLAG_DENY_RT_DS_TEXTURES;
+            break;
+        case 2:
+            outHeapFlags = D3D12_HEAP_FLAG_DENY_BUFFERS | D3D12_HEAP_FLAG_DENY_NON_RT_DS_TEXTURES;
+            break;
+        }
+
+        index /= 3;
+    }
+
+    switch (index)
+    {
+    case 0:
+        outHeapType = D3D12_HEAP_TYPE_DEFAULT;
+        break;
+    case 1:
+        outHeapType = D3D12_HEAP_TYPE_UPLOAD;
+        break;
+    case 2:
+        outHeapType = D3D12_HEAP_TYPE_READBACK;
+        break;
+    default:
+        D3D12MA_ASSERT(0);
+    }
+}
+
+void AllocatorPimpl::RegisterPool(Pool* pool, D3D12_HEAP_TYPE heapType)
+{
+    const UINT heapTypeIndex = HeapTypeToIndex(heapType);
+
+    MutexLockWrite lock(m_PoolsMutex[heapTypeIndex], m_UseMutex);
+    m_Pools[heapTypeIndex].PushBack(pool->m_Pimpl);
+}
+
+void AllocatorPimpl::UnregisterPool(Pool* pool, D3D12_HEAP_TYPE heapType)
+{
+    const UINT heapTypeIndex = HeapTypeToIndex(heapType);
+
+    MutexLockWrite lock(m_PoolsMutex[heapTypeIndex], m_UseMutex);
+    m_Pools[heapTypeIndex].Remove(pool->m_Pimpl);
+}
+
+HRESULT AllocatorPimpl::UpdateD3D12Budget()
+{
+#if D3D12MA_DXGI_1_4
+    if (m_Adapter3)
+        return m_Budget.UpdateBudget(m_Adapter3, m_UseMutex);
+    else
+        return E_NOINTERFACE;
+#else
+    return S_OK;
+#endif
+}
+
+D3D12_RESOURCE_ALLOCATION_INFO AllocatorPimpl::GetResourceAllocationInfoNative(const D3D12_RESOURCE_DESC& resourceDesc) const
+{
+    return m_Device->GetResourceAllocationInfo(0, 1, &resourceDesc);
+}
+
+#ifdef __ID3D12Device8_INTERFACE_DEFINED__
+D3D12_RESOURCE_ALLOCATION_INFO AllocatorPimpl::GetResourceAllocationInfoNative(const D3D12_RESOURCE_DESC1& resourceDesc) const
+{
+    D3D12MA_ASSERT(m_Device8 != NULL);
+    D3D12_RESOURCE_ALLOCATION_INFO1 info1Unused;
+    return m_Device8->GetResourceAllocationInfo2(0, 1, &resourceDesc, &info1Unused);
+}
+#endif // #ifdef __ID3D12Device8_INTERFACE_DEFINED__
+
+template<typename D3D12_RESOURCE_DESC_T>
+D3D12_RESOURCE_ALLOCATION_INFO AllocatorPimpl::GetResourceAllocationInfo(D3D12_RESOURCE_DESC_T& inOutResourceDesc) const
+{
+    /* Optional optimization: Microsoft documentation says:
+    https://docs.microsoft.com/en-us/windows/win32/api/d3d12/nf-d3d12-id3d12device-getresourceallocationinfo
+
+    Your application can forgo using GetResourceAllocationInfo for buffer resources
+    (D3D12_RESOURCE_DIMENSION_BUFFER). Buffers have the same size on all adapters,
+    which is merely the smallest multiple of 64KB that's greater or equal to
+    D3D12_RESOURCE_DESC::Width.
+    */
+    if (inOutResourceDesc.Alignment == 0 &&
+        inOutResourceDesc.Dimension == D3D12_RESOURCE_DIMENSION_BUFFER)
+    {
+        return {
+            AlignUp<UINT64>(inOutResourceDesc.Width, D3D12_DEFAULT_RESOURCE_PLACEMENT_ALIGNMENT), // SizeInBytes
+            D3D12_DEFAULT_RESOURCE_PLACEMENT_ALIGNMENT }; // Alignment
+    }
+
+#if D3D12MA_USE_SMALL_RESOURCE_PLACEMENT_ALIGNMENT
+    if (inOutResourceDesc.Alignment == 0 &&
+        inOutResourceDesc.Dimension == D3D12_RESOURCE_DIMENSION_TEXTURE2D &&
+        (inOutResourceDesc.Flags & (D3D12_RESOURCE_FLAG_ALLOW_RENDER_TARGET | D3D12_RESOURCE_FLAG_ALLOW_DEPTH_STENCIL)) == 0
+#if D3D12MA_USE_SMALL_RESOURCE_PLACEMENT_ALIGNMENT == 1
+        && CanUseSmallAlignment(inOutResourceDesc)
+#endif
+        )
+    {
+        /*
+        The algorithm here is based on Microsoft sample: "Small Resources Sample"
+        https://github.com/microsoft/DirectX-Graphics-Samples/tree/master/Samples/Desktop/D3D12SmallResources
+        */
+        const UINT64 smallAlignmentToTry = inOutResourceDesc.SampleDesc.Count > 1 ?
+            D3D12_SMALL_MSAA_RESOURCE_PLACEMENT_ALIGNMENT :
+            D3D12_SMALL_RESOURCE_PLACEMENT_ALIGNMENT;
+        inOutResourceDesc.Alignment = smallAlignmentToTry;
+        const D3D12_RESOURCE_ALLOCATION_INFO smallAllocInfo = GetResourceAllocationInfoNative(inOutResourceDesc);
+        // Check if alignment requested has been granted.
+        if (smallAllocInfo.Alignment == smallAlignmentToTry)
+        {
+            return smallAllocInfo;
+        }
+        inOutResourceDesc.Alignment = 0; // Restore original
+    }
+#endif // #if D3D12MA_USE_SMALL_RESOURCE_PLACEMENT_ALIGNMENT
+
+    return GetResourceAllocationInfoNative(inOutResourceDesc);
+}
+
+bool AllocatorPimpl::NewAllocationWithinBudget(D3D12_HEAP_TYPE heapType, UINT64 size)
+{
+    Budget budget = {};
+    GetBudgetForHeapType(budget, heapType);
+    return budget.UsageBytes + size <= budget.BudgetBytes;
+}
+
+void AllocatorPimpl::WriteBudgetToJson(JsonWriter& json, const Budget& budget)
+{
+    json.BeginObject();
+    {
+        json.WriteString(L"BudgetBytes");
+        json.WriteNumber(budget.BudgetBytes);
+        json.WriteString(L"UsageBytes");
+        json.WriteNumber(budget.UsageBytes);
+    }
+    json.EndObject();
+}
+
+#endif // _D3D12MA_ALLOCATOR_PIMPL
+#endif // _D3D12MA_ALLOCATOR_PIMPL
+
+#ifndef _D3D12MA_VIRTUAL_BLOCK_PIMPL
+class VirtualBlockPimpl
+{
+public:
+    const ALLOCATION_CALLBACKS m_AllocationCallbacks;
+    const UINT64 m_Size;
+    BlockMetadata* m_Metadata;
+
+    VirtualBlockPimpl(const ALLOCATION_CALLBACKS& allocationCallbacks, const VIRTUAL_BLOCK_DESC& desc);
+    ~VirtualBlockPimpl();
+};
+
+#ifndef _D3D12MA_VIRTUAL_BLOCK_PIMPL_FUNCTIONS
+VirtualBlockPimpl::VirtualBlockPimpl(const ALLOCATION_CALLBACKS& allocationCallbacks, const VIRTUAL_BLOCK_DESC& desc)
+    : m_AllocationCallbacks(allocationCallbacks), m_Size(desc.Size)
+{
+    switch (desc.Flags & VIRTUAL_BLOCK_FLAG_ALGORITHM_MASK)
+    {
+    case VIRTUAL_BLOCK_FLAG_ALGORITHM_LINEAR:
+        m_Metadata = D3D12MA_NEW(allocationCallbacks, BlockMetadata_Linear)(&m_AllocationCallbacks, true);
+        break;
+    default:
+        D3D12MA_ASSERT(0);
+    case 0:
+        m_Metadata = D3D12MA_NEW(allocationCallbacks, BlockMetadata_TLSF)(&m_AllocationCallbacks, true);
+        break;
+    }
+    m_Metadata->Init(m_Size);
+}
+
+VirtualBlockPimpl::~VirtualBlockPimpl()
+{
+    D3D12MA_DELETE(m_AllocationCallbacks, m_Metadata);
+}
+#endif // _D3D12MA_VIRTUAL_BLOCK_PIMPL_FUNCTIONS
+#endif // _D3D12MA_VIRTUAL_BLOCK_PIMPL
+
+
+#ifndef _D3D12MA_MEMORY_BLOCK_FUNCTIONS
+MemoryBlock::MemoryBlock(
+    AllocatorPimpl* allocator,
+    const D3D12_HEAP_PROPERTIES& heapProps,
+    D3D12_HEAP_FLAGS heapFlags,
+    UINT64 size,
+    UINT id)
+    : m_Allocator(allocator),
+    m_HeapProps(heapProps),
+    m_HeapFlags(heapFlags),
+    m_Size(size),
+    m_Id(id) {}
+
+MemoryBlock::~MemoryBlock()
+{
+    if (m_Heap)
+    {
+        m_Heap->Release();
+        m_Allocator->m_Budget.RemoveBlock(
+            m_Allocator->HeapPropertiesToMemorySegmentGroup(m_HeapProps), m_Size);
+    }
+}
+
+HRESULT MemoryBlock::Init(ID3D12ProtectedResourceSession* pProtectedSession, bool denyMsaaTextures)
+{
+    D3D12MA_ASSERT(m_Heap == NULL && m_Size > 0);
+
+    D3D12_HEAP_DESC heapDesc = {};
+    heapDesc.SizeInBytes = m_Size;
+    heapDesc.Properties = m_HeapProps;
+    heapDesc.Alignment = HeapFlagsToAlignment(m_HeapFlags, denyMsaaTextures);
+    heapDesc.Flags = m_HeapFlags;
+
+    HRESULT hr;
+#ifdef __ID3D12Device4_INTERFACE_DEFINED__
+    ID3D12Device4* const device4 = m_Allocator->GetDevice4();
+    if (device4)
+        hr = m_Allocator->GetDevice4()->CreateHeap1(&heapDesc, pProtectedSession, D3D12MA_IID_PPV_ARGS(&m_Heap));
+    else
+#endif
+    {
+        if (pProtectedSession == NULL)
+            hr = m_Allocator->GetDevice()->CreateHeap(&heapDesc, D3D12MA_IID_PPV_ARGS(&m_Heap));
+        else
+            hr = E_NOINTERFACE;
+    }
+
+    if (SUCCEEDED(hr))
+    {
+        m_Allocator->m_Budget.AddBlock(
+            m_Allocator->HeapPropertiesToMemorySegmentGroup(m_HeapProps), m_Size);
+    }
+    return hr;
+}
+#endif // _D3D12MA_MEMORY_BLOCK_FUNCTIONS
+
+#ifndef _D3D12MA_NORMAL_BLOCK_FUNCTIONS
+NormalBlock::NormalBlock(
+    AllocatorPimpl* allocator,
+    BlockVector* blockVector,
+    const D3D12_HEAP_PROPERTIES& heapProps,
+    D3D12_HEAP_FLAGS heapFlags,
+    UINT64 size,
+    UINT id)
+    : MemoryBlock(allocator, heapProps, heapFlags, size, id),
+    m_pMetadata(NULL),
+    m_BlockVector(blockVector) {}
+
+NormalBlock::~NormalBlock()
+{
+    if (m_pMetadata != NULL)
+    {
+        // Define macro D3D12MA_DEBUG_LOG to receive the list of the unfreed allocations.
+        if (!m_pMetadata->IsEmpty())
+            m_pMetadata->DebugLogAllAllocations();
+
+        // THIS IS THE MOST IMPORTANT ASSERT IN THE ENTIRE LIBRARY!
+        // Hitting it means you have some memory leak - unreleased Allocation objects.
+        D3D12MA_ASSERT(m_pMetadata->IsEmpty() && "Some allocations were not freed before destruction of this memory block!");
+
+        D3D12MA_DELETE(m_Allocator->GetAllocs(), m_pMetadata);
+    }
+}
+
+HRESULT NormalBlock::Init(UINT32 algorithm, ID3D12ProtectedResourceSession* pProtectedSession, bool denyMsaaTextures)
+{
+    HRESULT hr = MemoryBlock::Init(pProtectedSession, denyMsaaTextures);
+    if (FAILED(hr))
+    {
+        return hr;
+    }
+
+    switch (algorithm)
+    {
+    case POOL_FLAG_ALGORITHM_LINEAR:
+        m_pMetadata = D3D12MA_NEW(m_Allocator->GetAllocs(), BlockMetadata_Linear)(&m_Allocator->GetAllocs(), false);
+        break;
+    default:
+        D3D12MA_ASSERT(0);
+    case 0:
+        m_pMetadata = D3D12MA_NEW(m_Allocator->GetAllocs(), BlockMetadata_TLSF)(&m_Allocator->GetAllocs(), false);
+        break;
+    }
+    m_pMetadata->Init(m_Size);
+
+    return hr;
+}
+
+bool NormalBlock::Validate() const
+{
+    D3D12MA_VALIDATE(GetHeap() &&
+        m_pMetadata &&
+        m_pMetadata->GetSize() != 0 &&
+        m_pMetadata->GetSize() == GetSize());
+    return m_pMetadata->Validate();
+}
+#endif // _D3D12MA_NORMAL_BLOCK_FUNCTIONS
+
+#ifndef _D3D12MA_COMMITTED_ALLOCATION_LIST_FUNCTIONS
+void CommittedAllocationList::Init(bool useMutex, D3D12_HEAP_TYPE heapType, PoolPimpl* pool)
+{
+    m_UseMutex = useMutex;
+    m_HeapType = heapType;
+    m_Pool = pool;
+}
+
+CommittedAllocationList::~CommittedAllocationList()
+{
+    if (!m_AllocationList.IsEmpty())
+    {
+        D3D12MA_ASSERT(0 && "Unfreed committed allocations found!");
+    }
+}
+
+UINT CommittedAllocationList::GetMemorySegmentGroup(AllocatorPimpl* allocator) const
+{
+    if (m_Pool)
+        return allocator->HeapPropertiesToMemorySegmentGroup(m_Pool->GetDesc().HeapProperties);
+    else
+        return allocator->StandardHeapTypeToMemorySegmentGroup(m_HeapType);
+}
+
+void CommittedAllocationList::AddStatistics(Statistics& inoutStats)
+{
+    MutexLockRead lock(m_Mutex, m_UseMutex);
+
+    for (Allocation* alloc = m_AllocationList.Front();
+        alloc != NULL; alloc = m_AllocationList.GetNext(alloc))
+    {
+        const UINT64 size = alloc->GetSize();
+        inoutStats.BlockCount++;
+        inoutStats.AllocationCount++;
+        inoutStats.BlockBytes += size;
+        inoutStats.AllocationBytes += size;
+    }
+}
+
+void CommittedAllocationList::AddDetailedStatistics(DetailedStatistics& inoutStats)
+{
+    MutexLockRead lock(m_Mutex, m_UseMutex);
+
+    for (Allocation* alloc = m_AllocationList.Front();
+        alloc != NULL; alloc = m_AllocationList.GetNext(alloc))
+    {
+        const UINT64 size = alloc->GetSize();
+        inoutStats.Stats.BlockCount++;
+        inoutStats.Stats.BlockBytes += size;
+        AddDetailedStatisticsAllocation(inoutStats, size);
+    }
+}
+
+void CommittedAllocationList::BuildStatsString(JsonWriter& json)
+{
+    MutexLockRead lock(m_Mutex, m_UseMutex);
+
+    for (Allocation* alloc = m_AllocationList.Front();
+        alloc != NULL; alloc = m_AllocationList.GetNext(alloc))
+    {
+        json.BeginObject(true);
+        json.AddAllocationToObject(*alloc);
+        json.EndObject();
+    }
+}
+
+void CommittedAllocationList::Register(Allocation* alloc)
+{
+    MutexLockWrite lock(m_Mutex, m_UseMutex);
+    m_AllocationList.PushBack(alloc);
+}
+
+void CommittedAllocationList::Unregister(Allocation* alloc)
+{
+    MutexLockWrite lock(m_Mutex, m_UseMutex);
+    m_AllocationList.Remove(alloc);
+}
+#endif // _D3D12MA_COMMITTED_ALLOCATION_LIST_FUNCTIONS
+
+#ifndef _D3D12MA_BLOCK_VECTOR_FUNCTIONS
+BlockVector::BlockVector(
+    AllocatorPimpl* hAllocator,
+    const D3D12_HEAP_PROPERTIES& heapProps,
+    D3D12_HEAP_FLAGS heapFlags,
+    UINT64 preferredBlockSize,
+    size_t minBlockCount,
+    size_t maxBlockCount,
+    bool explicitBlockSize,
+    UINT64 minAllocationAlignment,
+    UINT32 algorithm,
+    bool denyMsaaTextures,
+    ID3D12ProtectedResourceSession* pProtectedSession,
+    D3D12_RESIDENCY_PRIORITY residencyPriority)
+    : m_hAllocator(hAllocator),
+    m_HeapProps(heapProps),
+    m_HeapFlags(heapFlags),
+    m_PreferredBlockSize(preferredBlockSize),
+    m_MinBlockCount(minBlockCount),
+    m_MaxBlockCount(maxBlockCount),
+    m_ExplicitBlockSize(explicitBlockSize),
+    m_MinAllocationAlignment(minAllocationAlignment),
+    m_Algorithm(algorithm),
+    m_DenyMsaaTextures(denyMsaaTextures),
+    m_ProtectedSession(pProtectedSession),
+    m_ResidencyPriority(residencyPriority),
+    m_HasEmptyBlock(false),
+    m_Blocks(hAllocator->GetAllocs()),
+    m_NextBlockId(0) {}
+
+BlockVector::~BlockVector()
+{
+    for (size_t i = m_Blocks.size(); i--; )
+    {
+        D3D12MA_DELETE(m_hAllocator->GetAllocs(), m_Blocks[i]);
+    }
+}
+
+HRESULT BlockVector::CreateMinBlocks()
+{
+    for (size_t i = 0; i < m_MinBlockCount; ++i)
+    {
+        HRESULT hr = CreateBlock(m_PreferredBlockSize, NULL);
+        if (FAILED(hr))
+        {
+            return hr;
+        }
+    }
+    return S_OK;
+}
+
+bool BlockVector::IsEmpty()
+{
+    MutexLockRead lock(m_Mutex, m_hAllocator->UseMutex());
+    return m_Blocks.empty();
+}
+
+HRESULT BlockVector::Allocate(
+    UINT64 size,
+    UINT64 alignment,
+    const ALLOCATION_DESC& allocDesc,
+    size_t allocationCount,
+    Allocation** pAllocations)
+{
+    size_t allocIndex;
+    HRESULT hr = S_OK;
+
+    {
+        MutexLockWrite lock(m_Mutex, m_hAllocator->UseMutex());
+        for (allocIndex = 0; allocIndex < allocationCount; ++allocIndex)
+        {
+            hr = AllocatePage(
+                size,
+                alignment,
+                allocDesc,
+                pAllocations + allocIndex);
+            if (FAILED(hr))
+            {
+                break;
+            }
+        }
+    }
+
+    if (FAILED(hr))
+    {
+        // Free all already created allocations.
+        while (allocIndex--)
+        {
+            Free(pAllocations[allocIndex]);
+        }
+        ZeroMemory(pAllocations, sizeof(Allocation*) * allocationCount);
+    }
+
+    return hr;
+}
+
+void BlockVector::Free(Allocation* hAllocation)
+{
+    NormalBlock* pBlockToDelete = NULL;
+
+    bool budgetExceeded = false;
+    if (IsHeapTypeStandard(m_HeapProps.Type))
+    {
+        Budget budget = {};
+        m_hAllocator->GetBudgetForHeapType(budget, m_HeapProps.Type);
+        budgetExceeded = budget.UsageBytes >= budget.BudgetBytes;
+    }
+
+    // Scope for lock.
+    {
+        MutexLockWrite lock(m_Mutex, m_hAllocator->UseMutex());
+
+        NormalBlock* pBlock = hAllocation->m_Placed.block;
+
+        pBlock->m_pMetadata->Free(hAllocation->GetAllocHandle());
+        D3D12MA_HEAVY_ASSERT(pBlock->Validate());
+
+        const size_t blockCount = m_Blocks.size();
+        // pBlock became empty after this deallocation.
+        if (pBlock->m_pMetadata->IsEmpty())
+        {
+            // Already has empty Allocation. We don't want to have two, so delete this one.
+            if ((m_HasEmptyBlock || budgetExceeded) &&
+                blockCount > m_MinBlockCount)
+            {
+                pBlockToDelete = pBlock;
+                Remove(pBlock);
+            }
+            // We now have first empty block.
+            else
+            {
+                m_HasEmptyBlock = true;
+            }
+        }
+        // pBlock didn't become empty, but we have another empty block - find and free that one.
+        // (This is optional, heuristics.)
+        else if (m_HasEmptyBlock && blockCount > m_MinBlockCount)
+        {
+            NormalBlock* pLastBlock = m_Blocks.back();
+            if (pLastBlock->m_pMetadata->IsEmpty())
+            {
+                pBlockToDelete = pLastBlock;
+                m_Blocks.pop_back();
+                m_HasEmptyBlock = false;
+            }
+        }
+
+        IncrementallySortBlocks();
+    }
+
+    // Destruction of a free Allocation. Deferred until this point, outside of mutex
+    // lock, for performance reason.
+    if (pBlockToDelete != NULL)
+    {
+        D3D12MA_DELETE(m_hAllocator->GetAllocs(), pBlockToDelete);
+    }
+}
+
+HRESULT BlockVector::CreateResource(
+    UINT64 size,
+    UINT64 alignment,
+    const ALLOCATION_DESC& allocDesc,
+    const CREATE_RESOURCE_PARAMS& createParams,
+    Allocation** ppAllocation,
+    REFIID riidResource,
+    void** ppvResource)
+{
+    HRESULT hr = Allocate(size, alignment, allocDesc, 1, ppAllocation);
+    if (SUCCEEDED(hr))
+    {
+        ID3D12Resource* res = NULL;
+        hr = m_hAllocator->CreatePlacedResourceWrap(
+            (*ppAllocation)->m_Placed.block->GetHeap(),
+            (*ppAllocation)->GetOffset(),
+            createParams,
+            D3D12MA_IID_PPV_ARGS(&res));
+        if (SUCCEEDED(hr))
+        {
+            if (ppvResource != NULL)
+            {
+                hr = res->QueryInterface(riidResource, ppvResource);
+            }
+            if (SUCCEEDED(hr))
+            {
+                (*ppAllocation)->SetResourcePointer(res, createParams.GetBaseResourceDesc());
+            }
+            else
+            {
+                res->Release();
+                SAFE_RELEASE(*ppAllocation);
+            }
+        }
+        else
+        {
+            SAFE_RELEASE(*ppAllocation);
+        }
+    }
+    return hr;
+}
+
+void BlockVector::AddStatistics(Statistics& inoutStats)
+{
+    MutexLockRead lock(m_Mutex, m_hAllocator->UseMutex());
+
+    for (size_t i = 0; i < m_Blocks.size(); ++i)
+    {
+        const NormalBlock* const pBlock = m_Blocks[i];
+        D3D12MA_ASSERT(pBlock);
+        D3D12MA_HEAVY_ASSERT(pBlock->Validate());
+        pBlock->m_pMetadata->AddStatistics(inoutStats);
+    }
+}
+
+void BlockVector::AddDetailedStatistics(DetailedStatistics& inoutStats)
+{
+    MutexLockRead lock(m_Mutex, m_hAllocator->UseMutex());
+
+    for (size_t i = 0; i < m_Blocks.size(); ++i)
+    {
+        const NormalBlock* const pBlock = m_Blocks[i];
+        D3D12MA_ASSERT(pBlock);
+        D3D12MA_HEAVY_ASSERT(pBlock->Validate());
+        pBlock->m_pMetadata->AddDetailedStatistics(inoutStats);
+    }
+}
+
+void BlockVector::WriteBlockInfoToJson(JsonWriter& json)
+{
+    MutexLockRead lock(m_Mutex, m_hAllocator->UseMutex());
+
+    json.BeginObject();
+
+    for (size_t i = 0, count = m_Blocks.size(); i < count; ++i)
+    {
+        const NormalBlock* const pBlock = m_Blocks[i];
+        D3D12MA_ASSERT(pBlock);
+        D3D12MA_HEAVY_ASSERT(pBlock->Validate());
+        json.BeginString();
+        json.ContinueString(pBlock->GetId());
+        json.EndString();
+
+        json.BeginObject();
+        pBlock->m_pMetadata->WriteAllocationInfoToJson(json);
+        json.EndObject();
+    }
+
+    json.EndObject();
+}
+
+UINT64 BlockVector::CalcSumBlockSize() const
+{
+    UINT64 result = 0;
+    for (size_t i = m_Blocks.size(); i--; )
+    {
+        result += m_Blocks[i]->m_pMetadata->GetSize();
+    }
+    return result;
+}
+
+UINT64 BlockVector::CalcMaxBlockSize() const
+{
+    UINT64 result = 0;
+    for (size_t i = m_Blocks.size(); i--; )
+    {
+        result = D3D12MA_MAX(result, m_Blocks[i]->m_pMetadata->GetSize());
+        if (result >= m_PreferredBlockSize)
+        {
+            break;
+        }
+    }
+    return result;
+}
+
+void BlockVector::Remove(NormalBlock* pBlock)
+{
+    for (size_t blockIndex = 0; blockIndex < m_Blocks.size(); ++blockIndex)
+    {
+        if (m_Blocks[blockIndex] == pBlock)
+        {
+            m_Blocks.remove(blockIndex);
+            return;
+        }
+    }
+    D3D12MA_ASSERT(0);
+}
+
+void BlockVector::IncrementallySortBlocks()
+{
+    if (!m_IncrementalSort)
+        return;
+    // Bubble sort only until first swap.
+    for (size_t i = 1; i < m_Blocks.size(); ++i)
+    {
+        if (m_Blocks[i - 1]->m_pMetadata->GetSumFreeSize() > m_Blocks[i]->m_pMetadata->GetSumFreeSize())
+        {
+            D3D12MA_SWAP(m_Blocks[i - 1], m_Blocks[i]);
+            return;
+        }
+    }
+}
+
+void BlockVector::SortByFreeSize()
+{
+    D3D12MA_SORT(m_Blocks.begin(), m_Blocks.end(),
+        [](auto* b1, auto* b2)
+        {
+            return b1->m_pMetadata->GetSumFreeSize() < b2->m_pMetadata->GetSumFreeSize();
+        });
+}
+
+HRESULT BlockVector::AllocatePage(
+    UINT64 size,
+    UINT64 alignment,
+    const ALLOCATION_DESC& allocDesc,
+    Allocation** pAllocation)
+{
+    // Early reject: requested allocation size is larger that maximum block size for this block vector.
+    if (size + D3D12MA_DEBUG_MARGIN > m_PreferredBlockSize)
+    {
+        return E_OUTOFMEMORY;
+    }
+
+    UINT64 freeMemory = UINT64_MAX;
+    if (IsHeapTypeStandard(m_HeapProps.Type))
+    {
+        Budget budget = {};
+        m_hAllocator->GetBudgetForHeapType(budget, m_HeapProps.Type);
+        freeMemory = (budget.UsageBytes < budget.BudgetBytes) ? (budget.BudgetBytes - budget.UsageBytes) : 0;
+    }
+
+    const bool canCreateNewBlock =
+        ((allocDesc.Flags & ALLOCATION_FLAG_NEVER_ALLOCATE) == 0) &&
+        (m_Blocks.size() < m_MaxBlockCount) &&
+        // Even if we don't have to stay within budget with this allocation, when the
+        // budget would be exceeded, we don't want to allocate new blocks, but always
+        // create resources as committed.
+        freeMemory >= size;
+
+    // 1. Search existing allocations
+    {
+        // Forward order in m_Blocks - prefer blocks with smallest amount of free space.
+        for (size_t blockIndex = 0; blockIndex < m_Blocks.size(); ++blockIndex)
+        {
+            NormalBlock* const pCurrBlock = m_Blocks[blockIndex];
+            D3D12MA_ASSERT(pCurrBlock);
+            HRESULT hr = AllocateFromBlock(
+                pCurrBlock,
+                size,
+                alignment,
+                allocDesc.Flags,
+                allocDesc.pPrivateData,
+                allocDesc.Flags & ALLOCATION_FLAG_STRATEGY_MASK,
+                pAllocation);
+            if (SUCCEEDED(hr))
+            {
+                return hr;
+            }
+        }
+    }
+
+    // 2. Try to create new block.
+    if (canCreateNewBlock)
+    {
+        // Calculate optimal size for new block.
+        UINT64 newBlockSize = m_PreferredBlockSize;
+        UINT newBlockSizeShift = 0;
+
+        if (!m_ExplicitBlockSize)
+        {
+            // Allocate 1/8, 1/4, 1/2 as first blocks.
+            const UINT64 maxExistingBlockSize = CalcMaxBlockSize();
+            for (UINT i = 0; i < NEW_BLOCK_SIZE_SHIFT_MAX; ++i)
+            {
+                const UINT64 smallerNewBlockSize = newBlockSize / 2;
+                if (smallerNewBlockSize > maxExistingBlockSize && smallerNewBlockSize >= size * 2)
+                {
+                    newBlockSize = smallerNewBlockSize;
+                    ++newBlockSizeShift;
+                }
+                else
+                {
+                    break;
+                }
+            }
+        }
+
+        size_t newBlockIndex = 0;
+        HRESULT hr = newBlockSize <= freeMemory ?
+            CreateBlock(newBlockSize, &newBlockIndex) : E_OUTOFMEMORY;
+        // Allocation of this size failed? Try 1/2, 1/4, 1/8 of m_PreferredBlockSize.
+        if (!m_ExplicitBlockSize)
+        {
+            while (FAILED(hr) && newBlockSizeShift < NEW_BLOCK_SIZE_SHIFT_MAX)
+            {
+                const UINT64 smallerNewBlockSize = newBlockSize / 2;
+                if (smallerNewBlockSize >= size)
+                {
+                    newBlockSize = smallerNewBlockSize;
+                    ++newBlockSizeShift;
+                    hr = newBlockSize <= freeMemory ?
+                        CreateBlock(newBlockSize, &newBlockIndex) : E_OUTOFMEMORY;
+                }
+                else
+                {
+                    break;
+                }
+            }
+        }
+
+        if (SUCCEEDED(hr))
+        {
+            NormalBlock* const pBlock = m_Blocks[newBlockIndex];
+            D3D12MA_ASSERT(pBlock->m_pMetadata->GetSize() >= size);
+
+            hr = AllocateFromBlock(
+                pBlock,
+                size,
+                alignment,
+                allocDesc.Flags,
+                allocDesc.pPrivateData,
+                allocDesc.Flags & ALLOCATION_FLAG_STRATEGY_MASK,
+                pAllocation);
+            if (SUCCEEDED(hr))
+            {
+                return hr;
+            }
+            else
+            {
+                // Allocation from new block failed, possibly due to D3D12MA_DEBUG_MARGIN or alignment.
+                return E_OUTOFMEMORY;
+            }
+        }
+    }
+
+    return E_OUTOFMEMORY;
+}
+
+HRESULT BlockVector::AllocateFromBlock(
+    NormalBlock* pBlock,
+    UINT64 size,
+    UINT64 alignment,
+    ALLOCATION_FLAGS allocFlags,
+    void* pPrivateData,
+    UINT32 strategy,
+    Allocation** pAllocation)
+{
+    alignment = D3D12MA_MAX(alignment, m_MinAllocationAlignment);
+
+    AllocationRequest currRequest = {};
+    if (pBlock->m_pMetadata->CreateAllocationRequest(
+        size,
+        alignment,
+        allocFlags & ALLOCATION_FLAG_UPPER_ADDRESS,
+        strategy,
+        &currRequest))
+    {
+        return CommitAllocationRequest(currRequest, pBlock, size, alignment, pPrivateData, pAllocation);
+    }
+    return E_OUTOFMEMORY;
+}
+
+HRESULT BlockVector::CommitAllocationRequest(
+    AllocationRequest& allocRequest,
+    NormalBlock* pBlock,
+    UINT64 size,
+    UINT64 alignment,
+    void* pPrivateData,
+    Allocation** pAllocation)
+{
+    // We no longer have an empty Allocation.
+    if (pBlock->m_pMetadata->IsEmpty())
+        m_HasEmptyBlock = false;
+
+    *pAllocation = m_hAllocator->GetAllocationObjectAllocator().Allocate(m_hAllocator, size, alignment, allocRequest.zeroInitialized);
+    pBlock->m_pMetadata->Alloc(allocRequest, size, *pAllocation);
+
+    (*pAllocation)->InitPlaced(allocRequest.allocHandle, pBlock);
+    (*pAllocation)->SetPrivateData(pPrivateData);
+
+    D3D12MA_HEAVY_ASSERT(pBlock->Validate());
+    m_hAllocator->m_Budget.AddAllocation(m_hAllocator->HeapPropertiesToMemorySegmentGroup(m_HeapProps), size);
+
+    return S_OK;
+}
+
+HRESULT BlockVector::CreateBlock(
+    UINT64 blockSize,
+    size_t* pNewBlockIndex)
+{
+    NormalBlock* const pBlock = D3D12MA_NEW(m_hAllocator->GetAllocs(), NormalBlock)(
+        m_hAllocator,
+        this,
+        m_HeapProps,
+        m_HeapFlags,
+        blockSize,
+        m_NextBlockId++);
+    HRESULT hr = pBlock->Init(m_Algorithm, m_ProtectedSession, m_DenyMsaaTextures);
+    if (FAILED(hr))
+    {
+        D3D12MA_DELETE(m_hAllocator->GetAllocs(), pBlock);
+        return hr;
+    }
+
+    m_hAllocator->SetResidencyPriority(pBlock->GetHeap(), m_ResidencyPriority);
+
+    m_Blocks.push_back(pBlock);
+    if (pNewBlockIndex != NULL)
+    {
+        *pNewBlockIndex = m_Blocks.size() - 1;
+    }
+
+    return hr;
+}
+#endif // _D3D12MA_BLOCK_VECTOR_FUNCTIONS
+
+#ifndef _D3D12MA_DEFRAGMENTATION_CONTEXT_PIMPL_FUNCTIONS
+DefragmentationContextPimpl::DefragmentationContextPimpl(
+    AllocatorPimpl* hAllocator,
+    const DEFRAGMENTATION_DESC& desc,
+    BlockVector* poolVector)
+    : m_MaxPassBytes(desc.MaxBytesPerPass == 0 ? UINT64_MAX : desc.MaxBytesPerPass),
+    m_MaxPassAllocations(desc.MaxAllocationsPerPass == 0 ? UINT32_MAX : desc.MaxAllocationsPerPass),
+    m_Moves(hAllocator->GetAllocs())
+{
+    m_Algorithm = desc.Flags & DEFRAGMENTATION_FLAG_ALGORITHM_MASK;
+
+    if (poolVector != NULL)
+    {
+        m_BlockVectorCount = 1;
+        m_PoolBlockVector = poolVector;
+        m_pBlockVectors = &m_PoolBlockVector;
+        m_PoolBlockVector->SetIncrementalSort(false);
+        m_PoolBlockVector->SortByFreeSize();
+    }
+    else
+    {
+        m_BlockVectorCount = hAllocator->GetDefaultPoolCount();
+        m_PoolBlockVector = NULL;
+        m_pBlockVectors = hAllocator->GetDefaultPools();
+        for (UINT32 i = 0; i < m_BlockVectorCount; ++i)
+        {
+            BlockVector* vector = m_pBlockVectors[i];
+            if (vector != NULL)
+            {
+                vector->SetIncrementalSort(false);
+                vector->SortByFreeSize();
+            }
+        }
+    }
+
+    switch (m_Algorithm)
+    {
+    case 0: // Default algorithm
+        m_Algorithm = DEFRAGMENTATION_FLAG_ALGORITHM_BALANCED;
+    case DEFRAGMENTATION_FLAG_ALGORITHM_BALANCED:
+    {
+        m_AlgorithmState = D3D12MA_NEW_ARRAY(hAllocator->GetAllocs(), StateBalanced, m_BlockVectorCount);
+        break;
+    }
+    }
+}
+
+DefragmentationContextPimpl::~DefragmentationContextPimpl()
+{
+    if (m_PoolBlockVector != NULL)
+        m_PoolBlockVector->SetIncrementalSort(true);
+    else
+    {
+        for (UINT32 i = 0; i < m_BlockVectorCount; ++i)
+        {
+            BlockVector* vector = m_pBlockVectors[i];
+            if (vector != NULL)
+                vector->SetIncrementalSort(true);
+        }
+    }
+
+    if (m_AlgorithmState)
+    {
+        switch (m_Algorithm)
+        {
+        case DEFRAGMENTATION_FLAG_ALGORITHM_BALANCED:
+            D3D12MA_DELETE_ARRAY(m_Moves.GetAllocs(), reinterpret_cast<StateBalanced*>(m_AlgorithmState), m_BlockVectorCount);
+            break;
+        default:
+            D3D12MA_ASSERT(0);
+        }
+    }
+}
+
+HRESULT DefragmentationContextPimpl::DefragmentPassBegin(DEFRAGMENTATION_PASS_MOVE_INFO& moveInfo)
+{
+    if (m_PoolBlockVector != NULL)
+    {
+        MutexLockWrite lock(m_PoolBlockVector->GetMutex(), m_PoolBlockVector->m_hAllocator->UseMutex());
+
+        if (m_PoolBlockVector->GetBlockCount() > 1)
+            ComputeDefragmentation(*m_PoolBlockVector, 0);
+        else if (m_PoolBlockVector->GetBlockCount() == 1)
+            ReallocWithinBlock(*m_PoolBlockVector, m_PoolBlockVector->GetBlock(0));
+
+        // Setup index into block vector
+        for (size_t i = 0; i < m_Moves.size(); ++i)
+            m_Moves[i].pDstTmpAllocation->SetPrivateData(0);
+    }
+    else
+    {
+        for (UINT32 i = 0; i < m_BlockVectorCount; ++i)
+        {
+            if (m_pBlockVectors[i] != NULL)
+            {
+                MutexLockWrite lock(m_pBlockVectors[i]->GetMutex(), m_pBlockVectors[i]->m_hAllocator->UseMutex());
+
+                bool end = false;
+                size_t movesOffset = m_Moves.size();
+                if (m_pBlockVectors[i]->GetBlockCount() > 1)
+                {
+                    end = ComputeDefragmentation(*m_pBlockVectors[i], i);
+                }
+                else if (m_pBlockVectors[i]->GetBlockCount() == 1)
+                {
+                    end = ReallocWithinBlock(*m_pBlockVectors[i], m_pBlockVectors[i]->GetBlock(0));
+                }
+
+                // Setup index into block vector
+                for (; movesOffset < m_Moves.size(); ++movesOffset)
+                    m_Moves[movesOffset].pDstTmpAllocation->SetPrivateData(reinterpret_cast<void*>(static_cast<uintptr_t>(i)));
+
+                if (end)
+                    break;
+            }
+        }
+    }
+
+    moveInfo.MoveCount = static_cast<UINT32>(m_Moves.size());
+    if (moveInfo.MoveCount > 0)
+    {
+        moveInfo.pMoves = m_Moves.data();
+        return S_FALSE;
+    }
+
+    moveInfo.pMoves = NULL;
+    return S_OK;
+}
+
+HRESULT DefragmentationContextPimpl::DefragmentPassEnd(DEFRAGMENTATION_PASS_MOVE_INFO& moveInfo)
+{
+    D3D12MA_ASSERT(moveInfo.MoveCount > 0 ? moveInfo.pMoves != NULL : true);
+
+    HRESULT result = S_OK;
+    Vector<FragmentedBlock> immovableBlocks(m_Moves.GetAllocs());
+
+    for (uint32_t i = 0; i < moveInfo.MoveCount; ++i)
+    {
+        DEFRAGMENTATION_MOVE& move = moveInfo.pMoves[i];
+        size_t prevCount = 0, currentCount = 0;
+        UINT64 freedBlockSize = 0;
+
+        UINT32 vectorIndex;
+        BlockVector* vector;
+        if (m_PoolBlockVector != NULL)
+        {
+            vectorIndex = 0;
+            vector = m_PoolBlockVector;
+        }
+        else
+        {
+            vectorIndex = static_cast<UINT32>(reinterpret_cast<uintptr_t>(move.pDstTmpAllocation->GetPrivateData()));
+            vector = m_pBlockVectors[vectorIndex];
+            D3D12MA_ASSERT(vector != NULL);
+        }
+
+        switch (move.Operation)
+        {
+        case DEFRAGMENTATION_MOVE_OPERATION_COPY:
+        {
+            move.pSrcAllocation->SwapBlockAllocation(move.pDstTmpAllocation);
+
+            // Scope for locks, Free have it's own lock
+            {
+                MutexLockRead lock(vector->GetMutex(), vector->m_hAllocator->UseMutex());
+                prevCount = vector->GetBlockCount();
+                freedBlockSize = move.pDstTmpAllocation->GetBlock()->m_pMetadata->GetSize();
+            }
+            move.pDstTmpAllocation->Release();
+            {
+                MutexLockRead lock(vector->GetMutex(), vector->m_hAllocator->UseMutex());
+                currentCount = vector->GetBlockCount();
+            }
+
+            result = S_FALSE;
+            break;
+        }
+        case DEFRAGMENTATION_MOVE_OPERATION_IGNORE:
+        {
+            m_PassStats.BytesMoved -= move.pSrcAllocation->GetSize();
+            --m_PassStats.AllocationsMoved;
+            move.pDstTmpAllocation->Release();
+
+            NormalBlock* newBlock = move.pSrcAllocation->GetBlock();
+            bool notPresent = true;
+            for (const FragmentedBlock& block : immovableBlocks)
+            {
+                if (block.block == newBlock)
+                {
+                    notPresent = false;
+                    break;
+                }
+            }
+            if (notPresent)
+                immovableBlocks.push_back({ vectorIndex, newBlock });
+            break;
+        }
+        case DEFRAGMENTATION_MOVE_OPERATION_DESTROY:
+        {
+            m_PassStats.BytesMoved -= move.pSrcAllocation->GetSize();
+            --m_PassStats.AllocationsMoved;
+            // Scope for locks, Free have it's own lock
+            {
+                MutexLockRead lock(vector->GetMutex(), vector->m_hAllocator->UseMutex());
+                prevCount = vector->GetBlockCount();
+                freedBlockSize = move.pSrcAllocation->GetBlock()->m_pMetadata->GetSize();
+            }
+            move.pSrcAllocation->Release();
+            {
+                MutexLockRead lock(vector->GetMutex(), vector->m_hAllocator->UseMutex());
+                currentCount = vector->GetBlockCount();
+            }
+            freedBlockSize *= prevCount - currentCount;
+
+            UINT64 dstBlockSize;
+            {
+                MutexLockRead lock(vector->GetMutex(), vector->m_hAllocator->UseMutex());
+                dstBlockSize = move.pDstTmpAllocation->GetBlock()->m_pMetadata->GetSize();
+            }
+            move.pDstTmpAllocation->Release();
+            {
+                MutexLockRead lock(vector->GetMutex(), vector->m_hAllocator->UseMutex());
+                freedBlockSize += dstBlockSize * (currentCount - vector->GetBlockCount());
+                currentCount = vector->GetBlockCount();
+            }
+
+            result = S_FALSE;
+            break;
+        }
+        default:
+            D3D12MA_ASSERT(0);
+        }
+
+        if (prevCount > currentCount)
+        {
+            size_t freedBlocks = prevCount - currentCount;
+            m_PassStats.HeapsFreed += static_cast<UINT32>(freedBlocks);
+            m_PassStats.BytesFreed += freedBlockSize;
+        }
+    }
+    moveInfo.MoveCount = 0;
+    moveInfo.pMoves = NULL;
+    m_Moves.clear();
+
+    // Update stats
+    m_GlobalStats.AllocationsMoved += m_PassStats.AllocationsMoved;
+    m_GlobalStats.BytesFreed += m_PassStats.BytesFreed;
+    m_GlobalStats.BytesMoved += m_PassStats.BytesMoved;
+    m_GlobalStats.HeapsFreed += m_PassStats.HeapsFreed;
+    m_PassStats = { 0 };
+
+    // Move blocks with immovable allocations according to algorithm
+    if (immovableBlocks.size() > 0)
+    {
+        // Move to the begining
+        for (const FragmentedBlock& block : immovableBlocks)
+        {
+            BlockVector* vector = m_pBlockVectors[block.data];
+            MutexLockWrite lock(vector->GetMutex(), vector->m_hAllocator->UseMutex());
+
+            for (size_t i = m_ImmovableBlockCount; i < vector->GetBlockCount(); ++i)
+            {
+                if (vector->GetBlock(i) == block.block)
+                {
+                    D3D12MA_SWAP(vector->m_Blocks[i], vector->m_Blocks[m_ImmovableBlockCount++]);
+                    break;
+                }
+            }
+        }
+    }
+    return result;
+}
+
+bool DefragmentationContextPimpl::ComputeDefragmentation(BlockVector& vector, size_t index)
+{
+    switch (m_Algorithm)
+    {
+    case DEFRAGMENTATION_FLAG_ALGORITHM_FAST:
+        return ComputeDefragmentation_Fast(vector);
+    default:
+        D3D12MA_ASSERT(0);
+    case DEFRAGMENTATION_FLAG_ALGORITHM_BALANCED:
+        return ComputeDefragmentation_Balanced(vector, index, true);
+    case DEFRAGMENTATION_FLAG_ALGORITHM_FULL:
+        return ComputeDefragmentation_Full(vector);
+    }
+}
+
+DefragmentationContextPimpl::MoveAllocationData DefragmentationContextPimpl::GetMoveData(
+    AllocHandle handle, BlockMetadata* metadata)
+{
+    MoveAllocationData moveData;
+    moveData.move.pSrcAllocation = (Allocation*)metadata->GetAllocationPrivateData(handle);
+    moveData.size = moveData.move.pSrcAllocation->GetSize();
+    moveData.alignment = moveData.move.pSrcAllocation->GetAlignment();
+    moveData.flags = ALLOCATION_FLAG_NONE;
+
+    return moveData;
+}
+
+DefragmentationContextPimpl::CounterStatus DefragmentationContextPimpl::CheckCounters(UINT64 bytes)
+{
+    // Ignore allocation if will exceed max size for copy
+    if (m_PassStats.BytesMoved + bytes > m_MaxPassBytes)
+    {
+        if (++m_IgnoredAllocs < MAX_ALLOCS_TO_IGNORE)
+            return CounterStatus::Ignore;
+        else
+            return CounterStatus::End;
+    }
+    return CounterStatus::Pass;
+}
+
+bool DefragmentationContextPimpl::IncrementCounters(UINT64 bytes)
+{
+    m_PassStats.BytesMoved += bytes;
+    // Early return when max found
+    if (++m_PassStats.AllocationsMoved >= m_MaxPassAllocations || m_PassStats.BytesMoved >= m_MaxPassBytes)
+    {
+        D3D12MA_ASSERT((m_PassStats.AllocationsMoved == m_MaxPassAllocations ||
+            m_PassStats.BytesMoved == m_MaxPassBytes) && "Exceeded maximal pass threshold!");
+        return true;
+    }
+    return false;
+}
+
+bool DefragmentationContextPimpl::ReallocWithinBlock(BlockVector& vector, NormalBlock* block)
+{
+    BlockMetadata* metadata = block->m_pMetadata;
+
+    for (AllocHandle handle = metadata->GetAllocationListBegin();
+        handle != (AllocHandle)0;
+        handle = metadata->GetNextAllocation(handle))
+    {
+        MoveAllocationData moveData = GetMoveData(handle, metadata);
+        // Ignore newly created allocations by defragmentation algorithm
+        if (moveData.move.pSrcAllocation->GetPrivateData() == this)
+            continue;
+        switch (CheckCounters(moveData.move.pSrcAllocation->GetSize()))
+        {
+        case CounterStatus::Ignore:
+            continue;
+        case CounterStatus::End:
+            return true;
+        default:
+            D3D12MA_ASSERT(0);
+        case CounterStatus::Pass:
+            break;
+        }
+        
+        UINT64 offset = moveData.move.pSrcAllocation->GetOffset();
+        if (offset != 0 && metadata->GetSumFreeSize() >= moveData.size)
+        {
+            AllocationRequest request = {};
+            if (metadata->CreateAllocationRequest(
+                moveData.size,
+                moveData.alignment,
+                false,
+                ALLOCATION_FLAG_STRATEGY_MIN_OFFSET,
+                &request))
+            {
+                if (metadata->GetAllocationOffset(request.allocHandle) < offset)
+                {
+                    if (SUCCEEDED(vector.CommitAllocationRequest(
+                        request,
+                        block,
+                        moveData.size,
+                        moveData.alignment,
+                        this,
+                        &moveData.move.pDstTmpAllocation)))
+                    {
+                        m_Moves.push_back(moveData.move);
+                        if (IncrementCounters(moveData.size))
+                            return true;
+                    }
+                }
+            }
+        }
+    }
+    return false;
+}
+
+bool DefragmentationContextPimpl::AllocInOtherBlock(size_t start, size_t end, MoveAllocationData& data, BlockVector& vector)
+{
+    for (; start < end; ++start)
+    {
+        NormalBlock* dstBlock = vector.GetBlock(start);
+        if (dstBlock->m_pMetadata->GetSumFreeSize() >= data.size)
+        {
+            if (SUCCEEDED(vector.AllocateFromBlock(dstBlock,
+                data.size,
+                data.alignment,
+                data.flags,
+                this,
+                0,
+                &data.move.pDstTmpAllocation)))
+            {
+                m_Moves.push_back(data.move);
+                if (IncrementCounters(data.size))
+                    return true;
+                break;
+            }
+        }
+    }
+    return false;
+}
+
+bool DefragmentationContextPimpl::ComputeDefragmentation_Fast(BlockVector& vector)
+{
+    // Move only between blocks
+
+    // Go through allocations in last blocks and try to fit them inside first ones
+    for (size_t i = vector.GetBlockCount() - 1; i > m_ImmovableBlockCount; --i)
+    {
+        BlockMetadata* metadata = vector.GetBlock(i)->m_pMetadata;
+
+        for (AllocHandle handle = metadata->GetAllocationListBegin();
+            handle != (AllocHandle)0;
+            handle = metadata->GetNextAllocation(handle))
+        {
+            MoveAllocationData moveData = GetMoveData(handle, metadata);
+            // Ignore newly created allocations by defragmentation algorithm
+            if (moveData.move.pSrcAllocation->GetPrivateData() == this)
+                continue;
+            switch (CheckCounters(moveData.move.pSrcAllocation->GetSize()))
+            {
+            case CounterStatus::Ignore:
+                continue;
+            case CounterStatus::End:
+                return true;
+            default:
+                D3D12MA_ASSERT(0);
+            case CounterStatus::Pass:
+                break;
+            }
+
+            // Check all previous blocks for free space
+            if (AllocInOtherBlock(0, i, moveData, vector))
+                return true;
+        }
+    }
+    return false;
+}
+
+bool DefragmentationContextPimpl::ComputeDefragmentation_Balanced(BlockVector& vector, size_t index, bool update)
+{
+    // Go over every allocation and try to fit it in previous blocks at lowest offsets,
+    // if not possible: realloc within single block to minimize offset (exclude offset == 0),
+    // but only if there are noticable gaps between them (some heuristic, ex. average size of allocation in block)
+    D3D12MA_ASSERT(m_AlgorithmState != NULL);
+
+    StateBalanced& vectorState = reinterpret_cast<StateBalanced*>(m_AlgorithmState)[index];
+    if (update && vectorState.avgAllocSize == UINT64_MAX)
+        UpdateVectorStatistics(vector, vectorState);
+
+    const size_t startMoveCount = m_Moves.size();
+    UINT64 minimalFreeRegion = vectorState.avgFreeSize / 2;
+    for (size_t i = vector.GetBlockCount() - 1; i > m_ImmovableBlockCount; --i)
+    {
+        NormalBlock* block = vector.GetBlock(i);
+        BlockMetadata* metadata = block->m_pMetadata;
+        UINT64 prevFreeRegionSize = 0;
+
+        for (AllocHandle handle = metadata->GetAllocationListBegin();
+            handle != (AllocHandle)0;
+            handle = metadata->GetNextAllocation(handle))
+        {
+            MoveAllocationData moveData = GetMoveData(handle, metadata);
+            // Ignore newly created allocations by defragmentation algorithm
+            if (moveData.move.pSrcAllocation->GetPrivateData() == this)
+                continue;
+            switch (CheckCounters(moveData.move.pSrcAllocation->GetSize()))
+            {
+            case CounterStatus::Ignore:
+                continue;
+            case CounterStatus::End:
+                return true;
+            default:
+                D3D12MA_ASSERT(0);
+            case CounterStatus::Pass:
+                break;
+            }
+
+            // Check all previous blocks for free space
+            const size_t prevMoveCount = m_Moves.size();
+            if (AllocInOtherBlock(0, i, moveData, vector))
+                return true;
+
+            UINT64 nextFreeRegionSize = metadata->GetNextFreeRegionSize(handle);
+            // If no room found then realloc within block for lower offset
+            UINT64 offset = moveData.move.pSrcAllocation->GetOffset();
+            if (prevMoveCount == m_Moves.size() && offset != 0 && metadata->GetSumFreeSize() >= moveData.size)
+            {
+                // Check if realloc will make sense
+                if (prevFreeRegionSize >= minimalFreeRegion ||
+                    nextFreeRegionSize >= minimalFreeRegion ||
+                    moveData.size <= vectorState.avgFreeSize ||
+                    moveData.size <= vectorState.avgAllocSize)
+                {
+                    AllocationRequest request = {};
+                    if (metadata->CreateAllocationRequest(
+                        moveData.size,
+                        moveData.alignment,
+                        false,
+                        ALLOCATION_FLAG_STRATEGY_MIN_OFFSET,
+                        &request))
+                    {
+                        if (metadata->GetAllocationOffset(request.allocHandle) < offset)
+                        {
+                            if (SUCCEEDED(vector.CommitAllocationRequest(
+                                request,
+                                block,
+                                moveData.size,
+                                moveData.alignment,
+                                this,
+                                &moveData.move.pDstTmpAllocation)))
+                            {
+                                m_Moves.push_back(moveData.move);
+                                if (IncrementCounters(moveData.size))
+                                    return true;
+                            }
+                        }
+                    }
+                }
+            }
+            prevFreeRegionSize = nextFreeRegionSize;
+        }
+    }
+
+    // No moves perfomed, update statistics to current vector state
+    if (startMoveCount == m_Moves.size() && !update)
+    {
+        vectorState.avgAllocSize = UINT64_MAX;
+        return ComputeDefragmentation_Balanced(vector, index, false);
+    }
+    return false;
+}
+
+bool DefragmentationContextPimpl::ComputeDefragmentation_Full(BlockVector& vector)
+{
+    // Go over every allocation and try to fit it in previous blocks at lowest offsets,
+    // if not possible: realloc within single block to minimize offset (exclude offset == 0)
+
+    for (size_t i = vector.GetBlockCount() - 1; i > m_ImmovableBlockCount; --i)
+    {
+        NormalBlock* block = vector.GetBlock(i);
+        BlockMetadata* metadata = block->m_pMetadata;
+
+        for (AllocHandle handle = metadata->GetAllocationListBegin();
+            handle != (AllocHandle)0;
+            handle = metadata->GetNextAllocation(handle))
+        {
+            MoveAllocationData moveData = GetMoveData(handle, metadata);
+            // Ignore newly created allocations by defragmentation algorithm
+            if (moveData.move.pSrcAllocation->GetPrivateData() == this)
+                continue;
+            switch (CheckCounters(moveData.move.pSrcAllocation->GetSize()))
+            {
+            case CounterStatus::Ignore:
+                continue;
+            case CounterStatus::End:
+                return true;
+            default:
+                D3D12MA_ASSERT(0);
+            case CounterStatus::Pass:
+                break;
+            }
+
+            // Check all previous blocks for free space
+            const size_t prevMoveCount = m_Moves.size();
+            if (AllocInOtherBlock(0, i, moveData, vector))
+                return true;
+
+            // If no room found then realloc within block for lower offset
+            UINT64 offset = moveData.move.pSrcAllocation->GetOffset();
+            if (prevMoveCount == m_Moves.size() && offset != 0 && metadata->GetSumFreeSize() >= moveData.size)
+            {
+                AllocationRequest request = {};
+                if (metadata->CreateAllocationRequest(
+                    moveData.size,
+                    moveData.alignment,
+                    false,
+                    ALLOCATION_FLAG_STRATEGY_MIN_OFFSET,
+                    &request))
+                {
+                    if (metadata->GetAllocationOffset(request.allocHandle) < offset)
+                    {
+                        if (SUCCEEDED(vector.CommitAllocationRequest(
+                            request,
+                            block,
+                            moveData.size,
+                            moveData.alignment,
+                            this,
+                            &moveData.move.pDstTmpAllocation)))
+                        {
+                            m_Moves.push_back(moveData.move);
+                            if (IncrementCounters(moveData.size))
+                                return true;
+                        }
+                    }
+                }
+            }
+        }
+    }
+    return false;
+}
+
+void DefragmentationContextPimpl::UpdateVectorStatistics(BlockVector& vector, StateBalanced& state)
+{
+    size_t allocCount = 0;
+    size_t freeCount = 0;
+    state.avgFreeSize = 0;
+    state.avgAllocSize = 0;
+
+    for (size_t i = 0; i < vector.GetBlockCount(); ++i)
+    {
+        BlockMetadata* metadata = vector.GetBlock(i)->m_pMetadata;
+
+        allocCount += metadata->GetAllocationCount();
+        freeCount += metadata->GetFreeRegionsCount();
+        state.avgFreeSize += metadata->GetSumFreeSize();
+        state.avgAllocSize += metadata->GetSize();
+    }
+
+    state.avgAllocSize = (state.avgAllocSize - state.avgFreeSize) / allocCount;
+    state.avgFreeSize /= freeCount;
+}
+#endif // _D3D12MA_DEFRAGMENTATION_CONTEXT_PIMPL_FUNCTIONS
+
+#ifndef _D3D12MA_POOL_PIMPL_FUNCTIONS
+PoolPimpl::PoolPimpl(AllocatorPimpl* allocator, const POOL_DESC& desc)
+    : m_Allocator(allocator),
+    m_Desc(desc),
+    m_BlockVector(NULL),
+    m_Name(NULL)
+{
+    const bool explicitBlockSize = desc.BlockSize != 0;
+    const UINT64 preferredBlockSize = explicitBlockSize ? desc.BlockSize : D3D12MA_DEFAULT_BLOCK_SIZE;
+    UINT maxBlockCount = desc.MaxBlockCount != 0 ? desc.MaxBlockCount : UINT_MAX;
+
+#ifndef __ID3D12Device4_INTERFACE_DEFINED__
+    D3D12MA_ASSERT(m_Desc.pProtectedSession == NULL);
+#endif
+
+    m_BlockVector = D3D12MA_NEW(allocator->GetAllocs(), BlockVector)(
+        allocator, desc.HeapProperties, desc.HeapFlags,
+        preferredBlockSize,
+        desc.MinBlockCount, maxBlockCount,
+        explicitBlockSize,
+        D3D12MA_MAX(desc.MinAllocationAlignment, (UINT64)D3D12MA_DEBUG_ALIGNMENT),
+        (desc.Flags & POOL_FLAG_ALGORITHM_MASK) != 0,
+        (desc.Flags & POOL_FLAG_MSAA_TEXTURES_ALWAYS_COMMITTED) != 0,
+        desc.pProtectedSession,
+        desc.ResidencyPriority);
+}
+
+PoolPimpl::~PoolPimpl()
+{
+    D3D12MA_ASSERT(m_PrevPool == NULL && m_NextPool == NULL);
+    FreeName();
+    D3D12MA_DELETE(m_Allocator->GetAllocs(), m_BlockVector);
+}
+
+HRESULT PoolPimpl::Init()
+{
+    m_CommittedAllocations.Init(m_Allocator->UseMutex(), m_Desc.HeapProperties.Type, this);
+    return m_BlockVector->CreateMinBlocks();
+}
+
+void PoolPimpl::GetStatistics(Statistics& outStats)
+{
+    ClearStatistics(outStats);
+    m_BlockVector->AddStatistics(outStats);
+    m_CommittedAllocations.AddStatistics(outStats);
+}
+
+void PoolPimpl::CalculateStatistics(DetailedStatistics& outStats)
+{
+    ClearDetailedStatistics(outStats);
+    AddDetailedStatistics(outStats);
+}
+
+void PoolPimpl::AddDetailedStatistics(DetailedStatistics& inoutStats)
+{
+    m_BlockVector->AddDetailedStatistics(inoutStats);
+    m_CommittedAllocations.AddDetailedStatistics(inoutStats);
+}
+
+void PoolPimpl::SetName(LPCWSTR Name)
+{
+    FreeName();
+
+    if (Name)
+    {
+        const size_t nameCharCount = wcslen(Name) + 1;
+        m_Name = D3D12MA_NEW_ARRAY(m_Allocator->GetAllocs(), WCHAR, nameCharCount);
+        memcpy(m_Name, Name, nameCharCount * sizeof(WCHAR));
+    }
+}
+
+void PoolPimpl::FreeName()
+{
+    if (m_Name)
+    {
+        const size_t nameCharCount = wcslen(m_Name) + 1;
+        D3D12MA_DELETE_ARRAY(m_Allocator->GetAllocs(), m_Name, nameCharCount);
+        m_Name = NULL;
+    }
+}
+#endif // _D3D12MA_POOL_PIMPL_FUNCTIONS
+
+
+#ifndef _D3D12MA_PUBLIC_INTERFACE
+HRESULT CreateAllocator(const ALLOCATOR_DESC* pDesc, Allocator** ppAllocator)
+{
+    if (!pDesc || !ppAllocator || !pDesc->pDevice || !pDesc->pAdapter ||
+        !(pDesc->PreferredBlockSize == 0 || (pDesc->PreferredBlockSize >= 16 && pDesc->PreferredBlockSize < 0x10000000000ull)))
+    {
+        D3D12MA_ASSERT(0 && "Invalid arguments passed to CreateAllocator.");
+        return E_INVALIDARG;
+    }
+
+    D3D12MA_DEBUG_GLOBAL_MUTEX_LOCK
+
+    ALLOCATION_CALLBACKS allocationCallbacks;
+    SetupAllocationCallbacks(allocationCallbacks, pDesc->pAllocationCallbacks);
+
+    *ppAllocator = D3D12MA_NEW(allocationCallbacks, Allocator)(allocationCallbacks, *pDesc);
+    HRESULT hr = (*ppAllocator)->m_Pimpl->Init(*pDesc);
+    if (FAILED(hr))
+    {
+        D3D12MA_DELETE(allocationCallbacks, *ppAllocator);
+        *ppAllocator = NULL;
+    }
+    return hr;
+}
+
+HRESULT CreateVirtualBlock(const VIRTUAL_BLOCK_DESC* pDesc, VirtualBlock** ppVirtualBlock)
+{
+    if (!pDesc || !ppVirtualBlock)
+    {
+        D3D12MA_ASSERT(0 && "Invalid arguments passed to CreateVirtualBlock.");
+        return E_INVALIDARG;
+    }
+
+    D3D12MA_DEBUG_GLOBAL_MUTEX_LOCK
+
+    ALLOCATION_CALLBACKS allocationCallbacks;
+    SetupAllocationCallbacks(allocationCallbacks, pDesc->pAllocationCallbacks);
+
+    *ppVirtualBlock = D3D12MA_NEW(allocationCallbacks, VirtualBlock)(allocationCallbacks, *pDesc);
+    return S_OK;
+}
+
+#ifndef _D3D12MA_IUNKNOWN_IMPL_FUNCTIONS
+HRESULT STDMETHODCALLTYPE IUnknownImpl::QueryInterface(REFIID riid, void** ppvObject)
+{
+    if (ppvObject == NULL)
+        return E_POINTER;
+    if (riid == IID_IUnknown)
+    {
+        ++m_RefCount;
+        *ppvObject = this;
+        return S_OK;
+    }
+    *ppvObject = NULL;
+    return E_NOINTERFACE;
+}
+
+ULONG STDMETHODCALLTYPE IUnknownImpl::AddRef()
+{
+    return ++m_RefCount;
+}
+
+ULONG STDMETHODCALLTYPE IUnknownImpl::Release()
+{
+    D3D12MA_DEBUG_GLOBAL_MUTEX_LOCK
+
+    const uint32_t newRefCount = --m_RefCount;
+    if (newRefCount == 0)
+        ReleaseThis();
+    return newRefCount;
+}
+#endif // _D3D12MA_IUNKNOWN_IMPL_FUNCTIONS
+
+#ifndef _D3D12MA_ALLOCATION_FUNCTIONS
+void Allocation::PackedData::SetType(Type type)
+{
+    const UINT u = (UINT)type;
+    D3D12MA_ASSERT(u < (1u << 2));
+    m_Type = u;
+}
+
+void Allocation::PackedData::SetResourceDimension(D3D12_RESOURCE_DIMENSION resourceDimension)
+{
+    const UINT u = (UINT)resourceDimension;
+    D3D12MA_ASSERT(u < (1u << 3));
+    m_ResourceDimension = u;
+}
+
+void Allocation::PackedData::SetResourceFlags(D3D12_RESOURCE_FLAGS resourceFlags)
+{
+    const UINT u = (UINT)resourceFlags;
+    D3D12MA_ASSERT(u < (1u << 24));
+    m_ResourceFlags = u;
+}
+
+void Allocation::PackedData::SetTextureLayout(D3D12_TEXTURE_LAYOUT textureLayout)
+{
+    const UINT u = (UINT)textureLayout;
+    D3D12MA_ASSERT(u < (1u << 9));
+    m_TextureLayout = u;
+}
+
+UINT64 Allocation::GetOffset() const
+{
+    switch (m_PackedData.GetType())
+    {
+    case TYPE_COMMITTED:
+    case TYPE_HEAP:
+        return 0;
+    case TYPE_PLACED:
+        return m_Placed.block->m_pMetadata->GetAllocationOffset(m_Placed.allocHandle);
+    default:
+        D3D12MA_ASSERT(0);
+        return 0;
+    }
+}
+
+void Allocation::SetResource(ID3D12Resource* pResource)
+{
+    if (pResource != m_Resource)
+    {
+        if (m_Resource)
+            m_Resource->Release();
+        m_Resource = pResource;
+        if (m_Resource)
+            m_Resource->AddRef();
+    }
+}
+
+ID3D12Heap* Allocation::GetHeap() const
+{
+    switch (m_PackedData.GetType())
+    {
+    case TYPE_COMMITTED:
+        return NULL;
+    case TYPE_PLACED:
+        return m_Placed.block->GetHeap();
+    case TYPE_HEAP:
+        return m_Heap.heap;
+    default:
+        D3D12MA_ASSERT(0);
+        return 0;
+    }
+}
+
+void Allocation::SetName(LPCWSTR Name)
+{
+    FreeName();
+
+    if (Name)
+    {
+        const size_t nameCharCount = wcslen(Name) + 1;
+        m_Name = D3D12MA_NEW_ARRAY(m_Allocator->GetAllocs(), WCHAR, nameCharCount);
+        memcpy(m_Name, Name, nameCharCount * sizeof(WCHAR));
+    }
+}
+
+void Allocation::ReleaseThis()
+{
+    if (this == NULL)
+    {
+        return;
+    }
+
+    SAFE_RELEASE(m_Resource);
+
+    switch (m_PackedData.GetType())
+    {
+    case TYPE_COMMITTED:
+        m_Allocator->FreeCommittedMemory(this);
+        break;
+    case TYPE_PLACED:
+        m_Allocator->FreePlacedMemory(this);
+        break;
+    case TYPE_HEAP:
+        m_Allocator->FreeHeapMemory(this);
+        break;
+    }
+
+    FreeName();
+
+    m_Allocator->GetAllocationObjectAllocator().Free(this);
+}
+
+Allocation::Allocation(AllocatorPimpl* allocator, UINT64 size, UINT64 alignment, BOOL wasZeroInitialized)
+    : m_Allocator{ allocator },
+    m_Size{ size },
+    m_Alignment{ alignment },
+    m_Resource{ NULL },
+    m_pPrivateData{ NULL },
+    m_Name{ NULL }
+{
+    D3D12MA_ASSERT(allocator);
+
+    m_PackedData.SetType(TYPE_COUNT);
+    m_PackedData.SetResourceDimension(D3D12_RESOURCE_DIMENSION_UNKNOWN);
+    m_PackedData.SetResourceFlags(D3D12_RESOURCE_FLAG_NONE);
+    m_PackedData.SetTextureLayout(D3D12_TEXTURE_LAYOUT_UNKNOWN);
+    m_PackedData.SetWasZeroInitialized(wasZeroInitialized);
+}
+
+void Allocation::InitCommitted(CommittedAllocationList* list)
+{
+    m_PackedData.SetType(TYPE_COMMITTED);
+    m_Committed.list = list;
+    m_Committed.prev = NULL;
+    m_Committed.next = NULL;
+}
+
+void Allocation::InitPlaced(AllocHandle allocHandle, NormalBlock* block)
+{
+    m_PackedData.SetType(TYPE_PLACED);
+    m_Placed.allocHandle = allocHandle;
+    m_Placed.block = block;
+}
+
+void Allocation::InitHeap(CommittedAllocationList* list, ID3D12Heap* heap)
+{
+    m_PackedData.SetType(TYPE_HEAP);
+    m_Heap.list = list;
+    m_Committed.prev = NULL;
+    m_Committed.next = NULL;
+    m_Heap.heap = heap;
+}
+
+void Allocation::SwapBlockAllocation(Allocation* allocation)
+{
+    D3D12MA_ASSERT(allocation != NULL);
+    D3D12MA_ASSERT(m_PackedData.GetType() == TYPE_PLACED);
+    D3D12MA_ASSERT(allocation->m_PackedData.GetType() == TYPE_PLACED);
+
+    D3D12MA_SWAP(m_Resource, allocation->m_Resource);
+    m_PackedData.SetWasZeroInitialized(allocation->m_PackedData.WasZeroInitialized());
+    m_Placed.block->m_pMetadata->SetAllocationPrivateData(m_Placed.allocHandle, allocation);
+    D3D12MA_SWAP(m_Placed, allocation->m_Placed);
+    m_Placed.block->m_pMetadata->SetAllocationPrivateData(m_Placed.allocHandle, this);
+}
+
+AllocHandle Allocation::GetAllocHandle() const
+{
+    switch (m_PackedData.GetType())
+    {
+    case TYPE_COMMITTED:
+    case TYPE_HEAP:
+        return (AllocHandle)0;
+    case TYPE_PLACED:
+        return m_Placed.allocHandle;
+    default:
+        D3D12MA_ASSERT(0);
+        return (AllocHandle)0;
+    }
+}
+
+NormalBlock* Allocation::GetBlock()
+{
+    switch (m_PackedData.GetType())
+    {
+    case TYPE_COMMITTED:
+    case TYPE_HEAP:
+        return NULL;
+    case TYPE_PLACED:
+        return m_Placed.block;
+    default:
+        D3D12MA_ASSERT(0);
+        return NULL;
+    }
+}
+
+template<typename D3D12_RESOURCE_DESC_T>
+void Allocation::SetResourcePointer(ID3D12Resource* resource, const D3D12_RESOURCE_DESC_T* pResourceDesc)
+{
+    D3D12MA_ASSERT(m_Resource == NULL && pResourceDesc);
+    m_Resource = resource;
+    m_PackedData.SetResourceDimension(pResourceDesc->Dimension);
+    m_PackedData.SetResourceFlags(pResourceDesc->Flags);
+    m_PackedData.SetTextureLayout(pResourceDesc->Layout);
+}
+
+void Allocation::FreeName()
+{
+    if (m_Name)
+    {
+        const size_t nameCharCount = wcslen(m_Name) + 1;
+        D3D12MA_DELETE_ARRAY(m_Allocator->GetAllocs(), m_Name, nameCharCount);
+        m_Name = NULL;
+    }
+}
+#endif // _D3D12MA_ALLOCATION_FUNCTIONS
+
+#ifndef _D3D12MA_DEFRAGMENTATION_CONTEXT_FUNCTIONS
+HRESULT DefragmentationContext::BeginPass(DEFRAGMENTATION_PASS_MOVE_INFO* pPassInfo)
+{
+    D3D12MA_ASSERT(pPassInfo);
+    return m_Pimpl->DefragmentPassBegin(*pPassInfo);
+}
+
+HRESULT DefragmentationContext::EndPass(DEFRAGMENTATION_PASS_MOVE_INFO* pPassInfo)
+{
+    D3D12MA_ASSERT(pPassInfo);
+    return m_Pimpl->DefragmentPassEnd(*pPassInfo);
+}
+
+void DefragmentationContext::GetStats(DEFRAGMENTATION_STATS* pStats)
+{
+    D3D12MA_ASSERT(pStats);
+    m_Pimpl->GetStats(*pStats);
+}
+
+void DefragmentationContext::ReleaseThis()
+{
+    if (this == NULL)
+    {
+        return;
+    }
+
+    D3D12MA_DELETE(m_Pimpl->GetAllocs(), this);
+}
+
+DefragmentationContext::DefragmentationContext(AllocatorPimpl* allocator,
+    const DEFRAGMENTATION_DESC& desc,
+    BlockVector* poolVector)
+    : m_Pimpl(D3D12MA_NEW(allocator->GetAllocs(), DefragmentationContextPimpl)(allocator, desc, poolVector)) {}
+
+DefragmentationContext::~DefragmentationContext()
+{
+    D3D12MA_DELETE(m_Pimpl->GetAllocs(), m_Pimpl);
+}
+#endif // _D3D12MA_DEFRAGMENTATION_CONTEXT_FUNCTIONS
+
+#ifndef _D3D12MA_POOL_FUNCTIONS
+POOL_DESC Pool::GetDesc() const
+{
+    return m_Pimpl->GetDesc();
+}
+
+void Pool::GetStatistics(Statistics* pStats)
+{
+    D3D12MA_ASSERT(pStats);
+    D3D12MA_DEBUG_GLOBAL_MUTEX_LOCK
+    m_Pimpl->GetStatistics(*pStats);
+}
+
+void Pool::CalculateStatistics(DetailedStatistics* pStats)
+{
+    D3D12MA_ASSERT(pStats);
+    D3D12MA_DEBUG_GLOBAL_MUTEX_LOCK
+    m_Pimpl->CalculateStatistics(*pStats);
+}
+
+void Pool::SetName(LPCWSTR Name)
+{
+    D3D12MA_DEBUG_GLOBAL_MUTEX_LOCK
+    m_Pimpl->SetName(Name);
+}
+
+LPCWSTR Pool::GetName() const
+{
+    return m_Pimpl->GetName();
+}
+
+HRESULT Pool::BeginDefragmentation(const DEFRAGMENTATION_DESC* pDesc, DefragmentationContext** ppContext)
+{
+    D3D12MA_ASSERT(pDesc && ppContext);
+
+    // Check for support
+    if (m_Pimpl->GetBlockVector()->GetAlgorithm() & POOL_FLAG_ALGORITHM_LINEAR)
+        return E_NOINTERFACE;
+
+    AllocatorPimpl* allocator = m_Pimpl->GetAllocator();
+    *ppContext = D3D12MA_NEW(allocator->GetAllocs(), DefragmentationContext)(allocator, *pDesc, m_Pimpl->GetBlockVector());
+    return S_OK;
+}
+
+void Pool::ReleaseThis()
+{
+    if (this == NULL)
+    {
+        return;
+    }
+
+    D3D12MA_DELETE(m_Pimpl->GetAllocator()->GetAllocs(), this);
+}
+
+Pool::Pool(Allocator* allocator, const POOL_DESC& desc)
+    : m_Pimpl(D3D12MA_NEW(allocator->m_Pimpl->GetAllocs(), PoolPimpl)(allocator->m_Pimpl, desc)) {}
+
+Pool::~Pool()
+{
+    m_Pimpl->GetAllocator()->UnregisterPool(this, m_Pimpl->GetDesc().HeapProperties.Type);
+
+    D3D12MA_DELETE(m_Pimpl->GetAllocator()->GetAllocs(), m_Pimpl);
+}
+#endif // _D3D12MA_POOL_FUNCTIONS
+
+#ifndef _D3D12MA_ALLOCATOR_FUNCTIONS
+const D3D12_FEATURE_DATA_D3D12_OPTIONS& Allocator::GetD3D12Options() const
+{
+    return m_Pimpl->GetD3D12Options();
+}
+
+BOOL Allocator::IsUMA() const
+{
+    return m_Pimpl->IsUMA();
+}
+
+BOOL Allocator::IsCacheCoherentUMA() const
+{
+    return m_Pimpl->IsCacheCoherentUMA();
+}
+
+UINT64 Allocator::GetMemoryCapacity(UINT memorySegmentGroup) const
+{
+    return m_Pimpl->GetMemoryCapacity(memorySegmentGroup);
+}
+
+HRESULT Allocator::CreateResource(
+    const ALLOCATION_DESC* pAllocDesc,
+    const D3D12_RESOURCE_DESC* pResourceDesc,
+    D3D12_RESOURCE_STATES InitialResourceState,
+    const D3D12_CLEAR_VALUE* pOptimizedClearValue,
+    Allocation** ppAllocation,
+    REFIID riidResource,
+    void** ppvResource)
+{
+    if (!pAllocDesc || !pResourceDesc || !ppAllocation)
+    {
+        D3D12MA_ASSERT(0 && "Invalid arguments passed to Allocator::CreateResource.");
+        return E_INVALIDARG;
+    }
+    D3D12MA_DEBUG_GLOBAL_MUTEX_LOCK
+    return m_Pimpl->CreateResource(
+        pAllocDesc, 
+        CREATE_RESOURCE_PARAMS(pResourceDesc, InitialResourceState, pOptimizedClearValue), 
+        ppAllocation, 
+        riidResource, 
+        ppvResource);
+}
+
+#ifdef __ID3D12Device8_INTERFACE_DEFINED__
+HRESULT Allocator::CreateResource2(
+    const ALLOCATION_DESC* pAllocDesc,
+    const D3D12_RESOURCE_DESC1* pResourceDesc,
+    D3D12_RESOURCE_STATES InitialResourceState,
+    const D3D12_CLEAR_VALUE* pOptimizedClearValue,
+    Allocation** ppAllocation,
+    REFIID riidResource,
+    void** ppvResource)
+{
+    if (!pAllocDesc || !pResourceDesc || !ppAllocation)
+    {
+        D3D12MA_ASSERT(0 && "Invalid arguments passed to Allocator::CreateResource2.");
+        return E_INVALIDARG;
+    }
+    D3D12MA_DEBUG_GLOBAL_MUTEX_LOCK
+    return m_Pimpl->CreateResource(
+        pAllocDesc, 
+        CREATE_RESOURCE_PARAMS(pResourceDesc, InitialResourceState, pOptimizedClearValue), 
+        ppAllocation, 
+        riidResource, 
+        ppvResource);
+}
+#endif // #ifdef __ID3D12Device8_INTERFACE_DEFINED__
+
+#ifdef __ID3D12Device10_INTERFACE_DEFINED__
+HRESULT Allocator::CreateResource3(
+    const ALLOCATION_DESC* pAllocDesc,
+    const D3D12_RESOURCE_DESC1* pResourceDesc,
+    D3D12_BARRIER_LAYOUT InitialLayout,
+    const D3D12_CLEAR_VALUE* pOptimizedClearValue,
+    UINT32 NumCastableFormats,
+    DXGI_FORMAT* pCastableFormats,
+    Allocation** ppAllocation,
+    REFIID riidResource,
+    void** ppvResource)
+{
+    if (!pAllocDesc || !pResourceDesc || !ppAllocation)
+    {
+        D3D12MA_ASSERT(0 && "Invalid arguments passed to Allocator::CreateResource3.");
+        return E_INVALIDARG;
+    }
+    D3D12MA_DEBUG_GLOBAL_MUTEX_LOCK
+    return m_Pimpl->CreateResource(
+        pAllocDesc, 
+        CREATE_RESOURCE_PARAMS(pResourceDesc, InitialLayout, pOptimizedClearValue, NumCastableFormats, pCastableFormats), 
+        ppAllocation, 
+        riidResource, 
+        ppvResource);
+}
+#endif // #ifdef __ID3D12Device10_INTERFACE_DEFINED__
+
+HRESULT Allocator::AllocateMemory(
+    const ALLOCATION_DESC* pAllocDesc,
+    const D3D12_RESOURCE_ALLOCATION_INFO* pAllocInfo,
+    Allocation** ppAllocation)
+{
+    if (!ValidateAllocateMemoryParameters(pAllocDesc, pAllocInfo, ppAllocation))
+    {
+        D3D12MA_ASSERT(0 && "Invalid arguments passed to Allocator::AllocateMemory.");
+        return E_INVALIDARG;
+    }
+    D3D12MA_DEBUG_GLOBAL_MUTEX_LOCK
+        return m_Pimpl->AllocateMemory(pAllocDesc, pAllocInfo, ppAllocation);
+}
+
+HRESULT Allocator::CreateAliasingResource(
+    Allocation* pAllocation,
+    UINT64 AllocationLocalOffset,
+    const D3D12_RESOURCE_DESC* pResourceDesc,
+    D3D12_RESOURCE_STATES InitialResourceState,
+    const D3D12_CLEAR_VALUE* pOptimizedClearValue,
+    REFIID riidResource,
+    void** ppvResource)
+{
+    if (!pAllocation || !pResourceDesc || !ppvResource)
+    {
+        D3D12MA_ASSERT(0 && "Invalid arguments passed to Allocator::CreateAliasingResource.");
+        return E_INVALIDARG;
+    }
+    D3D12MA_DEBUG_GLOBAL_MUTEX_LOCK
+    return m_Pimpl->CreateAliasingResource(
+        pAllocation, 
+        AllocationLocalOffset, 
+        CREATE_RESOURCE_PARAMS(pResourceDesc, InitialResourceState, pOptimizedClearValue), 
+        riidResource, 
+        ppvResource);
+}
+
+#ifdef __ID3D12Device8_INTERFACE_DEFINED__
+HRESULT Allocator::CreateAliasingResource1(
+    Allocation* pAllocation,
+    UINT64 AllocationLocalOffset,
+    const D3D12_RESOURCE_DESC1* pResourceDesc,
+    D3D12_RESOURCE_STATES InitialResourceState,
+    const D3D12_CLEAR_VALUE* pOptimizedClearValue,
+    REFIID riidResource,
+    void** ppvResource)
+{
+    if (!pAllocation || !pResourceDesc || !ppvResource)
+    {
+        D3D12MA_ASSERT(0 && "Invalid arguments passed to Allocator::CreateAliasingResource.");
+        return E_INVALIDARG;
+    }
+    D3D12MA_DEBUG_GLOBAL_MUTEX_LOCK
+    return m_Pimpl->CreateAliasingResource(
+        pAllocation, 
+        AllocationLocalOffset, 
+        CREATE_RESOURCE_PARAMS(pResourceDesc, InitialResourceState, pOptimizedClearValue), 
+        riidResource, 
+        ppvResource);
+}
+#endif  // #ifdef __ID3D12Device8_INTERFACE_DEFINED__
+
+#ifdef __ID3D12Device10_INTERFACE_DEFINED__
+HRESULT Allocator::CreateAliasingResource2(
+    Allocation* pAllocation,
+    UINT64 AllocationLocalOffset,
+    const D3D12_RESOURCE_DESC1* pResourceDesc,
+    D3D12_BARRIER_LAYOUT InitialLayout,
+    const D3D12_CLEAR_VALUE* pOptimizedClearValue,
+    UINT32 NumCastableFormats,
+    DXGI_FORMAT* pCastableFormats,
+    REFIID riidResource,
+    void** ppvResource)
+{
+    if (!pAllocation || !pResourceDesc || !ppvResource)
+    {
+        D3D12MA_ASSERT(0 && "Invalid arguments passed to Allocator::CreateAliasingResource.");
+        return E_INVALIDARG;
+    }
+    D3D12MA_DEBUG_GLOBAL_MUTEX_LOCK
+    return m_Pimpl->CreateAliasingResource(
+        pAllocation, 
+        AllocationLocalOffset, 
+        CREATE_RESOURCE_PARAMS(pResourceDesc, InitialLayout, pOptimizedClearValue, NumCastableFormats, pCastableFormats),
+        riidResource, 
+        ppvResource);
+}
+#endif  // #ifdef __ID3D12Device10_INTERFACE_DEFINED__
+
+HRESULT Allocator::CreatePool(
+    const POOL_DESC* pPoolDesc,
+    Pool** ppPool)
+{
+    if (!pPoolDesc || !ppPool ||
+        (pPoolDesc->MaxBlockCount > 0 && pPoolDesc->MaxBlockCount < pPoolDesc->MinBlockCount) ||
+        (pPoolDesc->MinAllocationAlignment > 0 && !IsPow2(pPoolDesc->MinAllocationAlignment)))
+    {
+        D3D12MA_ASSERT(0 && "Invalid arguments passed to Allocator::CreatePool.");
+        return E_INVALIDARG;
+    }
+    if (!m_Pimpl->HeapFlagsFulfillResourceHeapTier(pPoolDesc->HeapFlags))
+    {
+        D3D12MA_ASSERT(0 && "Invalid pPoolDesc->HeapFlags passed to Allocator::CreatePool. Did you forget to handle ResourceHeapTier=1?");
+        return E_INVALIDARG;
+    }
+    D3D12MA_DEBUG_GLOBAL_MUTEX_LOCK
+    * ppPool = D3D12MA_NEW(m_Pimpl->GetAllocs(), Pool)(this, *pPoolDesc);
+    HRESULT hr = (*ppPool)->m_Pimpl->Init();
+    if (SUCCEEDED(hr))
+    {
+        m_Pimpl->RegisterPool(*ppPool, pPoolDesc->HeapProperties.Type);
+    }
+    else
+    {
+        D3D12MA_DELETE(m_Pimpl->GetAllocs(), *ppPool);
+        *ppPool = NULL;
+    }
+    return hr;
+}
+
+void Allocator::SetCurrentFrameIndex(UINT frameIndex)
+{
+    D3D12MA_DEBUG_GLOBAL_MUTEX_LOCK
+    m_Pimpl->SetCurrentFrameIndex(frameIndex);
+}
+
+void Allocator::GetBudget(Budget* pLocalBudget, Budget* pNonLocalBudget)
+{
+    if (pLocalBudget == NULL && pNonLocalBudget == NULL)
+    {
+        return;
+    }
+    D3D12MA_DEBUG_GLOBAL_MUTEX_LOCK
+    m_Pimpl->GetBudget(pLocalBudget, pNonLocalBudget);
+}
+
+void Allocator::CalculateStatistics(TotalStatistics* pStats)
+{
+    D3D12MA_ASSERT(pStats);
+    D3D12MA_DEBUG_GLOBAL_MUTEX_LOCK
+    m_Pimpl->CalculateStatistics(*pStats);
+}
+
+void Allocator::BuildStatsString(WCHAR** ppStatsString, BOOL DetailedMap) const
+{
+    D3D12MA_ASSERT(ppStatsString);
+    D3D12MA_DEBUG_GLOBAL_MUTEX_LOCK
+    m_Pimpl->BuildStatsString(ppStatsString, DetailedMap);
+}
+
+void Allocator::FreeStatsString(WCHAR* pStatsString) const
+{
+    if (pStatsString != NULL)
+    {
+        D3D12MA_DEBUG_GLOBAL_MUTEX_LOCK
+        m_Pimpl->FreeStatsString(pStatsString);
+    }
+}
+
+void Allocator::BeginDefragmentation(const DEFRAGMENTATION_DESC* pDesc, DefragmentationContext** ppContext)
+{
+    D3D12MA_ASSERT(pDesc && ppContext);
+
+    *ppContext = D3D12MA_NEW(m_Pimpl->GetAllocs(), DefragmentationContext)(m_Pimpl, *pDesc, NULL);
+}
+
+void Allocator::ReleaseThis()
+{
+    // Copy is needed because otherwise we would call destructor and invalidate the structure with callbacks before using it to free memory.
+    const ALLOCATION_CALLBACKS allocationCallbacksCopy = m_Pimpl->GetAllocs();
+    D3D12MA_DELETE(allocationCallbacksCopy, this);
+}
+
+Allocator::Allocator(const ALLOCATION_CALLBACKS& allocationCallbacks, const ALLOCATOR_DESC& desc)
+    : m_Pimpl(D3D12MA_NEW(allocationCallbacks, AllocatorPimpl)(allocationCallbacks, desc)) {}
+
+Allocator::~Allocator()
+{
+    D3D12MA_DELETE(m_Pimpl->GetAllocs(), m_Pimpl);
+}
+#endif // _D3D12MA_ALLOCATOR_FUNCTIONS
+
+#ifndef _D3D12MA_VIRTUAL_BLOCK_FUNCTIONS
+BOOL VirtualBlock::IsEmpty() const
+{
+    D3D12MA_DEBUG_GLOBAL_MUTEX_LOCK
+    return m_Pimpl->m_Metadata->IsEmpty() ? TRUE : FALSE;
+}
+
+void VirtualBlock::GetAllocationInfo(VirtualAllocation allocation, VIRTUAL_ALLOCATION_INFO* pInfo) const
+{
+    D3D12MA_ASSERT(allocation.AllocHandle != (AllocHandle)0 && pInfo);
+
+    D3D12MA_DEBUG_GLOBAL_MUTEX_LOCK
+    m_Pimpl->m_Metadata->GetAllocationInfo(allocation.AllocHandle, *pInfo);
+}
+
+HRESULT VirtualBlock::Allocate(const VIRTUAL_ALLOCATION_DESC* pDesc, VirtualAllocation* pAllocation, UINT64* pOffset)
+{
+    if (!pDesc || !pAllocation || pDesc->Size == 0 || !IsPow2(pDesc->Alignment))
+    {
+        D3D12MA_ASSERT(0 && "Invalid arguments passed to VirtualBlock::Allocate.");
+        return E_INVALIDARG;
+    }
+
+    D3D12MA_DEBUG_GLOBAL_MUTEX_LOCK
+
+    const UINT64 alignment = pDesc->Alignment != 0 ? pDesc->Alignment : 1;
+    AllocationRequest allocRequest = {};
+    if (m_Pimpl->m_Metadata->CreateAllocationRequest(
+        pDesc->Size,
+        alignment,
+        pDesc->Flags & VIRTUAL_ALLOCATION_FLAG_UPPER_ADDRESS,
+        pDesc->Flags & VIRTUAL_ALLOCATION_FLAG_STRATEGY_MASK,
+        &allocRequest))
+    {
+        m_Pimpl->m_Metadata->Alloc(allocRequest, pDesc->Size, pDesc->pPrivateData);
+        D3D12MA_HEAVY_ASSERT(m_Pimpl->m_Metadata->Validate());
+        pAllocation->AllocHandle = allocRequest.allocHandle;
+
+        if (pOffset)
+            *pOffset = m_Pimpl->m_Metadata->GetAllocationOffset(allocRequest.allocHandle);
+        return S_OK;
+    }
+
+    pAllocation->AllocHandle = (AllocHandle)0;
+    if (pOffset)
+        *pOffset = UINT64_MAX;
+
+    return E_OUTOFMEMORY;
+}
+
+void VirtualBlock::FreeAllocation(VirtualAllocation allocation)
+{
+    if (allocation.AllocHandle == (AllocHandle)0)
+        return;
+
+    D3D12MA_DEBUG_GLOBAL_MUTEX_LOCK
+
+    m_Pimpl->m_Metadata->Free(allocation.AllocHandle);
+    D3D12MA_HEAVY_ASSERT(m_Pimpl->m_Metadata->Validate());
+}
+
+void VirtualBlock::Clear()
+{
+    D3D12MA_DEBUG_GLOBAL_MUTEX_LOCK
+
+    m_Pimpl->m_Metadata->Clear();
+    D3D12MA_HEAVY_ASSERT(m_Pimpl->m_Metadata->Validate());
+}
+
+void VirtualBlock::SetAllocationPrivateData(VirtualAllocation allocation, void* pPrivateData)
+{
+    D3D12MA_ASSERT(allocation.AllocHandle != (AllocHandle)0);
+
+    D3D12MA_DEBUG_GLOBAL_MUTEX_LOCK
+    m_Pimpl->m_Metadata->SetAllocationPrivateData(allocation.AllocHandle, pPrivateData);
+}
+
+void VirtualBlock::GetStatistics(Statistics* pStats) const
+{
+    D3D12MA_ASSERT(pStats);
+    D3D12MA_DEBUG_GLOBAL_MUTEX_LOCK
+    D3D12MA_HEAVY_ASSERT(m_Pimpl->m_Metadata->Validate());
+    ClearStatistics(*pStats);
+    m_Pimpl->m_Metadata->AddStatistics(*pStats);
+}
+
+void VirtualBlock::CalculateStatistics(DetailedStatistics* pStats) const
+{
+    D3D12MA_ASSERT(pStats);
+    D3D12MA_DEBUG_GLOBAL_MUTEX_LOCK
+    D3D12MA_HEAVY_ASSERT(m_Pimpl->m_Metadata->Validate());
+    ClearDetailedStatistics(*pStats);
+    m_Pimpl->m_Metadata->AddDetailedStatistics(*pStats);
+}
+
+void VirtualBlock::BuildStatsString(WCHAR** ppStatsString) const
+{
+    D3D12MA_ASSERT(ppStatsString);
+
+    D3D12MA_DEBUG_GLOBAL_MUTEX_LOCK
+
+    StringBuilder sb(m_Pimpl->m_AllocationCallbacks);
+    {
+        JsonWriter json(m_Pimpl->m_AllocationCallbacks, sb);
+        D3D12MA_HEAVY_ASSERT(m_Pimpl->m_Metadata->Validate());
+        json.BeginObject();
+        m_Pimpl->m_Metadata->WriteAllocationInfoToJson(json);
+        json.EndObject();
+    } // Scope for JsonWriter
+
+    const size_t length = sb.GetLength();
+    WCHAR* result = AllocateArray<WCHAR>(m_Pimpl->m_AllocationCallbacks, length + 1);
+    memcpy(result, sb.GetData(), length * sizeof(WCHAR));
+    result[length] = L'\0';
+    *ppStatsString = result;
+}
+
+void VirtualBlock::FreeStatsString(WCHAR* pStatsString) const
+{
+    if (pStatsString != NULL)
+    {
+        D3D12MA_DEBUG_GLOBAL_MUTEX_LOCK
+        D3D12MA::Free(m_Pimpl->m_AllocationCallbacks, pStatsString);
+    }
+}
+
+void VirtualBlock::ReleaseThis()
+{
+    // Copy is needed because otherwise we would call destructor and invalidate the structure with callbacks before using it to free memory.
+    const ALLOCATION_CALLBACKS allocationCallbacksCopy = m_Pimpl->m_AllocationCallbacks;
+    D3D12MA_DELETE(allocationCallbacksCopy, this);
+}
+
+VirtualBlock::VirtualBlock(const ALLOCATION_CALLBACKS& allocationCallbacks, const VIRTUAL_BLOCK_DESC& desc)
+    : m_Pimpl(D3D12MA_NEW(allocationCallbacks, VirtualBlockPimpl)(allocationCallbacks, desc)) {}
+
+VirtualBlock::~VirtualBlock()
+{
+    // THIS IS AN IMPORTANT ASSERT!
+    // Hitting it means you have some memory leak - unreleased allocations in this virtual block.
+    D3D12MA_ASSERT(m_Pimpl->m_Metadata->IsEmpty() && "Some allocations were not freed before destruction of this virtual block!");
+
+    D3D12MA_DELETE(m_Pimpl->m_AllocationCallbacks, m_Pimpl);
+}
+#endif // _D3D12MA_VIRTUAL_BLOCK_FUNCTIONS
+#endif // _D3D12MA_PUBLIC_INTERFACE
+} // namespace D3D12MA
diff --git a/thirdparty/d3d12ma/D3D12MemAlloc.h b/thirdparty/d3d12ma/D3D12MemAlloc.h
new file mode 100644
index 0000000000..4ab7be318e
--- /dev/null
+++ b/thirdparty/d3d12ma/D3D12MemAlloc.h
@@ -0,0 +1,2632 @@
+//
+// Copyright (c) 2019-2022 Advanced Micro Devices, Inc. All rights reserved.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// 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.  IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+//
+
+#pragma once
+
+/** \mainpage D3D12 Memory Allocator
+
+<b>Version 2.1.0-development</b> (2022-12-15)
+
+Copyright (c) 2019-2022 Advanced Micro Devices, Inc. All rights reserved. \n
+License: MIT
+
+Documentation of all members: D3D12MemAlloc.h
+
+\section main_table_of_contents Table of contents
+
+- \subpage quick_start
+    - [Project setup](@ref quick_start_project_setup)
+    - [Creating resources](@ref quick_start_creating_resources)
+    - [Resource reference counting](@ref quick_start_resource_reference_counting)
+    - [Mapping memory](@ref quick_start_mapping_memory)
+- \subpage custom_pools
+- \subpage defragmentation
+- \subpage statistics
+- \subpage resource_aliasing
+- \subpage linear_algorithm
+- \subpage virtual_allocator
+- \subpage configuration
+  - [Custom CPU memory allocator](@ref custom_memory_allocator)
+  - [Debug margins](@ref debug_margins)
+- \subpage general_considerations
+  - [Thread safety](@ref general_considerations_thread_safety)
+  - [Versioning and compatibility](@ref general_considerations_versioning_and_compatibility)
+  - [Features not supported](@ref general_considerations_features_not_supported)
+        
+\section main_see_also See also
+
+- [Product page on GPUOpen](https://gpuopen.com/gaming-product/d3d12-memory-allocator/)
+- [Source repository on GitHub](https://github.com/GPUOpen-LibrariesAndSDKs/D3D12MemoryAllocator)
+*/
+
+// If using this library on a platform different than Windows PC or want to use different version of DXGI,
+// you should include D3D12-compatible headers before this library on your own and define this macro.
+#ifndef D3D12MA_D3D12_HEADERS_ALREADY_INCLUDED
+    #include <d3d12.h>
+    #include <dxgi1_4.h>
+#endif
+
+// Define this macro to 0 to disable usage of DXGI 1.4 (needed for IDXGIAdapter3 and query for memory budget).
+#ifndef D3D12MA_DXGI_1_4
+    #ifdef __IDXGIAdapter3_INTERFACE_DEFINED__
+        #define D3D12MA_DXGI_1_4 1
+    #else
+        #define D3D12MA_DXGI_1_4 0
+    #endif
+#endif
+
+/*
+When defined to value other than 0, the library will try to use
+D3D12_SMALL_RESOURCE_PLACEMENT_ALIGNMENT or D3D12_SMALL_MSAA_RESOURCE_PLACEMENT_ALIGNMENT
+for created textures when possible, which can save memory because some small textures
+may get their alignment 4K and their size a multiply of 4K instead of 64K.
+
+#define D3D12MA_USE_SMALL_RESOURCE_PLACEMENT_ALIGNMENT 0
+    Disables small texture alignment.
+#define D3D12MA_USE_SMALL_RESOURCE_PLACEMENT_ALIGNMENT 1
+    Enables conservative algorithm that will use small alignment only for some textures
+    that are surely known to support it.
+#define D3D12MA_USE_SMALL_RESOURCE_PLACEMENT_ALIGNMENT 2
+    Enables query for small alignment to D3D12 (based on Microsoft sample) which will
+    enable small alignment for more textures, but will also generate D3D Debug Layer
+    error #721 on call to ID3D12Device::GetResourceAllocationInfo, which you should just
+    ignore.
+*/
+#ifndef D3D12MA_USE_SMALL_RESOURCE_PLACEMENT_ALIGNMENT
+    #define D3D12MA_USE_SMALL_RESOURCE_PLACEMENT_ALIGNMENT 1
+#endif
+
+/// \cond INTERNAL
+
+#define D3D12MA_CLASS_NO_COPY(className) \
+    private: \
+        className(const className&) = delete; \
+        className(className&&) = delete; \
+        className& operator=(const className&) = delete; \
+        className& operator=(className&&) = delete;
+
+// To be used with MAKE_HRESULT to define custom error codes.
+#define FACILITY_D3D12MA 3542
+
+/*
+If providing your own implementation, you need to implement a subset of std::atomic.
+*/
+#if !defined(D3D12MA_ATOMIC_UINT32) || !defined(D3D12MA_ATOMIC_UINT64)
+    #include <atomic>
+#endif
+
+#ifndef D3D12MA_ATOMIC_UINT32
+    #define D3D12MA_ATOMIC_UINT32 std::atomic<UINT>
+#endif
+
+#ifndef D3D12MA_ATOMIC_UINT64
+    #define D3D12MA_ATOMIC_UINT64 std::atomic<UINT64>
+#endif
+
+#ifdef D3D12MA_EXPORTS
+    #define D3D12MA_API __declspec(dllexport)
+#elif defined(D3D12MA_IMPORTS)
+    #define D3D12MA_API __declspec(dllimport)
+#else
+    #define D3D12MA_API
+#endif
+
+// Forward declaration if ID3D12ProtectedResourceSession is not defined inside the headers (older SDK, pre ID3D12Device4)
+struct ID3D12ProtectedResourceSession;
+
+// Define this enum even if SDK doesn't provide it, to simplify the API.
+#ifndef __ID3D12Device1_INTERFACE_DEFINED__
+typedef enum D3D12_RESIDENCY_PRIORITY
+{
+    D3D12_RESIDENCY_PRIORITY_MINIMUM = 0x28000000,
+    D3D12_RESIDENCY_PRIORITY_LOW = 0x50000000,
+    D3D12_RESIDENCY_PRIORITY_NORMAL = 0x78000000,
+    D3D12_RESIDENCY_PRIORITY_HIGH = 0xa0010000,
+    D3D12_RESIDENCY_PRIORITY_MAXIMUM = 0xc8000000
+} D3D12_RESIDENCY_PRIORITY;
+#endif
+
+namespace D3D12MA
+{
+class D3D12MA_API IUnknownImpl : public IUnknown
+{
+public:
+    virtual ~IUnknownImpl() = default;
+    virtual HRESULT STDMETHODCALLTYPE QueryInterface(REFIID riid, void** ppvObject);
+    virtual ULONG STDMETHODCALLTYPE AddRef();
+    virtual ULONG STDMETHODCALLTYPE Release();
+protected:
+    virtual void ReleaseThis() { delete this; }
+private:
+    D3D12MA_ATOMIC_UINT32 m_RefCount = {1};
+};
+} // namespace D3D12MA
+
+/// \endcond
+
+namespace D3D12MA
+{
+
+/// \cond INTERNAL
+class DefragmentationContextPimpl;
+class AllocatorPimpl;
+class PoolPimpl;
+class NormalBlock;
+class BlockVector;
+class CommittedAllocationList;
+class JsonWriter;
+class VirtualBlockPimpl;
+/// \endcond
+
+class Pool;
+class Allocator;
+struct Statistics;
+struct DetailedStatistics;
+struct TotalStatistics;
+
+/// \brief Unique identifier of single allocation done inside the memory heap.
+typedef UINT64 AllocHandle;
+
+/// Pointer to custom callback function that allocates CPU memory.
+using ALLOCATE_FUNC_PTR = void* (*)(size_t Size, size_t Alignment, void* pPrivateData);
+/**
+\brief Pointer to custom callback function that deallocates CPU memory.
+
+`pMemory = null` should be accepted and ignored.
+*/
+using FREE_FUNC_PTR = void (*)(void* pMemory, void* pPrivateData);
+
+/// Custom callbacks to CPU memory allocation functions.
+struct ALLOCATION_CALLBACKS
+{
+    /// %Allocation function.
+    ALLOCATE_FUNC_PTR pAllocate;
+    /// Dellocation function.
+    FREE_FUNC_PTR pFree;
+    /// Custom data that will be passed to allocation and deallocation functions as `pUserData` parameter.
+    void* pPrivateData;
+};
+
+
+/// \brief Bit flags to be used with ALLOCATION_DESC::Flags.
+enum ALLOCATION_FLAGS
+{
+    /// Zero
+    ALLOCATION_FLAG_NONE = 0,
+
+    /**
+    Set this flag if the allocation should have its own dedicated memory allocation (committed resource with implicit heap).
+    
+    Use it for special, big resources, like fullscreen textures used as render targets.
+
+    - When used with functions like D3D12MA::Allocator::CreateResource, it will use `ID3D12Device::CreateCommittedResource`,
+      so the created allocation will contain a resource (D3D12MA::Allocation::GetResource() `!= NULL`) but will not have
+      a heap (D3D12MA::Allocation::GetHeap() `== NULL`), as the heap is implicit.
+    - When used with raw memory allocation like D3D12MA::Allocator::AllocateMemory, it will use `ID3D12Device::CreateHeap`,
+      so the created allocation will contain a heap (D3D12MA::Allocation::GetHeap() `!= NULL`) and its offset will always be 0.
+    */
+    ALLOCATION_FLAG_COMMITTED = 0x1,
+
+    /**
+    Set this flag to only try to allocate from existing memory heaps and never create new such heap.
+
+    If new allocation cannot be placed in any of the existing heaps, allocation
+    fails with `E_OUTOFMEMORY` error.
+
+    You should not use D3D12MA::ALLOCATION_FLAG_COMMITTED and
+    D3D12MA::ALLOCATION_FLAG_NEVER_ALLOCATE at the same time. It makes no sense.
+    */
+    ALLOCATION_FLAG_NEVER_ALLOCATE = 0x2,
+
+    /** Create allocation only if additional memory required for it, if any, won't exceed
+    memory budget. Otherwise return `E_OUTOFMEMORY`.
+    */
+    ALLOCATION_FLAG_WITHIN_BUDGET = 0x4,
+
+    /** Allocation will be created from upper stack in a double stack pool.
+
+    This flag is only allowed for custom pools created with #POOL_FLAG_ALGORITHM_LINEAR flag.
+    */
+    ALLOCATION_FLAG_UPPER_ADDRESS = 0x8,
+
+    /** Set this flag if the allocated memory will have aliasing resources.
+    
+    Use this when calling D3D12MA::Allocator::CreateResource() and similar to
+    guarantee creation of explicit heap for desired allocation and prevent it from using `CreateCommittedResource`,
+    so that new allocation object will always have `allocation->GetHeap() != NULL`.
+    */
+    ALLOCATION_FLAG_CAN_ALIAS = 0x10,
+
+    /** Allocation strategy that chooses smallest possible free range for the allocation
+    to minimize memory usage and fragmentation, possibly at the expense of allocation time.
+    */
+    ALLOCATION_FLAG_STRATEGY_MIN_MEMORY = 0x00010000,
+
+    /** Allocation strategy that chooses first suitable free range for the allocation -
+    not necessarily in terms of the smallest offset but the one that is easiest and fastest to find
+    to minimize allocation time, possibly at the expense of allocation quality.
+    */
+    ALLOCATION_FLAG_STRATEGY_MIN_TIME = 0x00020000,
+
+    /** Allocation strategy that chooses always the lowest offset in available space.
+    This is not the most efficient strategy but achieves highly packed data.
+    Used internally by defragmentation, not recomended in typical usage.
+    */
+    ALLOCATION_FLAG_STRATEGY_MIN_OFFSET = 0x0004000,
+
+    /// Alias to #ALLOCATION_FLAG_STRATEGY_MIN_MEMORY.
+    ALLOCATION_FLAG_STRATEGY_BEST_FIT = ALLOCATION_FLAG_STRATEGY_MIN_MEMORY,
+    /// Alias to #ALLOCATION_FLAG_STRATEGY_MIN_TIME.
+    ALLOCATION_FLAG_STRATEGY_FIRST_FIT = ALLOCATION_FLAG_STRATEGY_MIN_TIME,
+
+    /// A bit mask to extract only `STRATEGY` bits from entire set of flags.
+    ALLOCATION_FLAG_STRATEGY_MASK =
+        ALLOCATION_FLAG_STRATEGY_MIN_MEMORY |
+        ALLOCATION_FLAG_STRATEGY_MIN_TIME |
+        ALLOCATION_FLAG_STRATEGY_MIN_OFFSET,
+};
+
+/// \brief Parameters of created D3D12MA::Allocation object. To be used with Allocator::CreateResource.
+struct ALLOCATION_DESC
+{
+    /// Flags.
+    ALLOCATION_FLAGS Flags;
+    /** \brief The type of memory heap where the new allocation should be placed.
+
+    It must be one of: `D3D12_HEAP_TYPE_DEFAULT`, `D3D12_HEAP_TYPE_UPLOAD`, `D3D12_HEAP_TYPE_READBACK`.
+
+    When D3D12MA::ALLOCATION_DESC::CustomPool != NULL this member is ignored.
+    */
+    D3D12_HEAP_TYPE HeapType;
+    /** \brief Additional heap flags to be used when allocating memory.
+
+    In most cases it can be 0.
+    
+    - If you use D3D12MA::Allocator::CreateResource(), you don't need to care.
+      Necessary flag `D3D12_HEAP_FLAG_ALLOW_ONLY_BUFFERS`, `D3D12_HEAP_FLAG_ALLOW_ONLY_NON_RT_DS_TEXTURES`,
+      or `D3D12_HEAP_FLAG_ALLOW_ONLY_RT_DS_TEXTURES` is added automatically.
+    - If you use D3D12MA::Allocator::AllocateMemory(), you should specify one of those `ALLOW_ONLY` flags.
+      Except when you validate that D3D12MA::Allocator::GetD3D12Options()`.ResourceHeapTier == D3D12_RESOURCE_HEAP_TIER_1` -
+      then you can leave it 0.
+    - You can specify additional flags if needed. Then the memory will always be allocated as
+      separate block using `D3D12Device::CreateCommittedResource` or `CreateHeap`, not as part of an existing larget block.
+
+    When D3D12MA::ALLOCATION_DESC::CustomPool != NULL this member is ignored.
+    */
+    D3D12_HEAP_FLAGS ExtraHeapFlags;
+    /** \brief Custom pool to place the new resource in. Optional.
+
+    When not NULL, the resource will be created inside specified custom pool.
+    */
+    Pool* CustomPool;
+    /// Custom general-purpose pointer that will be stored in D3D12MA::Allocation.
+    void* pPrivateData;
+};
+
+/** \brief Calculated statistics of memory usage e.g. in a specific memory heap type,
+memory segment group, custom pool, or total.
+
+These are fast to calculate.
+See functions: D3D12MA::Allocator::GetBudget(), D3D12MA::Pool::GetStatistics().
+*/
+struct Statistics
+{
+    /** \brief Number of D3D12 memory blocks allocated - `ID3D12Heap` objects and committed resources.
+    */
+    UINT BlockCount;
+    /** \brief Number of D3D12MA::Allocation objects allocated.
+
+    Committed allocations have their own blocks, so each one adds 1 to `AllocationCount` as well as `BlockCount`.
+    */
+    UINT AllocationCount;
+    /** \brief Number of bytes allocated in memory blocks.
+    */
+    UINT64 BlockBytes;
+    /** \brief Total number of bytes occupied by all D3D12MA::Allocation objects.
+
+    Always less or equal than `BlockBytes`.
+    Difference `(BlockBytes - AllocationBytes)` is the amount of memory allocated from D3D12
+    but unused by any D3D12MA::Allocation.
+    */
+    UINT64 AllocationBytes;
+};
+
+/** \brief More detailed statistics than D3D12MA::Statistics.
+
+These are slower to calculate. Use for debugging purposes.
+See functions: D3D12MA::Allocator::CalculateStatistics(), D3D12MA::Pool::CalculateStatistics().
+
+Averages are not provided because they can be easily calculated as:
+
+\code
+UINT64 AllocationSizeAvg = DetailedStats.Statistics.AllocationBytes / detailedStats.Statistics.AllocationCount;
+UINT64 UnusedBytes = DetailedStats.Statistics.BlockBytes - DetailedStats.Statistics.AllocationBytes;
+UINT64 UnusedRangeSizeAvg = UnusedBytes / DetailedStats.UnusedRangeCount;
+\endcode
+*/
+struct DetailedStatistics
+{
+    /// Basic statistics.
+    Statistics Stats;
+    /// Number of free ranges of memory between allocations.
+    UINT UnusedRangeCount;
+    /// Smallest allocation size. `UINT64_MAX` if there are 0 allocations.
+    UINT64 AllocationSizeMin;
+    /// Largest allocation size. 0 if there are 0 allocations.
+    UINT64 AllocationSizeMax;
+    /// Smallest empty range size. `UINT64_MAX` if there are 0 empty ranges.
+    UINT64 UnusedRangeSizeMin;
+    /// Largest empty range size. 0 if there are 0 empty ranges.
+    UINT64 UnusedRangeSizeMax;
+};
+
+/** \brief  General statistics from current state of the allocator -
+total memory usage across all memory heaps and segments.
+
+These are slower to calculate. Use for debugging purposes.
+See function D3D12MA::Allocator::CalculateStatistics().
+*/
+struct TotalStatistics
+{
+    /** \brief One element for each type of heap located at the following indices:
+
+    - 0 = `D3D12_HEAP_TYPE_DEFAULT`
+    - 1 = `D3D12_HEAP_TYPE_UPLOAD`
+    - 2 = `D3D12_HEAP_TYPE_READBACK`
+    - 3 = `D3D12_HEAP_TYPE_CUSTOM`
+    */
+    DetailedStatistics HeapType[4];
+    /** \brief One element for each memory segment group located at the following indices:
+
+    - 0 = `DXGI_MEMORY_SEGMENT_GROUP_LOCAL`
+    - 1 = `DXGI_MEMORY_SEGMENT_GROUP_NON_LOCAL`
+
+    Meaning of these segment groups is:
+
+    - When `IsUMA() == FALSE` (discrete graphics card):
+      - `DXGI_MEMORY_SEGMENT_GROUP_LOCAL` (index 0) represents GPU memory
+      (resources allocated in `D3D12_HEAP_TYPE_DEFAULT` or `D3D12_MEMORY_POOL_L1`).
+      - `DXGI_MEMORY_SEGMENT_GROUP_NON_LOCAL` (index 1) represents system memory
+      (resources allocated in `D3D12_HEAP_TYPE_UPLOAD`, `D3D12_HEAP_TYPE_READBACK`, or `D3D12_MEMORY_POOL_L0`).
+    - When `IsUMA() == TRUE` (integrated graphics chip):
+      - `DXGI_MEMORY_SEGMENT_GROUP_LOCAL` = (index 0) represents memory shared for all the resources.
+      - `DXGI_MEMORY_SEGMENT_GROUP_NON_LOCAL` = (index 1) is unused and always 0.
+    */
+    DetailedStatistics MemorySegmentGroup[2];
+    /// Total statistics from all memory allocated from D3D12.
+    DetailedStatistics Total;
+};
+
+/** \brief %Statistics of current memory usage and available budget for a specific memory segment group.
+
+These are fast to calculate. See function D3D12MA::Allocator::GetBudget().
+*/
+struct Budget
+{
+    /** \brief %Statistics fetched from the library.
+    */
+    Statistics Stats;
+    /** \brief Estimated current memory usage of the program.
+
+    Fetched from system using `IDXGIAdapter3::QueryVideoMemoryInfo` if possible.
+
+    It might be different than `BlockBytes` (usually higher) due to additional implicit objects
+    also occupying the memory, like swapchain, pipeline state objects, descriptor heaps, command lists, or
+    heaps and resources allocated outside of this library, if any.
+    */
+    UINT64 UsageBytes;
+    /** \brief Estimated amount of memory available to the program.
+
+    Fetched from system using `IDXGIAdapter3::QueryVideoMemoryInfo` if possible.
+
+    It might be different (most probably smaller) than memory capacity returned
+    by D3D12MA::Allocator::GetMemoryCapacity() due to factors
+    external to the program, decided by the operating system.
+    Difference `BudgetBytes - UsageBytes` is the amount of additional memory that can probably
+    be allocated without problems. Exceeding the budget may result in various problems.
+    */
+    UINT64 BudgetBytes;
+};
+
+
+/// \brief Represents single memory allocation done inside VirtualBlock.
+struct D3D12MA_API VirtualAllocation
+{
+    /// \brief Unique idenitfier of current allocation. 0 means null/invalid.
+    AllocHandle AllocHandle;
+};
+
+/** \brief Represents single memory allocation.
+
+It may be either implicit memory heap dedicated to a single resource or a
+specific region of a bigger heap plus unique offset.
+
+To create such object, fill structure D3D12MA::ALLOCATION_DESC and call function
+Allocator::CreateResource.
+
+The object remembers size and some other information.
+To retrieve this information, use methods of this class.
+
+The object also remembers `ID3D12Resource` and "owns" a reference to it,
+so it calls `%Release()` on the resource when destroyed.
+*/
+class D3D12MA_API Allocation : public IUnknownImpl
+{
+public:
+    /** \brief Returns offset in bytes from the start of memory heap.
+
+    You usually don't need to use this offset. If you create a buffer or a texture together with the allocation using function
+    D3D12MA::Allocator::CreateResource, functions that operate on that resource refer to the beginning of the resource,
+    not entire memory heap.
+
+    If the Allocation represents committed resource with implicit heap, returns 0.
+    */
+    UINT64 GetOffset() const;
+
+    /// Returns alignment that resource was created with.
+    UINT64 GetAlignment() const { return m_Alignment; }
+
+    /** \brief Returns size in bytes of the allocation.
+
+    - If you created a buffer or a texture together with the allocation using function D3D12MA::Allocator::CreateResource,
+      this is the size of the resource returned by `ID3D12Device::GetResourceAllocationInfo`.
+    - For allocations made out of bigger memory blocks, this also is the size of the memory region assigned exclusively to this allocation.
+    - For resources created as committed, this value may not be accurate. DirectX implementation may optimize memory usage internally
+      so that you may even observe regions of `ID3D12Resource::GetGPUVirtualAddress()` + Allocation::GetSize() to overlap in memory and still work correctly.
+    */
+    UINT64 GetSize() const { return m_Size; }
+
+    /** \brief Returns D3D12 resource associated with this object.
+
+    Calling this method doesn't increment resource's reference counter.
+    */
+    ID3D12Resource* GetResource() const { return m_Resource; }
+
+    /// Releases the resource currently pointed by the allocation (if any), sets it to new one, incrementing its reference counter (if not null).
+    void SetResource(ID3D12Resource* pResource);
+
+    /** \brief Returns memory heap that the resource is created in.
+
+    If the Allocation represents committed resource with implicit heap, returns NULL.
+    */
+    ID3D12Heap* GetHeap() const;
+
+    /// Changes custom pointer for an allocation to a new value.
+    void SetPrivateData(void* pPrivateData) { m_pPrivateData = pPrivateData; }
+
+    /// Get custom pointer associated with the allocation.
+    void* GetPrivateData() const { return m_pPrivateData; }
+
+    /** \brief Associates a name with the allocation object. This name is for use in debug diagnostics and tools.
+
+    Internal copy of the string is made, so the memory pointed by the argument can be
+    changed of freed immediately after this call.
+
+    `Name` can be null.
+    */
+    void SetName(LPCWSTR Name);
+
+    /** \brief Returns the name associated with the allocation object.
+
+    Returned string points to an internal copy.
+
+    If no name was associated with the allocation, returns null.
+    */
+    LPCWSTR GetName() const { return m_Name; }
+
+    /** \brief Returns `TRUE` if the memory of the allocation was filled with zeros when the allocation was created.
+
+    Returns `TRUE` only if the allocator is sure that the entire memory where the
+    allocation was created was filled with zeros at the moment the allocation was made.
+    
+    Returns `FALSE` if the memory could potentially contain garbage data.
+    If it's a render-target or depth-stencil texture, it then needs proper
+    initialization with `ClearRenderTargetView`, `ClearDepthStencilView`, `DiscardResource`,
+    or a copy operation, as described on page
+    "ID3D12Device::CreatePlacedResource method - Notes on the required resource initialization" in Microsoft documentation.
+    Please note that rendering a fullscreen triangle or quad to the texture as
+    a render target is not a proper way of initialization!
+
+    See also articles:
+
+    - "Coming to DirectX 12: More control over memory allocation" on DirectX Developer Blog
+    - ["Initializing DX12 Textures After Allocation and Aliasing"](https://asawicki.info/news_1724_initializing_dx12_textures_after_allocation_and_aliasing).
+    */
+    BOOL WasZeroInitialized() const { return m_PackedData.WasZeroInitialized(); }
+
+protected:
+    void ReleaseThis() override;
+
+private:
+    friend class AllocatorPimpl;
+    friend class BlockVector;
+    friend class CommittedAllocationList;
+    friend class JsonWriter;
+    friend class BlockMetadata_Linear;
+    friend class DefragmentationContextPimpl;
+    friend struct CommittedAllocationListItemTraits;
+    template<typename T> friend void D3D12MA_DELETE(const ALLOCATION_CALLBACKS&, T*);
+    template<typename T> friend class PoolAllocator;
+
+    enum Type
+    {
+        TYPE_COMMITTED,
+        TYPE_PLACED,
+        TYPE_HEAP,
+        TYPE_COUNT
+    };
+
+    AllocatorPimpl* m_Allocator;
+    UINT64 m_Size;
+    UINT64 m_Alignment;
+    ID3D12Resource* m_Resource;
+    void* m_pPrivateData;
+    wchar_t* m_Name;
+
+    union
+    {
+        struct
+        {
+            CommittedAllocationList* list;
+            Allocation* prev;
+            Allocation* next;
+        } m_Committed;
+
+        struct
+        {
+            AllocHandle allocHandle;
+            NormalBlock* block;
+        } m_Placed;
+
+        struct
+        {
+            // Beginning must be compatible with m_Committed.
+            CommittedAllocationList* list;
+            Allocation* prev;
+            Allocation* next;
+            ID3D12Heap* heap;
+        } m_Heap;
+    };
+
+    struct PackedData
+    {
+    public:
+        PackedData() :
+            m_Type(0), m_ResourceDimension(0), m_ResourceFlags(0), m_TextureLayout(0), m_WasZeroInitialized(0) { }
+
+        Type GetType() const { return (Type)m_Type; }
+        D3D12_RESOURCE_DIMENSION GetResourceDimension() const { return (D3D12_RESOURCE_DIMENSION)m_ResourceDimension; }
+        D3D12_RESOURCE_FLAGS GetResourceFlags() const { return (D3D12_RESOURCE_FLAGS)m_ResourceFlags; }
+        D3D12_TEXTURE_LAYOUT GetTextureLayout() const { return (D3D12_TEXTURE_LAYOUT)m_TextureLayout; }
+        BOOL WasZeroInitialized() const { return (BOOL)m_WasZeroInitialized; }
+
+        void SetType(Type type);
+        void SetResourceDimension(D3D12_RESOURCE_DIMENSION resourceDimension);
+        void SetResourceFlags(D3D12_RESOURCE_FLAGS resourceFlags);
+        void SetTextureLayout(D3D12_TEXTURE_LAYOUT textureLayout);
+        void SetWasZeroInitialized(BOOL wasZeroInitialized) { m_WasZeroInitialized = wasZeroInitialized ? 1 : 0; }
+
+    private:
+        UINT m_Type : 2;               // enum Type
+        UINT m_ResourceDimension : 3;  // enum D3D12_RESOURCE_DIMENSION
+        UINT m_ResourceFlags : 24;     // flags D3D12_RESOURCE_FLAGS
+        UINT m_TextureLayout : 9;      // enum D3D12_TEXTURE_LAYOUT
+        UINT m_WasZeroInitialized : 1; // BOOL
+    } m_PackedData;
+
+    Allocation(AllocatorPimpl* allocator, UINT64 size, UINT64 alignment, BOOL wasZeroInitialized);
+    //  Nothing here, everything already done in Release.
+    virtual ~Allocation() = default;
+
+    void InitCommitted(CommittedAllocationList* list);
+    void InitPlaced(AllocHandle allocHandle, NormalBlock* block);
+    void InitHeap(CommittedAllocationList* list, ID3D12Heap* heap);
+    void SwapBlockAllocation(Allocation* allocation);
+    // If the Allocation represents committed resource with implicit heap, returns UINT64_MAX.
+    AllocHandle GetAllocHandle() const;
+    NormalBlock* GetBlock();
+    template<typename D3D12_RESOURCE_DESC_T>
+    void SetResourcePointer(ID3D12Resource* resource, const D3D12_RESOURCE_DESC_T* pResourceDesc);
+    void FreeName();
+
+    D3D12MA_CLASS_NO_COPY(Allocation)
+};
+
+
+/// Flags to be passed as DEFRAGMENTATION_DESC::Flags.
+enum DEFRAGMENTATION_FLAGS
+{
+    /** Use simple but fast algorithm for defragmentation.
+    May not achieve best results but will require least time to compute and least allocations to copy.
+    */
+    DEFRAGMENTATION_FLAG_ALGORITHM_FAST = 0x1,
+    /** Default defragmentation algorithm, applied also when no `ALGORITHM` flag is specified.
+    Offers a balance between defragmentation quality and the amount of allocations and bytes that need to be moved.
+    */
+    DEFRAGMENTATION_FLAG_ALGORITHM_BALANCED = 0x2,
+    /** Perform full defragmentation of memory.
+    Can result in notably more time to compute and allocations to copy, but will achieve best memory packing.
+    */
+    DEFRAGMENTATION_FLAG_ALGORITHM_FULL = 0x4,
+
+    /// A bit mask to extract only `ALGORITHM` bits from entire set of flags.
+    DEFRAGMENTATION_FLAG_ALGORITHM_MASK =
+        DEFRAGMENTATION_FLAG_ALGORITHM_FAST |
+        DEFRAGMENTATION_FLAG_ALGORITHM_BALANCED |
+        DEFRAGMENTATION_FLAG_ALGORITHM_FULL
+};
+
+/** \brief Parameters for defragmentation.
+
+To be used with functions Allocator::BeginDefragmentation() and Pool::BeginDefragmentation().
+*/
+struct DEFRAGMENTATION_DESC
+{
+    /// Flags.
+    DEFRAGMENTATION_FLAGS Flags;
+    /** \brief Maximum numbers of bytes that can be copied during single pass, while moving allocations to different places.
+
+    0 means no limit.
+    */
+    UINT64 MaxBytesPerPass;
+    /** \brief Maximum number of allocations that can be moved during single pass to a different place.
+
+    0 means no limit.
+    */
+    UINT32 MaxAllocationsPerPass;
+};
+
+/// Operation performed on single defragmentation move.
+enum DEFRAGMENTATION_MOVE_OPERATION
+{
+    /** Resource has been recreated at `pDstTmpAllocation`, data has been copied, old resource has been destroyed.
+    `pSrcAllocation` will be changed to point to the new place. This is the default value set by DefragmentationContext::BeginPass().
+    */
+    DEFRAGMENTATION_MOVE_OPERATION_COPY = 0,
+    /// Set this value if you cannot move the allocation. New place reserved at `pDstTmpAllocation` will be freed. `pSrcAllocation` will remain unchanged.
+    DEFRAGMENTATION_MOVE_OPERATION_IGNORE = 1,
+    /// Set this value if you decide to abandon the allocation and you destroyed the resource. New place reserved `pDstTmpAllocation` will be freed, along with `pSrcAllocation`.
+    DEFRAGMENTATION_MOVE_OPERATION_DESTROY = 2,
+};
+
+/// Single move of an allocation to be done for defragmentation.
+struct DEFRAGMENTATION_MOVE
+{
+    /** \brief Operation to be performed on the allocation by DefragmentationContext::EndPass().
+    Default value is #DEFRAGMENTATION_MOVE_OPERATION_COPY. You can modify it.
+    */
+    DEFRAGMENTATION_MOVE_OPERATION Operation;
+    /// %Allocation that should be moved.
+    Allocation* pSrcAllocation;
+    /** \brief Temporary allocation pointing to destination memory that will replace `pSrcAllocation`.
+
+    Use it to retrieve new `ID3D12Heap` and offset to create new `ID3D12Resource` and then store it here via Allocation::SetResource().
+
+    \warning Do not store this allocation in your data structures! It exists only temporarily, for the duration of the defragmentation pass,
+    to be used for storing newly created resource. DefragmentationContext::EndPass() will destroy it and make `pSrcAllocation` point to this memory.
+    */
+    Allocation* pDstTmpAllocation;
+};
+
+/** \brief Parameters for incremental defragmentation steps.
+
+To be used with function DefragmentationContext::BeginPass().
+*/
+struct DEFRAGMENTATION_PASS_MOVE_INFO
+{
+    /// Number of elements in the `pMoves` array.
+    UINT32 MoveCount;
+    /** \brief Array of moves to be performed by the user in the current defragmentation pass.
+
+    Pointer to an array of `MoveCount` elements, owned by %D3D12MA, created in DefragmentationContext::BeginPass(), destroyed in DefragmentationContext::EndPass().
+
+    For each element, you should:
+
+    1. Create a new resource in the place pointed by `pMoves[i].pDstTmpAllocation->GetHeap()` + `pMoves[i].pDstTmpAllocation->GetOffset()`.
+    2. Store new resource in `pMoves[i].pDstTmpAllocation` by using Allocation::SetResource(). It will later replace old resource from `pMoves[i].pSrcAllocation`.
+    3. Copy data from the `pMoves[i].pSrcAllocation` e.g. using `D3D12GraphicsCommandList::CopyResource`.
+    4. Make sure these commands finished executing on the GPU.
+
+    Only then you can finish defragmentation pass by calling DefragmentationContext::EndPass().
+    After this call, the allocation will point to the new place in memory.
+
+    Alternatively, if you cannot move specific allocation,
+    you can set DEFRAGMENTATION_MOVE::Operation to D3D12MA::DEFRAGMENTATION_MOVE_OPERATION_IGNORE.
+
+    Alternatively, if you decide you want to completely remove the allocation,
+    set DEFRAGMENTATION_MOVE::Operation to D3D12MA::DEFRAGMENTATION_MOVE_OPERATION_DESTROY.
+    Then, after DefragmentationContext::EndPass() the allocation will be released.
+    */
+    DEFRAGMENTATION_MOVE* pMoves;
+};
+
+/// %Statistics returned for defragmentation process by function DefragmentationContext::GetStats().
+struct DEFRAGMENTATION_STATS
+{
+    /// Total number of bytes that have been copied while moving allocations to different places.
+    UINT64 BytesMoved;
+    /// Total number of bytes that have been released to the system by freeing empty heaps.
+    UINT64 BytesFreed;
+    /// Number of allocations that have been moved to different places.
+    UINT32 AllocationsMoved;
+    /// Number of empty `ID3D12Heap` objects that have been released to the system.
+    UINT32 HeapsFreed;
+};
+
+/** \brief Represents defragmentation process in progress.
+
+You can create this object using Allocator::BeginDefragmentation (for default pools) or
+Pool::BeginDefragmentation (for a custom pool).
+*/
+class D3D12MA_API DefragmentationContext : public IUnknownImpl
+{
+public:
+    /** \brief Starts single defragmentation pass.
+
+    \param[out] pPassInfo Computed informations for current pass.
+    \returns
+    - `S_OK` if no more moves are possible. Then you can omit call to DefragmentationContext::EndPass() and simply end whole defragmentation.
+    - `S_FALSE` if there are pending moves returned in `pPassInfo`. You need to perform them, call DefragmentationContext::EndPass(),
+      and then preferably try another pass with DefragmentationContext::BeginPass().
+    */
+    HRESULT BeginPass(DEFRAGMENTATION_PASS_MOVE_INFO* pPassInfo);
+    /** \brief Ends single defragmentation pass.
+
+    \param pPassInfo Computed informations for current pass filled by DefragmentationContext::BeginPass() and possibly modified by you.
+    \return Returns `S_OK` if no more moves are possible or `S_FALSE` if more defragmentations are possible.
+
+    Ends incremental defragmentation pass and commits all defragmentation moves from `pPassInfo`.
+    After this call:
+
+    - %Allocation at `pPassInfo[i].pSrcAllocation` that had `pPassInfo[i].Operation ==` #DEFRAGMENTATION_MOVE_OPERATION_COPY
+      (which is the default) will be pointing to the new destination place.
+    - %Allocation at `pPassInfo[i].pSrcAllocation` that had `pPassInfo[i].operation ==` #DEFRAGMENTATION_MOVE_OPERATION_DESTROY
+      will be released.
+
+    If no more moves are possible you can end whole defragmentation.
+    */
+    HRESULT EndPass(DEFRAGMENTATION_PASS_MOVE_INFO* pPassInfo);
+    /** \brief Returns statistics of the defragmentation performed so far.
+    */
+    void GetStats(DEFRAGMENTATION_STATS* pStats);
+
+protected:
+    void ReleaseThis() override;
+
+private:
+    friend class Pool;
+    friend class Allocator;
+    template<typename T> friend void D3D12MA_DELETE(const ALLOCATION_CALLBACKS&, T*);
+
+    DefragmentationContextPimpl* m_Pimpl;
+
+    DefragmentationContext(AllocatorPimpl* allocator,
+        const DEFRAGMENTATION_DESC& desc,
+        BlockVector* poolVector);
+    ~DefragmentationContext();
+
+    D3D12MA_CLASS_NO_COPY(DefragmentationContext)
+};
+
+/// \brief Bit flags to be used with POOL_DESC::Flags.
+enum POOL_FLAGS
+{
+    /// Zero
+    POOL_FLAG_NONE = 0,
+
+    /** \brief Enables alternative, linear allocation algorithm in this pool.
+
+    Specify this flag to enable linear allocation algorithm, which always creates
+    new allocations after last one and doesn't reuse space from allocations freed in
+    between. It trades memory consumption for simplified algorithm and data
+    structure, which has better performance and uses less memory for metadata.
+
+    By using this flag, you can achieve behavior of free-at-once, stack,
+    ring buffer, and double stack.
+    For details, see documentation chapter \ref linear_algorithm.
+    */
+    POOL_FLAG_ALGORITHM_LINEAR = 0x1,
+
+    /** \brief Optimization, allocate MSAA textures as committed resources always.
+    
+    Specify this flag to create MSAA textures with implicit heaps, as if they were created
+    with flag D3D12MA::ALLOCATION_FLAG_COMMITTED. Usage of this flags enables pool to create its heaps
+    on smaller alignment not suitable for MSAA textures.
+    */
+    POOL_FLAG_MSAA_TEXTURES_ALWAYS_COMMITTED = 0x2,
+
+    // Bit mask to extract only `ALGORITHM` bits from entire set of flags.
+    POOL_FLAG_ALGORITHM_MASK = POOL_FLAG_ALGORITHM_LINEAR
+};
+
+/// \brief Parameters of created D3D12MA::Pool object. To be used with D3D12MA::Allocator::CreatePool.
+struct POOL_DESC
+{
+    /// Flags.
+    POOL_FLAGS Flags;
+    /** \brief The parameters of memory heap where allocations of this pool should be placed.
+
+    In the simplest case, just fill it with zeros and set `Type` to one of: `D3D12_HEAP_TYPE_DEFAULT`,
+    `D3D12_HEAP_TYPE_UPLOAD`, `D3D12_HEAP_TYPE_READBACK`. Additional parameters can be used e.g. to utilize UMA.
+    */
+    D3D12_HEAP_PROPERTIES HeapProperties;
+    /** \brief Heap flags to be used when allocating heaps of this pool.
+
+    It should contain one of these values, depending on type of resources you are going to create in this heap:
+    `D3D12_HEAP_FLAG_ALLOW_ONLY_BUFFERS`,
+    `D3D12_HEAP_FLAG_ALLOW_ONLY_NON_RT_DS_TEXTURES`,
+    `D3D12_HEAP_FLAG_ALLOW_ONLY_RT_DS_TEXTURES`.
+    Except if ResourceHeapTier = 2, then it may be `D3D12_HEAP_FLAG_ALLOW_ALL_BUFFERS_AND_TEXTURES` = 0.
+    
+    You can specify additional flags if needed.
+    */
+    D3D12_HEAP_FLAGS HeapFlags;
+    /** \brief Size of a single heap (memory block) to be allocated as part of this pool, in bytes. Optional.
+
+    Specify nonzero to set explicit, constant size of memory blocks used by this pool.
+    Leave 0 to use default and let the library manage block sizes automatically.
+    Then sizes of particular blocks may vary.
+    */
+    UINT64 BlockSize;
+    /** \brief Minimum number of heaps (memory blocks) to be always allocated in this pool, even if they stay empty. Optional.
+
+    Set to 0 to have no preallocated blocks and allow the pool be completely empty.
+    */
+    UINT MinBlockCount;
+    /** \brief Maximum number of heaps (memory blocks) that can be allocated in this pool. Optional.
+
+    Set to 0 to use default, which is `UINT64_MAX`, which means no limit.
+
+    Set to same value as D3D12MA::POOL_DESC::MinBlockCount to have fixed amount of memory allocated
+    throughout whole lifetime of this pool.
+    */
+    UINT MaxBlockCount;
+    /** \brief Additional minimum alignment to be used for all allocations created from this pool. Can be 0.
+    
+    Leave 0 (default) not to impose any additional alignment. If not 0, it must be a power of two.
+    */
+    UINT64 MinAllocationAlignment;
+    /** \brief Additional parameter allowing pool to create resources with passed protected session.
+    
+    If not null then all the heaps and committed resources will be created with this parameter.
+    Valid only if ID3D12Device4 interface is present in current Windows SDK!
+    */
+    ID3D12ProtectedResourceSession* pProtectedSession;
+    /** \brief Residency priority to be set for all allocations made in this pool. Optional.
+    
+    Set this parameter to one of the possible enum values e.g. `D3D12_RESIDENCY_PRIORITY_HIGH`
+    to apply specific residency priority to all allocations made in this pool:
+    `ID3D12Heap` memory blocks used to sub-allocate for placed resources, as well as
+    committed resources or heaps created when D3D12MA::ALLOCATION_FLAG_COMMITTED is used.
+    This can increase/decrease chance that the memory will be pushed out from VRAM
+    to system RAM when the system runs out of memory, which is invisible to the developer
+    using D3D12 API while it can degrade performance.
+
+    Priority is set using function `ID3D12Device1::SetResidencyPriority`.
+    It is performed only when `ID3D12Device1` interface is defined and successfully obtained.
+    Otherwise, this parameter is ignored.
+
+    This parameter is optional. If you set it to `D3D12_RESIDENCY_PRIORITY(0)`,
+    residency priority will not be set for allocations made in this pool.
+
+    There is no equivalent parameter for allocations made in default pools.
+    If you want to set residency priority for such allocation, you need to do it manually:
+    allocate with D3D12MA::ALLOCATION_FLAG_COMMITTED and call
+    `ID3D12Device1::SetResidencyPriority`, passing `allocation->GetResource()`.
+    */
+    D3D12_RESIDENCY_PRIORITY ResidencyPriority;
+};
+
+/** \brief Custom memory pool
+
+Represents a separate set of heaps (memory blocks) that can be used to create
+D3D12MA::Allocation-s and resources in it. Usually there is no need to create custom
+pools - creating resources in default pool is sufficient.
+
+To create custom pool, fill D3D12MA::POOL_DESC and call D3D12MA::Allocator::CreatePool.
+*/
+class D3D12MA_API Pool : public IUnknownImpl
+{
+public:
+    /** \brief Returns copy of parameters of the pool.
+
+    These are the same parameters as passed to D3D12MA::Allocator::CreatePool.
+    */
+    POOL_DESC GetDesc() const;
+
+    /** \brief Retrieves basic statistics of the custom pool that are fast to calculate.
+
+    \param[out] pStats %Statistics of the current pool.
+    */
+    void GetStatistics(Statistics* pStats);
+
+    /** \brief Retrieves detailed statistics of the custom pool that are slower to calculate.
+
+    \param[out] pStats %Statistics of the current pool.
+    */
+    void CalculateStatistics(DetailedStatistics* pStats);
+
+    /** \brief Associates a name with the pool. This name is for use in debug diagnostics and tools.
+
+    Internal copy of the string is made, so the memory pointed by the argument can be
+    changed of freed immediately after this call.
+
+    `Name` can be NULL.
+    */
+    void SetName(LPCWSTR Name);
+
+    /** \brief Returns the name associated with the pool object.
+
+    Returned string points to an internal copy.
+
+    If no name was associated with the allocation, returns NULL.
+    */
+    LPCWSTR GetName() const;
+
+    /** \brief Begins defragmentation process of the current pool.
+
+    \param pDesc Structure filled with parameters of defragmentation.
+    \param[out] ppContext Context object that will manage defragmentation.
+    \returns
+    - `S_OK` if defragmentation can begin.
+    - `E_NOINTERFACE` if defragmentation is not supported.
+
+    For more information about defragmentation, see documentation chapter:
+    [Defragmentation](@ref defragmentation).
+    */
+    HRESULT BeginDefragmentation(const DEFRAGMENTATION_DESC* pDesc, DefragmentationContext** ppContext);
+
+protected:
+    void ReleaseThis() override;
+
+private:
+    friend class Allocator;
+    friend class AllocatorPimpl;
+    template<typename T> friend void D3D12MA_DELETE(const ALLOCATION_CALLBACKS&, T*);
+
+    PoolPimpl* m_Pimpl;
+
+    Pool(Allocator* allocator, const POOL_DESC &desc);
+    ~Pool();
+
+    D3D12MA_CLASS_NO_COPY(Pool)
+};
+
+
+/// \brief Bit flags to be used with ALLOCATOR_DESC::Flags.
+enum ALLOCATOR_FLAGS
+{
+    /// Zero
+    ALLOCATOR_FLAG_NONE = 0,
+
+    /**
+    Allocator and all objects created from it will not be synchronized internally,
+    so you must guarantee they are used from only one thread at a time or
+    synchronized by you.
+
+    Using this flag may increase performance because internal mutexes are not used.
+    */
+    ALLOCATOR_FLAG_SINGLETHREADED = 0x1,
+
+    /**
+    Every allocation will have its own memory block.
+    To be used for debugging purposes.
+    */
+    ALLOCATOR_FLAG_ALWAYS_COMMITTED = 0x2,
+
+    /**
+    Heaps created for the default pools will be created with flag `D3D12_HEAP_FLAG_CREATE_NOT_ZEROED`,
+    allowing for their memory to be not zeroed by the system if possible,
+    which can speed up allocation.
+
+    Only affects default pools.
+    To use the flag with @ref custom_pools, you need to add it manually:
+
+    \code
+    poolDesc.heapFlags |= D3D12_HEAP_FLAG_CREATE_NOT_ZEROED;
+    \endcode
+
+    Only avaiable if `ID3D12Device8` is present. Otherwise, the flag is ignored.
+    */
+    ALLOCATOR_FLAG_DEFAULT_POOLS_NOT_ZEROED = 0x4,
+
+    /** \brief Optimization, allocate MSAA textures as committed resources always.
+
+    Specify this flag to create MSAA textures with implicit heaps, as if they were created
+    with flag D3D12MA::ALLOCATION_FLAG_COMMITTED. Usage of this flags enables all default pools
+    to create its heaps on smaller alignment not suitable for MSAA textures.
+    */
+    ALLOCATOR_FLAG_MSAA_TEXTURES_ALWAYS_COMMITTED = 0x8,
+};
+
+/// \brief Parameters of created Allocator object. To be used with CreateAllocator().
+struct ALLOCATOR_DESC
+{
+    /// Flags.
+    ALLOCATOR_FLAGS Flags;
+    
+    /** Direct3D device object that the allocator should be attached to.
+
+    Allocator is doing `AddRef`/`Release` on this object.
+    */
+    ID3D12Device* pDevice;
+    
+    /** \brief Preferred size of a single `ID3D12Heap` block to be allocated.
+    
+    Set to 0 to use default, which is currently 64 MiB.
+    */
+    UINT64 PreferredBlockSize;
+    
+    /** \brief Custom CPU memory allocation callbacks. Optional.
+
+    Optional, can be null. When specified, will be used for all CPU-side memory allocations.
+    */
+    const ALLOCATION_CALLBACKS* pAllocationCallbacks;
+
+    /** DXGI Adapter object that you use for D3D12 and this allocator.
+
+    Allocator is doing `AddRef`/`Release` on this object.
+    */
+    IDXGIAdapter* pAdapter;
+};
+
+/**
+\brief Represents main object of this library initialized for particular `ID3D12Device`.
+
+Fill structure D3D12MA::ALLOCATOR_DESC and call function CreateAllocator() to create it.
+Call method `Release()` to destroy it.
+
+It is recommended to create just one object of this type per `ID3D12Device` object,
+right after Direct3D 12 is initialized and keep it alive until before Direct3D device is destroyed.
+*/
+class D3D12MA_API Allocator : public IUnknownImpl
+{
+public:
+    /// Returns cached options retrieved from D3D12 device.
+    const D3D12_FEATURE_DATA_D3D12_OPTIONS& GetD3D12Options() const;
+    /** \brief Returns true if `D3D12_FEATURE_DATA_ARCHITECTURE1::UMA` was found to be true.
+    
+    For more information about how to use it, see articles in Microsoft Docs articles:
+
+    - "UMA Optimizations: CPU Accessible Textures and Standard Swizzle"
+    - "D3D12_FEATURE_DATA_ARCHITECTURE structure (d3d12.h)"
+    - "ID3D12Device::GetCustomHeapProperties method (d3d12.h)"
+    */
+    BOOL IsUMA() const;
+    /** \brief Returns true if `D3D12_FEATURE_DATA_ARCHITECTURE1::CacheCoherentUMA` was found to be true.
+
+    For more information about how to use it, see articles in Microsoft Docs articles:
+
+    - "UMA Optimizations: CPU Accessible Textures and Standard Swizzle"
+    - "D3D12_FEATURE_DATA_ARCHITECTURE structure (d3d12.h)"
+    - "ID3D12Device::GetCustomHeapProperties method (d3d12.h)"
+    */
+    BOOL IsCacheCoherentUMA() const;
+    /** \brief Returns total amount of memory of specific segment group, in bytes.
+    
+    \param memorySegmentGroup use `DXGI_MEMORY_SEGMENT_GROUP_LOCAL` or DXGI_MEMORY_SEGMENT_GROUP_NON_LOCAL`.
+
+    This information is taken from `DXGI_ADAPTER_DESC`.
+    It is not recommended to use this number.
+    You should preferably call GetBudget() and limit memory usage to D3D12MA::Budget::BudgetBytes instead.
+
+    - When IsUMA() `== FALSE` (discrete graphics card):
+      - `GetMemoryCapacity(DXGI_MEMORY_SEGMENT_GROUP_LOCAL)` returns the size of the video memory.
+      - `GetMemoryCapacity(DXGI_MEMORY_SEGMENT_GROUP_NON_LOCAL)` returns the size of the system memory available for D3D12 resources.
+    - When IsUMA() `== TRUE` (integrated graphics chip):
+      - `GetMemoryCapacity(DXGI_MEMORY_SEGMENT_GROUP_LOCAL)` returns the size of the shared memory available for all D3D12 resources.
+        All memory is considered "local".
+      - `GetMemoryCapacity(DXGI_MEMORY_SEGMENT_GROUP_NON_LOCAL)` is not applicable and returns 0.
+    */
+    UINT64 GetMemoryCapacity(UINT memorySegmentGroup) const;
+
+    /** \brief Allocates memory and creates a D3D12 resource (buffer or texture). This is the main allocation function.
+
+    The function is similar to `ID3D12Device::CreateCommittedResource`, but it may
+    really call `ID3D12Device::CreatePlacedResource` to assign part of a larger,
+    existing memory heap to the new resource, which is the main purpose of this
+    whole library.
+
+    If `ppvResource` is null, you receive only `ppAllocation` object from this function.
+    It holds pointer to `ID3D12Resource` that can be queried using function D3D12MA::Allocation::GetResource().
+    Reference count of the resource object is 1.
+    It is automatically destroyed when you destroy the allocation object.
+
+    If `ppvResource` is not null, you receive pointer to the resource next to allocation object.
+    Reference count of the resource object is then increased by calling `QueryInterface`, so you need to manually `Release` it
+    along with the allocation.
+
+    \param pAllocDesc   Parameters of the allocation.
+    \param pResourceDesc   Description of created resource.
+    \param InitialResourceState   Initial resource state.
+    \param pOptimizedClearValue   Optional. Either null or optimized clear value.
+    \param[out] ppAllocation   Filled with pointer to new allocation object created.
+    \param riidResource   IID of a resource to be returned via `ppvResource`.
+    \param[out] ppvResource   Optional. If not null, filled with pointer to new resouce created.
+
+    \note This function creates a new resource. Sub-allocation of parts of one large buffer,
+    although recommended as a good practice, is out of scope of this library and could be implemented
+    by the user as a higher-level logic on top of it, e.g. using the \ref virtual_allocator feature.
+    */
+    HRESULT CreateResource(
+        const ALLOCATION_DESC* pAllocDesc,
+        const D3D12_RESOURCE_DESC* pResourceDesc,
+        D3D12_RESOURCE_STATES InitialResourceState,
+        const D3D12_CLEAR_VALUE *pOptimizedClearValue,
+        Allocation** ppAllocation,
+        REFIID riidResource,
+        void** ppvResource);
+
+#ifdef __ID3D12Device8_INTERFACE_DEFINED__
+    /** \brief Similar to Allocator::CreateResource, but supports new structure `D3D12_RESOURCE_DESC1`.
+    
+    It internally uses `ID3D12Device8::CreateCommittedResource2` or `ID3D12Device8::CreatePlacedResource1`.
+
+    To work correctly, `ID3D12Device8` interface must be available in the current system. Otherwise, `E_NOINTERFACE` is returned.
+    */
+    HRESULT CreateResource2(
+        const ALLOCATION_DESC* pAllocDesc,
+        const D3D12_RESOURCE_DESC1* pResourceDesc,
+        D3D12_RESOURCE_STATES InitialResourceState,
+        const D3D12_CLEAR_VALUE *pOptimizedClearValue,
+        Allocation** ppAllocation,
+        REFIID riidResource,
+        void** ppvResource);
+#endif // #ifdef __ID3D12Device8_INTERFACE_DEFINED__
+
+#ifdef __ID3D12Device10_INTERFACE_DEFINED__
+    /** \brief Similar to Allocator::CreateResource2, but there are initial layout instead of state and 
+    castable formats list
+
+    It internally uses `ID3D12Device10::CreateCommittedResource3` or `ID3D12Device10::CreatePlacedResource2`.
+
+    To work correctly, `ID3D12Device10` interface must be available in the current system. Otherwise, `E_NOINTERFACE` is returned.
+    */
+    HRESULT CreateResource3(const ALLOCATION_DESC* pAllocDesc,
+        const D3D12_RESOURCE_DESC1* pResourceDesc,
+        D3D12_BARRIER_LAYOUT InitialLayout,
+        const D3D12_CLEAR_VALUE* pOptimizedClearValue,
+        UINT32 NumCastableFormats,
+        DXGI_FORMAT* pCastableFormats,
+        Allocation** ppAllocation,
+        REFIID riidResource,
+        void** ppvResource);
+#endif  // #ifdef __ID3D12Device10_INTERFACE_DEFINED__
+
+    /** \brief Allocates memory without creating any resource placed in it.
+
+    This function is similar to `ID3D12Device::CreateHeap`, but it may really assign
+    part of a larger, existing heap to the allocation.
+
+    `pAllocDesc->heapFlags` should contain one of these values, depending on type of resources you are going to create in this memory:
+    `D3D12_HEAP_FLAG_ALLOW_ONLY_BUFFERS`,
+    `D3D12_HEAP_FLAG_ALLOW_ONLY_NON_RT_DS_TEXTURES`,
+    `D3D12_HEAP_FLAG_ALLOW_ONLY_RT_DS_TEXTURES`.
+    Except if you validate that ResourceHeapTier = 2 - then `heapFlags`
+    may be `D3D12_HEAP_FLAG_ALLOW_ALL_BUFFERS_AND_TEXTURES` = 0.
+    Additional flags in `heapFlags` are allowed as well.
+
+    `pAllocInfo->SizeInBytes` must be multiply of 64KB.
+    `pAllocInfo->Alignment` must be one of the legal values as described in documentation of `D3D12_HEAP_DESC`.
+
+    If you use D3D12MA::ALLOCATION_FLAG_COMMITTED you will get a separate memory block -
+    a heap that always has offset 0.
+    */
+    HRESULT AllocateMemory(
+        const ALLOCATION_DESC* pAllocDesc,
+        const D3D12_RESOURCE_ALLOCATION_INFO* pAllocInfo,
+        Allocation** ppAllocation);
+
+    /** \brief Creates a new resource in place of an existing allocation. This is useful for memory aliasing.
+
+    \param pAllocation Existing allocation indicating the memory where the new resource should be created.
+        It can be created using D3D12MA::Allocator::CreateResource and already have a resource bound to it,
+        or can be a raw memory allocated with D3D12MA::Allocator::AllocateMemory.
+        It must not be created as committed so that `ID3D12Heap` is available and not implicit.
+    \param AllocationLocalOffset Additional offset in bytes to be applied when allocating the resource.
+        Local from the start of `pAllocation`, not the beginning of the whole `ID3D12Heap`!
+        If the new resource should start from the beginning of the `pAllocation` it should be 0.
+    \param pResourceDesc Description of the new resource to be created.
+    \param InitialResourceState
+    \param pOptimizedClearValue
+    \param riidResource
+    \param[out] ppvResource Returns pointer to the new resource.
+        The resource is not bound with `pAllocation`.
+        This pointer must not be null - you must get the resource pointer and `Release` it when no longer needed.
+
+    Memory requirements of the new resource are checked for validation.
+    If its size exceeds the end of `pAllocation` or required alignment is not fulfilled
+    considering `pAllocation->GetOffset() + AllocationLocalOffset`, the function
+    returns `E_INVALIDARG`.
+    */
+    HRESULT CreateAliasingResource(
+        Allocation* pAllocation,
+        UINT64 AllocationLocalOffset,
+        const D3D12_RESOURCE_DESC* pResourceDesc,
+        D3D12_RESOURCE_STATES InitialResourceState,
+        const D3D12_CLEAR_VALUE *pOptimizedClearValue,
+        REFIID riidResource,
+        void** ppvResource);
+
+#ifdef __ID3D12Device8_INTERFACE_DEFINED__
+    /** \brief Similar to Allocator::CreateAliasingResource, but supports new structure `D3D12_RESOURCE_DESC1`.
+    
+    It internally uses `ID3D12Device8::CreatePlacedResource1`.
+
+    To work correctly, `ID3D12Device8` interface must be available in the current system. Otherwise, `E_NOINTERFACE` is returned.
+    */
+    HRESULT CreateAliasingResource1(Allocation* pAllocation,
+        UINT64 AllocationLocalOffset,
+        const D3D12_RESOURCE_DESC1* pResourceDesc,
+        D3D12_RESOURCE_STATES InitialResourceState,
+        const D3D12_CLEAR_VALUE* pOptimizedClearValue,
+        REFIID riidResource,
+        void** ppvResource);
+#endif // #ifdef __ID3D12Device8_INTERFACE_DEFINED__
+
+#ifdef __ID3D12Device10_INTERFACE_DEFINED__
+    /** \brief Similar to Allocator::CreateAliasingResource1, but there are initial layout instead of state and 
+    castable formats list
+
+    It internally uses `ID3D12Device10::CreatePlacedResource2`.
+
+    To work correctly, `ID3D12Device10` interface must be available in the current system. Otherwise, `E_NOINTERFACE` is returned.
+    */
+    HRESULT CreateAliasingResource2(Allocation* pAllocation,
+        UINT64 AllocationLocalOffset,
+        const D3D12_RESOURCE_DESC1* pResourceDesc,
+        D3D12_BARRIER_LAYOUT InitialLayout,
+        const D3D12_CLEAR_VALUE* pOptimizedClearValue,
+        UINT32 NumCastableFormats,
+        DXGI_FORMAT* pCastableFormats,
+        REFIID riidResource,
+        void** ppvResource);
+#endif  // #ifdef __ID3D12Device10_INTERFACE_DEFINED__
+
+    /** \brief Creates custom pool.
+    */
+    HRESULT CreatePool(
+        const POOL_DESC* pPoolDesc,
+        Pool** ppPool);
+
+    /** \brief Sets the index of the current frame.
+
+    This function is used to set the frame index in the allocator when a new game frame begins.
+    */
+    void SetCurrentFrameIndex(UINT frameIndex);
+
+    /** \brief Retrieves information about current memory usage and budget.
+
+    \param[out] pLocalBudget Optional, can be null.
+    \param[out] pNonLocalBudget Optional, can be null.
+
+    - When IsUMA() `== FALSE` (discrete graphics card):
+      - `pLocalBudget` returns the budget of the video memory.
+      - `pNonLocalBudget` returns the budget of the system memory available for D3D12 resources.
+    - When IsUMA() `== TRUE` (integrated graphics chip):
+      - `pLocalBudget` returns the budget of the shared memory available for all D3D12 resources.
+        All memory is considered "local".
+      - `pNonLocalBudget` is not applicable and returns zeros.
+
+    This function is called "get" not "calculate" because it is very fast, suitable to be called
+    every frame or every allocation. For more detailed statistics use CalculateStatistics().
+
+    Note that when using allocator from multiple threads, returned information may immediately
+    become outdated.
+    */
+    void GetBudget(Budget* pLocalBudget, Budget* pNonLocalBudget);
+
+    /** \brief Retrieves statistics from current state of the allocator.
+
+    This function is called "calculate" not "get" because it has to traverse all
+    internal data structures, so it may be quite slow. Use it for debugging purposes.
+    For faster but more brief statistics suitable to be called every frame or every allocation,
+    use GetBudget().
+
+    Note that when using allocator from multiple threads, returned information may immediately
+    become outdated.
+    */
+    void CalculateStatistics(TotalStatistics* pStats);
+
+    /** \brief Builds and returns statistics as a string in JSON format.
+    * 
+    @param[out] ppStatsString Must be freed using Allocator::FreeStatsString.
+    @param DetailedMap `TRUE` to include full list of allocations (can make the string quite long), `FALSE` to only return statistics.
+    */
+    void BuildStatsString(WCHAR** ppStatsString, BOOL DetailedMap) const;
+
+    /// Frees memory of a string returned from Allocator::BuildStatsString.
+    void FreeStatsString(WCHAR* pStatsString) const;
+
+    /** \brief Begins defragmentation process of the default pools.
+
+    \param pDesc Structure filled with parameters of defragmentation.
+    \param[out] ppContext Context object that will manage defragmentation.
+
+    For more information about defragmentation, see documentation chapter:
+    [Defragmentation](@ref defragmentation).
+    */
+    void BeginDefragmentation(const DEFRAGMENTATION_DESC* pDesc, DefragmentationContext** ppContext);
+
+protected:
+    void ReleaseThis() override;
+
+private:
+    friend D3D12MA_API HRESULT CreateAllocator(const ALLOCATOR_DESC*, Allocator**);
+    template<typename T> friend void D3D12MA_DELETE(const ALLOCATION_CALLBACKS&, T*);
+    friend class DefragmentationContext;
+    friend class Pool;
+
+    Allocator(const ALLOCATION_CALLBACKS& allocationCallbacks, const ALLOCATOR_DESC& desc);
+    ~Allocator();
+    
+    AllocatorPimpl* m_Pimpl;
+    
+    D3D12MA_CLASS_NO_COPY(Allocator)
+};
+
+
+/// \brief Bit flags to be used with VIRTUAL_BLOCK_DESC::Flags.
+enum VIRTUAL_BLOCK_FLAGS
+{
+    /// Zero
+    VIRTUAL_BLOCK_FLAG_NONE = 0,
+
+    /** \brief Enables alternative, linear allocation algorithm in this virtual block.
+
+    Specify this flag to enable linear allocation algorithm, which always creates
+    new allocations after last one and doesn't reuse space from allocations freed in
+    between. It trades memory consumption for simplified algorithm and data
+    structure, which has better performance and uses less memory for metadata.
+
+    By using this flag, you can achieve behavior of free-at-once, stack,
+    ring buffer, and double stack.
+    For details, see documentation chapter \ref linear_algorithm.
+    */
+    VIRTUAL_BLOCK_FLAG_ALGORITHM_LINEAR = POOL_FLAG_ALGORITHM_LINEAR,
+
+    // Bit mask to extract only `ALGORITHM` bits from entire set of flags.
+    VIRTUAL_BLOCK_FLAG_ALGORITHM_MASK = POOL_FLAG_ALGORITHM_MASK
+};
+
+/// Parameters of created D3D12MA::VirtualBlock object to be passed to CreateVirtualBlock().
+struct VIRTUAL_BLOCK_DESC
+{
+    /// Flags.
+    VIRTUAL_BLOCK_FLAGS Flags;
+    /** \brief Total size of the block.
+
+    Sizes can be expressed in bytes or any units you want as long as you are consistent in using them.
+    For example, if you allocate from some array of structures, 1 can mean single instance of entire structure.
+    */
+    UINT64 Size;
+    /** \brief Custom CPU memory allocation callbacks. Optional.
+
+    Optional, can be null. When specified, will be used for all CPU-side memory allocations.
+    */
+    const ALLOCATION_CALLBACKS* pAllocationCallbacks;
+};
+
+/// \brief Bit flags to be used with VIRTUAL_ALLOCATION_DESC::Flags.
+enum VIRTUAL_ALLOCATION_FLAGS
+{
+    /// Zero
+    VIRTUAL_ALLOCATION_FLAG_NONE = 0,
+
+    /** \brief Allocation will be created from upper stack in a double stack pool.
+
+    This flag is only allowed for virtual blocks created with #VIRTUAL_BLOCK_FLAG_ALGORITHM_LINEAR flag.
+    */
+    VIRTUAL_ALLOCATION_FLAG_UPPER_ADDRESS = ALLOCATION_FLAG_UPPER_ADDRESS,
+
+    /// Allocation strategy that tries to minimize memory usage.
+    VIRTUAL_ALLOCATION_FLAG_STRATEGY_MIN_MEMORY = ALLOCATION_FLAG_STRATEGY_MIN_MEMORY,
+    /// Allocation strategy that tries to minimize allocation time.
+    VIRTUAL_ALLOCATION_FLAG_STRATEGY_MIN_TIME = ALLOCATION_FLAG_STRATEGY_MIN_TIME,
+    /** \brief Allocation strategy that chooses always the lowest offset in available space.
+    This is not the most efficient strategy but achieves highly packed data.
+    */
+    VIRTUAL_ALLOCATION_FLAG_STRATEGY_MIN_OFFSET = ALLOCATION_FLAG_STRATEGY_MIN_OFFSET,
+    /** \brief A bit mask to extract only `STRATEGY` bits from entire set of flags.
+
+    These strategy flags are binary compatible with equivalent flags in #ALLOCATION_FLAGS.
+    */
+    VIRTUAL_ALLOCATION_FLAG_STRATEGY_MASK = ALLOCATION_FLAG_STRATEGY_MASK,
+};
+
+/// Parameters of created virtual allocation to be passed to VirtualBlock::Allocate().
+struct VIRTUAL_ALLOCATION_DESC
+{
+    /// Flags.
+    VIRTUAL_ALLOCATION_FLAGS Flags;
+    /** \brief Size of the allocation.
+    
+    Cannot be zero.
+    */
+    UINT64 Size;
+    /** \brief Required alignment of the allocation.
+    
+    Must be power of two. Special value 0 has the same meaning as 1 - means no special alignment is required, so allocation can start at any offset.
+    */
+    UINT64 Alignment;
+    /** \brief Custom pointer to be associated with the allocation.
+
+    It can be fetched or changed later.
+    */
+    void* pPrivateData;
+};
+
+/// Parameters of an existing virtual allocation, returned by VirtualBlock::GetAllocationInfo().
+struct VIRTUAL_ALLOCATION_INFO
+{
+    /// \brief Offset of the allocation.
+    UINT64 Offset;
+    /** \brief Size of the allocation.
+
+    Same value as passed in VIRTUAL_ALLOCATION_DESC::Size.
+    */
+    UINT64 Size;
+    /** \brief Custom pointer associated with the allocation.
+
+    Same value as passed in VIRTUAL_ALLOCATION_DESC::pPrivateData or VirtualBlock::SetAllocationPrivateData().
+    */
+    void* pPrivateData;
+};
+
+/** \brief Represents pure allocation algorithm and a data structure with allocations in some memory block, without actually allocating any GPU memory.
+
+This class allows to use the core algorithm of the library custom allocations e.g. CPU memory or
+sub-allocation regions inside a single GPU buffer.
+
+To create this object, fill in D3D12MA::VIRTUAL_BLOCK_DESC and call CreateVirtualBlock().
+To destroy it, call its method `VirtualBlock::Release()`.
+You need to free all the allocations within this block or call Clear() before destroying it.
+
+This object is not thread-safe - should not be used from multiple threads simultaneously, must be synchronized externally.
+*/
+class D3D12MA_API VirtualBlock : public IUnknownImpl
+{
+public:
+    /** \brief Returns true if the block is empty - contains 0 allocations.
+    */
+    BOOL IsEmpty() const;
+    /** \brief Returns information about an allocation - its offset, size and custom pointer.
+    */
+    void GetAllocationInfo(VirtualAllocation allocation, VIRTUAL_ALLOCATION_INFO* pInfo) const;
+
+    /** \brief Creates new allocation.
+    \param pDesc
+    \param[out] pAllocation Unique indentifier of the new allocation within single block.
+    \param[out] pOffset Returned offset of the new allocation. Optional, can be null.
+    \return `S_OK` if allocation succeeded, `E_OUTOFMEMORY` if it failed.
+
+    If the allocation failed, `pAllocation->AllocHandle` is set to 0 and `pOffset`, if not null, is set to `UINT64_MAX`.
+    */
+    HRESULT Allocate(const VIRTUAL_ALLOCATION_DESC* pDesc, VirtualAllocation* pAllocation, UINT64* pOffset);
+    /** \brief Frees the allocation.
+    
+    Calling this function with `allocation.AllocHandle == 0` is correct and does nothing.
+    */
+    void FreeAllocation(VirtualAllocation allocation);
+    /** \brief Frees all the allocations.
+    */
+    void Clear();
+    /** \brief Changes custom pointer for an allocation to a new value.
+    */
+    void SetAllocationPrivateData(VirtualAllocation allocation, void* pPrivateData);
+    /** \brief Retrieves basic statistics of the virtual block that are fast to calculate.
+
+    \param[out] pStats %Statistics of the virtual block.
+    */
+    void GetStatistics(Statistics* pStats) const;
+    /** \brief Retrieves detailed statistics of the virtual block that are slower to calculate.
+
+    \param[out] pStats %Statistics of the virtual block.
+    */
+    void CalculateStatistics(DetailedStatistics* pStats) const;
+
+    /** \brief Builds and returns statistics as a string in JSON format, including the list of allocations with their parameters.
+    @param[out] ppStatsString Must be freed using VirtualBlock::FreeStatsString.
+    */
+    void BuildStatsString(WCHAR** ppStatsString) const;
+
+    /** \brief Frees memory of a string returned from VirtualBlock::BuildStatsString.
+    */
+    void FreeStatsString(WCHAR* pStatsString) const;
+   
+protected:
+    void ReleaseThis() override;
+
+private:
+    friend D3D12MA_API HRESULT CreateVirtualBlock(const VIRTUAL_BLOCK_DESC*, VirtualBlock**);
+    template<typename T> friend void D3D12MA_DELETE(const ALLOCATION_CALLBACKS&, T*);
+
+    VirtualBlockPimpl* m_Pimpl;
+
+    VirtualBlock(const ALLOCATION_CALLBACKS& allocationCallbacks, const VIRTUAL_BLOCK_DESC& desc);
+    ~VirtualBlock();
+
+    D3D12MA_CLASS_NO_COPY(VirtualBlock)
+};
+
+
+/** \brief Creates new main D3D12MA::Allocator object and returns it through `ppAllocator`.
+
+You normally only need to call it once and keep a single Allocator object for your `ID3D12Device`.
+*/
+D3D12MA_API HRESULT CreateAllocator(const ALLOCATOR_DESC* pDesc, Allocator** ppAllocator);
+
+/** \brief Creates new D3D12MA::VirtualBlock object and returns it through `ppVirtualBlock`.
+
+Note you don't need to create D3D12MA::Allocator to use virtual blocks.
+*/
+D3D12MA_API HRESULT CreateVirtualBlock(const VIRTUAL_BLOCK_DESC* pDesc, VirtualBlock** ppVirtualBlock);
+
+} // namespace D3D12MA
+
+/// \cond INTERNAL
+DEFINE_ENUM_FLAG_OPERATORS(D3D12MA::ALLOCATION_FLAGS);
+DEFINE_ENUM_FLAG_OPERATORS(D3D12MA::DEFRAGMENTATION_FLAGS);
+DEFINE_ENUM_FLAG_OPERATORS(D3D12MA::ALLOCATOR_FLAGS);
+DEFINE_ENUM_FLAG_OPERATORS(D3D12MA::POOL_FLAGS);
+DEFINE_ENUM_FLAG_OPERATORS(D3D12MA::VIRTUAL_BLOCK_FLAGS);
+DEFINE_ENUM_FLAG_OPERATORS(D3D12MA::VIRTUAL_ALLOCATION_FLAGS);
+/// \endcond
+
+/**
+\page quick_start Quick start
+
+\section quick_start_project_setup Project setup and initialization
+
+This is a small, standalone C++ library. It consists of a pair of 2 files:
+"D3D12MemAlloc.h" header file with public interface and "D3D12MemAlloc.cpp" with
+internal implementation. The only external dependencies are WinAPI, Direct3D 12,
+and parts of C/C++ standard library (but STL containers, exceptions, or RTTI are
+not used).
+
+The library is developed and tested using Microsoft Visual Studio 2019, but it
+should work with other compilers as well. It is designed for 64-bit code.
+
+To use the library in your project:
+
+(1.) Copy files `D3D12MemAlloc.cpp`, `%D3D12MemAlloc.h` to your project.
+
+(2.) Make `D3D12MemAlloc.cpp` compiling as part of the project, as C++ code.
+
+(3.) Include library header in each CPP file that needs to use the library.
+
+\code
+#include "D3D12MemAlloc.h"
+\endcode
+
+(4.) Right after you created `ID3D12Device`, fill D3D12MA::ALLOCATOR_DESC
+structure and call function D3D12MA::CreateAllocator to create the main
+D3D12MA::Allocator object.
+
+Please note that all symbols of the library are declared inside #D3D12MA namespace.
+
+\code
+IDXGIAdapter* adapter = (...)
+ID3D12Device* device = (...)
+
+D3D12MA::ALLOCATOR_DESC allocatorDesc = {};
+allocatorDesc.pDevice = device;
+allocatorDesc.pAdapter = adapter;
+
+D3D12MA::Allocator* allocator;
+HRESULT hr = D3D12MA::CreateAllocator(&allocatorDesc, &allocator);
+\endcode
+
+(5.) Right before destroying the D3D12 device, destroy the allocator object.
+
+Objects of this library must be destroyed by calling `Release` method.
+They are somewhat compatible with COM: they implement `IUnknown` interface with its virtual methods: `AddRef`, `Release`, `QueryInterface`,
+and they are reference-counted internally.
+You can use smart pointers designed for COM with objects of this library - e.g. `CComPtr` or `Microsoft::WRL::ComPtr`.
+The reference counter is thread-safe.
+`QueryInterface` method supports only `IUnknown`, as classes of this library don't define their own GUIDs.
+
+\code
+allocator->Release();
+\endcode
+
+
+\section quick_start_creating_resources Creating resources
+
+To use the library for creating resources (textures and buffers), call method
+D3D12MA::Allocator::CreateResource in the place where you would previously call
+`ID3D12Device::CreateCommittedResource`.
+
+The function has similar syntax, but it expects structure D3D12MA::ALLOCATION_DESC
+to be passed along with `D3D12_RESOURCE_DESC` and other parameters for created
+resource. This structure describes parameters of the desired memory allocation,
+including choice of `D3D12_HEAP_TYPE`.
+
+The function returns a new object of type D3D12MA::Allocation.
+It represents allocated memory and can be queried for size, offset, `ID3D12Heap`.
+It also holds a reference to the `ID3D12Resource`, which can be accessed by calling D3D12MA::Allocation::GetResource().
+
+\code
+D3D12_RESOURCE_DESC resourceDesc = {};
+resourceDesc.Dimension = D3D12_RESOURCE_DIMENSION_TEXTURE2D;
+resourceDesc.Alignment = 0;
+resourceDesc.Width = 1024;
+resourceDesc.Height = 1024;
+resourceDesc.DepthOrArraySize = 1;
+resourceDesc.MipLevels = 1;
+resourceDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM;
+resourceDesc.SampleDesc.Count = 1;
+resourceDesc.SampleDesc.Quality = 0;
+resourceDesc.Layout = D3D12_TEXTURE_LAYOUT_UNKNOWN;
+resourceDesc.Flags = D3D12_RESOURCE_FLAG_NONE;
+
+D3D12MA::ALLOCATION_DESC allocationDesc = {};
+allocationDesc.HeapType = D3D12_HEAP_TYPE_DEFAULT;
+
+D3D12MA::Allocation* allocation;
+HRESULT hr = allocator->CreateResource(
+    &allocationDesc,
+    &resourceDesc,
+    D3D12_RESOURCE_STATE_COPY_DEST,
+    NULL,
+    &allocation,
+    IID_NULL, NULL);
+
+// Use allocation->GetResource()...
+\endcode
+
+You need to release the allocation object when no longer needed.
+This will also release the D3D12 resource.
+
+\code
+allocation->Release();
+\endcode
+
+The advantage of using the allocator instead of creating committed resource, and
+the main purpose of this library, is that it can decide to allocate bigger memory
+heap internally using `ID3D12Device::CreateHeap` and place multiple resources in
+it, at different offsets, using `ID3D12Device::CreatePlacedResource`. The library
+manages its own collection of allocated memory blocks (heaps) and remembers which
+parts of them are occupied and which parts are free to be used for new resources.
+
+It is important to remember that resources created as placed don't have their memory
+initialized to zeros, but may contain garbage data, so they need to be fully initialized
+before usage, e.g. using Clear (`ClearRenderTargetView`), Discard (`DiscardResource`),
+or copy (`CopyResource`).
+
+The library also automatically handles resource heap tier.
+When `D3D12_FEATURE_DATA_D3D12_OPTIONS::ResourceHeapTier` equals `D3D12_RESOURCE_HEAP_TIER_1`,
+resources of 3 types: buffers, textures that are render targets or depth-stencil,
+and other textures must be kept in separate heaps. When `D3D12_RESOURCE_HEAP_TIER_2`,
+they can be kept together. By using this library, you don't need to handle this
+manually.
+
+
+\section quick_start_resource_reference_counting Resource reference counting
+
+`ID3D12Resource` and other interfaces of Direct3D 12 use COM, so they are reference-counted.
+Objects of this library are reference-counted as well.
+An object of type D3D12MA::Allocation remembers the resource (buffer or texture)
+that was created together with this memory allocation
+and holds a reference to the `ID3D12Resource` object.
+(Note this is a difference to Vulkan Memory Allocator, where a `VmaAllocation` object has no connection
+with the buffer or image that was created with it.)
+Thus, it is important to manage the resource reference counter properly.
+
+<b>The simplest use case</b> is shown in the code snippet above.
+When only D3D12MA::Allocation object is obtained from a function call like D3D12MA::Allocator::CreateResource,
+it remembers the `ID3D12Resource` that was created with it and holds a reference to it.
+The resource can be obtained by calling `allocation->GetResource()`, which doesn't increment the resource
+reference counter.
+Calling `allocation->Release()` will decrease the resource reference counter, which is = 1 in this case,
+so the resource will be released.
+
+<b>Second option</b> is to retrieve a pointer to the resource along with D3D12MA::Allocation.
+Last parameters of the resource creation function can be used for this purpose.
+
+\code
+D3D12MA::Allocation* allocation;
+ID3D12Resource* resource;
+HRESULT hr = allocator->CreateResource(
+    &allocationDesc,
+    &resourceDesc,
+    D3D12_RESOURCE_STATE_COPY_DEST,
+    NULL,
+    &allocation,
+    IID_PPV_ARGS(&resource));
+
+// Use resource...
+\endcode
+
+In this case, returned pointer `resource` is equal to `allocation->GetResource()`,
+but the creation function additionally increases resource reference counter for the purpose of returning it from this call
+(it actually calls `QueryInterface` internally), so the resource will have the counter = 2.
+The resource then need to be released along with the allocation, in this particular order,
+to make sure the resource is destroyed before its memory heap can potentially be freed.
+
+\code
+resource->Release();
+allocation->Release();
+\endcode
+
+<b>More advanced use cases</b> are possible when we consider that an D3D12MA::Allocation object can just hold
+a reference to any resource.
+It can be changed by calling D3D12MA::Allocation::SetResource. This function
+releases the old resource and calls `AddRef` on the new one.
+
+Special care must be taken when performing <b>defragmentation</b>.
+The new resource created at the destination place should be set as `pass.pMoves[i].pDstTmpAllocation->SetResource(newRes)`,
+but it is moved to the source allocation at end of the defragmentation pass,
+while the old resource accessible through `pass.pMoves[i].pSrcAllocation->GetResource()` is then released.
+For more information, see documentation chapter \ref defragmentation.
+
+
+\section quick_start_mapping_memory Mapping memory
+
+The process of getting regular CPU-side pointer to the memory of a resource in
+Direct3D is called "mapping". There are rules and restrictions to this process,
+as described in D3D12 documentation of `ID3D12Resource::Map` method.
+
+Mapping happens on the level of particular resources, not entire memory heaps,
+and so it is out of scope of this library. Just as the documentation of the `Map` function says:
+
+- Returned pointer refers to data of particular subresource, not entire memory heap.
+- You can map same resource multiple times. It is ref-counted internally.
+- Mapping is thread-safe.
+- Unmapping is not required before resource destruction.
+- Unmapping may not be required before using written data - some heap types on
+  some platforms support resources persistently mapped.
+
+When using this library, you can map and use your resources normally without
+considering whether they are created as committed resources or placed resources in one large heap.
+
+Example for buffer created and filled in `UPLOAD` heap type:
+
+\code
+const UINT64 bufSize = 65536;
+const float* bufData = (...);
+
+D3D12_RESOURCE_DESC resourceDesc = {};
+resourceDesc.Dimension = D3D12_RESOURCE_DIMENSION_BUFFER;
+resourceDesc.Alignment = 0;
+resourceDesc.Width = bufSize;
+resourceDesc.Height = 1;
+resourceDesc.DepthOrArraySize = 1;
+resourceDesc.MipLevels = 1;
+resourceDesc.Format = DXGI_FORMAT_UNKNOWN;
+resourceDesc.SampleDesc.Count = 1;
+resourceDesc.SampleDesc.Quality = 0;
+resourceDesc.Layout = D3D12_TEXTURE_LAYOUT_ROW_MAJOR;
+resourceDesc.Flags = D3D12_RESOURCE_FLAG_NONE;
+
+D3D12MA::ALLOCATION_DESC allocationDesc = {};
+allocationDesc.HeapType = D3D12_HEAP_TYPE_UPLOAD;
+
+D3D12Resource* resource;
+D3D12MA::Allocation* allocation;
+HRESULT hr = allocator->CreateResource(
+    &allocationDesc,
+    &resourceDesc,
+    D3D12_RESOURCE_STATE_GENERIC_READ,
+    NULL,
+    &allocation,
+    IID_PPV_ARGS(&resource));
+
+void* mappedPtr;
+hr = resource->Map(0, NULL, &mappedPtr);
+
+memcpy(mappedPtr, bufData, bufSize);
+
+resource->Unmap(0, NULL);
+\endcode
+
+
+\page custom_pools Custom memory pools
+
+A "pool" is a collection of memory blocks that share certain properties.
+Allocator creates 3 default pools: for `D3D12_HEAP_TYPE_DEFAULT`, `UPLOAD`, `READBACK`.
+A default pool automatically grows in size. Size of allocated blocks is also variable and managed automatically.
+Typical allocations are created in these pools. You can also create custom pools.
+
+\section custom_pools_usage Usage
+
+To create a custom pool, fill in structure D3D12MA::POOL_DESC and call function D3D12MA::Allocator::CreatePool
+to obtain object D3D12MA::Pool. Example:
+
+\code
+POOL_DESC poolDesc = {};
+poolDesc.HeapProperties.Type = D3D12_HEAP_TYPE_DEFAULT;
+
+Pool* pool;
+HRESULT hr = allocator->CreatePool(&poolDesc, &pool);
+\endcode
+
+To allocate resources out of a custom pool, only set member D3D12MA::ALLOCATION_DESC::CustomPool.
+Example:
+
+\code
+ALLOCATION_DESC allocDesc = {};
+allocDesc.CustomPool = pool;
+
+D3D12_RESOURCE_DESC resDesc = ...
+Allocation* alloc;
+hr = allocator->CreateResource(&allocDesc, &resDesc,
+    D3D12_RESOURCE_STATE_GENERIC_READ, NULL, &alloc, IID_NULL, NULL);
+\endcode
+
+All allocations must be released before releasing the pool.
+The pool must be released before relasing the allocator.
+
+\code
+alloc->Release();
+pool->Release();
+\endcode
+
+\section custom_pools_features_and_benefits Features and benefits
+
+While it is recommended to use default pools whenever possible for simplicity and to give the allocator
+more opportunities for internal optimizations, custom pools may be useful in following cases:
+
+- To keep some resources separate from others in memory.
+- To keep track of memory usage of just a specific group of resources. %Statistics can be queried using
+  D3D12MA::Pool::CalculateStatistics.
+- To use specific size of a memory block (`ID3D12Heap`). To set it, use member D3D12MA::POOL_DESC::BlockSize.
+  When set to 0, the library uses automatically determined, variable block sizes.
+- To reserve some minimum amount of memory allocated. To use it, set member D3D12MA::POOL_DESC::MinBlockCount.
+- To limit maximum amount of memory allocated. To use it, set member D3D12MA::POOL_DESC::MaxBlockCount.
+- To use extended parameters of the D3D12 memory allocation. While resources created from default pools
+  can only specify `D3D12_HEAP_TYPE_DEFAULT`, `UPLOAD`, `READBACK`, a custom pool may use non-standard
+  `D3D12_HEAP_PROPERTIES` (member D3D12MA::POOL_DESC::HeapProperties) and `D3D12_HEAP_FLAGS`
+  (D3D12MA::POOL_DESC::HeapFlags), which is useful e.g. for cross-adapter sharing or UMA
+  (see also D3D12MA::Allocator::IsUMA).
+
+New versions of this library support creating **committed allocations in custom pools**.
+It is supported only when D3D12MA::POOL_DESC::BlockSize = 0.
+To use this feature, set D3D12MA::ALLOCATION_DESC::CustomPool to the pointer to your custom pool and
+D3D12MA::ALLOCATION_DESC::Flags to D3D12MA::ALLOCATION_FLAG_COMMITTED. Example:
+
+\code
+ALLOCATION_DESC allocDesc = {};
+allocDesc.CustomPool = pool;
+allocDesc.Flags = ALLOCATION_FLAG_COMMITTED;
+
+D3D12_RESOURCE_DESC resDesc = ...
+Allocation* alloc;
+ID3D12Resource* res;
+hr = allocator->CreateResource(&allocDesc, &resDesc,
+    D3D12_RESOURCE_STATE_GENERIC_READ, NULL, &alloc, IID_PPV_ARGS(&res));
+\endcode
+
+This feature may seem unnecessary, but creating committed allocations from custom pools may be useful
+in some cases, e.g. to have separate memory usage statistics for some group of resources or to use
+extended allocation parameters, like custom `D3D12_HEAP_PROPERTIES`, which are available only in custom pools.
+
+
+\page defragmentation Defragmentation
+
+Interleaved allocations and deallocations of many objects of varying size can
+cause fragmentation over time, which can lead to a situation where the library is unable
+to find a continuous range of free memory for a new allocation despite there is
+enough free space, just scattered across many small free ranges between existing
+allocations.
+
+To mitigate this problem, you can use defragmentation feature.
+It doesn't happen automatically though and needs your cooperation,
+because %D3D12MA is a low level library that only allocates memory.
+It cannot recreate buffers and textures in a new place as it doesn't remember the contents of `D3D12_RESOURCE_DESC` structure.
+It cannot copy their contents as it doesn't record any commands to a command list.
+
+Example:
+
+\code
+D3D12MA::DEFRAGMENTATION_DESC defragDesc = {};
+defragDesc.Flags = D3D12MA::DEFRAGMENTATION_FLAG_ALGORITHM_FAST;
+
+D3D12MA::DefragmentationContext* defragCtx;
+allocator->BeginDefragmentation(&defragDesc, &defragCtx);
+
+for(;;)
+{
+    D3D12MA::DEFRAGMENTATION_PASS_MOVE_INFO pass;
+    HRESULT hr = defragCtx->BeginPass(&pass);
+    if(hr == S_OK)
+        break;
+    else if(hr != S_FALSE)
+        // Handle error...
+
+    for(UINT i = 0; i < pass.MoveCount; ++i)
+    {
+        // Inspect pass.pMoves[i].pSrcAllocation, identify what buffer/texture it represents.
+        MyEngineResourceData* resData = (MyEngineResourceData*)pMoves[i].pSrcAllocation->GetPrivateData();
+            
+        // Recreate this buffer/texture as placed at pass.pMoves[i].pDstTmpAllocation.
+        D3D12_RESOURCE_DESC resDesc = ...
+        ID3D12Resource* newRes;
+        hr = device->CreatePlacedResource(
+            pass.pMoves[i].pDstTmpAllocation->GetHeap(),
+            pass.pMoves[i].pDstTmpAllocation->GetOffset(), &resDesc,
+            D3D12_RESOURCE_STATE_COPY_DEST, NULL, IID_PPV_ARGS(&newRes));
+        // Check hr...
+
+        // Store new resource in the pDstTmpAllocation.
+        pass.pMoves[i].pDstTmpAllocation->SetResource(newRes);
+
+        // Copy its content to the new place.
+        cmdList->CopyResource(
+            pass.pMoves[i].pDstTmpAllocation->GetResource(),
+            pass.pMoves[i].pSrcAllocation->GetResource());
+    }
+        
+    // Make sure the copy commands finished executing.
+    cmdQueue->ExecuteCommandLists(...);
+    // ...
+    WaitForSingleObject(fenceEvent, INFINITE);
+
+    // Update appropriate descriptors to point to the new places...
+        
+    hr = defragCtx->EndPass(&pass);
+    if(hr == S_OK)
+        break;
+    else if(hr != S_FALSE)
+        // Handle error...
+}
+
+defragCtx->Release();
+\endcode
+
+Although functions like D3D12MA::Allocator::CreateResource()
+create an allocation and a buffer/texture at once, these are just a shortcut for
+allocating memory and creating a placed resource.
+Defragmentation works on memory allocations only. You must handle the rest manually.
+Defragmentation is an iterative process that should repreat "passes" as long as related functions
+return `S_FALSE` not `S_OK`.
+In each pass:
+
+1. D3D12MA::DefragmentationContext::BeginPass() function call:
+   - Calculates and returns the list of allocations to be moved in this pass.
+     Note this can be a time-consuming process.
+   - Reserves destination memory for them by creating temporary destination allocations
+     that you can query for their `ID3D12Heap` + offset using methods like D3D12MA::Allocation::GetHeap().
+2. Inside the pass, **you should**:
+   - Inspect the returned list of allocations to be moved.
+   - Create new buffers/textures as placed at the returned destination temporary allocations.
+   - Copy data from source to destination resources if necessary.
+   - Store the pointer to the new resource in the temporary destination allocation.
+3. D3D12MA::DefragmentationContext::EndPass() function call:
+   - Frees the source memory reserved for the allocations that are moved.
+   - Modifies source D3D12MA::Allocation objects that are moved to point to the destination reserved memory
+     and destination resource, while source resource is released.
+   - Frees `ID3D12Heap` blocks that became empty.
+
+Defragmentation algorithm tries to move all suitable allocations.
+You can, however, refuse to move some of them inside a defragmentation pass, by setting
+`pass.pMoves[i].Operation` to D3D12MA::DEFRAGMENTATION_MOVE_OPERATION_IGNORE.
+This is not recommended and may result in suboptimal packing of the allocations after defragmentation.
+If you cannot ensure any allocation can be moved, it is better to keep movable allocations separate in a custom pool.
+
+Inside a pass, for each allocation that should be moved:
+
+- You should copy its data from the source to the destination place by calling e.g. `CopyResource()`.
+  - You need to make sure these commands finished executing before the source buffers/textures are released by D3D12MA::DefragmentationContext::EndPass().
+- If a resource doesn't contain any meaningful data, e.g. it is a transient render-target texture to be cleared,
+  filled, and used temporarily in each rendering frame, you can just recreate this texture
+  without copying its data.
+- If the resource is in `D3D12_HEAP_TYPE_READBACK` memory, you can copy its data on the CPU
+  using `memcpy()`.
+- If you cannot move the allocation, you can set `pass.pMoves[i].Operation` to D3D12MA::DEFRAGMENTATION_MOVE_OPERATION_IGNORE.
+  This will cancel the move.
+  - D3D12MA::DefragmentationContext::EndPass() will then free the destination memory
+    not the source memory of the allocation, leaving it unchanged.
+- If you decide the allocation is unimportant and can be destroyed instead of moved (e.g. it wasn't used for long time),
+  you can set `pass.pMoves[i].Operation` to D3D12MA::DEFRAGMENTATION_MOVE_OPERATION_DESTROY.
+  - D3D12MA::DefragmentationContext::EndPass() will then free both source and destination memory, and will destroy the source D3D12MA::Allocation object.
+
+You can defragment a specific custom pool by calling D3D12MA::Pool::BeginDefragmentation
+or all the default pools by calling D3D12MA::Allocator::BeginDefragmentation (like in the example above).
+
+Defragmentation is always performed in each pool separately.
+Allocations are never moved between different heap types.
+The size of the destination memory reserved for a moved allocation is the same as the original one.
+Alignment of an allocation as it was determined using `GetResourceAllocationInfo()` is also respected after defragmentation.
+Buffers/textures should be recreated with the same `D3D12_RESOURCE_DESC` parameters as the original ones.
+
+You can perform the defragmentation incrementally to limit the number of allocations and bytes to be moved
+in each pass, e.g. to call it in sync with render frames and not to experience too big hitches.
+See members: D3D12MA::DEFRAGMENTATION_DESC::MaxBytesPerPass, D3D12MA::DEFRAGMENTATION_DESC::MaxAllocationsPerPass.
+
+<b>Thread safety:</b>
+It is safe to perform the defragmentation asynchronously to render frames and other Direct3D 12 and %D3D12MA
+usage, possibly from multiple threads, with the exception that allocations
+returned in D3D12MA::DEFRAGMENTATION_PASS_MOVE_INFO::pMoves shouldn't be released until the defragmentation pass is ended.
+During the call to D3D12MA::DefragmentationContext::BeginPass(), any operations on the memory pool
+affected by the defragmentation are blocked by a mutex.
+
+What it means in practice is that you shouldn't free any allocations from the defragmented pool
+since the moment a call to `BeginPass` begins. Otherwise, a thread performing the `allocation->Release()`
+would block for the time `BeginPass` executes and then free the allocation when it finishes, while the allocation
+could have ended up on the list of allocations to move.
+A solution to freeing allocations during defragmentation is to find such allocation on the list
+`pass.pMoves[i]` and set its operation to D3D12MA::DEFRAGMENTATION_MOVE_OPERATION_DESTROY instead of
+calling `allocation->Release()`, or simply deferring the release to the time after defragmentation finished.
+
+<b>Mapping</b> is out of scope of this library and so it is not preserved after an allocation is moved during defragmentation.
+You need to map the new resource yourself if needed.
+
+\note Defragmentation is not supported in custom pools created with D3D12MA::POOL_FLAG_ALGORITHM_LINEAR.
+
+
+\page statistics Statistics
+
+This library contains several functions that return information about its internal state,
+especially the amount of memory allocated from D3D12.
+
+\section statistics_numeric_statistics Numeric statistics
+
+If you need to obtain basic statistics about memory usage per memory segment group, together with current budget,
+you can call function D3D12MA::Allocator::GetBudget() and inspect structure D3D12MA::Budget.
+This is useful to keep track of memory usage and stay withing budget.
+Example:
+
+\code
+D3D12MA::Budget localBudget;
+allocator->GetBudget(&localBudget, NULL);
+
+printf("My GPU memory currently has %u allocations taking %llu B,\n",
+    localBudget.Statistics.AllocationCount,
+    localBudget.Statistics.AllocationBytes);
+printf("allocated out of %u D3D12 memory heaps taking %llu B,\n",
+    localBudget.Statistics.BlockCount,
+    localBudget.Statistics.BlockBytes);
+printf("D3D12 reports total usage %llu B with budget %llu B.\n",
+    localBudget.UsageBytes,
+    localBudget.BudgetBytes);
+\endcode
+
+You can query for more detailed statistics per heap type, memory segment group, and totals,
+including minimum and maximum allocation size and unused range size,
+by calling function D3D12MA::Allocator::CalculateStatistics() and inspecting structure D3D12MA::TotalStatistics.
+This function is slower though, as it has to traverse all the internal data structures,
+so it should be used only for debugging purposes.
+
+You can query for statistics of a custom pool using function D3D12MA::Pool::GetStatistics()
+or D3D12MA::Pool::CalculateStatistics().
+
+You can query for information about a specific allocation using functions of the D3D12MA::Allocation class,
+e.g. `GetSize()`, `GetOffset()`, `GetHeap()`.
+
+\section statistics_json_dump JSON dump
+
+You can dump internal state of the allocator to a string in JSON format using function D3D12MA::Allocator::BuildStatsString().
+The result is guaranteed to be correct JSON.
+It uses Windows Unicode (UTF-16) encoding.
+Any strings provided by user (see D3D12MA::Allocation::SetName())
+are copied as-is and properly escaped for JSON.
+It must be freed using function D3D12MA::Allocator::FreeStatsString().
+
+The format of this JSON string is not part of official documentation of the library,
+but it will not change in backward-incompatible way without increasing library major version number
+and appropriate mention in changelog.
+
+The JSON string contains all the data that can be obtained using D3D12MA::Allocator::CalculateStatistics().
+It can also contain detailed map of allocated memory blocks and their regions -
+free and occupied by allocations.
+This allows e.g. to visualize the memory or assess fragmentation.
+
+
+\page resource_aliasing Resource aliasing (overlap)
+
+New explicit graphics APIs (Vulkan and Direct3D 12), thanks to manual memory
+management, give an opportunity to alias (overlap) multiple resources in the
+same region of memory - a feature not available in the old APIs (Direct3D 11, OpenGL).
+It can be useful to save video memory, but it must be used with caution.
+
+For example, if you know the flow of your whole render frame in advance, you
+are going to use some intermediate textures or buffers only during a small range of render passes,
+and you know these ranges don't overlap in time, you can create these resources in
+the same place in memory, even if they have completely different parameters (width, height, format etc.).
+
+![Resource aliasing (overlap)](../gfx/Aliasing.png)
+
+Such scenario is possible using D3D12MA, but you need to create your resources
+using special function D3D12MA::Allocator::CreateAliasingResource.
+Before that, you need to allocate memory with parameters calculated using formula:
+
+- allocation size = max(size of each resource)
+- allocation alignment = max(alignment of each resource)
+
+Following example shows two different textures created in the same place in memory,
+allocated to fit largest of them.
+
+\code
+D3D12_RESOURCE_DESC resDesc1 = {};
+resDesc1.Dimension = D3D12_RESOURCE_DIMENSION_TEXTURE2D;
+resDesc1.Alignment = 0;
+resDesc1.Width = 1920;
+resDesc1.Height = 1080;
+resDesc1.DepthOrArraySize = 1;
+resDesc1.MipLevels = 1;
+resDesc1.Format = DXGI_FORMAT_R8G8B8A8_UNORM;
+resDesc1.SampleDesc.Count = 1;
+resDesc1.SampleDesc.Quality = 0;
+resDesc1.Layout = D3D12_TEXTURE_LAYOUT_UNKNOWN;
+resDesc1.Flags = D3D12_RESOURCE_FLAG_ALLOW_RENDER_TARGET | D3D12_RESOURCE_FLAG_ALLOW_UNORDERED_ACCESS;
+
+D3D12_RESOURCE_DESC resDesc2 = {};
+resDesc2.Dimension = D3D12_RESOURCE_DIMENSION_TEXTURE2D;
+resDesc2.Alignment = 0;
+resDesc2.Width = 1024;
+resDesc2.Height = 1024;
+resDesc2.DepthOrArraySize = 1;
+resDesc2.MipLevels = 0;
+resDesc2.Format = DXGI_FORMAT_R8G8B8A8_UNORM;
+resDesc2.SampleDesc.Count = 1;
+resDesc2.SampleDesc.Quality = 0;
+resDesc2.Layout = D3D12_TEXTURE_LAYOUT_UNKNOWN;
+resDesc2.Flags = D3D12_RESOURCE_FLAG_ALLOW_RENDER_TARGET;
+
+const D3D12_RESOURCE_ALLOCATION_INFO allocInfo1 =
+    device->GetResourceAllocationInfo(0, 1, &resDesc1);
+const D3D12_RESOURCE_ALLOCATION_INFO allocInfo2 =
+    device->GetResourceAllocationInfo(0, 1, &resDesc2);
+
+D3D12_RESOURCE_ALLOCATION_INFO finalAllocInfo = {};
+finalAllocInfo.Alignment = std::max(allocInfo1.Alignment, allocInfo2.Alignment);
+finalAllocInfo.SizeInBytes = std::max(allocInfo1.SizeInBytes, allocInfo2.SizeInBytes);
+
+D3D12MA::ALLOCATION_DESC allocDesc = {};
+allocDesc.HeapType = D3D12_HEAP_TYPE_DEFAULT;
+allocDesc.ExtraHeapFlags = D3D12_HEAP_FLAG_ALLOW_ONLY_RT_DS_TEXTURES;
+
+D3D12MA::Allocation* alloc;
+hr = allocator->AllocateMemory(&allocDesc, &finalAllocInfo, &alloc);
+assert(alloc != NULL && alloc->GetHeap() != NULL);
+
+ID3D12Resource* res1;
+hr = allocator->CreateAliasingResource(
+    alloc,
+    0, // AllocationLocalOffset
+    &resDesc1,
+    D3D12_RESOURCE_STATE_COMMON,
+    NULL, // pOptimizedClearValue
+    IID_PPV_ARGS(&res1));
+
+ID3D12Resource* res2;
+hr = allocator->CreateAliasingResource(
+    alloc,
+    0, // AllocationLocalOffset
+    &resDesc2,
+    D3D12_RESOURCE_STATE_COMMON,
+    NULL, // pOptimizedClearValue
+    IID_PPV_ARGS(&res2));
+
+// You can use res1 and res2, but not at the same time!
+
+res2->Release();
+res1->Release();
+alloc->Release();
+\endcode
+
+Remember that using resouces that alias in memory requires proper synchronization.
+You need to issue a special barrier of type `D3D12_RESOURCE_BARRIER_TYPE_ALIASING`.
+You also need to treat a resource after aliasing as uninitialized - containing garbage data.
+For example, if you use `res1` and then want to use `res2`, you need to first initialize `res2`
+using either Clear, Discard, or Copy to the entire resource.
+
+Additional considerations:
+
+- D3D12 also allows to interpret contents of memory between aliasing resources consistently in some cases,
+  which is called "data inheritance". For details, see
+  Microsoft documentation chapter "Memory Aliasing and Data Inheritance".
+- You can create more complex layout where different textures and buffers are bound
+  at different offsets inside one large allocation. For example, one can imagine
+  a big texture used in some render passes, aliasing with a set of many small buffers
+  used in some further passes. To bind a resource at non-zero offset of an allocation,
+  call D3D12MA::Allocator::CreateAliasingResource with appropriate value of `AllocationLocalOffset` parameter.
+- Resources of the three categories: buffers, textures with `RENDER_TARGET` or `DEPTH_STENCIL` flags, and all other textures,
+  can be placed in the same memory only when `allocator->GetD3D12Options().ResourceHeapTier >= D3D12_RESOURCE_HEAP_TIER_2`.
+  Otherwise they must be placed in different memory heap types, and thus aliasing them is not possible.
+
+
+\page linear_algorithm Linear allocation algorithm
+
+Each D3D12 memory block managed by this library has accompanying metadata that
+keeps track of used and unused regions. By default, the metadata structure and
+algorithm tries to find best place for new allocations among free regions to
+optimize memory usage. This way you can allocate and free objects in any order.
+
+![Default allocation algorithm](../gfx/Linear_allocator_1_algo_default.png)
+
+Sometimes there is a need to use simpler, linear allocation algorithm. You can
+create custom pool that uses such algorithm by adding flag
+D3D12MA::POOL_FLAG_ALGORITHM_LINEAR to D3D12MA::POOL_DESC::Flags while creating
+D3D12MA::Pool object. Then an alternative metadata management is used. It always
+creates new allocations after last one and doesn't reuse free regions after
+allocations freed in the middle. It results in better allocation performance and
+less memory consumed by metadata.
+
+![Linear allocation algorithm](../gfx/Linear_allocator_2_algo_linear.png)
+
+With this one flag, you can create a custom pool that can be used in many ways:
+free-at-once, stack, double stack, and ring buffer. See below for details.
+You don't need to specify explicitly which of these options you are going to use - it is detected automatically.
+
+\section linear_algorithm_free_at_once Free-at-once
+
+In a pool that uses linear algorithm, you still need to free all the allocations
+individually by calling `allocation->Release()`. You can free
+them in any order. New allocations are always made after last one - free space
+in the middle is not reused. However, when you release all the allocation and
+the pool becomes empty, allocation starts from the beginning again. This way you
+can use linear algorithm to speed up creation of allocations that you are going
+to release all at once.
+
+![Free-at-once](../gfx/Linear_allocator_3_free_at_once.png)
+
+This mode is also available for pools created with D3D12MA::POOL_DESC::MaxBlockCount
+value that allows multiple memory blocks.
+
+\section linear_algorithm_stack Stack
+
+When you free an allocation that was created last, its space can be reused.
+Thanks to this, if you always release allocations in the order opposite to their
+creation (LIFO - Last In First Out), you can achieve behavior of a stack.
+
+![Stack](../gfx/Linear_allocator_4_stack.png)
+
+This mode is also available for pools created with D3D12MA::POOL_DESC::MaxBlockCount
+value that allows multiple memory blocks.
+
+\section linear_algorithm_double_stack Double stack
+
+The space reserved by a custom pool with linear algorithm may be used by two
+stacks:
+
+- First, default one, growing up from offset 0.
+- Second, "upper" one, growing down from the end towards lower offsets.
+
+To make allocation from the upper stack, add flag D3D12MA::ALLOCATION_FLAG_UPPER_ADDRESS
+to D3D12MA::ALLOCATION_DESC::Flags.
+
+![Double stack](../gfx/Linear_allocator_7_double_stack.png)
+
+Double stack is available only in pools with one memory block -
+D3D12MA::POOL_DESC::MaxBlockCount must be 1. Otherwise behavior is undefined.
+
+When the two stacks' ends meet so there is not enough space between them for a
+new allocation, such allocation fails with usual `E_OUTOFMEMORY` error.
+
+\section linear_algorithm_ring_buffer Ring buffer
+
+When you free some allocations from the beginning and there is not enough free space
+for a new one at the end of a pool, allocator's "cursor" wraps around to the
+beginning and starts allocation there. Thanks to this, if you always release
+allocations in the same order as you created them (FIFO - First In First Out),
+you can achieve behavior of a ring buffer / queue.
+
+![Ring buffer](../gfx/Linear_allocator_5_ring_buffer.png)
+
+Ring buffer is available only in pools with one memory block -
+D3D12MA::POOL_DESC::MaxBlockCount must be 1. Otherwise behavior is undefined.
+
+\section linear_algorithm_additional_considerations Additional considerations
+
+Linear algorithm can also be used with \ref virtual_allocator.
+See flag D3D12MA::VIRTUAL_BLOCK_FLAG_ALGORITHM_LINEAR.
+
+
+\page virtual_allocator Virtual allocator
+
+As an extra feature, the core allocation algorithm of the library is exposed through a simple and convenient API of "virtual allocator".
+It doesn't allocate any real GPU memory. It just keeps track of used and free regions of a "virtual block".
+You can use it to allocate your own memory or other objects, even completely unrelated to D3D12.
+A common use case is sub-allocation of pieces of one large GPU buffer.
+
+\section virtual_allocator_creating_virtual_block Creating virtual block
+
+To use this functionality, there is no main "allocator" object.
+You don't need to have D3D12MA::Allocator object created.
+All you need to do is to create a separate D3D12MA::VirtualBlock object for each block of memory you want to be managed by the allocator:
+
+-# Fill in D3D12MA::ALLOCATOR_DESC structure.
+-# Call D3D12MA::CreateVirtualBlock. Get new D3D12MA::VirtualBlock object.
+
+Example:
+
+\code
+D3D12MA::VIRTUAL_BLOCK_DESC blockDesc = {};
+blockDesc.Size = 1048576; // 1 MB
+
+D3D12MA::VirtualBlock *block;
+HRESULT hr = CreateVirtualBlock(&blockDesc, &block);
+\endcode
+
+\section virtual_allocator_making_virtual_allocations Making virtual allocations
+
+D3D12MA::VirtualBlock object contains internal data structure that keeps track of free and occupied regions
+using the same code as the main D3D12 memory allocator.
+A single allocation is identified by a lightweight structure D3D12MA::VirtualAllocation.
+You will also likely want to know the offset at which the allocation was made in the block.
+
+In order to make an allocation:
+
+-# Fill in D3D12MA::VIRTUAL_ALLOCATION_DESC structure.
+-# Call D3D12MA::VirtualBlock::Allocate. Get new D3D12MA::VirtualAllocation value that identifies the allocation.
+
+Example:
+
+\code
+D3D12MA::VIRTUAL_ALLOCATION_DESC allocDesc = {};
+allocDesc.Size = 4096; // 4 KB
+
+D3D12MA::VirtualAllocation alloc;
+UINT64 allocOffset;
+hr = block->Allocate(&allocDesc, &alloc, &allocOffset);
+if(SUCCEEDED(hr))
+{
+    // Use the 4 KB of your memory starting at allocOffset.
+}
+else
+{
+    // Allocation failed - no space for it could be found. Handle this error!
+}
+\endcode
+
+\section virtual_allocator_deallocation Deallocation
+
+When no longer needed, an allocation can be freed by calling D3D12MA::VirtualBlock::FreeAllocation.
+
+When whole block is no longer needed, the block object can be released by calling `block->Release()`.
+All allocations must be freed before the block is destroyed, which is checked internally by an assert.
+However, if you don't want to call `block->FreeAllocation` for each allocation, you can use D3D12MA::VirtualBlock::Clear to free them all at once -
+a feature not available in normal D3D12 memory allocator.
+
+Example:
+
+\code
+block->FreeAllocation(alloc);
+block->Release();
+\endcode
+
+\section virtual_allocator_allocation_parameters Allocation parameters
+
+You can attach a custom pointer to each allocation by using D3D12MA::VirtualBlock::SetAllocationPrivateData.
+Its default value is `NULL`.
+It can be used to store any data that needs to be associated with that allocation - e.g. an index, a handle, or a pointer to some
+larger data structure containing more information. Example:
+
+\code
+struct CustomAllocData
+{
+    std::string m_AllocName;
+};
+CustomAllocData* allocData = new CustomAllocData();
+allocData->m_AllocName = "My allocation 1";
+block->SetAllocationPrivateData(alloc, allocData);
+\endcode
+
+The pointer can later be fetched, along with allocation offset and size, by passing the allocation handle to function
+D3D12MA::VirtualBlock::GetAllocationInfo and inspecting returned structure D3D12MA::VIRTUAL_ALLOCATION_INFO.
+If you allocated a new object to be used as the custom pointer, don't forget to delete that object before freeing the allocation!
+Example:
+
+\code
+VIRTUAL_ALLOCATION_INFO allocInfo;
+block->GetAllocationInfo(alloc, &allocInfo);
+delete (CustomAllocData*)allocInfo.pPrivateData;
+
+block->FreeAllocation(alloc);
+\endcode
+
+\section virtual_allocator_alignment_and_units Alignment and units
+
+It feels natural to express sizes and offsets in bytes.
+If an offset of an allocation needs to be aligned to a multiply of some number (e.g. 4 bytes), you can fill optional member
+D3D12MA::VIRTUAL_ALLOCATION_DESC::Alignment to request it. Example:
+
+\code
+D3D12MA::VIRTUAL_ALLOCATION_DESC allocDesc = {};
+allocDesc.Size = 4096; // 4 KB
+allocDesc.Alignment = 4; // Returned offset must be a multiply of 4 B
+
+D3D12MA::VirtualAllocation alloc;
+UINT64 allocOffset;
+hr = block->Allocate(&allocDesc, &alloc, &allocOffset);
+\endcode
+
+Alignments of different allocations made from one block may vary.
+However, if all alignments and sizes are always multiply of some size e.g. 4 B or `sizeof(MyDataStruct)`,
+you can express all sizes, alignments, and offsets in multiples of that size instead of individual bytes.
+It might be more convenient, but you need to make sure to use this new unit consistently in all the places:
+
+- D3D12MA::VIRTUAL_BLOCK_DESC::Size
+- D3D12MA::VIRTUAL_ALLOCATION_DESC::Size and D3D12MA::VIRTUAL_ALLOCATION_DESC::Alignment
+- Using offset returned by D3D12MA::VirtualBlock::Allocate and D3D12MA::VIRTUAL_ALLOCATION_INFO::Offset
+
+\section virtual_allocator_statistics Statistics
+
+You can obtain brief statistics of a virtual block using D3D12MA::VirtualBlock::GetStatistics().
+The function fills structure D3D12MA::Statistics - same as used by the normal D3D12 memory allocator.
+Example:
+
+\code
+D3D12MA::Statistics stats;
+block->GetStatistics(&stats);
+printf("My virtual block has %llu bytes used by %u virtual allocations\n",
+    stats.AllocationBytes, stats.AllocationCount);
+\endcode
+
+More detailed statistics can be obtained using function D3D12MA::VirtualBlock::CalculateStatistics(),
+but they are slower to calculate.
+
+You can also request a full list of allocations and free regions as a string in JSON format by calling
+D3D12MA::VirtualBlock::BuildStatsString.
+Returned string must be later freed using D3D12MA::VirtualBlock::FreeStatsString.
+The format of this string may differ from the one returned by the main D3D12 allocator, but it is similar.
+
+\section virtual_allocator_additional_considerations Additional considerations
+
+Alternative, linear algorithm can be used with virtual allocator - see flag
+D3D12MA::VIRTUAL_BLOCK_FLAG_ALGORITHM_LINEAR and documentation: \ref linear_algorithm.
+
+Note that the "virtual allocator" functionality is implemented on a level of individual memory blocks.
+Keeping track of a whole collection of blocks, allocating new ones when out of free space,
+deleting empty ones, and deciding which one to try first for a new allocation must be implemented by the user.
+
+
+\page configuration Configuration
+
+Please check file `D3D12MemAlloc.cpp` lines between "Configuration Begin" and
+"Configuration End" to find macros that you can define to change the behavior of
+the library, primarily for debugging purposes.
+
+\section custom_memory_allocator Custom CPU memory allocator
+
+If you use custom allocator for CPU memory rather than default C++ operator `new`
+and `delete` or `malloc` and `free` functions, you can make this library using
+your allocator as well by filling structure D3D12MA::ALLOCATION_CALLBACKS and
+passing it as optional member D3D12MA::ALLOCATOR_DESC::pAllocationCallbacks.
+Functions pointed there will be used by the library to make any CPU-side
+allocations. Example:
+
+\code
+#include <malloc.h>
+
+void* CustomAllocate(size_t Size, size_t Alignment, void* pPrivateData)
+{
+    void* memory = _aligned_malloc(Size, Alignment);
+    // Your extra bookkeeping here...
+    return memory;
+}
+
+void CustomFree(void* pMemory, void* pPrivateData)
+{
+    // Your extra bookkeeping here...
+    _aligned_free(pMemory);
+}
+
+(...)
+
+D3D12MA::ALLOCATION_CALLBACKS allocationCallbacks = {};
+allocationCallbacks.pAllocate = &CustomAllocate;
+allocationCallbacks.pFree = &CustomFree;
+
+D3D12MA::ALLOCATOR_DESC allocatorDesc = {};
+allocatorDesc.pDevice = device;
+allocatorDesc.pAdapter = adapter;
+allocatorDesc.pAllocationCallbacks = &allocationCallbacks;
+
+D3D12MA::Allocator* allocator;
+HRESULT hr = D3D12MA::CreateAllocator(&allocatorDesc, &allocator);
+\endcode
+
+
+\section debug_margins Debug margins
+
+By default, allocations are laid out in memory blocks next to each other if possible
+(considering required alignment returned by `ID3D12Device::GetResourceAllocationInfo`).
+
+![Allocations without margin](../gfx/Margins_1.png)
+
+Define macro `D3D12MA_DEBUG_MARGIN` to some non-zero value (e.g. 16) inside "D3D12MemAlloc.cpp"
+to enforce specified number of bytes as a margin after every allocation.
+
+![Allocations with margin](../gfx/Margins_2.png)
+
+If your bug goes away after enabling margins, it means it may be caused by memory
+being overwritten outside of allocation boundaries. It is not 100% certain though.
+Change in application behavior may also be caused by different order and distribution
+of allocations across memory blocks after margins are applied.
+
+Margins work with all memory heap types.
+
+Margin is applied only to placed allocations made out of memory heaps and not to committed
+allocations, which have their own, implicit memory heap of specific size.
+It is thus not applied to allocations made using D3D12MA::ALLOCATION_FLAG_COMMITTED flag
+or those automatically decided to put into committed allocations, e.g. due to its large size.
+
+Margins appear in [JSON dump](@ref statistics_json_dump) as part of free space.
+
+Note that enabling margins increases memory usage and fragmentation.
+
+Margins do not apply to \ref virtual_allocator.
+
+
+\page general_considerations General considerations
+
+\section general_considerations_thread_safety Thread safety
+
+- The library has no global state, so separate D3D12MA::Allocator objects can be used independently.
+  In typical applications there should be no need to create multiple such objects though - one per `ID3D12Device` is enough.
+- All calls to methods of D3D12MA::Allocator class are safe to be made from multiple
+  threads simultaneously because they are synchronized internally when needed.
+- When the allocator is created with D3D12MA::ALLOCATOR_FLAG_SINGLETHREADED,
+  calls to methods of D3D12MA::Allocator class must be made from a single thread or synchronized by the user.
+  Using this flag may improve performance.
+- D3D12MA::VirtualBlock is not safe to be used from multiple threads simultaneously.
+
+\section general_considerations_versioning_and_compatibility Versioning and compatibility
+
+The library uses [**Semantic Versioning**](https://semver.org/),
+which means version numbers follow convention: Major.Minor.Patch (e.g. 2.3.0), where:
+
+- Incremented Patch version means a release is backward- and forward-compatible,
+  introducing only some internal improvements, bug fixes, optimizations etc.
+  or changes that are out of scope of the official API described in this documentation.
+- Incremented Minor version means a release is backward-compatible,
+  so existing code that uses the library should continue to work, while some new
+  symbols could have been added: new structures, functions, new values in existing
+  enums and bit flags, new structure members, but not new function parameters.
+- Incrementing Major version means a release could break some backward compatibility.
+
+All changes between official releases are documented in file "CHANGELOG.md".
+
+\warning Backward compatiblity is considered on the level of C++ source code, not binary linkage.
+Adding new members to existing structures is treated as backward compatible if initializing
+the new members to binary zero results in the old behavior.
+You should always fully initialize all library structures to zeros and not rely on their
+exact binary size.
+
+\section general_considerations_features_not_supported Features not supported
+
+Features deliberately excluded from the scope of this library:
+
+- **Descriptor allocation.** Although also called "heaps", objects that represent
+  descriptors are separate part of the D3D12 API from buffers and textures.
+  You can still use \ref virtual_allocator to manage descriptors and their ranges inside a descriptor heap.
+- **Support for reserved (tiled) resources.** We don't recommend using them.
+- Support for `ID3D12Device::Evict` and `MakeResident`. We don't recommend using them.
+  You can call them on the D3D12 objects manually.
+  Plese keep in mind, however, that eviction happens on the level of entire `ID3D12Heap` memory blocks
+  and not individual buffers or textures which may be placed inside them.
+- **Handling CPU memory allocation failures.** When dynamically creating small C++
+  objects in CPU memory (not the GPU memory), allocation failures are not
+  handled gracefully, because that would complicate code significantly and
+  is usually not needed in desktop PC applications anyway.
+  Success of an allocation is just checked with an assert.
+- **Code free of any compiler warnings.**
+  There are many preprocessor macros that make some variables unused, function parameters unreferenced,
+  or conditional expressions constant in some configurations.
+  The code of this library should not be bigger or more complicated just to silence these warnings.
+  It is recommended to disable such warnings instead.
+- This is a C++ library. **Bindings or ports to any other programming languages** are welcome as external projects but
+  are not going to be included into this repository.
+*/
diff --git a/thirdparty/d3d12ma/D3D12MemAlloc.natvis b/thirdparty/d3d12ma/D3D12MemAlloc.natvis
new file mode 100644
index 0000000000..957edc929d
--- /dev/null
+++ b/thirdparty/d3d12ma/D3D12MemAlloc.natvis
@@ -0,0 +1,58 @@
+<?xml version="1.0" encoding="utf-8"?> 
+<AutoVisualizer xmlns="http://schemas.microsoft.com/vstudio/debugger/natvis/2010">
+  <Type Name="D3D12MA::Vector&lt;*&gt;">
+    <DisplayString>{{ Count={m_Count} }}</DisplayString>
+    <Expand>
+      <Item Name="[Count]">m_Count</Item>
+      <Item Name="[Capacity]">m_Capacity</Item>
+      <ArrayItems>
+        <Size>m_Count</Size>
+        <ValuePointer>m_pArray</ValuePointer>
+      </ArrayItems>
+    </Expand>
+  </Type>
+
+  <Type Name="D3D12MA::List&lt;*&gt;">
+    <DisplayString>{{ Count={m_Count} }}</DisplayString>
+    <Expand>
+      <Item Name="[Count]">m_Count</Item>
+      <LinkedListItems>
+        <Size>m_Count</Size>
+        <HeadPointer>m_pFront</HeadPointer>
+        <NextPointer>pNext</NextPointer>
+        <ValueNode>Value</ValueNode>
+      </LinkedListItems>
+    </Expand>
+  </Type>
+  
+  <!--
+    Due to custom way of accesing next items in
+    D3D12MA::IntrusiveLinkedList via methods in provided type traits,
+    every specialization must be manually added with
+    custom <NextPointer> field describing proper way of iterating the list.
+  -->
+  <Type Name="D3D12MA::IntrusiveLinkedList&lt;D3D12MA::CommittedAllocationListItemTraits&gt;">
+    <DisplayString>{{ Count={m_Count} }}</DisplayString>
+    <Expand>
+      <Item Name="[Count]">m_Count</Item>
+      <LinkedListItems>
+        <Size>m_Count</Size>
+        <HeadPointer>m_Front</HeadPointer>
+        <NextPointer>m_Committed.next</NextPointer>
+        <ValueNode>*this</ValueNode>
+      </LinkedListItems>
+    </Expand>
+  </Type>
+  <Type Name="D3D12MA::IntrusiveLinkedList&lt;D3D12MA::PoolListItemTraits&gt;">
+    <DisplayString>{{ Count={m_Count} }}</DisplayString>
+    <Expand>
+      <Item Name="[Count]">m_Count</Item>
+      <LinkedListItems>
+        <Size>m_Count</Size>
+        <HeadPointer>m_Front</HeadPointer>
+        <NextPointer>m_NextPool</NextPointer>
+        <ValueNode>*this</ValueNode>
+      </LinkedListItems>
+    </Expand>
+  </Type>
+</AutoVisualizer>
\ No newline at end of file
diff --git a/thirdparty/d3d12ma/LICENSE.txt b/thirdparty/d3d12ma/LICENSE.txt
new file mode 100644
index 0000000000..bc2ab4dc05
--- /dev/null
+++ b/thirdparty/d3d12ma/LICENSE.txt
@@ -0,0 +1,19 @@
+Copyright (c) 2019-2022 Advanced Micro Devices, Inc. All rights reserved.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+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.  IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
diff --git a/thirdparty/d3d12ma/NOTICES.txt b/thirdparty/d3d12ma/NOTICES.txt
new file mode 100644
index 0000000000..98bccc5de5
--- /dev/null
+++ b/thirdparty/d3d12ma/NOTICES.txt
@@ -0,0 +1,52 @@
+Notices and licenses file
+_________________________
+
+AMD copyrighted code (MIT) 
+Copyright (c) 2019 Advanced Micro Devices, Inc. All rights reserved. 
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation 
+files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, 
+modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the 
+Software is furnished to do so, subject to the following conditions: 
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the 
+Software. 
+
+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.  IN NO EVENT SHALL THE AUTHORS OR 
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, 
+ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+
+Dependecnies on microsoft-directx-graphics-samples v-u (MIT) 
+
+Copyright (c) 2019 Advanced Micro Devices, Inc. All rights reserved. 
+Copyright (c) Microsoft. All rights reserved.
+
+This code is licensed under the MIT License (MIT).
+THIS CODE IS PROVIDED *AS IS* WITHOUT WARRANTY OF
+ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING ANY
+IMPLIED WARRANTIES OF FITNESS FOR A PARTICULAR
+PURPOSE, MERCHANTABILITY, OR NON-INFRINGEMENT.
+
+
+gpuopen-librariesandsdks-vulkanmemoryallocator v-u (MIT) 
+Copyright (c) 2019-2022 Advanced Micro Devices, Inc. All rights reserved. 
+
+Permission is hereby granted, free of charge, to any person obtaining a copy 
+of this software and associated documentation files (the "Software"), to deal 
+in the Software without restriction, including without limitation the rights 
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 
+copies of the Software, and to permit persons to whom the Software is 
+furnished to do so, subject to the following conditions: 
+
+The above copyright notice and this permission notice shall be included in 
+all copies or substantial portions of the Software. 
+
+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.  IN NO EVENT SHALL THE 
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 
+THE SOFTWARE.
diff --git a/thirdparty/directx_headers/LICENSE b/thirdparty/directx_headers/LICENSE
new file mode 100644
index 0000000000..63447fd8bb
--- /dev/null
+++ b/thirdparty/directx_headers/LICENSE
@@ -0,0 +1,21 @@
+Copyright (c) Microsoft Corporation.
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+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. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
\ No newline at end of file
diff --git a/thirdparty/directx_headers/d3d12.h b/thirdparty/directx_headers/d3d12.h
new file mode 100644
index 0000000000..07355f558c
--- /dev/null
+++ b/thirdparty/directx_headers/d3d12.h
@@ -0,0 +1,28706 @@
+/*-------------------------------------------------------------------------------------
+ *
+ * Copyright (c) Microsoft Corporation
+ * Licensed under the MIT license
+ *
+ *-------------------------------------------------------------------------------------*/
+
+
+/* this ALWAYS GENERATED file contains the definitions for the interfaces */
+
+
+ /* File created by MIDL compiler version 8.01.0628 */
+
+
+
+/* verify that the <rpcndr.h> version is high enough to compile this file*/
+#ifndef __REQUIRED_RPCNDR_H_VERSION__
+#define __REQUIRED_RPCNDR_H_VERSION__ 500
+#endif
+
+/* verify that the <rpcsal.h> version is high enough to compile this file*/
+#ifndef __REQUIRED_RPCSAL_H_VERSION__
+#define __REQUIRED_RPCSAL_H_VERSION__ 100
+#endif
+
+#include "rpc.h"
+#include "rpcndr.h"
+
+#ifndef __RPCNDR_H_VERSION__
+#error this stub requires an updated version of <rpcndr.h>
+#endif /* __RPCNDR_H_VERSION__ */
+
+#ifndef COM_NO_WINDOWS_H
+#include "windows.h"
+#include "ole2.h"
+#endif /*COM_NO_WINDOWS_H*/
+
+#ifndef __d3d12_h__
+#define __d3d12_h__
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+#pragma once
+#endif
+
+#ifndef DECLSPEC_XFGVIRT
+#if defined(_CONTROL_FLOW_GUARD_XFG)
+#define DECLSPEC_XFGVIRT(base, func) __declspec(xfg_virtual(base, func))
+#else
+#define DECLSPEC_XFGVIRT(base, func)
+#endif
+#endif
+
+/* Forward Declarations */ 
+
+#ifndef __ID3D12Object_FWD_DEFINED__
+#define __ID3D12Object_FWD_DEFINED__
+typedef interface ID3D12Object ID3D12Object;
+
+#endif 	/* __ID3D12Object_FWD_DEFINED__ */
+
+
+#ifndef __ID3D12DeviceChild_FWD_DEFINED__
+#define __ID3D12DeviceChild_FWD_DEFINED__
+typedef interface ID3D12DeviceChild ID3D12DeviceChild;
+
+#endif 	/* __ID3D12DeviceChild_FWD_DEFINED__ */
+
+
+#ifndef __ID3D12RootSignature_FWD_DEFINED__
+#define __ID3D12RootSignature_FWD_DEFINED__
+typedef interface ID3D12RootSignature ID3D12RootSignature;
+
+#endif 	/* __ID3D12RootSignature_FWD_DEFINED__ */
+
+
+#ifndef __ID3D12RootSignatureDeserializer_FWD_DEFINED__
+#define __ID3D12RootSignatureDeserializer_FWD_DEFINED__
+typedef interface ID3D12RootSignatureDeserializer ID3D12RootSignatureDeserializer;
+
+#endif 	/* __ID3D12RootSignatureDeserializer_FWD_DEFINED__ */
+
+
+#ifndef __ID3D12VersionedRootSignatureDeserializer_FWD_DEFINED__
+#define __ID3D12VersionedRootSignatureDeserializer_FWD_DEFINED__
+typedef interface ID3D12VersionedRootSignatureDeserializer ID3D12VersionedRootSignatureDeserializer;
+
+#endif 	/* __ID3D12VersionedRootSignatureDeserializer_FWD_DEFINED__ */
+
+
+#ifndef __ID3D12Pageable_FWD_DEFINED__
+#define __ID3D12Pageable_FWD_DEFINED__
+typedef interface ID3D12Pageable ID3D12Pageable;
+
+#endif 	/* __ID3D12Pageable_FWD_DEFINED__ */
+
+
+#ifndef __ID3D12Heap_FWD_DEFINED__
+#define __ID3D12Heap_FWD_DEFINED__
+typedef interface ID3D12Heap ID3D12Heap;
+
+#endif 	/* __ID3D12Heap_FWD_DEFINED__ */
+
+
+#ifndef __ID3D12Resource_FWD_DEFINED__
+#define __ID3D12Resource_FWD_DEFINED__
+typedef interface ID3D12Resource ID3D12Resource;
+
+#endif 	/* __ID3D12Resource_FWD_DEFINED__ */
+
+
+#ifndef __ID3D12CommandAllocator_FWD_DEFINED__
+#define __ID3D12CommandAllocator_FWD_DEFINED__
+typedef interface ID3D12CommandAllocator ID3D12CommandAllocator;
+
+#endif 	/* __ID3D12CommandAllocator_FWD_DEFINED__ */
+
+
+#ifndef __ID3D12Fence_FWD_DEFINED__
+#define __ID3D12Fence_FWD_DEFINED__
+typedef interface ID3D12Fence ID3D12Fence;
+
+#endif 	/* __ID3D12Fence_FWD_DEFINED__ */
+
+
+#ifndef __ID3D12Fence1_FWD_DEFINED__
+#define __ID3D12Fence1_FWD_DEFINED__
+typedef interface ID3D12Fence1 ID3D12Fence1;
+
+#endif 	/* __ID3D12Fence1_FWD_DEFINED__ */
+
+
+#ifndef __ID3D12PipelineState_FWD_DEFINED__
+#define __ID3D12PipelineState_FWD_DEFINED__
+typedef interface ID3D12PipelineState ID3D12PipelineState;
+
+#endif 	/* __ID3D12PipelineState_FWD_DEFINED__ */
+
+
+#ifndef __ID3D12DescriptorHeap_FWD_DEFINED__
+#define __ID3D12DescriptorHeap_FWD_DEFINED__
+typedef interface ID3D12DescriptorHeap ID3D12DescriptorHeap;
+
+#endif 	/* __ID3D12DescriptorHeap_FWD_DEFINED__ */
+
+
+#ifndef __ID3D12QueryHeap_FWD_DEFINED__
+#define __ID3D12QueryHeap_FWD_DEFINED__
+typedef interface ID3D12QueryHeap ID3D12QueryHeap;
+
+#endif 	/* __ID3D12QueryHeap_FWD_DEFINED__ */
+
+
+#ifndef __ID3D12CommandSignature_FWD_DEFINED__
+#define __ID3D12CommandSignature_FWD_DEFINED__
+typedef interface ID3D12CommandSignature ID3D12CommandSignature;
+
+#endif 	/* __ID3D12CommandSignature_FWD_DEFINED__ */
+
+
+#ifndef __ID3D12CommandList_FWD_DEFINED__
+#define __ID3D12CommandList_FWD_DEFINED__
+typedef interface ID3D12CommandList ID3D12CommandList;
+
+#endif 	/* __ID3D12CommandList_FWD_DEFINED__ */
+
+
+#ifndef __ID3D12GraphicsCommandList_FWD_DEFINED__
+#define __ID3D12GraphicsCommandList_FWD_DEFINED__
+typedef interface ID3D12GraphicsCommandList ID3D12GraphicsCommandList;
+
+#endif 	/* __ID3D12GraphicsCommandList_FWD_DEFINED__ */
+
+
+#ifndef __ID3D12GraphicsCommandList1_FWD_DEFINED__
+#define __ID3D12GraphicsCommandList1_FWD_DEFINED__
+typedef interface ID3D12GraphicsCommandList1 ID3D12GraphicsCommandList1;
+
+#endif 	/* __ID3D12GraphicsCommandList1_FWD_DEFINED__ */
+
+
+#ifndef __ID3D12GraphicsCommandList2_FWD_DEFINED__
+#define __ID3D12GraphicsCommandList2_FWD_DEFINED__
+typedef interface ID3D12GraphicsCommandList2 ID3D12GraphicsCommandList2;
+
+#endif 	/* __ID3D12GraphicsCommandList2_FWD_DEFINED__ */
+
+
+#ifndef __ID3D12CommandQueue_FWD_DEFINED__
+#define __ID3D12CommandQueue_FWD_DEFINED__
+typedef interface ID3D12CommandQueue ID3D12CommandQueue;
+
+#endif 	/* __ID3D12CommandQueue_FWD_DEFINED__ */
+
+
+#ifndef __ID3D12Device_FWD_DEFINED__
+#define __ID3D12Device_FWD_DEFINED__
+typedef interface ID3D12Device ID3D12Device;
+
+#endif 	/* __ID3D12Device_FWD_DEFINED__ */
+
+
+#ifndef __ID3D12PipelineLibrary_FWD_DEFINED__
+#define __ID3D12PipelineLibrary_FWD_DEFINED__
+typedef interface ID3D12PipelineLibrary ID3D12PipelineLibrary;
+
+#endif 	/* __ID3D12PipelineLibrary_FWD_DEFINED__ */
+
+
+#ifndef __ID3D12PipelineLibrary1_FWD_DEFINED__
+#define __ID3D12PipelineLibrary1_FWD_DEFINED__
+typedef interface ID3D12PipelineLibrary1 ID3D12PipelineLibrary1;
+
+#endif 	/* __ID3D12PipelineLibrary1_FWD_DEFINED__ */
+
+
+#ifndef __ID3D12Device1_FWD_DEFINED__
+#define __ID3D12Device1_FWD_DEFINED__
+typedef interface ID3D12Device1 ID3D12Device1;
+
+#endif 	/* __ID3D12Device1_FWD_DEFINED__ */
+
+
+#ifndef __ID3D12Device2_FWD_DEFINED__
+#define __ID3D12Device2_FWD_DEFINED__
+typedef interface ID3D12Device2 ID3D12Device2;
+
+#endif 	/* __ID3D12Device2_FWD_DEFINED__ */
+
+
+#ifndef __ID3D12Device3_FWD_DEFINED__
+#define __ID3D12Device3_FWD_DEFINED__
+typedef interface ID3D12Device3 ID3D12Device3;
+
+#endif 	/* __ID3D12Device3_FWD_DEFINED__ */
+
+
+#ifndef __ID3D12ProtectedSession_FWD_DEFINED__
+#define __ID3D12ProtectedSession_FWD_DEFINED__
+typedef interface ID3D12ProtectedSession ID3D12ProtectedSession;
+
+#endif 	/* __ID3D12ProtectedSession_FWD_DEFINED__ */
+
+
+#ifndef __ID3D12ProtectedResourceSession_FWD_DEFINED__
+#define __ID3D12ProtectedResourceSession_FWD_DEFINED__
+typedef interface ID3D12ProtectedResourceSession ID3D12ProtectedResourceSession;
+
+#endif 	/* __ID3D12ProtectedResourceSession_FWD_DEFINED__ */
+
+
+#ifndef __ID3D12Device4_FWD_DEFINED__
+#define __ID3D12Device4_FWD_DEFINED__
+typedef interface ID3D12Device4 ID3D12Device4;
+
+#endif 	/* __ID3D12Device4_FWD_DEFINED__ */
+
+
+#ifndef __ID3D12LifetimeOwner_FWD_DEFINED__
+#define __ID3D12LifetimeOwner_FWD_DEFINED__
+typedef interface ID3D12LifetimeOwner ID3D12LifetimeOwner;
+
+#endif 	/* __ID3D12LifetimeOwner_FWD_DEFINED__ */
+
+
+#ifndef __ID3D12SwapChainAssistant_FWD_DEFINED__
+#define __ID3D12SwapChainAssistant_FWD_DEFINED__
+typedef interface ID3D12SwapChainAssistant ID3D12SwapChainAssistant;
+
+#endif 	/* __ID3D12SwapChainAssistant_FWD_DEFINED__ */
+
+
+#ifndef __ID3D12LifetimeTracker_FWD_DEFINED__
+#define __ID3D12LifetimeTracker_FWD_DEFINED__
+typedef interface ID3D12LifetimeTracker ID3D12LifetimeTracker;
+
+#endif 	/* __ID3D12LifetimeTracker_FWD_DEFINED__ */
+
+
+#ifndef __ID3D12StateObject_FWD_DEFINED__
+#define __ID3D12StateObject_FWD_DEFINED__
+typedef interface ID3D12StateObject ID3D12StateObject;
+
+#endif 	/* __ID3D12StateObject_FWD_DEFINED__ */
+
+
+#ifndef __ID3D12StateObjectProperties_FWD_DEFINED__
+#define __ID3D12StateObjectProperties_FWD_DEFINED__
+typedef interface ID3D12StateObjectProperties ID3D12StateObjectProperties;
+
+#endif 	/* __ID3D12StateObjectProperties_FWD_DEFINED__ */
+
+
+#ifndef __ID3D12Device5_FWD_DEFINED__
+#define __ID3D12Device5_FWD_DEFINED__
+typedef interface ID3D12Device5 ID3D12Device5;
+
+#endif 	/* __ID3D12Device5_FWD_DEFINED__ */
+
+
+#ifndef __ID3D12DeviceRemovedExtendedDataSettings_FWD_DEFINED__
+#define __ID3D12DeviceRemovedExtendedDataSettings_FWD_DEFINED__
+typedef interface ID3D12DeviceRemovedExtendedDataSettings ID3D12DeviceRemovedExtendedDataSettings;
+
+#endif 	/* __ID3D12DeviceRemovedExtendedDataSettings_FWD_DEFINED__ */
+
+
+#ifndef __ID3D12DeviceRemovedExtendedDataSettings1_FWD_DEFINED__
+#define __ID3D12DeviceRemovedExtendedDataSettings1_FWD_DEFINED__
+typedef interface ID3D12DeviceRemovedExtendedDataSettings1 ID3D12DeviceRemovedExtendedDataSettings1;
+
+#endif 	/* __ID3D12DeviceRemovedExtendedDataSettings1_FWD_DEFINED__ */
+
+
+#ifndef __ID3D12DeviceRemovedExtendedDataSettings2_FWD_DEFINED__
+#define __ID3D12DeviceRemovedExtendedDataSettings2_FWD_DEFINED__
+typedef interface ID3D12DeviceRemovedExtendedDataSettings2 ID3D12DeviceRemovedExtendedDataSettings2;
+
+#endif 	/* __ID3D12DeviceRemovedExtendedDataSettings2_FWD_DEFINED__ */
+
+
+#ifndef __ID3D12DeviceRemovedExtendedData_FWD_DEFINED__
+#define __ID3D12DeviceRemovedExtendedData_FWD_DEFINED__
+typedef interface ID3D12DeviceRemovedExtendedData ID3D12DeviceRemovedExtendedData;
+
+#endif 	/* __ID3D12DeviceRemovedExtendedData_FWD_DEFINED__ */
+
+
+#ifndef __ID3D12DeviceRemovedExtendedData1_FWD_DEFINED__
+#define __ID3D12DeviceRemovedExtendedData1_FWD_DEFINED__
+typedef interface ID3D12DeviceRemovedExtendedData1 ID3D12DeviceRemovedExtendedData1;
+
+#endif 	/* __ID3D12DeviceRemovedExtendedData1_FWD_DEFINED__ */
+
+
+#ifndef __ID3D12DeviceRemovedExtendedData2_FWD_DEFINED__
+#define __ID3D12DeviceRemovedExtendedData2_FWD_DEFINED__
+typedef interface ID3D12DeviceRemovedExtendedData2 ID3D12DeviceRemovedExtendedData2;
+
+#endif 	/* __ID3D12DeviceRemovedExtendedData2_FWD_DEFINED__ */
+
+
+#ifndef __ID3D12Device6_FWD_DEFINED__
+#define __ID3D12Device6_FWD_DEFINED__
+typedef interface ID3D12Device6 ID3D12Device6;
+
+#endif 	/* __ID3D12Device6_FWD_DEFINED__ */
+
+
+#ifndef __ID3D12ProtectedResourceSession1_FWD_DEFINED__
+#define __ID3D12ProtectedResourceSession1_FWD_DEFINED__
+typedef interface ID3D12ProtectedResourceSession1 ID3D12ProtectedResourceSession1;
+
+#endif 	/* __ID3D12ProtectedResourceSession1_FWD_DEFINED__ */
+
+
+#ifndef __ID3D12Device7_FWD_DEFINED__
+#define __ID3D12Device7_FWD_DEFINED__
+typedef interface ID3D12Device7 ID3D12Device7;
+
+#endif 	/* __ID3D12Device7_FWD_DEFINED__ */
+
+
+#ifndef __ID3D12Device8_FWD_DEFINED__
+#define __ID3D12Device8_FWD_DEFINED__
+typedef interface ID3D12Device8 ID3D12Device8;
+
+#endif 	/* __ID3D12Device8_FWD_DEFINED__ */
+
+
+#ifndef __ID3D12Resource1_FWD_DEFINED__
+#define __ID3D12Resource1_FWD_DEFINED__
+typedef interface ID3D12Resource1 ID3D12Resource1;
+
+#endif 	/* __ID3D12Resource1_FWD_DEFINED__ */
+
+
+#ifndef __ID3D12Resource2_FWD_DEFINED__
+#define __ID3D12Resource2_FWD_DEFINED__
+typedef interface ID3D12Resource2 ID3D12Resource2;
+
+#endif 	/* __ID3D12Resource2_FWD_DEFINED__ */
+
+
+#ifndef __ID3D12Heap1_FWD_DEFINED__
+#define __ID3D12Heap1_FWD_DEFINED__
+typedef interface ID3D12Heap1 ID3D12Heap1;
+
+#endif 	/* __ID3D12Heap1_FWD_DEFINED__ */
+
+
+#ifndef __ID3D12GraphicsCommandList3_FWD_DEFINED__
+#define __ID3D12GraphicsCommandList3_FWD_DEFINED__
+typedef interface ID3D12GraphicsCommandList3 ID3D12GraphicsCommandList3;
+
+#endif 	/* __ID3D12GraphicsCommandList3_FWD_DEFINED__ */
+
+
+#ifndef __ID3D12MetaCommand_FWD_DEFINED__
+#define __ID3D12MetaCommand_FWD_DEFINED__
+typedef interface ID3D12MetaCommand ID3D12MetaCommand;
+
+#endif 	/* __ID3D12MetaCommand_FWD_DEFINED__ */
+
+
+#ifndef __ID3D12GraphicsCommandList4_FWD_DEFINED__
+#define __ID3D12GraphicsCommandList4_FWD_DEFINED__
+typedef interface ID3D12GraphicsCommandList4 ID3D12GraphicsCommandList4;
+
+#endif 	/* __ID3D12GraphicsCommandList4_FWD_DEFINED__ */
+
+
+#ifndef __ID3D12ShaderCacheSession_FWD_DEFINED__
+#define __ID3D12ShaderCacheSession_FWD_DEFINED__
+typedef interface ID3D12ShaderCacheSession ID3D12ShaderCacheSession;
+
+#endif 	/* __ID3D12ShaderCacheSession_FWD_DEFINED__ */
+
+
+#ifndef __ID3D12Device9_FWD_DEFINED__
+#define __ID3D12Device9_FWD_DEFINED__
+typedef interface ID3D12Device9 ID3D12Device9;
+
+#endif 	/* __ID3D12Device9_FWD_DEFINED__ */
+
+
+#ifndef __ID3D12Device10_FWD_DEFINED__
+#define __ID3D12Device10_FWD_DEFINED__
+typedef interface ID3D12Device10 ID3D12Device10;
+
+#endif 	/* __ID3D12Device10_FWD_DEFINED__ */
+
+
+#ifndef __ID3D12Device11_FWD_DEFINED__
+#define __ID3D12Device11_FWD_DEFINED__
+typedef interface ID3D12Device11 ID3D12Device11;
+
+#endif 	/* __ID3D12Device11_FWD_DEFINED__ */
+
+
+#ifndef __ID3D12VirtualizationGuestDevice_FWD_DEFINED__
+#define __ID3D12VirtualizationGuestDevice_FWD_DEFINED__
+typedef interface ID3D12VirtualizationGuestDevice ID3D12VirtualizationGuestDevice;
+
+#endif 	/* __ID3D12VirtualizationGuestDevice_FWD_DEFINED__ */
+
+
+#ifndef __ID3D12Tools_FWD_DEFINED__
+#define __ID3D12Tools_FWD_DEFINED__
+typedef interface ID3D12Tools ID3D12Tools;
+
+#endif 	/* __ID3D12Tools_FWD_DEFINED__ */
+
+
+#ifndef __ID3D12SDKConfiguration_FWD_DEFINED__
+#define __ID3D12SDKConfiguration_FWD_DEFINED__
+typedef interface ID3D12SDKConfiguration ID3D12SDKConfiguration;
+
+#endif 	/* __ID3D12SDKConfiguration_FWD_DEFINED__ */
+
+
+#ifndef __ID3D12SDKConfiguration1_FWD_DEFINED__
+#define __ID3D12SDKConfiguration1_FWD_DEFINED__
+typedef interface ID3D12SDKConfiguration1 ID3D12SDKConfiguration1;
+
+#endif 	/* __ID3D12SDKConfiguration1_FWD_DEFINED__ */
+
+
+#ifndef __ID3D12DeviceFactory_FWD_DEFINED__
+#define __ID3D12DeviceFactory_FWD_DEFINED__
+typedef interface ID3D12DeviceFactory ID3D12DeviceFactory;
+
+#endif 	/* __ID3D12DeviceFactory_FWD_DEFINED__ */
+
+
+#ifndef __ID3D12DeviceConfiguration_FWD_DEFINED__
+#define __ID3D12DeviceConfiguration_FWD_DEFINED__
+typedef interface ID3D12DeviceConfiguration ID3D12DeviceConfiguration;
+
+#endif 	/* __ID3D12DeviceConfiguration_FWD_DEFINED__ */
+
+
+#ifndef __ID3D12GraphicsCommandList5_FWD_DEFINED__
+#define __ID3D12GraphicsCommandList5_FWD_DEFINED__
+typedef interface ID3D12GraphicsCommandList5 ID3D12GraphicsCommandList5;
+
+#endif 	/* __ID3D12GraphicsCommandList5_FWD_DEFINED__ */
+
+
+#ifndef __ID3D12GraphicsCommandList6_FWD_DEFINED__
+#define __ID3D12GraphicsCommandList6_FWD_DEFINED__
+typedef interface ID3D12GraphicsCommandList6 ID3D12GraphicsCommandList6;
+
+#endif 	/* __ID3D12GraphicsCommandList6_FWD_DEFINED__ */
+
+
+#ifndef __ID3D12GraphicsCommandList7_FWD_DEFINED__
+#define __ID3D12GraphicsCommandList7_FWD_DEFINED__
+typedef interface ID3D12GraphicsCommandList7 ID3D12GraphicsCommandList7;
+
+#endif 	/* __ID3D12GraphicsCommandList7_FWD_DEFINED__ */
+
+
+#ifndef __ID3D12GraphicsCommandList8_FWD_DEFINED__
+#define __ID3D12GraphicsCommandList8_FWD_DEFINED__
+typedef interface ID3D12GraphicsCommandList8 ID3D12GraphicsCommandList8;
+
+#endif 	/* __ID3D12GraphicsCommandList8_FWD_DEFINED__ */
+
+
+/* header files for imported files */
+#include "oaidl.h"
+#include "ocidl.h"
+#include "dxgicommon.h"
+#include "dxgiformat.h"
+#include "d3dcommon.h"
+
+#ifdef __cplusplus
+extern "C"{
+#endif 
+
+
+/* interface __MIDL_itf_d3d12_0000_0000 */
+/* [local] */ 
+
+#include <winapifamily.h>
+#pragma region App Family
+#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP | WINAPI_PARTITION_GAMES)
+#ifndef _D3D12_CONSTANTS
+#define _D3D12_CONSTANTS
+#define	D3D12_16BIT_INDEX_STRIP_CUT_VALUE	( 0xffff )
+
+#define	D3D12_32BIT_INDEX_STRIP_CUT_VALUE	( 0xffffffff )
+
+#define	D3D12_8BIT_INDEX_STRIP_CUT_VALUE	( 0xff )
+
+#define	D3D12_APPEND_ALIGNED_ELEMENT	( 0xffffffff )
+
+#define	D3D12_ARRAY_AXIS_ADDRESS_RANGE_BIT_COUNT	( 9 )
+
+#define	D3D12_CLIP_OR_CULL_DISTANCE_COUNT	( 8 )
+
+#define	D3D12_CLIP_OR_CULL_DISTANCE_ELEMENT_COUNT	( 2 )
+
+#define	D3D12_COMMONSHADER_CONSTANT_BUFFER_API_SLOT_COUNT	( 14 )
+
+#define	D3D12_COMMONSHADER_CONSTANT_BUFFER_COMPONENTS	( 4 )
+
+#define	D3D12_COMMONSHADER_CONSTANT_BUFFER_COMPONENT_BIT_COUNT	( 32 )
+
+#define	D3D12_COMMONSHADER_CONSTANT_BUFFER_HW_SLOT_COUNT	( 15 )
+
+#define	D3D12_COMMONSHADER_CONSTANT_BUFFER_PARTIAL_UPDATE_EXTENTS_BYTE_ALIGNMENT	( 16 )
+
+#define	D3D12_COMMONSHADER_CONSTANT_BUFFER_REGISTER_COMPONENTS	( 4 )
+
+#define	D3D12_COMMONSHADER_CONSTANT_BUFFER_REGISTER_COUNT	( 15 )
+
+#define	D3D12_COMMONSHADER_CONSTANT_BUFFER_REGISTER_READS_PER_INST	( 1 )
+
+#define	D3D12_COMMONSHADER_CONSTANT_BUFFER_REGISTER_READ_PORTS	( 1 )
+
+#define	D3D12_COMMONSHADER_FLOWCONTROL_NESTING_LIMIT	( 64 )
+
+#define	D3D12_COMMONSHADER_IMMEDIATE_CONSTANT_BUFFER_REGISTER_COMPONENTS	( 4 )
+
+#define	D3D12_COMMONSHADER_IMMEDIATE_CONSTANT_BUFFER_REGISTER_COUNT	( 1 )
+
+#define	D3D12_COMMONSHADER_IMMEDIATE_CONSTANT_BUFFER_REGISTER_READS_PER_INST	( 1 )
+
+#define	D3D12_COMMONSHADER_IMMEDIATE_CONSTANT_BUFFER_REGISTER_READ_PORTS	( 1 )
+
+#define	D3D12_COMMONSHADER_IMMEDIATE_VALUE_COMPONENT_BIT_COUNT	( 32 )
+
+#define	D3D12_COMMONSHADER_INPUT_RESOURCE_REGISTER_COMPONENTS	( 1 )
+
+#define	D3D12_COMMONSHADER_INPUT_RESOURCE_REGISTER_COUNT	( 128 )
+
+#define	D3D12_COMMONSHADER_INPUT_RESOURCE_REGISTER_READS_PER_INST	( 1 )
+
+#define	D3D12_COMMONSHADER_INPUT_RESOURCE_REGISTER_READ_PORTS	( 1 )
+
+#define	D3D12_COMMONSHADER_INPUT_RESOURCE_SLOT_COUNT	( 128 )
+
+#define	D3D12_COMMONSHADER_SAMPLER_REGISTER_COMPONENTS	( 1 )
+
+#define	D3D12_COMMONSHADER_SAMPLER_REGISTER_COUNT	( 16 )
+
+#define	D3D12_COMMONSHADER_SAMPLER_REGISTER_READS_PER_INST	( 1 )
+
+#define	D3D12_COMMONSHADER_SAMPLER_REGISTER_READ_PORTS	( 1 )
+
+#define	D3D12_COMMONSHADER_SAMPLER_SLOT_COUNT	( 16 )
+
+#define	D3D12_COMMONSHADER_SUBROUTINE_NESTING_LIMIT	( 32 )
+
+#define	D3D12_COMMONSHADER_TEMP_REGISTER_COMPONENTS	( 4 )
+
+#define	D3D12_COMMONSHADER_TEMP_REGISTER_COMPONENT_BIT_COUNT	( 32 )
+
+#define	D3D12_COMMONSHADER_TEMP_REGISTER_COUNT	( 4096 )
+
+#define	D3D12_COMMONSHADER_TEMP_REGISTER_READS_PER_INST	( 3 )
+
+#define	D3D12_COMMONSHADER_TEMP_REGISTER_READ_PORTS	( 3 )
+
+#define	D3D12_COMMONSHADER_TEXCOORD_RANGE_REDUCTION_MAX	( 10 )
+
+#define	D3D12_COMMONSHADER_TEXCOORD_RANGE_REDUCTION_MIN	( -10 )
+
+#define	D3D12_COMMONSHADER_TEXEL_OFFSET_MAX_NEGATIVE	( -8 )
+
+#define	D3D12_COMMONSHADER_TEXEL_OFFSET_MAX_POSITIVE	( 7 )
+
+#define	D3D12_CONSTANT_BUFFER_DATA_PLACEMENT_ALIGNMENT	( 256 )
+
+#define	D3D12_CS_4_X_BUCKET00_MAX_BYTES_TGSM_WRITABLE_PER_THREAD	( 256 )
+
+#define	D3D12_CS_4_X_BUCKET00_MAX_NUM_THREADS_PER_GROUP	( 64 )
+
+#define	D3D12_CS_4_X_BUCKET01_MAX_BYTES_TGSM_WRITABLE_PER_THREAD	( 240 )
+
+#define	D3D12_CS_4_X_BUCKET01_MAX_NUM_THREADS_PER_GROUP	( 68 )
+
+#define	D3D12_CS_4_X_BUCKET02_MAX_BYTES_TGSM_WRITABLE_PER_THREAD	( 224 )
+
+#define	D3D12_CS_4_X_BUCKET02_MAX_NUM_THREADS_PER_GROUP	( 72 )
+
+#define	D3D12_CS_4_X_BUCKET03_MAX_BYTES_TGSM_WRITABLE_PER_THREAD	( 208 )
+
+#define	D3D12_CS_4_X_BUCKET03_MAX_NUM_THREADS_PER_GROUP	( 76 )
+
+#define	D3D12_CS_4_X_BUCKET04_MAX_BYTES_TGSM_WRITABLE_PER_THREAD	( 192 )
+
+#define	D3D12_CS_4_X_BUCKET04_MAX_NUM_THREADS_PER_GROUP	( 84 )
+
+#define	D3D12_CS_4_X_BUCKET05_MAX_BYTES_TGSM_WRITABLE_PER_THREAD	( 176 )
+
+#define	D3D12_CS_4_X_BUCKET05_MAX_NUM_THREADS_PER_GROUP	( 92 )
+
+#define	D3D12_CS_4_X_BUCKET06_MAX_BYTES_TGSM_WRITABLE_PER_THREAD	( 160 )
+
+#define	D3D12_CS_4_X_BUCKET06_MAX_NUM_THREADS_PER_GROUP	( 100 )
+
+#define	D3D12_CS_4_X_BUCKET07_MAX_BYTES_TGSM_WRITABLE_PER_THREAD	( 144 )
+
+#define	D3D12_CS_4_X_BUCKET07_MAX_NUM_THREADS_PER_GROUP	( 112 )
+
+#define	D3D12_CS_4_X_BUCKET08_MAX_BYTES_TGSM_WRITABLE_PER_THREAD	( 128 )
+
+#define	D3D12_CS_4_X_BUCKET08_MAX_NUM_THREADS_PER_GROUP	( 128 )
+
+#define	D3D12_CS_4_X_BUCKET09_MAX_BYTES_TGSM_WRITABLE_PER_THREAD	( 112 )
+
+#define	D3D12_CS_4_X_BUCKET09_MAX_NUM_THREADS_PER_GROUP	( 144 )
+
+#define	D3D12_CS_4_X_BUCKET10_MAX_BYTES_TGSM_WRITABLE_PER_THREAD	( 96 )
+
+#define	D3D12_CS_4_X_BUCKET10_MAX_NUM_THREADS_PER_GROUP	( 168 )
+
+#define	D3D12_CS_4_X_BUCKET11_MAX_BYTES_TGSM_WRITABLE_PER_THREAD	( 80 )
+
+#define	D3D12_CS_4_X_BUCKET11_MAX_NUM_THREADS_PER_GROUP	( 204 )
+
+#define	D3D12_CS_4_X_BUCKET12_MAX_BYTES_TGSM_WRITABLE_PER_THREAD	( 64 )
+
+#define	D3D12_CS_4_X_BUCKET12_MAX_NUM_THREADS_PER_GROUP	( 256 )
+
+#define	D3D12_CS_4_X_BUCKET13_MAX_BYTES_TGSM_WRITABLE_PER_THREAD	( 48 )
+
+#define	D3D12_CS_4_X_BUCKET13_MAX_NUM_THREADS_PER_GROUP	( 340 )
+
+#define	D3D12_CS_4_X_BUCKET14_MAX_BYTES_TGSM_WRITABLE_PER_THREAD	( 32 )
+
+#define	D3D12_CS_4_X_BUCKET14_MAX_NUM_THREADS_PER_GROUP	( 512 )
+
+#define	D3D12_CS_4_X_BUCKET15_MAX_BYTES_TGSM_WRITABLE_PER_THREAD	( 16 )
+
+#define	D3D12_CS_4_X_BUCKET15_MAX_NUM_THREADS_PER_GROUP	( 768 )
+
+#define	D3D12_CS_4_X_DISPATCH_MAX_THREAD_GROUPS_IN_Z_DIMENSION	( 1 )
+
+#define	D3D12_CS_4_X_RAW_UAV_BYTE_ALIGNMENT	( 256 )
+
+#define	D3D12_CS_4_X_THREAD_GROUP_MAX_THREADS_PER_GROUP	( 768 )
+
+#define	D3D12_CS_4_X_THREAD_GROUP_MAX_X	( 768 )
+
+#define	D3D12_CS_4_X_THREAD_GROUP_MAX_Y	( 768 )
+
+#define	D3D12_CS_4_X_UAV_REGISTER_COUNT	( 1 )
+
+#define	D3D12_CS_DISPATCH_MAX_THREAD_GROUPS_PER_DIMENSION	( 65535 )
+
+#define	D3D12_CS_TGSM_REGISTER_COUNT	( 8192 )
+
+#define	D3D12_CS_TGSM_REGISTER_READS_PER_INST	( 1 )
+
+#define	D3D12_CS_TGSM_RESOURCE_REGISTER_COMPONENTS	( 1 )
+
+#define	D3D12_CS_TGSM_RESOURCE_REGISTER_READ_PORTS	( 1 )
+
+#define	D3D12_CS_THREADGROUPID_REGISTER_COMPONENTS	( 3 )
+
+#define	D3D12_CS_THREADGROUPID_REGISTER_COUNT	( 1 )
+
+#define	D3D12_CS_THREADIDINGROUPFLATTENED_REGISTER_COMPONENTS	( 1 )
+
+#define	D3D12_CS_THREADIDINGROUPFLATTENED_REGISTER_COUNT	( 1 )
+
+#define	D3D12_CS_THREADIDINGROUP_REGISTER_COMPONENTS	( 3 )
+
+#define	D3D12_CS_THREADIDINGROUP_REGISTER_COUNT	( 1 )
+
+#define	D3D12_CS_THREADID_REGISTER_COMPONENTS	( 3 )
+
+#define	D3D12_CS_THREADID_REGISTER_COUNT	( 1 )
+
+#define	D3D12_CS_THREAD_GROUP_MAX_THREADS_PER_GROUP	( 1024 )
+
+#define	D3D12_CS_THREAD_GROUP_MAX_X	( 1024 )
+
+#define	D3D12_CS_THREAD_GROUP_MAX_Y	( 1024 )
+
+#define	D3D12_CS_THREAD_GROUP_MAX_Z	( 64 )
+
+#define	D3D12_CS_THREAD_GROUP_MIN_X	( 1 )
+
+#define	D3D12_CS_THREAD_GROUP_MIN_Y	( 1 )
+
+#define	D3D12_CS_THREAD_GROUP_MIN_Z	( 1 )
+
+#define	D3D12_CS_THREAD_LOCAL_TEMP_REGISTER_POOL	( 16384 )
+
+#define D3D12_DEFAULT_BLEND_FACTOR_ALPHA	( 1.0f )
+#define D3D12_DEFAULT_BLEND_FACTOR_BLUE	( 1.0f )
+#define D3D12_DEFAULT_BLEND_FACTOR_GREEN	( 1.0f )
+#define D3D12_DEFAULT_BLEND_FACTOR_RED	( 1.0f )
+#define D3D12_DEFAULT_BORDER_COLOR_COMPONENT	( 0.0f )
+#define	D3D12_DEFAULT_DEPTH_BIAS	( 0 )
+
+#define D3D12_DEFAULT_DEPTH_BIAS_CLAMP	( 0.0f )
+#define	D3D12_DEFAULT_MAX_ANISOTROPY	( 16 )
+
+#define D3D12_DEFAULT_MIP_LOD_BIAS	( 0.0f )
+#define	D3D12_DEFAULT_MSAA_RESOURCE_PLACEMENT_ALIGNMENT	( 4194304 )
+
+#define	D3D12_DEFAULT_RENDER_TARGET_ARRAY_INDEX	( 0 )
+
+#define	D3D12_DEFAULT_RESOURCE_PLACEMENT_ALIGNMENT	( 65536 )
+
+#define	D3D12_DEFAULT_SAMPLE_MASK	( 0xffffffff )
+
+#define	D3D12_DEFAULT_SCISSOR_ENDX	( 0 )
+
+#define	D3D12_DEFAULT_SCISSOR_ENDY	( 0 )
+
+#define	D3D12_DEFAULT_SCISSOR_STARTX	( 0 )
+
+#define	D3D12_DEFAULT_SCISSOR_STARTY	( 0 )
+
+#define D3D12_DEFAULT_SLOPE_SCALED_DEPTH_BIAS	( 0.0f )
+#define	D3D12_DEFAULT_STENCIL_READ_MASK	( 0xff )
+
+#define	D3D12_DEFAULT_STENCIL_REFERENCE	( 0 )
+
+#define	D3D12_DEFAULT_STENCIL_WRITE_MASK	( 0xff )
+
+#define	D3D12_DEFAULT_VIEWPORT_AND_SCISSORRECT_INDEX	( 0 )
+
+#define	D3D12_DEFAULT_VIEWPORT_HEIGHT	( 0 )
+
+#define D3D12_DEFAULT_VIEWPORT_MAX_DEPTH	( 0.0f )
+#define D3D12_DEFAULT_VIEWPORT_MIN_DEPTH	( 0.0f )
+#define	D3D12_DEFAULT_VIEWPORT_TOPLEFTX	( 0 )
+
+#define	D3D12_DEFAULT_VIEWPORT_TOPLEFTY	( 0 )
+
+#define	D3D12_DEFAULT_VIEWPORT_WIDTH	( 0 )
+
+#define	D3D12_DESCRIPTOR_RANGE_OFFSET_APPEND	( 0xffffffff )
+
+#define	D3D12_DRIVER_RESERVED_REGISTER_SPACE_VALUES_END	( 0xfffffff7 )
+
+#define	D3D12_DRIVER_RESERVED_REGISTER_SPACE_VALUES_START	( 0xfffffff0 )
+
+#define	D3D12_DS_INPUT_CONTROL_POINTS_MAX_TOTAL_SCALARS	( 3968 )
+
+#define	D3D12_DS_INPUT_CONTROL_POINT_REGISTER_COMPONENTS	( 4 )
+
+#define	D3D12_DS_INPUT_CONTROL_POINT_REGISTER_COMPONENT_BIT_COUNT	( 32 )
+
+#define	D3D12_DS_INPUT_CONTROL_POINT_REGISTER_COUNT	( 32 )
+
+#define	D3D12_DS_INPUT_CONTROL_POINT_REGISTER_READS_PER_INST	( 2 )
+
+#define	D3D12_DS_INPUT_CONTROL_POINT_REGISTER_READ_PORTS	( 1 )
+
+#define	D3D12_DS_INPUT_DOMAIN_POINT_REGISTER_COMPONENTS	( 3 )
+
+#define	D3D12_DS_INPUT_DOMAIN_POINT_REGISTER_COMPONENT_BIT_COUNT	( 32 )
+
+#define	D3D12_DS_INPUT_DOMAIN_POINT_REGISTER_COUNT	( 1 )
+
+#define	D3D12_DS_INPUT_DOMAIN_POINT_REGISTER_READS_PER_INST	( 2 )
+
+#define	D3D12_DS_INPUT_DOMAIN_POINT_REGISTER_READ_PORTS	( 1 )
+
+#define	D3D12_DS_INPUT_PATCH_CONSTANT_REGISTER_COMPONENTS	( 4 )
+
+#define	D3D12_DS_INPUT_PATCH_CONSTANT_REGISTER_COMPONENT_BIT_COUNT	( 32 )
+
+#define	D3D12_DS_INPUT_PATCH_CONSTANT_REGISTER_COUNT	( 32 )
+
+#define	D3D12_DS_INPUT_PATCH_CONSTANT_REGISTER_READS_PER_INST	( 2 )
+
+#define	D3D12_DS_INPUT_PATCH_CONSTANT_REGISTER_READ_PORTS	( 1 )
+
+#define	D3D12_DS_INPUT_PRIMITIVE_ID_REGISTER_COMPONENTS	( 1 )
+
+#define	D3D12_DS_INPUT_PRIMITIVE_ID_REGISTER_COMPONENT_BIT_COUNT	( 32 )
+
+#define	D3D12_DS_INPUT_PRIMITIVE_ID_REGISTER_COUNT	( 1 )
+
+#define	D3D12_DS_INPUT_PRIMITIVE_ID_REGISTER_READS_PER_INST	( 2 )
+
+#define	D3D12_DS_INPUT_PRIMITIVE_ID_REGISTER_READ_PORTS	( 1 )
+
+#define	D3D12_DS_OUTPUT_REGISTER_COMPONENTS	( 4 )
+
+#define	D3D12_DS_OUTPUT_REGISTER_COMPONENT_BIT_COUNT	( 32 )
+
+#define	D3D12_DS_OUTPUT_REGISTER_COUNT	( 32 )
+
+#define D3D12_FLOAT16_FUSED_TOLERANCE_IN_ULP	( 0.6 )
+#define D3D12_FLOAT32_MAX	( 3.402823466e+38f )
+#define D3D12_FLOAT32_TO_INTEGER_TOLERANCE_IN_ULP	( 0.6f )
+#define D3D12_FLOAT_TO_SRGB_EXPONENT_DENOMINATOR	( 2.4f )
+#define D3D12_FLOAT_TO_SRGB_EXPONENT_NUMERATOR	( 1.0f )
+#define D3D12_FLOAT_TO_SRGB_OFFSET	( 0.055f )
+#define D3D12_FLOAT_TO_SRGB_SCALE_1	( 12.92f )
+#define D3D12_FLOAT_TO_SRGB_SCALE_2	( 1.055f )
+#define D3D12_FLOAT_TO_SRGB_THRESHOLD	( 0.0031308f )
+#define D3D12_FTOI_INSTRUCTION_MAX_INPUT	( 2147483647.999f )
+#define D3D12_FTOI_INSTRUCTION_MIN_INPUT	( -2147483648.999f )
+#define D3D12_FTOU_INSTRUCTION_MAX_INPUT	( 4294967295.999f )
+#define D3D12_FTOU_INSTRUCTION_MIN_INPUT	( 0.0f )
+#define	D3D12_GS_INPUT_INSTANCE_ID_READS_PER_INST	( 2 )
+
+#define	D3D12_GS_INPUT_INSTANCE_ID_READ_PORTS	( 1 )
+
+#define	D3D12_GS_INPUT_INSTANCE_ID_REGISTER_COMPONENTS	( 1 )
+
+#define	D3D12_GS_INPUT_INSTANCE_ID_REGISTER_COMPONENT_BIT_COUNT	( 32 )
+
+#define	D3D12_GS_INPUT_INSTANCE_ID_REGISTER_COUNT	( 1 )
+
+#define	D3D12_GS_INPUT_PRIM_CONST_REGISTER_COMPONENTS	( 1 )
+
+#define	D3D12_GS_INPUT_PRIM_CONST_REGISTER_COMPONENT_BIT_COUNT	( 32 )
+
+#define	D3D12_GS_INPUT_PRIM_CONST_REGISTER_COUNT	( 1 )
+
+#define	D3D12_GS_INPUT_PRIM_CONST_REGISTER_READS_PER_INST	( 2 )
+
+#define	D3D12_GS_INPUT_PRIM_CONST_REGISTER_READ_PORTS	( 1 )
+
+#define	D3D12_GS_INPUT_REGISTER_COMPONENTS	( 4 )
+
+#define	D3D12_GS_INPUT_REGISTER_COMPONENT_BIT_COUNT	( 32 )
+
+#define	D3D12_GS_INPUT_REGISTER_COUNT	( 32 )
+
+#define	D3D12_GS_INPUT_REGISTER_READS_PER_INST	( 2 )
+
+#define	D3D12_GS_INPUT_REGISTER_READ_PORTS	( 1 )
+
+#define	D3D12_GS_INPUT_REGISTER_VERTICES	( 32 )
+
+#define	D3D12_GS_MAX_INSTANCE_COUNT	( 32 )
+
+#define	D3D12_GS_MAX_OUTPUT_VERTEX_COUNT_ACROSS_INSTANCES	( 1024 )
+
+#define	D3D12_GS_OUTPUT_ELEMENTS	( 32 )
+
+#define	D3D12_GS_OUTPUT_REGISTER_COMPONENTS	( 4 )
+
+#define	D3D12_GS_OUTPUT_REGISTER_COMPONENT_BIT_COUNT	( 32 )
+
+#define	D3D12_GS_OUTPUT_REGISTER_COUNT	( 32 )
+
+#define	D3D12_HS_CONTROL_POINT_PHASE_INPUT_REGISTER_COUNT	( 32 )
+
+#define	D3D12_HS_CONTROL_POINT_PHASE_OUTPUT_REGISTER_COUNT	( 32 )
+
+#define	D3D12_HS_CONTROL_POINT_REGISTER_COMPONENTS	( 4 )
+
+#define	D3D12_HS_CONTROL_POINT_REGISTER_COMPONENT_BIT_COUNT	( 32 )
+
+#define	D3D12_HS_CONTROL_POINT_REGISTER_READS_PER_INST	( 2 )
+
+#define	D3D12_HS_CONTROL_POINT_REGISTER_READ_PORTS	( 1 )
+
+#define	D3D12_HS_FORK_PHASE_INSTANCE_COUNT_UPPER_BOUND	( 0xffffffff )
+
+#define	D3D12_HS_INPUT_FORK_INSTANCE_ID_REGISTER_COMPONENTS	( 1 )
+
+#define	D3D12_HS_INPUT_FORK_INSTANCE_ID_REGISTER_COMPONENT_BIT_COUNT	( 32 )
+
+#define	D3D12_HS_INPUT_FORK_INSTANCE_ID_REGISTER_COUNT	( 1 )
+
+#define	D3D12_HS_INPUT_FORK_INSTANCE_ID_REGISTER_READS_PER_INST	( 2 )
+
+#define	D3D12_HS_INPUT_FORK_INSTANCE_ID_REGISTER_READ_PORTS	( 1 )
+
+#define	D3D12_HS_INPUT_JOIN_INSTANCE_ID_REGISTER_COMPONENTS	( 1 )
+
+#define	D3D12_HS_INPUT_JOIN_INSTANCE_ID_REGISTER_COMPONENT_BIT_COUNT	( 32 )
+
+#define	D3D12_HS_INPUT_JOIN_INSTANCE_ID_REGISTER_COUNT	( 1 )
+
+#define	D3D12_HS_INPUT_JOIN_INSTANCE_ID_REGISTER_READS_PER_INST	( 2 )
+
+#define	D3D12_HS_INPUT_JOIN_INSTANCE_ID_REGISTER_READ_PORTS	( 1 )
+
+#define	D3D12_HS_INPUT_PRIMITIVE_ID_REGISTER_COMPONENTS	( 1 )
+
+#define	D3D12_HS_INPUT_PRIMITIVE_ID_REGISTER_COMPONENT_BIT_COUNT	( 32 )
+
+#define	D3D12_HS_INPUT_PRIMITIVE_ID_REGISTER_COUNT	( 1 )
+
+#define	D3D12_HS_INPUT_PRIMITIVE_ID_REGISTER_READS_PER_INST	( 2 )
+
+#define	D3D12_HS_INPUT_PRIMITIVE_ID_REGISTER_READ_PORTS	( 1 )
+
+#define	D3D12_HS_JOIN_PHASE_INSTANCE_COUNT_UPPER_BOUND	( 0xffffffff )
+
+#define D3D12_HS_MAXTESSFACTOR_LOWER_BOUND	( 1.0f )
+#define D3D12_HS_MAXTESSFACTOR_UPPER_BOUND	( 64.0f )
+#define	D3D12_HS_OUTPUT_CONTROL_POINTS_MAX_TOTAL_SCALARS	( 3968 )
+
+#define	D3D12_HS_OUTPUT_CONTROL_POINT_ID_REGISTER_COMPONENTS	( 1 )
+
+#define	D3D12_HS_OUTPUT_CONTROL_POINT_ID_REGISTER_COMPONENT_BIT_COUNT	( 32 )
+
+#define	D3D12_HS_OUTPUT_CONTROL_POINT_ID_REGISTER_COUNT	( 1 )
+
+#define	D3D12_HS_OUTPUT_CONTROL_POINT_ID_REGISTER_READS_PER_INST	( 2 )
+
+#define	D3D12_HS_OUTPUT_CONTROL_POINT_ID_REGISTER_READ_PORTS	( 1 )
+
+#define	D3D12_HS_OUTPUT_PATCH_CONSTANT_REGISTER_COMPONENTS	( 4 )
+
+#define	D3D12_HS_OUTPUT_PATCH_CONSTANT_REGISTER_COMPONENT_BIT_COUNT	( 32 )
+
+#define	D3D12_HS_OUTPUT_PATCH_CONSTANT_REGISTER_COUNT	( 32 )
+
+#define	D3D12_HS_OUTPUT_PATCH_CONSTANT_REGISTER_READS_PER_INST	( 2 )
+
+#define	D3D12_HS_OUTPUT_PATCH_CONSTANT_REGISTER_READ_PORTS	( 1 )
+
+#define	D3D12_HS_OUTPUT_PATCH_CONSTANT_REGISTER_SCALAR_COMPONENTS	( 128 )
+
+#define	D3D12_IA_DEFAULT_INDEX_BUFFER_OFFSET_IN_BYTES	( 0 )
+
+#define	D3D12_IA_DEFAULT_PRIMITIVE_TOPOLOGY	( 0 )
+
+#define	D3D12_IA_DEFAULT_VERTEX_BUFFER_OFFSET_IN_BYTES	( 0 )
+
+#define	D3D12_IA_INDEX_INPUT_RESOURCE_SLOT_COUNT	( 1 )
+
+#define	D3D12_IA_INSTANCE_ID_BIT_COUNT	( 32 )
+
+#define	D3D12_IA_INTEGER_ARITHMETIC_BIT_COUNT	( 32 )
+
+#define	D3D12_IA_PATCH_MAX_CONTROL_POINT_COUNT	( 32 )
+
+#define	D3D12_IA_PRIMITIVE_ID_BIT_COUNT	( 32 )
+
+#define	D3D12_IA_VERTEX_ID_BIT_COUNT	( 32 )
+
+#define	D3D12_IA_VERTEX_INPUT_RESOURCE_SLOT_COUNT	( 32 )
+
+#define	D3D12_IA_VERTEX_INPUT_STRUCTURE_ELEMENTS_COMPONENTS	( 128 )
+
+#define	D3D12_IA_VERTEX_INPUT_STRUCTURE_ELEMENT_COUNT	( 32 )
+
+#define	D3D12_INTEGER_DIVIDE_BY_ZERO_QUOTIENT	( 0xffffffff )
+
+#define	D3D12_INTEGER_DIVIDE_BY_ZERO_REMAINDER	( 0xffffffff )
+
+#define	D3D12_KEEP_RENDER_TARGETS_AND_DEPTH_STENCIL	( 0xffffffff )
+
+#define	D3D12_KEEP_UNORDERED_ACCESS_VIEWS	( 0xffffffff )
+
+#define D3D12_LINEAR_GAMMA	( 1.0f )
+#define	D3D12_MAJOR_VERSION	( 12 )
+
+#define D3D12_MAX_BORDER_COLOR_COMPONENT	( 1.0f )
+#define D3D12_MAX_DEPTH	( 1.0f )
+#define	D3D12_MAX_LIVE_STATIC_SAMPLERS	( 2032 )
+
+#define	D3D12_MAX_MAXANISOTROPY	( 16 )
+
+#define	D3D12_MAX_MULTISAMPLE_SAMPLE_COUNT	( 32 )
+
+#define D3D12_MAX_POSITION_VALUE	( 3.402823466e+34f )
+#define	D3D12_MAX_ROOT_COST	( 64 )
+
+#define	D3D12_MAX_SHADER_VISIBLE_DESCRIPTOR_HEAP_SIZE_TIER_1	( 1000000 )
+
+#define	D3D12_MAX_SHADER_VISIBLE_DESCRIPTOR_HEAP_SIZE_TIER_2	( 1000000 )
+
+#define	D3D12_MAX_SHADER_VISIBLE_SAMPLER_HEAP_SIZE	( 2048 )
+
+#define	D3D12_MAX_TEXTURE_DIMENSION_2_TO_EXP	( 17 )
+
+#define	D3D12_MAX_VIEW_INSTANCE_COUNT	( 4 )
+
+#define	D3D12_MINOR_VERSION	( 0 )
+
+#define D3D12_MIN_BORDER_COLOR_COMPONENT	( 0.0f )
+#define D3D12_MIN_DEPTH	( 0.0f )
+#define	D3D12_MIN_MAXANISOTROPY	( 0 )
+
+#define D3D12_MIP_LOD_BIAS_MAX	( 15.99f )
+#define D3D12_MIP_LOD_BIAS_MIN	( -16.0f )
+#define	D3D12_MIP_LOD_FRACTIONAL_BIT_COUNT	( 8 )
+
+#define	D3D12_MIP_LOD_RANGE_BIT_COUNT	( 8 )
+
+#define D3D12_MULTISAMPLE_ANTIALIAS_LINE_WIDTH	( 1.4f )
+#define	D3D12_NONSAMPLE_FETCH_OUT_OF_RANGE_ACCESS_RESULT	( 0 )
+
+#define	D3D12_OS_RESERVED_REGISTER_SPACE_VALUES_END	( 0xffffffff )
+
+#define	D3D12_OS_RESERVED_REGISTER_SPACE_VALUES_START	( 0xfffffff8 )
+
+#define	D3D12_PACKED_TILE	( 0xffffffff )
+
+#define	D3D12_PIXEL_ADDRESS_RANGE_BIT_COUNT	( 15 )
+
+#define	D3D12_PREVIEW_SDK_VERSION	( 706 )
+
+#define	D3D12_PRE_SCISSOR_PIXEL_ADDRESS_RANGE_BIT_COUNT	( 16 )
+
+#define	D3D12_PS_CS_UAV_REGISTER_COMPONENTS	( 1 )
+
+#define	D3D12_PS_CS_UAV_REGISTER_COUNT	( 8 )
+
+#define	D3D12_PS_CS_UAV_REGISTER_READS_PER_INST	( 1 )
+
+#define	D3D12_PS_CS_UAV_REGISTER_READ_PORTS	( 1 )
+
+#define	D3D12_PS_FRONTFACING_DEFAULT_VALUE	( 0xffffffff )
+
+#define	D3D12_PS_FRONTFACING_FALSE_VALUE	( 0 )
+
+#define	D3D12_PS_FRONTFACING_TRUE_VALUE	( 0xffffffff )
+
+#define	D3D12_PS_INPUT_REGISTER_COMPONENTS	( 4 )
+
+#define	D3D12_PS_INPUT_REGISTER_COMPONENT_BIT_COUNT	( 32 )
+
+#define	D3D12_PS_INPUT_REGISTER_COUNT	( 32 )
+
+#define	D3D12_PS_INPUT_REGISTER_READS_PER_INST	( 2 )
+
+#define	D3D12_PS_INPUT_REGISTER_READ_PORTS	( 1 )
+
+#define D3D12_PS_LEGACY_PIXEL_CENTER_FRACTIONAL_COMPONENT	( 0.0f )
+#define	D3D12_PS_OUTPUT_DEPTH_REGISTER_COMPONENTS	( 1 )
+
+#define	D3D12_PS_OUTPUT_DEPTH_REGISTER_COMPONENT_BIT_COUNT	( 32 )
+
+#define	D3D12_PS_OUTPUT_DEPTH_REGISTER_COUNT	( 1 )
+
+#define	D3D12_PS_OUTPUT_MASK_REGISTER_COMPONENTS	( 1 )
+
+#define	D3D12_PS_OUTPUT_MASK_REGISTER_COMPONENT_BIT_COUNT	( 32 )
+
+#define	D3D12_PS_OUTPUT_MASK_REGISTER_COUNT	( 1 )
+
+#define	D3D12_PS_OUTPUT_REGISTER_COMPONENTS	( 4 )
+
+#define	D3D12_PS_OUTPUT_REGISTER_COMPONENT_BIT_COUNT	( 32 )
+
+#define	D3D12_PS_OUTPUT_REGISTER_COUNT	( 8 )
+
+#define D3D12_PS_PIXEL_CENTER_FRACTIONAL_COMPONENT	( 0.5f )
+#define	D3D12_RAW_UAV_SRV_BYTE_ALIGNMENT	( 16 )
+
+#define	D3D12_RAYTRACING_AABB_BYTE_ALIGNMENT	( 8 )
+
+#define	D3D12_RAYTRACING_ACCELERATION_STRUCTURE_BYTE_ALIGNMENT	( 256 )
+
+#define	D3D12_RAYTRACING_INSTANCE_DESCS_BYTE_ALIGNMENT	( 16 )
+
+#define	D3D12_RAYTRACING_MAX_ATTRIBUTE_SIZE_IN_BYTES	( 32 )
+
+#define	D3D12_RAYTRACING_MAX_DECLARABLE_TRACE_RECURSION_DEPTH	( 31 )
+
+#define	D3D12_RAYTRACING_MAX_GEOMETRIES_PER_BOTTOM_LEVEL_ACCELERATION_STRUCTURE	( 16777216 )
+
+#define	D3D12_RAYTRACING_MAX_INSTANCES_PER_TOP_LEVEL_ACCELERATION_STRUCTURE	( 16777216 )
+
+#define	D3D12_RAYTRACING_MAX_PRIMITIVES_PER_BOTTOM_LEVEL_ACCELERATION_STRUCTURE	( 536870912 )
+
+#define	D3D12_RAYTRACING_MAX_RAY_GENERATION_SHADER_THREADS	( 1073741824 )
+
+#define	D3D12_RAYTRACING_MAX_SHADER_RECORD_STRIDE	( 4096 )
+
+#define	D3D12_RAYTRACING_SHADER_RECORD_BYTE_ALIGNMENT	( 32 )
+
+#define	D3D12_RAYTRACING_SHADER_TABLE_BYTE_ALIGNMENT	( 64 )
+
+#define	D3D12_RAYTRACING_TRANSFORM3X4_BYTE_ALIGNMENT	( 16 )
+
+#define	D3D12_REQ_BLEND_OBJECT_COUNT_PER_DEVICE	( 4096 )
+
+#define	D3D12_REQ_BUFFER_RESOURCE_TEXEL_COUNT_2_TO_EXP	( 27 )
+
+#define	D3D12_REQ_CONSTANT_BUFFER_ELEMENT_COUNT	( 4096 )
+
+#define	D3D12_REQ_DEPTH_STENCIL_OBJECT_COUNT_PER_DEVICE	( 4096 )
+
+#define	D3D12_REQ_DRAWINDEXED_INDEX_COUNT_2_TO_EXP	( 32 )
+
+#define	D3D12_REQ_DRAW_VERTEX_COUNT_2_TO_EXP	( 32 )
+
+#define	D3D12_REQ_FILTERING_HW_ADDRESSABLE_RESOURCE_DIMENSION	( 16384 )
+
+#define	D3D12_REQ_GS_INVOCATION_32BIT_OUTPUT_COMPONENT_LIMIT	( 1024 )
+
+#define	D3D12_REQ_IMMEDIATE_CONSTANT_BUFFER_ELEMENT_COUNT	( 4096 )
+
+#define	D3D12_REQ_MAXANISOTROPY	( 16 )
+
+#define	D3D12_REQ_MIP_LEVELS	( 15 )
+
+#define	D3D12_REQ_MULTI_ELEMENT_STRUCTURE_SIZE_IN_BYTES	( 2048 )
+
+#define	D3D12_REQ_RASTERIZER_OBJECT_COUNT_PER_DEVICE	( 4096 )
+
+#define	D3D12_REQ_RENDER_TO_BUFFER_WINDOW_WIDTH	( 16384 )
+
+#define	D3D12_REQ_RESOURCE_SIZE_IN_MEGABYTES_EXPRESSION_A_TERM	( 128 )
+
+#define D3D12_REQ_RESOURCE_SIZE_IN_MEGABYTES_EXPRESSION_B_TERM	( 0.25f )
+#define	D3D12_REQ_RESOURCE_SIZE_IN_MEGABYTES_EXPRESSION_C_TERM	( 2048 )
+
+#define	D3D12_REQ_RESOURCE_VIEW_COUNT_PER_DEVICE_2_TO_EXP	( 20 )
+
+#define	D3D12_REQ_SAMPLER_OBJECT_COUNT_PER_DEVICE	( 4096 )
+
+#define	D3D12_REQ_SUBRESOURCES	( 30720 )
+
+#define	D3D12_REQ_TEXTURE1D_ARRAY_AXIS_DIMENSION	( 2048 )
+
+#define	D3D12_REQ_TEXTURE1D_U_DIMENSION	( 16384 )
+
+#define	D3D12_REQ_TEXTURE2D_ARRAY_AXIS_DIMENSION	( 2048 )
+
+#define	D3D12_REQ_TEXTURE2D_U_OR_V_DIMENSION	( 16384 )
+
+#define	D3D12_REQ_TEXTURE3D_U_V_OR_W_DIMENSION	( 2048 )
+
+#define	D3D12_REQ_TEXTURECUBE_DIMENSION	( 16384 )
+
+#define	D3D12_RESINFO_INSTRUCTION_MISSING_COMPONENT_RETVAL	( 0 )
+
+#define	D3D12_RESOURCE_BARRIER_ALL_SUBRESOURCES	( 0xffffffff )
+
+#define	D3D12_RS_SET_SHADING_RATE_COMBINER_COUNT	( 2 )
+
+#define	D3D12_SDK_VERSION	( 606 )
+
+#define	D3D12_SHADER_IDENTIFIER_SIZE_IN_BYTES	( 32 )
+
+#define	D3D12_SHADER_MAJOR_VERSION	( 5 )
+
+#define	D3D12_SHADER_MAX_INSTANCES	( 65535 )
+
+#define	D3D12_SHADER_MAX_INTERFACES	( 253 )
+
+#define	D3D12_SHADER_MAX_INTERFACE_CALL_SITES	( 4096 )
+
+#define	D3D12_SHADER_MAX_TYPES	( 65535 )
+
+#define	D3D12_SHADER_MINOR_VERSION	( 1 )
+
+#define	D3D12_SHIFT_INSTRUCTION_PAD_VALUE	( 0 )
+
+#define	D3D12_SHIFT_INSTRUCTION_SHIFT_VALUE_BIT_COUNT	( 5 )
+
+#define	D3D12_SIMULTANEOUS_RENDER_TARGET_COUNT	( 8 )
+
+#define	D3D12_SMALL_MSAA_RESOURCE_PLACEMENT_ALIGNMENT	( 65536 )
+
+#define	D3D12_SMALL_RESOURCE_PLACEMENT_ALIGNMENT	( 4096 )
+
+#define	D3D12_SO_BUFFER_MAX_STRIDE_IN_BYTES	( 2048 )
+
+#define	D3D12_SO_BUFFER_MAX_WRITE_WINDOW_IN_BYTES	( 512 )
+
+#define	D3D12_SO_BUFFER_SLOT_COUNT	( 4 )
+
+#define	D3D12_SO_DDI_REGISTER_INDEX_DENOTING_GAP	( 0xffffffff )
+
+#define	D3D12_SO_NO_RASTERIZED_STREAM	( 0xffffffff )
+
+#define	D3D12_SO_OUTPUT_COMPONENT_COUNT	( 128 )
+
+#define	D3D12_SO_STREAM_COUNT	( 4 )
+
+#define	D3D12_SPEC_DATE_DAY	( 14 )
+
+#define	D3D12_SPEC_DATE_MONTH	( 11 )
+
+#define	D3D12_SPEC_DATE_YEAR	( 2014 )
+
+#define D3D12_SPEC_VERSION	( 1.16 )
+#define D3D12_SRGB_GAMMA	( 2.2f )
+#define D3D12_SRGB_TO_FLOAT_DENOMINATOR_1	( 12.92f )
+#define D3D12_SRGB_TO_FLOAT_DENOMINATOR_2	( 1.055f )
+#define D3D12_SRGB_TO_FLOAT_EXPONENT	( 2.4f )
+#define D3D12_SRGB_TO_FLOAT_OFFSET	( 0.055f )
+#define D3D12_SRGB_TO_FLOAT_THRESHOLD	( 0.04045f )
+#define D3D12_SRGB_TO_FLOAT_TOLERANCE_IN_ULP	( 0.5f )
+#define	D3D12_STANDARD_COMPONENT_BIT_COUNT	( 32 )
+
+#define	D3D12_STANDARD_COMPONENT_BIT_COUNT_DOUBLED	( 64 )
+
+#define	D3D12_STANDARD_MAXIMUM_ELEMENT_ALIGNMENT_BYTE_MULTIPLE	( 4 )
+
+#define	D3D12_STANDARD_PIXEL_COMPONENT_COUNT	( 128 )
+
+#define	D3D12_STANDARD_PIXEL_ELEMENT_COUNT	( 32 )
+
+#define	D3D12_STANDARD_VECTOR_SIZE	( 4 )
+
+#define	D3D12_STANDARD_VERTEX_ELEMENT_COUNT	( 32 )
+
+#define	D3D12_STANDARD_VERTEX_TOTAL_COMPONENT_COUNT	( 64 )
+
+#define	D3D12_SUBPIXEL_FRACTIONAL_BIT_COUNT	( 8 )
+
+#define	D3D12_SUBTEXEL_FRACTIONAL_BIT_COUNT	( 8 )
+
+#define	D3D12_SYSTEM_RESERVED_REGISTER_SPACE_VALUES_END	( 0xffffffff )
+
+#define	D3D12_SYSTEM_RESERVED_REGISTER_SPACE_VALUES_START	( 0xfffffff0 )
+
+#define	D3D12_TESSELLATOR_MAX_EVEN_TESSELLATION_FACTOR	( 64 )
+
+#define	D3D12_TESSELLATOR_MAX_ISOLINE_DENSITY_TESSELLATION_FACTOR	( 64 )
+
+#define	D3D12_TESSELLATOR_MAX_ODD_TESSELLATION_FACTOR	( 63 )
+
+#define	D3D12_TESSELLATOR_MAX_TESSELLATION_FACTOR	( 64 )
+
+#define	D3D12_TESSELLATOR_MIN_EVEN_TESSELLATION_FACTOR	( 2 )
+
+#define	D3D12_TESSELLATOR_MIN_ISOLINE_DENSITY_TESSELLATION_FACTOR	( 1 )
+
+#define	D3D12_TESSELLATOR_MIN_ODD_TESSELLATION_FACTOR	( 1 )
+
+#define	D3D12_TEXEL_ADDRESS_RANGE_BIT_COUNT	( 16 )
+
+#define	D3D12_TEXTURE_DATA_PITCH_ALIGNMENT	( 256 )
+
+#define	D3D12_TEXTURE_DATA_PLACEMENT_ALIGNMENT	( 512 )
+
+#define	D3D12_TILED_RESOURCE_TILE_SIZE_IN_BYTES	( 65536 )
+
+#define	D3D12_TRACKED_WORKLOAD_MAX_INSTANCES	( 32 )
+
+#define	D3D12_UAV_COUNTER_PLACEMENT_ALIGNMENT	( 4096 )
+
+#define	D3D12_UAV_SLOT_COUNT	( 64 )
+
+#define	D3D12_UNBOUND_MEMORY_ACCESS_RESULT	( 0 )
+
+#define	D3D12_VIDEO_DECODE_MAX_ARGUMENTS	( 10 )
+
+#define	D3D12_VIDEO_DECODE_MAX_HISTOGRAM_COMPONENTS	( 4 )
+
+#define	D3D12_VIDEO_DECODE_MIN_BITSTREAM_OFFSET_ALIGNMENT	( 256 )
+
+#define	D3D12_VIDEO_DECODE_MIN_HISTOGRAM_OFFSET_ALIGNMENT	( 256 )
+
+#define	D3D12_VIDEO_DECODE_STATUS_MACROBLOCKS_AFFECTED_UNKNOWN	( 0xffffffff )
+
+#define	D3D12_VIDEO_PROCESS_MAX_FILTERS	( 32 )
+
+#define	D3D12_VIDEO_PROCESS_STEREO_VIEWS	( 2 )
+
+#define	D3D12_VIEWPORT_AND_SCISSORRECT_MAX_INDEX	( 15 )
+
+#define	D3D12_VIEWPORT_AND_SCISSORRECT_OBJECT_COUNT_PER_PIPELINE	( 16 )
+
+#define	D3D12_VIEWPORT_BOUNDS_MAX	( 32767 )
+
+#define	D3D12_VIEWPORT_BOUNDS_MIN	( -32768 )
+
+#define	D3D12_VS_INPUT_REGISTER_COMPONENTS	( 4 )
+
+#define	D3D12_VS_INPUT_REGISTER_COMPONENT_BIT_COUNT	( 32 )
+
+#define	D3D12_VS_INPUT_REGISTER_COUNT	( 32 )
+
+#define	D3D12_VS_INPUT_REGISTER_READS_PER_INST	( 2 )
+
+#define	D3D12_VS_INPUT_REGISTER_READ_PORTS	( 1 )
+
+#define	D3D12_VS_OUTPUT_REGISTER_COMPONENTS	( 4 )
+
+#define	D3D12_VS_OUTPUT_REGISTER_COMPONENT_BIT_COUNT	( 32 )
+
+#define	D3D12_VS_OUTPUT_REGISTER_COUNT	( 32 )
+
+#define	D3D12_WHQL_CONTEXT_COUNT_FOR_RESOURCE_LIMIT	( 10 )
+
+#define	D3D12_WHQL_DRAWINDEXED_INDEX_COUNT_2_TO_EXP	( 25 )
+
+#define	D3D12_WHQL_DRAW_VERTEX_COUNT_2_TO_EXP	( 25 )
+
+#endif
+
+typedef UINT64 D3D12_GPU_VIRTUAL_ADDRESS;
+
+typedef 
+enum D3D12_COMMAND_LIST_TYPE
+    {
+        D3D12_COMMAND_LIST_TYPE_DIRECT	= 0,
+        D3D12_COMMAND_LIST_TYPE_BUNDLE	= 1,
+        D3D12_COMMAND_LIST_TYPE_COMPUTE	= 2,
+        D3D12_COMMAND_LIST_TYPE_COPY	= 3,
+        D3D12_COMMAND_LIST_TYPE_VIDEO_DECODE	= 4,
+        D3D12_COMMAND_LIST_TYPE_VIDEO_PROCESS	= 5,
+        D3D12_COMMAND_LIST_TYPE_VIDEO_ENCODE	= 6,
+        D3D12_COMMAND_LIST_TYPE_NONE	= -1
+    } 	D3D12_COMMAND_LIST_TYPE;
+
+typedef 
+enum D3D12_COMMAND_QUEUE_FLAGS
+    {
+        D3D12_COMMAND_QUEUE_FLAG_NONE	= 0,
+        D3D12_COMMAND_QUEUE_FLAG_DISABLE_GPU_TIMEOUT	= 0x1
+    } 	D3D12_COMMAND_QUEUE_FLAGS;
+
+DEFINE_ENUM_FLAG_OPERATORS( D3D12_COMMAND_QUEUE_FLAGS );
+typedef 
+enum D3D12_COMMAND_QUEUE_PRIORITY
+    {
+        D3D12_COMMAND_QUEUE_PRIORITY_NORMAL	= 0,
+        D3D12_COMMAND_QUEUE_PRIORITY_HIGH	= 100,
+        D3D12_COMMAND_QUEUE_PRIORITY_GLOBAL_REALTIME	= 10000
+    } 	D3D12_COMMAND_QUEUE_PRIORITY;
+
+typedef struct D3D12_COMMAND_QUEUE_DESC
+    {
+    D3D12_COMMAND_LIST_TYPE Type;
+    INT Priority;
+    D3D12_COMMAND_QUEUE_FLAGS Flags;
+    UINT NodeMask;
+    } 	D3D12_COMMAND_QUEUE_DESC;
+
+typedef 
+enum D3D12_PRIMITIVE_TOPOLOGY_TYPE
+    {
+        D3D12_PRIMITIVE_TOPOLOGY_TYPE_UNDEFINED	= 0,
+        D3D12_PRIMITIVE_TOPOLOGY_TYPE_POINT	= 1,
+        D3D12_PRIMITIVE_TOPOLOGY_TYPE_LINE	= 2,
+        D3D12_PRIMITIVE_TOPOLOGY_TYPE_TRIANGLE	= 3,
+        D3D12_PRIMITIVE_TOPOLOGY_TYPE_PATCH	= 4
+    } 	D3D12_PRIMITIVE_TOPOLOGY_TYPE;
+
+typedef 
+enum D3D12_INPUT_CLASSIFICATION
+    {
+        D3D12_INPUT_CLASSIFICATION_PER_VERTEX_DATA	= 0,
+        D3D12_INPUT_CLASSIFICATION_PER_INSTANCE_DATA	= 1
+    } 	D3D12_INPUT_CLASSIFICATION;
+
+typedef struct D3D12_INPUT_ELEMENT_DESC
+    {
+    LPCSTR SemanticName;
+    UINT SemanticIndex;
+    DXGI_FORMAT Format;
+    UINT InputSlot;
+    UINT AlignedByteOffset;
+    D3D12_INPUT_CLASSIFICATION InputSlotClass;
+    UINT InstanceDataStepRate;
+    } 	D3D12_INPUT_ELEMENT_DESC;
+
+typedef 
+enum D3D12_FILL_MODE
+    {
+        D3D12_FILL_MODE_WIREFRAME	= 2,
+        D3D12_FILL_MODE_SOLID	= 3
+    } 	D3D12_FILL_MODE;
+
+typedef D3D_PRIMITIVE_TOPOLOGY D3D12_PRIMITIVE_TOPOLOGY;
+
+typedef D3D_PRIMITIVE D3D12_PRIMITIVE;
+
+typedef 
+enum D3D12_CULL_MODE
+    {
+        D3D12_CULL_MODE_NONE	= 1,
+        D3D12_CULL_MODE_FRONT	= 2,
+        D3D12_CULL_MODE_BACK	= 3
+    } 	D3D12_CULL_MODE;
+
+typedef struct D3D12_SO_DECLARATION_ENTRY
+    {
+    UINT Stream;
+    LPCSTR SemanticName;
+    UINT SemanticIndex;
+    BYTE StartComponent;
+    BYTE ComponentCount;
+    BYTE OutputSlot;
+    } 	D3D12_SO_DECLARATION_ENTRY;
+
+typedef struct D3D12_VIEWPORT
+    {
+    FLOAT TopLeftX;
+    FLOAT TopLeftY;
+    FLOAT Width;
+    FLOAT Height;
+    FLOAT MinDepth;
+    FLOAT MaxDepth;
+    } 	D3D12_VIEWPORT;
+
+typedef RECT D3D12_RECT;
+
+typedef struct D3D12_BOX
+    {
+    UINT left;
+    UINT top;
+    UINT front;
+    UINT right;
+    UINT bottom;
+    UINT back;
+    } 	D3D12_BOX;
+
+typedef 
+enum D3D12_COMPARISON_FUNC
+    {
+        D3D12_COMPARISON_FUNC_NONE	= 0,
+        D3D12_COMPARISON_FUNC_NEVER	= 1,
+        D3D12_COMPARISON_FUNC_LESS	= 2,
+        D3D12_COMPARISON_FUNC_EQUAL	= 3,
+        D3D12_COMPARISON_FUNC_LESS_EQUAL	= 4,
+        D3D12_COMPARISON_FUNC_GREATER	= 5,
+        D3D12_COMPARISON_FUNC_NOT_EQUAL	= 6,
+        D3D12_COMPARISON_FUNC_GREATER_EQUAL	= 7,
+        D3D12_COMPARISON_FUNC_ALWAYS	= 8
+    } 	D3D12_COMPARISON_FUNC;
+
+typedef 
+enum D3D12_DEPTH_WRITE_MASK
+    {
+        D3D12_DEPTH_WRITE_MASK_ZERO	= 0,
+        D3D12_DEPTH_WRITE_MASK_ALL	= 1
+    } 	D3D12_DEPTH_WRITE_MASK;
+
+typedef 
+enum D3D12_STENCIL_OP
+    {
+        D3D12_STENCIL_OP_KEEP	= 1,
+        D3D12_STENCIL_OP_ZERO	= 2,
+        D3D12_STENCIL_OP_REPLACE	= 3,
+        D3D12_STENCIL_OP_INCR_SAT	= 4,
+        D3D12_STENCIL_OP_DECR_SAT	= 5,
+        D3D12_STENCIL_OP_INVERT	= 6,
+        D3D12_STENCIL_OP_INCR	= 7,
+        D3D12_STENCIL_OP_DECR	= 8
+    } 	D3D12_STENCIL_OP;
+
+typedef struct D3D12_DEPTH_STENCILOP_DESC
+    {
+    D3D12_STENCIL_OP StencilFailOp;
+    D3D12_STENCIL_OP StencilDepthFailOp;
+    D3D12_STENCIL_OP StencilPassOp;
+    D3D12_COMPARISON_FUNC StencilFunc;
+    } 	D3D12_DEPTH_STENCILOP_DESC;
+
+typedef struct D3D12_DEPTH_STENCIL_DESC
+    {
+    BOOL DepthEnable;
+    D3D12_DEPTH_WRITE_MASK DepthWriteMask;
+    D3D12_COMPARISON_FUNC DepthFunc;
+    BOOL StencilEnable;
+    UINT8 StencilReadMask;
+    UINT8 StencilWriteMask;
+    D3D12_DEPTH_STENCILOP_DESC FrontFace;
+    D3D12_DEPTH_STENCILOP_DESC BackFace;
+    } 	D3D12_DEPTH_STENCIL_DESC;
+
+typedef struct D3D12_DEPTH_STENCIL_DESC1
+    {
+    BOOL DepthEnable;
+    D3D12_DEPTH_WRITE_MASK DepthWriteMask;
+    D3D12_COMPARISON_FUNC DepthFunc;
+    BOOL StencilEnable;
+    UINT8 StencilReadMask;
+    UINT8 StencilWriteMask;
+    D3D12_DEPTH_STENCILOP_DESC FrontFace;
+    D3D12_DEPTH_STENCILOP_DESC BackFace;
+    BOOL DepthBoundsTestEnable;
+    } 	D3D12_DEPTH_STENCIL_DESC1;
+
+typedef struct D3D12_DEPTH_STENCILOP_DESC1
+    {
+    D3D12_STENCIL_OP StencilFailOp;
+    D3D12_STENCIL_OP StencilDepthFailOp;
+    D3D12_STENCIL_OP StencilPassOp;
+    D3D12_COMPARISON_FUNC StencilFunc;
+    UINT8 StencilReadMask;
+    UINT8 StencilWriteMask;
+    } 	D3D12_DEPTH_STENCILOP_DESC1;
+
+typedef struct D3D12_DEPTH_STENCIL_DESC2
+    {
+    BOOL DepthEnable;
+    D3D12_DEPTH_WRITE_MASK DepthWriteMask;
+    D3D12_COMPARISON_FUNC DepthFunc;
+    BOOL StencilEnable;
+    D3D12_DEPTH_STENCILOP_DESC1 FrontFace;
+    D3D12_DEPTH_STENCILOP_DESC1 BackFace;
+    BOOL DepthBoundsTestEnable;
+    } 	D3D12_DEPTH_STENCIL_DESC2;
+
+typedef 
+enum D3D12_BLEND
+    {
+        D3D12_BLEND_ZERO	= 1,
+        D3D12_BLEND_ONE	= 2,
+        D3D12_BLEND_SRC_COLOR	= 3,
+        D3D12_BLEND_INV_SRC_COLOR	= 4,
+        D3D12_BLEND_SRC_ALPHA	= 5,
+        D3D12_BLEND_INV_SRC_ALPHA	= 6,
+        D3D12_BLEND_DEST_ALPHA	= 7,
+        D3D12_BLEND_INV_DEST_ALPHA	= 8,
+        D3D12_BLEND_DEST_COLOR	= 9,
+        D3D12_BLEND_INV_DEST_COLOR	= 10,
+        D3D12_BLEND_SRC_ALPHA_SAT	= 11,
+        D3D12_BLEND_BLEND_FACTOR	= 14,
+        D3D12_BLEND_INV_BLEND_FACTOR	= 15,
+        D3D12_BLEND_SRC1_COLOR	= 16,
+        D3D12_BLEND_INV_SRC1_COLOR	= 17,
+        D3D12_BLEND_SRC1_ALPHA	= 18,
+        D3D12_BLEND_INV_SRC1_ALPHA	= 19,
+        D3D12_BLEND_ALPHA_FACTOR	= 20,
+        D3D12_BLEND_INV_ALPHA_FACTOR	= 21
+    } 	D3D12_BLEND;
+
+typedef 
+enum D3D12_BLEND_OP
+    {
+        D3D12_BLEND_OP_ADD	= 1,
+        D3D12_BLEND_OP_SUBTRACT	= 2,
+        D3D12_BLEND_OP_REV_SUBTRACT	= 3,
+        D3D12_BLEND_OP_MIN	= 4,
+        D3D12_BLEND_OP_MAX	= 5
+    } 	D3D12_BLEND_OP;
+
+typedef 
+enum D3D12_COLOR_WRITE_ENABLE
+    {
+        D3D12_COLOR_WRITE_ENABLE_RED	= 1,
+        D3D12_COLOR_WRITE_ENABLE_GREEN	= 2,
+        D3D12_COLOR_WRITE_ENABLE_BLUE	= 4,
+        D3D12_COLOR_WRITE_ENABLE_ALPHA	= 8,
+        D3D12_COLOR_WRITE_ENABLE_ALL	= ( ( ( D3D12_COLOR_WRITE_ENABLE_RED | D3D12_COLOR_WRITE_ENABLE_GREEN )  | D3D12_COLOR_WRITE_ENABLE_BLUE )  | D3D12_COLOR_WRITE_ENABLE_ALPHA ) 
+    } 	D3D12_COLOR_WRITE_ENABLE;
+
+typedef 
+enum D3D12_LOGIC_OP
+    {
+        D3D12_LOGIC_OP_CLEAR	= 0,
+        D3D12_LOGIC_OP_SET	= ( D3D12_LOGIC_OP_CLEAR + 1 ) ,
+        D3D12_LOGIC_OP_COPY	= ( D3D12_LOGIC_OP_SET + 1 ) ,
+        D3D12_LOGIC_OP_COPY_INVERTED	= ( D3D12_LOGIC_OP_COPY + 1 ) ,
+        D3D12_LOGIC_OP_NOOP	= ( D3D12_LOGIC_OP_COPY_INVERTED + 1 ) ,
+        D3D12_LOGIC_OP_INVERT	= ( D3D12_LOGIC_OP_NOOP + 1 ) ,
+        D3D12_LOGIC_OP_AND	= ( D3D12_LOGIC_OP_INVERT + 1 ) ,
+        D3D12_LOGIC_OP_NAND	= ( D3D12_LOGIC_OP_AND + 1 ) ,
+        D3D12_LOGIC_OP_OR	= ( D3D12_LOGIC_OP_NAND + 1 ) ,
+        D3D12_LOGIC_OP_NOR	= ( D3D12_LOGIC_OP_OR + 1 ) ,
+        D3D12_LOGIC_OP_XOR	= ( D3D12_LOGIC_OP_NOR + 1 ) ,
+        D3D12_LOGIC_OP_EQUIV	= ( D3D12_LOGIC_OP_XOR + 1 ) ,
+        D3D12_LOGIC_OP_AND_REVERSE	= ( D3D12_LOGIC_OP_EQUIV + 1 ) ,
+        D3D12_LOGIC_OP_AND_INVERTED	= ( D3D12_LOGIC_OP_AND_REVERSE + 1 ) ,
+        D3D12_LOGIC_OP_OR_REVERSE	= ( D3D12_LOGIC_OP_AND_INVERTED + 1 ) ,
+        D3D12_LOGIC_OP_OR_INVERTED	= ( D3D12_LOGIC_OP_OR_REVERSE + 1 ) 
+    } 	D3D12_LOGIC_OP;
+
+typedef struct D3D12_RENDER_TARGET_BLEND_DESC
+    {
+    BOOL BlendEnable;
+    BOOL LogicOpEnable;
+    D3D12_BLEND SrcBlend;
+    D3D12_BLEND DestBlend;
+    D3D12_BLEND_OP BlendOp;
+    D3D12_BLEND SrcBlendAlpha;
+    D3D12_BLEND DestBlendAlpha;
+    D3D12_BLEND_OP BlendOpAlpha;
+    D3D12_LOGIC_OP LogicOp;
+    UINT8 RenderTargetWriteMask;
+    } 	D3D12_RENDER_TARGET_BLEND_DESC;
+
+typedef struct D3D12_BLEND_DESC
+    {
+    BOOL AlphaToCoverageEnable;
+    BOOL IndependentBlendEnable;
+    D3D12_RENDER_TARGET_BLEND_DESC RenderTarget[ 8 ];
+    } 	D3D12_BLEND_DESC;
+
+/* Note, the array size for RenderTarget[] above is D3D12_SIMULTANEOUS_RENDERTARGET_COUNT. 
+   IDL processing/generation of this header replaces the define; this comment is merely explaining what happened. */
+typedef 
+enum D3D12_CONSERVATIVE_RASTERIZATION_MODE
+    {
+        D3D12_CONSERVATIVE_RASTERIZATION_MODE_OFF	= 0,
+        D3D12_CONSERVATIVE_RASTERIZATION_MODE_ON	= 1
+    } 	D3D12_CONSERVATIVE_RASTERIZATION_MODE;
+
+typedef struct D3D12_RASTERIZER_DESC
+    {
+    D3D12_FILL_MODE FillMode;
+    D3D12_CULL_MODE CullMode;
+    BOOL FrontCounterClockwise;
+    INT DepthBias;
+    FLOAT DepthBiasClamp;
+    FLOAT SlopeScaledDepthBias;
+    BOOL DepthClipEnable;
+    BOOL MultisampleEnable;
+    BOOL AntialiasedLineEnable;
+    UINT ForcedSampleCount;
+    D3D12_CONSERVATIVE_RASTERIZATION_MODE ConservativeRaster;
+    } 	D3D12_RASTERIZER_DESC;
+
+
+
+extern RPC_IF_HANDLE __MIDL_itf_d3d12_0000_0000_v0_0_c_ifspec;
+extern RPC_IF_HANDLE __MIDL_itf_d3d12_0000_0000_v0_0_s_ifspec;
+
+#ifndef __ID3D12Object_INTERFACE_DEFINED__
+#define __ID3D12Object_INTERFACE_DEFINED__
+
+/* interface ID3D12Object */
+/* [unique][local][object][uuid] */ 
+
+
+EXTERN_C const IID IID_ID3D12Object;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("c4fec28f-7966-4e95-9f94-f431cb56c3b8")
+    ID3D12Object : public IUnknown
+    {
+    public:
+        virtual HRESULT STDMETHODCALLTYPE GetPrivateData( 
+            _In_  REFGUID guid,
+            _Inout_  UINT *pDataSize,
+            _Out_writes_bytes_opt_( *pDataSize )  void *pData) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE SetPrivateData( 
+            _In_  REFGUID guid,
+            _In_  UINT DataSize,
+            _In_reads_bytes_opt_( DataSize )  const void *pData) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE SetPrivateDataInterface( 
+            _In_  REFGUID guid,
+            _In_opt_  const IUnknown *pData) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE SetName( 
+            _In_z_  LPCWSTR Name) = 0;
+        
+    };
+    
+    
+#else 	/* C style interface */
+
+    typedef struct ID3D12ObjectVtbl
+    {
+        BEGIN_INTERFACE
+        
+        DECLSPEC_XFGVIRT(IUnknown, QueryInterface)
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            ID3D12Object * This,
+            REFIID riid,
+            _COM_Outptr_  void **ppvObject);
+        
+        DECLSPEC_XFGVIRT(IUnknown, AddRef)
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            ID3D12Object * This);
+        
+        DECLSPEC_XFGVIRT(IUnknown, Release)
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            ID3D12Object * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, GetPrivateData)
+        HRESULT ( STDMETHODCALLTYPE *GetPrivateData )( 
+            ID3D12Object * This,
+            _In_  REFGUID guid,
+            _Inout_  UINT *pDataSize,
+            _Out_writes_bytes_opt_( *pDataSize )  void *pData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, SetPrivateData)
+        HRESULT ( STDMETHODCALLTYPE *SetPrivateData )( 
+            ID3D12Object * This,
+            _In_  REFGUID guid,
+            _In_  UINT DataSize,
+            _In_reads_bytes_opt_( DataSize )  const void *pData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, SetPrivateDataInterface)
+        HRESULT ( STDMETHODCALLTYPE *SetPrivateDataInterface )( 
+            ID3D12Object * This,
+            _In_  REFGUID guid,
+            _In_opt_  const IUnknown *pData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, SetName)
+        HRESULT ( STDMETHODCALLTYPE *SetName )( 
+            ID3D12Object * This,
+            _In_z_  LPCWSTR Name);
+        
+        END_INTERFACE
+    } ID3D12ObjectVtbl;
+
+    interface ID3D12Object
+    {
+        CONST_VTBL struct ID3D12ObjectVtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define ID3D12Object_QueryInterface(This,riid,ppvObject)	\
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define ID3D12Object_AddRef(This)	\
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define ID3D12Object_Release(This)	\
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#define ID3D12Object_GetPrivateData(This,guid,pDataSize,pData)	\
+    ( (This)->lpVtbl -> GetPrivateData(This,guid,pDataSize,pData) ) 
+
+#define ID3D12Object_SetPrivateData(This,guid,DataSize,pData)	\
+    ( (This)->lpVtbl -> SetPrivateData(This,guid,DataSize,pData) ) 
+
+#define ID3D12Object_SetPrivateDataInterface(This,guid,pData)	\
+    ( (This)->lpVtbl -> SetPrivateDataInterface(This,guid,pData) ) 
+
+#define ID3D12Object_SetName(This,Name)	\
+    ( (This)->lpVtbl -> SetName(This,Name) ) 
+
+#endif /* COBJMACROS */
+
+
+#endif 	/* C style interface */
+
+
+
+
+#endif 	/* __ID3D12Object_INTERFACE_DEFINED__ */
+
+
+#ifndef __ID3D12DeviceChild_INTERFACE_DEFINED__
+#define __ID3D12DeviceChild_INTERFACE_DEFINED__
+
+/* interface ID3D12DeviceChild */
+/* [unique][local][object][uuid] */ 
+
+
+EXTERN_C const IID IID_ID3D12DeviceChild;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("905db94b-a00c-4140-9df5-2b64ca9ea357")
+    ID3D12DeviceChild : public ID3D12Object
+    {
+    public:
+        virtual HRESULT STDMETHODCALLTYPE GetDevice( 
+            REFIID riid,
+            _COM_Outptr_opt_  void **ppvDevice) = 0;
+        
+    };
+    
+    
+#else 	/* C style interface */
+
+    typedef struct ID3D12DeviceChildVtbl
+    {
+        BEGIN_INTERFACE
+        
+        DECLSPEC_XFGVIRT(IUnknown, QueryInterface)
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            ID3D12DeviceChild * This,
+            REFIID riid,
+            _COM_Outptr_  void **ppvObject);
+        
+        DECLSPEC_XFGVIRT(IUnknown, AddRef)
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            ID3D12DeviceChild * This);
+        
+        DECLSPEC_XFGVIRT(IUnknown, Release)
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            ID3D12DeviceChild * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, GetPrivateData)
+        HRESULT ( STDMETHODCALLTYPE *GetPrivateData )( 
+            ID3D12DeviceChild * This,
+            _In_  REFGUID guid,
+            _Inout_  UINT *pDataSize,
+            _Out_writes_bytes_opt_( *pDataSize )  void *pData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, SetPrivateData)
+        HRESULT ( STDMETHODCALLTYPE *SetPrivateData )( 
+            ID3D12DeviceChild * This,
+            _In_  REFGUID guid,
+            _In_  UINT DataSize,
+            _In_reads_bytes_opt_( DataSize )  const void *pData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, SetPrivateDataInterface)
+        HRESULT ( STDMETHODCALLTYPE *SetPrivateDataInterface )( 
+            ID3D12DeviceChild * This,
+            _In_  REFGUID guid,
+            _In_opt_  const IUnknown *pData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, SetName)
+        HRESULT ( STDMETHODCALLTYPE *SetName )( 
+            ID3D12DeviceChild * This,
+            _In_z_  LPCWSTR Name);
+        
+        DECLSPEC_XFGVIRT(ID3D12DeviceChild, GetDevice)
+        HRESULT ( STDMETHODCALLTYPE *GetDevice )( 
+            ID3D12DeviceChild * This,
+            REFIID riid,
+            _COM_Outptr_opt_  void **ppvDevice);
+        
+        END_INTERFACE
+    } ID3D12DeviceChildVtbl;
+
+    interface ID3D12DeviceChild
+    {
+        CONST_VTBL struct ID3D12DeviceChildVtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define ID3D12DeviceChild_QueryInterface(This,riid,ppvObject)	\
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define ID3D12DeviceChild_AddRef(This)	\
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define ID3D12DeviceChild_Release(This)	\
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#define ID3D12DeviceChild_GetPrivateData(This,guid,pDataSize,pData)	\
+    ( (This)->lpVtbl -> GetPrivateData(This,guid,pDataSize,pData) ) 
+
+#define ID3D12DeviceChild_SetPrivateData(This,guid,DataSize,pData)	\
+    ( (This)->lpVtbl -> SetPrivateData(This,guid,DataSize,pData) ) 
+
+#define ID3D12DeviceChild_SetPrivateDataInterface(This,guid,pData)	\
+    ( (This)->lpVtbl -> SetPrivateDataInterface(This,guid,pData) ) 
+
+#define ID3D12DeviceChild_SetName(This,Name)	\
+    ( (This)->lpVtbl -> SetName(This,Name) ) 
+
+
+#define ID3D12DeviceChild_GetDevice(This,riid,ppvDevice)	\
+    ( (This)->lpVtbl -> GetDevice(This,riid,ppvDevice) ) 
+
+#endif /* COBJMACROS */
+
+
+#endif 	/* C style interface */
+
+
+
+
+#endif 	/* __ID3D12DeviceChild_INTERFACE_DEFINED__ */
+
+
+#ifndef __ID3D12RootSignature_INTERFACE_DEFINED__
+#define __ID3D12RootSignature_INTERFACE_DEFINED__
+
+/* interface ID3D12RootSignature */
+/* [unique][local][object][uuid] */ 
+
+
+EXTERN_C const IID IID_ID3D12RootSignature;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("c54a6b66-72df-4ee8-8be5-a946a1429214")
+    ID3D12RootSignature : public ID3D12DeviceChild
+    {
+    public:
+    };
+    
+    
+#else 	/* C style interface */
+
+    typedef struct ID3D12RootSignatureVtbl
+    {
+        BEGIN_INTERFACE
+        
+        DECLSPEC_XFGVIRT(IUnknown, QueryInterface)
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            ID3D12RootSignature * This,
+            REFIID riid,
+            _COM_Outptr_  void **ppvObject);
+        
+        DECLSPEC_XFGVIRT(IUnknown, AddRef)
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            ID3D12RootSignature * This);
+        
+        DECLSPEC_XFGVIRT(IUnknown, Release)
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            ID3D12RootSignature * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, GetPrivateData)
+        HRESULT ( STDMETHODCALLTYPE *GetPrivateData )( 
+            ID3D12RootSignature * This,
+            _In_  REFGUID guid,
+            _Inout_  UINT *pDataSize,
+            _Out_writes_bytes_opt_( *pDataSize )  void *pData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, SetPrivateData)
+        HRESULT ( STDMETHODCALLTYPE *SetPrivateData )( 
+            ID3D12RootSignature * This,
+            _In_  REFGUID guid,
+            _In_  UINT DataSize,
+            _In_reads_bytes_opt_( DataSize )  const void *pData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, SetPrivateDataInterface)
+        HRESULT ( STDMETHODCALLTYPE *SetPrivateDataInterface )( 
+            ID3D12RootSignature * This,
+            _In_  REFGUID guid,
+            _In_opt_  const IUnknown *pData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, SetName)
+        HRESULT ( STDMETHODCALLTYPE *SetName )( 
+            ID3D12RootSignature * This,
+            _In_z_  LPCWSTR Name);
+        
+        DECLSPEC_XFGVIRT(ID3D12DeviceChild, GetDevice)
+        HRESULT ( STDMETHODCALLTYPE *GetDevice )( 
+            ID3D12RootSignature * This,
+            REFIID riid,
+            _COM_Outptr_opt_  void **ppvDevice);
+        
+        END_INTERFACE
+    } ID3D12RootSignatureVtbl;
+
+    interface ID3D12RootSignature
+    {
+        CONST_VTBL struct ID3D12RootSignatureVtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define ID3D12RootSignature_QueryInterface(This,riid,ppvObject)	\
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define ID3D12RootSignature_AddRef(This)	\
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define ID3D12RootSignature_Release(This)	\
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#define ID3D12RootSignature_GetPrivateData(This,guid,pDataSize,pData)	\
+    ( (This)->lpVtbl -> GetPrivateData(This,guid,pDataSize,pData) ) 
+
+#define ID3D12RootSignature_SetPrivateData(This,guid,DataSize,pData)	\
+    ( (This)->lpVtbl -> SetPrivateData(This,guid,DataSize,pData) ) 
+
+#define ID3D12RootSignature_SetPrivateDataInterface(This,guid,pData)	\
+    ( (This)->lpVtbl -> SetPrivateDataInterface(This,guid,pData) ) 
+
+#define ID3D12RootSignature_SetName(This,Name)	\
+    ( (This)->lpVtbl -> SetName(This,Name) ) 
+
+
+#define ID3D12RootSignature_GetDevice(This,riid,ppvDevice)	\
+    ( (This)->lpVtbl -> GetDevice(This,riid,ppvDevice) ) 
+
+
+#endif /* COBJMACROS */
+
+
+#endif 	/* C style interface */
+
+
+
+
+#endif 	/* __ID3D12RootSignature_INTERFACE_DEFINED__ */
+
+
+/* interface __MIDL_itf_d3d12_0000_0001 */
+/* [local] */ 
+
+typedef struct D3D12_SHADER_BYTECODE
+    {
+    _Field_size_bytes_full_(BytecodeLength)  const void *pShaderBytecode;
+    SIZE_T BytecodeLength;
+    } 	D3D12_SHADER_BYTECODE;
+
+typedef struct D3D12_STREAM_OUTPUT_DESC
+    {
+    _Field_size_full_(NumEntries)  const D3D12_SO_DECLARATION_ENTRY *pSODeclaration;
+    UINT NumEntries;
+    _Field_size_full_(NumStrides)  const UINT *pBufferStrides;
+    UINT NumStrides;
+    UINT RasterizedStream;
+    } 	D3D12_STREAM_OUTPUT_DESC;
+
+typedef struct D3D12_INPUT_LAYOUT_DESC
+    {
+    _Field_size_full_(NumElements)  const D3D12_INPUT_ELEMENT_DESC *pInputElementDescs;
+    UINT NumElements;
+    } 	D3D12_INPUT_LAYOUT_DESC;
+
+typedef 
+enum D3D12_INDEX_BUFFER_STRIP_CUT_VALUE
+    {
+        D3D12_INDEX_BUFFER_STRIP_CUT_VALUE_DISABLED	= 0,
+        D3D12_INDEX_BUFFER_STRIP_CUT_VALUE_0xFFFF	= 1,
+        D3D12_INDEX_BUFFER_STRIP_CUT_VALUE_0xFFFFFFFF	= 2
+    } 	D3D12_INDEX_BUFFER_STRIP_CUT_VALUE;
+
+typedef struct D3D12_CACHED_PIPELINE_STATE
+    {
+    _Field_size_bytes_full_(CachedBlobSizeInBytes)  const void *pCachedBlob;
+    SIZE_T CachedBlobSizeInBytes;
+    } 	D3D12_CACHED_PIPELINE_STATE;
+
+typedef 
+enum D3D12_PIPELINE_STATE_FLAGS
+    {
+        D3D12_PIPELINE_STATE_FLAG_NONE	= 0,
+        D3D12_PIPELINE_STATE_FLAG_TOOL_DEBUG	= 0x1
+    } 	D3D12_PIPELINE_STATE_FLAGS;
+
+DEFINE_ENUM_FLAG_OPERATORS( D3D12_PIPELINE_STATE_FLAGS );
+typedef struct D3D12_GRAPHICS_PIPELINE_STATE_DESC
+    {
+    ID3D12RootSignature *pRootSignature;
+    D3D12_SHADER_BYTECODE VS;
+    D3D12_SHADER_BYTECODE PS;
+    D3D12_SHADER_BYTECODE DS;
+    D3D12_SHADER_BYTECODE HS;
+    D3D12_SHADER_BYTECODE GS;
+    D3D12_STREAM_OUTPUT_DESC StreamOutput;
+    D3D12_BLEND_DESC BlendState;
+    UINT SampleMask;
+    D3D12_RASTERIZER_DESC RasterizerState;
+    D3D12_DEPTH_STENCIL_DESC DepthStencilState;
+    D3D12_INPUT_LAYOUT_DESC InputLayout;
+    D3D12_INDEX_BUFFER_STRIP_CUT_VALUE IBStripCutValue;
+    D3D12_PRIMITIVE_TOPOLOGY_TYPE PrimitiveTopologyType;
+    UINT NumRenderTargets;
+    DXGI_FORMAT RTVFormats[ 8 ];
+    DXGI_FORMAT DSVFormat;
+    DXGI_SAMPLE_DESC SampleDesc;
+    UINT NodeMask;
+    D3D12_CACHED_PIPELINE_STATE CachedPSO;
+    D3D12_PIPELINE_STATE_FLAGS Flags;
+    } 	D3D12_GRAPHICS_PIPELINE_STATE_DESC;
+
+typedef struct D3D12_COMPUTE_PIPELINE_STATE_DESC
+    {
+    ID3D12RootSignature *pRootSignature;
+    D3D12_SHADER_BYTECODE CS;
+    UINT NodeMask;
+    D3D12_CACHED_PIPELINE_STATE CachedPSO;
+    D3D12_PIPELINE_STATE_FLAGS Flags;
+    } 	D3D12_COMPUTE_PIPELINE_STATE_DESC;
+
+struct D3D12_RT_FORMAT_ARRAY
+    {
+    DXGI_FORMAT RTFormats[ 8 ];
+    UINT NumRenderTargets;
+    } ;
+typedef struct D3D12_PIPELINE_STATE_STREAM_DESC
+    {
+    _In_  SIZE_T SizeInBytes;
+    _In_reads_(_Inexpressible_("Dependent on size of subobjects"))  void *pPipelineStateSubobjectStream;
+    } 	D3D12_PIPELINE_STATE_STREAM_DESC;
+
+typedef 
+enum D3D12_PIPELINE_STATE_SUBOBJECT_TYPE
+    {
+        D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_ROOT_SIGNATURE	= 0,
+        D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_VS	= ( D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_ROOT_SIGNATURE + 1 ) ,
+        D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_PS	= ( D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_VS + 1 ) ,
+        D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_DS	= ( D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_PS + 1 ) ,
+        D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_HS	= ( D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_DS + 1 ) ,
+        D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_GS	= ( D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_HS + 1 ) ,
+        D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_CS	= ( D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_GS + 1 ) ,
+        D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_STREAM_OUTPUT	= ( D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_CS + 1 ) ,
+        D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_BLEND	= ( D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_STREAM_OUTPUT + 1 ) ,
+        D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_SAMPLE_MASK	= ( D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_BLEND + 1 ) ,
+        D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_RASTERIZER	= ( D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_SAMPLE_MASK + 1 ) ,
+        D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_DEPTH_STENCIL	= ( D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_RASTERIZER + 1 ) ,
+        D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_INPUT_LAYOUT	= ( D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_DEPTH_STENCIL + 1 ) ,
+        D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_IB_STRIP_CUT_VALUE	= ( D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_INPUT_LAYOUT + 1 ) ,
+        D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_PRIMITIVE_TOPOLOGY	= ( D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_IB_STRIP_CUT_VALUE + 1 ) ,
+        D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_RENDER_TARGET_FORMATS	= ( D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_PRIMITIVE_TOPOLOGY + 1 ) ,
+        D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_DEPTH_STENCIL_FORMAT	= ( D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_RENDER_TARGET_FORMATS + 1 ) ,
+        D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_SAMPLE_DESC	= ( D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_DEPTH_STENCIL_FORMAT + 1 ) ,
+        D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_NODE_MASK	= ( D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_SAMPLE_DESC + 1 ) ,
+        D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_CACHED_PSO	= ( D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_NODE_MASK + 1 ) ,
+        D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_FLAGS	= ( D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_CACHED_PSO + 1 ) ,
+        D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_DEPTH_STENCIL1	= ( D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_FLAGS + 1 ) ,
+        D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_VIEW_INSTANCING	= ( D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_DEPTH_STENCIL1 + 1 ) ,
+        D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_AS	= 24,
+        D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_MS	= 25,
+        D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_DEPTH_STENCIL2	= 26,
+        D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_MAX_VALID	= ( D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_DEPTH_STENCIL2 + 1 ) 
+    } 	D3D12_PIPELINE_STATE_SUBOBJECT_TYPE;
+
+typedef 
+enum D3D12_FEATURE
+    {
+        D3D12_FEATURE_D3D12_OPTIONS	= 0,
+        D3D12_FEATURE_ARCHITECTURE	= 1,
+        D3D12_FEATURE_FEATURE_LEVELS	= 2,
+        D3D12_FEATURE_FORMAT_SUPPORT	= 3,
+        D3D12_FEATURE_MULTISAMPLE_QUALITY_LEVELS	= 4,
+        D3D12_FEATURE_FORMAT_INFO	= 5,
+        D3D12_FEATURE_GPU_VIRTUAL_ADDRESS_SUPPORT	= 6,
+        D3D12_FEATURE_SHADER_MODEL	= 7,
+        D3D12_FEATURE_D3D12_OPTIONS1	= 8,
+        D3D12_FEATURE_PROTECTED_RESOURCE_SESSION_SUPPORT	= 10,
+        D3D12_FEATURE_ROOT_SIGNATURE	= 12,
+        D3D12_FEATURE_ARCHITECTURE1	= 16,
+        D3D12_FEATURE_D3D12_OPTIONS2	= 18,
+        D3D12_FEATURE_SHADER_CACHE	= 19,
+        D3D12_FEATURE_COMMAND_QUEUE_PRIORITY	= 20,
+        D3D12_FEATURE_D3D12_OPTIONS3	= 21,
+        D3D12_FEATURE_EXISTING_HEAPS	= 22,
+        D3D12_FEATURE_D3D12_OPTIONS4	= 23,
+        D3D12_FEATURE_SERIALIZATION	= 24,
+        D3D12_FEATURE_CROSS_NODE	= 25,
+        D3D12_FEATURE_D3D12_OPTIONS5	= 27,
+        D3D12_FEATURE_DISPLAYABLE	= 28,
+        D3D12_FEATURE_D3D12_OPTIONS6	= 30,
+        D3D12_FEATURE_QUERY_META_COMMAND	= 31,
+        D3D12_FEATURE_D3D12_OPTIONS7	= 32,
+        D3D12_FEATURE_PROTECTED_RESOURCE_SESSION_TYPE_COUNT	= 33,
+        D3D12_FEATURE_PROTECTED_RESOURCE_SESSION_TYPES	= 34,
+        D3D12_FEATURE_D3D12_OPTIONS8	= 36,
+        D3D12_FEATURE_D3D12_OPTIONS9	= 37,
+        D3D12_FEATURE_D3D12_OPTIONS10	= 39,
+        D3D12_FEATURE_D3D12_OPTIONS11	= 40,
+        D3D12_FEATURE_D3D12_OPTIONS12	= 41,
+        D3D12_FEATURE_D3D12_OPTIONS13	= 42,
+        D3D12_FEATURE_D3D12_OPTIONS14	= 43,
+        D3D12_FEATURE_D3D12_OPTIONS15	= 44
+    } 	D3D12_FEATURE;
+
+typedef 
+enum D3D12_SHADER_MIN_PRECISION_SUPPORT
+    {
+        D3D12_SHADER_MIN_PRECISION_SUPPORT_NONE	= 0,
+        D3D12_SHADER_MIN_PRECISION_SUPPORT_10_BIT	= 0x1,
+        D3D12_SHADER_MIN_PRECISION_SUPPORT_16_BIT	= 0x2
+    } 	D3D12_SHADER_MIN_PRECISION_SUPPORT;
+
+DEFINE_ENUM_FLAG_OPERATORS( D3D12_SHADER_MIN_PRECISION_SUPPORT );
+typedef 
+enum D3D12_TILED_RESOURCES_TIER
+    {
+        D3D12_TILED_RESOURCES_TIER_NOT_SUPPORTED	= 0,
+        D3D12_TILED_RESOURCES_TIER_1	= 1,
+        D3D12_TILED_RESOURCES_TIER_2	= 2,
+        D3D12_TILED_RESOURCES_TIER_3	= 3,
+        D3D12_TILED_RESOURCES_TIER_4	= 4
+    } 	D3D12_TILED_RESOURCES_TIER;
+
+typedef 
+enum D3D12_RESOURCE_BINDING_TIER
+    {
+        D3D12_RESOURCE_BINDING_TIER_1	= 1,
+        D3D12_RESOURCE_BINDING_TIER_2	= 2,
+        D3D12_RESOURCE_BINDING_TIER_3	= 3
+    } 	D3D12_RESOURCE_BINDING_TIER;
+
+typedef 
+enum D3D12_CONSERVATIVE_RASTERIZATION_TIER
+    {
+        D3D12_CONSERVATIVE_RASTERIZATION_TIER_NOT_SUPPORTED	= 0,
+        D3D12_CONSERVATIVE_RASTERIZATION_TIER_1	= 1,
+        D3D12_CONSERVATIVE_RASTERIZATION_TIER_2	= 2,
+        D3D12_CONSERVATIVE_RASTERIZATION_TIER_3	= 3
+    } 	D3D12_CONSERVATIVE_RASTERIZATION_TIER;
+
+typedef 
+enum D3D12_FORMAT_SUPPORT1
+    {
+        D3D12_FORMAT_SUPPORT1_NONE	= 0,
+        D3D12_FORMAT_SUPPORT1_BUFFER	= 0x1,
+        D3D12_FORMAT_SUPPORT1_IA_VERTEX_BUFFER	= 0x2,
+        D3D12_FORMAT_SUPPORT1_IA_INDEX_BUFFER	= 0x4,
+        D3D12_FORMAT_SUPPORT1_SO_BUFFER	= 0x8,
+        D3D12_FORMAT_SUPPORT1_TEXTURE1D	= 0x10,
+        D3D12_FORMAT_SUPPORT1_TEXTURE2D	= 0x20,
+        D3D12_FORMAT_SUPPORT1_TEXTURE3D	= 0x40,
+        D3D12_FORMAT_SUPPORT1_TEXTURECUBE	= 0x80,
+        D3D12_FORMAT_SUPPORT1_SHADER_LOAD	= 0x100,
+        D3D12_FORMAT_SUPPORT1_SHADER_SAMPLE	= 0x200,
+        D3D12_FORMAT_SUPPORT1_SHADER_SAMPLE_COMPARISON	= 0x400,
+        D3D12_FORMAT_SUPPORT1_SHADER_SAMPLE_MONO_TEXT	= 0x800,
+        D3D12_FORMAT_SUPPORT1_MIP	= 0x1000,
+        D3D12_FORMAT_SUPPORT1_RENDER_TARGET	= 0x4000,
+        D3D12_FORMAT_SUPPORT1_BLENDABLE	= 0x8000,
+        D3D12_FORMAT_SUPPORT1_DEPTH_STENCIL	= 0x10000,
+        D3D12_FORMAT_SUPPORT1_MULTISAMPLE_RESOLVE	= 0x40000,
+        D3D12_FORMAT_SUPPORT1_DISPLAY	= 0x80000,
+        D3D12_FORMAT_SUPPORT1_CAST_WITHIN_BIT_LAYOUT	= 0x100000,
+        D3D12_FORMAT_SUPPORT1_MULTISAMPLE_RENDERTARGET	= 0x200000,
+        D3D12_FORMAT_SUPPORT1_MULTISAMPLE_LOAD	= 0x400000,
+        D3D12_FORMAT_SUPPORT1_SHADER_GATHER	= 0x800000,
+        D3D12_FORMAT_SUPPORT1_BACK_BUFFER_CAST	= 0x1000000,
+        D3D12_FORMAT_SUPPORT1_TYPED_UNORDERED_ACCESS_VIEW	= 0x2000000,
+        D3D12_FORMAT_SUPPORT1_SHADER_GATHER_COMPARISON	= 0x4000000,
+        D3D12_FORMAT_SUPPORT1_DECODER_OUTPUT	= 0x8000000,
+        D3D12_FORMAT_SUPPORT1_VIDEO_PROCESSOR_OUTPUT	= 0x10000000,
+        D3D12_FORMAT_SUPPORT1_VIDEO_PROCESSOR_INPUT	= 0x20000000,
+        D3D12_FORMAT_SUPPORT1_VIDEO_ENCODER	= 0x40000000
+    } 	D3D12_FORMAT_SUPPORT1;
+
+DEFINE_ENUM_FLAG_OPERATORS( D3D12_FORMAT_SUPPORT1 );
+typedef 
+enum D3D12_FORMAT_SUPPORT2
+    {
+        D3D12_FORMAT_SUPPORT2_NONE	= 0,
+        D3D12_FORMAT_SUPPORT2_UAV_ATOMIC_ADD	= 0x1,
+        D3D12_FORMAT_SUPPORT2_UAV_ATOMIC_BITWISE_OPS	= 0x2,
+        D3D12_FORMAT_SUPPORT2_UAV_ATOMIC_COMPARE_STORE_OR_COMPARE_EXCHANGE	= 0x4,
+        D3D12_FORMAT_SUPPORT2_UAV_ATOMIC_EXCHANGE	= 0x8,
+        D3D12_FORMAT_SUPPORT2_UAV_ATOMIC_SIGNED_MIN_OR_MAX	= 0x10,
+        D3D12_FORMAT_SUPPORT2_UAV_ATOMIC_UNSIGNED_MIN_OR_MAX	= 0x20,
+        D3D12_FORMAT_SUPPORT2_UAV_TYPED_LOAD	= 0x40,
+        D3D12_FORMAT_SUPPORT2_UAV_TYPED_STORE	= 0x80,
+        D3D12_FORMAT_SUPPORT2_OUTPUT_MERGER_LOGIC_OP	= 0x100,
+        D3D12_FORMAT_SUPPORT2_TILED	= 0x200,
+        D3D12_FORMAT_SUPPORT2_MULTIPLANE_OVERLAY	= 0x4000,
+        D3D12_FORMAT_SUPPORT2_SAMPLER_FEEDBACK	= 0x8000
+    } 	D3D12_FORMAT_SUPPORT2;
+
+DEFINE_ENUM_FLAG_OPERATORS( D3D12_FORMAT_SUPPORT2 );
+typedef 
+enum D3D12_MULTISAMPLE_QUALITY_LEVEL_FLAGS
+    {
+        D3D12_MULTISAMPLE_QUALITY_LEVELS_FLAG_NONE	= 0,
+        D3D12_MULTISAMPLE_QUALITY_LEVELS_FLAG_TILED_RESOURCE	= 0x1
+    } 	D3D12_MULTISAMPLE_QUALITY_LEVEL_FLAGS;
+
+DEFINE_ENUM_FLAG_OPERATORS( D3D12_MULTISAMPLE_QUALITY_LEVEL_FLAGS );
+typedef 
+enum D3D12_CROSS_NODE_SHARING_TIER
+    {
+        D3D12_CROSS_NODE_SHARING_TIER_NOT_SUPPORTED	= 0,
+        D3D12_CROSS_NODE_SHARING_TIER_1_EMULATED	= 1,
+        D3D12_CROSS_NODE_SHARING_TIER_1	= 2,
+        D3D12_CROSS_NODE_SHARING_TIER_2	= 3,
+        D3D12_CROSS_NODE_SHARING_TIER_3	= 4
+    } 	D3D12_CROSS_NODE_SHARING_TIER;
+
+typedef 
+enum D3D12_RESOURCE_HEAP_TIER
+    {
+        D3D12_RESOURCE_HEAP_TIER_1	= 1,
+        D3D12_RESOURCE_HEAP_TIER_2	= 2
+    } 	D3D12_RESOURCE_HEAP_TIER;
+
+typedef 
+enum D3D12_PROGRAMMABLE_SAMPLE_POSITIONS_TIER
+    {
+        D3D12_PROGRAMMABLE_SAMPLE_POSITIONS_TIER_NOT_SUPPORTED	= 0,
+        D3D12_PROGRAMMABLE_SAMPLE_POSITIONS_TIER_1	= 1,
+        D3D12_PROGRAMMABLE_SAMPLE_POSITIONS_TIER_2	= 2
+    } 	D3D12_PROGRAMMABLE_SAMPLE_POSITIONS_TIER;
+
+typedef 
+enum D3D12_VIEW_INSTANCING_TIER
+    {
+        D3D12_VIEW_INSTANCING_TIER_NOT_SUPPORTED	= 0,
+        D3D12_VIEW_INSTANCING_TIER_1	= 1,
+        D3D12_VIEW_INSTANCING_TIER_2	= 2,
+        D3D12_VIEW_INSTANCING_TIER_3	= 3
+    } 	D3D12_VIEW_INSTANCING_TIER;
+
+typedef struct D3D12_FEATURE_DATA_D3D12_OPTIONS
+    {
+    _Out_  BOOL DoublePrecisionFloatShaderOps;
+    _Out_  BOOL OutputMergerLogicOp;
+    _Out_  D3D12_SHADER_MIN_PRECISION_SUPPORT MinPrecisionSupport;
+    _Out_  D3D12_TILED_RESOURCES_TIER TiledResourcesTier;
+    _Out_  D3D12_RESOURCE_BINDING_TIER ResourceBindingTier;
+    _Out_  BOOL PSSpecifiedStencilRefSupported;
+    _Out_  BOOL TypedUAVLoadAdditionalFormats;
+    _Out_  BOOL ROVsSupported;
+    _Out_  D3D12_CONSERVATIVE_RASTERIZATION_TIER ConservativeRasterizationTier;
+    _Out_  UINT MaxGPUVirtualAddressBitsPerResource;
+    _Out_  BOOL StandardSwizzle64KBSupported;
+    _Out_  D3D12_CROSS_NODE_SHARING_TIER CrossNodeSharingTier;
+    _Out_  BOOL CrossAdapterRowMajorTextureSupported;
+    _Out_  BOOL VPAndRTArrayIndexFromAnyShaderFeedingRasterizerSupportedWithoutGSEmulation;
+    _Out_  D3D12_RESOURCE_HEAP_TIER ResourceHeapTier;
+    } 	D3D12_FEATURE_DATA_D3D12_OPTIONS;
+
+typedef struct D3D12_FEATURE_DATA_D3D12_OPTIONS1
+    {
+    _Out_  BOOL WaveOps;
+    _Out_  UINT WaveLaneCountMin;
+    _Out_  UINT WaveLaneCountMax;
+    _Out_  UINT TotalLaneCount;
+    _Out_  BOOL ExpandedComputeResourceStates;
+    _Out_  BOOL Int64ShaderOps;
+    } 	D3D12_FEATURE_DATA_D3D12_OPTIONS1;
+
+typedef struct D3D12_FEATURE_DATA_D3D12_OPTIONS2
+    {
+    _Out_  BOOL DepthBoundsTestSupported;
+    _Out_  D3D12_PROGRAMMABLE_SAMPLE_POSITIONS_TIER ProgrammableSamplePositionsTier;
+    } 	D3D12_FEATURE_DATA_D3D12_OPTIONS2;
+
+typedef 
+enum D3D_ROOT_SIGNATURE_VERSION
+    {
+        D3D_ROOT_SIGNATURE_VERSION_1	= 0x1,
+        D3D_ROOT_SIGNATURE_VERSION_1_0	= 0x1,
+        D3D_ROOT_SIGNATURE_VERSION_1_1	= 0x2
+    } 	D3D_ROOT_SIGNATURE_VERSION;
+
+typedef struct D3D12_FEATURE_DATA_ROOT_SIGNATURE
+    {
+    _Inout_  D3D_ROOT_SIGNATURE_VERSION HighestVersion;
+    } 	D3D12_FEATURE_DATA_ROOT_SIGNATURE;
+
+typedef struct D3D12_FEATURE_DATA_ARCHITECTURE
+    {
+    _In_  UINT NodeIndex;
+    _Out_  BOOL TileBasedRenderer;
+    _Out_  BOOL UMA;
+    _Out_  BOOL CacheCoherentUMA;
+    } 	D3D12_FEATURE_DATA_ARCHITECTURE;
+
+typedef struct D3D12_FEATURE_DATA_ARCHITECTURE1
+    {
+    _In_  UINT NodeIndex;
+    _Out_  BOOL TileBasedRenderer;
+    _Out_  BOOL UMA;
+    _Out_  BOOL CacheCoherentUMA;
+    _Out_  BOOL IsolatedMMU;
+    } 	D3D12_FEATURE_DATA_ARCHITECTURE1;
+
+typedef struct D3D12_FEATURE_DATA_FEATURE_LEVELS
+    {
+    _In_  UINT NumFeatureLevels;
+    _In_reads_(NumFeatureLevels)  const D3D_FEATURE_LEVEL *pFeatureLevelsRequested;
+    _Out_  D3D_FEATURE_LEVEL MaxSupportedFeatureLevel;
+    } 	D3D12_FEATURE_DATA_FEATURE_LEVELS;
+
+typedef 
+enum D3D_SHADER_MODEL
+    {
+        D3D_SHADER_MODEL_5_1	= 0x51,
+        D3D_SHADER_MODEL_6_0	= 0x60,
+        D3D_SHADER_MODEL_6_1	= 0x61,
+        D3D_SHADER_MODEL_6_2	= 0x62,
+        D3D_SHADER_MODEL_6_3	= 0x63,
+        D3D_SHADER_MODEL_6_4	= 0x64,
+        D3D_SHADER_MODEL_6_5	= 0x65,
+        D3D_SHADER_MODEL_6_6	= 0x66,
+        D3D_SHADER_MODEL_6_7	= 0x67,
+        D3D_SHADER_MODEL_6_8	= 0x68,
+        D3D_HIGHEST_SHADER_MODEL	= D3D_SHADER_MODEL_6_8
+    } 	D3D_SHADER_MODEL;
+
+typedef struct D3D12_FEATURE_DATA_SHADER_MODEL
+    {
+    _Inout_  D3D_SHADER_MODEL HighestShaderModel;
+    } 	D3D12_FEATURE_DATA_SHADER_MODEL;
+
+typedef struct D3D12_FEATURE_DATA_FORMAT_SUPPORT
+    {
+    _In_  DXGI_FORMAT Format;
+    _Out_  D3D12_FORMAT_SUPPORT1 Support1;
+    _Out_  D3D12_FORMAT_SUPPORT2 Support2;
+    } 	D3D12_FEATURE_DATA_FORMAT_SUPPORT;
+
+typedef struct D3D12_FEATURE_DATA_MULTISAMPLE_QUALITY_LEVELS
+    {
+    _In_  DXGI_FORMAT Format;
+    _In_  UINT SampleCount;
+    _In_  D3D12_MULTISAMPLE_QUALITY_LEVEL_FLAGS Flags;
+    _Out_  UINT NumQualityLevels;
+    } 	D3D12_FEATURE_DATA_MULTISAMPLE_QUALITY_LEVELS;
+
+typedef struct D3D12_FEATURE_DATA_FORMAT_INFO
+    {
+    DXGI_FORMAT Format;
+    UINT8 PlaneCount;
+    } 	D3D12_FEATURE_DATA_FORMAT_INFO;
+
+typedef struct D3D12_FEATURE_DATA_GPU_VIRTUAL_ADDRESS_SUPPORT
+    {
+    UINT MaxGPUVirtualAddressBitsPerResource;
+    UINT MaxGPUVirtualAddressBitsPerProcess;
+    } 	D3D12_FEATURE_DATA_GPU_VIRTUAL_ADDRESS_SUPPORT;
+
+typedef 
+enum D3D12_SHADER_CACHE_SUPPORT_FLAGS
+    {
+        D3D12_SHADER_CACHE_SUPPORT_NONE	= 0,
+        D3D12_SHADER_CACHE_SUPPORT_SINGLE_PSO	= 0x1,
+        D3D12_SHADER_CACHE_SUPPORT_LIBRARY	= 0x2,
+        D3D12_SHADER_CACHE_SUPPORT_AUTOMATIC_INPROC_CACHE	= 0x4,
+        D3D12_SHADER_CACHE_SUPPORT_AUTOMATIC_DISK_CACHE	= 0x8,
+        D3D12_SHADER_CACHE_SUPPORT_DRIVER_MANAGED_CACHE	= 0x10,
+        D3D12_SHADER_CACHE_SUPPORT_SHADER_CONTROL_CLEAR	= 0x20,
+        D3D12_SHADER_CACHE_SUPPORT_SHADER_SESSION_DELETE	= 0x40
+    } 	D3D12_SHADER_CACHE_SUPPORT_FLAGS;
+
+DEFINE_ENUM_FLAG_OPERATORS( D3D12_SHADER_CACHE_SUPPORT_FLAGS );
+typedef struct D3D12_FEATURE_DATA_SHADER_CACHE
+    {
+    _Out_  D3D12_SHADER_CACHE_SUPPORT_FLAGS SupportFlags;
+    } 	D3D12_FEATURE_DATA_SHADER_CACHE;
+
+typedef struct D3D12_FEATURE_DATA_COMMAND_QUEUE_PRIORITY
+    {
+    _In_  D3D12_COMMAND_LIST_TYPE CommandListType;
+    _In_  UINT Priority;
+    _Out_  BOOL PriorityForTypeIsSupported;
+    } 	D3D12_FEATURE_DATA_COMMAND_QUEUE_PRIORITY;
+
+typedef 
+enum D3D12_COMMAND_LIST_SUPPORT_FLAGS
+    {
+        D3D12_COMMAND_LIST_SUPPORT_FLAG_NONE	= 0,
+        D3D12_COMMAND_LIST_SUPPORT_FLAG_DIRECT	= ( 1 << D3D12_COMMAND_LIST_TYPE_DIRECT ) ,
+        D3D12_COMMAND_LIST_SUPPORT_FLAG_BUNDLE	= ( 1 << D3D12_COMMAND_LIST_TYPE_BUNDLE ) ,
+        D3D12_COMMAND_LIST_SUPPORT_FLAG_COMPUTE	= ( 1 << D3D12_COMMAND_LIST_TYPE_COMPUTE ) ,
+        D3D12_COMMAND_LIST_SUPPORT_FLAG_COPY	= ( 1 << D3D12_COMMAND_LIST_TYPE_COPY ) ,
+        D3D12_COMMAND_LIST_SUPPORT_FLAG_VIDEO_DECODE	= ( 1 << D3D12_COMMAND_LIST_TYPE_VIDEO_DECODE ) ,
+        D3D12_COMMAND_LIST_SUPPORT_FLAG_VIDEO_PROCESS	= ( 1 << D3D12_COMMAND_LIST_TYPE_VIDEO_PROCESS ) ,
+        D3D12_COMMAND_LIST_SUPPORT_FLAG_VIDEO_ENCODE	= ( 1 << D3D12_COMMAND_LIST_TYPE_VIDEO_ENCODE ) 
+    } 	D3D12_COMMAND_LIST_SUPPORT_FLAGS;
+
+DEFINE_ENUM_FLAG_OPERATORS( D3D12_COMMAND_LIST_SUPPORT_FLAGS );
+typedef struct D3D12_FEATURE_DATA_D3D12_OPTIONS3
+    {
+    _Out_  BOOL CopyQueueTimestampQueriesSupported;
+    _Out_  BOOL CastingFullyTypedFormatSupported;
+    _Out_  D3D12_COMMAND_LIST_SUPPORT_FLAGS WriteBufferImmediateSupportFlags;
+    _Out_  D3D12_VIEW_INSTANCING_TIER ViewInstancingTier;
+    _Out_  BOOL BarycentricsSupported;
+    } 	D3D12_FEATURE_DATA_D3D12_OPTIONS3;
+
+typedef struct D3D12_FEATURE_DATA_EXISTING_HEAPS
+    {
+    _Out_  BOOL Supported;
+    } 	D3D12_FEATURE_DATA_EXISTING_HEAPS;
+
+typedef 
+enum D3D12_SHARED_RESOURCE_COMPATIBILITY_TIER
+    {
+        D3D12_SHARED_RESOURCE_COMPATIBILITY_TIER_0	= 0,
+        D3D12_SHARED_RESOURCE_COMPATIBILITY_TIER_1	= ( D3D12_SHARED_RESOURCE_COMPATIBILITY_TIER_0 + 1 ) ,
+        D3D12_SHARED_RESOURCE_COMPATIBILITY_TIER_2	= ( D3D12_SHARED_RESOURCE_COMPATIBILITY_TIER_1 + 1 ) 
+    } 	D3D12_SHARED_RESOURCE_COMPATIBILITY_TIER;
+
+typedef struct D3D12_FEATURE_DATA_DISPLAYABLE
+    {
+    _Out_  BOOL DisplayableTexture;
+    _Out_  D3D12_SHARED_RESOURCE_COMPATIBILITY_TIER SharedResourceCompatibilityTier;
+    } 	D3D12_FEATURE_DATA_DISPLAYABLE;
+
+typedef struct D3D12_FEATURE_DATA_D3D12_OPTIONS4
+    {
+    _Out_  BOOL MSAA64KBAlignedTextureSupported;
+    _Out_  D3D12_SHARED_RESOURCE_COMPATIBILITY_TIER SharedResourceCompatibilityTier;
+    _Out_  BOOL Native16BitShaderOpsSupported;
+    } 	D3D12_FEATURE_DATA_D3D12_OPTIONS4;
+
+typedef 
+enum D3D12_HEAP_SERIALIZATION_TIER
+    {
+        D3D12_HEAP_SERIALIZATION_TIER_0	= 0,
+        D3D12_HEAP_SERIALIZATION_TIER_10	= 10
+    } 	D3D12_HEAP_SERIALIZATION_TIER;
+
+typedef struct D3D12_FEATURE_DATA_SERIALIZATION
+    {
+    _In_  UINT NodeIndex;
+    _Out_  D3D12_HEAP_SERIALIZATION_TIER HeapSerializationTier;
+    } 	D3D12_FEATURE_DATA_SERIALIZATION;
+
+typedef struct D3D12_FEATURE_DATA_CROSS_NODE
+    {
+    D3D12_CROSS_NODE_SHARING_TIER SharingTier;
+    BOOL AtomicShaderInstructions;
+    } 	D3D12_FEATURE_DATA_CROSS_NODE;
+
+typedef 
+enum D3D12_RENDER_PASS_TIER
+    {
+        D3D12_RENDER_PASS_TIER_0	= 0,
+        D3D12_RENDER_PASS_TIER_1	= 1,
+        D3D12_RENDER_PASS_TIER_2	= 2
+    } 	D3D12_RENDER_PASS_TIER;
+
+typedef 
+enum D3D12_RAYTRACING_TIER
+    {
+        D3D12_RAYTRACING_TIER_NOT_SUPPORTED	= 0,
+        D3D12_RAYTRACING_TIER_1_0	= 10,
+        D3D12_RAYTRACING_TIER_1_1	= 11
+    } 	D3D12_RAYTRACING_TIER;
+
+typedef struct D3D12_FEATURE_DATA_D3D12_OPTIONS5
+    {
+    _Out_  BOOL SRVOnlyTiledResourceTier3;
+    _Out_  D3D12_RENDER_PASS_TIER RenderPassesTier;
+    _Out_  D3D12_RAYTRACING_TIER RaytracingTier;
+    } 	D3D12_FEATURE_DATA_D3D12_OPTIONS5;
+
+typedef 
+enum D3D12_VARIABLE_SHADING_RATE_TIER
+    {
+        D3D12_VARIABLE_SHADING_RATE_TIER_NOT_SUPPORTED	= 0,
+        D3D12_VARIABLE_SHADING_RATE_TIER_1	= 1,
+        D3D12_VARIABLE_SHADING_RATE_TIER_2	= 2
+    } 	D3D12_VARIABLE_SHADING_RATE_TIER;
+
+typedef struct D3D12_FEATURE_DATA_D3D12_OPTIONS6
+    {
+    _Out_  BOOL AdditionalShadingRatesSupported;
+    _Out_  BOOL PerPrimitiveShadingRateSupportedWithViewportIndexing;
+    _Out_  D3D12_VARIABLE_SHADING_RATE_TIER VariableShadingRateTier;
+    _Out_  UINT ShadingRateImageTileSize;
+    _Out_  BOOL BackgroundProcessingSupported;
+    } 	D3D12_FEATURE_DATA_D3D12_OPTIONS6;
+
+typedef 
+enum D3D12_MESH_SHADER_TIER
+    {
+        D3D12_MESH_SHADER_TIER_NOT_SUPPORTED	= 0,
+        D3D12_MESH_SHADER_TIER_1	= 10
+    } 	D3D12_MESH_SHADER_TIER;
+
+typedef 
+enum D3D12_SAMPLER_FEEDBACK_TIER
+    {
+        D3D12_SAMPLER_FEEDBACK_TIER_NOT_SUPPORTED	= 0,
+        D3D12_SAMPLER_FEEDBACK_TIER_0_9	= 90,
+        D3D12_SAMPLER_FEEDBACK_TIER_1_0	= 100
+    } 	D3D12_SAMPLER_FEEDBACK_TIER;
+
+typedef struct D3D12_FEATURE_DATA_D3D12_OPTIONS7
+    {
+    _Out_  D3D12_MESH_SHADER_TIER MeshShaderTier;
+    _Out_  D3D12_SAMPLER_FEEDBACK_TIER SamplerFeedbackTier;
+    } 	D3D12_FEATURE_DATA_D3D12_OPTIONS7;
+
+typedef struct D3D12_FEATURE_DATA_QUERY_META_COMMAND
+    {
+    _In_  GUID CommandId;
+    _In_  UINT NodeMask;
+    _Field_size_bytes_full_opt_( QueryInputDataSizeInBytes )  const void *pQueryInputData;
+    _In_  SIZE_T QueryInputDataSizeInBytes;
+    _Field_size_bytes_full_( QueryOutputDataSizeInBytes )  void *pQueryOutputData;
+    _In_  SIZE_T QueryOutputDataSizeInBytes;
+    } 	D3D12_FEATURE_DATA_QUERY_META_COMMAND;
+
+typedef struct D3D12_FEATURE_DATA_D3D12_OPTIONS8
+    {
+    _Out_  BOOL UnalignedBlockTexturesSupported;
+    } 	D3D12_FEATURE_DATA_D3D12_OPTIONS8;
+
+typedef 
+enum D3D12_WAVE_MMA_TIER
+    {
+        D3D12_WAVE_MMA_TIER_NOT_SUPPORTED	= 0,
+        D3D12_WAVE_MMA_TIER_1_0	= 10
+    } 	D3D12_WAVE_MMA_TIER;
+
+typedef struct D3D12_FEATURE_DATA_D3D12_OPTIONS9
+    {
+    _Out_  BOOL MeshShaderPipelineStatsSupported;
+    _Out_  BOOL MeshShaderSupportsFullRangeRenderTargetArrayIndex;
+    _Out_  BOOL AtomicInt64OnTypedResourceSupported;
+    _Out_  BOOL AtomicInt64OnGroupSharedSupported;
+    _Out_  BOOL DerivativesInMeshAndAmplificationShadersSupported;
+    _Out_  D3D12_WAVE_MMA_TIER WaveMMATier;
+    } 	D3D12_FEATURE_DATA_D3D12_OPTIONS9;
+
+typedef struct D3D12_FEATURE_DATA_D3D12_OPTIONS10
+    {
+    _Out_  BOOL VariableRateShadingSumCombinerSupported;
+    _Out_  BOOL MeshShaderPerPrimitiveShadingRateSupported;
+    } 	D3D12_FEATURE_DATA_D3D12_OPTIONS10;
+
+typedef struct D3D12_FEATURE_DATA_D3D12_OPTIONS11
+    {
+    _Out_  BOOL AtomicInt64OnDescriptorHeapResourceSupported;
+    } 	D3D12_FEATURE_DATA_D3D12_OPTIONS11;
+
+typedef 
+enum D3D12_TRI_STATE
+    {
+        D3D12_TRI_STATE_UNKNOWN	= -1,
+        D3D12_TRI_STATE_FALSE	= 0,
+        D3D12_TRI_STATE_TRUE	= 1
+    } 	D3D12_TRI_STATE;
+
+typedef struct D3D12_FEATURE_DATA_D3D12_OPTIONS12
+    {
+    _Out_  D3D12_TRI_STATE MSPrimitivesPipelineStatisticIncludesCulledPrimitives;
+    _Out_  BOOL EnhancedBarriersSupported;
+    _Out_  BOOL RelaxedFormatCastingSupported;
+    } 	D3D12_FEATURE_DATA_D3D12_OPTIONS12;
+
+typedef struct D3D12_FEATURE_DATA_D3D12_OPTIONS13
+    {
+    _Out_  BOOL UnrestrictedBufferTextureCopyPitchSupported;
+    _Out_  BOOL UnrestrictedVertexElementAlignmentSupported;
+    _Out_  BOOL InvertedViewportHeightFlipsYSupported;
+    _Out_  BOOL InvertedViewportDepthFlipsZSupported;
+    _Out_  BOOL TextureCopyBetweenDimensionsSupported;
+    _Out_  BOOL AlphaBlendFactorSupported;
+    } 	D3D12_FEATURE_DATA_D3D12_OPTIONS13;
+
+typedef struct D3D12_FEATURE_DATA_D3D12_OPTIONS14
+    {
+    _Out_  BOOL AdvancedTextureOpsSupported;
+    _Out_  BOOL WriteableMSAATexturesSupported;
+    _Out_  BOOL IndependentFrontAndBackStencilRefMaskSupported;
+    } 	D3D12_FEATURE_DATA_D3D12_OPTIONS14;
+
+typedef struct D3D12_FEATURE_DATA_D3D12_OPTIONS15
+    {
+    _Out_  BOOL TriangleFanSupported;
+    _Out_  BOOL DynamicIndexBufferStripCutSupported;
+    } 	D3D12_FEATURE_DATA_D3D12_OPTIONS15;
+
+typedef struct D3D12_RESOURCE_ALLOCATION_INFO
+    {
+    UINT64 SizeInBytes;
+    UINT64 Alignment;
+    } 	D3D12_RESOURCE_ALLOCATION_INFO;
+
+typedef struct D3D12_RESOURCE_ALLOCATION_INFO1
+    {
+    UINT64 Offset;
+    UINT64 Alignment;
+    UINT64 SizeInBytes;
+    } 	D3D12_RESOURCE_ALLOCATION_INFO1;
+
+typedef 
+enum D3D12_HEAP_TYPE
+    {
+        D3D12_HEAP_TYPE_DEFAULT	= 1,
+        D3D12_HEAP_TYPE_UPLOAD	= 2,
+        D3D12_HEAP_TYPE_READBACK	= 3,
+        D3D12_HEAP_TYPE_CUSTOM	= 4
+    } 	D3D12_HEAP_TYPE;
+
+typedef 
+enum D3D12_CPU_PAGE_PROPERTY
+    {
+        D3D12_CPU_PAGE_PROPERTY_UNKNOWN	= 0,
+        D3D12_CPU_PAGE_PROPERTY_NOT_AVAILABLE	= 1,
+        D3D12_CPU_PAGE_PROPERTY_WRITE_COMBINE	= 2,
+        D3D12_CPU_PAGE_PROPERTY_WRITE_BACK	= 3
+    } 	D3D12_CPU_PAGE_PROPERTY;
+
+typedef 
+enum D3D12_MEMORY_POOL
+    {
+        D3D12_MEMORY_POOL_UNKNOWN	= 0,
+        D3D12_MEMORY_POOL_L0	= 1,
+        D3D12_MEMORY_POOL_L1	= 2
+    } 	D3D12_MEMORY_POOL;
+
+typedef struct D3D12_HEAP_PROPERTIES
+    {
+    D3D12_HEAP_TYPE Type;
+    D3D12_CPU_PAGE_PROPERTY CPUPageProperty;
+    D3D12_MEMORY_POOL MemoryPoolPreference;
+    UINT CreationNodeMask;
+    UINT VisibleNodeMask;
+    } 	D3D12_HEAP_PROPERTIES;
+
+typedef 
+enum D3D12_HEAP_FLAGS
+    {
+        D3D12_HEAP_FLAG_NONE	= 0,
+        D3D12_HEAP_FLAG_SHARED	= 0x1,
+        D3D12_HEAP_FLAG_DENY_BUFFERS	= 0x4,
+        D3D12_HEAP_FLAG_ALLOW_DISPLAY	= 0x8,
+        D3D12_HEAP_FLAG_SHARED_CROSS_ADAPTER	= 0x20,
+        D3D12_HEAP_FLAG_DENY_RT_DS_TEXTURES	= 0x40,
+        D3D12_HEAP_FLAG_DENY_NON_RT_DS_TEXTURES	= 0x80,
+        D3D12_HEAP_FLAG_HARDWARE_PROTECTED	= 0x100,
+        D3D12_HEAP_FLAG_ALLOW_WRITE_WATCH	= 0x200,
+        D3D12_HEAP_FLAG_ALLOW_SHADER_ATOMICS	= 0x400,
+        D3D12_HEAP_FLAG_CREATE_NOT_RESIDENT	= 0x800,
+        D3D12_HEAP_FLAG_CREATE_NOT_ZEROED	= 0x1000,
+        D3D12_HEAP_FLAG_ALLOW_ALL_BUFFERS_AND_TEXTURES	= 0,
+        D3D12_HEAP_FLAG_ALLOW_ONLY_BUFFERS	= 0xc0,
+        D3D12_HEAP_FLAG_ALLOW_ONLY_NON_RT_DS_TEXTURES	= 0x44,
+        D3D12_HEAP_FLAG_ALLOW_ONLY_RT_DS_TEXTURES	= 0x84
+    } 	D3D12_HEAP_FLAGS;
+
+DEFINE_ENUM_FLAG_OPERATORS( D3D12_HEAP_FLAGS );
+typedef struct D3D12_HEAP_DESC
+    {
+    UINT64 SizeInBytes;
+    D3D12_HEAP_PROPERTIES Properties;
+    UINT64 Alignment;
+    D3D12_HEAP_FLAGS Flags;
+    } 	D3D12_HEAP_DESC;
+
+typedef 
+enum D3D12_RESOURCE_DIMENSION
+    {
+        D3D12_RESOURCE_DIMENSION_UNKNOWN	= 0,
+        D3D12_RESOURCE_DIMENSION_BUFFER	= 1,
+        D3D12_RESOURCE_DIMENSION_TEXTURE1D	= 2,
+        D3D12_RESOURCE_DIMENSION_TEXTURE2D	= 3,
+        D3D12_RESOURCE_DIMENSION_TEXTURE3D	= 4
+    } 	D3D12_RESOURCE_DIMENSION;
+
+typedef 
+enum D3D12_TEXTURE_LAYOUT
+    {
+        D3D12_TEXTURE_LAYOUT_UNKNOWN	= 0,
+        D3D12_TEXTURE_LAYOUT_ROW_MAJOR	= 1,
+        D3D12_TEXTURE_LAYOUT_64KB_UNDEFINED_SWIZZLE	= 2,
+        D3D12_TEXTURE_LAYOUT_64KB_STANDARD_SWIZZLE	= 3
+    } 	D3D12_TEXTURE_LAYOUT;
+
+typedef 
+enum D3D12_RESOURCE_FLAGS
+    {
+        D3D12_RESOURCE_FLAG_NONE	= 0,
+        D3D12_RESOURCE_FLAG_ALLOW_RENDER_TARGET	= 0x1,
+        D3D12_RESOURCE_FLAG_ALLOW_DEPTH_STENCIL	= 0x2,
+        D3D12_RESOURCE_FLAG_ALLOW_UNORDERED_ACCESS	= 0x4,
+        D3D12_RESOURCE_FLAG_DENY_SHADER_RESOURCE	= 0x8,
+        D3D12_RESOURCE_FLAG_ALLOW_CROSS_ADAPTER	= 0x10,
+        D3D12_RESOURCE_FLAG_ALLOW_SIMULTANEOUS_ACCESS	= 0x20,
+        D3D12_RESOURCE_FLAG_VIDEO_DECODE_REFERENCE_ONLY	= 0x40,
+        D3D12_RESOURCE_FLAG_VIDEO_ENCODE_REFERENCE_ONLY	= 0x80,
+        D3D12_RESOURCE_FLAG_RAYTRACING_ACCELERATION_STRUCTURE	= 0x100
+    } 	D3D12_RESOURCE_FLAGS;
+
+DEFINE_ENUM_FLAG_OPERATORS( D3D12_RESOURCE_FLAGS );
+typedef struct D3D12_MIP_REGION
+    {
+    UINT Width;
+    UINT Height;
+    UINT Depth;
+    } 	D3D12_MIP_REGION;
+
+typedef struct D3D12_RESOURCE_DESC
+    {
+    D3D12_RESOURCE_DIMENSION Dimension;
+    UINT64 Alignment;
+    UINT64 Width;
+    UINT Height;
+    UINT16 DepthOrArraySize;
+    UINT16 MipLevels;
+    DXGI_FORMAT Format;
+    DXGI_SAMPLE_DESC SampleDesc;
+    D3D12_TEXTURE_LAYOUT Layout;
+    D3D12_RESOURCE_FLAGS Flags;
+    } 	D3D12_RESOURCE_DESC;
+
+typedef struct D3D12_RESOURCE_DESC1
+    {
+    D3D12_RESOURCE_DIMENSION Dimension;
+    UINT64 Alignment;
+    UINT64 Width;
+    UINT Height;
+    UINT16 DepthOrArraySize;
+    UINT16 MipLevels;
+    DXGI_FORMAT Format;
+    DXGI_SAMPLE_DESC SampleDesc;
+    D3D12_TEXTURE_LAYOUT Layout;
+    D3D12_RESOURCE_FLAGS Flags;
+    D3D12_MIP_REGION SamplerFeedbackMipRegion;
+    } 	D3D12_RESOURCE_DESC1;
+
+typedef struct D3D12_DEPTH_STENCIL_VALUE
+    {
+    FLOAT Depth;
+    UINT8 Stencil;
+    } 	D3D12_DEPTH_STENCIL_VALUE;
+
+typedef struct D3D12_CLEAR_VALUE
+    {
+    DXGI_FORMAT Format;
+    union 
+        {
+        FLOAT Color[ 4 ];
+        D3D12_DEPTH_STENCIL_VALUE DepthStencil;
+        } 	;
+    } 	D3D12_CLEAR_VALUE;
+
+typedef struct D3D12_RANGE
+    {
+    SIZE_T Begin;
+    SIZE_T End;
+    } 	D3D12_RANGE;
+
+typedef struct D3D12_RANGE_UINT64
+    {
+    UINT64 Begin;
+    UINT64 End;
+    } 	D3D12_RANGE_UINT64;
+
+typedef struct D3D12_SUBRESOURCE_RANGE_UINT64
+    {
+    UINT Subresource;
+    D3D12_RANGE_UINT64 Range;
+    } 	D3D12_SUBRESOURCE_RANGE_UINT64;
+
+typedef struct D3D12_SUBRESOURCE_INFO
+    {
+    UINT64 Offset;
+    UINT RowPitch;
+    UINT DepthPitch;
+    } 	D3D12_SUBRESOURCE_INFO;
+
+typedef struct D3D12_TILED_RESOURCE_COORDINATE
+    {
+    UINT X;
+    UINT Y;
+    UINT Z;
+    UINT Subresource;
+    } 	D3D12_TILED_RESOURCE_COORDINATE;
+
+typedef struct D3D12_TILE_REGION_SIZE
+    {
+    UINT NumTiles;
+    BOOL UseBox;
+    UINT Width;
+    UINT16 Height;
+    UINT16 Depth;
+    } 	D3D12_TILE_REGION_SIZE;
+
+typedef 
+enum D3D12_TILE_RANGE_FLAGS
+    {
+        D3D12_TILE_RANGE_FLAG_NONE	= 0,
+        D3D12_TILE_RANGE_FLAG_NULL	= 1,
+        D3D12_TILE_RANGE_FLAG_SKIP	= 2,
+        D3D12_TILE_RANGE_FLAG_REUSE_SINGLE_TILE	= 4
+    } 	D3D12_TILE_RANGE_FLAGS;
+
+typedef struct D3D12_SUBRESOURCE_TILING
+    {
+    UINT WidthInTiles;
+    UINT16 HeightInTiles;
+    UINT16 DepthInTiles;
+    UINT StartTileIndexInOverallResource;
+    } 	D3D12_SUBRESOURCE_TILING;
+
+typedef struct D3D12_TILE_SHAPE
+    {
+    UINT WidthInTexels;
+    UINT HeightInTexels;
+    UINT DepthInTexels;
+    } 	D3D12_TILE_SHAPE;
+
+typedef struct D3D12_PACKED_MIP_INFO
+    {
+    UINT8 NumStandardMips;
+    UINT8 NumPackedMips;
+    UINT NumTilesForPackedMips;
+    UINT StartTileIndexInOverallResource;
+    } 	D3D12_PACKED_MIP_INFO;
+
+typedef 
+enum D3D12_TILE_MAPPING_FLAGS
+    {
+        D3D12_TILE_MAPPING_FLAG_NONE	= 0,
+        D3D12_TILE_MAPPING_FLAG_NO_HAZARD	= 0x1
+    } 	D3D12_TILE_MAPPING_FLAGS;
+
+DEFINE_ENUM_FLAG_OPERATORS( D3D12_TILE_MAPPING_FLAGS );
+typedef 
+enum D3D12_TILE_COPY_FLAGS
+    {
+        D3D12_TILE_COPY_FLAG_NONE	= 0,
+        D3D12_TILE_COPY_FLAG_NO_HAZARD	= 0x1,
+        D3D12_TILE_COPY_FLAG_LINEAR_BUFFER_TO_SWIZZLED_TILED_RESOURCE	= 0x2,
+        D3D12_TILE_COPY_FLAG_SWIZZLED_TILED_RESOURCE_TO_LINEAR_BUFFER	= 0x4
+    } 	D3D12_TILE_COPY_FLAGS;
+
+DEFINE_ENUM_FLAG_OPERATORS( D3D12_TILE_COPY_FLAGS );
+typedef 
+enum D3D12_RESOURCE_STATES
+    {
+        D3D12_RESOURCE_STATE_COMMON	= 0,
+        D3D12_RESOURCE_STATE_VERTEX_AND_CONSTANT_BUFFER	= 0x1,
+        D3D12_RESOURCE_STATE_INDEX_BUFFER	= 0x2,
+        D3D12_RESOURCE_STATE_RENDER_TARGET	= 0x4,
+        D3D12_RESOURCE_STATE_UNORDERED_ACCESS	= 0x8,
+        D3D12_RESOURCE_STATE_DEPTH_WRITE	= 0x10,
+        D3D12_RESOURCE_STATE_DEPTH_READ	= 0x20,
+        D3D12_RESOURCE_STATE_NON_PIXEL_SHADER_RESOURCE	= 0x40,
+        D3D12_RESOURCE_STATE_PIXEL_SHADER_RESOURCE	= 0x80,
+        D3D12_RESOURCE_STATE_STREAM_OUT	= 0x100,
+        D3D12_RESOURCE_STATE_INDIRECT_ARGUMENT	= 0x200,
+        D3D12_RESOURCE_STATE_COPY_DEST	= 0x400,
+        D3D12_RESOURCE_STATE_COPY_SOURCE	= 0x800,
+        D3D12_RESOURCE_STATE_RESOLVE_DEST	= 0x1000,
+        D3D12_RESOURCE_STATE_RESOLVE_SOURCE	= 0x2000,
+        D3D12_RESOURCE_STATE_RAYTRACING_ACCELERATION_STRUCTURE	= 0x400000,
+        D3D12_RESOURCE_STATE_SHADING_RATE_SOURCE	= 0x1000000,
+        D3D12_RESOURCE_STATE_GENERIC_READ	= ( ( ( ( ( 0x1 | 0x2 )  | 0x40 )  | 0x80 )  | 0x200 )  | 0x800 ) ,
+        D3D12_RESOURCE_STATE_ALL_SHADER_RESOURCE	= ( 0x40 | 0x80 ) ,
+        D3D12_RESOURCE_STATE_PRESENT	= 0,
+        D3D12_RESOURCE_STATE_PREDICATION	= 0x200,
+        D3D12_RESOURCE_STATE_VIDEO_DECODE_READ	= 0x10000,
+        D3D12_RESOURCE_STATE_VIDEO_DECODE_WRITE	= 0x20000,
+        D3D12_RESOURCE_STATE_VIDEO_PROCESS_READ	= 0x40000,
+        D3D12_RESOURCE_STATE_VIDEO_PROCESS_WRITE	= 0x80000,
+        D3D12_RESOURCE_STATE_VIDEO_ENCODE_READ	= 0x200000,
+        D3D12_RESOURCE_STATE_VIDEO_ENCODE_WRITE	= 0x800000
+    } 	D3D12_RESOURCE_STATES;
+
+DEFINE_ENUM_FLAG_OPERATORS( D3D12_RESOURCE_STATES );
+typedef 
+enum D3D12_RESOURCE_BARRIER_TYPE
+    {
+        D3D12_RESOURCE_BARRIER_TYPE_TRANSITION	= 0,
+        D3D12_RESOURCE_BARRIER_TYPE_ALIASING	= ( D3D12_RESOURCE_BARRIER_TYPE_TRANSITION + 1 ) ,
+        D3D12_RESOURCE_BARRIER_TYPE_UAV	= ( D3D12_RESOURCE_BARRIER_TYPE_ALIASING + 1 ) 
+    } 	D3D12_RESOURCE_BARRIER_TYPE;
+
+
+typedef struct D3D12_RESOURCE_TRANSITION_BARRIER
+    {
+    ID3D12Resource *pResource;
+    UINT Subresource;
+    D3D12_RESOURCE_STATES StateBefore;
+    D3D12_RESOURCE_STATES StateAfter;
+    } 	D3D12_RESOURCE_TRANSITION_BARRIER;
+
+typedef struct D3D12_RESOURCE_ALIASING_BARRIER
+    {
+    ID3D12Resource *pResourceBefore;
+    ID3D12Resource *pResourceAfter;
+    } 	D3D12_RESOURCE_ALIASING_BARRIER;
+
+typedef struct D3D12_RESOURCE_UAV_BARRIER
+    {
+    ID3D12Resource *pResource;
+    } 	D3D12_RESOURCE_UAV_BARRIER;
+
+typedef 
+enum D3D12_RESOURCE_BARRIER_FLAGS
+    {
+        D3D12_RESOURCE_BARRIER_FLAG_NONE	= 0,
+        D3D12_RESOURCE_BARRIER_FLAG_BEGIN_ONLY	= 0x1,
+        D3D12_RESOURCE_BARRIER_FLAG_END_ONLY	= 0x2
+    } 	D3D12_RESOURCE_BARRIER_FLAGS;
+
+DEFINE_ENUM_FLAG_OPERATORS( D3D12_RESOURCE_BARRIER_FLAGS );
+typedef struct D3D12_RESOURCE_BARRIER
+    {
+    D3D12_RESOURCE_BARRIER_TYPE Type;
+    D3D12_RESOURCE_BARRIER_FLAGS Flags;
+    union 
+        {
+        D3D12_RESOURCE_TRANSITION_BARRIER Transition;
+        D3D12_RESOURCE_ALIASING_BARRIER Aliasing;
+        D3D12_RESOURCE_UAV_BARRIER UAV;
+        } 	;
+    } 	D3D12_RESOURCE_BARRIER;
+
+typedef struct D3D12_SUBRESOURCE_FOOTPRINT
+    {
+    DXGI_FORMAT Format;
+    UINT Width;
+    UINT Height;
+    UINT Depth;
+    UINT RowPitch;
+    } 	D3D12_SUBRESOURCE_FOOTPRINT;
+
+typedef struct D3D12_PLACED_SUBRESOURCE_FOOTPRINT
+    {
+    UINT64 Offset;
+    D3D12_SUBRESOURCE_FOOTPRINT Footprint;
+    } 	D3D12_PLACED_SUBRESOURCE_FOOTPRINT;
+
+typedef 
+enum D3D12_TEXTURE_COPY_TYPE
+    {
+        D3D12_TEXTURE_COPY_TYPE_SUBRESOURCE_INDEX	= 0,
+        D3D12_TEXTURE_COPY_TYPE_PLACED_FOOTPRINT	= 1
+    } 	D3D12_TEXTURE_COPY_TYPE;
+
+typedef struct D3D12_TEXTURE_COPY_LOCATION
+    {
+    ID3D12Resource *pResource;
+    D3D12_TEXTURE_COPY_TYPE Type;
+    union 
+        {
+        D3D12_PLACED_SUBRESOURCE_FOOTPRINT PlacedFootprint;
+        UINT SubresourceIndex;
+        } 	;
+    } 	D3D12_TEXTURE_COPY_LOCATION;
+
+typedef 
+enum D3D12_RESOLVE_MODE
+    {
+        D3D12_RESOLVE_MODE_DECOMPRESS	= 0,
+        D3D12_RESOLVE_MODE_MIN	= 1,
+        D3D12_RESOLVE_MODE_MAX	= 2,
+        D3D12_RESOLVE_MODE_AVERAGE	= 3,
+        D3D12_RESOLVE_MODE_ENCODE_SAMPLER_FEEDBACK	= 4,
+        D3D12_RESOLVE_MODE_DECODE_SAMPLER_FEEDBACK	= 5
+    } 	D3D12_RESOLVE_MODE;
+
+typedef struct D3D12_SAMPLE_POSITION
+    {
+    INT8 X;
+    INT8 Y;
+    } 	D3D12_SAMPLE_POSITION;
+
+typedef struct D3D12_VIEW_INSTANCE_LOCATION
+    {
+    UINT ViewportArrayIndex;
+    UINT RenderTargetArrayIndex;
+    } 	D3D12_VIEW_INSTANCE_LOCATION;
+
+typedef 
+enum D3D12_VIEW_INSTANCING_FLAGS
+    {
+        D3D12_VIEW_INSTANCING_FLAG_NONE	= 0,
+        D3D12_VIEW_INSTANCING_FLAG_ENABLE_VIEW_INSTANCE_MASKING	= 0x1
+    } 	D3D12_VIEW_INSTANCING_FLAGS;
+
+DEFINE_ENUM_FLAG_OPERATORS( D3D12_VIEW_INSTANCING_FLAGS );
+typedef struct D3D12_VIEW_INSTANCING_DESC
+    {
+    UINT ViewInstanceCount;
+    _Field_size_full_(ViewInstanceCount)  const D3D12_VIEW_INSTANCE_LOCATION *pViewInstanceLocations;
+    D3D12_VIEW_INSTANCING_FLAGS Flags;
+    } 	D3D12_VIEW_INSTANCING_DESC;
+
+typedef 
+enum D3D12_SHADER_COMPONENT_MAPPING
+    {
+        D3D12_SHADER_COMPONENT_MAPPING_FROM_MEMORY_COMPONENT_0	= 0,
+        D3D12_SHADER_COMPONENT_MAPPING_FROM_MEMORY_COMPONENT_1	= 1,
+        D3D12_SHADER_COMPONENT_MAPPING_FROM_MEMORY_COMPONENT_2	= 2,
+        D3D12_SHADER_COMPONENT_MAPPING_FROM_MEMORY_COMPONENT_3	= 3,
+        D3D12_SHADER_COMPONENT_MAPPING_FORCE_VALUE_0	= 4,
+        D3D12_SHADER_COMPONENT_MAPPING_FORCE_VALUE_1	= 5
+    } 	D3D12_SHADER_COMPONENT_MAPPING;
+
+#define D3D12_SHADER_COMPONENT_MAPPING_MASK 0x7 
+#define D3D12_SHADER_COMPONENT_MAPPING_SHIFT 3 
+#define D3D12_SHADER_COMPONENT_MAPPING_ALWAYS_SET_BIT_AVOIDING_ZEROMEM_MISTAKES (1<<(D3D12_SHADER_COMPONENT_MAPPING_SHIFT*4)) 
+#define D3D12_ENCODE_SHADER_4_COMPONENT_MAPPING(Src0,Src1,Src2,Src3) ((((Src0)&D3D12_SHADER_COMPONENT_MAPPING_MASK)| \
+                                                                (((Src1)&D3D12_SHADER_COMPONENT_MAPPING_MASK)<<D3D12_SHADER_COMPONENT_MAPPING_SHIFT)| \
+                                                                (((Src2)&D3D12_SHADER_COMPONENT_MAPPING_MASK)<<(D3D12_SHADER_COMPONENT_MAPPING_SHIFT*2))| \
+                                                                (((Src3)&D3D12_SHADER_COMPONENT_MAPPING_MASK)<<(D3D12_SHADER_COMPONENT_MAPPING_SHIFT*3))| \
+                                                                D3D12_SHADER_COMPONENT_MAPPING_ALWAYS_SET_BIT_AVOIDING_ZEROMEM_MISTAKES))
+#define D3D12_DECODE_SHADER_4_COMPONENT_MAPPING(ComponentToExtract,Mapping) ((D3D12_SHADER_COMPONENT_MAPPING)(Mapping >> (D3D12_SHADER_COMPONENT_MAPPING_SHIFT*ComponentToExtract) & D3D12_SHADER_COMPONENT_MAPPING_MASK))
+#define D3D12_DEFAULT_SHADER_4_COMPONENT_MAPPING D3D12_ENCODE_SHADER_4_COMPONENT_MAPPING(0,1,2,3) 
+typedef 
+enum D3D12_BUFFER_SRV_FLAGS
+    {
+        D3D12_BUFFER_SRV_FLAG_NONE	= 0,
+        D3D12_BUFFER_SRV_FLAG_RAW	= 0x1
+    } 	D3D12_BUFFER_SRV_FLAGS;
+
+DEFINE_ENUM_FLAG_OPERATORS( D3D12_BUFFER_SRV_FLAGS );
+typedef struct D3D12_BUFFER_SRV
+    {
+    UINT64 FirstElement;
+    UINT NumElements;
+    UINT StructureByteStride;
+    D3D12_BUFFER_SRV_FLAGS Flags;
+    } 	D3D12_BUFFER_SRV;
+
+typedef struct D3D12_TEX1D_SRV
+    {
+    UINT MostDetailedMip;
+    UINT MipLevels;
+    FLOAT ResourceMinLODClamp;
+    } 	D3D12_TEX1D_SRV;
+
+typedef struct D3D12_TEX1D_ARRAY_SRV
+    {
+    UINT MostDetailedMip;
+    UINT MipLevels;
+    UINT FirstArraySlice;
+    UINT ArraySize;
+    FLOAT ResourceMinLODClamp;
+    } 	D3D12_TEX1D_ARRAY_SRV;
+
+typedef struct D3D12_TEX2D_SRV
+    {
+    UINT MostDetailedMip;
+    UINT MipLevels;
+    UINT PlaneSlice;
+    FLOAT ResourceMinLODClamp;
+    } 	D3D12_TEX2D_SRV;
+
+typedef struct D3D12_TEX2D_ARRAY_SRV
+    {
+    UINT MostDetailedMip;
+    UINT MipLevels;
+    UINT FirstArraySlice;
+    UINT ArraySize;
+    UINT PlaneSlice;
+    FLOAT ResourceMinLODClamp;
+    } 	D3D12_TEX2D_ARRAY_SRV;
+
+typedef struct D3D12_TEX3D_SRV
+    {
+    UINT MostDetailedMip;
+    UINT MipLevels;
+    FLOAT ResourceMinLODClamp;
+    } 	D3D12_TEX3D_SRV;
+
+typedef struct D3D12_TEXCUBE_SRV
+    {
+    UINT MostDetailedMip;
+    UINT MipLevels;
+    FLOAT ResourceMinLODClamp;
+    } 	D3D12_TEXCUBE_SRV;
+
+typedef struct D3D12_TEXCUBE_ARRAY_SRV
+    {
+    UINT MostDetailedMip;
+    UINT MipLevels;
+    UINT First2DArrayFace;
+    UINT NumCubes;
+    FLOAT ResourceMinLODClamp;
+    } 	D3D12_TEXCUBE_ARRAY_SRV;
+
+typedef struct D3D12_TEX2DMS_SRV
+    {
+    UINT UnusedField_NothingToDefine;
+    } 	D3D12_TEX2DMS_SRV;
+
+typedef struct D3D12_TEX2DMS_ARRAY_SRV
+    {
+    UINT FirstArraySlice;
+    UINT ArraySize;
+    } 	D3D12_TEX2DMS_ARRAY_SRV;
+
+typedef struct D3D12_RAYTRACING_ACCELERATION_STRUCTURE_SRV
+    {
+    D3D12_GPU_VIRTUAL_ADDRESS Location;
+    } 	D3D12_RAYTRACING_ACCELERATION_STRUCTURE_SRV;
+
+typedef 
+enum D3D12_SRV_DIMENSION
+    {
+        D3D12_SRV_DIMENSION_UNKNOWN	= 0,
+        D3D12_SRV_DIMENSION_BUFFER	= 1,
+        D3D12_SRV_DIMENSION_TEXTURE1D	= 2,
+        D3D12_SRV_DIMENSION_TEXTURE1DARRAY	= 3,
+        D3D12_SRV_DIMENSION_TEXTURE2D	= 4,
+        D3D12_SRV_DIMENSION_TEXTURE2DARRAY	= 5,
+        D3D12_SRV_DIMENSION_TEXTURE2DMS	= 6,
+        D3D12_SRV_DIMENSION_TEXTURE2DMSARRAY	= 7,
+        D3D12_SRV_DIMENSION_TEXTURE3D	= 8,
+        D3D12_SRV_DIMENSION_TEXTURECUBE	= 9,
+        D3D12_SRV_DIMENSION_TEXTURECUBEARRAY	= 10,
+        D3D12_SRV_DIMENSION_RAYTRACING_ACCELERATION_STRUCTURE	= 11
+    } 	D3D12_SRV_DIMENSION;
+
+typedef struct D3D12_SHADER_RESOURCE_VIEW_DESC
+    {
+    DXGI_FORMAT Format;
+    D3D12_SRV_DIMENSION ViewDimension;
+    UINT Shader4ComponentMapping;
+    union 
+        {
+        D3D12_BUFFER_SRV Buffer;
+        D3D12_TEX1D_SRV Texture1D;
+        D3D12_TEX1D_ARRAY_SRV Texture1DArray;
+        D3D12_TEX2D_SRV Texture2D;
+        D3D12_TEX2D_ARRAY_SRV Texture2DArray;
+        D3D12_TEX2DMS_SRV Texture2DMS;
+        D3D12_TEX2DMS_ARRAY_SRV Texture2DMSArray;
+        D3D12_TEX3D_SRV Texture3D;
+        D3D12_TEXCUBE_SRV TextureCube;
+        D3D12_TEXCUBE_ARRAY_SRV TextureCubeArray;
+        D3D12_RAYTRACING_ACCELERATION_STRUCTURE_SRV RaytracingAccelerationStructure;
+        } 	;
+    } 	D3D12_SHADER_RESOURCE_VIEW_DESC;
+
+typedef struct D3D12_CONSTANT_BUFFER_VIEW_DESC
+    {
+    D3D12_GPU_VIRTUAL_ADDRESS BufferLocation;
+    UINT SizeInBytes;
+    } 	D3D12_CONSTANT_BUFFER_VIEW_DESC;
+
+typedef 
+enum D3D12_FILTER
+    {
+        D3D12_FILTER_MIN_MAG_MIP_POINT	= 0,
+        D3D12_FILTER_MIN_MAG_POINT_MIP_LINEAR	= 0x1,
+        D3D12_FILTER_MIN_POINT_MAG_LINEAR_MIP_POINT	= 0x4,
+        D3D12_FILTER_MIN_POINT_MAG_MIP_LINEAR	= 0x5,
+        D3D12_FILTER_MIN_LINEAR_MAG_MIP_POINT	= 0x10,
+        D3D12_FILTER_MIN_LINEAR_MAG_POINT_MIP_LINEAR	= 0x11,
+        D3D12_FILTER_MIN_MAG_LINEAR_MIP_POINT	= 0x14,
+        D3D12_FILTER_MIN_MAG_MIP_LINEAR	= 0x15,
+        D3D12_FILTER_ANISOTROPIC	= 0x55,
+        D3D12_FILTER_COMPARISON_MIN_MAG_MIP_POINT	= 0x80,
+        D3D12_FILTER_COMPARISON_MIN_MAG_POINT_MIP_LINEAR	= 0x81,
+        D3D12_FILTER_COMPARISON_MIN_POINT_MAG_LINEAR_MIP_POINT	= 0x84,
+        D3D12_FILTER_COMPARISON_MIN_POINT_MAG_MIP_LINEAR	= 0x85,
+        D3D12_FILTER_COMPARISON_MIN_LINEAR_MAG_MIP_POINT	= 0x90,
+        D3D12_FILTER_COMPARISON_MIN_LINEAR_MAG_POINT_MIP_LINEAR	= 0x91,
+        D3D12_FILTER_COMPARISON_MIN_MAG_LINEAR_MIP_POINT	= 0x94,
+        D3D12_FILTER_COMPARISON_MIN_MAG_MIP_LINEAR	= 0x95,
+        D3D12_FILTER_COMPARISON_ANISOTROPIC	= 0xd5,
+        D3D12_FILTER_MINIMUM_MIN_MAG_MIP_POINT	= 0x100,
+        D3D12_FILTER_MINIMUM_MIN_MAG_POINT_MIP_LINEAR	= 0x101,
+        D3D12_FILTER_MINIMUM_MIN_POINT_MAG_LINEAR_MIP_POINT	= 0x104,
+        D3D12_FILTER_MINIMUM_MIN_POINT_MAG_MIP_LINEAR	= 0x105,
+        D3D12_FILTER_MINIMUM_MIN_LINEAR_MAG_MIP_POINT	= 0x110,
+        D3D12_FILTER_MINIMUM_MIN_LINEAR_MAG_POINT_MIP_LINEAR	= 0x111,
+        D3D12_FILTER_MINIMUM_MIN_MAG_LINEAR_MIP_POINT	= 0x114,
+        D3D12_FILTER_MINIMUM_MIN_MAG_MIP_LINEAR	= 0x115,
+        D3D12_FILTER_MINIMUM_ANISOTROPIC	= 0x155,
+        D3D12_FILTER_MAXIMUM_MIN_MAG_MIP_POINT	= 0x180,
+        D3D12_FILTER_MAXIMUM_MIN_MAG_POINT_MIP_LINEAR	= 0x181,
+        D3D12_FILTER_MAXIMUM_MIN_POINT_MAG_LINEAR_MIP_POINT	= 0x184,
+        D3D12_FILTER_MAXIMUM_MIN_POINT_MAG_MIP_LINEAR	= 0x185,
+        D3D12_FILTER_MAXIMUM_MIN_LINEAR_MAG_MIP_POINT	= 0x190,
+        D3D12_FILTER_MAXIMUM_MIN_LINEAR_MAG_POINT_MIP_LINEAR	= 0x191,
+        D3D12_FILTER_MAXIMUM_MIN_MAG_LINEAR_MIP_POINT	= 0x194,
+        D3D12_FILTER_MAXIMUM_MIN_MAG_MIP_LINEAR	= 0x195,
+        D3D12_FILTER_MAXIMUM_ANISOTROPIC	= 0x1d5
+    } 	D3D12_FILTER;
+
+typedef 
+enum D3D12_FILTER_TYPE
+    {
+        D3D12_FILTER_TYPE_POINT	= 0,
+        D3D12_FILTER_TYPE_LINEAR	= 1
+    } 	D3D12_FILTER_TYPE;
+
+typedef 
+enum D3D12_FILTER_REDUCTION_TYPE
+    {
+        D3D12_FILTER_REDUCTION_TYPE_STANDARD	= 0,
+        D3D12_FILTER_REDUCTION_TYPE_COMPARISON	= 1,
+        D3D12_FILTER_REDUCTION_TYPE_MINIMUM	= 2,
+        D3D12_FILTER_REDUCTION_TYPE_MAXIMUM	= 3
+    } 	D3D12_FILTER_REDUCTION_TYPE;
+
+#define	D3D12_FILTER_REDUCTION_TYPE_MASK	( 0x3 )
+
+#define	D3D12_FILTER_REDUCTION_TYPE_SHIFT	( 7 )
+
+#define	D3D12_FILTER_TYPE_MASK	( 0x3 )
+
+#define	D3D12_MIN_FILTER_SHIFT	( 4 )
+
+#define	D3D12_MAG_FILTER_SHIFT	( 2 )
+
+#define	D3D12_MIP_FILTER_SHIFT	( 0 )
+
+#define	D3D12_ANISOTROPIC_FILTERING_BIT	( 0x40 )
+
+#define D3D12_ENCODE_BASIC_FILTER( min, mag, mip, reduction )                                                     \
+                                   ( ( D3D12_FILTER ) (                                                           \
+                                   ( ( ( min ) & D3D12_FILTER_TYPE_MASK ) << D3D12_MIN_FILTER_SHIFT ) |           \
+                                   ( ( ( mag ) & D3D12_FILTER_TYPE_MASK ) << D3D12_MAG_FILTER_SHIFT ) |           \
+                                   ( ( ( mip ) & D3D12_FILTER_TYPE_MASK ) << D3D12_MIP_FILTER_SHIFT ) |           \
+                                   ( ( ( reduction ) & D3D12_FILTER_REDUCTION_TYPE_MASK ) << D3D12_FILTER_REDUCTION_TYPE_SHIFT ) ) ) 
+#define D3D12_ENCODE_ANISOTROPIC_FILTER( reduction )                                                  \
+                                         ( ( D3D12_FILTER ) (                                         \
+                                         D3D12_ANISOTROPIC_FILTERING_BIT |                            \
+                                         D3D12_ENCODE_BASIC_FILTER( D3D12_FILTER_TYPE_LINEAR,         \
+                                                                    D3D12_FILTER_TYPE_LINEAR,         \
+                                                                    D3D12_FILTER_TYPE_LINEAR,         \
+                                                                    reduction ) ) )                     
+#define D3D12_DECODE_MIN_FILTER( D3D12Filter )                                                              \
+                                 ( ( D3D12_FILTER_TYPE )                                                    \
+                                 ( ( ( D3D12Filter ) >> D3D12_MIN_FILTER_SHIFT ) & D3D12_FILTER_TYPE_MASK ) ) 
+#define D3D12_DECODE_MAG_FILTER( D3D12Filter )                                                              \
+                                 ( ( D3D12_FILTER_TYPE )                                                    \
+                                 ( ( ( D3D12Filter ) >> D3D12_MAG_FILTER_SHIFT ) & D3D12_FILTER_TYPE_MASK ) ) 
+#define D3D12_DECODE_MIP_FILTER( D3D12Filter )                                                              \
+                                 ( ( D3D12_FILTER_TYPE )                                                    \
+                                 ( ( ( D3D12Filter ) >> D3D12_MIP_FILTER_SHIFT ) & D3D12_FILTER_TYPE_MASK ) ) 
+#define D3D12_DECODE_FILTER_REDUCTION( D3D12Filter )                                                        \
+                                 ( ( D3D12_FILTER_REDUCTION_TYPE )                                                      \
+                                 ( ( ( D3D12Filter ) >> D3D12_FILTER_REDUCTION_TYPE_SHIFT ) & D3D12_FILTER_REDUCTION_TYPE_MASK ) ) 
+#define D3D12_DECODE_IS_COMPARISON_FILTER( D3D12Filter )                                                    \
+                                 ( D3D12_DECODE_FILTER_REDUCTION( D3D12Filter ) == D3D12_FILTER_REDUCTION_TYPE_COMPARISON ) 
+#define D3D12_DECODE_IS_ANISOTROPIC_FILTER( D3D12Filter )                                               \
+                            ( ( ( D3D12Filter ) & D3D12_ANISOTROPIC_FILTERING_BIT ) &&                  \
+                            ( D3D12_FILTER_TYPE_LINEAR == D3D12_DECODE_MIN_FILTER( D3D12Filter ) ) &&   \
+                            ( D3D12_FILTER_TYPE_LINEAR == D3D12_DECODE_MAG_FILTER( D3D12Filter ) ) &&   \
+                            ( D3D12_FILTER_TYPE_LINEAR == D3D12_DECODE_MIP_FILTER( D3D12Filter ) ) )      
+typedef 
+enum D3D12_TEXTURE_ADDRESS_MODE
+    {
+        D3D12_TEXTURE_ADDRESS_MODE_WRAP	= 1,
+        D3D12_TEXTURE_ADDRESS_MODE_MIRROR	= 2,
+        D3D12_TEXTURE_ADDRESS_MODE_CLAMP	= 3,
+        D3D12_TEXTURE_ADDRESS_MODE_BORDER	= 4,
+        D3D12_TEXTURE_ADDRESS_MODE_MIRROR_ONCE	= 5
+    } 	D3D12_TEXTURE_ADDRESS_MODE;
+
+typedef struct D3D12_SAMPLER_DESC
+    {
+    D3D12_FILTER Filter;
+    D3D12_TEXTURE_ADDRESS_MODE AddressU;
+    D3D12_TEXTURE_ADDRESS_MODE AddressV;
+    D3D12_TEXTURE_ADDRESS_MODE AddressW;
+    FLOAT MipLODBias;
+    UINT MaxAnisotropy;
+    D3D12_COMPARISON_FUNC ComparisonFunc;
+    FLOAT BorderColor[ 4 ];
+    FLOAT MinLOD;
+    FLOAT MaxLOD;
+    } 	D3D12_SAMPLER_DESC;
+
+typedef 
+enum D3D12_SAMPLER_FLAGS
+    {
+        D3D12_SAMPLER_FLAG_NONE	= 0,
+        D3D12_SAMPLER_FLAG_UINT_BORDER_COLOR	= 0x1
+    } 	D3D12_SAMPLER_FLAGS;
+
+DEFINE_ENUM_FLAG_OPERATORS( D3D12_SAMPLER_FLAGS );
+typedef struct D3D12_SAMPLER_DESC2
+    {
+    D3D12_FILTER Filter;
+    D3D12_TEXTURE_ADDRESS_MODE AddressU;
+    D3D12_TEXTURE_ADDRESS_MODE AddressV;
+    D3D12_TEXTURE_ADDRESS_MODE AddressW;
+    FLOAT MipLODBias;
+    UINT MaxAnisotropy;
+    D3D12_COMPARISON_FUNC ComparisonFunc;
+    union 
+        {
+        FLOAT FloatBorderColor[ 4 ];
+        UINT UintBorderColor[ 4 ];
+        } 	;
+    FLOAT MinLOD;
+    FLOAT MaxLOD;
+    D3D12_SAMPLER_FLAGS Flags;
+    } 	D3D12_SAMPLER_DESC2;
+
+typedef 
+enum D3D12_BUFFER_UAV_FLAGS
+    {
+        D3D12_BUFFER_UAV_FLAG_NONE	= 0,
+        D3D12_BUFFER_UAV_FLAG_RAW	= 0x1
+    } 	D3D12_BUFFER_UAV_FLAGS;
+
+DEFINE_ENUM_FLAG_OPERATORS( D3D12_BUFFER_UAV_FLAGS );
+typedef struct D3D12_BUFFER_UAV
+    {
+    UINT64 FirstElement;
+    UINT NumElements;
+    UINT StructureByteStride;
+    UINT64 CounterOffsetInBytes;
+    D3D12_BUFFER_UAV_FLAGS Flags;
+    } 	D3D12_BUFFER_UAV;
+
+typedef struct D3D12_TEX1D_UAV
+    {
+    UINT MipSlice;
+    } 	D3D12_TEX1D_UAV;
+
+typedef struct D3D12_TEX1D_ARRAY_UAV
+    {
+    UINT MipSlice;
+    UINT FirstArraySlice;
+    UINT ArraySize;
+    } 	D3D12_TEX1D_ARRAY_UAV;
+
+typedef struct D3D12_TEX2D_UAV
+    {
+    UINT MipSlice;
+    UINT PlaneSlice;
+    } 	D3D12_TEX2D_UAV;
+
+typedef struct D3D12_TEX2D_ARRAY_UAV
+    {
+    UINT MipSlice;
+    UINT FirstArraySlice;
+    UINT ArraySize;
+    UINT PlaneSlice;
+    } 	D3D12_TEX2D_ARRAY_UAV;
+
+typedef struct D3D12_TEX2DMS_UAV
+    {
+    UINT UnusedField_NothingToDefine;
+    } 	D3D12_TEX2DMS_UAV;
+
+typedef struct D3D12_TEX2DMS_ARRAY_UAV
+    {
+    UINT FirstArraySlice;
+    UINT ArraySize;
+    } 	D3D12_TEX2DMS_ARRAY_UAV;
+
+typedef struct D3D12_TEX3D_UAV
+    {
+    UINT MipSlice;
+    UINT FirstWSlice;
+    UINT WSize;
+    } 	D3D12_TEX3D_UAV;
+
+typedef 
+enum D3D12_UAV_DIMENSION
+    {
+        D3D12_UAV_DIMENSION_UNKNOWN	= 0,
+        D3D12_UAV_DIMENSION_BUFFER	= 1,
+        D3D12_UAV_DIMENSION_TEXTURE1D	= 2,
+        D3D12_UAV_DIMENSION_TEXTURE1DARRAY	= 3,
+        D3D12_UAV_DIMENSION_TEXTURE2D	= 4,
+        D3D12_UAV_DIMENSION_TEXTURE2DARRAY	= 5,
+        D3D12_UAV_DIMENSION_TEXTURE2DMS	= 6,
+        D3D12_UAV_DIMENSION_TEXTURE2DMSARRAY	= 7,
+        D3D12_UAV_DIMENSION_TEXTURE3D	= 8
+    } 	D3D12_UAV_DIMENSION;
+
+typedef struct D3D12_UNORDERED_ACCESS_VIEW_DESC
+    {
+    DXGI_FORMAT Format;
+    D3D12_UAV_DIMENSION ViewDimension;
+    union 
+        {
+        D3D12_BUFFER_UAV Buffer;
+        D3D12_TEX1D_UAV Texture1D;
+        D3D12_TEX1D_ARRAY_UAV Texture1DArray;
+        D3D12_TEX2D_UAV Texture2D;
+        D3D12_TEX2D_ARRAY_UAV Texture2DArray;
+        D3D12_TEX2DMS_UAV Texture2DMS;
+        D3D12_TEX2DMS_ARRAY_UAV Texture2DMSArray;
+        D3D12_TEX3D_UAV Texture3D;
+        } 	;
+    } 	D3D12_UNORDERED_ACCESS_VIEW_DESC;
+
+typedef struct D3D12_BUFFER_RTV
+    {
+    UINT64 FirstElement;
+    UINT NumElements;
+    } 	D3D12_BUFFER_RTV;
+
+typedef struct D3D12_TEX1D_RTV
+    {
+    UINT MipSlice;
+    } 	D3D12_TEX1D_RTV;
+
+typedef struct D3D12_TEX1D_ARRAY_RTV
+    {
+    UINT MipSlice;
+    UINT FirstArraySlice;
+    UINT ArraySize;
+    } 	D3D12_TEX1D_ARRAY_RTV;
+
+typedef struct D3D12_TEX2D_RTV
+    {
+    UINT MipSlice;
+    UINT PlaneSlice;
+    } 	D3D12_TEX2D_RTV;
+
+typedef struct D3D12_TEX2DMS_RTV
+    {
+    UINT UnusedField_NothingToDefine;
+    } 	D3D12_TEX2DMS_RTV;
+
+typedef struct D3D12_TEX2D_ARRAY_RTV
+    {
+    UINT MipSlice;
+    UINT FirstArraySlice;
+    UINT ArraySize;
+    UINT PlaneSlice;
+    } 	D3D12_TEX2D_ARRAY_RTV;
+
+typedef struct D3D12_TEX2DMS_ARRAY_RTV
+    {
+    UINT FirstArraySlice;
+    UINT ArraySize;
+    } 	D3D12_TEX2DMS_ARRAY_RTV;
+
+typedef struct D3D12_TEX3D_RTV
+    {
+    UINT MipSlice;
+    UINT FirstWSlice;
+    UINT WSize;
+    } 	D3D12_TEX3D_RTV;
+
+typedef 
+enum D3D12_RTV_DIMENSION
+    {
+        D3D12_RTV_DIMENSION_UNKNOWN	= 0,
+        D3D12_RTV_DIMENSION_BUFFER	= 1,
+        D3D12_RTV_DIMENSION_TEXTURE1D	= 2,
+        D3D12_RTV_DIMENSION_TEXTURE1DARRAY	= 3,
+        D3D12_RTV_DIMENSION_TEXTURE2D	= 4,
+        D3D12_RTV_DIMENSION_TEXTURE2DARRAY	= 5,
+        D3D12_RTV_DIMENSION_TEXTURE2DMS	= 6,
+        D3D12_RTV_DIMENSION_TEXTURE2DMSARRAY	= 7,
+        D3D12_RTV_DIMENSION_TEXTURE3D	= 8
+    } 	D3D12_RTV_DIMENSION;
+
+typedef struct D3D12_RENDER_TARGET_VIEW_DESC
+    {
+    DXGI_FORMAT Format;
+    D3D12_RTV_DIMENSION ViewDimension;
+    union 
+        {
+        D3D12_BUFFER_RTV Buffer;
+        D3D12_TEX1D_RTV Texture1D;
+        D3D12_TEX1D_ARRAY_RTV Texture1DArray;
+        D3D12_TEX2D_RTV Texture2D;
+        D3D12_TEX2D_ARRAY_RTV Texture2DArray;
+        D3D12_TEX2DMS_RTV Texture2DMS;
+        D3D12_TEX2DMS_ARRAY_RTV Texture2DMSArray;
+        D3D12_TEX3D_RTV Texture3D;
+        } 	;
+    } 	D3D12_RENDER_TARGET_VIEW_DESC;
+
+typedef struct D3D12_TEX1D_DSV
+    {
+    UINT MipSlice;
+    } 	D3D12_TEX1D_DSV;
+
+typedef struct D3D12_TEX1D_ARRAY_DSV
+    {
+    UINT MipSlice;
+    UINT FirstArraySlice;
+    UINT ArraySize;
+    } 	D3D12_TEX1D_ARRAY_DSV;
+
+typedef struct D3D12_TEX2D_DSV
+    {
+    UINT MipSlice;
+    } 	D3D12_TEX2D_DSV;
+
+typedef struct D3D12_TEX2D_ARRAY_DSV
+    {
+    UINT MipSlice;
+    UINT FirstArraySlice;
+    UINT ArraySize;
+    } 	D3D12_TEX2D_ARRAY_DSV;
+
+typedef struct D3D12_TEX2DMS_DSV
+    {
+    UINT UnusedField_NothingToDefine;
+    } 	D3D12_TEX2DMS_DSV;
+
+typedef struct D3D12_TEX2DMS_ARRAY_DSV
+    {
+    UINT FirstArraySlice;
+    UINT ArraySize;
+    } 	D3D12_TEX2DMS_ARRAY_DSV;
+
+typedef 
+enum D3D12_DSV_FLAGS
+    {
+        D3D12_DSV_FLAG_NONE	= 0,
+        D3D12_DSV_FLAG_READ_ONLY_DEPTH	= 0x1,
+        D3D12_DSV_FLAG_READ_ONLY_STENCIL	= 0x2
+    } 	D3D12_DSV_FLAGS;
+
+DEFINE_ENUM_FLAG_OPERATORS( D3D12_DSV_FLAGS );
+typedef 
+enum D3D12_DSV_DIMENSION
+    {
+        D3D12_DSV_DIMENSION_UNKNOWN	= 0,
+        D3D12_DSV_DIMENSION_TEXTURE1D	= 1,
+        D3D12_DSV_DIMENSION_TEXTURE1DARRAY	= 2,
+        D3D12_DSV_DIMENSION_TEXTURE2D	= 3,
+        D3D12_DSV_DIMENSION_TEXTURE2DARRAY	= 4,
+        D3D12_DSV_DIMENSION_TEXTURE2DMS	= 5,
+        D3D12_DSV_DIMENSION_TEXTURE2DMSARRAY	= 6
+    } 	D3D12_DSV_DIMENSION;
+
+typedef struct D3D12_DEPTH_STENCIL_VIEW_DESC
+    {
+    DXGI_FORMAT Format;
+    D3D12_DSV_DIMENSION ViewDimension;
+    D3D12_DSV_FLAGS Flags;
+    union 
+        {
+        D3D12_TEX1D_DSV Texture1D;
+        D3D12_TEX1D_ARRAY_DSV Texture1DArray;
+        D3D12_TEX2D_DSV Texture2D;
+        D3D12_TEX2D_ARRAY_DSV Texture2DArray;
+        D3D12_TEX2DMS_DSV Texture2DMS;
+        D3D12_TEX2DMS_ARRAY_DSV Texture2DMSArray;
+        } 	;
+    } 	D3D12_DEPTH_STENCIL_VIEW_DESC;
+
+typedef 
+enum D3D12_CLEAR_FLAGS
+    {
+        D3D12_CLEAR_FLAG_DEPTH	= 0x1,
+        D3D12_CLEAR_FLAG_STENCIL	= 0x2
+    } 	D3D12_CLEAR_FLAGS;
+
+DEFINE_ENUM_FLAG_OPERATORS( D3D12_CLEAR_FLAGS );
+typedef 
+enum D3D12_FENCE_FLAGS
+    {
+        D3D12_FENCE_FLAG_NONE	= 0,
+        D3D12_FENCE_FLAG_SHARED	= 0x1,
+        D3D12_FENCE_FLAG_SHARED_CROSS_ADAPTER	= 0x2,
+        D3D12_FENCE_FLAG_NON_MONITORED	= 0x4
+    } 	D3D12_FENCE_FLAGS;
+
+DEFINE_ENUM_FLAG_OPERATORS( D3D12_FENCE_FLAGS );
+typedef 
+enum D3D12_DESCRIPTOR_HEAP_TYPE
+    {
+        D3D12_DESCRIPTOR_HEAP_TYPE_CBV_SRV_UAV	= 0,
+        D3D12_DESCRIPTOR_HEAP_TYPE_SAMPLER	= ( D3D12_DESCRIPTOR_HEAP_TYPE_CBV_SRV_UAV + 1 ) ,
+        D3D12_DESCRIPTOR_HEAP_TYPE_RTV	= ( D3D12_DESCRIPTOR_HEAP_TYPE_SAMPLER + 1 ) ,
+        D3D12_DESCRIPTOR_HEAP_TYPE_DSV	= ( D3D12_DESCRIPTOR_HEAP_TYPE_RTV + 1 ) ,
+        D3D12_DESCRIPTOR_HEAP_TYPE_NUM_TYPES	= ( D3D12_DESCRIPTOR_HEAP_TYPE_DSV + 1 ) 
+    } 	D3D12_DESCRIPTOR_HEAP_TYPE;
+
+typedef 
+enum D3D12_DESCRIPTOR_HEAP_FLAGS
+    {
+        D3D12_DESCRIPTOR_HEAP_FLAG_NONE	= 0,
+        D3D12_DESCRIPTOR_HEAP_FLAG_SHADER_VISIBLE	= 0x1
+    } 	D3D12_DESCRIPTOR_HEAP_FLAGS;
+
+DEFINE_ENUM_FLAG_OPERATORS( D3D12_DESCRIPTOR_HEAP_FLAGS );
+typedef struct D3D12_DESCRIPTOR_HEAP_DESC
+    {
+    D3D12_DESCRIPTOR_HEAP_TYPE Type;
+    UINT NumDescriptors;
+    D3D12_DESCRIPTOR_HEAP_FLAGS Flags;
+    UINT NodeMask;
+    } 	D3D12_DESCRIPTOR_HEAP_DESC;
+
+typedef 
+enum D3D12_DESCRIPTOR_RANGE_TYPE
+    {
+        D3D12_DESCRIPTOR_RANGE_TYPE_SRV	= 0,
+        D3D12_DESCRIPTOR_RANGE_TYPE_UAV	= ( D3D12_DESCRIPTOR_RANGE_TYPE_SRV + 1 ) ,
+        D3D12_DESCRIPTOR_RANGE_TYPE_CBV	= ( D3D12_DESCRIPTOR_RANGE_TYPE_UAV + 1 ) ,
+        D3D12_DESCRIPTOR_RANGE_TYPE_SAMPLER	= ( D3D12_DESCRIPTOR_RANGE_TYPE_CBV + 1 ) 
+    } 	D3D12_DESCRIPTOR_RANGE_TYPE;
+
+typedef struct D3D12_DESCRIPTOR_RANGE
+    {
+    D3D12_DESCRIPTOR_RANGE_TYPE RangeType;
+    UINT NumDescriptors;
+    UINT BaseShaderRegister;
+    UINT RegisterSpace;
+    UINT OffsetInDescriptorsFromTableStart;
+    } 	D3D12_DESCRIPTOR_RANGE;
+
+typedef struct D3D12_ROOT_DESCRIPTOR_TABLE
+    {
+    UINT NumDescriptorRanges;
+    _Field_size_full_(NumDescriptorRanges)  const D3D12_DESCRIPTOR_RANGE *pDescriptorRanges;
+    } 	D3D12_ROOT_DESCRIPTOR_TABLE;
+
+typedef struct D3D12_ROOT_CONSTANTS
+    {
+    UINT ShaderRegister;
+    UINT RegisterSpace;
+    UINT Num32BitValues;
+    } 	D3D12_ROOT_CONSTANTS;
+
+typedef struct D3D12_ROOT_DESCRIPTOR
+    {
+    UINT ShaderRegister;
+    UINT RegisterSpace;
+    } 	D3D12_ROOT_DESCRIPTOR;
+
+typedef 
+enum D3D12_SHADER_VISIBILITY
+    {
+        D3D12_SHADER_VISIBILITY_ALL	= 0,
+        D3D12_SHADER_VISIBILITY_VERTEX	= 1,
+        D3D12_SHADER_VISIBILITY_HULL	= 2,
+        D3D12_SHADER_VISIBILITY_DOMAIN	= 3,
+        D3D12_SHADER_VISIBILITY_GEOMETRY	= 4,
+        D3D12_SHADER_VISIBILITY_PIXEL	= 5,
+        D3D12_SHADER_VISIBILITY_AMPLIFICATION	= 6,
+        D3D12_SHADER_VISIBILITY_MESH	= 7
+    } 	D3D12_SHADER_VISIBILITY;
+
+typedef 
+enum D3D12_ROOT_PARAMETER_TYPE
+    {
+        D3D12_ROOT_PARAMETER_TYPE_DESCRIPTOR_TABLE	= 0,
+        D3D12_ROOT_PARAMETER_TYPE_32BIT_CONSTANTS	= ( D3D12_ROOT_PARAMETER_TYPE_DESCRIPTOR_TABLE + 1 ) ,
+        D3D12_ROOT_PARAMETER_TYPE_CBV	= ( D3D12_ROOT_PARAMETER_TYPE_32BIT_CONSTANTS + 1 ) ,
+        D3D12_ROOT_PARAMETER_TYPE_SRV	= ( D3D12_ROOT_PARAMETER_TYPE_CBV + 1 ) ,
+        D3D12_ROOT_PARAMETER_TYPE_UAV	= ( D3D12_ROOT_PARAMETER_TYPE_SRV + 1 ) 
+    } 	D3D12_ROOT_PARAMETER_TYPE;
+
+typedef struct D3D12_ROOT_PARAMETER
+    {
+    D3D12_ROOT_PARAMETER_TYPE ParameterType;
+    union 
+        {
+        D3D12_ROOT_DESCRIPTOR_TABLE DescriptorTable;
+        D3D12_ROOT_CONSTANTS Constants;
+        D3D12_ROOT_DESCRIPTOR Descriptor;
+        } 	;
+    D3D12_SHADER_VISIBILITY ShaderVisibility;
+    } 	D3D12_ROOT_PARAMETER;
+
+typedef 
+enum D3D12_ROOT_SIGNATURE_FLAGS
+    {
+        D3D12_ROOT_SIGNATURE_FLAG_NONE	= 0,
+        D3D12_ROOT_SIGNATURE_FLAG_ALLOW_INPUT_ASSEMBLER_INPUT_LAYOUT	= 0x1,
+        D3D12_ROOT_SIGNATURE_FLAG_DENY_VERTEX_SHADER_ROOT_ACCESS	= 0x2,
+        D3D12_ROOT_SIGNATURE_FLAG_DENY_HULL_SHADER_ROOT_ACCESS	= 0x4,
+        D3D12_ROOT_SIGNATURE_FLAG_DENY_DOMAIN_SHADER_ROOT_ACCESS	= 0x8,
+        D3D12_ROOT_SIGNATURE_FLAG_DENY_GEOMETRY_SHADER_ROOT_ACCESS	= 0x10,
+        D3D12_ROOT_SIGNATURE_FLAG_DENY_PIXEL_SHADER_ROOT_ACCESS	= 0x20,
+        D3D12_ROOT_SIGNATURE_FLAG_ALLOW_STREAM_OUTPUT	= 0x40,
+        D3D12_ROOT_SIGNATURE_FLAG_LOCAL_ROOT_SIGNATURE	= 0x80,
+        D3D12_ROOT_SIGNATURE_FLAG_DENY_AMPLIFICATION_SHADER_ROOT_ACCESS	= 0x100,
+        D3D12_ROOT_SIGNATURE_FLAG_DENY_MESH_SHADER_ROOT_ACCESS	= 0x200,
+        D3D12_ROOT_SIGNATURE_FLAG_CBV_SRV_UAV_HEAP_DIRECTLY_INDEXED	= 0x400,
+        D3D12_ROOT_SIGNATURE_FLAG_SAMPLER_HEAP_DIRECTLY_INDEXED	= 0x800
+    } 	D3D12_ROOT_SIGNATURE_FLAGS;
+
+DEFINE_ENUM_FLAG_OPERATORS( D3D12_ROOT_SIGNATURE_FLAGS );
+typedef 
+enum D3D12_STATIC_BORDER_COLOR
+    {
+        D3D12_STATIC_BORDER_COLOR_TRANSPARENT_BLACK	= 0,
+        D3D12_STATIC_BORDER_COLOR_OPAQUE_BLACK	= ( D3D12_STATIC_BORDER_COLOR_TRANSPARENT_BLACK + 1 ) ,
+        D3D12_STATIC_BORDER_COLOR_OPAQUE_WHITE	= ( D3D12_STATIC_BORDER_COLOR_OPAQUE_BLACK + 1 ) ,
+        D3D12_STATIC_BORDER_COLOR_OPAQUE_BLACK_UINT	= ( D3D12_STATIC_BORDER_COLOR_OPAQUE_WHITE + 1 ) ,
+        D3D12_STATIC_BORDER_COLOR_OPAQUE_WHITE_UINT	= ( D3D12_STATIC_BORDER_COLOR_OPAQUE_BLACK_UINT + 1 ) 
+    } 	D3D12_STATIC_BORDER_COLOR;
+
+typedef struct D3D12_STATIC_SAMPLER_DESC
+    {
+    D3D12_FILTER Filter;
+    D3D12_TEXTURE_ADDRESS_MODE AddressU;
+    D3D12_TEXTURE_ADDRESS_MODE AddressV;
+    D3D12_TEXTURE_ADDRESS_MODE AddressW;
+    FLOAT MipLODBias;
+    UINT MaxAnisotropy;
+    D3D12_COMPARISON_FUNC ComparisonFunc;
+    D3D12_STATIC_BORDER_COLOR BorderColor;
+    FLOAT MinLOD;
+    FLOAT MaxLOD;
+    UINT ShaderRegister;
+    UINT RegisterSpace;
+    D3D12_SHADER_VISIBILITY ShaderVisibility;
+    } 	D3D12_STATIC_SAMPLER_DESC;
+
+typedef struct D3D12_ROOT_SIGNATURE_DESC
+    {
+    UINT NumParameters;
+    _Field_size_full_(NumParameters)  const D3D12_ROOT_PARAMETER *pParameters;
+    UINT NumStaticSamplers;
+    _Field_size_full_(NumStaticSamplers)  const D3D12_STATIC_SAMPLER_DESC *pStaticSamplers;
+    D3D12_ROOT_SIGNATURE_FLAGS Flags;
+    } 	D3D12_ROOT_SIGNATURE_DESC;
+
+typedef 
+enum D3D12_DESCRIPTOR_RANGE_FLAGS
+    {
+        D3D12_DESCRIPTOR_RANGE_FLAG_NONE	= 0,
+        D3D12_DESCRIPTOR_RANGE_FLAG_DESCRIPTORS_VOLATILE	= 0x1,
+        D3D12_DESCRIPTOR_RANGE_FLAG_DATA_VOLATILE	= 0x2,
+        D3D12_DESCRIPTOR_RANGE_FLAG_DATA_STATIC_WHILE_SET_AT_EXECUTE	= 0x4,
+        D3D12_DESCRIPTOR_RANGE_FLAG_DATA_STATIC	= 0x8,
+        D3D12_DESCRIPTOR_RANGE_FLAG_DESCRIPTORS_STATIC_KEEPING_BUFFER_BOUNDS_CHECKS	= 0x10000
+    } 	D3D12_DESCRIPTOR_RANGE_FLAGS;
+
+DEFINE_ENUM_FLAG_OPERATORS( D3D12_DESCRIPTOR_RANGE_FLAGS );
+typedef struct D3D12_DESCRIPTOR_RANGE1
+    {
+    D3D12_DESCRIPTOR_RANGE_TYPE RangeType;
+    UINT NumDescriptors;
+    UINT BaseShaderRegister;
+    UINT RegisterSpace;
+    D3D12_DESCRIPTOR_RANGE_FLAGS Flags;
+    UINT OffsetInDescriptorsFromTableStart;
+    } 	D3D12_DESCRIPTOR_RANGE1;
+
+typedef struct D3D12_ROOT_DESCRIPTOR_TABLE1
+    {
+    UINT NumDescriptorRanges;
+    _Field_size_full_(NumDescriptorRanges)  const D3D12_DESCRIPTOR_RANGE1 *pDescriptorRanges;
+    } 	D3D12_ROOT_DESCRIPTOR_TABLE1;
+
+typedef 
+enum D3D12_ROOT_DESCRIPTOR_FLAGS
+    {
+        D3D12_ROOT_DESCRIPTOR_FLAG_NONE	= 0,
+        D3D12_ROOT_DESCRIPTOR_FLAG_DATA_VOLATILE	= 0x2,
+        D3D12_ROOT_DESCRIPTOR_FLAG_DATA_STATIC_WHILE_SET_AT_EXECUTE	= 0x4,
+        D3D12_ROOT_DESCRIPTOR_FLAG_DATA_STATIC	= 0x8
+    } 	D3D12_ROOT_DESCRIPTOR_FLAGS;
+
+DEFINE_ENUM_FLAG_OPERATORS( D3D12_ROOT_DESCRIPTOR_FLAGS );
+typedef struct D3D12_ROOT_DESCRIPTOR1
+    {
+    UINT ShaderRegister;
+    UINT RegisterSpace;
+    D3D12_ROOT_DESCRIPTOR_FLAGS Flags;
+    } 	D3D12_ROOT_DESCRIPTOR1;
+
+typedef struct D3D12_ROOT_PARAMETER1
+    {
+    D3D12_ROOT_PARAMETER_TYPE ParameterType;
+    union 
+        {
+        D3D12_ROOT_DESCRIPTOR_TABLE1 DescriptorTable;
+        D3D12_ROOT_CONSTANTS Constants;
+        D3D12_ROOT_DESCRIPTOR1 Descriptor;
+        } 	;
+    D3D12_SHADER_VISIBILITY ShaderVisibility;
+    } 	D3D12_ROOT_PARAMETER1;
+
+typedef struct D3D12_ROOT_SIGNATURE_DESC1
+    {
+    UINT NumParameters;
+    _Field_size_full_(NumParameters)  const D3D12_ROOT_PARAMETER1 *pParameters;
+    UINT NumStaticSamplers;
+    _Field_size_full_(NumStaticSamplers)  const D3D12_STATIC_SAMPLER_DESC *pStaticSamplers;
+    D3D12_ROOT_SIGNATURE_FLAGS Flags;
+    } 	D3D12_ROOT_SIGNATURE_DESC1;
+
+typedef struct D3D12_VERSIONED_ROOT_SIGNATURE_DESC
+    {
+    D3D_ROOT_SIGNATURE_VERSION Version;
+    union 
+        {
+        D3D12_ROOT_SIGNATURE_DESC Desc_1_0;
+        D3D12_ROOT_SIGNATURE_DESC1 Desc_1_1;
+        } 	;
+    } 	D3D12_VERSIONED_ROOT_SIGNATURE_DESC;
+
+
+
+extern RPC_IF_HANDLE __MIDL_itf_d3d12_0000_0001_v0_0_c_ifspec;
+extern RPC_IF_HANDLE __MIDL_itf_d3d12_0000_0001_v0_0_s_ifspec;
+
+#ifndef __ID3D12RootSignatureDeserializer_INTERFACE_DEFINED__
+#define __ID3D12RootSignatureDeserializer_INTERFACE_DEFINED__
+
+/* interface ID3D12RootSignatureDeserializer */
+/* [unique][local][object][uuid] */ 
+
+
+EXTERN_C const IID IID_ID3D12RootSignatureDeserializer;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("34AB647B-3CC8-46AC-841B-C0965645C046")
+    ID3D12RootSignatureDeserializer : public IUnknown
+    {
+    public:
+        virtual const D3D12_ROOT_SIGNATURE_DESC *STDMETHODCALLTYPE GetRootSignatureDesc( void) = 0;
+        
+    };
+    
+    
+#else 	/* C style interface */
+
+    typedef struct ID3D12RootSignatureDeserializerVtbl
+    {
+        BEGIN_INTERFACE
+        
+        DECLSPEC_XFGVIRT(IUnknown, QueryInterface)
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            ID3D12RootSignatureDeserializer * This,
+            REFIID riid,
+            _COM_Outptr_  void **ppvObject);
+        
+        DECLSPEC_XFGVIRT(IUnknown, AddRef)
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            ID3D12RootSignatureDeserializer * This);
+        
+        DECLSPEC_XFGVIRT(IUnknown, Release)
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            ID3D12RootSignatureDeserializer * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12RootSignatureDeserializer, GetRootSignatureDesc)
+        const D3D12_ROOT_SIGNATURE_DESC *( STDMETHODCALLTYPE *GetRootSignatureDesc )( 
+            ID3D12RootSignatureDeserializer * This);
+        
+        END_INTERFACE
+    } ID3D12RootSignatureDeserializerVtbl;
+
+    interface ID3D12RootSignatureDeserializer
+    {
+        CONST_VTBL struct ID3D12RootSignatureDeserializerVtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define ID3D12RootSignatureDeserializer_QueryInterface(This,riid,ppvObject)	\
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define ID3D12RootSignatureDeserializer_AddRef(This)	\
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define ID3D12RootSignatureDeserializer_Release(This)	\
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#define ID3D12RootSignatureDeserializer_GetRootSignatureDesc(This)	\
+    ( (This)->lpVtbl -> GetRootSignatureDesc(This) ) 
+
+#endif /* COBJMACROS */
+
+
+#endif 	/* C style interface */
+
+
+
+
+#endif 	/* __ID3D12RootSignatureDeserializer_INTERFACE_DEFINED__ */
+
+
+#ifndef __ID3D12VersionedRootSignatureDeserializer_INTERFACE_DEFINED__
+#define __ID3D12VersionedRootSignatureDeserializer_INTERFACE_DEFINED__
+
+/* interface ID3D12VersionedRootSignatureDeserializer */
+/* [unique][local][object][uuid] */ 
+
+
+EXTERN_C const IID IID_ID3D12VersionedRootSignatureDeserializer;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("7F91CE67-090C-4BB7-B78E-ED8FF2E31DA0")
+    ID3D12VersionedRootSignatureDeserializer : public IUnknown
+    {
+    public:
+        virtual HRESULT STDMETHODCALLTYPE GetRootSignatureDescAtVersion( 
+            D3D_ROOT_SIGNATURE_VERSION convertToVersion,
+            _Out_  const D3D12_VERSIONED_ROOT_SIGNATURE_DESC **ppDesc) = 0;
+        
+        virtual const D3D12_VERSIONED_ROOT_SIGNATURE_DESC *STDMETHODCALLTYPE GetUnconvertedRootSignatureDesc( void) = 0;
+        
+    };
+    
+    
+#else 	/* C style interface */
+
+    typedef struct ID3D12VersionedRootSignatureDeserializerVtbl
+    {
+        BEGIN_INTERFACE
+        
+        DECLSPEC_XFGVIRT(IUnknown, QueryInterface)
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            ID3D12VersionedRootSignatureDeserializer * This,
+            REFIID riid,
+            _COM_Outptr_  void **ppvObject);
+        
+        DECLSPEC_XFGVIRT(IUnknown, AddRef)
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            ID3D12VersionedRootSignatureDeserializer * This);
+        
+        DECLSPEC_XFGVIRT(IUnknown, Release)
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            ID3D12VersionedRootSignatureDeserializer * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12VersionedRootSignatureDeserializer, GetRootSignatureDescAtVersion)
+        HRESULT ( STDMETHODCALLTYPE *GetRootSignatureDescAtVersion )( 
+            ID3D12VersionedRootSignatureDeserializer * This,
+            D3D_ROOT_SIGNATURE_VERSION convertToVersion,
+            _Out_  const D3D12_VERSIONED_ROOT_SIGNATURE_DESC **ppDesc);
+        
+        DECLSPEC_XFGVIRT(ID3D12VersionedRootSignatureDeserializer, GetUnconvertedRootSignatureDesc)
+        const D3D12_VERSIONED_ROOT_SIGNATURE_DESC *( STDMETHODCALLTYPE *GetUnconvertedRootSignatureDesc )( 
+            ID3D12VersionedRootSignatureDeserializer * This);
+        
+        END_INTERFACE
+    } ID3D12VersionedRootSignatureDeserializerVtbl;
+
+    interface ID3D12VersionedRootSignatureDeserializer
+    {
+        CONST_VTBL struct ID3D12VersionedRootSignatureDeserializerVtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define ID3D12VersionedRootSignatureDeserializer_QueryInterface(This,riid,ppvObject)	\
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define ID3D12VersionedRootSignatureDeserializer_AddRef(This)	\
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define ID3D12VersionedRootSignatureDeserializer_Release(This)	\
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#define ID3D12VersionedRootSignatureDeserializer_GetRootSignatureDescAtVersion(This,convertToVersion,ppDesc)	\
+    ( (This)->lpVtbl -> GetRootSignatureDescAtVersion(This,convertToVersion,ppDesc) ) 
+
+#define ID3D12VersionedRootSignatureDeserializer_GetUnconvertedRootSignatureDesc(This)	\
+    ( (This)->lpVtbl -> GetUnconvertedRootSignatureDesc(This) ) 
+
+#endif /* COBJMACROS */
+
+
+#endif 	/* C style interface */
+
+
+
+
+#endif 	/* __ID3D12VersionedRootSignatureDeserializer_INTERFACE_DEFINED__ */
+
+
+/* interface __MIDL_itf_d3d12_0000_0003 */
+/* [local] */ 
+
+typedef HRESULT (WINAPI* PFN_D3D12_SERIALIZE_ROOT_SIGNATURE)(
+                            _In_ const D3D12_ROOT_SIGNATURE_DESC* pRootSignature,
+                            _In_ D3D_ROOT_SIGNATURE_VERSION Version,
+                            _Out_ ID3DBlob** ppBlob,
+                            _Always_(_Outptr_opt_result_maybenull_) ID3DBlob** ppErrorBlob);
+
+HRESULT WINAPI D3D12SerializeRootSignature(
+                            _In_ const D3D12_ROOT_SIGNATURE_DESC* pRootSignature,
+                            _In_ D3D_ROOT_SIGNATURE_VERSION Version,
+                            _Out_ ID3DBlob** ppBlob,
+                            _Always_(_Outptr_opt_result_maybenull_) ID3DBlob** ppErrorBlob);
+
+typedef HRESULT (WINAPI* PFN_D3D12_CREATE_ROOT_SIGNATURE_DESERIALIZER)(
+                                     _In_reads_bytes_(SrcDataSizeInBytes) LPCVOID pSrcData,
+                                     _In_ SIZE_T SrcDataSizeInBytes,
+                                     _In_ REFIID pRootSignatureDeserializerInterface,
+                                     _Out_ void** ppRootSignatureDeserializer);
+
+HRESULT WINAPI D3D12CreateRootSignatureDeserializer(
+                                     _In_reads_bytes_(SrcDataSizeInBytes) LPCVOID pSrcData,
+                                     _In_ SIZE_T SrcDataSizeInBytes,
+                                     _In_ REFIID pRootSignatureDeserializerInterface,
+                                     _Out_ void** ppRootSignatureDeserializer);
+
+typedef HRESULT (WINAPI* PFN_D3D12_SERIALIZE_VERSIONED_ROOT_SIGNATURE)(
+                            _In_ const D3D12_VERSIONED_ROOT_SIGNATURE_DESC* pRootSignature,
+                            _Out_ ID3DBlob** ppBlob,
+                            _Always_(_Outptr_opt_result_maybenull_) ID3DBlob** ppErrorBlob);
+
+HRESULT WINAPI D3D12SerializeVersionedRootSignature(
+                            _In_ const D3D12_VERSIONED_ROOT_SIGNATURE_DESC* pRootSignature,
+                            _Out_ ID3DBlob** ppBlob,
+                            _Always_(_Outptr_opt_result_maybenull_) ID3DBlob** ppErrorBlob);
+
+typedef HRESULT (WINAPI* PFN_D3D12_CREATE_VERSIONED_ROOT_SIGNATURE_DESERIALIZER)(
+                                     _In_reads_bytes_(SrcDataSizeInBytes) LPCVOID pSrcData,
+                                     _In_ SIZE_T SrcDataSizeInBytes,
+                                     _In_ REFIID pRootSignatureDeserializerInterface,
+                                     _Out_ void** ppRootSignatureDeserializer);
+
+HRESULT WINAPI D3D12CreateVersionedRootSignatureDeserializer(
+                                     _In_reads_bytes_(SrcDataSizeInBytes) LPCVOID pSrcData,
+                                     _In_ SIZE_T SrcDataSizeInBytes,
+                                     _In_ REFIID pRootSignatureDeserializerInterface,
+                                     _Out_ void** ppRootSignatureDeserializer);
+
+typedef struct D3D12_CPU_DESCRIPTOR_HANDLE
+    {
+    SIZE_T ptr;
+    } 	D3D12_CPU_DESCRIPTOR_HANDLE;
+
+typedef struct D3D12_GPU_DESCRIPTOR_HANDLE
+    {
+    UINT64 ptr;
+    } 	D3D12_GPU_DESCRIPTOR_HANDLE;
+
+// If rects are supplied in D3D12_DISCARD_REGION, below, the resource 
+// must have 2D subresources with all specified subresources the same dimension.
+typedef struct D3D12_DISCARD_REGION
+    {
+    UINT NumRects;
+    _In_reads_(NumRects)  const D3D12_RECT *pRects;
+    UINT FirstSubresource;
+    UINT NumSubresources;
+    } 	D3D12_DISCARD_REGION;
+
+typedef 
+enum D3D12_QUERY_HEAP_TYPE
+    {
+        D3D12_QUERY_HEAP_TYPE_OCCLUSION	= 0,
+        D3D12_QUERY_HEAP_TYPE_TIMESTAMP	= 1,
+        D3D12_QUERY_HEAP_TYPE_PIPELINE_STATISTICS	= 2,
+        D3D12_QUERY_HEAP_TYPE_SO_STATISTICS	= 3,
+        D3D12_QUERY_HEAP_TYPE_VIDEO_DECODE_STATISTICS	= 4,
+        D3D12_QUERY_HEAP_TYPE_COPY_QUEUE_TIMESTAMP	= 5,
+        D3D12_QUERY_HEAP_TYPE_PIPELINE_STATISTICS1	= 7
+    } 	D3D12_QUERY_HEAP_TYPE;
+
+typedef struct D3D12_QUERY_HEAP_DESC
+    {
+    D3D12_QUERY_HEAP_TYPE Type;
+    UINT Count;
+    UINT NodeMask;
+    } 	D3D12_QUERY_HEAP_DESC;
+
+typedef 
+enum D3D12_QUERY_TYPE
+    {
+        D3D12_QUERY_TYPE_OCCLUSION	= 0,
+        D3D12_QUERY_TYPE_BINARY_OCCLUSION	= 1,
+        D3D12_QUERY_TYPE_TIMESTAMP	= 2,
+        D3D12_QUERY_TYPE_PIPELINE_STATISTICS	= 3,
+        D3D12_QUERY_TYPE_SO_STATISTICS_STREAM0	= 4,
+        D3D12_QUERY_TYPE_SO_STATISTICS_STREAM1	= 5,
+        D3D12_QUERY_TYPE_SO_STATISTICS_STREAM2	= 6,
+        D3D12_QUERY_TYPE_SO_STATISTICS_STREAM3	= 7,
+        D3D12_QUERY_TYPE_VIDEO_DECODE_STATISTICS	= 8,
+        D3D12_QUERY_TYPE_PIPELINE_STATISTICS1	= 10
+    } 	D3D12_QUERY_TYPE;
+
+typedef 
+enum D3D12_PREDICATION_OP
+    {
+        D3D12_PREDICATION_OP_EQUAL_ZERO	= 0,
+        D3D12_PREDICATION_OP_NOT_EQUAL_ZERO	= 1
+    } 	D3D12_PREDICATION_OP;
+
+typedef struct D3D12_QUERY_DATA_PIPELINE_STATISTICS
+    {
+    UINT64 IAVertices;
+    UINT64 IAPrimitives;
+    UINT64 VSInvocations;
+    UINT64 GSInvocations;
+    UINT64 GSPrimitives;
+    UINT64 CInvocations;
+    UINT64 CPrimitives;
+    UINT64 PSInvocations;
+    UINT64 HSInvocations;
+    UINT64 DSInvocations;
+    UINT64 CSInvocations;
+    } 	D3D12_QUERY_DATA_PIPELINE_STATISTICS;
+
+typedef struct D3D12_QUERY_DATA_PIPELINE_STATISTICS1
+    {
+    UINT64 IAVertices;
+    UINT64 IAPrimitives;
+    UINT64 VSInvocations;
+    UINT64 GSInvocations;
+    UINT64 GSPrimitives;
+    UINT64 CInvocations;
+    UINT64 CPrimitives;
+    UINT64 PSInvocations;
+    UINT64 HSInvocations;
+    UINT64 DSInvocations;
+    UINT64 CSInvocations;
+    UINT64 ASInvocations;
+    UINT64 MSInvocations;
+    UINT64 MSPrimitives;
+    } 	D3D12_QUERY_DATA_PIPELINE_STATISTICS1;
+
+typedef struct D3D12_QUERY_DATA_SO_STATISTICS
+    {
+    UINT64 NumPrimitivesWritten;
+    UINT64 PrimitivesStorageNeeded;
+    } 	D3D12_QUERY_DATA_SO_STATISTICS;
+
+typedef struct D3D12_STREAM_OUTPUT_BUFFER_VIEW
+    {
+    D3D12_GPU_VIRTUAL_ADDRESS BufferLocation;
+    UINT64 SizeInBytes;
+    D3D12_GPU_VIRTUAL_ADDRESS BufferFilledSizeLocation;
+    } 	D3D12_STREAM_OUTPUT_BUFFER_VIEW;
+
+typedef struct D3D12_DRAW_ARGUMENTS
+    {
+    UINT VertexCountPerInstance;
+    UINT InstanceCount;
+    UINT StartVertexLocation;
+    UINT StartInstanceLocation;
+    } 	D3D12_DRAW_ARGUMENTS;
+
+typedef struct D3D12_DRAW_INDEXED_ARGUMENTS
+    {
+    UINT IndexCountPerInstance;
+    UINT InstanceCount;
+    UINT StartIndexLocation;
+    INT BaseVertexLocation;
+    UINT StartInstanceLocation;
+    } 	D3D12_DRAW_INDEXED_ARGUMENTS;
+
+typedef struct D3D12_DISPATCH_ARGUMENTS
+    {
+    UINT ThreadGroupCountX;
+    UINT ThreadGroupCountY;
+    UINT ThreadGroupCountZ;
+    } 	D3D12_DISPATCH_ARGUMENTS;
+
+typedef struct D3D12_VERTEX_BUFFER_VIEW
+    {
+    D3D12_GPU_VIRTUAL_ADDRESS BufferLocation;
+    UINT SizeInBytes;
+    UINT StrideInBytes;
+    } 	D3D12_VERTEX_BUFFER_VIEW;
+
+typedef struct D3D12_INDEX_BUFFER_VIEW
+    {
+    D3D12_GPU_VIRTUAL_ADDRESS BufferLocation;
+    UINT SizeInBytes;
+    DXGI_FORMAT Format;
+    } 	D3D12_INDEX_BUFFER_VIEW;
+
+typedef 
+enum D3D12_INDIRECT_ARGUMENT_TYPE
+    {
+        D3D12_INDIRECT_ARGUMENT_TYPE_DRAW	= 0,
+        D3D12_INDIRECT_ARGUMENT_TYPE_DRAW_INDEXED	= ( D3D12_INDIRECT_ARGUMENT_TYPE_DRAW + 1 ) ,
+        D3D12_INDIRECT_ARGUMENT_TYPE_DISPATCH	= ( D3D12_INDIRECT_ARGUMENT_TYPE_DRAW_INDEXED + 1 ) ,
+        D3D12_INDIRECT_ARGUMENT_TYPE_VERTEX_BUFFER_VIEW	= ( D3D12_INDIRECT_ARGUMENT_TYPE_DISPATCH + 1 ) ,
+        D3D12_INDIRECT_ARGUMENT_TYPE_INDEX_BUFFER_VIEW	= ( D3D12_INDIRECT_ARGUMENT_TYPE_VERTEX_BUFFER_VIEW + 1 ) ,
+        D3D12_INDIRECT_ARGUMENT_TYPE_CONSTANT	= ( D3D12_INDIRECT_ARGUMENT_TYPE_INDEX_BUFFER_VIEW + 1 ) ,
+        D3D12_INDIRECT_ARGUMENT_TYPE_CONSTANT_BUFFER_VIEW	= ( D3D12_INDIRECT_ARGUMENT_TYPE_CONSTANT + 1 ) ,
+        D3D12_INDIRECT_ARGUMENT_TYPE_SHADER_RESOURCE_VIEW	= ( D3D12_INDIRECT_ARGUMENT_TYPE_CONSTANT_BUFFER_VIEW + 1 ) ,
+        D3D12_INDIRECT_ARGUMENT_TYPE_UNORDERED_ACCESS_VIEW	= ( D3D12_INDIRECT_ARGUMENT_TYPE_SHADER_RESOURCE_VIEW + 1 ) ,
+        D3D12_INDIRECT_ARGUMENT_TYPE_DISPATCH_RAYS	= ( D3D12_INDIRECT_ARGUMENT_TYPE_UNORDERED_ACCESS_VIEW + 1 ) ,
+        D3D12_INDIRECT_ARGUMENT_TYPE_DISPATCH_MESH	= ( D3D12_INDIRECT_ARGUMENT_TYPE_DISPATCH_RAYS + 1 ) 
+    } 	D3D12_INDIRECT_ARGUMENT_TYPE;
+
+typedef struct D3D12_INDIRECT_ARGUMENT_DESC
+    {
+    D3D12_INDIRECT_ARGUMENT_TYPE Type;
+    union 
+        {
+        struct 
+            {
+            UINT Slot;
+            } 	VertexBuffer;
+        struct 
+            {
+            UINT RootParameterIndex;
+            UINT DestOffsetIn32BitValues;
+            UINT Num32BitValuesToSet;
+            } 	Constant;
+        struct 
+            {
+            UINT RootParameterIndex;
+            } 	ConstantBufferView;
+        struct 
+            {
+            UINT RootParameterIndex;
+            } 	ShaderResourceView;
+        struct 
+            {
+            UINT RootParameterIndex;
+            } 	UnorderedAccessView;
+        } 	;
+    } 	D3D12_INDIRECT_ARGUMENT_DESC;
+
+typedef struct D3D12_COMMAND_SIGNATURE_DESC
+    {
+    UINT ByteStride;
+    UINT NumArgumentDescs;
+    _Field_size_full_(NumArgumentDescs)  const D3D12_INDIRECT_ARGUMENT_DESC *pArgumentDescs;
+    UINT NodeMask;
+    } 	D3D12_COMMAND_SIGNATURE_DESC;
+
+
+
+
+extern RPC_IF_HANDLE __MIDL_itf_d3d12_0000_0003_v0_0_c_ifspec;
+extern RPC_IF_HANDLE __MIDL_itf_d3d12_0000_0003_v0_0_s_ifspec;
+
+#ifndef __ID3D12Pageable_INTERFACE_DEFINED__
+#define __ID3D12Pageable_INTERFACE_DEFINED__
+
+/* interface ID3D12Pageable */
+/* [unique][local][object][uuid] */ 
+
+
+EXTERN_C const IID IID_ID3D12Pageable;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("63ee58fb-1268-4835-86da-f008ce62f0d6")
+    ID3D12Pageable : public ID3D12DeviceChild
+    {
+    public:
+    };
+    
+    
+#else 	/* C style interface */
+
+    typedef struct ID3D12PageableVtbl
+    {
+        BEGIN_INTERFACE
+        
+        DECLSPEC_XFGVIRT(IUnknown, QueryInterface)
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            ID3D12Pageable * This,
+            REFIID riid,
+            _COM_Outptr_  void **ppvObject);
+        
+        DECLSPEC_XFGVIRT(IUnknown, AddRef)
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            ID3D12Pageable * This);
+        
+        DECLSPEC_XFGVIRT(IUnknown, Release)
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            ID3D12Pageable * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, GetPrivateData)
+        HRESULT ( STDMETHODCALLTYPE *GetPrivateData )( 
+            ID3D12Pageable * This,
+            _In_  REFGUID guid,
+            _Inout_  UINT *pDataSize,
+            _Out_writes_bytes_opt_( *pDataSize )  void *pData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, SetPrivateData)
+        HRESULT ( STDMETHODCALLTYPE *SetPrivateData )( 
+            ID3D12Pageable * This,
+            _In_  REFGUID guid,
+            _In_  UINT DataSize,
+            _In_reads_bytes_opt_( DataSize )  const void *pData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, SetPrivateDataInterface)
+        HRESULT ( STDMETHODCALLTYPE *SetPrivateDataInterface )( 
+            ID3D12Pageable * This,
+            _In_  REFGUID guid,
+            _In_opt_  const IUnknown *pData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, SetName)
+        HRESULT ( STDMETHODCALLTYPE *SetName )( 
+            ID3D12Pageable * This,
+            _In_z_  LPCWSTR Name);
+        
+        DECLSPEC_XFGVIRT(ID3D12DeviceChild, GetDevice)
+        HRESULT ( STDMETHODCALLTYPE *GetDevice )( 
+            ID3D12Pageable * This,
+            REFIID riid,
+            _COM_Outptr_opt_  void **ppvDevice);
+        
+        END_INTERFACE
+    } ID3D12PageableVtbl;
+
+    interface ID3D12Pageable
+    {
+        CONST_VTBL struct ID3D12PageableVtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define ID3D12Pageable_QueryInterface(This,riid,ppvObject)	\
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define ID3D12Pageable_AddRef(This)	\
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define ID3D12Pageable_Release(This)	\
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#define ID3D12Pageable_GetPrivateData(This,guid,pDataSize,pData)	\
+    ( (This)->lpVtbl -> GetPrivateData(This,guid,pDataSize,pData) ) 
+
+#define ID3D12Pageable_SetPrivateData(This,guid,DataSize,pData)	\
+    ( (This)->lpVtbl -> SetPrivateData(This,guid,DataSize,pData) ) 
+
+#define ID3D12Pageable_SetPrivateDataInterface(This,guid,pData)	\
+    ( (This)->lpVtbl -> SetPrivateDataInterface(This,guid,pData) ) 
+
+#define ID3D12Pageable_SetName(This,Name)	\
+    ( (This)->lpVtbl -> SetName(This,Name) ) 
+
+
+#define ID3D12Pageable_GetDevice(This,riid,ppvDevice)	\
+    ( (This)->lpVtbl -> GetDevice(This,riid,ppvDevice) ) 
+
+
+#endif /* COBJMACROS */
+
+
+#endif 	/* C style interface */
+
+
+
+
+#endif 	/* __ID3D12Pageable_INTERFACE_DEFINED__ */
+
+
+#ifndef __ID3D12Heap_INTERFACE_DEFINED__
+#define __ID3D12Heap_INTERFACE_DEFINED__
+
+/* interface ID3D12Heap */
+/* [unique][local][object][uuid] */ 
+
+
+EXTERN_C const IID IID_ID3D12Heap;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("6b3b2502-6e51-45b3-90ee-9884265e8df3")
+    ID3D12Heap : public ID3D12Pageable
+    {
+    public:
+#if defined(_MSC_VER) || !defined(_WIN32)
+        virtual D3D12_HEAP_DESC STDMETHODCALLTYPE GetDesc( void) = 0;
+#else
+        virtual D3D12_HEAP_DESC *STDMETHODCALLTYPE GetDesc( 
+            D3D12_HEAP_DESC * RetVal) = 0;
+#endif
+        
+    };
+    
+    
+#else 	/* C style interface */
+
+    typedef struct ID3D12HeapVtbl
+    {
+        BEGIN_INTERFACE
+        
+        DECLSPEC_XFGVIRT(IUnknown, QueryInterface)
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            ID3D12Heap * This,
+            REFIID riid,
+            _COM_Outptr_  void **ppvObject);
+        
+        DECLSPEC_XFGVIRT(IUnknown, AddRef)
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            ID3D12Heap * This);
+        
+        DECLSPEC_XFGVIRT(IUnknown, Release)
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            ID3D12Heap * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, GetPrivateData)
+        HRESULT ( STDMETHODCALLTYPE *GetPrivateData )( 
+            ID3D12Heap * This,
+            _In_  REFGUID guid,
+            _Inout_  UINT *pDataSize,
+            _Out_writes_bytes_opt_( *pDataSize )  void *pData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, SetPrivateData)
+        HRESULT ( STDMETHODCALLTYPE *SetPrivateData )( 
+            ID3D12Heap * This,
+            _In_  REFGUID guid,
+            _In_  UINT DataSize,
+            _In_reads_bytes_opt_( DataSize )  const void *pData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, SetPrivateDataInterface)
+        HRESULT ( STDMETHODCALLTYPE *SetPrivateDataInterface )( 
+            ID3D12Heap * This,
+            _In_  REFGUID guid,
+            _In_opt_  const IUnknown *pData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, SetName)
+        HRESULT ( STDMETHODCALLTYPE *SetName )( 
+            ID3D12Heap * This,
+            _In_z_  LPCWSTR Name);
+        
+        DECLSPEC_XFGVIRT(ID3D12DeviceChild, GetDevice)
+        HRESULT ( STDMETHODCALLTYPE *GetDevice )( 
+            ID3D12Heap * This,
+            REFIID riid,
+            _COM_Outptr_opt_  void **ppvDevice);
+        
+        DECLSPEC_XFGVIRT(ID3D12Heap, GetDesc)
+#if !defined(_WIN32)
+        D3D12_HEAP_DESC ( STDMETHODCALLTYPE *GetDesc )( 
+            ID3D12Heap * This);
+        
+#else
+        D3D12_HEAP_DESC *( STDMETHODCALLTYPE *GetDesc )( 
+            ID3D12Heap * This,
+            D3D12_HEAP_DESC * RetVal);
+        
+#endif
+        
+        END_INTERFACE
+    } ID3D12HeapVtbl;
+
+    interface ID3D12Heap
+    {
+        CONST_VTBL struct ID3D12HeapVtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define ID3D12Heap_QueryInterface(This,riid,ppvObject)	\
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define ID3D12Heap_AddRef(This)	\
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define ID3D12Heap_Release(This)	\
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#define ID3D12Heap_GetPrivateData(This,guid,pDataSize,pData)	\
+    ( (This)->lpVtbl -> GetPrivateData(This,guid,pDataSize,pData) ) 
+
+#define ID3D12Heap_SetPrivateData(This,guid,DataSize,pData)	\
+    ( (This)->lpVtbl -> SetPrivateData(This,guid,DataSize,pData) ) 
+
+#define ID3D12Heap_SetPrivateDataInterface(This,guid,pData)	\
+    ( (This)->lpVtbl -> SetPrivateDataInterface(This,guid,pData) ) 
+
+#define ID3D12Heap_SetName(This,Name)	\
+    ( (This)->lpVtbl -> SetName(This,Name) ) 
+
+
+#define ID3D12Heap_GetDevice(This,riid,ppvDevice)	\
+    ( (This)->lpVtbl -> GetDevice(This,riid,ppvDevice) ) 
+
+
+#if !defined(_WIN32)
+
+#define ID3D12Heap_GetDesc(This)	\
+    ( (This)->lpVtbl -> GetDesc(This) ) 
+#else
+#define ID3D12Heap_GetDesc(This,RetVal)	\
+    ( (This)->lpVtbl -> GetDesc(This,RetVal) ) 
+#endif
+
+#endif /* COBJMACROS */
+
+
+#endif 	/* C style interface */
+
+
+
+
+#endif 	/* __ID3D12Heap_INTERFACE_DEFINED__ */
+
+
+#ifndef __ID3D12Resource_INTERFACE_DEFINED__
+#define __ID3D12Resource_INTERFACE_DEFINED__
+
+/* interface ID3D12Resource */
+/* [unique][local][object][uuid] */ 
+
+
+EXTERN_C const IID IID_ID3D12Resource;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("696442be-a72e-4059-bc79-5b5c98040fad")
+    ID3D12Resource : public ID3D12Pageable
+    {
+    public:
+        virtual HRESULT STDMETHODCALLTYPE Map( 
+            UINT Subresource,
+            _In_opt_  const D3D12_RANGE *pReadRange,
+            _Outptr_opt_result_bytebuffer_(_Inexpressible_("Dependent on resource"))  void **ppData) = 0;
+        
+        virtual void STDMETHODCALLTYPE Unmap( 
+            UINT Subresource,
+            _In_opt_  const D3D12_RANGE *pWrittenRange) = 0;
+        
+#if defined(_MSC_VER) || !defined(_WIN32)
+        virtual D3D12_RESOURCE_DESC STDMETHODCALLTYPE GetDesc( void) = 0;
+#else
+        virtual D3D12_RESOURCE_DESC *STDMETHODCALLTYPE GetDesc( 
+            D3D12_RESOURCE_DESC * RetVal) = 0;
+#endif
+        
+        virtual D3D12_GPU_VIRTUAL_ADDRESS STDMETHODCALLTYPE GetGPUVirtualAddress( void) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE WriteToSubresource( 
+            UINT DstSubresource,
+            _In_opt_  const D3D12_BOX *pDstBox,
+            _In_  const void *pSrcData,
+            UINT SrcRowPitch,
+            UINT SrcDepthPitch) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE ReadFromSubresource( 
+            _Out_  void *pDstData,
+            UINT DstRowPitch,
+            UINT DstDepthPitch,
+            UINT SrcSubresource,
+            _In_opt_  const D3D12_BOX *pSrcBox) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE GetHeapProperties( 
+            _Out_opt_  D3D12_HEAP_PROPERTIES *pHeapProperties,
+            _Out_opt_  D3D12_HEAP_FLAGS *pHeapFlags) = 0;
+        
+    };
+    
+    
+#else 	/* C style interface */
+
+    typedef struct ID3D12ResourceVtbl
+    {
+        BEGIN_INTERFACE
+        
+        DECLSPEC_XFGVIRT(IUnknown, QueryInterface)
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            ID3D12Resource * This,
+            REFIID riid,
+            _COM_Outptr_  void **ppvObject);
+        
+        DECLSPEC_XFGVIRT(IUnknown, AddRef)
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            ID3D12Resource * This);
+        
+        DECLSPEC_XFGVIRT(IUnknown, Release)
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            ID3D12Resource * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, GetPrivateData)
+        HRESULT ( STDMETHODCALLTYPE *GetPrivateData )( 
+            ID3D12Resource * This,
+            _In_  REFGUID guid,
+            _Inout_  UINT *pDataSize,
+            _Out_writes_bytes_opt_( *pDataSize )  void *pData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, SetPrivateData)
+        HRESULT ( STDMETHODCALLTYPE *SetPrivateData )( 
+            ID3D12Resource * This,
+            _In_  REFGUID guid,
+            _In_  UINT DataSize,
+            _In_reads_bytes_opt_( DataSize )  const void *pData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, SetPrivateDataInterface)
+        HRESULT ( STDMETHODCALLTYPE *SetPrivateDataInterface )( 
+            ID3D12Resource * This,
+            _In_  REFGUID guid,
+            _In_opt_  const IUnknown *pData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, SetName)
+        HRESULT ( STDMETHODCALLTYPE *SetName )( 
+            ID3D12Resource * This,
+            _In_z_  LPCWSTR Name);
+        
+        DECLSPEC_XFGVIRT(ID3D12DeviceChild, GetDevice)
+        HRESULT ( STDMETHODCALLTYPE *GetDevice )( 
+            ID3D12Resource * This,
+            REFIID riid,
+            _COM_Outptr_opt_  void **ppvDevice);
+        
+        DECLSPEC_XFGVIRT(ID3D12Resource, Map)
+        HRESULT ( STDMETHODCALLTYPE *Map )( 
+            ID3D12Resource * This,
+            UINT Subresource,
+            _In_opt_  const D3D12_RANGE *pReadRange,
+            _Outptr_opt_result_bytebuffer_(_Inexpressible_("Dependent on resource"))  void **ppData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Resource, Unmap)
+        void ( STDMETHODCALLTYPE *Unmap )( 
+            ID3D12Resource * This,
+            UINT Subresource,
+            _In_opt_  const D3D12_RANGE *pWrittenRange);
+        
+        DECLSPEC_XFGVIRT(ID3D12Resource, GetDesc)
+#if !defined(_WIN32)
+        D3D12_RESOURCE_DESC ( STDMETHODCALLTYPE *GetDesc )( 
+            ID3D12Resource * This);
+        
+#else
+        D3D12_RESOURCE_DESC *( STDMETHODCALLTYPE *GetDesc )( 
+            ID3D12Resource * This,
+            D3D12_RESOURCE_DESC * RetVal);
+        
+#endif
+        
+        DECLSPEC_XFGVIRT(ID3D12Resource, GetGPUVirtualAddress)
+        D3D12_GPU_VIRTUAL_ADDRESS ( STDMETHODCALLTYPE *GetGPUVirtualAddress )( 
+            ID3D12Resource * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12Resource, WriteToSubresource)
+        HRESULT ( STDMETHODCALLTYPE *WriteToSubresource )( 
+            ID3D12Resource * This,
+            UINT DstSubresource,
+            _In_opt_  const D3D12_BOX *pDstBox,
+            _In_  const void *pSrcData,
+            UINT SrcRowPitch,
+            UINT SrcDepthPitch);
+        
+        DECLSPEC_XFGVIRT(ID3D12Resource, ReadFromSubresource)
+        HRESULT ( STDMETHODCALLTYPE *ReadFromSubresource )( 
+            ID3D12Resource * This,
+            _Out_  void *pDstData,
+            UINT DstRowPitch,
+            UINT DstDepthPitch,
+            UINT SrcSubresource,
+            _In_opt_  const D3D12_BOX *pSrcBox);
+        
+        DECLSPEC_XFGVIRT(ID3D12Resource, GetHeapProperties)
+        HRESULT ( STDMETHODCALLTYPE *GetHeapProperties )( 
+            ID3D12Resource * This,
+            _Out_opt_  D3D12_HEAP_PROPERTIES *pHeapProperties,
+            _Out_opt_  D3D12_HEAP_FLAGS *pHeapFlags);
+        
+        END_INTERFACE
+    } ID3D12ResourceVtbl;
+
+    interface ID3D12Resource
+    {
+        CONST_VTBL struct ID3D12ResourceVtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define ID3D12Resource_QueryInterface(This,riid,ppvObject)	\
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define ID3D12Resource_AddRef(This)	\
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define ID3D12Resource_Release(This)	\
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#define ID3D12Resource_GetPrivateData(This,guid,pDataSize,pData)	\
+    ( (This)->lpVtbl -> GetPrivateData(This,guid,pDataSize,pData) ) 
+
+#define ID3D12Resource_SetPrivateData(This,guid,DataSize,pData)	\
+    ( (This)->lpVtbl -> SetPrivateData(This,guid,DataSize,pData) ) 
+
+#define ID3D12Resource_SetPrivateDataInterface(This,guid,pData)	\
+    ( (This)->lpVtbl -> SetPrivateDataInterface(This,guid,pData) ) 
+
+#define ID3D12Resource_SetName(This,Name)	\
+    ( (This)->lpVtbl -> SetName(This,Name) ) 
+
+
+#define ID3D12Resource_GetDevice(This,riid,ppvDevice)	\
+    ( (This)->lpVtbl -> GetDevice(This,riid,ppvDevice) ) 
+
+
+
+#define ID3D12Resource_Map(This,Subresource,pReadRange,ppData)	\
+    ( (This)->lpVtbl -> Map(This,Subresource,pReadRange,ppData) ) 
+
+#define ID3D12Resource_Unmap(This,Subresource,pWrittenRange)	\
+    ( (This)->lpVtbl -> Unmap(This,Subresource,pWrittenRange) ) 
+#if !defined(_WIN32)
+
+#define ID3D12Resource_GetDesc(This)	\
+    ( (This)->lpVtbl -> GetDesc(This) ) 
+#else
+#define ID3D12Resource_GetDesc(This,RetVal)	\
+    ( (This)->lpVtbl -> GetDesc(This,RetVal) ) 
+#endif
+
+#define ID3D12Resource_GetGPUVirtualAddress(This)	\
+    ( (This)->lpVtbl -> GetGPUVirtualAddress(This) ) 
+
+#define ID3D12Resource_WriteToSubresource(This,DstSubresource,pDstBox,pSrcData,SrcRowPitch,SrcDepthPitch)	\
+    ( (This)->lpVtbl -> WriteToSubresource(This,DstSubresource,pDstBox,pSrcData,SrcRowPitch,SrcDepthPitch) ) 
+
+#define ID3D12Resource_ReadFromSubresource(This,pDstData,DstRowPitch,DstDepthPitch,SrcSubresource,pSrcBox)	\
+    ( (This)->lpVtbl -> ReadFromSubresource(This,pDstData,DstRowPitch,DstDepthPitch,SrcSubresource,pSrcBox) ) 
+
+#define ID3D12Resource_GetHeapProperties(This,pHeapProperties,pHeapFlags)	\
+    ( (This)->lpVtbl -> GetHeapProperties(This,pHeapProperties,pHeapFlags) ) 
+
+#endif /* COBJMACROS */
+
+
+#endif 	/* C style interface */
+
+
+
+
+#endif 	/* __ID3D12Resource_INTERFACE_DEFINED__ */
+
+
+#ifndef __ID3D12CommandAllocator_INTERFACE_DEFINED__
+#define __ID3D12CommandAllocator_INTERFACE_DEFINED__
+
+/* interface ID3D12CommandAllocator */
+/* [unique][local][object][uuid] */ 
+
+
+EXTERN_C const IID IID_ID3D12CommandAllocator;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("6102dee4-af59-4b09-b999-b44d73f09b24")
+    ID3D12CommandAllocator : public ID3D12Pageable
+    {
+    public:
+        virtual HRESULT STDMETHODCALLTYPE Reset( void) = 0;
+        
+    };
+    
+    
+#else 	/* C style interface */
+
+    typedef struct ID3D12CommandAllocatorVtbl
+    {
+        BEGIN_INTERFACE
+        
+        DECLSPEC_XFGVIRT(IUnknown, QueryInterface)
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            ID3D12CommandAllocator * This,
+            REFIID riid,
+            _COM_Outptr_  void **ppvObject);
+        
+        DECLSPEC_XFGVIRT(IUnknown, AddRef)
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            ID3D12CommandAllocator * This);
+        
+        DECLSPEC_XFGVIRT(IUnknown, Release)
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            ID3D12CommandAllocator * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, GetPrivateData)
+        HRESULT ( STDMETHODCALLTYPE *GetPrivateData )( 
+            ID3D12CommandAllocator * This,
+            _In_  REFGUID guid,
+            _Inout_  UINT *pDataSize,
+            _Out_writes_bytes_opt_( *pDataSize )  void *pData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, SetPrivateData)
+        HRESULT ( STDMETHODCALLTYPE *SetPrivateData )( 
+            ID3D12CommandAllocator * This,
+            _In_  REFGUID guid,
+            _In_  UINT DataSize,
+            _In_reads_bytes_opt_( DataSize )  const void *pData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, SetPrivateDataInterface)
+        HRESULT ( STDMETHODCALLTYPE *SetPrivateDataInterface )( 
+            ID3D12CommandAllocator * This,
+            _In_  REFGUID guid,
+            _In_opt_  const IUnknown *pData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, SetName)
+        HRESULT ( STDMETHODCALLTYPE *SetName )( 
+            ID3D12CommandAllocator * This,
+            _In_z_  LPCWSTR Name);
+        
+        DECLSPEC_XFGVIRT(ID3D12DeviceChild, GetDevice)
+        HRESULT ( STDMETHODCALLTYPE *GetDevice )( 
+            ID3D12CommandAllocator * This,
+            REFIID riid,
+            _COM_Outptr_opt_  void **ppvDevice);
+        
+        DECLSPEC_XFGVIRT(ID3D12CommandAllocator, Reset)
+        HRESULT ( STDMETHODCALLTYPE *Reset )( 
+            ID3D12CommandAllocator * This);
+        
+        END_INTERFACE
+    } ID3D12CommandAllocatorVtbl;
+
+    interface ID3D12CommandAllocator
+    {
+        CONST_VTBL struct ID3D12CommandAllocatorVtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define ID3D12CommandAllocator_QueryInterface(This,riid,ppvObject)	\
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define ID3D12CommandAllocator_AddRef(This)	\
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define ID3D12CommandAllocator_Release(This)	\
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#define ID3D12CommandAllocator_GetPrivateData(This,guid,pDataSize,pData)	\
+    ( (This)->lpVtbl -> GetPrivateData(This,guid,pDataSize,pData) ) 
+
+#define ID3D12CommandAllocator_SetPrivateData(This,guid,DataSize,pData)	\
+    ( (This)->lpVtbl -> SetPrivateData(This,guid,DataSize,pData) ) 
+
+#define ID3D12CommandAllocator_SetPrivateDataInterface(This,guid,pData)	\
+    ( (This)->lpVtbl -> SetPrivateDataInterface(This,guid,pData) ) 
+
+#define ID3D12CommandAllocator_SetName(This,Name)	\
+    ( (This)->lpVtbl -> SetName(This,Name) ) 
+
+
+#define ID3D12CommandAllocator_GetDevice(This,riid,ppvDevice)	\
+    ( (This)->lpVtbl -> GetDevice(This,riid,ppvDevice) ) 
+
+
+
+#define ID3D12CommandAllocator_Reset(This)	\
+    ( (This)->lpVtbl -> Reset(This) ) 
+
+#endif /* COBJMACROS */
+
+
+#endif 	/* C style interface */
+
+
+
+
+#endif 	/* __ID3D12CommandAllocator_INTERFACE_DEFINED__ */
+
+
+#ifndef __ID3D12Fence_INTERFACE_DEFINED__
+#define __ID3D12Fence_INTERFACE_DEFINED__
+
+/* interface ID3D12Fence */
+/* [unique][local][object][uuid] */ 
+
+
+EXTERN_C const IID IID_ID3D12Fence;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("0a753dcf-c4d8-4b91-adf6-be5a60d95a76")
+    ID3D12Fence : public ID3D12Pageable
+    {
+    public:
+        virtual UINT64 STDMETHODCALLTYPE GetCompletedValue( void) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE SetEventOnCompletion( 
+            UINT64 Value,
+            HANDLE hEvent) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE Signal( 
+            UINT64 Value) = 0;
+        
+    };
+    
+    
+#else 	/* C style interface */
+
+    typedef struct ID3D12FenceVtbl
+    {
+        BEGIN_INTERFACE
+        
+        DECLSPEC_XFGVIRT(IUnknown, QueryInterface)
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            ID3D12Fence * This,
+            REFIID riid,
+            _COM_Outptr_  void **ppvObject);
+        
+        DECLSPEC_XFGVIRT(IUnknown, AddRef)
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            ID3D12Fence * This);
+        
+        DECLSPEC_XFGVIRT(IUnknown, Release)
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            ID3D12Fence * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, GetPrivateData)
+        HRESULT ( STDMETHODCALLTYPE *GetPrivateData )( 
+            ID3D12Fence * This,
+            _In_  REFGUID guid,
+            _Inout_  UINT *pDataSize,
+            _Out_writes_bytes_opt_( *pDataSize )  void *pData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, SetPrivateData)
+        HRESULT ( STDMETHODCALLTYPE *SetPrivateData )( 
+            ID3D12Fence * This,
+            _In_  REFGUID guid,
+            _In_  UINT DataSize,
+            _In_reads_bytes_opt_( DataSize )  const void *pData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, SetPrivateDataInterface)
+        HRESULT ( STDMETHODCALLTYPE *SetPrivateDataInterface )( 
+            ID3D12Fence * This,
+            _In_  REFGUID guid,
+            _In_opt_  const IUnknown *pData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, SetName)
+        HRESULT ( STDMETHODCALLTYPE *SetName )( 
+            ID3D12Fence * This,
+            _In_z_  LPCWSTR Name);
+        
+        DECLSPEC_XFGVIRT(ID3D12DeviceChild, GetDevice)
+        HRESULT ( STDMETHODCALLTYPE *GetDevice )( 
+            ID3D12Fence * This,
+            REFIID riid,
+            _COM_Outptr_opt_  void **ppvDevice);
+        
+        DECLSPEC_XFGVIRT(ID3D12Fence, GetCompletedValue)
+        UINT64 ( STDMETHODCALLTYPE *GetCompletedValue )( 
+            ID3D12Fence * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12Fence, SetEventOnCompletion)
+        HRESULT ( STDMETHODCALLTYPE *SetEventOnCompletion )( 
+            ID3D12Fence * This,
+            UINT64 Value,
+            HANDLE hEvent);
+        
+        DECLSPEC_XFGVIRT(ID3D12Fence, Signal)
+        HRESULT ( STDMETHODCALLTYPE *Signal )( 
+            ID3D12Fence * This,
+            UINT64 Value);
+        
+        END_INTERFACE
+    } ID3D12FenceVtbl;
+
+    interface ID3D12Fence
+    {
+        CONST_VTBL struct ID3D12FenceVtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define ID3D12Fence_QueryInterface(This,riid,ppvObject)	\
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define ID3D12Fence_AddRef(This)	\
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define ID3D12Fence_Release(This)	\
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#define ID3D12Fence_GetPrivateData(This,guid,pDataSize,pData)	\
+    ( (This)->lpVtbl -> GetPrivateData(This,guid,pDataSize,pData) ) 
+
+#define ID3D12Fence_SetPrivateData(This,guid,DataSize,pData)	\
+    ( (This)->lpVtbl -> SetPrivateData(This,guid,DataSize,pData) ) 
+
+#define ID3D12Fence_SetPrivateDataInterface(This,guid,pData)	\
+    ( (This)->lpVtbl -> SetPrivateDataInterface(This,guid,pData) ) 
+
+#define ID3D12Fence_SetName(This,Name)	\
+    ( (This)->lpVtbl -> SetName(This,Name) ) 
+
+
+#define ID3D12Fence_GetDevice(This,riid,ppvDevice)	\
+    ( (This)->lpVtbl -> GetDevice(This,riid,ppvDevice) ) 
+
+
+
+#define ID3D12Fence_GetCompletedValue(This)	\
+    ( (This)->lpVtbl -> GetCompletedValue(This) ) 
+
+#define ID3D12Fence_SetEventOnCompletion(This,Value,hEvent)	\
+    ( (This)->lpVtbl -> SetEventOnCompletion(This,Value,hEvent) ) 
+
+#define ID3D12Fence_Signal(This,Value)	\
+    ( (This)->lpVtbl -> Signal(This,Value) ) 
+
+#endif /* COBJMACROS */
+
+
+#endif 	/* C style interface */
+
+
+
+
+#endif 	/* __ID3D12Fence_INTERFACE_DEFINED__ */
+
+
+#ifndef __ID3D12Fence1_INTERFACE_DEFINED__
+#define __ID3D12Fence1_INTERFACE_DEFINED__
+
+/* interface ID3D12Fence1 */
+/* [unique][local][object][uuid] */ 
+
+
+EXTERN_C const IID IID_ID3D12Fence1;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("433685fe-e22b-4ca0-a8db-b5b4f4dd0e4a")
+    ID3D12Fence1 : public ID3D12Fence
+    {
+    public:
+        virtual D3D12_FENCE_FLAGS STDMETHODCALLTYPE GetCreationFlags( void) = 0;
+        
+    };
+    
+    
+#else 	/* C style interface */
+
+    typedef struct ID3D12Fence1Vtbl
+    {
+        BEGIN_INTERFACE
+        
+        DECLSPEC_XFGVIRT(IUnknown, QueryInterface)
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            ID3D12Fence1 * This,
+            REFIID riid,
+            _COM_Outptr_  void **ppvObject);
+        
+        DECLSPEC_XFGVIRT(IUnknown, AddRef)
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            ID3D12Fence1 * This);
+        
+        DECLSPEC_XFGVIRT(IUnknown, Release)
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            ID3D12Fence1 * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, GetPrivateData)
+        HRESULT ( STDMETHODCALLTYPE *GetPrivateData )( 
+            ID3D12Fence1 * This,
+            _In_  REFGUID guid,
+            _Inout_  UINT *pDataSize,
+            _Out_writes_bytes_opt_( *pDataSize )  void *pData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, SetPrivateData)
+        HRESULT ( STDMETHODCALLTYPE *SetPrivateData )( 
+            ID3D12Fence1 * This,
+            _In_  REFGUID guid,
+            _In_  UINT DataSize,
+            _In_reads_bytes_opt_( DataSize )  const void *pData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, SetPrivateDataInterface)
+        HRESULT ( STDMETHODCALLTYPE *SetPrivateDataInterface )( 
+            ID3D12Fence1 * This,
+            _In_  REFGUID guid,
+            _In_opt_  const IUnknown *pData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, SetName)
+        HRESULT ( STDMETHODCALLTYPE *SetName )( 
+            ID3D12Fence1 * This,
+            _In_z_  LPCWSTR Name);
+        
+        DECLSPEC_XFGVIRT(ID3D12DeviceChild, GetDevice)
+        HRESULT ( STDMETHODCALLTYPE *GetDevice )( 
+            ID3D12Fence1 * This,
+            REFIID riid,
+            _COM_Outptr_opt_  void **ppvDevice);
+        
+        DECLSPEC_XFGVIRT(ID3D12Fence, GetCompletedValue)
+        UINT64 ( STDMETHODCALLTYPE *GetCompletedValue )( 
+            ID3D12Fence1 * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12Fence, SetEventOnCompletion)
+        HRESULT ( STDMETHODCALLTYPE *SetEventOnCompletion )( 
+            ID3D12Fence1 * This,
+            UINT64 Value,
+            HANDLE hEvent);
+        
+        DECLSPEC_XFGVIRT(ID3D12Fence, Signal)
+        HRESULT ( STDMETHODCALLTYPE *Signal )( 
+            ID3D12Fence1 * This,
+            UINT64 Value);
+        
+        DECLSPEC_XFGVIRT(ID3D12Fence1, GetCreationFlags)
+        D3D12_FENCE_FLAGS ( STDMETHODCALLTYPE *GetCreationFlags )( 
+            ID3D12Fence1 * This);
+        
+        END_INTERFACE
+    } ID3D12Fence1Vtbl;
+
+    interface ID3D12Fence1
+    {
+        CONST_VTBL struct ID3D12Fence1Vtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define ID3D12Fence1_QueryInterface(This,riid,ppvObject)	\
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define ID3D12Fence1_AddRef(This)	\
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define ID3D12Fence1_Release(This)	\
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#define ID3D12Fence1_GetPrivateData(This,guid,pDataSize,pData)	\
+    ( (This)->lpVtbl -> GetPrivateData(This,guid,pDataSize,pData) ) 
+
+#define ID3D12Fence1_SetPrivateData(This,guid,DataSize,pData)	\
+    ( (This)->lpVtbl -> SetPrivateData(This,guid,DataSize,pData) ) 
+
+#define ID3D12Fence1_SetPrivateDataInterface(This,guid,pData)	\
+    ( (This)->lpVtbl -> SetPrivateDataInterface(This,guid,pData) ) 
+
+#define ID3D12Fence1_SetName(This,Name)	\
+    ( (This)->lpVtbl -> SetName(This,Name) ) 
+
+
+#define ID3D12Fence1_GetDevice(This,riid,ppvDevice)	\
+    ( (This)->lpVtbl -> GetDevice(This,riid,ppvDevice) ) 
+
+
+
+#define ID3D12Fence1_GetCompletedValue(This)	\
+    ( (This)->lpVtbl -> GetCompletedValue(This) ) 
+
+#define ID3D12Fence1_SetEventOnCompletion(This,Value,hEvent)	\
+    ( (This)->lpVtbl -> SetEventOnCompletion(This,Value,hEvent) ) 
+
+#define ID3D12Fence1_Signal(This,Value)	\
+    ( (This)->lpVtbl -> Signal(This,Value) ) 
+
+
+#define ID3D12Fence1_GetCreationFlags(This)	\
+    ( (This)->lpVtbl -> GetCreationFlags(This) ) 
+
+#endif /* COBJMACROS */
+
+
+#endif 	/* C style interface */
+
+
+
+
+#endif 	/* __ID3D12Fence1_INTERFACE_DEFINED__ */
+
+
+#ifndef __ID3D12PipelineState_INTERFACE_DEFINED__
+#define __ID3D12PipelineState_INTERFACE_DEFINED__
+
+/* interface ID3D12PipelineState */
+/* [unique][local][object][uuid] */ 
+
+
+EXTERN_C const IID IID_ID3D12PipelineState;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("765a30f3-f624-4c6f-a828-ace948622445")
+    ID3D12PipelineState : public ID3D12Pageable
+    {
+    public:
+        virtual HRESULT STDMETHODCALLTYPE GetCachedBlob( 
+            _COM_Outptr_  ID3DBlob **ppBlob) = 0;
+        
+    };
+    
+    
+#else 	/* C style interface */
+
+    typedef struct ID3D12PipelineStateVtbl
+    {
+        BEGIN_INTERFACE
+        
+        DECLSPEC_XFGVIRT(IUnknown, QueryInterface)
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            ID3D12PipelineState * This,
+            REFIID riid,
+            _COM_Outptr_  void **ppvObject);
+        
+        DECLSPEC_XFGVIRT(IUnknown, AddRef)
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            ID3D12PipelineState * This);
+        
+        DECLSPEC_XFGVIRT(IUnknown, Release)
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            ID3D12PipelineState * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, GetPrivateData)
+        HRESULT ( STDMETHODCALLTYPE *GetPrivateData )( 
+            ID3D12PipelineState * This,
+            _In_  REFGUID guid,
+            _Inout_  UINT *pDataSize,
+            _Out_writes_bytes_opt_( *pDataSize )  void *pData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, SetPrivateData)
+        HRESULT ( STDMETHODCALLTYPE *SetPrivateData )( 
+            ID3D12PipelineState * This,
+            _In_  REFGUID guid,
+            _In_  UINT DataSize,
+            _In_reads_bytes_opt_( DataSize )  const void *pData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, SetPrivateDataInterface)
+        HRESULT ( STDMETHODCALLTYPE *SetPrivateDataInterface )( 
+            ID3D12PipelineState * This,
+            _In_  REFGUID guid,
+            _In_opt_  const IUnknown *pData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, SetName)
+        HRESULT ( STDMETHODCALLTYPE *SetName )( 
+            ID3D12PipelineState * This,
+            _In_z_  LPCWSTR Name);
+        
+        DECLSPEC_XFGVIRT(ID3D12DeviceChild, GetDevice)
+        HRESULT ( STDMETHODCALLTYPE *GetDevice )( 
+            ID3D12PipelineState * This,
+            REFIID riid,
+            _COM_Outptr_opt_  void **ppvDevice);
+        
+        DECLSPEC_XFGVIRT(ID3D12PipelineState, GetCachedBlob)
+        HRESULT ( STDMETHODCALLTYPE *GetCachedBlob )( 
+            ID3D12PipelineState * This,
+            _COM_Outptr_  ID3DBlob **ppBlob);
+        
+        END_INTERFACE
+    } ID3D12PipelineStateVtbl;
+
+    interface ID3D12PipelineState
+    {
+        CONST_VTBL struct ID3D12PipelineStateVtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define ID3D12PipelineState_QueryInterface(This,riid,ppvObject)	\
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define ID3D12PipelineState_AddRef(This)	\
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define ID3D12PipelineState_Release(This)	\
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#define ID3D12PipelineState_GetPrivateData(This,guid,pDataSize,pData)	\
+    ( (This)->lpVtbl -> GetPrivateData(This,guid,pDataSize,pData) ) 
+
+#define ID3D12PipelineState_SetPrivateData(This,guid,DataSize,pData)	\
+    ( (This)->lpVtbl -> SetPrivateData(This,guid,DataSize,pData) ) 
+
+#define ID3D12PipelineState_SetPrivateDataInterface(This,guid,pData)	\
+    ( (This)->lpVtbl -> SetPrivateDataInterface(This,guid,pData) ) 
+
+#define ID3D12PipelineState_SetName(This,Name)	\
+    ( (This)->lpVtbl -> SetName(This,Name) ) 
+
+
+#define ID3D12PipelineState_GetDevice(This,riid,ppvDevice)	\
+    ( (This)->lpVtbl -> GetDevice(This,riid,ppvDevice) ) 
+
+
+
+#define ID3D12PipelineState_GetCachedBlob(This,ppBlob)	\
+    ( (This)->lpVtbl -> GetCachedBlob(This,ppBlob) ) 
+
+#endif /* COBJMACROS */
+
+
+#endif 	/* C style interface */
+
+
+
+
+#endif 	/* __ID3D12PipelineState_INTERFACE_DEFINED__ */
+
+
+#ifndef __ID3D12DescriptorHeap_INTERFACE_DEFINED__
+#define __ID3D12DescriptorHeap_INTERFACE_DEFINED__
+
+/* interface ID3D12DescriptorHeap */
+/* [unique][local][object][uuid] */ 
+
+
+EXTERN_C const IID IID_ID3D12DescriptorHeap;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("8efb471d-616c-4f49-90f7-127bb763fa51")
+    ID3D12DescriptorHeap : public ID3D12Pageable
+    {
+    public:
+#if defined(_MSC_VER) || !defined(_WIN32)
+        virtual D3D12_DESCRIPTOR_HEAP_DESC STDMETHODCALLTYPE GetDesc( void) = 0;
+#else
+        virtual D3D12_DESCRIPTOR_HEAP_DESC *STDMETHODCALLTYPE GetDesc( 
+            D3D12_DESCRIPTOR_HEAP_DESC * RetVal) = 0;
+#endif
+        
+#if defined(_MSC_VER) || !defined(_WIN32)
+        virtual D3D12_CPU_DESCRIPTOR_HANDLE STDMETHODCALLTYPE GetCPUDescriptorHandleForHeapStart( void) = 0;
+#else
+        virtual D3D12_CPU_DESCRIPTOR_HANDLE *STDMETHODCALLTYPE GetCPUDescriptorHandleForHeapStart( 
+            D3D12_CPU_DESCRIPTOR_HANDLE * RetVal) = 0;
+#endif
+        
+#if defined(_MSC_VER) || !defined(_WIN32)
+        virtual D3D12_GPU_DESCRIPTOR_HANDLE STDMETHODCALLTYPE GetGPUDescriptorHandleForHeapStart( void) = 0;
+#else
+        virtual D3D12_GPU_DESCRIPTOR_HANDLE *STDMETHODCALLTYPE GetGPUDescriptorHandleForHeapStart( 
+            D3D12_GPU_DESCRIPTOR_HANDLE * RetVal) = 0;
+#endif
+        
+    };
+    
+    
+#else 	/* C style interface */
+
+    typedef struct ID3D12DescriptorHeapVtbl
+    {
+        BEGIN_INTERFACE
+        
+        DECLSPEC_XFGVIRT(IUnknown, QueryInterface)
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            ID3D12DescriptorHeap * This,
+            REFIID riid,
+            _COM_Outptr_  void **ppvObject);
+        
+        DECLSPEC_XFGVIRT(IUnknown, AddRef)
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            ID3D12DescriptorHeap * This);
+        
+        DECLSPEC_XFGVIRT(IUnknown, Release)
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            ID3D12DescriptorHeap * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, GetPrivateData)
+        HRESULT ( STDMETHODCALLTYPE *GetPrivateData )( 
+            ID3D12DescriptorHeap * This,
+            _In_  REFGUID guid,
+            _Inout_  UINT *pDataSize,
+            _Out_writes_bytes_opt_( *pDataSize )  void *pData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, SetPrivateData)
+        HRESULT ( STDMETHODCALLTYPE *SetPrivateData )( 
+            ID3D12DescriptorHeap * This,
+            _In_  REFGUID guid,
+            _In_  UINT DataSize,
+            _In_reads_bytes_opt_( DataSize )  const void *pData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, SetPrivateDataInterface)
+        HRESULT ( STDMETHODCALLTYPE *SetPrivateDataInterface )( 
+            ID3D12DescriptorHeap * This,
+            _In_  REFGUID guid,
+            _In_opt_  const IUnknown *pData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, SetName)
+        HRESULT ( STDMETHODCALLTYPE *SetName )( 
+            ID3D12DescriptorHeap * This,
+            _In_z_  LPCWSTR Name);
+        
+        DECLSPEC_XFGVIRT(ID3D12DeviceChild, GetDevice)
+        HRESULT ( STDMETHODCALLTYPE *GetDevice )( 
+            ID3D12DescriptorHeap * This,
+            REFIID riid,
+            _COM_Outptr_opt_  void **ppvDevice);
+        
+        DECLSPEC_XFGVIRT(ID3D12DescriptorHeap, GetDesc)
+#if !defined(_WIN32)
+        D3D12_DESCRIPTOR_HEAP_DESC ( STDMETHODCALLTYPE *GetDesc )( 
+            ID3D12DescriptorHeap * This);
+        
+#else
+        D3D12_DESCRIPTOR_HEAP_DESC *( STDMETHODCALLTYPE *GetDesc )( 
+            ID3D12DescriptorHeap * This,
+            D3D12_DESCRIPTOR_HEAP_DESC * RetVal);
+        
+#endif
+        
+        DECLSPEC_XFGVIRT(ID3D12DescriptorHeap, GetCPUDescriptorHandleForHeapStart)
+#if !defined(_WIN32)
+        D3D12_CPU_DESCRIPTOR_HANDLE ( STDMETHODCALLTYPE *GetCPUDescriptorHandleForHeapStart )( 
+            ID3D12DescriptorHeap * This);
+        
+#else
+        D3D12_CPU_DESCRIPTOR_HANDLE *( STDMETHODCALLTYPE *GetCPUDescriptorHandleForHeapStart )( 
+            ID3D12DescriptorHeap * This,
+            D3D12_CPU_DESCRIPTOR_HANDLE * RetVal);
+        
+#endif
+        
+        DECLSPEC_XFGVIRT(ID3D12DescriptorHeap, GetGPUDescriptorHandleForHeapStart)
+#if !defined(_WIN32)
+        D3D12_GPU_DESCRIPTOR_HANDLE ( STDMETHODCALLTYPE *GetGPUDescriptorHandleForHeapStart )( 
+            ID3D12DescriptorHeap * This);
+        
+#else
+        D3D12_GPU_DESCRIPTOR_HANDLE *( STDMETHODCALLTYPE *GetGPUDescriptorHandleForHeapStart )( 
+            ID3D12DescriptorHeap * This,
+            D3D12_GPU_DESCRIPTOR_HANDLE * RetVal);
+        
+#endif
+        
+        END_INTERFACE
+    } ID3D12DescriptorHeapVtbl;
+
+    interface ID3D12DescriptorHeap
+    {
+        CONST_VTBL struct ID3D12DescriptorHeapVtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define ID3D12DescriptorHeap_QueryInterface(This,riid,ppvObject)	\
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define ID3D12DescriptorHeap_AddRef(This)	\
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define ID3D12DescriptorHeap_Release(This)	\
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#define ID3D12DescriptorHeap_GetPrivateData(This,guid,pDataSize,pData)	\
+    ( (This)->lpVtbl -> GetPrivateData(This,guid,pDataSize,pData) ) 
+
+#define ID3D12DescriptorHeap_SetPrivateData(This,guid,DataSize,pData)	\
+    ( (This)->lpVtbl -> SetPrivateData(This,guid,DataSize,pData) ) 
+
+#define ID3D12DescriptorHeap_SetPrivateDataInterface(This,guid,pData)	\
+    ( (This)->lpVtbl -> SetPrivateDataInterface(This,guid,pData) ) 
+
+#define ID3D12DescriptorHeap_SetName(This,Name)	\
+    ( (This)->lpVtbl -> SetName(This,Name) ) 
+
+
+#define ID3D12DescriptorHeap_GetDevice(This,riid,ppvDevice)	\
+    ( (This)->lpVtbl -> GetDevice(This,riid,ppvDevice) ) 
+
+
+#if !defined(_WIN32)
+
+#define ID3D12DescriptorHeap_GetDesc(This)	\
+    ( (This)->lpVtbl -> GetDesc(This) ) 
+#else
+#define ID3D12DescriptorHeap_GetDesc(This,RetVal)	\
+    ( (This)->lpVtbl -> GetDesc(This,RetVal) ) 
+#endif
+#if !defined(_WIN32)
+
+#define ID3D12DescriptorHeap_GetCPUDescriptorHandleForHeapStart(This)	\
+    ( (This)->lpVtbl -> GetCPUDescriptorHandleForHeapStart(This) ) 
+#else
+#define ID3D12DescriptorHeap_GetCPUDescriptorHandleForHeapStart(This,RetVal)	\
+    ( (This)->lpVtbl -> GetCPUDescriptorHandleForHeapStart(This,RetVal) ) 
+#endif
+#if !defined(_WIN32)
+
+#define ID3D12DescriptorHeap_GetGPUDescriptorHandleForHeapStart(This)	\
+    ( (This)->lpVtbl -> GetGPUDescriptorHandleForHeapStart(This) ) 
+#else
+#define ID3D12DescriptorHeap_GetGPUDescriptorHandleForHeapStart(This,RetVal)	\
+    ( (This)->lpVtbl -> GetGPUDescriptorHandleForHeapStart(This,RetVal) ) 
+#endif
+
+#endif /* COBJMACROS */
+
+
+#endif 	/* C style interface */
+
+
+
+
+#endif 	/* __ID3D12DescriptorHeap_INTERFACE_DEFINED__ */
+
+
+#ifndef __ID3D12QueryHeap_INTERFACE_DEFINED__
+#define __ID3D12QueryHeap_INTERFACE_DEFINED__
+
+/* interface ID3D12QueryHeap */
+/* [unique][local][object][uuid] */ 
+
+
+EXTERN_C const IID IID_ID3D12QueryHeap;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("0d9658ae-ed45-469e-a61d-970ec583cab4")
+    ID3D12QueryHeap : public ID3D12Pageable
+    {
+    public:
+    };
+    
+    
+#else 	/* C style interface */
+
+    typedef struct ID3D12QueryHeapVtbl
+    {
+        BEGIN_INTERFACE
+        
+        DECLSPEC_XFGVIRT(IUnknown, QueryInterface)
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            ID3D12QueryHeap * This,
+            REFIID riid,
+            _COM_Outptr_  void **ppvObject);
+        
+        DECLSPEC_XFGVIRT(IUnknown, AddRef)
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            ID3D12QueryHeap * This);
+        
+        DECLSPEC_XFGVIRT(IUnknown, Release)
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            ID3D12QueryHeap * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, GetPrivateData)
+        HRESULT ( STDMETHODCALLTYPE *GetPrivateData )( 
+            ID3D12QueryHeap * This,
+            _In_  REFGUID guid,
+            _Inout_  UINT *pDataSize,
+            _Out_writes_bytes_opt_( *pDataSize )  void *pData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, SetPrivateData)
+        HRESULT ( STDMETHODCALLTYPE *SetPrivateData )( 
+            ID3D12QueryHeap * This,
+            _In_  REFGUID guid,
+            _In_  UINT DataSize,
+            _In_reads_bytes_opt_( DataSize )  const void *pData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, SetPrivateDataInterface)
+        HRESULT ( STDMETHODCALLTYPE *SetPrivateDataInterface )( 
+            ID3D12QueryHeap * This,
+            _In_  REFGUID guid,
+            _In_opt_  const IUnknown *pData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, SetName)
+        HRESULT ( STDMETHODCALLTYPE *SetName )( 
+            ID3D12QueryHeap * This,
+            _In_z_  LPCWSTR Name);
+        
+        DECLSPEC_XFGVIRT(ID3D12DeviceChild, GetDevice)
+        HRESULT ( STDMETHODCALLTYPE *GetDevice )( 
+            ID3D12QueryHeap * This,
+            REFIID riid,
+            _COM_Outptr_opt_  void **ppvDevice);
+        
+        END_INTERFACE
+    } ID3D12QueryHeapVtbl;
+
+    interface ID3D12QueryHeap
+    {
+        CONST_VTBL struct ID3D12QueryHeapVtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define ID3D12QueryHeap_QueryInterface(This,riid,ppvObject)	\
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define ID3D12QueryHeap_AddRef(This)	\
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define ID3D12QueryHeap_Release(This)	\
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#define ID3D12QueryHeap_GetPrivateData(This,guid,pDataSize,pData)	\
+    ( (This)->lpVtbl -> GetPrivateData(This,guid,pDataSize,pData) ) 
+
+#define ID3D12QueryHeap_SetPrivateData(This,guid,DataSize,pData)	\
+    ( (This)->lpVtbl -> SetPrivateData(This,guid,DataSize,pData) ) 
+
+#define ID3D12QueryHeap_SetPrivateDataInterface(This,guid,pData)	\
+    ( (This)->lpVtbl -> SetPrivateDataInterface(This,guid,pData) ) 
+
+#define ID3D12QueryHeap_SetName(This,Name)	\
+    ( (This)->lpVtbl -> SetName(This,Name) ) 
+
+
+#define ID3D12QueryHeap_GetDevice(This,riid,ppvDevice)	\
+    ( (This)->lpVtbl -> GetDevice(This,riid,ppvDevice) ) 
+
+
+
+#endif /* COBJMACROS */
+
+
+#endif 	/* C style interface */
+
+
+
+
+#endif 	/* __ID3D12QueryHeap_INTERFACE_DEFINED__ */
+
+
+#ifndef __ID3D12CommandSignature_INTERFACE_DEFINED__
+#define __ID3D12CommandSignature_INTERFACE_DEFINED__
+
+/* interface ID3D12CommandSignature */
+/* [unique][local][object][uuid] */ 
+
+
+EXTERN_C const IID IID_ID3D12CommandSignature;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("c36a797c-ec80-4f0a-8985-a7b2475082d1")
+    ID3D12CommandSignature : public ID3D12Pageable
+    {
+    public:
+    };
+    
+    
+#else 	/* C style interface */
+
+    typedef struct ID3D12CommandSignatureVtbl
+    {
+        BEGIN_INTERFACE
+        
+        DECLSPEC_XFGVIRT(IUnknown, QueryInterface)
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            ID3D12CommandSignature * This,
+            REFIID riid,
+            _COM_Outptr_  void **ppvObject);
+        
+        DECLSPEC_XFGVIRT(IUnknown, AddRef)
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            ID3D12CommandSignature * This);
+        
+        DECLSPEC_XFGVIRT(IUnknown, Release)
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            ID3D12CommandSignature * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, GetPrivateData)
+        HRESULT ( STDMETHODCALLTYPE *GetPrivateData )( 
+            ID3D12CommandSignature * This,
+            _In_  REFGUID guid,
+            _Inout_  UINT *pDataSize,
+            _Out_writes_bytes_opt_( *pDataSize )  void *pData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, SetPrivateData)
+        HRESULT ( STDMETHODCALLTYPE *SetPrivateData )( 
+            ID3D12CommandSignature * This,
+            _In_  REFGUID guid,
+            _In_  UINT DataSize,
+            _In_reads_bytes_opt_( DataSize )  const void *pData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, SetPrivateDataInterface)
+        HRESULT ( STDMETHODCALLTYPE *SetPrivateDataInterface )( 
+            ID3D12CommandSignature * This,
+            _In_  REFGUID guid,
+            _In_opt_  const IUnknown *pData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, SetName)
+        HRESULT ( STDMETHODCALLTYPE *SetName )( 
+            ID3D12CommandSignature * This,
+            _In_z_  LPCWSTR Name);
+        
+        DECLSPEC_XFGVIRT(ID3D12DeviceChild, GetDevice)
+        HRESULT ( STDMETHODCALLTYPE *GetDevice )( 
+            ID3D12CommandSignature * This,
+            REFIID riid,
+            _COM_Outptr_opt_  void **ppvDevice);
+        
+        END_INTERFACE
+    } ID3D12CommandSignatureVtbl;
+
+    interface ID3D12CommandSignature
+    {
+        CONST_VTBL struct ID3D12CommandSignatureVtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define ID3D12CommandSignature_QueryInterface(This,riid,ppvObject)	\
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define ID3D12CommandSignature_AddRef(This)	\
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define ID3D12CommandSignature_Release(This)	\
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#define ID3D12CommandSignature_GetPrivateData(This,guid,pDataSize,pData)	\
+    ( (This)->lpVtbl -> GetPrivateData(This,guid,pDataSize,pData) ) 
+
+#define ID3D12CommandSignature_SetPrivateData(This,guid,DataSize,pData)	\
+    ( (This)->lpVtbl -> SetPrivateData(This,guid,DataSize,pData) ) 
+
+#define ID3D12CommandSignature_SetPrivateDataInterface(This,guid,pData)	\
+    ( (This)->lpVtbl -> SetPrivateDataInterface(This,guid,pData) ) 
+
+#define ID3D12CommandSignature_SetName(This,Name)	\
+    ( (This)->lpVtbl -> SetName(This,Name) ) 
+
+
+#define ID3D12CommandSignature_GetDevice(This,riid,ppvDevice)	\
+    ( (This)->lpVtbl -> GetDevice(This,riid,ppvDevice) ) 
+
+
+
+#endif /* COBJMACROS */
+
+
+#endif 	/* C style interface */
+
+
+
+
+#endif 	/* __ID3D12CommandSignature_INTERFACE_DEFINED__ */
+
+
+#ifndef __ID3D12CommandList_INTERFACE_DEFINED__
+#define __ID3D12CommandList_INTERFACE_DEFINED__
+
+/* interface ID3D12CommandList */
+/* [unique][local][object][uuid] */ 
+
+
+EXTERN_C const IID IID_ID3D12CommandList;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("7116d91c-e7e4-47ce-b8c6-ec8168f437e5")
+    ID3D12CommandList : public ID3D12DeviceChild
+    {
+    public:
+        virtual D3D12_COMMAND_LIST_TYPE STDMETHODCALLTYPE GetType( void) = 0;
+        
+    };
+    
+    
+#else 	/* C style interface */
+
+    typedef struct ID3D12CommandListVtbl
+    {
+        BEGIN_INTERFACE
+        
+        DECLSPEC_XFGVIRT(IUnknown, QueryInterface)
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            ID3D12CommandList * This,
+            REFIID riid,
+            _COM_Outptr_  void **ppvObject);
+        
+        DECLSPEC_XFGVIRT(IUnknown, AddRef)
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            ID3D12CommandList * This);
+        
+        DECLSPEC_XFGVIRT(IUnknown, Release)
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            ID3D12CommandList * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, GetPrivateData)
+        HRESULT ( STDMETHODCALLTYPE *GetPrivateData )( 
+            ID3D12CommandList * This,
+            _In_  REFGUID guid,
+            _Inout_  UINT *pDataSize,
+            _Out_writes_bytes_opt_( *pDataSize )  void *pData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, SetPrivateData)
+        HRESULT ( STDMETHODCALLTYPE *SetPrivateData )( 
+            ID3D12CommandList * This,
+            _In_  REFGUID guid,
+            _In_  UINT DataSize,
+            _In_reads_bytes_opt_( DataSize )  const void *pData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, SetPrivateDataInterface)
+        HRESULT ( STDMETHODCALLTYPE *SetPrivateDataInterface )( 
+            ID3D12CommandList * This,
+            _In_  REFGUID guid,
+            _In_opt_  const IUnknown *pData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, SetName)
+        HRESULT ( STDMETHODCALLTYPE *SetName )( 
+            ID3D12CommandList * This,
+            _In_z_  LPCWSTR Name);
+        
+        DECLSPEC_XFGVIRT(ID3D12DeviceChild, GetDevice)
+        HRESULT ( STDMETHODCALLTYPE *GetDevice )( 
+            ID3D12CommandList * This,
+            REFIID riid,
+            _COM_Outptr_opt_  void **ppvDevice);
+        
+        DECLSPEC_XFGVIRT(ID3D12CommandList, GetType)
+        D3D12_COMMAND_LIST_TYPE ( STDMETHODCALLTYPE *GetType )( 
+            ID3D12CommandList * This);
+        
+        END_INTERFACE
+    } ID3D12CommandListVtbl;
+
+    interface ID3D12CommandList
+    {
+        CONST_VTBL struct ID3D12CommandListVtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define ID3D12CommandList_QueryInterface(This,riid,ppvObject)	\
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define ID3D12CommandList_AddRef(This)	\
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define ID3D12CommandList_Release(This)	\
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#define ID3D12CommandList_GetPrivateData(This,guid,pDataSize,pData)	\
+    ( (This)->lpVtbl -> GetPrivateData(This,guid,pDataSize,pData) ) 
+
+#define ID3D12CommandList_SetPrivateData(This,guid,DataSize,pData)	\
+    ( (This)->lpVtbl -> SetPrivateData(This,guid,DataSize,pData) ) 
+
+#define ID3D12CommandList_SetPrivateDataInterface(This,guid,pData)	\
+    ( (This)->lpVtbl -> SetPrivateDataInterface(This,guid,pData) ) 
+
+#define ID3D12CommandList_SetName(This,Name)	\
+    ( (This)->lpVtbl -> SetName(This,Name) ) 
+
+
+#define ID3D12CommandList_GetDevice(This,riid,ppvDevice)	\
+    ( (This)->lpVtbl -> GetDevice(This,riid,ppvDevice) ) 
+
+
+#define ID3D12CommandList_GetType(This)	\
+    ( (This)->lpVtbl -> GetType(This) ) 
+
+#endif /* COBJMACROS */
+
+
+#endif 	/* C style interface */
+
+
+
+
+#endif 	/* __ID3D12CommandList_INTERFACE_DEFINED__ */
+
+
+#ifndef __ID3D12GraphicsCommandList_INTERFACE_DEFINED__
+#define __ID3D12GraphicsCommandList_INTERFACE_DEFINED__
+
+/* interface ID3D12GraphicsCommandList */
+/* [unique][local][object][uuid] */ 
+
+
+EXTERN_C const IID IID_ID3D12GraphicsCommandList;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("5b160d0f-ac1b-4185-8ba8-b3ae42a5a455")
+    ID3D12GraphicsCommandList : public ID3D12CommandList
+    {
+    public:
+        virtual HRESULT STDMETHODCALLTYPE Close( void) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE Reset( 
+            _In_  ID3D12CommandAllocator *pAllocator,
+            _In_opt_  ID3D12PipelineState *pInitialState) = 0;
+        
+        virtual void STDMETHODCALLTYPE ClearState( 
+            _In_opt_  ID3D12PipelineState *pPipelineState) = 0;
+        
+        virtual void STDMETHODCALLTYPE DrawInstanced( 
+            _In_  UINT VertexCountPerInstance,
+            _In_  UINT InstanceCount,
+            _In_  UINT StartVertexLocation,
+            _In_  UINT StartInstanceLocation) = 0;
+        
+        virtual void STDMETHODCALLTYPE DrawIndexedInstanced( 
+            _In_  UINT IndexCountPerInstance,
+            _In_  UINT InstanceCount,
+            _In_  UINT StartIndexLocation,
+            _In_  INT BaseVertexLocation,
+            _In_  UINT StartInstanceLocation) = 0;
+        
+        virtual void STDMETHODCALLTYPE Dispatch( 
+            _In_  UINT ThreadGroupCountX,
+            _In_  UINT ThreadGroupCountY,
+            _In_  UINT ThreadGroupCountZ) = 0;
+        
+        virtual void STDMETHODCALLTYPE CopyBufferRegion( 
+            _In_  ID3D12Resource *pDstBuffer,
+            UINT64 DstOffset,
+            _In_  ID3D12Resource *pSrcBuffer,
+            UINT64 SrcOffset,
+            UINT64 NumBytes) = 0;
+        
+        virtual void STDMETHODCALLTYPE CopyTextureRegion( 
+            _In_  const D3D12_TEXTURE_COPY_LOCATION *pDst,
+            UINT DstX,
+            UINT DstY,
+            UINT DstZ,
+            _In_  const D3D12_TEXTURE_COPY_LOCATION *pSrc,
+            _In_opt_  const D3D12_BOX *pSrcBox) = 0;
+        
+        virtual void STDMETHODCALLTYPE CopyResource( 
+            _In_  ID3D12Resource *pDstResource,
+            _In_  ID3D12Resource *pSrcResource) = 0;
+        
+        virtual void STDMETHODCALLTYPE CopyTiles( 
+            _In_  ID3D12Resource *pTiledResource,
+            _In_  const D3D12_TILED_RESOURCE_COORDINATE *pTileRegionStartCoordinate,
+            _In_  const D3D12_TILE_REGION_SIZE *pTileRegionSize,
+            _In_  ID3D12Resource *pBuffer,
+            UINT64 BufferStartOffsetInBytes,
+            D3D12_TILE_COPY_FLAGS Flags) = 0;
+        
+        virtual void STDMETHODCALLTYPE ResolveSubresource( 
+            _In_  ID3D12Resource *pDstResource,
+            _In_  UINT DstSubresource,
+            _In_  ID3D12Resource *pSrcResource,
+            _In_  UINT SrcSubresource,
+            _In_  DXGI_FORMAT Format) = 0;
+        
+        virtual void STDMETHODCALLTYPE IASetPrimitiveTopology( 
+            _In_  D3D12_PRIMITIVE_TOPOLOGY PrimitiveTopology) = 0;
+        
+        virtual void STDMETHODCALLTYPE RSSetViewports( 
+            _In_range_(0, D3D12_VIEWPORT_AND_SCISSORRECT_OBJECT_COUNT_PER_PIPELINE)  UINT NumViewports,
+            _In_reads_( NumViewports)  const D3D12_VIEWPORT *pViewports) = 0;
+        
+        virtual void STDMETHODCALLTYPE RSSetScissorRects( 
+            _In_range_(0, D3D12_VIEWPORT_AND_SCISSORRECT_OBJECT_COUNT_PER_PIPELINE)  UINT NumRects,
+            _In_reads_( NumRects)  const D3D12_RECT *pRects) = 0;
+        
+        virtual void STDMETHODCALLTYPE OMSetBlendFactor( 
+            _In_reads_opt_(4)  const FLOAT BlendFactor[ 4 ]) = 0;
+        
+        virtual void STDMETHODCALLTYPE OMSetStencilRef( 
+            _In_  UINT StencilRef) = 0;
+        
+        virtual void STDMETHODCALLTYPE SetPipelineState( 
+            _In_  ID3D12PipelineState *pPipelineState) = 0;
+        
+        virtual void STDMETHODCALLTYPE ResourceBarrier( 
+            _In_  UINT NumBarriers,
+            _In_reads_(NumBarriers)  const D3D12_RESOURCE_BARRIER *pBarriers) = 0;
+        
+        virtual void STDMETHODCALLTYPE ExecuteBundle( 
+            _In_  ID3D12GraphicsCommandList *pCommandList) = 0;
+        
+        virtual void STDMETHODCALLTYPE SetDescriptorHeaps( 
+            _In_  UINT NumDescriptorHeaps,
+            _In_reads_(NumDescriptorHeaps)  ID3D12DescriptorHeap *const *ppDescriptorHeaps) = 0;
+        
+        virtual void STDMETHODCALLTYPE SetComputeRootSignature( 
+            _In_opt_  ID3D12RootSignature *pRootSignature) = 0;
+        
+        virtual void STDMETHODCALLTYPE SetGraphicsRootSignature( 
+            _In_opt_  ID3D12RootSignature *pRootSignature) = 0;
+        
+        virtual void STDMETHODCALLTYPE SetComputeRootDescriptorTable( 
+            _In_  UINT RootParameterIndex,
+            _In_  D3D12_GPU_DESCRIPTOR_HANDLE BaseDescriptor) = 0;
+        
+        virtual void STDMETHODCALLTYPE SetGraphicsRootDescriptorTable( 
+            _In_  UINT RootParameterIndex,
+            _In_  D3D12_GPU_DESCRIPTOR_HANDLE BaseDescriptor) = 0;
+        
+        virtual void STDMETHODCALLTYPE SetComputeRoot32BitConstant( 
+            _In_  UINT RootParameterIndex,
+            _In_  UINT SrcData,
+            _In_  UINT DestOffsetIn32BitValues) = 0;
+        
+        virtual void STDMETHODCALLTYPE SetGraphicsRoot32BitConstant( 
+            _In_  UINT RootParameterIndex,
+            _In_  UINT SrcData,
+            _In_  UINT DestOffsetIn32BitValues) = 0;
+        
+        virtual void STDMETHODCALLTYPE SetComputeRoot32BitConstants( 
+            _In_  UINT RootParameterIndex,
+            _In_  UINT Num32BitValuesToSet,
+            _In_reads_(Num32BitValuesToSet*sizeof(UINT))  const void *pSrcData,
+            _In_  UINT DestOffsetIn32BitValues) = 0;
+        
+        virtual void STDMETHODCALLTYPE SetGraphicsRoot32BitConstants( 
+            _In_  UINT RootParameterIndex,
+            _In_  UINT Num32BitValuesToSet,
+            _In_reads_(Num32BitValuesToSet*sizeof(UINT))  const void *pSrcData,
+            _In_  UINT DestOffsetIn32BitValues) = 0;
+        
+        virtual void STDMETHODCALLTYPE SetComputeRootConstantBufferView( 
+            _In_  UINT RootParameterIndex,
+            _In_  D3D12_GPU_VIRTUAL_ADDRESS BufferLocation) = 0;
+        
+        virtual void STDMETHODCALLTYPE SetGraphicsRootConstantBufferView( 
+            _In_  UINT RootParameterIndex,
+            _In_  D3D12_GPU_VIRTUAL_ADDRESS BufferLocation) = 0;
+        
+        virtual void STDMETHODCALLTYPE SetComputeRootShaderResourceView( 
+            _In_  UINT RootParameterIndex,
+            _In_  D3D12_GPU_VIRTUAL_ADDRESS BufferLocation) = 0;
+        
+        virtual void STDMETHODCALLTYPE SetGraphicsRootShaderResourceView( 
+            _In_  UINT RootParameterIndex,
+            _In_  D3D12_GPU_VIRTUAL_ADDRESS BufferLocation) = 0;
+        
+        virtual void STDMETHODCALLTYPE SetComputeRootUnorderedAccessView( 
+            _In_  UINT RootParameterIndex,
+            _In_  D3D12_GPU_VIRTUAL_ADDRESS BufferLocation) = 0;
+        
+        virtual void STDMETHODCALLTYPE SetGraphicsRootUnorderedAccessView( 
+            _In_  UINT RootParameterIndex,
+            _In_  D3D12_GPU_VIRTUAL_ADDRESS BufferLocation) = 0;
+        
+        virtual void STDMETHODCALLTYPE IASetIndexBuffer( 
+            _In_opt_  const D3D12_INDEX_BUFFER_VIEW *pView) = 0;
+        
+        virtual void STDMETHODCALLTYPE IASetVertexBuffers( 
+            _In_  UINT StartSlot,
+            _In_  UINT NumViews,
+            _In_reads_opt_(NumViews)  const D3D12_VERTEX_BUFFER_VIEW *pViews) = 0;
+        
+        virtual void STDMETHODCALLTYPE SOSetTargets( 
+            _In_  UINT StartSlot,
+            _In_  UINT NumViews,
+            _In_reads_opt_(NumViews)  const D3D12_STREAM_OUTPUT_BUFFER_VIEW *pViews) = 0;
+        
+        virtual void STDMETHODCALLTYPE OMSetRenderTargets( 
+            _In_  UINT NumRenderTargetDescriptors,
+            _In_opt_  const D3D12_CPU_DESCRIPTOR_HANDLE *pRenderTargetDescriptors,
+            _In_  BOOL RTsSingleHandleToDescriptorRange,
+            _In_opt_  const D3D12_CPU_DESCRIPTOR_HANDLE *pDepthStencilDescriptor) = 0;
+        
+        virtual void STDMETHODCALLTYPE ClearDepthStencilView( 
+            _In_  D3D12_CPU_DESCRIPTOR_HANDLE DepthStencilView,
+            _In_  D3D12_CLEAR_FLAGS ClearFlags,
+            _In_  FLOAT Depth,
+            _In_  UINT8 Stencil,
+            _In_  UINT NumRects,
+            _In_reads_(NumRects)  const D3D12_RECT *pRects) = 0;
+        
+        virtual void STDMETHODCALLTYPE ClearRenderTargetView( 
+            _In_  D3D12_CPU_DESCRIPTOR_HANDLE RenderTargetView,
+            _In_  const FLOAT ColorRGBA[ 4 ],
+            _In_  UINT NumRects,
+            _In_reads_(NumRects)  const D3D12_RECT *pRects) = 0;
+        
+        virtual void STDMETHODCALLTYPE ClearUnorderedAccessViewUint( 
+            _In_  D3D12_GPU_DESCRIPTOR_HANDLE ViewGPUHandleInCurrentHeap,
+            _In_  D3D12_CPU_DESCRIPTOR_HANDLE ViewCPUHandle,
+            _In_  ID3D12Resource *pResource,
+            _In_  const UINT Values[ 4 ],
+            _In_  UINT NumRects,
+            _In_reads_(NumRects)  const D3D12_RECT *pRects) = 0;
+        
+        virtual void STDMETHODCALLTYPE ClearUnorderedAccessViewFloat( 
+            _In_  D3D12_GPU_DESCRIPTOR_HANDLE ViewGPUHandleInCurrentHeap,
+            _In_  D3D12_CPU_DESCRIPTOR_HANDLE ViewCPUHandle,
+            _In_  ID3D12Resource *pResource,
+            _In_  const FLOAT Values[ 4 ],
+            _In_  UINT NumRects,
+            _In_reads_(NumRects)  const D3D12_RECT *pRects) = 0;
+        
+        virtual void STDMETHODCALLTYPE DiscardResource( 
+            _In_  ID3D12Resource *pResource,
+            _In_opt_  const D3D12_DISCARD_REGION *pRegion) = 0;
+        
+        virtual void STDMETHODCALLTYPE BeginQuery( 
+            _In_  ID3D12QueryHeap *pQueryHeap,
+            _In_  D3D12_QUERY_TYPE Type,
+            _In_  UINT Index) = 0;
+        
+        virtual void STDMETHODCALLTYPE EndQuery( 
+            _In_  ID3D12QueryHeap *pQueryHeap,
+            _In_  D3D12_QUERY_TYPE Type,
+            _In_  UINT Index) = 0;
+        
+        virtual void STDMETHODCALLTYPE ResolveQueryData( 
+            _In_  ID3D12QueryHeap *pQueryHeap,
+            _In_  D3D12_QUERY_TYPE Type,
+            _In_  UINT StartIndex,
+            _In_  UINT NumQueries,
+            _In_  ID3D12Resource *pDestinationBuffer,
+            _In_  UINT64 AlignedDestinationBufferOffset) = 0;
+        
+        virtual void STDMETHODCALLTYPE SetPredication( 
+            _In_opt_  ID3D12Resource *pBuffer,
+            _In_  UINT64 AlignedBufferOffset,
+            _In_  D3D12_PREDICATION_OP Operation) = 0;
+        
+        virtual void STDMETHODCALLTYPE SetMarker( 
+            UINT Metadata,
+            _In_reads_bytes_opt_(Size)  const void *pData,
+            UINT Size) = 0;
+        
+        virtual void STDMETHODCALLTYPE BeginEvent( 
+            UINT Metadata,
+            _In_reads_bytes_opt_(Size)  const void *pData,
+            UINT Size) = 0;
+        
+        virtual void STDMETHODCALLTYPE EndEvent( void) = 0;
+        
+        virtual void STDMETHODCALLTYPE ExecuteIndirect( 
+            _In_  ID3D12CommandSignature *pCommandSignature,
+            _In_  UINT MaxCommandCount,
+            _In_  ID3D12Resource *pArgumentBuffer,
+            _In_  UINT64 ArgumentBufferOffset,
+            _In_opt_  ID3D12Resource *pCountBuffer,
+            _In_  UINT64 CountBufferOffset) = 0;
+        
+    };
+    
+    
+#else 	/* C style interface */
+
+    typedef struct ID3D12GraphicsCommandListVtbl
+    {
+        BEGIN_INTERFACE
+        
+        DECLSPEC_XFGVIRT(IUnknown, QueryInterface)
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            ID3D12GraphicsCommandList * This,
+            REFIID riid,
+            _COM_Outptr_  void **ppvObject);
+        
+        DECLSPEC_XFGVIRT(IUnknown, AddRef)
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            ID3D12GraphicsCommandList * This);
+        
+        DECLSPEC_XFGVIRT(IUnknown, Release)
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            ID3D12GraphicsCommandList * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, GetPrivateData)
+        HRESULT ( STDMETHODCALLTYPE *GetPrivateData )( 
+            ID3D12GraphicsCommandList * This,
+            _In_  REFGUID guid,
+            _Inout_  UINT *pDataSize,
+            _Out_writes_bytes_opt_( *pDataSize )  void *pData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, SetPrivateData)
+        HRESULT ( STDMETHODCALLTYPE *SetPrivateData )( 
+            ID3D12GraphicsCommandList * This,
+            _In_  REFGUID guid,
+            _In_  UINT DataSize,
+            _In_reads_bytes_opt_( DataSize )  const void *pData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, SetPrivateDataInterface)
+        HRESULT ( STDMETHODCALLTYPE *SetPrivateDataInterface )( 
+            ID3D12GraphicsCommandList * This,
+            _In_  REFGUID guid,
+            _In_opt_  const IUnknown *pData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, SetName)
+        HRESULT ( STDMETHODCALLTYPE *SetName )( 
+            ID3D12GraphicsCommandList * This,
+            _In_z_  LPCWSTR Name);
+        
+        DECLSPEC_XFGVIRT(ID3D12DeviceChild, GetDevice)
+        HRESULT ( STDMETHODCALLTYPE *GetDevice )( 
+            ID3D12GraphicsCommandList * This,
+            REFIID riid,
+            _COM_Outptr_opt_  void **ppvDevice);
+        
+        DECLSPEC_XFGVIRT(ID3D12CommandList, GetType)
+        D3D12_COMMAND_LIST_TYPE ( STDMETHODCALLTYPE *GetType )( 
+            ID3D12GraphicsCommandList * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, Close)
+        HRESULT ( STDMETHODCALLTYPE *Close )( 
+            ID3D12GraphicsCommandList * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, Reset)
+        HRESULT ( STDMETHODCALLTYPE *Reset )( 
+            ID3D12GraphicsCommandList * This,
+            _In_  ID3D12CommandAllocator *pAllocator,
+            _In_opt_  ID3D12PipelineState *pInitialState);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, ClearState)
+        void ( STDMETHODCALLTYPE *ClearState )( 
+            ID3D12GraphicsCommandList * This,
+            _In_opt_  ID3D12PipelineState *pPipelineState);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, DrawInstanced)
+        void ( STDMETHODCALLTYPE *DrawInstanced )( 
+            ID3D12GraphicsCommandList * This,
+            _In_  UINT VertexCountPerInstance,
+            _In_  UINT InstanceCount,
+            _In_  UINT StartVertexLocation,
+            _In_  UINT StartInstanceLocation);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, DrawIndexedInstanced)
+        void ( STDMETHODCALLTYPE *DrawIndexedInstanced )( 
+            ID3D12GraphicsCommandList * This,
+            _In_  UINT IndexCountPerInstance,
+            _In_  UINT InstanceCount,
+            _In_  UINT StartIndexLocation,
+            _In_  INT BaseVertexLocation,
+            _In_  UINT StartInstanceLocation);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, Dispatch)
+        void ( STDMETHODCALLTYPE *Dispatch )( 
+            ID3D12GraphicsCommandList * This,
+            _In_  UINT ThreadGroupCountX,
+            _In_  UINT ThreadGroupCountY,
+            _In_  UINT ThreadGroupCountZ);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, CopyBufferRegion)
+        void ( STDMETHODCALLTYPE *CopyBufferRegion )( 
+            ID3D12GraphicsCommandList * This,
+            _In_  ID3D12Resource *pDstBuffer,
+            UINT64 DstOffset,
+            _In_  ID3D12Resource *pSrcBuffer,
+            UINT64 SrcOffset,
+            UINT64 NumBytes);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, CopyTextureRegion)
+        void ( STDMETHODCALLTYPE *CopyTextureRegion )( 
+            ID3D12GraphicsCommandList * This,
+            _In_  const D3D12_TEXTURE_COPY_LOCATION *pDst,
+            UINT DstX,
+            UINT DstY,
+            UINT DstZ,
+            _In_  const D3D12_TEXTURE_COPY_LOCATION *pSrc,
+            _In_opt_  const D3D12_BOX *pSrcBox);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, CopyResource)
+        void ( STDMETHODCALLTYPE *CopyResource )( 
+            ID3D12GraphicsCommandList * This,
+            _In_  ID3D12Resource *pDstResource,
+            _In_  ID3D12Resource *pSrcResource);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, CopyTiles)
+        void ( STDMETHODCALLTYPE *CopyTiles )( 
+            ID3D12GraphicsCommandList * This,
+            _In_  ID3D12Resource *pTiledResource,
+            _In_  const D3D12_TILED_RESOURCE_COORDINATE *pTileRegionStartCoordinate,
+            _In_  const D3D12_TILE_REGION_SIZE *pTileRegionSize,
+            _In_  ID3D12Resource *pBuffer,
+            UINT64 BufferStartOffsetInBytes,
+            D3D12_TILE_COPY_FLAGS Flags);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, ResolveSubresource)
+        void ( STDMETHODCALLTYPE *ResolveSubresource )( 
+            ID3D12GraphicsCommandList * This,
+            _In_  ID3D12Resource *pDstResource,
+            _In_  UINT DstSubresource,
+            _In_  ID3D12Resource *pSrcResource,
+            _In_  UINT SrcSubresource,
+            _In_  DXGI_FORMAT Format);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, IASetPrimitiveTopology)
+        void ( STDMETHODCALLTYPE *IASetPrimitiveTopology )( 
+            ID3D12GraphicsCommandList * This,
+            _In_  D3D12_PRIMITIVE_TOPOLOGY PrimitiveTopology);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, RSSetViewports)
+        void ( STDMETHODCALLTYPE *RSSetViewports )( 
+            ID3D12GraphicsCommandList * This,
+            _In_range_(0, D3D12_VIEWPORT_AND_SCISSORRECT_OBJECT_COUNT_PER_PIPELINE)  UINT NumViewports,
+            _In_reads_( NumViewports)  const D3D12_VIEWPORT *pViewports);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, RSSetScissorRects)
+        void ( STDMETHODCALLTYPE *RSSetScissorRects )( 
+            ID3D12GraphicsCommandList * This,
+            _In_range_(0, D3D12_VIEWPORT_AND_SCISSORRECT_OBJECT_COUNT_PER_PIPELINE)  UINT NumRects,
+            _In_reads_( NumRects)  const D3D12_RECT *pRects);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, OMSetBlendFactor)
+        void ( STDMETHODCALLTYPE *OMSetBlendFactor )( 
+            ID3D12GraphicsCommandList * This,
+            _In_reads_opt_(4)  const FLOAT BlendFactor[ 4 ]);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, OMSetStencilRef)
+        void ( STDMETHODCALLTYPE *OMSetStencilRef )( 
+            ID3D12GraphicsCommandList * This,
+            _In_  UINT StencilRef);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetPipelineState)
+        void ( STDMETHODCALLTYPE *SetPipelineState )( 
+            ID3D12GraphicsCommandList * This,
+            _In_  ID3D12PipelineState *pPipelineState);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, ResourceBarrier)
+        void ( STDMETHODCALLTYPE *ResourceBarrier )( 
+            ID3D12GraphicsCommandList * This,
+            _In_  UINT NumBarriers,
+            _In_reads_(NumBarriers)  const D3D12_RESOURCE_BARRIER *pBarriers);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, ExecuteBundle)
+        void ( STDMETHODCALLTYPE *ExecuteBundle )( 
+            ID3D12GraphicsCommandList * This,
+            _In_  ID3D12GraphicsCommandList *pCommandList);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetDescriptorHeaps)
+        void ( STDMETHODCALLTYPE *SetDescriptorHeaps )( 
+            ID3D12GraphicsCommandList * This,
+            _In_  UINT NumDescriptorHeaps,
+            _In_reads_(NumDescriptorHeaps)  ID3D12DescriptorHeap *const *ppDescriptorHeaps);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetComputeRootSignature)
+        void ( STDMETHODCALLTYPE *SetComputeRootSignature )( 
+            ID3D12GraphicsCommandList * This,
+            _In_opt_  ID3D12RootSignature *pRootSignature);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetGraphicsRootSignature)
+        void ( STDMETHODCALLTYPE *SetGraphicsRootSignature )( 
+            ID3D12GraphicsCommandList * This,
+            _In_opt_  ID3D12RootSignature *pRootSignature);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetComputeRootDescriptorTable)
+        void ( STDMETHODCALLTYPE *SetComputeRootDescriptorTable )( 
+            ID3D12GraphicsCommandList * This,
+            _In_  UINT RootParameterIndex,
+            _In_  D3D12_GPU_DESCRIPTOR_HANDLE BaseDescriptor);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetGraphicsRootDescriptorTable)
+        void ( STDMETHODCALLTYPE *SetGraphicsRootDescriptorTable )( 
+            ID3D12GraphicsCommandList * This,
+            _In_  UINT RootParameterIndex,
+            _In_  D3D12_GPU_DESCRIPTOR_HANDLE BaseDescriptor);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetComputeRoot32BitConstant)
+        void ( STDMETHODCALLTYPE *SetComputeRoot32BitConstant )( 
+            ID3D12GraphicsCommandList * This,
+            _In_  UINT RootParameterIndex,
+            _In_  UINT SrcData,
+            _In_  UINT DestOffsetIn32BitValues);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetGraphicsRoot32BitConstant)
+        void ( STDMETHODCALLTYPE *SetGraphicsRoot32BitConstant )( 
+            ID3D12GraphicsCommandList * This,
+            _In_  UINT RootParameterIndex,
+            _In_  UINT SrcData,
+            _In_  UINT DestOffsetIn32BitValues);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetComputeRoot32BitConstants)
+        void ( STDMETHODCALLTYPE *SetComputeRoot32BitConstants )( 
+            ID3D12GraphicsCommandList * This,
+            _In_  UINT RootParameterIndex,
+            _In_  UINT Num32BitValuesToSet,
+            _In_reads_(Num32BitValuesToSet*sizeof(UINT))  const void *pSrcData,
+            _In_  UINT DestOffsetIn32BitValues);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetGraphicsRoot32BitConstants)
+        void ( STDMETHODCALLTYPE *SetGraphicsRoot32BitConstants )( 
+            ID3D12GraphicsCommandList * This,
+            _In_  UINT RootParameterIndex,
+            _In_  UINT Num32BitValuesToSet,
+            _In_reads_(Num32BitValuesToSet*sizeof(UINT))  const void *pSrcData,
+            _In_  UINT DestOffsetIn32BitValues);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetComputeRootConstantBufferView)
+        void ( STDMETHODCALLTYPE *SetComputeRootConstantBufferView )( 
+            ID3D12GraphicsCommandList * This,
+            _In_  UINT RootParameterIndex,
+            _In_  D3D12_GPU_VIRTUAL_ADDRESS BufferLocation);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetGraphicsRootConstantBufferView)
+        void ( STDMETHODCALLTYPE *SetGraphicsRootConstantBufferView )( 
+            ID3D12GraphicsCommandList * This,
+            _In_  UINT RootParameterIndex,
+            _In_  D3D12_GPU_VIRTUAL_ADDRESS BufferLocation);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetComputeRootShaderResourceView)
+        void ( STDMETHODCALLTYPE *SetComputeRootShaderResourceView )( 
+            ID3D12GraphicsCommandList * This,
+            _In_  UINT RootParameterIndex,
+            _In_  D3D12_GPU_VIRTUAL_ADDRESS BufferLocation);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetGraphicsRootShaderResourceView)
+        void ( STDMETHODCALLTYPE *SetGraphicsRootShaderResourceView )( 
+            ID3D12GraphicsCommandList * This,
+            _In_  UINT RootParameterIndex,
+            _In_  D3D12_GPU_VIRTUAL_ADDRESS BufferLocation);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetComputeRootUnorderedAccessView)
+        void ( STDMETHODCALLTYPE *SetComputeRootUnorderedAccessView )( 
+            ID3D12GraphicsCommandList * This,
+            _In_  UINT RootParameterIndex,
+            _In_  D3D12_GPU_VIRTUAL_ADDRESS BufferLocation);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetGraphicsRootUnorderedAccessView)
+        void ( STDMETHODCALLTYPE *SetGraphicsRootUnorderedAccessView )( 
+            ID3D12GraphicsCommandList * This,
+            _In_  UINT RootParameterIndex,
+            _In_  D3D12_GPU_VIRTUAL_ADDRESS BufferLocation);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, IASetIndexBuffer)
+        void ( STDMETHODCALLTYPE *IASetIndexBuffer )( 
+            ID3D12GraphicsCommandList * This,
+            _In_opt_  const D3D12_INDEX_BUFFER_VIEW *pView);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, IASetVertexBuffers)
+        void ( STDMETHODCALLTYPE *IASetVertexBuffers )( 
+            ID3D12GraphicsCommandList * This,
+            _In_  UINT StartSlot,
+            _In_  UINT NumViews,
+            _In_reads_opt_(NumViews)  const D3D12_VERTEX_BUFFER_VIEW *pViews);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SOSetTargets)
+        void ( STDMETHODCALLTYPE *SOSetTargets )( 
+            ID3D12GraphicsCommandList * This,
+            _In_  UINT StartSlot,
+            _In_  UINT NumViews,
+            _In_reads_opt_(NumViews)  const D3D12_STREAM_OUTPUT_BUFFER_VIEW *pViews);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, OMSetRenderTargets)
+        void ( STDMETHODCALLTYPE *OMSetRenderTargets )( 
+            ID3D12GraphicsCommandList * This,
+            _In_  UINT NumRenderTargetDescriptors,
+            _In_opt_  const D3D12_CPU_DESCRIPTOR_HANDLE *pRenderTargetDescriptors,
+            _In_  BOOL RTsSingleHandleToDescriptorRange,
+            _In_opt_  const D3D12_CPU_DESCRIPTOR_HANDLE *pDepthStencilDescriptor);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, ClearDepthStencilView)
+        void ( STDMETHODCALLTYPE *ClearDepthStencilView )( 
+            ID3D12GraphicsCommandList * This,
+            _In_  D3D12_CPU_DESCRIPTOR_HANDLE DepthStencilView,
+            _In_  D3D12_CLEAR_FLAGS ClearFlags,
+            _In_  FLOAT Depth,
+            _In_  UINT8 Stencil,
+            _In_  UINT NumRects,
+            _In_reads_(NumRects)  const D3D12_RECT *pRects);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, ClearRenderTargetView)
+        void ( STDMETHODCALLTYPE *ClearRenderTargetView )( 
+            ID3D12GraphicsCommandList * This,
+            _In_  D3D12_CPU_DESCRIPTOR_HANDLE RenderTargetView,
+            _In_  const FLOAT ColorRGBA[ 4 ],
+            _In_  UINT NumRects,
+            _In_reads_(NumRects)  const D3D12_RECT *pRects);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, ClearUnorderedAccessViewUint)
+        void ( STDMETHODCALLTYPE *ClearUnorderedAccessViewUint )( 
+            ID3D12GraphicsCommandList * This,
+            _In_  D3D12_GPU_DESCRIPTOR_HANDLE ViewGPUHandleInCurrentHeap,
+            _In_  D3D12_CPU_DESCRIPTOR_HANDLE ViewCPUHandle,
+            _In_  ID3D12Resource *pResource,
+            _In_  const UINT Values[ 4 ],
+            _In_  UINT NumRects,
+            _In_reads_(NumRects)  const D3D12_RECT *pRects);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, ClearUnorderedAccessViewFloat)
+        void ( STDMETHODCALLTYPE *ClearUnorderedAccessViewFloat )( 
+            ID3D12GraphicsCommandList * This,
+            _In_  D3D12_GPU_DESCRIPTOR_HANDLE ViewGPUHandleInCurrentHeap,
+            _In_  D3D12_CPU_DESCRIPTOR_HANDLE ViewCPUHandle,
+            _In_  ID3D12Resource *pResource,
+            _In_  const FLOAT Values[ 4 ],
+            _In_  UINT NumRects,
+            _In_reads_(NumRects)  const D3D12_RECT *pRects);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, DiscardResource)
+        void ( STDMETHODCALLTYPE *DiscardResource )( 
+            ID3D12GraphicsCommandList * This,
+            _In_  ID3D12Resource *pResource,
+            _In_opt_  const D3D12_DISCARD_REGION *pRegion);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, BeginQuery)
+        void ( STDMETHODCALLTYPE *BeginQuery )( 
+            ID3D12GraphicsCommandList * This,
+            _In_  ID3D12QueryHeap *pQueryHeap,
+            _In_  D3D12_QUERY_TYPE Type,
+            _In_  UINT Index);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, EndQuery)
+        void ( STDMETHODCALLTYPE *EndQuery )( 
+            ID3D12GraphicsCommandList * This,
+            _In_  ID3D12QueryHeap *pQueryHeap,
+            _In_  D3D12_QUERY_TYPE Type,
+            _In_  UINT Index);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, ResolveQueryData)
+        void ( STDMETHODCALLTYPE *ResolveQueryData )( 
+            ID3D12GraphicsCommandList * This,
+            _In_  ID3D12QueryHeap *pQueryHeap,
+            _In_  D3D12_QUERY_TYPE Type,
+            _In_  UINT StartIndex,
+            _In_  UINT NumQueries,
+            _In_  ID3D12Resource *pDestinationBuffer,
+            _In_  UINT64 AlignedDestinationBufferOffset);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetPredication)
+        void ( STDMETHODCALLTYPE *SetPredication )( 
+            ID3D12GraphicsCommandList * This,
+            _In_opt_  ID3D12Resource *pBuffer,
+            _In_  UINT64 AlignedBufferOffset,
+            _In_  D3D12_PREDICATION_OP Operation);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetMarker)
+        void ( STDMETHODCALLTYPE *SetMarker )( 
+            ID3D12GraphicsCommandList * This,
+            UINT Metadata,
+            _In_reads_bytes_opt_(Size)  const void *pData,
+            UINT Size);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, BeginEvent)
+        void ( STDMETHODCALLTYPE *BeginEvent )( 
+            ID3D12GraphicsCommandList * This,
+            UINT Metadata,
+            _In_reads_bytes_opt_(Size)  const void *pData,
+            UINT Size);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, EndEvent)
+        void ( STDMETHODCALLTYPE *EndEvent )( 
+            ID3D12GraphicsCommandList * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, ExecuteIndirect)
+        void ( STDMETHODCALLTYPE *ExecuteIndirect )( 
+            ID3D12GraphicsCommandList * This,
+            _In_  ID3D12CommandSignature *pCommandSignature,
+            _In_  UINT MaxCommandCount,
+            _In_  ID3D12Resource *pArgumentBuffer,
+            _In_  UINT64 ArgumentBufferOffset,
+            _In_opt_  ID3D12Resource *pCountBuffer,
+            _In_  UINT64 CountBufferOffset);
+        
+        END_INTERFACE
+    } ID3D12GraphicsCommandListVtbl;
+
+    interface ID3D12GraphicsCommandList
+    {
+        CONST_VTBL struct ID3D12GraphicsCommandListVtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define ID3D12GraphicsCommandList_QueryInterface(This,riid,ppvObject)	\
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define ID3D12GraphicsCommandList_AddRef(This)	\
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define ID3D12GraphicsCommandList_Release(This)	\
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#define ID3D12GraphicsCommandList_GetPrivateData(This,guid,pDataSize,pData)	\
+    ( (This)->lpVtbl -> GetPrivateData(This,guid,pDataSize,pData) ) 
+
+#define ID3D12GraphicsCommandList_SetPrivateData(This,guid,DataSize,pData)	\
+    ( (This)->lpVtbl -> SetPrivateData(This,guid,DataSize,pData) ) 
+
+#define ID3D12GraphicsCommandList_SetPrivateDataInterface(This,guid,pData)	\
+    ( (This)->lpVtbl -> SetPrivateDataInterface(This,guid,pData) ) 
+
+#define ID3D12GraphicsCommandList_SetName(This,Name)	\
+    ( (This)->lpVtbl -> SetName(This,Name) ) 
+
+
+#define ID3D12GraphicsCommandList_GetDevice(This,riid,ppvDevice)	\
+    ( (This)->lpVtbl -> GetDevice(This,riid,ppvDevice) ) 
+
+
+#define ID3D12GraphicsCommandList_GetType(This)	\
+    ( (This)->lpVtbl -> GetType(This) ) 
+
+
+#define ID3D12GraphicsCommandList_Close(This)	\
+    ( (This)->lpVtbl -> Close(This) ) 
+
+#define ID3D12GraphicsCommandList_Reset(This,pAllocator,pInitialState)	\
+    ( (This)->lpVtbl -> Reset(This,pAllocator,pInitialState) ) 
+
+#define ID3D12GraphicsCommandList_ClearState(This,pPipelineState)	\
+    ( (This)->lpVtbl -> ClearState(This,pPipelineState) ) 
+
+#define ID3D12GraphicsCommandList_DrawInstanced(This,VertexCountPerInstance,InstanceCount,StartVertexLocation,StartInstanceLocation)	\
+    ( (This)->lpVtbl -> DrawInstanced(This,VertexCountPerInstance,InstanceCount,StartVertexLocation,StartInstanceLocation) ) 
+
+#define ID3D12GraphicsCommandList_DrawIndexedInstanced(This,IndexCountPerInstance,InstanceCount,StartIndexLocation,BaseVertexLocation,StartInstanceLocation)	\
+    ( (This)->lpVtbl -> DrawIndexedInstanced(This,IndexCountPerInstance,InstanceCount,StartIndexLocation,BaseVertexLocation,StartInstanceLocation) ) 
+
+#define ID3D12GraphicsCommandList_Dispatch(This,ThreadGroupCountX,ThreadGroupCountY,ThreadGroupCountZ)	\
+    ( (This)->lpVtbl -> Dispatch(This,ThreadGroupCountX,ThreadGroupCountY,ThreadGroupCountZ) ) 
+
+#define ID3D12GraphicsCommandList_CopyBufferRegion(This,pDstBuffer,DstOffset,pSrcBuffer,SrcOffset,NumBytes)	\
+    ( (This)->lpVtbl -> CopyBufferRegion(This,pDstBuffer,DstOffset,pSrcBuffer,SrcOffset,NumBytes) ) 
+
+#define ID3D12GraphicsCommandList_CopyTextureRegion(This,pDst,DstX,DstY,DstZ,pSrc,pSrcBox)	\
+    ( (This)->lpVtbl -> CopyTextureRegion(This,pDst,DstX,DstY,DstZ,pSrc,pSrcBox) ) 
+
+#define ID3D12GraphicsCommandList_CopyResource(This,pDstResource,pSrcResource)	\
+    ( (This)->lpVtbl -> CopyResource(This,pDstResource,pSrcResource) ) 
+
+#define ID3D12GraphicsCommandList_CopyTiles(This,pTiledResource,pTileRegionStartCoordinate,pTileRegionSize,pBuffer,BufferStartOffsetInBytes,Flags)	\
+    ( (This)->lpVtbl -> CopyTiles(This,pTiledResource,pTileRegionStartCoordinate,pTileRegionSize,pBuffer,BufferStartOffsetInBytes,Flags) ) 
+
+#define ID3D12GraphicsCommandList_ResolveSubresource(This,pDstResource,DstSubresource,pSrcResource,SrcSubresource,Format)	\
+    ( (This)->lpVtbl -> ResolveSubresource(This,pDstResource,DstSubresource,pSrcResource,SrcSubresource,Format) ) 
+
+#define ID3D12GraphicsCommandList_IASetPrimitiveTopology(This,PrimitiveTopology)	\
+    ( (This)->lpVtbl -> IASetPrimitiveTopology(This,PrimitiveTopology) ) 
+
+#define ID3D12GraphicsCommandList_RSSetViewports(This,NumViewports,pViewports)	\
+    ( (This)->lpVtbl -> RSSetViewports(This,NumViewports,pViewports) ) 
+
+#define ID3D12GraphicsCommandList_RSSetScissorRects(This,NumRects,pRects)	\
+    ( (This)->lpVtbl -> RSSetScissorRects(This,NumRects,pRects) ) 
+
+#define ID3D12GraphicsCommandList_OMSetBlendFactor(This,BlendFactor)	\
+    ( (This)->lpVtbl -> OMSetBlendFactor(This,BlendFactor) ) 
+
+#define ID3D12GraphicsCommandList_OMSetStencilRef(This,StencilRef)	\
+    ( (This)->lpVtbl -> OMSetStencilRef(This,StencilRef) ) 
+
+#define ID3D12GraphicsCommandList_SetPipelineState(This,pPipelineState)	\
+    ( (This)->lpVtbl -> SetPipelineState(This,pPipelineState) ) 
+
+#define ID3D12GraphicsCommandList_ResourceBarrier(This,NumBarriers,pBarriers)	\
+    ( (This)->lpVtbl -> ResourceBarrier(This,NumBarriers,pBarriers) ) 
+
+#define ID3D12GraphicsCommandList_ExecuteBundle(This,pCommandList)	\
+    ( (This)->lpVtbl -> ExecuteBundle(This,pCommandList) ) 
+
+#define ID3D12GraphicsCommandList_SetDescriptorHeaps(This,NumDescriptorHeaps,ppDescriptorHeaps)	\
+    ( (This)->lpVtbl -> SetDescriptorHeaps(This,NumDescriptorHeaps,ppDescriptorHeaps) ) 
+
+#define ID3D12GraphicsCommandList_SetComputeRootSignature(This,pRootSignature)	\
+    ( (This)->lpVtbl -> SetComputeRootSignature(This,pRootSignature) ) 
+
+#define ID3D12GraphicsCommandList_SetGraphicsRootSignature(This,pRootSignature)	\
+    ( (This)->lpVtbl -> SetGraphicsRootSignature(This,pRootSignature) ) 
+
+#define ID3D12GraphicsCommandList_SetComputeRootDescriptorTable(This,RootParameterIndex,BaseDescriptor)	\
+    ( (This)->lpVtbl -> SetComputeRootDescriptorTable(This,RootParameterIndex,BaseDescriptor) ) 
+
+#define ID3D12GraphicsCommandList_SetGraphicsRootDescriptorTable(This,RootParameterIndex,BaseDescriptor)	\
+    ( (This)->lpVtbl -> SetGraphicsRootDescriptorTable(This,RootParameterIndex,BaseDescriptor) ) 
+
+#define ID3D12GraphicsCommandList_SetComputeRoot32BitConstant(This,RootParameterIndex,SrcData,DestOffsetIn32BitValues)	\
+    ( (This)->lpVtbl -> SetComputeRoot32BitConstant(This,RootParameterIndex,SrcData,DestOffsetIn32BitValues) ) 
+
+#define ID3D12GraphicsCommandList_SetGraphicsRoot32BitConstant(This,RootParameterIndex,SrcData,DestOffsetIn32BitValues)	\
+    ( (This)->lpVtbl -> SetGraphicsRoot32BitConstant(This,RootParameterIndex,SrcData,DestOffsetIn32BitValues) ) 
+
+#define ID3D12GraphicsCommandList_SetComputeRoot32BitConstants(This,RootParameterIndex,Num32BitValuesToSet,pSrcData,DestOffsetIn32BitValues)	\
+    ( (This)->lpVtbl -> SetComputeRoot32BitConstants(This,RootParameterIndex,Num32BitValuesToSet,pSrcData,DestOffsetIn32BitValues) ) 
+
+#define ID3D12GraphicsCommandList_SetGraphicsRoot32BitConstants(This,RootParameterIndex,Num32BitValuesToSet,pSrcData,DestOffsetIn32BitValues)	\
+    ( (This)->lpVtbl -> SetGraphicsRoot32BitConstants(This,RootParameterIndex,Num32BitValuesToSet,pSrcData,DestOffsetIn32BitValues) ) 
+
+#define ID3D12GraphicsCommandList_SetComputeRootConstantBufferView(This,RootParameterIndex,BufferLocation)	\
+    ( (This)->lpVtbl -> SetComputeRootConstantBufferView(This,RootParameterIndex,BufferLocation) ) 
+
+#define ID3D12GraphicsCommandList_SetGraphicsRootConstantBufferView(This,RootParameterIndex,BufferLocation)	\
+    ( (This)->lpVtbl -> SetGraphicsRootConstantBufferView(This,RootParameterIndex,BufferLocation) ) 
+
+#define ID3D12GraphicsCommandList_SetComputeRootShaderResourceView(This,RootParameterIndex,BufferLocation)	\
+    ( (This)->lpVtbl -> SetComputeRootShaderResourceView(This,RootParameterIndex,BufferLocation) ) 
+
+#define ID3D12GraphicsCommandList_SetGraphicsRootShaderResourceView(This,RootParameterIndex,BufferLocation)	\
+    ( (This)->lpVtbl -> SetGraphicsRootShaderResourceView(This,RootParameterIndex,BufferLocation) ) 
+
+#define ID3D12GraphicsCommandList_SetComputeRootUnorderedAccessView(This,RootParameterIndex,BufferLocation)	\
+    ( (This)->lpVtbl -> SetComputeRootUnorderedAccessView(This,RootParameterIndex,BufferLocation) ) 
+
+#define ID3D12GraphicsCommandList_SetGraphicsRootUnorderedAccessView(This,RootParameterIndex,BufferLocation)	\
+    ( (This)->lpVtbl -> SetGraphicsRootUnorderedAccessView(This,RootParameterIndex,BufferLocation) ) 
+
+#define ID3D12GraphicsCommandList_IASetIndexBuffer(This,pView)	\
+    ( (This)->lpVtbl -> IASetIndexBuffer(This,pView) ) 
+
+#define ID3D12GraphicsCommandList_IASetVertexBuffers(This,StartSlot,NumViews,pViews)	\
+    ( (This)->lpVtbl -> IASetVertexBuffers(This,StartSlot,NumViews,pViews) ) 
+
+#define ID3D12GraphicsCommandList_SOSetTargets(This,StartSlot,NumViews,pViews)	\
+    ( (This)->lpVtbl -> SOSetTargets(This,StartSlot,NumViews,pViews) ) 
+
+#define ID3D12GraphicsCommandList_OMSetRenderTargets(This,NumRenderTargetDescriptors,pRenderTargetDescriptors,RTsSingleHandleToDescriptorRange,pDepthStencilDescriptor)	\
+    ( (This)->lpVtbl -> OMSetRenderTargets(This,NumRenderTargetDescriptors,pRenderTargetDescriptors,RTsSingleHandleToDescriptorRange,pDepthStencilDescriptor) ) 
+
+#define ID3D12GraphicsCommandList_ClearDepthStencilView(This,DepthStencilView,ClearFlags,Depth,Stencil,NumRects,pRects)	\
+    ( (This)->lpVtbl -> ClearDepthStencilView(This,DepthStencilView,ClearFlags,Depth,Stencil,NumRects,pRects) ) 
+
+#define ID3D12GraphicsCommandList_ClearRenderTargetView(This,RenderTargetView,ColorRGBA,NumRects,pRects)	\
+    ( (This)->lpVtbl -> ClearRenderTargetView(This,RenderTargetView,ColorRGBA,NumRects,pRects) ) 
+
+#define ID3D12GraphicsCommandList_ClearUnorderedAccessViewUint(This,ViewGPUHandleInCurrentHeap,ViewCPUHandle,pResource,Values,NumRects,pRects)	\
+    ( (This)->lpVtbl -> ClearUnorderedAccessViewUint(This,ViewGPUHandleInCurrentHeap,ViewCPUHandle,pResource,Values,NumRects,pRects) ) 
+
+#define ID3D12GraphicsCommandList_ClearUnorderedAccessViewFloat(This,ViewGPUHandleInCurrentHeap,ViewCPUHandle,pResource,Values,NumRects,pRects)	\
+    ( (This)->lpVtbl -> ClearUnorderedAccessViewFloat(This,ViewGPUHandleInCurrentHeap,ViewCPUHandle,pResource,Values,NumRects,pRects) ) 
+
+#define ID3D12GraphicsCommandList_DiscardResource(This,pResource,pRegion)	\
+    ( (This)->lpVtbl -> DiscardResource(This,pResource,pRegion) ) 
+
+#define ID3D12GraphicsCommandList_BeginQuery(This,pQueryHeap,Type,Index)	\
+    ( (This)->lpVtbl -> BeginQuery(This,pQueryHeap,Type,Index) ) 
+
+#define ID3D12GraphicsCommandList_EndQuery(This,pQueryHeap,Type,Index)	\
+    ( (This)->lpVtbl -> EndQuery(This,pQueryHeap,Type,Index) ) 
+
+#define ID3D12GraphicsCommandList_ResolveQueryData(This,pQueryHeap,Type,StartIndex,NumQueries,pDestinationBuffer,AlignedDestinationBufferOffset)	\
+    ( (This)->lpVtbl -> ResolveQueryData(This,pQueryHeap,Type,StartIndex,NumQueries,pDestinationBuffer,AlignedDestinationBufferOffset) ) 
+
+#define ID3D12GraphicsCommandList_SetPredication(This,pBuffer,AlignedBufferOffset,Operation)	\
+    ( (This)->lpVtbl -> SetPredication(This,pBuffer,AlignedBufferOffset,Operation) ) 
+
+#define ID3D12GraphicsCommandList_SetMarker(This,Metadata,pData,Size)	\
+    ( (This)->lpVtbl -> SetMarker(This,Metadata,pData,Size) ) 
+
+#define ID3D12GraphicsCommandList_BeginEvent(This,Metadata,pData,Size)	\
+    ( (This)->lpVtbl -> BeginEvent(This,Metadata,pData,Size) ) 
+
+#define ID3D12GraphicsCommandList_EndEvent(This)	\
+    ( (This)->lpVtbl -> EndEvent(This) ) 
+
+#define ID3D12GraphicsCommandList_ExecuteIndirect(This,pCommandSignature,MaxCommandCount,pArgumentBuffer,ArgumentBufferOffset,pCountBuffer,CountBufferOffset)	\
+    ( (This)->lpVtbl -> ExecuteIndirect(This,pCommandSignature,MaxCommandCount,pArgumentBuffer,ArgumentBufferOffset,pCountBuffer,CountBufferOffset) ) 
+
+#endif /* COBJMACROS */
+
+
+#endif 	/* C style interface */
+
+
+
+
+#endif 	/* __ID3D12GraphicsCommandList_INTERFACE_DEFINED__ */
+
+
+#ifndef __ID3D12GraphicsCommandList1_INTERFACE_DEFINED__
+#define __ID3D12GraphicsCommandList1_INTERFACE_DEFINED__
+
+/* interface ID3D12GraphicsCommandList1 */
+/* [unique][local][object][uuid] */ 
+
+
+EXTERN_C const IID IID_ID3D12GraphicsCommandList1;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("553103fb-1fe7-4557-bb38-946d7d0e7ca7")
+    ID3D12GraphicsCommandList1 : public ID3D12GraphicsCommandList
+    {
+    public:
+        virtual void STDMETHODCALLTYPE AtomicCopyBufferUINT( 
+            _In_  ID3D12Resource *pDstBuffer,
+            UINT64 DstOffset,
+            _In_  ID3D12Resource *pSrcBuffer,
+            UINT64 SrcOffset,
+            UINT Dependencies,
+            _In_reads_(Dependencies)  ID3D12Resource *const *ppDependentResources,
+            _In_reads_(Dependencies)  const D3D12_SUBRESOURCE_RANGE_UINT64 *pDependentSubresourceRanges) = 0;
+        
+        virtual void STDMETHODCALLTYPE AtomicCopyBufferUINT64( 
+            _In_  ID3D12Resource *pDstBuffer,
+            UINT64 DstOffset,
+            _In_  ID3D12Resource *pSrcBuffer,
+            UINT64 SrcOffset,
+            UINT Dependencies,
+            _In_reads_(Dependencies)  ID3D12Resource *const *ppDependentResources,
+            _In_reads_(Dependencies)  const D3D12_SUBRESOURCE_RANGE_UINT64 *pDependentSubresourceRanges) = 0;
+        
+        virtual void STDMETHODCALLTYPE OMSetDepthBounds( 
+            _In_  FLOAT Min,
+            _In_  FLOAT Max) = 0;
+        
+        virtual void STDMETHODCALLTYPE SetSamplePositions( 
+            _In_  UINT NumSamplesPerPixel,
+            _In_  UINT NumPixels,
+            _In_reads_(NumSamplesPerPixel*NumPixels)  D3D12_SAMPLE_POSITION *pSamplePositions) = 0;
+        
+        virtual void STDMETHODCALLTYPE ResolveSubresourceRegion( 
+            _In_  ID3D12Resource *pDstResource,
+            _In_  UINT DstSubresource,
+            _In_  UINT DstX,
+            _In_  UINT DstY,
+            _In_  ID3D12Resource *pSrcResource,
+            _In_  UINT SrcSubresource,
+            _In_opt_  D3D12_RECT *pSrcRect,
+            _In_  DXGI_FORMAT Format,
+            _In_  D3D12_RESOLVE_MODE ResolveMode) = 0;
+        
+        virtual void STDMETHODCALLTYPE SetViewInstanceMask( 
+            _In_  UINT Mask) = 0;
+        
+    };
+    
+    
+#else 	/* C style interface */
+
+    typedef struct ID3D12GraphicsCommandList1Vtbl
+    {
+        BEGIN_INTERFACE
+        
+        DECLSPEC_XFGVIRT(IUnknown, QueryInterface)
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            ID3D12GraphicsCommandList1 * This,
+            REFIID riid,
+            _COM_Outptr_  void **ppvObject);
+        
+        DECLSPEC_XFGVIRT(IUnknown, AddRef)
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            ID3D12GraphicsCommandList1 * This);
+        
+        DECLSPEC_XFGVIRT(IUnknown, Release)
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            ID3D12GraphicsCommandList1 * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, GetPrivateData)
+        HRESULT ( STDMETHODCALLTYPE *GetPrivateData )( 
+            ID3D12GraphicsCommandList1 * This,
+            _In_  REFGUID guid,
+            _Inout_  UINT *pDataSize,
+            _Out_writes_bytes_opt_( *pDataSize )  void *pData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, SetPrivateData)
+        HRESULT ( STDMETHODCALLTYPE *SetPrivateData )( 
+            ID3D12GraphicsCommandList1 * This,
+            _In_  REFGUID guid,
+            _In_  UINT DataSize,
+            _In_reads_bytes_opt_( DataSize )  const void *pData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, SetPrivateDataInterface)
+        HRESULT ( STDMETHODCALLTYPE *SetPrivateDataInterface )( 
+            ID3D12GraphicsCommandList1 * This,
+            _In_  REFGUID guid,
+            _In_opt_  const IUnknown *pData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, SetName)
+        HRESULT ( STDMETHODCALLTYPE *SetName )( 
+            ID3D12GraphicsCommandList1 * This,
+            _In_z_  LPCWSTR Name);
+        
+        DECLSPEC_XFGVIRT(ID3D12DeviceChild, GetDevice)
+        HRESULT ( STDMETHODCALLTYPE *GetDevice )( 
+            ID3D12GraphicsCommandList1 * This,
+            REFIID riid,
+            _COM_Outptr_opt_  void **ppvDevice);
+        
+        DECLSPEC_XFGVIRT(ID3D12CommandList, GetType)
+        D3D12_COMMAND_LIST_TYPE ( STDMETHODCALLTYPE *GetType )( 
+            ID3D12GraphicsCommandList1 * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, Close)
+        HRESULT ( STDMETHODCALLTYPE *Close )( 
+            ID3D12GraphicsCommandList1 * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, Reset)
+        HRESULT ( STDMETHODCALLTYPE *Reset )( 
+            ID3D12GraphicsCommandList1 * This,
+            _In_  ID3D12CommandAllocator *pAllocator,
+            _In_opt_  ID3D12PipelineState *pInitialState);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, ClearState)
+        void ( STDMETHODCALLTYPE *ClearState )( 
+            ID3D12GraphicsCommandList1 * This,
+            _In_opt_  ID3D12PipelineState *pPipelineState);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, DrawInstanced)
+        void ( STDMETHODCALLTYPE *DrawInstanced )( 
+            ID3D12GraphicsCommandList1 * This,
+            _In_  UINT VertexCountPerInstance,
+            _In_  UINT InstanceCount,
+            _In_  UINT StartVertexLocation,
+            _In_  UINT StartInstanceLocation);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, DrawIndexedInstanced)
+        void ( STDMETHODCALLTYPE *DrawIndexedInstanced )( 
+            ID3D12GraphicsCommandList1 * This,
+            _In_  UINT IndexCountPerInstance,
+            _In_  UINT InstanceCount,
+            _In_  UINT StartIndexLocation,
+            _In_  INT BaseVertexLocation,
+            _In_  UINT StartInstanceLocation);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, Dispatch)
+        void ( STDMETHODCALLTYPE *Dispatch )( 
+            ID3D12GraphicsCommandList1 * This,
+            _In_  UINT ThreadGroupCountX,
+            _In_  UINT ThreadGroupCountY,
+            _In_  UINT ThreadGroupCountZ);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, CopyBufferRegion)
+        void ( STDMETHODCALLTYPE *CopyBufferRegion )( 
+            ID3D12GraphicsCommandList1 * This,
+            _In_  ID3D12Resource *pDstBuffer,
+            UINT64 DstOffset,
+            _In_  ID3D12Resource *pSrcBuffer,
+            UINT64 SrcOffset,
+            UINT64 NumBytes);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, CopyTextureRegion)
+        void ( STDMETHODCALLTYPE *CopyTextureRegion )( 
+            ID3D12GraphicsCommandList1 * This,
+            _In_  const D3D12_TEXTURE_COPY_LOCATION *pDst,
+            UINT DstX,
+            UINT DstY,
+            UINT DstZ,
+            _In_  const D3D12_TEXTURE_COPY_LOCATION *pSrc,
+            _In_opt_  const D3D12_BOX *pSrcBox);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, CopyResource)
+        void ( STDMETHODCALLTYPE *CopyResource )( 
+            ID3D12GraphicsCommandList1 * This,
+            _In_  ID3D12Resource *pDstResource,
+            _In_  ID3D12Resource *pSrcResource);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, CopyTiles)
+        void ( STDMETHODCALLTYPE *CopyTiles )( 
+            ID3D12GraphicsCommandList1 * This,
+            _In_  ID3D12Resource *pTiledResource,
+            _In_  const D3D12_TILED_RESOURCE_COORDINATE *pTileRegionStartCoordinate,
+            _In_  const D3D12_TILE_REGION_SIZE *pTileRegionSize,
+            _In_  ID3D12Resource *pBuffer,
+            UINT64 BufferStartOffsetInBytes,
+            D3D12_TILE_COPY_FLAGS Flags);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, ResolveSubresource)
+        void ( STDMETHODCALLTYPE *ResolveSubresource )( 
+            ID3D12GraphicsCommandList1 * This,
+            _In_  ID3D12Resource *pDstResource,
+            _In_  UINT DstSubresource,
+            _In_  ID3D12Resource *pSrcResource,
+            _In_  UINT SrcSubresource,
+            _In_  DXGI_FORMAT Format);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, IASetPrimitiveTopology)
+        void ( STDMETHODCALLTYPE *IASetPrimitiveTopology )( 
+            ID3D12GraphicsCommandList1 * This,
+            _In_  D3D12_PRIMITIVE_TOPOLOGY PrimitiveTopology);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, RSSetViewports)
+        void ( STDMETHODCALLTYPE *RSSetViewports )( 
+            ID3D12GraphicsCommandList1 * This,
+            _In_range_(0, D3D12_VIEWPORT_AND_SCISSORRECT_OBJECT_COUNT_PER_PIPELINE)  UINT NumViewports,
+            _In_reads_( NumViewports)  const D3D12_VIEWPORT *pViewports);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, RSSetScissorRects)
+        void ( STDMETHODCALLTYPE *RSSetScissorRects )( 
+            ID3D12GraphicsCommandList1 * This,
+            _In_range_(0, D3D12_VIEWPORT_AND_SCISSORRECT_OBJECT_COUNT_PER_PIPELINE)  UINT NumRects,
+            _In_reads_( NumRects)  const D3D12_RECT *pRects);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, OMSetBlendFactor)
+        void ( STDMETHODCALLTYPE *OMSetBlendFactor )( 
+            ID3D12GraphicsCommandList1 * This,
+            _In_reads_opt_(4)  const FLOAT BlendFactor[ 4 ]);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, OMSetStencilRef)
+        void ( STDMETHODCALLTYPE *OMSetStencilRef )( 
+            ID3D12GraphicsCommandList1 * This,
+            _In_  UINT StencilRef);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetPipelineState)
+        void ( STDMETHODCALLTYPE *SetPipelineState )( 
+            ID3D12GraphicsCommandList1 * This,
+            _In_  ID3D12PipelineState *pPipelineState);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, ResourceBarrier)
+        void ( STDMETHODCALLTYPE *ResourceBarrier )( 
+            ID3D12GraphicsCommandList1 * This,
+            _In_  UINT NumBarriers,
+            _In_reads_(NumBarriers)  const D3D12_RESOURCE_BARRIER *pBarriers);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, ExecuteBundle)
+        void ( STDMETHODCALLTYPE *ExecuteBundle )( 
+            ID3D12GraphicsCommandList1 * This,
+            _In_  ID3D12GraphicsCommandList *pCommandList);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetDescriptorHeaps)
+        void ( STDMETHODCALLTYPE *SetDescriptorHeaps )( 
+            ID3D12GraphicsCommandList1 * This,
+            _In_  UINT NumDescriptorHeaps,
+            _In_reads_(NumDescriptorHeaps)  ID3D12DescriptorHeap *const *ppDescriptorHeaps);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetComputeRootSignature)
+        void ( STDMETHODCALLTYPE *SetComputeRootSignature )( 
+            ID3D12GraphicsCommandList1 * This,
+            _In_opt_  ID3D12RootSignature *pRootSignature);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetGraphicsRootSignature)
+        void ( STDMETHODCALLTYPE *SetGraphicsRootSignature )( 
+            ID3D12GraphicsCommandList1 * This,
+            _In_opt_  ID3D12RootSignature *pRootSignature);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetComputeRootDescriptorTable)
+        void ( STDMETHODCALLTYPE *SetComputeRootDescriptorTable )( 
+            ID3D12GraphicsCommandList1 * This,
+            _In_  UINT RootParameterIndex,
+            _In_  D3D12_GPU_DESCRIPTOR_HANDLE BaseDescriptor);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetGraphicsRootDescriptorTable)
+        void ( STDMETHODCALLTYPE *SetGraphicsRootDescriptorTable )( 
+            ID3D12GraphicsCommandList1 * This,
+            _In_  UINT RootParameterIndex,
+            _In_  D3D12_GPU_DESCRIPTOR_HANDLE BaseDescriptor);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetComputeRoot32BitConstant)
+        void ( STDMETHODCALLTYPE *SetComputeRoot32BitConstant )( 
+            ID3D12GraphicsCommandList1 * This,
+            _In_  UINT RootParameterIndex,
+            _In_  UINT SrcData,
+            _In_  UINT DestOffsetIn32BitValues);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetGraphicsRoot32BitConstant)
+        void ( STDMETHODCALLTYPE *SetGraphicsRoot32BitConstant )( 
+            ID3D12GraphicsCommandList1 * This,
+            _In_  UINT RootParameterIndex,
+            _In_  UINT SrcData,
+            _In_  UINT DestOffsetIn32BitValues);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetComputeRoot32BitConstants)
+        void ( STDMETHODCALLTYPE *SetComputeRoot32BitConstants )( 
+            ID3D12GraphicsCommandList1 * This,
+            _In_  UINT RootParameterIndex,
+            _In_  UINT Num32BitValuesToSet,
+            _In_reads_(Num32BitValuesToSet*sizeof(UINT))  const void *pSrcData,
+            _In_  UINT DestOffsetIn32BitValues);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetGraphicsRoot32BitConstants)
+        void ( STDMETHODCALLTYPE *SetGraphicsRoot32BitConstants )( 
+            ID3D12GraphicsCommandList1 * This,
+            _In_  UINT RootParameterIndex,
+            _In_  UINT Num32BitValuesToSet,
+            _In_reads_(Num32BitValuesToSet*sizeof(UINT))  const void *pSrcData,
+            _In_  UINT DestOffsetIn32BitValues);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetComputeRootConstantBufferView)
+        void ( STDMETHODCALLTYPE *SetComputeRootConstantBufferView )( 
+            ID3D12GraphicsCommandList1 * This,
+            _In_  UINT RootParameterIndex,
+            _In_  D3D12_GPU_VIRTUAL_ADDRESS BufferLocation);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetGraphicsRootConstantBufferView)
+        void ( STDMETHODCALLTYPE *SetGraphicsRootConstantBufferView )( 
+            ID3D12GraphicsCommandList1 * This,
+            _In_  UINT RootParameterIndex,
+            _In_  D3D12_GPU_VIRTUAL_ADDRESS BufferLocation);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetComputeRootShaderResourceView)
+        void ( STDMETHODCALLTYPE *SetComputeRootShaderResourceView )( 
+            ID3D12GraphicsCommandList1 * This,
+            _In_  UINT RootParameterIndex,
+            _In_  D3D12_GPU_VIRTUAL_ADDRESS BufferLocation);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetGraphicsRootShaderResourceView)
+        void ( STDMETHODCALLTYPE *SetGraphicsRootShaderResourceView )( 
+            ID3D12GraphicsCommandList1 * This,
+            _In_  UINT RootParameterIndex,
+            _In_  D3D12_GPU_VIRTUAL_ADDRESS BufferLocation);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetComputeRootUnorderedAccessView)
+        void ( STDMETHODCALLTYPE *SetComputeRootUnorderedAccessView )( 
+            ID3D12GraphicsCommandList1 * This,
+            _In_  UINT RootParameterIndex,
+            _In_  D3D12_GPU_VIRTUAL_ADDRESS BufferLocation);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetGraphicsRootUnorderedAccessView)
+        void ( STDMETHODCALLTYPE *SetGraphicsRootUnorderedAccessView )( 
+            ID3D12GraphicsCommandList1 * This,
+            _In_  UINT RootParameterIndex,
+            _In_  D3D12_GPU_VIRTUAL_ADDRESS BufferLocation);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, IASetIndexBuffer)
+        void ( STDMETHODCALLTYPE *IASetIndexBuffer )( 
+            ID3D12GraphicsCommandList1 * This,
+            _In_opt_  const D3D12_INDEX_BUFFER_VIEW *pView);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, IASetVertexBuffers)
+        void ( STDMETHODCALLTYPE *IASetVertexBuffers )( 
+            ID3D12GraphicsCommandList1 * This,
+            _In_  UINT StartSlot,
+            _In_  UINT NumViews,
+            _In_reads_opt_(NumViews)  const D3D12_VERTEX_BUFFER_VIEW *pViews);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SOSetTargets)
+        void ( STDMETHODCALLTYPE *SOSetTargets )( 
+            ID3D12GraphicsCommandList1 * This,
+            _In_  UINT StartSlot,
+            _In_  UINT NumViews,
+            _In_reads_opt_(NumViews)  const D3D12_STREAM_OUTPUT_BUFFER_VIEW *pViews);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, OMSetRenderTargets)
+        void ( STDMETHODCALLTYPE *OMSetRenderTargets )( 
+            ID3D12GraphicsCommandList1 * This,
+            _In_  UINT NumRenderTargetDescriptors,
+            _In_opt_  const D3D12_CPU_DESCRIPTOR_HANDLE *pRenderTargetDescriptors,
+            _In_  BOOL RTsSingleHandleToDescriptorRange,
+            _In_opt_  const D3D12_CPU_DESCRIPTOR_HANDLE *pDepthStencilDescriptor);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, ClearDepthStencilView)
+        void ( STDMETHODCALLTYPE *ClearDepthStencilView )( 
+            ID3D12GraphicsCommandList1 * This,
+            _In_  D3D12_CPU_DESCRIPTOR_HANDLE DepthStencilView,
+            _In_  D3D12_CLEAR_FLAGS ClearFlags,
+            _In_  FLOAT Depth,
+            _In_  UINT8 Stencil,
+            _In_  UINT NumRects,
+            _In_reads_(NumRects)  const D3D12_RECT *pRects);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, ClearRenderTargetView)
+        void ( STDMETHODCALLTYPE *ClearRenderTargetView )( 
+            ID3D12GraphicsCommandList1 * This,
+            _In_  D3D12_CPU_DESCRIPTOR_HANDLE RenderTargetView,
+            _In_  const FLOAT ColorRGBA[ 4 ],
+            _In_  UINT NumRects,
+            _In_reads_(NumRects)  const D3D12_RECT *pRects);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, ClearUnorderedAccessViewUint)
+        void ( STDMETHODCALLTYPE *ClearUnorderedAccessViewUint )( 
+            ID3D12GraphicsCommandList1 * This,
+            _In_  D3D12_GPU_DESCRIPTOR_HANDLE ViewGPUHandleInCurrentHeap,
+            _In_  D3D12_CPU_DESCRIPTOR_HANDLE ViewCPUHandle,
+            _In_  ID3D12Resource *pResource,
+            _In_  const UINT Values[ 4 ],
+            _In_  UINT NumRects,
+            _In_reads_(NumRects)  const D3D12_RECT *pRects);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, ClearUnorderedAccessViewFloat)
+        void ( STDMETHODCALLTYPE *ClearUnorderedAccessViewFloat )( 
+            ID3D12GraphicsCommandList1 * This,
+            _In_  D3D12_GPU_DESCRIPTOR_HANDLE ViewGPUHandleInCurrentHeap,
+            _In_  D3D12_CPU_DESCRIPTOR_HANDLE ViewCPUHandle,
+            _In_  ID3D12Resource *pResource,
+            _In_  const FLOAT Values[ 4 ],
+            _In_  UINT NumRects,
+            _In_reads_(NumRects)  const D3D12_RECT *pRects);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, DiscardResource)
+        void ( STDMETHODCALLTYPE *DiscardResource )( 
+            ID3D12GraphicsCommandList1 * This,
+            _In_  ID3D12Resource *pResource,
+            _In_opt_  const D3D12_DISCARD_REGION *pRegion);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, BeginQuery)
+        void ( STDMETHODCALLTYPE *BeginQuery )( 
+            ID3D12GraphicsCommandList1 * This,
+            _In_  ID3D12QueryHeap *pQueryHeap,
+            _In_  D3D12_QUERY_TYPE Type,
+            _In_  UINT Index);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, EndQuery)
+        void ( STDMETHODCALLTYPE *EndQuery )( 
+            ID3D12GraphicsCommandList1 * This,
+            _In_  ID3D12QueryHeap *pQueryHeap,
+            _In_  D3D12_QUERY_TYPE Type,
+            _In_  UINT Index);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, ResolveQueryData)
+        void ( STDMETHODCALLTYPE *ResolveQueryData )( 
+            ID3D12GraphicsCommandList1 * This,
+            _In_  ID3D12QueryHeap *pQueryHeap,
+            _In_  D3D12_QUERY_TYPE Type,
+            _In_  UINT StartIndex,
+            _In_  UINT NumQueries,
+            _In_  ID3D12Resource *pDestinationBuffer,
+            _In_  UINT64 AlignedDestinationBufferOffset);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetPredication)
+        void ( STDMETHODCALLTYPE *SetPredication )( 
+            ID3D12GraphicsCommandList1 * This,
+            _In_opt_  ID3D12Resource *pBuffer,
+            _In_  UINT64 AlignedBufferOffset,
+            _In_  D3D12_PREDICATION_OP Operation);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetMarker)
+        void ( STDMETHODCALLTYPE *SetMarker )( 
+            ID3D12GraphicsCommandList1 * This,
+            UINT Metadata,
+            _In_reads_bytes_opt_(Size)  const void *pData,
+            UINT Size);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, BeginEvent)
+        void ( STDMETHODCALLTYPE *BeginEvent )( 
+            ID3D12GraphicsCommandList1 * This,
+            UINT Metadata,
+            _In_reads_bytes_opt_(Size)  const void *pData,
+            UINT Size);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, EndEvent)
+        void ( STDMETHODCALLTYPE *EndEvent )( 
+            ID3D12GraphicsCommandList1 * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, ExecuteIndirect)
+        void ( STDMETHODCALLTYPE *ExecuteIndirect )( 
+            ID3D12GraphicsCommandList1 * This,
+            _In_  ID3D12CommandSignature *pCommandSignature,
+            _In_  UINT MaxCommandCount,
+            _In_  ID3D12Resource *pArgumentBuffer,
+            _In_  UINT64 ArgumentBufferOffset,
+            _In_opt_  ID3D12Resource *pCountBuffer,
+            _In_  UINT64 CountBufferOffset);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList1, AtomicCopyBufferUINT)
+        void ( STDMETHODCALLTYPE *AtomicCopyBufferUINT )( 
+            ID3D12GraphicsCommandList1 * This,
+            _In_  ID3D12Resource *pDstBuffer,
+            UINT64 DstOffset,
+            _In_  ID3D12Resource *pSrcBuffer,
+            UINT64 SrcOffset,
+            UINT Dependencies,
+            _In_reads_(Dependencies)  ID3D12Resource *const *ppDependentResources,
+            _In_reads_(Dependencies)  const D3D12_SUBRESOURCE_RANGE_UINT64 *pDependentSubresourceRanges);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList1, AtomicCopyBufferUINT64)
+        void ( STDMETHODCALLTYPE *AtomicCopyBufferUINT64 )( 
+            ID3D12GraphicsCommandList1 * This,
+            _In_  ID3D12Resource *pDstBuffer,
+            UINT64 DstOffset,
+            _In_  ID3D12Resource *pSrcBuffer,
+            UINT64 SrcOffset,
+            UINT Dependencies,
+            _In_reads_(Dependencies)  ID3D12Resource *const *ppDependentResources,
+            _In_reads_(Dependencies)  const D3D12_SUBRESOURCE_RANGE_UINT64 *pDependentSubresourceRanges);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList1, OMSetDepthBounds)
+        void ( STDMETHODCALLTYPE *OMSetDepthBounds )( 
+            ID3D12GraphicsCommandList1 * This,
+            _In_  FLOAT Min,
+            _In_  FLOAT Max);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList1, SetSamplePositions)
+        void ( STDMETHODCALLTYPE *SetSamplePositions )( 
+            ID3D12GraphicsCommandList1 * This,
+            _In_  UINT NumSamplesPerPixel,
+            _In_  UINT NumPixels,
+            _In_reads_(NumSamplesPerPixel*NumPixels)  D3D12_SAMPLE_POSITION *pSamplePositions);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList1, ResolveSubresourceRegion)
+        void ( STDMETHODCALLTYPE *ResolveSubresourceRegion )( 
+            ID3D12GraphicsCommandList1 * This,
+            _In_  ID3D12Resource *pDstResource,
+            _In_  UINT DstSubresource,
+            _In_  UINT DstX,
+            _In_  UINT DstY,
+            _In_  ID3D12Resource *pSrcResource,
+            _In_  UINT SrcSubresource,
+            _In_opt_  D3D12_RECT *pSrcRect,
+            _In_  DXGI_FORMAT Format,
+            _In_  D3D12_RESOLVE_MODE ResolveMode);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList1, SetViewInstanceMask)
+        void ( STDMETHODCALLTYPE *SetViewInstanceMask )( 
+            ID3D12GraphicsCommandList1 * This,
+            _In_  UINT Mask);
+        
+        END_INTERFACE
+    } ID3D12GraphicsCommandList1Vtbl;
+
+    interface ID3D12GraphicsCommandList1
+    {
+        CONST_VTBL struct ID3D12GraphicsCommandList1Vtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define ID3D12GraphicsCommandList1_QueryInterface(This,riid,ppvObject)	\
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define ID3D12GraphicsCommandList1_AddRef(This)	\
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define ID3D12GraphicsCommandList1_Release(This)	\
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#define ID3D12GraphicsCommandList1_GetPrivateData(This,guid,pDataSize,pData)	\
+    ( (This)->lpVtbl -> GetPrivateData(This,guid,pDataSize,pData) ) 
+
+#define ID3D12GraphicsCommandList1_SetPrivateData(This,guid,DataSize,pData)	\
+    ( (This)->lpVtbl -> SetPrivateData(This,guid,DataSize,pData) ) 
+
+#define ID3D12GraphicsCommandList1_SetPrivateDataInterface(This,guid,pData)	\
+    ( (This)->lpVtbl -> SetPrivateDataInterface(This,guid,pData) ) 
+
+#define ID3D12GraphicsCommandList1_SetName(This,Name)	\
+    ( (This)->lpVtbl -> SetName(This,Name) ) 
+
+
+#define ID3D12GraphicsCommandList1_GetDevice(This,riid,ppvDevice)	\
+    ( (This)->lpVtbl -> GetDevice(This,riid,ppvDevice) ) 
+
+
+#define ID3D12GraphicsCommandList1_GetType(This)	\
+    ( (This)->lpVtbl -> GetType(This) ) 
+
+
+#define ID3D12GraphicsCommandList1_Close(This)	\
+    ( (This)->lpVtbl -> Close(This) ) 
+
+#define ID3D12GraphicsCommandList1_Reset(This,pAllocator,pInitialState)	\
+    ( (This)->lpVtbl -> Reset(This,pAllocator,pInitialState) ) 
+
+#define ID3D12GraphicsCommandList1_ClearState(This,pPipelineState)	\
+    ( (This)->lpVtbl -> ClearState(This,pPipelineState) ) 
+
+#define ID3D12GraphicsCommandList1_DrawInstanced(This,VertexCountPerInstance,InstanceCount,StartVertexLocation,StartInstanceLocation)	\
+    ( (This)->lpVtbl -> DrawInstanced(This,VertexCountPerInstance,InstanceCount,StartVertexLocation,StartInstanceLocation) ) 
+
+#define ID3D12GraphicsCommandList1_DrawIndexedInstanced(This,IndexCountPerInstance,InstanceCount,StartIndexLocation,BaseVertexLocation,StartInstanceLocation)	\
+    ( (This)->lpVtbl -> DrawIndexedInstanced(This,IndexCountPerInstance,InstanceCount,StartIndexLocation,BaseVertexLocation,StartInstanceLocation) ) 
+
+#define ID3D12GraphicsCommandList1_Dispatch(This,ThreadGroupCountX,ThreadGroupCountY,ThreadGroupCountZ)	\
+    ( (This)->lpVtbl -> Dispatch(This,ThreadGroupCountX,ThreadGroupCountY,ThreadGroupCountZ) ) 
+
+#define ID3D12GraphicsCommandList1_CopyBufferRegion(This,pDstBuffer,DstOffset,pSrcBuffer,SrcOffset,NumBytes)	\
+    ( (This)->lpVtbl -> CopyBufferRegion(This,pDstBuffer,DstOffset,pSrcBuffer,SrcOffset,NumBytes) ) 
+
+#define ID3D12GraphicsCommandList1_CopyTextureRegion(This,pDst,DstX,DstY,DstZ,pSrc,pSrcBox)	\
+    ( (This)->lpVtbl -> CopyTextureRegion(This,pDst,DstX,DstY,DstZ,pSrc,pSrcBox) ) 
+
+#define ID3D12GraphicsCommandList1_CopyResource(This,pDstResource,pSrcResource)	\
+    ( (This)->lpVtbl -> CopyResource(This,pDstResource,pSrcResource) ) 
+
+#define ID3D12GraphicsCommandList1_CopyTiles(This,pTiledResource,pTileRegionStartCoordinate,pTileRegionSize,pBuffer,BufferStartOffsetInBytes,Flags)	\
+    ( (This)->lpVtbl -> CopyTiles(This,pTiledResource,pTileRegionStartCoordinate,pTileRegionSize,pBuffer,BufferStartOffsetInBytes,Flags) ) 
+
+#define ID3D12GraphicsCommandList1_ResolveSubresource(This,pDstResource,DstSubresource,pSrcResource,SrcSubresource,Format)	\
+    ( (This)->lpVtbl -> ResolveSubresource(This,pDstResource,DstSubresource,pSrcResource,SrcSubresource,Format) ) 
+
+#define ID3D12GraphicsCommandList1_IASetPrimitiveTopology(This,PrimitiveTopology)	\
+    ( (This)->lpVtbl -> IASetPrimitiveTopology(This,PrimitiveTopology) ) 
+
+#define ID3D12GraphicsCommandList1_RSSetViewports(This,NumViewports,pViewports)	\
+    ( (This)->lpVtbl -> RSSetViewports(This,NumViewports,pViewports) ) 
+
+#define ID3D12GraphicsCommandList1_RSSetScissorRects(This,NumRects,pRects)	\
+    ( (This)->lpVtbl -> RSSetScissorRects(This,NumRects,pRects) ) 
+
+#define ID3D12GraphicsCommandList1_OMSetBlendFactor(This,BlendFactor)	\
+    ( (This)->lpVtbl -> OMSetBlendFactor(This,BlendFactor) ) 
+
+#define ID3D12GraphicsCommandList1_OMSetStencilRef(This,StencilRef)	\
+    ( (This)->lpVtbl -> OMSetStencilRef(This,StencilRef) ) 
+
+#define ID3D12GraphicsCommandList1_SetPipelineState(This,pPipelineState)	\
+    ( (This)->lpVtbl -> SetPipelineState(This,pPipelineState) ) 
+
+#define ID3D12GraphicsCommandList1_ResourceBarrier(This,NumBarriers,pBarriers)	\
+    ( (This)->lpVtbl -> ResourceBarrier(This,NumBarriers,pBarriers) ) 
+
+#define ID3D12GraphicsCommandList1_ExecuteBundle(This,pCommandList)	\
+    ( (This)->lpVtbl -> ExecuteBundle(This,pCommandList) ) 
+
+#define ID3D12GraphicsCommandList1_SetDescriptorHeaps(This,NumDescriptorHeaps,ppDescriptorHeaps)	\
+    ( (This)->lpVtbl -> SetDescriptorHeaps(This,NumDescriptorHeaps,ppDescriptorHeaps) ) 
+
+#define ID3D12GraphicsCommandList1_SetComputeRootSignature(This,pRootSignature)	\
+    ( (This)->lpVtbl -> SetComputeRootSignature(This,pRootSignature) ) 
+
+#define ID3D12GraphicsCommandList1_SetGraphicsRootSignature(This,pRootSignature)	\
+    ( (This)->lpVtbl -> SetGraphicsRootSignature(This,pRootSignature) ) 
+
+#define ID3D12GraphicsCommandList1_SetComputeRootDescriptorTable(This,RootParameterIndex,BaseDescriptor)	\
+    ( (This)->lpVtbl -> SetComputeRootDescriptorTable(This,RootParameterIndex,BaseDescriptor) ) 
+
+#define ID3D12GraphicsCommandList1_SetGraphicsRootDescriptorTable(This,RootParameterIndex,BaseDescriptor)	\
+    ( (This)->lpVtbl -> SetGraphicsRootDescriptorTable(This,RootParameterIndex,BaseDescriptor) ) 
+
+#define ID3D12GraphicsCommandList1_SetComputeRoot32BitConstant(This,RootParameterIndex,SrcData,DestOffsetIn32BitValues)	\
+    ( (This)->lpVtbl -> SetComputeRoot32BitConstant(This,RootParameterIndex,SrcData,DestOffsetIn32BitValues) ) 
+
+#define ID3D12GraphicsCommandList1_SetGraphicsRoot32BitConstant(This,RootParameterIndex,SrcData,DestOffsetIn32BitValues)	\
+    ( (This)->lpVtbl -> SetGraphicsRoot32BitConstant(This,RootParameterIndex,SrcData,DestOffsetIn32BitValues) ) 
+
+#define ID3D12GraphicsCommandList1_SetComputeRoot32BitConstants(This,RootParameterIndex,Num32BitValuesToSet,pSrcData,DestOffsetIn32BitValues)	\
+    ( (This)->lpVtbl -> SetComputeRoot32BitConstants(This,RootParameterIndex,Num32BitValuesToSet,pSrcData,DestOffsetIn32BitValues) ) 
+
+#define ID3D12GraphicsCommandList1_SetGraphicsRoot32BitConstants(This,RootParameterIndex,Num32BitValuesToSet,pSrcData,DestOffsetIn32BitValues)	\
+    ( (This)->lpVtbl -> SetGraphicsRoot32BitConstants(This,RootParameterIndex,Num32BitValuesToSet,pSrcData,DestOffsetIn32BitValues) ) 
+
+#define ID3D12GraphicsCommandList1_SetComputeRootConstantBufferView(This,RootParameterIndex,BufferLocation)	\
+    ( (This)->lpVtbl -> SetComputeRootConstantBufferView(This,RootParameterIndex,BufferLocation) ) 
+
+#define ID3D12GraphicsCommandList1_SetGraphicsRootConstantBufferView(This,RootParameterIndex,BufferLocation)	\
+    ( (This)->lpVtbl -> SetGraphicsRootConstantBufferView(This,RootParameterIndex,BufferLocation) ) 
+
+#define ID3D12GraphicsCommandList1_SetComputeRootShaderResourceView(This,RootParameterIndex,BufferLocation)	\
+    ( (This)->lpVtbl -> SetComputeRootShaderResourceView(This,RootParameterIndex,BufferLocation) ) 
+
+#define ID3D12GraphicsCommandList1_SetGraphicsRootShaderResourceView(This,RootParameterIndex,BufferLocation)	\
+    ( (This)->lpVtbl -> SetGraphicsRootShaderResourceView(This,RootParameterIndex,BufferLocation) ) 
+
+#define ID3D12GraphicsCommandList1_SetComputeRootUnorderedAccessView(This,RootParameterIndex,BufferLocation)	\
+    ( (This)->lpVtbl -> SetComputeRootUnorderedAccessView(This,RootParameterIndex,BufferLocation) ) 
+
+#define ID3D12GraphicsCommandList1_SetGraphicsRootUnorderedAccessView(This,RootParameterIndex,BufferLocation)	\
+    ( (This)->lpVtbl -> SetGraphicsRootUnorderedAccessView(This,RootParameterIndex,BufferLocation) ) 
+
+#define ID3D12GraphicsCommandList1_IASetIndexBuffer(This,pView)	\
+    ( (This)->lpVtbl -> IASetIndexBuffer(This,pView) ) 
+
+#define ID3D12GraphicsCommandList1_IASetVertexBuffers(This,StartSlot,NumViews,pViews)	\
+    ( (This)->lpVtbl -> IASetVertexBuffers(This,StartSlot,NumViews,pViews) ) 
+
+#define ID3D12GraphicsCommandList1_SOSetTargets(This,StartSlot,NumViews,pViews)	\
+    ( (This)->lpVtbl -> SOSetTargets(This,StartSlot,NumViews,pViews) ) 
+
+#define ID3D12GraphicsCommandList1_OMSetRenderTargets(This,NumRenderTargetDescriptors,pRenderTargetDescriptors,RTsSingleHandleToDescriptorRange,pDepthStencilDescriptor)	\
+    ( (This)->lpVtbl -> OMSetRenderTargets(This,NumRenderTargetDescriptors,pRenderTargetDescriptors,RTsSingleHandleToDescriptorRange,pDepthStencilDescriptor) ) 
+
+#define ID3D12GraphicsCommandList1_ClearDepthStencilView(This,DepthStencilView,ClearFlags,Depth,Stencil,NumRects,pRects)	\
+    ( (This)->lpVtbl -> ClearDepthStencilView(This,DepthStencilView,ClearFlags,Depth,Stencil,NumRects,pRects) ) 
+
+#define ID3D12GraphicsCommandList1_ClearRenderTargetView(This,RenderTargetView,ColorRGBA,NumRects,pRects)	\
+    ( (This)->lpVtbl -> ClearRenderTargetView(This,RenderTargetView,ColorRGBA,NumRects,pRects) ) 
+
+#define ID3D12GraphicsCommandList1_ClearUnorderedAccessViewUint(This,ViewGPUHandleInCurrentHeap,ViewCPUHandle,pResource,Values,NumRects,pRects)	\
+    ( (This)->lpVtbl -> ClearUnorderedAccessViewUint(This,ViewGPUHandleInCurrentHeap,ViewCPUHandle,pResource,Values,NumRects,pRects) ) 
+
+#define ID3D12GraphicsCommandList1_ClearUnorderedAccessViewFloat(This,ViewGPUHandleInCurrentHeap,ViewCPUHandle,pResource,Values,NumRects,pRects)	\
+    ( (This)->lpVtbl -> ClearUnorderedAccessViewFloat(This,ViewGPUHandleInCurrentHeap,ViewCPUHandle,pResource,Values,NumRects,pRects) ) 
+
+#define ID3D12GraphicsCommandList1_DiscardResource(This,pResource,pRegion)	\
+    ( (This)->lpVtbl -> DiscardResource(This,pResource,pRegion) ) 
+
+#define ID3D12GraphicsCommandList1_BeginQuery(This,pQueryHeap,Type,Index)	\
+    ( (This)->lpVtbl -> BeginQuery(This,pQueryHeap,Type,Index) ) 
+
+#define ID3D12GraphicsCommandList1_EndQuery(This,pQueryHeap,Type,Index)	\
+    ( (This)->lpVtbl -> EndQuery(This,pQueryHeap,Type,Index) ) 
+
+#define ID3D12GraphicsCommandList1_ResolveQueryData(This,pQueryHeap,Type,StartIndex,NumQueries,pDestinationBuffer,AlignedDestinationBufferOffset)	\
+    ( (This)->lpVtbl -> ResolveQueryData(This,pQueryHeap,Type,StartIndex,NumQueries,pDestinationBuffer,AlignedDestinationBufferOffset) ) 
+
+#define ID3D12GraphicsCommandList1_SetPredication(This,pBuffer,AlignedBufferOffset,Operation)	\
+    ( (This)->lpVtbl -> SetPredication(This,pBuffer,AlignedBufferOffset,Operation) ) 
+
+#define ID3D12GraphicsCommandList1_SetMarker(This,Metadata,pData,Size)	\
+    ( (This)->lpVtbl -> SetMarker(This,Metadata,pData,Size) ) 
+
+#define ID3D12GraphicsCommandList1_BeginEvent(This,Metadata,pData,Size)	\
+    ( (This)->lpVtbl -> BeginEvent(This,Metadata,pData,Size) ) 
+
+#define ID3D12GraphicsCommandList1_EndEvent(This)	\
+    ( (This)->lpVtbl -> EndEvent(This) ) 
+
+#define ID3D12GraphicsCommandList1_ExecuteIndirect(This,pCommandSignature,MaxCommandCount,pArgumentBuffer,ArgumentBufferOffset,pCountBuffer,CountBufferOffset)	\
+    ( (This)->lpVtbl -> ExecuteIndirect(This,pCommandSignature,MaxCommandCount,pArgumentBuffer,ArgumentBufferOffset,pCountBuffer,CountBufferOffset) ) 
+
+
+#define ID3D12GraphicsCommandList1_AtomicCopyBufferUINT(This,pDstBuffer,DstOffset,pSrcBuffer,SrcOffset,Dependencies,ppDependentResources,pDependentSubresourceRanges)	\
+    ( (This)->lpVtbl -> AtomicCopyBufferUINT(This,pDstBuffer,DstOffset,pSrcBuffer,SrcOffset,Dependencies,ppDependentResources,pDependentSubresourceRanges) ) 
+
+#define ID3D12GraphicsCommandList1_AtomicCopyBufferUINT64(This,pDstBuffer,DstOffset,pSrcBuffer,SrcOffset,Dependencies,ppDependentResources,pDependentSubresourceRanges)	\
+    ( (This)->lpVtbl -> AtomicCopyBufferUINT64(This,pDstBuffer,DstOffset,pSrcBuffer,SrcOffset,Dependencies,ppDependentResources,pDependentSubresourceRanges) ) 
+
+#define ID3D12GraphicsCommandList1_OMSetDepthBounds(This,Min,Max)	\
+    ( (This)->lpVtbl -> OMSetDepthBounds(This,Min,Max) ) 
+
+#define ID3D12GraphicsCommandList1_SetSamplePositions(This,NumSamplesPerPixel,NumPixels,pSamplePositions)	\
+    ( (This)->lpVtbl -> SetSamplePositions(This,NumSamplesPerPixel,NumPixels,pSamplePositions) ) 
+
+#define ID3D12GraphicsCommandList1_ResolveSubresourceRegion(This,pDstResource,DstSubresource,DstX,DstY,pSrcResource,SrcSubresource,pSrcRect,Format,ResolveMode)	\
+    ( (This)->lpVtbl -> ResolveSubresourceRegion(This,pDstResource,DstSubresource,DstX,DstY,pSrcResource,SrcSubresource,pSrcRect,Format,ResolveMode) ) 
+
+#define ID3D12GraphicsCommandList1_SetViewInstanceMask(This,Mask)	\
+    ( (This)->lpVtbl -> SetViewInstanceMask(This,Mask) ) 
+
+#endif /* COBJMACROS */
+
+
+#endif 	/* C style interface */
+
+
+
+
+#endif 	/* __ID3D12GraphicsCommandList1_INTERFACE_DEFINED__ */
+
+
+/* interface __MIDL_itf_d3d12_0000_0018 */
+/* [local] */ 
+
+typedef struct D3D12_WRITEBUFFERIMMEDIATE_PARAMETER
+    {
+    D3D12_GPU_VIRTUAL_ADDRESS Dest;
+    UINT32 Value;
+    } 	D3D12_WRITEBUFFERIMMEDIATE_PARAMETER;
+
+typedef 
+enum D3D12_WRITEBUFFERIMMEDIATE_MODE
+    {
+        D3D12_WRITEBUFFERIMMEDIATE_MODE_DEFAULT	= 0,
+        D3D12_WRITEBUFFERIMMEDIATE_MODE_MARKER_IN	= 0x1,
+        D3D12_WRITEBUFFERIMMEDIATE_MODE_MARKER_OUT	= 0x2
+    } 	D3D12_WRITEBUFFERIMMEDIATE_MODE;
+
+
+
+extern RPC_IF_HANDLE __MIDL_itf_d3d12_0000_0018_v0_0_c_ifspec;
+extern RPC_IF_HANDLE __MIDL_itf_d3d12_0000_0018_v0_0_s_ifspec;
+
+#ifndef __ID3D12GraphicsCommandList2_INTERFACE_DEFINED__
+#define __ID3D12GraphicsCommandList2_INTERFACE_DEFINED__
+
+/* interface ID3D12GraphicsCommandList2 */
+/* [unique][local][object][uuid] */ 
+
+
+EXTERN_C const IID IID_ID3D12GraphicsCommandList2;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("38C3E585-FF17-412C-9150-4FC6F9D72A28")
+    ID3D12GraphicsCommandList2 : public ID3D12GraphicsCommandList1
+    {
+    public:
+        virtual void STDMETHODCALLTYPE WriteBufferImmediate( 
+            UINT Count,
+            _In_reads_(Count)  const D3D12_WRITEBUFFERIMMEDIATE_PARAMETER *pParams,
+            _In_reads_opt_(Count)  const D3D12_WRITEBUFFERIMMEDIATE_MODE *pModes) = 0;
+        
+    };
+    
+    
+#else 	/* C style interface */
+
+    typedef struct ID3D12GraphicsCommandList2Vtbl
+    {
+        BEGIN_INTERFACE
+        
+        DECLSPEC_XFGVIRT(IUnknown, QueryInterface)
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            ID3D12GraphicsCommandList2 * This,
+            REFIID riid,
+            _COM_Outptr_  void **ppvObject);
+        
+        DECLSPEC_XFGVIRT(IUnknown, AddRef)
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            ID3D12GraphicsCommandList2 * This);
+        
+        DECLSPEC_XFGVIRT(IUnknown, Release)
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            ID3D12GraphicsCommandList2 * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, GetPrivateData)
+        HRESULT ( STDMETHODCALLTYPE *GetPrivateData )( 
+            ID3D12GraphicsCommandList2 * This,
+            _In_  REFGUID guid,
+            _Inout_  UINT *pDataSize,
+            _Out_writes_bytes_opt_( *pDataSize )  void *pData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, SetPrivateData)
+        HRESULT ( STDMETHODCALLTYPE *SetPrivateData )( 
+            ID3D12GraphicsCommandList2 * This,
+            _In_  REFGUID guid,
+            _In_  UINT DataSize,
+            _In_reads_bytes_opt_( DataSize )  const void *pData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, SetPrivateDataInterface)
+        HRESULT ( STDMETHODCALLTYPE *SetPrivateDataInterface )( 
+            ID3D12GraphicsCommandList2 * This,
+            _In_  REFGUID guid,
+            _In_opt_  const IUnknown *pData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, SetName)
+        HRESULT ( STDMETHODCALLTYPE *SetName )( 
+            ID3D12GraphicsCommandList2 * This,
+            _In_z_  LPCWSTR Name);
+        
+        DECLSPEC_XFGVIRT(ID3D12DeviceChild, GetDevice)
+        HRESULT ( STDMETHODCALLTYPE *GetDevice )( 
+            ID3D12GraphicsCommandList2 * This,
+            REFIID riid,
+            _COM_Outptr_opt_  void **ppvDevice);
+        
+        DECLSPEC_XFGVIRT(ID3D12CommandList, GetType)
+        D3D12_COMMAND_LIST_TYPE ( STDMETHODCALLTYPE *GetType )( 
+            ID3D12GraphicsCommandList2 * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, Close)
+        HRESULT ( STDMETHODCALLTYPE *Close )( 
+            ID3D12GraphicsCommandList2 * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, Reset)
+        HRESULT ( STDMETHODCALLTYPE *Reset )( 
+            ID3D12GraphicsCommandList2 * This,
+            _In_  ID3D12CommandAllocator *pAllocator,
+            _In_opt_  ID3D12PipelineState *pInitialState);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, ClearState)
+        void ( STDMETHODCALLTYPE *ClearState )( 
+            ID3D12GraphicsCommandList2 * This,
+            _In_opt_  ID3D12PipelineState *pPipelineState);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, DrawInstanced)
+        void ( STDMETHODCALLTYPE *DrawInstanced )( 
+            ID3D12GraphicsCommandList2 * This,
+            _In_  UINT VertexCountPerInstance,
+            _In_  UINT InstanceCount,
+            _In_  UINT StartVertexLocation,
+            _In_  UINT StartInstanceLocation);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, DrawIndexedInstanced)
+        void ( STDMETHODCALLTYPE *DrawIndexedInstanced )( 
+            ID3D12GraphicsCommandList2 * This,
+            _In_  UINT IndexCountPerInstance,
+            _In_  UINT InstanceCount,
+            _In_  UINT StartIndexLocation,
+            _In_  INT BaseVertexLocation,
+            _In_  UINT StartInstanceLocation);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, Dispatch)
+        void ( STDMETHODCALLTYPE *Dispatch )( 
+            ID3D12GraphicsCommandList2 * This,
+            _In_  UINT ThreadGroupCountX,
+            _In_  UINT ThreadGroupCountY,
+            _In_  UINT ThreadGroupCountZ);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, CopyBufferRegion)
+        void ( STDMETHODCALLTYPE *CopyBufferRegion )( 
+            ID3D12GraphicsCommandList2 * This,
+            _In_  ID3D12Resource *pDstBuffer,
+            UINT64 DstOffset,
+            _In_  ID3D12Resource *pSrcBuffer,
+            UINT64 SrcOffset,
+            UINT64 NumBytes);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, CopyTextureRegion)
+        void ( STDMETHODCALLTYPE *CopyTextureRegion )( 
+            ID3D12GraphicsCommandList2 * This,
+            _In_  const D3D12_TEXTURE_COPY_LOCATION *pDst,
+            UINT DstX,
+            UINT DstY,
+            UINT DstZ,
+            _In_  const D3D12_TEXTURE_COPY_LOCATION *pSrc,
+            _In_opt_  const D3D12_BOX *pSrcBox);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, CopyResource)
+        void ( STDMETHODCALLTYPE *CopyResource )( 
+            ID3D12GraphicsCommandList2 * This,
+            _In_  ID3D12Resource *pDstResource,
+            _In_  ID3D12Resource *pSrcResource);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, CopyTiles)
+        void ( STDMETHODCALLTYPE *CopyTiles )( 
+            ID3D12GraphicsCommandList2 * This,
+            _In_  ID3D12Resource *pTiledResource,
+            _In_  const D3D12_TILED_RESOURCE_COORDINATE *pTileRegionStartCoordinate,
+            _In_  const D3D12_TILE_REGION_SIZE *pTileRegionSize,
+            _In_  ID3D12Resource *pBuffer,
+            UINT64 BufferStartOffsetInBytes,
+            D3D12_TILE_COPY_FLAGS Flags);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, ResolveSubresource)
+        void ( STDMETHODCALLTYPE *ResolveSubresource )( 
+            ID3D12GraphicsCommandList2 * This,
+            _In_  ID3D12Resource *pDstResource,
+            _In_  UINT DstSubresource,
+            _In_  ID3D12Resource *pSrcResource,
+            _In_  UINT SrcSubresource,
+            _In_  DXGI_FORMAT Format);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, IASetPrimitiveTopology)
+        void ( STDMETHODCALLTYPE *IASetPrimitiveTopology )( 
+            ID3D12GraphicsCommandList2 * This,
+            _In_  D3D12_PRIMITIVE_TOPOLOGY PrimitiveTopology);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, RSSetViewports)
+        void ( STDMETHODCALLTYPE *RSSetViewports )( 
+            ID3D12GraphicsCommandList2 * This,
+            _In_range_(0, D3D12_VIEWPORT_AND_SCISSORRECT_OBJECT_COUNT_PER_PIPELINE)  UINT NumViewports,
+            _In_reads_( NumViewports)  const D3D12_VIEWPORT *pViewports);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, RSSetScissorRects)
+        void ( STDMETHODCALLTYPE *RSSetScissorRects )( 
+            ID3D12GraphicsCommandList2 * This,
+            _In_range_(0, D3D12_VIEWPORT_AND_SCISSORRECT_OBJECT_COUNT_PER_PIPELINE)  UINT NumRects,
+            _In_reads_( NumRects)  const D3D12_RECT *pRects);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, OMSetBlendFactor)
+        void ( STDMETHODCALLTYPE *OMSetBlendFactor )( 
+            ID3D12GraphicsCommandList2 * This,
+            _In_reads_opt_(4)  const FLOAT BlendFactor[ 4 ]);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, OMSetStencilRef)
+        void ( STDMETHODCALLTYPE *OMSetStencilRef )( 
+            ID3D12GraphicsCommandList2 * This,
+            _In_  UINT StencilRef);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetPipelineState)
+        void ( STDMETHODCALLTYPE *SetPipelineState )( 
+            ID3D12GraphicsCommandList2 * This,
+            _In_  ID3D12PipelineState *pPipelineState);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, ResourceBarrier)
+        void ( STDMETHODCALLTYPE *ResourceBarrier )( 
+            ID3D12GraphicsCommandList2 * This,
+            _In_  UINT NumBarriers,
+            _In_reads_(NumBarriers)  const D3D12_RESOURCE_BARRIER *pBarriers);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, ExecuteBundle)
+        void ( STDMETHODCALLTYPE *ExecuteBundle )( 
+            ID3D12GraphicsCommandList2 * This,
+            _In_  ID3D12GraphicsCommandList *pCommandList);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetDescriptorHeaps)
+        void ( STDMETHODCALLTYPE *SetDescriptorHeaps )( 
+            ID3D12GraphicsCommandList2 * This,
+            _In_  UINT NumDescriptorHeaps,
+            _In_reads_(NumDescriptorHeaps)  ID3D12DescriptorHeap *const *ppDescriptorHeaps);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetComputeRootSignature)
+        void ( STDMETHODCALLTYPE *SetComputeRootSignature )( 
+            ID3D12GraphicsCommandList2 * This,
+            _In_opt_  ID3D12RootSignature *pRootSignature);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetGraphicsRootSignature)
+        void ( STDMETHODCALLTYPE *SetGraphicsRootSignature )( 
+            ID3D12GraphicsCommandList2 * This,
+            _In_opt_  ID3D12RootSignature *pRootSignature);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetComputeRootDescriptorTable)
+        void ( STDMETHODCALLTYPE *SetComputeRootDescriptorTable )( 
+            ID3D12GraphicsCommandList2 * This,
+            _In_  UINT RootParameterIndex,
+            _In_  D3D12_GPU_DESCRIPTOR_HANDLE BaseDescriptor);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetGraphicsRootDescriptorTable)
+        void ( STDMETHODCALLTYPE *SetGraphicsRootDescriptorTable )( 
+            ID3D12GraphicsCommandList2 * This,
+            _In_  UINT RootParameterIndex,
+            _In_  D3D12_GPU_DESCRIPTOR_HANDLE BaseDescriptor);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetComputeRoot32BitConstant)
+        void ( STDMETHODCALLTYPE *SetComputeRoot32BitConstant )( 
+            ID3D12GraphicsCommandList2 * This,
+            _In_  UINT RootParameterIndex,
+            _In_  UINT SrcData,
+            _In_  UINT DestOffsetIn32BitValues);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetGraphicsRoot32BitConstant)
+        void ( STDMETHODCALLTYPE *SetGraphicsRoot32BitConstant )( 
+            ID3D12GraphicsCommandList2 * This,
+            _In_  UINT RootParameterIndex,
+            _In_  UINT SrcData,
+            _In_  UINT DestOffsetIn32BitValues);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetComputeRoot32BitConstants)
+        void ( STDMETHODCALLTYPE *SetComputeRoot32BitConstants )( 
+            ID3D12GraphicsCommandList2 * This,
+            _In_  UINT RootParameterIndex,
+            _In_  UINT Num32BitValuesToSet,
+            _In_reads_(Num32BitValuesToSet*sizeof(UINT))  const void *pSrcData,
+            _In_  UINT DestOffsetIn32BitValues);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetGraphicsRoot32BitConstants)
+        void ( STDMETHODCALLTYPE *SetGraphicsRoot32BitConstants )( 
+            ID3D12GraphicsCommandList2 * This,
+            _In_  UINT RootParameterIndex,
+            _In_  UINT Num32BitValuesToSet,
+            _In_reads_(Num32BitValuesToSet*sizeof(UINT))  const void *pSrcData,
+            _In_  UINT DestOffsetIn32BitValues);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetComputeRootConstantBufferView)
+        void ( STDMETHODCALLTYPE *SetComputeRootConstantBufferView )( 
+            ID3D12GraphicsCommandList2 * This,
+            _In_  UINT RootParameterIndex,
+            _In_  D3D12_GPU_VIRTUAL_ADDRESS BufferLocation);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetGraphicsRootConstantBufferView)
+        void ( STDMETHODCALLTYPE *SetGraphicsRootConstantBufferView )( 
+            ID3D12GraphicsCommandList2 * This,
+            _In_  UINT RootParameterIndex,
+            _In_  D3D12_GPU_VIRTUAL_ADDRESS BufferLocation);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetComputeRootShaderResourceView)
+        void ( STDMETHODCALLTYPE *SetComputeRootShaderResourceView )( 
+            ID3D12GraphicsCommandList2 * This,
+            _In_  UINT RootParameterIndex,
+            _In_  D3D12_GPU_VIRTUAL_ADDRESS BufferLocation);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetGraphicsRootShaderResourceView)
+        void ( STDMETHODCALLTYPE *SetGraphicsRootShaderResourceView )( 
+            ID3D12GraphicsCommandList2 * This,
+            _In_  UINT RootParameterIndex,
+            _In_  D3D12_GPU_VIRTUAL_ADDRESS BufferLocation);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetComputeRootUnorderedAccessView)
+        void ( STDMETHODCALLTYPE *SetComputeRootUnorderedAccessView )( 
+            ID3D12GraphicsCommandList2 * This,
+            _In_  UINT RootParameterIndex,
+            _In_  D3D12_GPU_VIRTUAL_ADDRESS BufferLocation);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetGraphicsRootUnorderedAccessView)
+        void ( STDMETHODCALLTYPE *SetGraphicsRootUnorderedAccessView )( 
+            ID3D12GraphicsCommandList2 * This,
+            _In_  UINT RootParameterIndex,
+            _In_  D3D12_GPU_VIRTUAL_ADDRESS BufferLocation);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, IASetIndexBuffer)
+        void ( STDMETHODCALLTYPE *IASetIndexBuffer )( 
+            ID3D12GraphicsCommandList2 * This,
+            _In_opt_  const D3D12_INDEX_BUFFER_VIEW *pView);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, IASetVertexBuffers)
+        void ( STDMETHODCALLTYPE *IASetVertexBuffers )( 
+            ID3D12GraphicsCommandList2 * This,
+            _In_  UINT StartSlot,
+            _In_  UINT NumViews,
+            _In_reads_opt_(NumViews)  const D3D12_VERTEX_BUFFER_VIEW *pViews);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SOSetTargets)
+        void ( STDMETHODCALLTYPE *SOSetTargets )( 
+            ID3D12GraphicsCommandList2 * This,
+            _In_  UINT StartSlot,
+            _In_  UINT NumViews,
+            _In_reads_opt_(NumViews)  const D3D12_STREAM_OUTPUT_BUFFER_VIEW *pViews);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, OMSetRenderTargets)
+        void ( STDMETHODCALLTYPE *OMSetRenderTargets )( 
+            ID3D12GraphicsCommandList2 * This,
+            _In_  UINT NumRenderTargetDescriptors,
+            _In_opt_  const D3D12_CPU_DESCRIPTOR_HANDLE *pRenderTargetDescriptors,
+            _In_  BOOL RTsSingleHandleToDescriptorRange,
+            _In_opt_  const D3D12_CPU_DESCRIPTOR_HANDLE *pDepthStencilDescriptor);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, ClearDepthStencilView)
+        void ( STDMETHODCALLTYPE *ClearDepthStencilView )( 
+            ID3D12GraphicsCommandList2 * This,
+            _In_  D3D12_CPU_DESCRIPTOR_HANDLE DepthStencilView,
+            _In_  D3D12_CLEAR_FLAGS ClearFlags,
+            _In_  FLOAT Depth,
+            _In_  UINT8 Stencil,
+            _In_  UINT NumRects,
+            _In_reads_(NumRects)  const D3D12_RECT *pRects);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, ClearRenderTargetView)
+        void ( STDMETHODCALLTYPE *ClearRenderTargetView )( 
+            ID3D12GraphicsCommandList2 * This,
+            _In_  D3D12_CPU_DESCRIPTOR_HANDLE RenderTargetView,
+            _In_  const FLOAT ColorRGBA[ 4 ],
+            _In_  UINT NumRects,
+            _In_reads_(NumRects)  const D3D12_RECT *pRects);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, ClearUnorderedAccessViewUint)
+        void ( STDMETHODCALLTYPE *ClearUnorderedAccessViewUint )( 
+            ID3D12GraphicsCommandList2 * This,
+            _In_  D3D12_GPU_DESCRIPTOR_HANDLE ViewGPUHandleInCurrentHeap,
+            _In_  D3D12_CPU_DESCRIPTOR_HANDLE ViewCPUHandle,
+            _In_  ID3D12Resource *pResource,
+            _In_  const UINT Values[ 4 ],
+            _In_  UINT NumRects,
+            _In_reads_(NumRects)  const D3D12_RECT *pRects);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, ClearUnorderedAccessViewFloat)
+        void ( STDMETHODCALLTYPE *ClearUnorderedAccessViewFloat )( 
+            ID3D12GraphicsCommandList2 * This,
+            _In_  D3D12_GPU_DESCRIPTOR_HANDLE ViewGPUHandleInCurrentHeap,
+            _In_  D3D12_CPU_DESCRIPTOR_HANDLE ViewCPUHandle,
+            _In_  ID3D12Resource *pResource,
+            _In_  const FLOAT Values[ 4 ],
+            _In_  UINT NumRects,
+            _In_reads_(NumRects)  const D3D12_RECT *pRects);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, DiscardResource)
+        void ( STDMETHODCALLTYPE *DiscardResource )( 
+            ID3D12GraphicsCommandList2 * This,
+            _In_  ID3D12Resource *pResource,
+            _In_opt_  const D3D12_DISCARD_REGION *pRegion);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, BeginQuery)
+        void ( STDMETHODCALLTYPE *BeginQuery )( 
+            ID3D12GraphicsCommandList2 * This,
+            _In_  ID3D12QueryHeap *pQueryHeap,
+            _In_  D3D12_QUERY_TYPE Type,
+            _In_  UINT Index);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, EndQuery)
+        void ( STDMETHODCALLTYPE *EndQuery )( 
+            ID3D12GraphicsCommandList2 * This,
+            _In_  ID3D12QueryHeap *pQueryHeap,
+            _In_  D3D12_QUERY_TYPE Type,
+            _In_  UINT Index);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, ResolveQueryData)
+        void ( STDMETHODCALLTYPE *ResolveQueryData )( 
+            ID3D12GraphicsCommandList2 * This,
+            _In_  ID3D12QueryHeap *pQueryHeap,
+            _In_  D3D12_QUERY_TYPE Type,
+            _In_  UINT StartIndex,
+            _In_  UINT NumQueries,
+            _In_  ID3D12Resource *pDestinationBuffer,
+            _In_  UINT64 AlignedDestinationBufferOffset);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetPredication)
+        void ( STDMETHODCALLTYPE *SetPredication )( 
+            ID3D12GraphicsCommandList2 * This,
+            _In_opt_  ID3D12Resource *pBuffer,
+            _In_  UINT64 AlignedBufferOffset,
+            _In_  D3D12_PREDICATION_OP Operation);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetMarker)
+        void ( STDMETHODCALLTYPE *SetMarker )( 
+            ID3D12GraphicsCommandList2 * This,
+            UINT Metadata,
+            _In_reads_bytes_opt_(Size)  const void *pData,
+            UINT Size);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, BeginEvent)
+        void ( STDMETHODCALLTYPE *BeginEvent )( 
+            ID3D12GraphicsCommandList2 * This,
+            UINT Metadata,
+            _In_reads_bytes_opt_(Size)  const void *pData,
+            UINT Size);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, EndEvent)
+        void ( STDMETHODCALLTYPE *EndEvent )( 
+            ID3D12GraphicsCommandList2 * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, ExecuteIndirect)
+        void ( STDMETHODCALLTYPE *ExecuteIndirect )( 
+            ID3D12GraphicsCommandList2 * This,
+            _In_  ID3D12CommandSignature *pCommandSignature,
+            _In_  UINT MaxCommandCount,
+            _In_  ID3D12Resource *pArgumentBuffer,
+            _In_  UINT64 ArgumentBufferOffset,
+            _In_opt_  ID3D12Resource *pCountBuffer,
+            _In_  UINT64 CountBufferOffset);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList1, AtomicCopyBufferUINT)
+        void ( STDMETHODCALLTYPE *AtomicCopyBufferUINT )( 
+            ID3D12GraphicsCommandList2 * This,
+            _In_  ID3D12Resource *pDstBuffer,
+            UINT64 DstOffset,
+            _In_  ID3D12Resource *pSrcBuffer,
+            UINT64 SrcOffset,
+            UINT Dependencies,
+            _In_reads_(Dependencies)  ID3D12Resource *const *ppDependentResources,
+            _In_reads_(Dependencies)  const D3D12_SUBRESOURCE_RANGE_UINT64 *pDependentSubresourceRanges);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList1, AtomicCopyBufferUINT64)
+        void ( STDMETHODCALLTYPE *AtomicCopyBufferUINT64 )( 
+            ID3D12GraphicsCommandList2 * This,
+            _In_  ID3D12Resource *pDstBuffer,
+            UINT64 DstOffset,
+            _In_  ID3D12Resource *pSrcBuffer,
+            UINT64 SrcOffset,
+            UINT Dependencies,
+            _In_reads_(Dependencies)  ID3D12Resource *const *ppDependentResources,
+            _In_reads_(Dependencies)  const D3D12_SUBRESOURCE_RANGE_UINT64 *pDependentSubresourceRanges);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList1, OMSetDepthBounds)
+        void ( STDMETHODCALLTYPE *OMSetDepthBounds )( 
+            ID3D12GraphicsCommandList2 * This,
+            _In_  FLOAT Min,
+            _In_  FLOAT Max);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList1, SetSamplePositions)
+        void ( STDMETHODCALLTYPE *SetSamplePositions )( 
+            ID3D12GraphicsCommandList2 * This,
+            _In_  UINT NumSamplesPerPixel,
+            _In_  UINT NumPixels,
+            _In_reads_(NumSamplesPerPixel*NumPixels)  D3D12_SAMPLE_POSITION *pSamplePositions);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList1, ResolveSubresourceRegion)
+        void ( STDMETHODCALLTYPE *ResolveSubresourceRegion )( 
+            ID3D12GraphicsCommandList2 * This,
+            _In_  ID3D12Resource *pDstResource,
+            _In_  UINT DstSubresource,
+            _In_  UINT DstX,
+            _In_  UINT DstY,
+            _In_  ID3D12Resource *pSrcResource,
+            _In_  UINT SrcSubresource,
+            _In_opt_  D3D12_RECT *pSrcRect,
+            _In_  DXGI_FORMAT Format,
+            _In_  D3D12_RESOLVE_MODE ResolveMode);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList1, SetViewInstanceMask)
+        void ( STDMETHODCALLTYPE *SetViewInstanceMask )( 
+            ID3D12GraphicsCommandList2 * This,
+            _In_  UINT Mask);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList2, WriteBufferImmediate)
+        void ( STDMETHODCALLTYPE *WriteBufferImmediate )( 
+            ID3D12GraphicsCommandList2 * This,
+            UINT Count,
+            _In_reads_(Count)  const D3D12_WRITEBUFFERIMMEDIATE_PARAMETER *pParams,
+            _In_reads_opt_(Count)  const D3D12_WRITEBUFFERIMMEDIATE_MODE *pModes);
+        
+        END_INTERFACE
+    } ID3D12GraphicsCommandList2Vtbl;
+
+    interface ID3D12GraphicsCommandList2
+    {
+        CONST_VTBL struct ID3D12GraphicsCommandList2Vtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define ID3D12GraphicsCommandList2_QueryInterface(This,riid,ppvObject)	\
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define ID3D12GraphicsCommandList2_AddRef(This)	\
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define ID3D12GraphicsCommandList2_Release(This)	\
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#define ID3D12GraphicsCommandList2_GetPrivateData(This,guid,pDataSize,pData)	\
+    ( (This)->lpVtbl -> GetPrivateData(This,guid,pDataSize,pData) ) 
+
+#define ID3D12GraphicsCommandList2_SetPrivateData(This,guid,DataSize,pData)	\
+    ( (This)->lpVtbl -> SetPrivateData(This,guid,DataSize,pData) ) 
+
+#define ID3D12GraphicsCommandList2_SetPrivateDataInterface(This,guid,pData)	\
+    ( (This)->lpVtbl -> SetPrivateDataInterface(This,guid,pData) ) 
+
+#define ID3D12GraphicsCommandList2_SetName(This,Name)	\
+    ( (This)->lpVtbl -> SetName(This,Name) ) 
+
+
+#define ID3D12GraphicsCommandList2_GetDevice(This,riid,ppvDevice)	\
+    ( (This)->lpVtbl -> GetDevice(This,riid,ppvDevice) ) 
+
+
+#define ID3D12GraphicsCommandList2_GetType(This)	\
+    ( (This)->lpVtbl -> GetType(This) ) 
+
+
+#define ID3D12GraphicsCommandList2_Close(This)	\
+    ( (This)->lpVtbl -> Close(This) ) 
+
+#define ID3D12GraphicsCommandList2_Reset(This,pAllocator,pInitialState)	\
+    ( (This)->lpVtbl -> Reset(This,pAllocator,pInitialState) ) 
+
+#define ID3D12GraphicsCommandList2_ClearState(This,pPipelineState)	\
+    ( (This)->lpVtbl -> ClearState(This,pPipelineState) ) 
+
+#define ID3D12GraphicsCommandList2_DrawInstanced(This,VertexCountPerInstance,InstanceCount,StartVertexLocation,StartInstanceLocation)	\
+    ( (This)->lpVtbl -> DrawInstanced(This,VertexCountPerInstance,InstanceCount,StartVertexLocation,StartInstanceLocation) ) 
+
+#define ID3D12GraphicsCommandList2_DrawIndexedInstanced(This,IndexCountPerInstance,InstanceCount,StartIndexLocation,BaseVertexLocation,StartInstanceLocation)	\
+    ( (This)->lpVtbl -> DrawIndexedInstanced(This,IndexCountPerInstance,InstanceCount,StartIndexLocation,BaseVertexLocation,StartInstanceLocation) ) 
+
+#define ID3D12GraphicsCommandList2_Dispatch(This,ThreadGroupCountX,ThreadGroupCountY,ThreadGroupCountZ)	\
+    ( (This)->lpVtbl -> Dispatch(This,ThreadGroupCountX,ThreadGroupCountY,ThreadGroupCountZ) ) 
+
+#define ID3D12GraphicsCommandList2_CopyBufferRegion(This,pDstBuffer,DstOffset,pSrcBuffer,SrcOffset,NumBytes)	\
+    ( (This)->lpVtbl -> CopyBufferRegion(This,pDstBuffer,DstOffset,pSrcBuffer,SrcOffset,NumBytes) ) 
+
+#define ID3D12GraphicsCommandList2_CopyTextureRegion(This,pDst,DstX,DstY,DstZ,pSrc,pSrcBox)	\
+    ( (This)->lpVtbl -> CopyTextureRegion(This,pDst,DstX,DstY,DstZ,pSrc,pSrcBox) ) 
+
+#define ID3D12GraphicsCommandList2_CopyResource(This,pDstResource,pSrcResource)	\
+    ( (This)->lpVtbl -> CopyResource(This,pDstResource,pSrcResource) ) 
+
+#define ID3D12GraphicsCommandList2_CopyTiles(This,pTiledResource,pTileRegionStartCoordinate,pTileRegionSize,pBuffer,BufferStartOffsetInBytes,Flags)	\
+    ( (This)->lpVtbl -> CopyTiles(This,pTiledResource,pTileRegionStartCoordinate,pTileRegionSize,pBuffer,BufferStartOffsetInBytes,Flags) ) 
+
+#define ID3D12GraphicsCommandList2_ResolveSubresource(This,pDstResource,DstSubresource,pSrcResource,SrcSubresource,Format)	\
+    ( (This)->lpVtbl -> ResolveSubresource(This,pDstResource,DstSubresource,pSrcResource,SrcSubresource,Format) ) 
+
+#define ID3D12GraphicsCommandList2_IASetPrimitiveTopology(This,PrimitiveTopology)	\
+    ( (This)->lpVtbl -> IASetPrimitiveTopology(This,PrimitiveTopology) ) 
+
+#define ID3D12GraphicsCommandList2_RSSetViewports(This,NumViewports,pViewports)	\
+    ( (This)->lpVtbl -> RSSetViewports(This,NumViewports,pViewports) ) 
+
+#define ID3D12GraphicsCommandList2_RSSetScissorRects(This,NumRects,pRects)	\
+    ( (This)->lpVtbl -> RSSetScissorRects(This,NumRects,pRects) ) 
+
+#define ID3D12GraphicsCommandList2_OMSetBlendFactor(This,BlendFactor)	\
+    ( (This)->lpVtbl -> OMSetBlendFactor(This,BlendFactor) ) 
+
+#define ID3D12GraphicsCommandList2_OMSetStencilRef(This,StencilRef)	\
+    ( (This)->lpVtbl -> OMSetStencilRef(This,StencilRef) ) 
+
+#define ID3D12GraphicsCommandList2_SetPipelineState(This,pPipelineState)	\
+    ( (This)->lpVtbl -> SetPipelineState(This,pPipelineState) ) 
+
+#define ID3D12GraphicsCommandList2_ResourceBarrier(This,NumBarriers,pBarriers)	\
+    ( (This)->lpVtbl -> ResourceBarrier(This,NumBarriers,pBarriers) ) 
+
+#define ID3D12GraphicsCommandList2_ExecuteBundle(This,pCommandList)	\
+    ( (This)->lpVtbl -> ExecuteBundle(This,pCommandList) ) 
+
+#define ID3D12GraphicsCommandList2_SetDescriptorHeaps(This,NumDescriptorHeaps,ppDescriptorHeaps)	\
+    ( (This)->lpVtbl -> SetDescriptorHeaps(This,NumDescriptorHeaps,ppDescriptorHeaps) ) 
+
+#define ID3D12GraphicsCommandList2_SetComputeRootSignature(This,pRootSignature)	\
+    ( (This)->lpVtbl -> SetComputeRootSignature(This,pRootSignature) ) 
+
+#define ID3D12GraphicsCommandList2_SetGraphicsRootSignature(This,pRootSignature)	\
+    ( (This)->lpVtbl -> SetGraphicsRootSignature(This,pRootSignature) ) 
+
+#define ID3D12GraphicsCommandList2_SetComputeRootDescriptorTable(This,RootParameterIndex,BaseDescriptor)	\
+    ( (This)->lpVtbl -> SetComputeRootDescriptorTable(This,RootParameterIndex,BaseDescriptor) ) 
+
+#define ID3D12GraphicsCommandList2_SetGraphicsRootDescriptorTable(This,RootParameterIndex,BaseDescriptor)	\
+    ( (This)->lpVtbl -> SetGraphicsRootDescriptorTable(This,RootParameterIndex,BaseDescriptor) ) 
+
+#define ID3D12GraphicsCommandList2_SetComputeRoot32BitConstant(This,RootParameterIndex,SrcData,DestOffsetIn32BitValues)	\
+    ( (This)->lpVtbl -> SetComputeRoot32BitConstant(This,RootParameterIndex,SrcData,DestOffsetIn32BitValues) ) 
+
+#define ID3D12GraphicsCommandList2_SetGraphicsRoot32BitConstant(This,RootParameterIndex,SrcData,DestOffsetIn32BitValues)	\
+    ( (This)->lpVtbl -> SetGraphicsRoot32BitConstant(This,RootParameterIndex,SrcData,DestOffsetIn32BitValues) ) 
+
+#define ID3D12GraphicsCommandList2_SetComputeRoot32BitConstants(This,RootParameterIndex,Num32BitValuesToSet,pSrcData,DestOffsetIn32BitValues)	\
+    ( (This)->lpVtbl -> SetComputeRoot32BitConstants(This,RootParameterIndex,Num32BitValuesToSet,pSrcData,DestOffsetIn32BitValues) ) 
+
+#define ID3D12GraphicsCommandList2_SetGraphicsRoot32BitConstants(This,RootParameterIndex,Num32BitValuesToSet,pSrcData,DestOffsetIn32BitValues)	\
+    ( (This)->lpVtbl -> SetGraphicsRoot32BitConstants(This,RootParameterIndex,Num32BitValuesToSet,pSrcData,DestOffsetIn32BitValues) ) 
+
+#define ID3D12GraphicsCommandList2_SetComputeRootConstantBufferView(This,RootParameterIndex,BufferLocation)	\
+    ( (This)->lpVtbl -> SetComputeRootConstantBufferView(This,RootParameterIndex,BufferLocation) ) 
+
+#define ID3D12GraphicsCommandList2_SetGraphicsRootConstantBufferView(This,RootParameterIndex,BufferLocation)	\
+    ( (This)->lpVtbl -> SetGraphicsRootConstantBufferView(This,RootParameterIndex,BufferLocation) ) 
+
+#define ID3D12GraphicsCommandList2_SetComputeRootShaderResourceView(This,RootParameterIndex,BufferLocation)	\
+    ( (This)->lpVtbl -> SetComputeRootShaderResourceView(This,RootParameterIndex,BufferLocation) ) 
+
+#define ID3D12GraphicsCommandList2_SetGraphicsRootShaderResourceView(This,RootParameterIndex,BufferLocation)	\
+    ( (This)->lpVtbl -> SetGraphicsRootShaderResourceView(This,RootParameterIndex,BufferLocation) ) 
+
+#define ID3D12GraphicsCommandList2_SetComputeRootUnorderedAccessView(This,RootParameterIndex,BufferLocation)	\
+    ( (This)->lpVtbl -> SetComputeRootUnorderedAccessView(This,RootParameterIndex,BufferLocation) ) 
+
+#define ID3D12GraphicsCommandList2_SetGraphicsRootUnorderedAccessView(This,RootParameterIndex,BufferLocation)	\
+    ( (This)->lpVtbl -> SetGraphicsRootUnorderedAccessView(This,RootParameterIndex,BufferLocation) ) 
+
+#define ID3D12GraphicsCommandList2_IASetIndexBuffer(This,pView)	\
+    ( (This)->lpVtbl -> IASetIndexBuffer(This,pView) ) 
+
+#define ID3D12GraphicsCommandList2_IASetVertexBuffers(This,StartSlot,NumViews,pViews)	\
+    ( (This)->lpVtbl -> IASetVertexBuffers(This,StartSlot,NumViews,pViews) ) 
+
+#define ID3D12GraphicsCommandList2_SOSetTargets(This,StartSlot,NumViews,pViews)	\
+    ( (This)->lpVtbl -> SOSetTargets(This,StartSlot,NumViews,pViews) ) 
+
+#define ID3D12GraphicsCommandList2_OMSetRenderTargets(This,NumRenderTargetDescriptors,pRenderTargetDescriptors,RTsSingleHandleToDescriptorRange,pDepthStencilDescriptor)	\
+    ( (This)->lpVtbl -> OMSetRenderTargets(This,NumRenderTargetDescriptors,pRenderTargetDescriptors,RTsSingleHandleToDescriptorRange,pDepthStencilDescriptor) ) 
+
+#define ID3D12GraphicsCommandList2_ClearDepthStencilView(This,DepthStencilView,ClearFlags,Depth,Stencil,NumRects,pRects)	\
+    ( (This)->lpVtbl -> ClearDepthStencilView(This,DepthStencilView,ClearFlags,Depth,Stencil,NumRects,pRects) ) 
+
+#define ID3D12GraphicsCommandList2_ClearRenderTargetView(This,RenderTargetView,ColorRGBA,NumRects,pRects)	\
+    ( (This)->lpVtbl -> ClearRenderTargetView(This,RenderTargetView,ColorRGBA,NumRects,pRects) ) 
+
+#define ID3D12GraphicsCommandList2_ClearUnorderedAccessViewUint(This,ViewGPUHandleInCurrentHeap,ViewCPUHandle,pResource,Values,NumRects,pRects)	\
+    ( (This)->lpVtbl -> ClearUnorderedAccessViewUint(This,ViewGPUHandleInCurrentHeap,ViewCPUHandle,pResource,Values,NumRects,pRects) ) 
+
+#define ID3D12GraphicsCommandList2_ClearUnorderedAccessViewFloat(This,ViewGPUHandleInCurrentHeap,ViewCPUHandle,pResource,Values,NumRects,pRects)	\
+    ( (This)->lpVtbl -> ClearUnorderedAccessViewFloat(This,ViewGPUHandleInCurrentHeap,ViewCPUHandle,pResource,Values,NumRects,pRects) ) 
+
+#define ID3D12GraphicsCommandList2_DiscardResource(This,pResource,pRegion)	\
+    ( (This)->lpVtbl -> DiscardResource(This,pResource,pRegion) ) 
+
+#define ID3D12GraphicsCommandList2_BeginQuery(This,pQueryHeap,Type,Index)	\
+    ( (This)->lpVtbl -> BeginQuery(This,pQueryHeap,Type,Index) ) 
+
+#define ID3D12GraphicsCommandList2_EndQuery(This,pQueryHeap,Type,Index)	\
+    ( (This)->lpVtbl -> EndQuery(This,pQueryHeap,Type,Index) ) 
+
+#define ID3D12GraphicsCommandList2_ResolveQueryData(This,pQueryHeap,Type,StartIndex,NumQueries,pDestinationBuffer,AlignedDestinationBufferOffset)	\
+    ( (This)->lpVtbl -> ResolveQueryData(This,pQueryHeap,Type,StartIndex,NumQueries,pDestinationBuffer,AlignedDestinationBufferOffset) ) 
+
+#define ID3D12GraphicsCommandList2_SetPredication(This,pBuffer,AlignedBufferOffset,Operation)	\
+    ( (This)->lpVtbl -> SetPredication(This,pBuffer,AlignedBufferOffset,Operation) ) 
+
+#define ID3D12GraphicsCommandList2_SetMarker(This,Metadata,pData,Size)	\
+    ( (This)->lpVtbl -> SetMarker(This,Metadata,pData,Size) ) 
+
+#define ID3D12GraphicsCommandList2_BeginEvent(This,Metadata,pData,Size)	\
+    ( (This)->lpVtbl -> BeginEvent(This,Metadata,pData,Size) ) 
+
+#define ID3D12GraphicsCommandList2_EndEvent(This)	\
+    ( (This)->lpVtbl -> EndEvent(This) ) 
+
+#define ID3D12GraphicsCommandList2_ExecuteIndirect(This,pCommandSignature,MaxCommandCount,pArgumentBuffer,ArgumentBufferOffset,pCountBuffer,CountBufferOffset)	\
+    ( (This)->lpVtbl -> ExecuteIndirect(This,pCommandSignature,MaxCommandCount,pArgumentBuffer,ArgumentBufferOffset,pCountBuffer,CountBufferOffset) ) 
+
+
+#define ID3D12GraphicsCommandList2_AtomicCopyBufferUINT(This,pDstBuffer,DstOffset,pSrcBuffer,SrcOffset,Dependencies,ppDependentResources,pDependentSubresourceRanges)	\
+    ( (This)->lpVtbl -> AtomicCopyBufferUINT(This,pDstBuffer,DstOffset,pSrcBuffer,SrcOffset,Dependencies,ppDependentResources,pDependentSubresourceRanges) ) 
+
+#define ID3D12GraphicsCommandList2_AtomicCopyBufferUINT64(This,pDstBuffer,DstOffset,pSrcBuffer,SrcOffset,Dependencies,ppDependentResources,pDependentSubresourceRanges)	\
+    ( (This)->lpVtbl -> AtomicCopyBufferUINT64(This,pDstBuffer,DstOffset,pSrcBuffer,SrcOffset,Dependencies,ppDependentResources,pDependentSubresourceRanges) ) 
+
+#define ID3D12GraphicsCommandList2_OMSetDepthBounds(This,Min,Max)	\
+    ( (This)->lpVtbl -> OMSetDepthBounds(This,Min,Max) ) 
+
+#define ID3D12GraphicsCommandList2_SetSamplePositions(This,NumSamplesPerPixel,NumPixels,pSamplePositions)	\
+    ( (This)->lpVtbl -> SetSamplePositions(This,NumSamplesPerPixel,NumPixels,pSamplePositions) ) 
+
+#define ID3D12GraphicsCommandList2_ResolveSubresourceRegion(This,pDstResource,DstSubresource,DstX,DstY,pSrcResource,SrcSubresource,pSrcRect,Format,ResolveMode)	\
+    ( (This)->lpVtbl -> ResolveSubresourceRegion(This,pDstResource,DstSubresource,DstX,DstY,pSrcResource,SrcSubresource,pSrcRect,Format,ResolveMode) ) 
+
+#define ID3D12GraphicsCommandList2_SetViewInstanceMask(This,Mask)	\
+    ( (This)->lpVtbl -> SetViewInstanceMask(This,Mask) ) 
+
+
+#define ID3D12GraphicsCommandList2_WriteBufferImmediate(This,Count,pParams,pModes)	\
+    ( (This)->lpVtbl -> WriteBufferImmediate(This,Count,pParams,pModes) ) 
+
+#endif /* COBJMACROS */
+
+
+#endif 	/* C style interface */
+
+
+
+
+#endif 	/* __ID3D12GraphicsCommandList2_INTERFACE_DEFINED__ */
+
+
+#ifndef __ID3D12CommandQueue_INTERFACE_DEFINED__
+#define __ID3D12CommandQueue_INTERFACE_DEFINED__
+
+/* interface ID3D12CommandQueue */
+/* [unique][local][object][uuid] */ 
+
+
+EXTERN_C const IID IID_ID3D12CommandQueue;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("0ec870a6-5d7e-4c22-8cfc-5baae07616ed")
+    ID3D12CommandQueue : public ID3D12Pageable
+    {
+    public:
+        virtual void STDMETHODCALLTYPE UpdateTileMappings( 
+            _In_  ID3D12Resource *pResource,
+            UINT NumResourceRegions,
+            _In_reads_opt_(NumResourceRegions)  const D3D12_TILED_RESOURCE_COORDINATE *pResourceRegionStartCoordinates,
+            _In_reads_opt_(NumResourceRegions)  const D3D12_TILE_REGION_SIZE *pResourceRegionSizes,
+            _In_opt_  ID3D12Heap *pHeap,
+            UINT NumRanges,
+            _In_reads_opt_(NumRanges)  const D3D12_TILE_RANGE_FLAGS *pRangeFlags,
+            _In_reads_opt_(NumRanges)  const UINT *pHeapRangeStartOffsets,
+            _In_reads_opt_(NumRanges)  const UINT *pRangeTileCounts,
+            D3D12_TILE_MAPPING_FLAGS Flags) = 0;
+        
+        virtual void STDMETHODCALLTYPE CopyTileMappings( 
+            _In_  ID3D12Resource *pDstResource,
+            _In_  const D3D12_TILED_RESOURCE_COORDINATE *pDstRegionStartCoordinate,
+            _In_  ID3D12Resource *pSrcResource,
+            _In_  const D3D12_TILED_RESOURCE_COORDINATE *pSrcRegionStartCoordinate,
+            _In_  const D3D12_TILE_REGION_SIZE *pRegionSize,
+            D3D12_TILE_MAPPING_FLAGS Flags) = 0;
+        
+        virtual void STDMETHODCALLTYPE ExecuteCommandLists( 
+            _In_  UINT NumCommandLists,
+            _In_reads_(NumCommandLists)  ID3D12CommandList *const *ppCommandLists) = 0;
+        
+        virtual void STDMETHODCALLTYPE SetMarker( 
+            UINT Metadata,
+            _In_reads_bytes_opt_(Size)  const void *pData,
+            UINT Size) = 0;
+        
+        virtual void STDMETHODCALLTYPE BeginEvent( 
+            UINT Metadata,
+            _In_reads_bytes_opt_(Size)  const void *pData,
+            UINT Size) = 0;
+        
+        virtual void STDMETHODCALLTYPE EndEvent( void) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE Signal( 
+            ID3D12Fence *pFence,
+            UINT64 Value) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE Wait( 
+            ID3D12Fence *pFence,
+            UINT64 Value) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE GetTimestampFrequency( 
+            _Out_  UINT64 *pFrequency) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE GetClockCalibration( 
+            _Out_  UINT64 *pGpuTimestamp,
+            _Out_  UINT64 *pCpuTimestamp) = 0;
+        
+#if defined(_MSC_VER) || !defined(_WIN32)
+        virtual D3D12_COMMAND_QUEUE_DESC STDMETHODCALLTYPE GetDesc( void) = 0;
+#else
+        virtual D3D12_COMMAND_QUEUE_DESC *STDMETHODCALLTYPE GetDesc( 
+            D3D12_COMMAND_QUEUE_DESC * RetVal) = 0;
+#endif
+        
+    };
+    
+    
+#else 	/* C style interface */
+
+    typedef struct ID3D12CommandQueueVtbl
+    {
+        BEGIN_INTERFACE
+        
+        DECLSPEC_XFGVIRT(IUnknown, QueryInterface)
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            ID3D12CommandQueue * This,
+            REFIID riid,
+            _COM_Outptr_  void **ppvObject);
+        
+        DECLSPEC_XFGVIRT(IUnknown, AddRef)
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            ID3D12CommandQueue * This);
+        
+        DECLSPEC_XFGVIRT(IUnknown, Release)
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            ID3D12CommandQueue * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, GetPrivateData)
+        HRESULT ( STDMETHODCALLTYPE *GetPrivateData )( 
+            ID3D12CommandQueue * This,
+            _In_  REFGUID guid,
+            _Inout_  UINT *pDataSize,
+            _Out_writes_bytes_opt_( *pDataSize )  void *pData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, SetPrivateData)
+        HRESULT ( STDMETHODCALLTYPE *SetPrivateData )( 
+            ID3D12CommandQueue * This,
+            _In_  REFGUID guid,
+            _In_  UINT DataSize,
+            _In_reads_bytes_opt_( DataSize )  const void *pData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, SetPrivateDataInterface)
+        HRESULT ( STDMETHODCALLTYPE *SetPrivateDataInterface )( 
+            ID3D12CommandQueue * This,
+            _In_  REFGUID guid,
+            _In_opt_  const IUnknown *pData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, SetName)
+        HRESULT ( STDMETHODCALLTYPE *SetName )( 
+            ID3D12CommandQueue * This,
+            _In_z_  LPCWSTR Name);
+        
+        DECLSPEC_XFGVIRT(ID3D12DeviceChild, GetDevice)
+        HRESULT ( STDMETHODCALLTYPE *GetDevice )( 
+            ID3D12CommandQueue * This,
+            REFIID riid,
+            _COM_Outptr_opt_  void **ppvDevice);
+        
+        DECLSPEC_XFGVIRT(ID3D12CommandQueue, UpdateTileMappings)
+        void ( STDMETHODCALLTYPE *UpdateTileMappings )( 
+            ID3D12CommandQueue * This,
+            _In_  ID3D12Resource *pResource,
+            UINT NumResourceRegions,
+            _In_reads_opt_(NumResourceRegions)  const D3D12_TILED_RESOURCE_COORDINATE *pResourceRegionStartCoordinates,
+            _In_reads_opt_(NumResourceRegions)  const D3D12_TILE_REGION_SIZE *pResourceRegionSizes,
+            _In_opt_  ID3D12Heap *pHeap,
+            UINT NumRanges,
+            _In_reads_opt_(NumRanges)  const D3D12_TILE_RANGE_FLAGS *pRangeFlags,
+            _In_reads_opt_(NumRanges)  const UINT *pHeapRangeStartOffsets,
+            _In_reads_opt_(NumRanges)  const UINT *pRangeTileCounts,
+            D3D12_TILE_MAPPING_FLAGS Flags);
+        
+        DECLSPEC_XFGVIRT(ID3D12CommandQueue, CopyTileMappings)
+        void ( STDMETHODCALLTYPE *CopyTileMappings )( 
+            ID3D12CommandQueue * This,
+            _In_  ID3D12Resource *pDstResource,
+            _In_  const D3D12_TILED_RESOURCE_COORDINATE *pDstRegionStartCoordinate,
+            _In_  ID3D12Resource *pSrcResource,
+            _In_  const D3D12_TILED_RESOURCE_COORDINATE *pSrcRegionStartCoordinate,
+            _In_  const D3D12_TILE_REGION_SIZE *pRegionSize,
+            D3D12_TILE_MAPPING_FLAGS Flags);
+        
+        DECLSPEC_XFGVIRT(ID3D12CommandQueue, ExecuteCommandLists)
+        void ( STDMETHODCALLTYPE *ExecuteCommandLists )( 
+            ID3D12CommandQueue * This,
+            _In_  UINT NumCommandLists,
+            _In_reads_(NumCommandLists)  ID3D12CommandList *const *ppCommandLists);
+        
+        DECLSPEC_XFGVIRT(ID3D12CommandQueue, SetMarker)
+        void ( STDMETHODCALLTYPE *SetMarker )( 
+            ID3D12CommandQueue * This,
+            UINT Metadata,
+            _In_reads_bytes_opt_(Size)  const void *pData,
+            UINT Size);
+        
+        DECLSPEC_XFGVIRT(ID3D12CommandQueue, BeginEvent)
+        void ( STDMETHODCALLTYPE *BeginEvent )( 
+            ID3D12CommandQueue * This,
+            UINT Metadata,
+            _In_reads_bytes_opt_(Size)  const void *pData,
+            UINT Size);
+        
+        DECLSPEC_XFGVIRT(ID3D12CommandQueue, EndEvent)
+        void ( STDMETHODCALLTYPE *EndEvent )( 
+            ID3D12CommandQueue * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12CommandQueue, Signal)
+        HRESULT ( STDMETHODCALLTYPE *Signal )( 
+            ID3D12CommandQueue * This,
+            ID3D12Fence *pFence,
+            UINT64 Value);
+        
+        DECLSPEC_XFGVIRT(ID3D12CommandQueue, Wait)
+        HRESULT ( STDMETHODCALLTYPE *Wait )( 
+            ID3D12CommandQueue * This,
+            ID3D12Fence *pFence,
+            UINT64 Value);
+        
+        DECLSPEC_XFGVIRT(ID3D12CommandQueue, GetTimestampFrequency)
+        HRESULT ( STDMETHODCALLTYPE *GetTimestampFrequency )( 
+            ID3D12CommandQueue * This,
+            _Out_  UINT64 *pFrequency);
+        
+        DECLSPEC_XFGVIRT(ID3D12CommandQueue, GetClockCalibration)
+        HRESULT ( STDMETHODCALLTYPE *GetClockCalibration )( 
+            ID3D12CommandQueue * This,
+            _Out_  UINT64 *pGpuTimestamp,
+            _Out_  UINT64 *pCpuTimestamp);
+        
+        DECLSPEC_XFGVIRT(ID3D12CommandQueue, GetDesc)
+#if !defined(_WIN32)
+        D3D12_COMMAND_QUEUE_DESC ( STDMETHODCALLTYPE *GetDesc )( 
+            ID3D12CommandQueue * This);
+        
+#else
+        D3D12_COMMAND_QUEUE_DESC *( STDMETHODCALLTYPE *GetDesc )( 
+            ID3D12CommandQueue * This,
+            D3D12_COMMAND_QUEUE_DESC * RetVal);
+        
+#endif
+        
+        END_INTERFACE
+    } ID3D12CommandQueueVtbl;
+
+    interface ID3D12CommandQueue
+    {
+        CONST_VTBL struct ID3D12CommandQueueVtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define ID3D12CommandQueue_QueryInterface(This,riid,ppvObject)	\
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define ID3D12CommandQueue_AddRef(This)	\
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define ID3D12CommandQueue_Release(This)	\
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#define ID3D12CommandQueue_GetPrivateData(This,guid,pDataSize,pData)	\
+    ( (This)->lpVtbl -> GetPrivateData(This,guid,pDataSize,pData) ) 
+
+#define ID3D12CommandQueue_SetPrivateData(This,guid,DataSize,pData)	\
+    ( (This)->lpVtbl -> SetPrivateData(This,guid,DataSize,pData) ) 
+
+#define ID3D12CommandQueue_SetPrivateDataInterface(This,guid,pData)	\
+    ( (This)->lpVtbl -> SetPrivateDataInterface(This,guid,pData) ) 
+
+#define ID3D12CommandQueue_SetName(This,Name)	\
+    ( (This)->lpVtbl -> SetName(This,Name) ) 
+
+
+#define ID3D12CommandQueue_GetDevice(This,riid,ppvDevice)	\
+    ( (This)->lpVtbl -> GetDevice(This,riid,ppvDevice) ) 
+
+
+
+#define ID3D12CommandQueue_UpdateTileMappings(This,pResource,NumResourceRegions,pResourceRegionStartCoordinates,pResourceRegionSizes,pHeap,NumRanges,pRangeFlags,pHeapRangeStartOffsets,pRangeTileCounts,Flags)	\
+    ( (This)->lpVtbl -> UpdateTileMappings(This,pResource,NumResourceRegions,pResourceRegionStartCoordinates,pResourceRegionSizes,pHeap,NumRanges,pRangeFlags,pHeapRangeStartOffsets,pRangeTileCounts,Flags) ) 
+
+#define ID3D12CommandQueue_CopyTileMappings(This,pDstResource,pDstRegionStartCoordinate,pSrcResource,pSrcRegionStartCoordinate,pRegionSize,Flags)	\
+    ( (This)->lpVtbl -> CopyTileMappings(This,pDstResource,pDstRegionStartCoordinate,pSrcResource,pSrcRegionStartCoordinate,pRegionSize,Flags) ) 
+
+#define ID3D12CommandQueue_ExecuteCommandLists(This,NumCommandLists,ppCommandLists)	\
+    ( (This)->lpVtbl -> ExecuteCommandLists(This,NumCommandLists,ppCommandLists) ) 
+
+#define ID3D12CommandQueue_SetMarker(This,Metadata,pData,Size)	\
+    ( (This)->lpVtbl -> SetMarker(This,Metadata,pData,Size) ) 
+
+#define ID3D12CommandQueue_BeginEvent(This,Metadata,pData,Size)	\
+    ( (This)->lpVtbl -> BeginEvent(This,Metadata,pData,Size) ) 
+
+#define ID3D12CommandQueue_EndEvent(This)	\
+    ( (This)->lpVtbl -> EndEvent(This) ) 
+
+#define ID3D12CommandQueue_Signal(This,pFence,Value)	\
+    ( (This)->lpVtbl -> Signal(This,pFence,Value) ) 
+
+#define ID3D12CommandQueue_Wait(This,pFence,Value)	\
+    ( (This)->lpVtbl -> Wait(This,pFence,Value) ) 
+
+#define ID3D12CommandQueue_GetTimestampFrequency(This,pFrequency)	\
+    ( (This)->lpVtbl -> GetTimestampFrequency(This,pFrequency) ) 
+
+#define ID3D12CommandQueue_GetClockCalibration(This,pGpuTimestamp,pCpuTimestamp)	\
+    ( (This)->lpVtbl -> GetClockCalibration(This,pGpuTimestamp,pCpuTimestamp) ) 
+#if !defined(_WIN32)
+
+#define ID3D12CommandQueue_GetDesc(This)	\
+    ( (This)->lpVtbl -> GetDesc(This) ) 
+#else
+#define ID3D12CommandQueue_GetDesc(This,RetVal)	\
+    ( (This)->lpVtbl -> GetDesc(This,RetVal) ) 
+#endif
+
+#endif /* COBJMACROS */
+
+
+#endif 	/* C style interface */
+
+
+
+
+#endif 	/* __ID3D12CommandQueue_INTERFACE_DEFINED__ */
+
+
+/* interface __MIDL_itf_d3d12_0000_0020 */
+/* [local] */ 
+
+#ifdef __midl
+#ifndef LUID_DEFINED
+#define LUID_DEFINED 1
+typedef struct __LUID
+    {
+    DWORD LowPart;
+    LONG HighPart;
+    } 	LUID;
+
+typedef struct __LUID *PLUID;
+
+#endif
+#endif
+
+
+extern RPC_IF_HANDLE __MIDL_itf_d3d12_0000_0020_v0_0_c_ifspec;
+extern RPC_IF_HANDLE __MIDL_itf_d3d12_0000_0020_v0_0_s_ifspec;
+
+#ifndef __ID3D12Device_INTERFACE_DEFINED__
+#define __ID3D12Device_INTERFACE_DEFINED__
+
+/* interface ID3D12Device */
+/* [unique][local][object][uuid] */ 
+
+
+EXTERN_C const IID IID_ID3D12Device;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("189819f1-1db6-4b57-be54-1821339b85f7")
+    ID3D12Device : public ID3D12Object
+    {
+    public:
+        virtual UINT STDMETHODCALLTYPE GetNodeCount( void) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE CreateCommandQueue( 
+            _In_  const D3D12_COMMAND_QUEUE_DESC *pDesc,
+            REFIID riid,
+            _COM_Outptr_  void **ppCommandQueue) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE CreateCommandAllocator( 
+            _In_  D3D12_COMMAND_LIST_TYPE type,
+            REFIID riid,
+            _COM_Outptr_  void **ppCommandAllocator) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE CreateGraphicsPipelineState( 
+            _In_  const D3D12_GRAPHICS_PIPELINE_STATE_DESC *pDesc,
+            REFIID riid,
+            _COM_Outptr_  void **ppPipelineState) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE CreateComputePipelineState( 
+            _In_  const D3D12_COMPUTE_PIPELINE_STATE_DESC *pDesc,
+            REFIID riid,
+            _COM_Outptr_  void **ppPipelineState) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE CreateCommandList( 
+            _In_  UINT nodeMask,
+            _In_  D3D12_COMMAND_LIST_TYPE type,
+            _In_  ID3D12CommandAllocator *pCommandAllocator,
+            _In_opt_  ID3D12PipelineState *pInitialState,
+            REFIID riid,
+            _COM_Outptr_  void **ppCommandList) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE CheckFeatureSupport( 
+            D3D12_FEATURE Feature,
+            _Inout_updates_bytes_(FeatureSupportDataSize)  void *pFeatureSupportData,
+            UINT FeatureSupportDataSize) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE CreateDescriptorHeap( 
+            _In_  const D3D12_DESCRIPTOR_HEAP_DESC *pDescriptorHeapDesc,
+            REFIID riid,
+            _COM_Outptr_  void **ppvHeap) = 0;
+        
+        virtual UINT STDMETHODCALLTYPE GetDescriptorHandleIncrementSize( 
+            _In_  D3D12_DESCRIPTOR_HEAP_TYPE DescriptorHeapType) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE CreateRootSignature( 
+            _In_  UINT nodeMask,
+            _In_reads_(blobLengthInBytes)  const void *pBlobWithRootSignature,
+            _In_  SIZE_T blobLengthInBytes,
+            REFIID riid,
+            _COM_Outptr_  void **ppvRootSignature) = 0;
+        
+        virtual void STDMETHODCALLTYPE CreateConstantBufferView( 
+            _In_opt_  const D3D12_CONSTANT_BUFFER_VIEW_DESC *pDesc,
+            _In_  D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor) = 0;
+        
+        virtual void STDMETHODCALLTYPE CreateShaderResourceView( 
+            _In_opt_  ID3D12Resource *pResource,
+            _In_opt_  const D3D12_SHADER_RESOURCE_VIEW_DESC *pDesc,
+            _In_  D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor) = 0;
+        
+        virtual void STDMETHODCALLTYPE CreateUnorderedAccessView( 
+            _In_opt_  ID3D12Resource *pResource,
+            _In_opt_  ID3D12Resource *pCounterResource,
+            _In_opt_  const D3D12_UNORDERED_ACCESS_VIEW_DESC *pDesc,
+            _In_  D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor) = 0;
+        
+        virtual void STDMETHODCALLTYPE CreateRenderTargetView( 
+            _In_opt_  ID3D12Resource *pResource,
+            _In_opt_  const D3D12_RENDER_TARGET_VIEW_DESC *pDesc,
+            _In_  D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor) = 0;
+        
+        virtual void STDMETHODCALLTYPE CreateDepthStencilView( 
+            _In_opt_  ID3D12Resource *pResource,
+            _In_opt_  const D3D12_DEPTH_STENCIL_VIEW_DESC *pDesc,
+            _In_  D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor) = 0;
+        
+        virtual void STDMETHODCALLTYPE CreateSampler( 
+            _In_  const D3D12_SAMPLER_DESC *pDesc,
+            _In_  D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor) = 0;
+        
+        virtual void STDMETHODCALLTYPE CopyDescriptors( 
+            _In_  UINT NumDestDescriptorRanges,
+            _In_reads_(NumDestDescriptorRanges)  const D3D12_CPU_DESCRIPTOR_HANDLE *pDestDescriptorRangeStarts,
+            _In_reads_opt_(NumDestDescriptorRanges)  const UINT *pDestDescriptorRangeSizes,
+            _In_  UINT NumSrcDescriptorRanges,
+            _In_reads_(NumSrcDescriptorRanges)  const D3D12_CPU_DESCRIPTOR_HANDLE *pSrcDescriptorRangeStarts,
+            _In_reads_opt_(NumSrcDescriptorRanges)  const UINT *pSrcDescriptorRangeSizes,
+            _In_  D3D12_DESCRIPTOR_HEAP_TYPE DescriptorHeapsType) = 0;
+        
+        virtual void STDMETHODCALLTYPE CopyDescriptorsSimple( 
+            _In_  UINT NumDescriptors,
+            _In_  D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptorRangeStart,
+            _In_  D3D12_CPU_DESCRIPTOR_HANDLE SrcDescriptorRangeStart,
+            _In_  D3D12_DESCRIPTOR_HEAP_TYPE DescriptorHeapsType) = 0;
+        
+#if defined(_MSC_VER) || !defined(_WIN32)
+        virtual D3D12_RESOURCE_ALLOCATION_INFO STDMETHODCALLTYPE GetResourceAllocationInfo( 
+            _In_  UINT visibleMask,
+            _In_  UINT numResourceDescs,
+            _In_reads_(numResourceDescs)  const D3D12_RESOURCE_DESC *pResourceDescs) = 0;
+#else
+        virtual D3D12_RESOURCE_ALLOCATION_INFO *STDMETHODCALLTYPE GetResourceAllocationInfo( 
+            D3D12_RESOURCE_ALLOCATION_INFO * RetVal,
+            _In_  UINT visibleMask,
+            _In_  UINT numResourceDescs,
+            _In_reads_(numResourceDescs)  const D3D12_RESOURCE_DESC *pResourceDescs) = 0;
+#endif
+        
+#if defined(_MSC_VER) || !defined(_WIN32)
+        virtual D3D12_HEAP_PROPERTIES STDMETHODCALLTYPE GetCustomHeapProperties( 
+            _In_  UINT nodeMask,
+            D3D12_HEAP_TYPE heapType) = 0;
+#else
+        virtual D3D12_HEAP_PROPERTIES *STDMETHODCALLTYPE GetCustomHeapProperties( 
+            D3D12_HEAP_PROPERTIES * RetVal,
+            _In_  UINT nodeMask,
+            D3D12_HEAP_TYPE heapType) = 0;
+#endif
+        
+        virtual HRESULT STDMETHODCALLTYPE CreateCommittedResource( 
+            _In_  const D3D12_HEAP_PROPERTIES *pHeapProperties,
+            D3D12_HEAP_FLAGS HeapFlags,
+            _In_  const D3D12_RESOURCE_DESC *pDesc,
+            D3D12_RESOURCE_STATES InitialResourceState,
+            _In_opt_  const D3D12_CLEAR_VALUE *pOptimizedClearValue,
+            REFIID riidResource,
+            _COM_Outptr_opt_  void **ppvResource) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE CreateHeap( 
+            _In_  const D3D12_HEAP_DESC *pDesc,
+            REFIID riid,
+            _COM_Outptr_opt_  void **ppvHeap) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE CreatePlacedResource( 
+            _In_  ID3D12Heap *pHeap,
+            UINT64 HeapOffset,
+            _In_  const D3D12_RESOURCE_DESC *pDesc,
+            D3D12_RESOURCE_STATES InitialState,
+            _In_opt_  const D3D12_CLEAR_VALUE *pOptimizedClearValue,
+            REFIID riid,
+            _COM_Outptr_opt_  void **ppvResource) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE CreateReservedResource( 
+            _In_  const D3D12_RESOURCE_DESC *pDesc,
+            D3D12_RESOURCE_STATES InitialState,
+            _In_opt_  const D3D12_CLEAR_VALUE *pOptimizedClearValue,
+            REFIID riid,
+            _COM_Outptr_opt_  void **ppvResource) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE CreateSharedHandle( 
+            _In_  ID3D12DeviceChild *pObject,
+            _In_opt_  const SECURITY_ATTRIBUTES *pAttributes,
+            DWORD Access,
+            _In_opt_  LPCWSTR Name,
+            _Out_  HANDLE *pHandle) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE OpenSharedHandle( 
+            _In_  HANDLE NTHandle,
+            REFIID riid,
+            _COM_Outptr_opt_  void **ppvObj) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE OpenSharedHandleByName( 
+            _In_  LPCWSTR Name,
+            DWORD Access,
+            /* [annotation][out] */ 
+            _Out_  HANDLE *pNTHandle) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE MakeResident( 
+            UINT NumObjects,
+            _In_reads_(NumObjects)  ID3D12Pageable *const *ppObjects) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE Evict( 
+            UINT NumObjects,
+            _In_reads_(NumObjects)  ID3D12Pageable *const *ppObjects) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE CreateFence( 
+            UINT64 InitialValue,
+            D3D12_FENCE_FLAGS Flags,
+            REFIID riid,
+            _COM_Outptr_  void **ppFence) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE GetDeviceRemovedReason( void) = 0;
+        
+        virtual void STDMETHODCALLTYPE GetCopyableFootprints( 
+            _In_  const D3D12_RESOURCE_DESC *pResourceDesc,
+            _In_range_(0,D3D12_REQ_SUBRESOURCES)  UINT FirstSubresource,
+            _In_range_(0,D3D12_REQ_SUBRESOURCES-FirstSubresource)  UINT NumSubresources,
+            UINT64 BaseOffset,
+            _Out_writes_opt_(NumSubresources)  D3D12_PLACED_SUBRESOURCE_FOOTPRINT *pLayouts,
+            _Out_writes_opt_(NumSubresources)  UINT *pNumRows,
+            _Out_writes_opt_(NumSubresources)  UINT64 *pRowSizeInBytes,
+            _Out_opt_  UINT64 *pTotalBytes) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE CreateQueryHeap( 
+            _In_  const D3D12_QUERY_HEAP_DESC *pDesc,
+            REFIID riid,
+            _COM_Outptr_opt_  void **ppvHeap) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE SetStablePowerState( 
+            BOOL Enable) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE CreateCommandSignature( 
+            _In_  const D3D12_COMMAND_SIGNATURE_DESC *pDesc,
+            _In_opt_  ID3D12RootSignature *pRootSignature,
+            REFIID riid,
+            _COM_Outptr_opt_  void **ppvCommandSignature) = 0;
+        
+        virtual void STDMETHODCALLTYPE GetResourceTiling( 
+            _In_  ID3D12Resource *pTiledResource,
+            _Out_opt_  UINT *pNumTilesForEntireResource,
+            _Out_opt_  D3D12_PACKED_MIP_INFO *pPackedMipDesc,
+            _Out_opt_  D3D12_TILE_SHAPE *pStandardTileShapeForNonPackedMips,
+            _Inout_opt_  UINT *pNumSubresourceTilings,
+            _In_  UINT FirstSubresourceTilingToGet,
+            _Out_writes_(*pNumSubresourceTilings)  D3D12_SUBRESOURCE_TILING *pSubresourceTilingsForNonPackedMips) = 0;
+        
+#if defined(_MSC_VER) || !defined(_WIN32)
+        virtual LUID STDMETHODCALLTYPE GetAdapterLuid( void) = 0;
+#else
+        virtual LUID *STDMETHODCALLTYPE GetAdapterLuid( 
+            LUID * RetVal) = 0;
+#endif
+        
+    };
+    
+    
+#else 	/* C style interface */
+
+    typedef struct ID3D12DeviceVtbl
+    {
+        BEGIN_INTERFACE
+        
+        DECLSPEC_XFGVIRT(IUnknown, QueryInterface)
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            ID3D12Device * This,
+            REFIID riid,
+            _COM_Outptr_  void **ppvObject);
+        
+        DECLSPEC_XFGVIRT(IUnknown, AddRef)
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            ID3D12Device * This);
+        
+        DECLSPEC_XFGVIRT(IUnknown, Release)
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            ID3D12Device * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, GetPrivateData)
+        HRESULT ( STDMETHODCALLTYPE *GetPrivateData )( 
+            ID3D12Device * This,
+            _In_  REFGUID guid,
+            _Inout_  UINT *pDataSize,
+            _Out_writes_bytes_opt_( *pDataSize )  void *pData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, SetPrivateData)
+        HRESULT ( STDMETHODCALLTYPE *SetPrivateData )( 
+            ID3D12Device * This,
+            _In_  REFGUID guid,
+            _In_  UINT DataSize,
+            _In_reads_bytes_opt_( DataSize )  const void *pData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, SetPrivateDataInterface)
+        HRESULT ( STDMETHODCALLTYPE *SetPrivateDataInterface )( 
+            ID3D12Device * This,
+            _In_  REFGUID guid,
+            _In_opt_  const IUnknown *pData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, SetName)
+        HRESULT ( STDMETHODCALLTYPE *SetName )( 
+            ID3D12Device * This,
+            _In_z_  LPCWSTR Name);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, GetNodeCount)
+        UINT ( STDMETHODCALLTYPE *GetNodeCount )( 
+            ID3D12Device * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CreateCommandQueue)
+        HRESULT ( STDMETHODCALLTYPE *CreateCommandQueue )( 
+            ID3D12Device * This,
+            _In_  const D3D12_COMMAND_QUEUE_DESC *pDesc,
+            REFIID riid,
+            _COM_Outptr_  void **ppCommandQueue);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CreateCommandAllocator)
+        HRESULT ( STDMETHODCALLTYPE *CreateCommandAllocator )( 
+            ID3D12Device * This,
+            _In_  D3D12_COMMAND_LIST_TYPE type,
+            REFIID riid,
+            _COM_Outptr_  void **ppCommandAllocator);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CreateGraphicsPipelineState)
+        HRESULT ( STDMETHODCALLTYPE *CreateGraphicsPipelineState )( 
+            ID3D12Device * This,
+            _In_  const D3D12_GRAPHICS_PIPELINE_STATE_DESC *pDesc,
+            REFIID riid,
+            _COM_Outptr_  void **ppPipelineState);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CreateComputePipelineState)
+        HRESULT ( STDMETHODCALLTYPE *CreateComputePipelineState )( 
+            ID3D12Device * This,
+            _In_  const D3D12_COMPUTE_PIPELINE_STATE_DESC *pDesc,
+            REFIID riid,
+            _COM_Outptr_  void **ppPipelineState);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CreateCommandList)
+        HRESULT ( STDMETHODCALLTYPE *CreateCommandList )( 
+            ID3D12Device * This,
+            _In_  UINT nodeMask,
+            _In_  D3D12_COMMAND_LIST_TYPE type,
+            _In_  ID3D12CommandAllocator *pCommandAllocator,
+            _In_opt_  ID3D12PipelineState *pInitialState,
+            REFIID riid,
+            _COM_Outptr_  void **ppCommandList);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CheckFeatureSupport)
+        HRESULT ( STDMETHODCALLTYPE *CheckFeatureSupport )( 
+            ID3D12Device * This,
+            D3D12_FEATURE Feature,
+            _Inout_updates_bytes_(FeatureSupportDataSize)  void *pFeatureSupportData,
+            UINT FeatureSupportDataSize);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CreateDescriptorHeap)
+        HRESULT ( STDMETHODCALLTYPE *CreateDescriptorHeap )( 
+            ID3D12Device * This,
+            _In_  const D3D12_DESCRIPTOR_HEAP_DESC *pDescriptorHeapDesc,
+            REFIID riid,
+            _COM_Outptr_  void **ppvHeap);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, GetDescriptorHandleIncrementSize)
+        UINT ( STDMETHODCALLTYPE *GetDescriptorHandleIncrementSize )( 
+            ID3D12Device * This,
+            _In_  D3D12_DESCRIPTOR_HEAP_TYPE DescriptorHeapType);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CreateRootSignature)
+        HRESULT ( STDMETHODCALLTYPE *CreateRootSignature )( 
+            ID3D12Device * This,
+            _In_  UINT nodeMask,
+            _In_reads_(blobLengthInBytes)  const void *pBlobWithRootSignature,
+            _In_  SIZE_T blobLengthInBytes,
+            REFIID riid,
+            _COM_Outptr_  void **ppvRootSignature);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CreateConstantBufferView)
+        void ( STDMETHODCALLTYPE *CreateConstantBufferView )( 
+            ID3D12Device * This,
+            _In_opt_  const D3D12_CONSTANT_BUFFER_VIEW_DESC *pDesc,
+            _In_  D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CreateShaderResourceView)
+        void ( STDMETHODCALLTYPE *CreateShaderResourceView )( 
+            ID3D12Device * This,
+            _In_opt_  ID3D12Resource *pResource,
+            _In_opt_  const D3D12_SHADER_RESOURCE_VIEW_DESC *pDesc,
+            _In_  D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CreateUnorderedAccessView)
+        void ( STDMETHODCALLTYPE *CreateUnorderedAccessView )( 
+            ID3D12Device * This,
+            _In_opt_  ID3D12Resource *pResource,
+            _In_opt_  ID3D12Resource *pCounterResource,
+            _In_opt_  const D3D12_UNORDERED_ACCESS_VIEW_DESC *pDesc,
+            _In_  D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CreateRenderTargetView)
+        void ( STDMETHODCALLTYPE *CreateRenderTargetView )( 
+            ID3D12Device * This,
+            _In_opt_  ID3D12Resource *pResource,
+            _In_opt_  const D3D12_RENDER_TARGET_VIEW_DESC *pDesc,
+            _In_  D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CreateDepthStencilView)
+        void ( STDMETHODCALLTYPE *CreateDepthStencilView )( 
+            ID3D12Device * This,
+            _In_opt_  ID3D12Resource *pResource,
+            _In_opt_  const D3D12_DEPTH_STENCIL_VIEW_DESC *pDesc,
+            _In_  D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CreateSampler)
+        void ( STDMETHODCALLTYPE *CreateSampler )( 
+            ID3D12Device * This,
+            _In_  const D3D12_SAMPLER_DESC *pDesc,
+            _In_  D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CopyDescriptors)
+        void ( STDMETHODCALLTYPE *CopyDescriptors )( 
+            ID3D12Device * This,
+            _In_  UINT NumDestDescriptorRanges,
+            _In_reads_(NumDestDescriptorRanges)  const D3D12_CPU_DESCRIPTOR_HANDLE *pDestDescriptorRangeStarts,
+            _In_reads_opt_(NumDestDescriptorRanges)  const UINT *pDestDescriptorRangeSizes,
+            _In_  UINT NumSrcDescriptorRanges,
+            _In_reads_(NumSrcDescriptorRanges)  const D3D12_CPU_DESCRIPTOR_HANDLE *pSrcDescriptorRangeStarts,
+            _In_reads_opt_(NumSrcDescriptorRanges)  const UINT *pSrcDescriptorRangeSizes,
+            _In_  D3D12_DESCRIPTOR_HEAP_TYPE DescriptorHeapsType);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CopyDescriptorsSimple)
+        void ( STDMETHODCALLTYPE *CopyDescriptorsSimple )( 
+            ID3D12Device * This,
+            _In_  UINT NumDescriptors,
+            _In_  D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptorRangeStart,
+            _In_  D3D12_CPU_DESCRIPTOR_HANDLE SrcDescriptorRangeStart,
+            _In_  D3D12_DESCRIPTOR_HEAP_TYPE DescriptorHeapsType);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, GetResourceAllocationInfo)
+#if !defined(_WIN32)
+        D3D12_RESOURCE_ALLOCATION_INFO ( STDMETHODCALLTYPE *GetResourceAllocationInfo )( 
+            ID3D12Device * This,
+            _In_  UINT visibleMask,
+            _In_  UINT numResourceDescs,
+            _In_reads_(numResourceDescs)  const D3D12_RESOURCE_DESC *pResourceDescs);
+        
+#else
+        D3D12_RESOURCE_ALLOCATION_INFO *( STDMETHODCALLTYPE *GetResourceAllocationInfo )( 
+            ID3D12Device * This,
+            D3D12_RESOURCE_ALLOCATION_INFO * RetVal,
+            _In_  UINT visibleMask,
+            _In_  UINT numResourceDescs,
+            _In_reads_(numResourceDescs)  const D3D12_RESOURCE_DESC *pResourceDescs);
+        
+#endif
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, GetCustomHeapProperties)
+#if !defined(_WIN32)
+        D3D12_HEAP_PROPERTIES ( STDMETHODCALLTYPE *GetCustomHeapProperties )( 
+            ID3D12Device * This,
+            _In_  UINT nodeMask,
+            D3D12_HEAP_TYPE heapType);
+        
+#else
+        D3D12_HEAP_PROPERTIES *( STDMETHODCALLTYPE *GetCustomHeapProperties )( 
+            ID3D12Device * This,
+            D3D12_HEAP_PROPERTIES * RetVal,
+            _In_  UINT nodeMask,
+            D3D12_HEAP_TYPE heapType);
+        
+#endif
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CreateCommittedResource)
+        HRESULT ( STDMETHODCALLTYPE *CreateCommittedResource )( 
+            ID3D12Device * This,
+            _In_  const D3D12_HEAP_PROPERTIES *pHeapProperties,
+            D3D12_HEAP_FLAGS HeapFlags,
+            _In_  const D3D12_RESOURCE_DESC *pDesc,
+            D3D12_RESOURCE_STATES InitialResourceState,
+            _In_opt_  const D3D12_CLEAR_VALUE *pOptimizedClearValue,
+            REFIID riidResource,
+            _COM_Outptr_opt_  void **ppvResource);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CreateHeap)
+        HRESULT ( STDMETHODCALLTYPE *CreateHeap )( 
+            ID3D12Device * This,
+            _In_  const D3D12_HEAP_DESC *pDesc,
+            REFIID riid,
+            _COM_Outptr_opt_  void **ppvHeap);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CreatePlacedResource)
+        HRESULT ( STDMETHODCALLTYPE *CreatePlacedResource )( 
+            ID3D12Device * This,
+            _In_  ID3D12Heap *pHeap,
+            UINT64 HeapOffset,
+            _In_  const D3D12_RESOURCE_DESC *pDesc,
+            D3D12_RESOURCE_STATES InitialState,
+            _In_opt_  const D3D12_CLEAR_VALUE *pOptimizedClearValue,
+            REFIID riid,
+            _COM_Outptr_opt_  void **ppvResource);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CreateReservedResource)
+        HRESULT ( STDMETHODCALLTYPE *CreateReservedResource )( 
+            ID3D12Device * This,
+            _In_  const D3D12_RESOURCE_DESC *pDesc,
+            D3D12_RESOURCE_STATES InitialState,
+            _In_opt_  const D3D12_CLEAR_VALUE *pOptimizedClearValue,
+            REFIID riid,
+            _COM_Outptr_opt_  void **ppvResource);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CreateSharedHandle)
+        HRESULT ( STDMETHODCALLTYPE *CreateSharedHandle )( 
+            ID3D12Device * This,
+            _In_  ID3D12DeviceChild *pObject,
+            _In_opt_  const SECURITY_ATTRIBUTES *pAttributes,
+            DWORD Access,
+            _In_opt_  LPCWSTR Name,
+            _Out_  HANDLE *pHandle);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, OpenSharedHandle)
+        HRESULT ( STDMETHODCALLTYPE *OpenSharedHandle )( 
+            ID3D12Device * This,
+            _In_  HANDLE NTHandle,
+            REFIID riid,
+            _COM_Outptr_opt_  void **ppvObj);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, OpenSharedHandleByName)
+        HRESULT ( STDMETHODCALLTYPE *OpenSharedHandleByName )( 
+            ID3D12Device * This,
+            _In_  LPCWSTR Name,
+            DWORD Access,
+            /* [annotation][out] */ 
+            _Out_  HANDLE *pNTHandle);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, MakeResident)
+        HRESULT ( STDMETHODCALLTYPE *MakeResident )( 
+            ID3D12Device * This,
+            UINT NumObjects,
+            _In_reads_(NumObjects)  ID3D12Pageable *const *ppObjects);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, Evict)
+        HRESULT ( STDMETHODCALLTYPE *Evict )( 
+            ID3D12Device * This,
+            UINT NumObjects,
+            _In_reads_(NumObjects)  ID3D12Pageable *const *ppObjects);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CreateFence)
+        HRESULT ( STDMETHODCALLTYPE *CreateFence )( 
+            ID3D12Device * This,
+            UINT64 InitialValue,
+            D3D12_FENCE_FLAGS Flags,
+            REFIID riid,
+            _COM_Outptr_  void **ppFence);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, GetDeviceRemovedReason)
+        HRESULT ( STDMETHODCALLTYPE *GetDeviceRemovedReason )( 
+            ID3D12Device * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, GetCopyableFootprints)
+        void ( STDMETHODCALLTYPE *GetCopyableFootprints )( 
+            ID3D12Device * This,
+            _In_  const D3D12_RESOURCE_DESC *pResourceDesc,
+            _In_range_(0,D3D12_REQ_SUBRESOURCES)  UINT FirstSubresource,
+            _In_range_(0,D3D12_REQ_SUBRESOURCES-FirstSubresource)  UINT NumSubresources,
+            UINT64 BaseOffset,
+            _Out_writes_opt_(NumSubresources)  D3D12_PLACED_SUBRESOURCE_FOOTPRINT *pLayouts,
+            _Out_writes_opt_(NumSubresources)  UINT *pNumRows,
+            _Out_writes_opt_(NumSubresources)  UINT64 *pRowSizeInBytes,
+            _Out_opt_  UINT64 *pTotalBytes);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CreateQueryHeap)
+        HRESULT ( STDMETHODCALLTYPE *CreateQueryHeap )( 
+            ID3D12Device * This,
+            _In_  const D3D12_QUERY_HEAP_DESC *pDesc,
+            REFIID riid,
+            _COM_Outptr_opt_  void **ppvHeap);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, SetStablePowerState)
+        HRESULT ( STDMETHODCALLTYPE *SetStablePowerState )( 
+            ID3D12Device * This,
+            BOOL Enable);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CreateCommandSignature)
+        HRESULT ( STDMETHODCALLTYPE *CreateCommandSignature )( 
+            ID3D12Device * This,
+            _In_  const D3D12_COMMAND_SIGNATURE_DESC *pDesc,
+            _In_opt_  ID3D12RootSignature *pRootSignature,
+            REFIID riid,
+            _COM_Outptr_opt_  void **ppvCommandSignature);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, GetResourceTiling)
+        void ( STDMETHODCALLTYPE *GetResourceTiling )( 
+            ID3D12Device * This,
+            _In_  ID3D12Resource *pTiledResource,
+            _Out_opt_  UINT *pNumTilesForEntireResource,
+            _Out_opt_  D3D12_PACKED_MIP_INFO *pPackedMipDesc,
+            _Out_opt_  D3D12_TILE_SHAPE *pStandardTileShapeForNonPackedMips,
+            _Inout_opt_  UINT *pNumSubresourceTilings,
+            _In_  UINT FirstSubresourceTilingToGet,
+            _Out_writes_(*pNumSubresourceTilings)  D3D12_SUBRESOURCE_TILING *pSubresourceTilingsForNonPackedMips);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, GetAdapterLuid)
+#if !defined(_WIN32)
+        LUID ( STDMETHODCALLTYPE *GetAdapterLuid )( 
+            ID3D12Device * This);
+        
+#else
+        LUID *( STDMETHODCALLTYPE *GetAdapterLuid )( 
+            ID3D12Device * This,
+            LUID * RetVal);
+        
+#endif
+        
+        END_INTERFACE
+    } ID3D12DeviceVtbl;
+
+    interface ID3D12Device
+    {
+        CONST_VTBL struct ID3D12DeviceVtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define ID3D12Device_QueryInterface(This,riid,ppvObject)	\
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define ID3D12Device_AddRef(This)	\
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define ID3D12Device_Release(This)	\
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#define ID3D12Device_GetPrivateData(This,guid,pDataSize,pData)	\
+    ( (This)->lpVtbl -> GetPrivateData(This,guid,pDataSize,pData) ) 
+
+#define ID3D12Device_SetPrivateData(This,guid,DataSize,pData)	\
+    ( (This)->lpVtbl -> SetPrivateData(This,guid,DataSize,pData) ) 
+
+#define ID3D12Device_SetPrivateDataInterface(This,guid,pData)	\
+    ( (This)->lpVtbl -> SetPrivateDataInterface(This,guid,pData) ) 
+
+#define ID3D12Device_SetName(This,Name)	\
+    ( (This)->lpVtbl -> SetName(This,Name) ) 
+
+
+#define ID3D12Device_GetNodeCount(This)	\
+    ( (This)->lpVtbl -> GetNodeCount(This) ) 
+
+#define ID3D12Device_CreateCommandQueue(This,pDesc,riid,ppCommandQueue)	\
+    ( (This)->lpVtbl -> CreateCommandQueue(This,pDesc,riid,ppCommandQueue) ) 
+
+#define ID3D12Device_CreateCommandAllocator(This,type,riid,ppCommandAllocator)	\
+    ( (This)->lpVtbl -> CreateCommandAllocator(This,type,riid,ppCommandAllocator) ) 
+
+#define ID3D12Device_CreateGraphicsPipelineState(This,pDesc,riid,ppPipelineState)	\
+    ( (This)->lpVtbl -> CreateGraphicsPipelineState(This,pDesc,riid,ppPipelineState) ) 
+
+#define ID3D12Device_CreateComputePipelineState(This,pDesc,riid,ppPipelineState)	\
+    ( (This)->lpVtbl -> CreateComputePipelineState(This,pDesc,riid,ppPipelineState) ) 
+
+#define ID3D12Device_CreateCommandList(This,nodeMask,type,pCommandAllocator,pInitialState,riid,ppCommandList)	\
+    ( (This)->lpVtbl -> CreateCommandList(This,nodeMask,type,pCommandAllocator,pInitialState,riid,ppCommandList) ) 
+
+#define ID3D12Device_CheckFeatureSupport(This,Feature,pFeatureSupportData,FeatureSupportDataSize)	\
+    ( (This)->lpVtbl -> CheckFeatureSupport(This,Feature,pFeatureSupportData,FeatureSupportDataSize) ) 
+
+#define ID3D12Device_CreateDescriptorHeap(This,pDescriptorHeapDesc,riid,ppvHeap)	\
+    ( (This)->lpVtbl -> CreateDescriptorHeap(This,pDescriptorHeapDesc,riid,ppvHeap) ) 
+
+#define ID3D12Device_GetDescriptorHandleIncrementSize(This,DescriptorHeapType)	\
+    ( (This)->lpVtbl -> GetDescriptorHandleIncrementSize(This,DescriptorHeapType) ) 
+
+#define ID3D12Device_CreateRootSignature(This,nodeMask,pBlobWithRootSignature,blobLengthInBytes,riid,ppvRootSignature)	\
+    ( (This)->lpVtbl -> CreateRootSignature(This,nodeMask,pBlobWithRootSignature,blobLengthInBytes,riid,ppvRootSignature) ) 
+
+#define ID3D12Device_CreateConstantBufferView(This,pDesc,DestDescriptor)	\
+    ( (This)->lpVtbl -> CreateConstantBufferView(This,pDesc,DestDescriptor) ) 
+
+#define ID3D12Device_CreateShaderResourceView(This,pResource,pDesc,DestDescriptor)	\
+    ( (This)->lpVtbl -> CreateShaderResourceView(This,pResource,pDesc,DestDescriptor) ) 
+
+#define ID3D12Device_CreateUnorderedAccessView(This,pResource,pCounterResource,pDesc,DestDescriptor)	\
+    ( (This)->lpVtbl -> CreateUnorderedAccessView(This,pResource,pCounterResource,pDesc,DestDescriptor) ) 
+
+#define ID3D12Device_CreateRenderTargetView(This,pResource,pDesc,DestDescriptor)	\
+    ( (This)->lpVtbl -> CreateRenderTargetView(This,pResource,pDesc,DestDescriptor) ) 
+
+#define ID3D12Device_CreateDepthStencilView(This,pResource,pDesc,DestDescriptor)	\
+    ( (This)->lpVtbl -> CreateDepthStencilView(This,pResource,pDesc,DestDescriptor) ) 
+
+#define ID3D12Device_CreateSampler(This,pDesc,DestDescriptor)	\
+    ( (This)->lpVtbl -> CreateSampler(This,pDesc,DestDescriptor) ) 
+
+#define ID3D12Device_CopyDescriptors(This,NumDestDescriptorRanges,pDestDescriptorRangeStarts,pDestDescriptorRangeSizes,NumSrcDescriptorRanges,pSrcDescriptorRangeStarts,pSrcDescriptorRangeSizes,DescriptorHeapsType)	\
+    ( (This)->lpVtbl -> CopyDescriptors(This,NumDestDescriptorRanges,pDestDescriptorRangeStarts,pDestDescriptorRangeSizes,NumSrcDescriptorRanges,pSrcDescriptorRangeStarts,pSrcDescriptorRangeSizes,DescriptorHeapsType) ) 
+
+#define ID3D12Device_CopyDescriptorsSimple(This,NumDescriptors,DestDescriptorRangeStart,SrcDescriptorRangeStart,DescriptorHeapsType)	\
+    ( (This)->lpVtbl -> CopyDescriptorsSimple(This,NumDescriptors,DestDescriptorRangeStart,SrcDescriptorRangeStart,DescriptorHeapsType) ) 
+#if !defined(_WIN32)
+
+#define ID3D12Device_GetResourceAllocationInfo(This,visibleMask,numResourceDescs,pResourceDescs)	\
+    ( (This)->lpVtbl -> GetResourceAllocationInfo(This,visibleMask,numResourceDescs,pResourceDescs) ) 
+#else
+#define ID3D12Device_GetResourceAllocationInfo(This,RetVal,visibleMask,numResourceDescs,pResourceDescs)	\
+    ( (This)->lpVtbl -> GetResourceAllocationInfo(This,RetVal,visibleMask,numResourceDescs,pResourceDescs) ) 
+#endif
+#if !defined(_WIN32)
+
+#define ID3D12Device_GetCustomHeapProperties(This,nodeMask,heapType)	\
+    ( (This)->lpVtbl -> GetCustomHeapProperties(This,nodeMask,heapType) ) 
+#else
+#define ID3D12Device_GetCustomHeapProperties(This,RetVal,nodeMask,heapType)	\
+    ( (This)->lpVtbl -> GetCustomHeapProperties(This,RetVal,nodeMask,heapType) ) 
+#endif
+
+#define ID3D12Device_CreateCommittedResource(This,pHeapProperties,HeapFlags,pDesc,InitialResourceState,pOptimizedClearValue,riidResource,ppvResource)	\
+    ( (This)->lpVtbl -> CreateCommittedResource(This,pHeapProperties,HeapFlags,pDesc,InitialResourceState,pOptimizedClearValue,riidResource,ppvResource) ) 
+
+#define ID3D12Device_CreateHeap(This,pDesc,riid,ppvHeap)	\
+    ( (This)->lpVtbl -> CreateHeap(This,pDesc,riid,ppvHeap) ) 
+
+#define ID3D12Device_CreatePlacedResource(This,pHeap,HeapOffset,pDesc,InitialState,pOptimizedClearValue,riid,ppvResource)	\
+    ( (This)->lpVtbl -> CreatePlacedResource(This,pHeap,HeapOffset,pDesc,InitialState,pOptimizedClearValue,riid,ppvResource) ) 
+
+#define ID3D12Device_CreateReservedResource(This,pDesc,InitialState,pOptimizedClearValue,riid,ppvResource)	\
+    ( (This)->lpVtbl -> CreateReservedResource(This,pDesc,InitialState,pOptimizedClearValue,riid,ppvResource) ) 
+
+#define ID3D12Device_CreateSharedHandle(This,pObject,pAttributes,Access,Name,pHandle)	\
+    ( (This)->lpVtbl -> CreateSharedHandle(This,pObject,pAttributes,Access,Name,pHandle) ) 
+
+#define ID3D12Device_OpenSharedHandle(This,NTHandle,riid,ppvObj)	\
+    ( (This)->lpVtbl -> OpenSharedHandle(This,NTHandle,riid,ppvObj) ) 
+
+#define ID3D12Device_OpenSharedHandleByName(This,Name,Access,pNTHandle)	\
+    ( (This)->lpVtbl -> OpenSharedHandleByName(This,Name,Access,pNTHandle) ) 
+
+#define ID3D12Device_MakeResident(This,NumObjects,ppObjects)	\
+    ( (This)->lpVtbl -> MakeResident(This,NumObjects,ppObjects) ) 
+
+#define ID3D12Device_Evict(This,NumObjects,ppObjects)	\
+    ( (This)->lpVtbl -> Evict(This,NumObjects,ppObjects) ) 
+
+#define ID3D12Device_CreateFence(This,InitialValue,Flags,riid,ppFence)	\
+    ( (This)->lpVtbl -> CreateFence(This,InitialValue,Flags,riid,ppFence) ) 
+
+#define ID3D12Device_GetDeviceRemovedReason(This)	\
+    ( (This)->lpVtbl -> GetDeviceRemovedReason(This) ) 
+
+#define ID3D12Device_GetCopyableFootprints(This,pResourceDesc,FirstSubresource,NumSubresources,BaseOffset,pLayouts,pNumRows,pRowSizeInBytes,pTotalBytes)	\
+    ( (This)->lpVtbl -> GetCopyableFootprints(This,pResourceDesc,FirstSubresource,NumSubresources,BaseOffset,pLayouts,pNumRows,pRowSizeInBytes,pTotalBytes) ) 
+
+#define ID3D12Device_CreateQueryHeap(This,pDesc,riid,ppvHeap)	\
+    ( (This)->lpVtbl -> CreateQueryHeap(This,pDesc,riid,ppvHeap) ) 
+
+#define ID3D12Device_SetStablePowerState(This,Enable)	\
+    ( (This)->lpVtbl -> SetStablePowerState(This,Enable) ) 
+
+#define ID3D12Device_CreateCommandSignature(This,pDesc,pRootSignature,riid,ppvCommandSignature)	\
+    ( (This)->lpVtbl -> CreateCommandSignature(This,pDesc,pRootSignature,riid,ppvCommandSignature) ) 
+
+#define ID3D12Device_GetResourceTiling(This,pTiledResource,pNumTilesForEntireResource,pPackedMipDesc,pStandardTileShapeForNonPackedMips,pNumSubresourceTilings,FirstSubresourceTilingToGet,pSubresourceTilingsForNonPackedMips)	\
+    ( (This)->lpVtbl -> GetResourceTiling(This,pTiledResource,pNumTilesForEntireResource,pPackedMipDesc,pStandardTileShapeForNonPackedMips,pNumSubresourceTilings,FirstSubresourceTilingToGet,pSubresourceTilingsForNonPackedMips) ) 
+#if !defined(_WIN32)
+
+#define ID3D12Device_GetAdapterLuid(This)	\
+    ( (This)->lpVtbl -> GetAdapterLuid(This) ) 
+#else
+#define ID3D12Device_GetAdapterLuid(This,RetVal)	\
+    ( (This)->lpVtbl -> GetAdapterLuid(This,RetVal) ) 
+#endif
+
+#endif /* COBJMACROS */
+
+
+#endif 	/* C style interface */
+
+
+
+
+#endif 	/* __ID3D12Device_INTERFACE_DEFINED__ */
+
+
+#ifndef __ID3D12PipelineLibrary_INTERFACE_DEFINED__
+#define __ID3D12PipelineLibrary_INTERFACE_DEFINED__
+
+/* interface ID3D12PipelineLibrary */
+/* [unique][local][object][uuid] */ 
+
+
+EXTERN_C const IID IID_ID3D12PipelineLibrary;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("c64226a8-9201-46af-b4cc-53fb9ff7414f")
+    ID3D12PipelineLibrary : public ID3D12DeviceChild
+    {
+    public:
+        virtual HRESULT STDMETHODCALLTYPE StorePipeline( 
+            _In_opt_  LPCWSTR pName,
+            _In_  ID3D12PipelineState *pPipeline) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE LoadGraphicsPipeline( 
+            _In_  LPCWSTR pName,
+            _In_  const D3D12_GRAPHICS_PIPELINE_STATE_DESC *pDesc,
+            REFIID riid,
+            _COM_Outptr_  void **ppPipelineState) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE LoadComputePipeline( 
+            _In_  LPCWSTR pName,
+            _In_  const D3D12_COMPUTE_PIPELINE_STATE_DESC *pDesc,
+            REFIID riid,
+            _COM_Outptr_  void **ppPipelineState) = 0;
+        
+        virtual SIZE_T STDMETHODCALLTYPE GetSerializedSize( void) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE Serialize( 
+            _Out_writes_(DataSizeInBytes)  void *pData,
+            SIZE_T DataSizeInBytes) = 0;
+        
+    };
+    
+    
+#else 	/* C style interface */
+
+    typedef struct ID3D12PipelineLibraryVtbl
+    {
+        BEGIN_INTERFACE
+        
+        DECLSPEC_XFGVIRT(IUnknown, QueryInterface)
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            ID3D12PipelineLibrary * This,
+            REFIID riid,
+            _COM_Outptr_  void **ppvObject);
+        
+        DECLSPEC_XFGVIRT(IUnknown, AddRef)
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            ID3D12PipelineLibrary * This);
+        
+        DECLSPEC_XFGVIRT(IUnknown, Release)
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            ID3D12PipelineLibrary * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, GetPrivateData)
+        HRESULT ( STDMETHODCALLTYPE *GetPrivateData )( 
+            ID3D12PipelineLibrary * This,
+            _In_  REFGUID guid,
+            _Inout_  UINT *pDataSize,
+            _Out_writes_bytes_opt_( *pDataSize )  void *pData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, SetPrivateData)
+        HRESULT ( STDMETHODCALLTYPE *SetPrivateData )( 
+            ID3D12PipelineLibrary * This,
+            _In_  REFGUID guid,
+            _In_  UINT DataSize,
+            _In_reads_bytes_opt_( DataSize )  const void *pData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, SetPrivateDataInterface)
+        HRESULT ( STDMETHODCALLTYPE *SetPrivateDataInterface )( 
+            ID3D12PipelineLibrary * This,
+            _In_  REFGUID guid,
+            _In_opt_  const IUnknown *pData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, SetName)
+        HRESULT ( STDMETHODCALLTYPE *SetName )( 
+            ID3D12PipelineLibrary * This,
+            _In_z_  LPCWSTR Name);
+        
+        DECLSPEC_XFGVIRT(ID3D12DeviceChild, GetDevice)
+        HRESULT ( STDMETHODCALLTYPE *GetDevice )( 
+            ID3D12PipelineLibrary * This,
+            REFIID riid,
+            _COM_Outptr_opt_  void **ppvDevice);
+        
+        DECLSPEC_XFGVIRT(ID3D12PipelineLibrary, StorePipeline)
+        HRESULT ( STDMETHODCALLTYPE *StorePipeline )( 
+            ID3D12PipelineLibrary * This,
+            _In_opt_  LPCWSTR pName,
+            _In_  ID3D12PipelineState *pPipeline);
+        
+        DECLSPEC_XFGVIRT(ID3D12PipelineLibrary, LoadGraphicsPipeline)
+        HRESULT ( STDMETHODCALLTYPE *LoadGraphicsPipeline )( 
+            ID3D12PipelineLibrary * This,
+            _In_  LPCWSTR pName,
+            _In_  const D3D12_GRAPHICS_PIPELINE_STATE_DESC *pDesc,
+            REFIID riid,
+            _COM_Outptr_  void **ppPipelineState);
+        
+        DECLSPEC_XFGVIRT(ID3D12PipelineLibrary, LoadComputePipeline)
+        HRESULT ( STDMETHODCALLTYPE *LoadComputePipeline )( 
+            ID3D12PipelineLibrary * This,
+            _In_  LPCWSTR pName,
+            _In_  const D3D12_COMPUTE_PIPELINE_STATE_DESC *pDesc,
+            REFIID riid,
+            _COM_Outptr_  void **ppPipelineState);
+        
+        DECLSPEC_XFGVIRT(ID3D12PipelineLibrary, GetSerializedSize)
+        SIZE_T ( STDMETHODCALLTYPE *GetSerializedSize )( 
+            ID3D12PipelineLibrary * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12PipelineLibrary, Serialize)
+        HRESULT ( STDMETHODCALLTYPE *Serialize )( 
+            ID3D12PipelineLibrary * This,
+            _Out_writes_(DataSizeInBytes)  void *pData,
+            SIZE_T DataSizeInBytes);
+        
+        END_INTERFACE
+    } ID3D12PipelineLibraryVtbl;
+
+    interface ID3D12PipelineLibrary
+    {
+        CONST_VTBL struct ID3D12PipelineLibraryVtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define ID3D12PipelineLibrary_QueryInterface(This,riid,ppvObject)	\
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define ID3D12PipelineLibrary_AddRef(This)	\
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define ID3D12PipelineLibrary_Release(This)	\
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#define ID3D12PipelineLibrary_GetPrivateData(This,guid,pDataSize,pData)	\
+    ( (This)->lpVtbl -> GetPrivateData(This,guid,pDataSize,pData) ) 
+
+#define ID3D12PipelineLibrary_SetPrivateData(This,guid,DataSize,pData)	\
+    ( (This)->lpVtbl -> SetPrivateData(This,guid,DataSize,pData) ) 
+
+#define ID3D12PipelineLibrary_SetPrivateDataInterface(This,guid,pData)	\
+    ( (This)->lpVtbl -> SetPrivateDataInterface(This,guid,pData) ) 
+
+#define ID3D12PipelineLibrary_SetName(This,Name)	\
+    ( (This)->lpVtbl -> SetName(This,Name) ) 
+
+
+#define ID3D12PipelineLibrary_GetDevice(This,riid,ppvDevice)	\
+    ( (This)->lpVtbl -> GetDevice(This,riid,ppvDevice) ) 
+
+
+#define ID3D12PipelineLibrary_StorePipeline(This,pName,pPipeline)	\
+    ( (This)->lpVtbl -> StorePipeline(This,pName,pPipeline) ) 
+
+#define ID3D12PipelineLibrary_LoadGraphicsPipeline(This,pName,pDesc,riid,ppPipelineState)	\
+    ( (This)->lpVtbl -> LoadGraphicsPipeline(This,pName,pDesc,riid,ppPipelineState) ) 
+
+#define ID3D12PipelineLibrary_LoadComputePipeline(This,pName,pDesc,riid,ppPipelineState)	\
+    ( (This)->lpVtbl -> LoadComputePipeline(This,pName,pDesc,riid,ppPipelineState) ) 
+
+#define ID3D12PipelineLibrary_GetSerializedSize(This)	\
+    ( (This)->lpVtbl -> GetSerializedSize(This) ) 
+
+#define ID3D12PipelineLibrary_Serialize(This,pData,DataSizeInBytes)	\
+    ( (This)->lpVtbl -> Serialize(This,pData,DataSizeInBytes) ) 
+
+#endif /* COBJMACROS */
+
+
+#endif 	/* C style interface */
+
+
+
+
+#endif 	/* __ID3D12PipelineLibrary_INTERFACE_DEFINED__ */
+
+
+#ifndef __ID3D12PipelineLibrary1_INTERFACE_DEFINED__
+#define __ID3D12PipelineLibrary1_INTERFACE_DEFINED__
+
+/* interface ID3D12PipelineLibrary1 */
+/* [unique][local][object][uuid] */ 
+
+
+EXTERN_C const IID IID_ID3D12PipelineLibrary1;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("80eabf42-2568-4e5e-bd82-c37f86961dc3")
+    ID3D12PipelineLibrary1 : public ID3D12PipelineLibrary
+    {
+    public:
+        virtual HRESULT STDMETHODCALLTYPE LoadPipeline( 
+            _In_  LPCWSTR pName,
+            _In_  const D3D12_PIPELINE_STATE_STREAM_DESC *pDesc,
+            REFIID riid,
+            _COM_Outptr_  void **ppPipelineState) = 0;
+        
+    };
+    
+    
+#else 	/* C style interface */
+
+    typedef struct ID3D12PipelineLibrary1Vtbl
+    {
+        BEGIN_INTERFACE
+        
+        DECLSPEC_XFGVIRT(IUnknown, QueryInterface)
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            ID3D12PipelineLibrary1 * This,
+            REFIID riid,
+            _COM_Outptr_  void **ppvObject);
+        
+        DECLSPEC_XFGVIRT(IUnknown, AddRef)
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            ID3D12PipelineLibrary1 * This);
+        
+        DECLSPEC_XFGVIRT(IUnknown, Release)
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            ID3D12PipelineLibrary1 * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, GetPrivateData)
+        HRESULT ( STDMETHODCALLTYPE *GetPrivateData )( 
+            ID3D12PipelineLibrary1 * This,
+            _In_  REFGUID guid,
+            _Inout_  UINT *pDataSize,
+            _Out_writes_bytes_opt_( *pDataSize )  void *pData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, SetPrivateData)
+        HRESULT ( STDMETHODCALLTYPE *SetPrivateData )( 
+            ID3D12PipelineLibrary1 * This,
+            _In_  REFGUID guid,
+            _In_  UINT DataSize,
+            _In_reads_bytes_opt_( DataSize )  const void *pData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, SetPrivateDataInterface)
+        HRESULT ( STDMETHODCALLTYPE *SetPrivateDataInterface )( 
+            ID3D12PipelineLibrary1 * This,
+            _In_  REFGUID guid,
+            _In_opt_  const IUnknown *pData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, SetName)
+        HRESULT ( STDMETHODCALLTYPE *SetName )( 
+            ID3D12PipelineLibrary1 * This,
+            _In_z_  LPCWSTR Name);
+        
+        DECLSPEC_XFGVIRT(ID3D12DeviceChild, GetDevice)
+        HRESULT ( STDMETHODCALLTYPE *GetDevice )( 
+            ID3D12PipelineLibrary1 * This,
+            REFIID riid,
+            _COM_Outptr_opt_  void **ppvDevice);
+        
+        DECLSPEC_XFGVIRT(ID3D12PipelineLibrary, StorePipeline)
+        HRESULT ( STDMETHODCALLTYPE *StorePipeline )( 
+            ID3D12PipelineLibrary1 * This,
+            _In_opt_  LPCWSTR pName,
+            _In_  ID3D12PipelineState *pPipeline);
+        
+        DECLSPEC_XFGVIRT(ID3D12PipelineLibrary, LoadGraphicsPipeline)
+        HRESULT ( STDMETHODCALLTYPE *LoadGraphicsPipeline )( 
+            ID3D12PipelineLibrary1 * This,
+            _In_  LPCWSTR pName,
+            _In_  const D3D12_GRAPHICS_PIPELINE_STATE_DESC *pDesc,
+            REFIID riid,
+            _COM_Outptr_  void **ppPipelineState);
+        
+        DECLSPEC_XFGVIRT(ID3D12PipelineLibrary, LoadComputePipeline)
+        HRESULT ( STDMETHODCALLTYPE *LoadComputePipeline )( 
+            ID3D12PipelineLibrary1 * This,
+            _In_  LPCWSTR pName,
+            _In_  const D3D12_COMPUTE_PIPELINE_STATE_DESC *pDesc,
+            REFIID riid,
+            _COM_Outptr_  void **ppPipelineState);
+        
+        DECLSPEC_XFGVIRT(ID3D12PipelineLibrary, GetSerializedSize)
+        SIZE_T ( STDMETHODCALLTYPE *GetSerializedSize )( 
+            ID3D12PipelineLibrary1 * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12PipelineLibrary, Serialize)
+        HRESULT ( STDMETHODCALLTYPE *Serialize )( 
+            ID3D12PipelineLibrary1 * This,
+            _Out_writes_(DataSizeInBytes)  void *pData,
+            SIZE_T DataSizeInBytes);
+        
+        DECLSPEC_XFGVIRT(ID3D12PipelineLibrary1, LoadPipeline)
+        HRESULT ( STDMETHODCALLTYPE *LoadPipeline )( 
+            ID3D12PipelineLibrary1 * This,
+            _In_  LPCWSTR pName,
+            _In_  const D3D12_PIPELINE_STATE_STREAM_DESC *pDesc,
+            REFIID riid,
+            _COM_Outptr_  void **ppPipelineState);
+        
+        END_INTERFACE
+    } ID3D12PipelineLibrary1Vtbl;
+
+    interface ID3D12PipelineLibrary1
+    {
+        CONST_VTBL struct ID3D12PipelineLibrary1Vtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define ID3D12PipelineLibrary1_QueryInterface(This,riid,ppvObject)	\
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define ID3D12PipelineLibrary1_AddRef(This)	\
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define ID3D12PipelineLibrary1_Release(This)	\
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#define ID3D12PipelineLibrary1_GetPrivateData(This,guid,pDataSize,pData)	\
+    ( (This)->lpVtbl -> GetPrivateData(This,guid,pDataSize,pData) ) 
+
+#define ID3D12PipelineLibrary1_SetPrivateData(This,guid,DataSize,pData)	\
+    ( (This)->lpVtbl -> SetPrivateData(This,guid,DataSize,pData) ) 
+
+#define ID3D12PipelineLibrary1_SetPrivateDataInterface(This,guid,pData)	\
+    ( (This)->lpVtbl -> SetPrivateDataInterface(This,guid,pData) ) 
+
+#define ID3D12PipelineLibrary1_SetName(This,Name)	\
+    ( (This)->lpVtbl -> SetName(This,Name) ) 
+
+
+#define ID3D12PipelineLibrary1_GetDevice(This,riid,ppvDevice)	\
+    ( (This)->lpVtbl -> GetDevice(This,riid,ppvDevice) ) 
+
+
+#define ID3D12PipelineLibrary1_StorePipeline(This,pName,pPipeline)	\
+    ( (This)->lpVtbl -> StorePipeline(This,pName,pPipeline) ) 
+
+#define ID3D12PipelineLibrary1_LoadGraphicsPipeline(This,pName,pDesc,riid,ppPipelineState)	\
+    ( (This)->lpVtbl -> LoadGraphicsPipeline(This,pName,pDesc,riid,ppPipelineState) ) 
+
+#define ID3D12PipelineLibrary1_LoadComputePipeline(This,pName,pDesc,riid,ppPipelineState)	\
+    ( (This)->lpVtbl -> LoadComputePipeline(This,pName,pDesc,riid,ppPipelineState) ) 
+
+#define ID3D12PipelineLibrary1_GetSerializedSize(This)	\
+    ( (This)->lpVtbl -> GetSerializedSize(This) ) 
+
+#define ID3D12PipelineLibrary1_Serialize(This,pData,DataSizeInBytes)	\
+    ( (This)->lpVtbl -> Serialize(This,pData,DataSizeInBytes) ) 
+
+
+#define ID3D12PipelineLibrary1_LoadPipeline(This,pName,pDesc,riid,ppPipelineState)	\
+    ( (This)->lpVtbl -> LoadPipeline(This,pName,pDesc,riid,ppPipelineState) ) 
+
+#endif /* COBJMACROS */
+
+
+#endif 	/* C style interface */
+
+
+
+
+#endif 	/* __ID3D12PipelineLibrary1_INTERFACE_DEFINED__ */
+
+
+/* interface __MIDL_itf_d3d12_0000_0023 */
+/* [local] */ 
+
+typedef 
+enum D3D12_MULTIPLE_FENCE_WAIT_FLAGS
+    {
+        D3D12_MULTIPLE_FENCE_WAIT_FLAG_NONE	= 0,
+        D3D12_MULTIPLE_FENCE_WAIT_FLAG_ANY	= 0x1,
+        D3D12_MULTIPLE_FENCE_WAIT_FLAG_ALL	= 0
+    } 	D3D12_MULTIPLE_FENCE_WAIT_FLAGS;
+
+DEFINE_ENUM_FLAG_OPERATORS( D3D12_MULTIPLE_FENCE_WAIT_FLAGS );
+typedef 
+enum D3D12_RESIDENCY_PRIORITY
+    {
+        D3D12_RESIDENCY_PRIORITY_MINIMUM	= 0x28000000,
+        D3D12_RESIDENCY_PRIORITY_LOW	= 0x50000000,
+        D3D12_RESIDENCY_PRIORITY_NORMAL	= 0x78000000,
+        D3D12_RESIDENCY_PRIORITY_HIGH	= 0xa0010000,
+        D3D12_RESIDENCY_PRIORITY_MAXIMUM	= 0xc8000000
+    } 	D3D12_RESIDENCY_PRIORITY;
+
+
+
+extern RPC_IF_HANDLE __MIDL_itf_d3d12_0000_0023_v0_0_c_ifspec;
+extern RPC_IF_HANDLE __MIDL_itf_d3d12_0000_0023_v0_0_s_ifspec;
+
+#ifndef __ID3D12Device1_INTERFACE_DEFINED__
+#define __ID3D12Device1_INTERFACE_DEFINED__
+
+/* interface ID3D12Device1 */
+/* [unique][local][object][uuid] */ 
+
+
+EXTERN_C const IID IID_ID3D12Device1;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("77acce80-638e-4e65-8895-c1f23386863e")
+    ID3D12Device1 : public ID3D12Device
+    {
+    public:
+        virtual HRESULT STDMETHODCALLTYPE CreatePipelineLibrary( 
+            _In_reads_(BlobLength)  const void *pLibraryBlob,
+            SIZE_T BlobLength,
+            REFIID riid,
+            _COM_Outptr_  void **ppPipelineLibrary) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE SetEventOnMultipleFenceCompletion( 
+            _In_reads_(NumFences)  ID3D12Fence *const *ppFences,
+            _In_reads_(NumFences)  const UINT64 *pFenceValues,
+            UINT NumFences,
+            D3D12_MULTIPLE_FENCE_WAIT_FLAGS Flags,
+            HANDLE hEvent) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE SetResidencyPriority( 
+            UINT NumObjects,
+            _In_reads_(NumObjects)  ID3D12Pageable *const *ppObjects,
+            _In_reads_(NumObjects)  const D3D12_RESIDENCY_PRIORITY *pPriorities) = 0;
+        
+    };
+    
+    
+#else 	/* C style interface */
+
+    typedef struct ID3D12Device1Vtbl
+    {
+        BEGIN_INTERFACE
+        
+        DECLSPEC_XFGVIRT(IUnknown, QueryInterface)
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            ID3D12Device1 * This,
+            REFIID riid,
+            _COM_Outptr_  void **ppvObject);
+        
+        DECLSPEC_XFGVIRT(IUnknown, AddRef)
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            ID3D12Device1 * This);
+        
+        DECLSPEC_XFGVIRT(IUnknown, Release)
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            ID3D12Device1 * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, GetPrivateData)
+        HRESULT ( STDMETHODCALLTYPE *GetPrivateData )( 
+            ID3D12Device1 * This,
+            _In_  REFGUID guid,
+            _Inout_  UINT *pDataSize,
+            _Out_writes_bytes_opt_( *pDataSize )  void *pData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, SetPrivateData)
+        HRESULT ( STDMETHODCALLTYPE *SetPrivateData )( 
+            ID3D12Device1 * This,
+            _In_  REFGUID guid,
+            _In_  UINT DataSize,
+            _In_reads_bytes_opt_( DataSize )  const void *pData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, SetPrivateDataInterface)
+        HRESULT ( STDMETHODCALLTYPE *SetPrivateDataInterface )( 
+            ID3D12Device1 * This,
+            _In_  REFGUID guid,
+            _In_opt_  const IUnknown *pData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, SetName)
+        HRESULT ( STDMETHODCALLTYPE *SetName )( 
+            ID3D12Device1 * This,
+            _In_z_  LPCWSTR Name);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, GetNodeCount)
+        UINT ( STDMETHODCALLTYPE *GetNodeCount )( 
+            ID3D12Device1 * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CreateCommandQueue)
+        HRESULT ( STDMETHODCALLTYPE *CreateCommandQueue )( 
+            ID3D12Device1 * This,
+            _In_  const D3D12_COMMAND_QUEUE_DESC *pDesc,
+            REFIID riid,
+            _COM_Outptr_  void **ppCommandQueue);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CreateCommandAllocator)
+        HRESULT ( STDMETHODCALLTYPE *CreateCommandAllocator )( 
+            ID3D12Device1 * This,
+            _In_  D3D12_COMMAND_LIST_TYPE type,
+            REFIID riid,
+            _COM_Outptr_  void **ppCommandAllocator);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CreateGraphicsPipelineState)
+        HRESULT ( STDMETHODCALLTYPE *CreateGraphicsPipelineState )( 
+            ID3D12Device1 * This,
+            _In_  const D3D12_GRAPHICS_PIPELINE_STATE_DESC *pDesc,
+            REFIID riid,
+            _COM_Outptr_  void **ppPipelineState);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CreateComputePipelineState)
+        HRESULT ( STDMETHODCALLTYPE *CreateComputePipelineState )( 
+            ID3D12Device1 * This,
+            _In_  const D3D12_COMPUTE_PIPELINE_STATE_DESC *pDesc,
+            REFIID riid,
+            _COM_Outptr_  void **ppPipelineState);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CreateCommandList)
+        HRESULT ( STDMETHODCALLTYPE *CreateCommandList )( 
+            ID3D12Device1 * This,
+            _In_  UINT nodeMask,
+            _In_  D3D12_COMMAND_LIST_TYPE type,
+            _In_  ID3D12CommandAllocator *pCommandAllocator,
+            _In_opt_  ID3D12PipelineState *pInitialState,
+            REFIID riid,
+            _COM_Outptr_  void **ppCommandList);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CheckFeatureSupport)
+        HRESULT ( STDMETHODCALLTYPE *CheckFeatureSupport )( 
+            ID3D12Device1 * This,
+            D3D12_FEATURE Feature,
+            _Inout_updates_bytes_(FeatureSupportDataSize)  void *pFeatureSupportData,
+            UINT FeatureSupportDataSize);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CreateDescriptorHeap)
+        HRESULT ( STDMETHODCALLTYPE *CreateDescriptorHeap )( 
+            ID3D12Device1 * This,
+            _In_  const D3D12_DESCRIPTOR_HEAP_DESC *pDescriptorHeapDesc,
+            REFIID riid,
+            _COM_Outptr_  void **ppvHeap);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, GetDescriptorHandleIncrementSize)
+        UINT ( STDMETHODCALLTYPE *GetDescriptorHandleIncrementSize )( 
+            ID3D12Device1 * This,
+            _In_  D3D12_DESCRIPTOR_HEAP_TYPE DescriptorHeapType);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CreateRootSignature)
+        HRESULT ( STDMETHODCALLTYPE *CreateRootSignature )( 
+            ID3D12Device1 * This,
+            _In_  UINT nodeMask,
+            _In_reads_(blobLengthInBytes)  const void *pBlobWithRootSignature,
+            _In_  SIZE_T blobLengthInBytes,
+            REFIID riid,
+            _COM_Outptr_  void **ppvRootSignature);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CreateConstantBufferView)
+        void ( STDMETHODCALLTYPE *CreateConstantBufferView )( 
+            ID3D12Device1 * This,
+            _In_opt_  const D3D12_CONSTANT_BUFFER_VIEW_DESC *pDesc,
+            _In_  D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CreateShaderResourceView)
+        void ( STDMETHODCALLTYPE *CreateShaderResourceView )( 
+            ID3D12Device1 * This,
+            _In_opt_  ID3D12Resource *pResource,
+            _In_opt_  const D3D12_SHADER_RESOURCE_VIEW_DESC *pDesc,
+            _In_  D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CreateUnorderedAccessView)
+        void ( STDMETHODCALLTYPE *CreateUnorderedAccessView )( 
+            ID3D12Device1 * This,
+            _In_opt_  ID3D12Resource *pResource,
+            _In_opt_  ID3D12Resource *pCounterResource,
+            _In_opt_  const D3D12_UNORDERED_ACCESS_VIEW_DESC *pDesc,
+            _In_  D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CreateRenderTargetView)
+        void ( STDMETHODCALLTYPE *CreateRenderTargetView )( 
+            ID3D12Device1 * This,
+            _In_opt_  ID3D12Resource *pResource,
+            _In_opt_  const D3D12_RENDER_TARGET_VIEW_DESC *pDesc,
+            _In_  D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CreateDepthStencilView)
+        void ( STDMETHODCALLTYPE *CreateDepthStencilView )( 
+            ID3D12Device1 * This,
+            _In_opt_  ID3D12Resource *pResource,
+            _In_opt_  const D3D12_DEPTH_STENCIL_VIEW_DESC *pDesc,
+            _In_  D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CreateSampler)
+        void ( STDMETHODCALLTYPE *CreateSampler )( 
+            ID3D12Device1 * This,
+            _In_  const D3D12_SAMPLER_DESC *pDesc,
+            _In_  D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CopyDescriptors)
+        void ( STDMETHODCALLTYPE *CopyDescriptors )( 
+            ID3D12Device1 * This,
+            _In_  UINT NumDestDescriptorRanges,
+            _In_reads_(NumDestDescriptorRanges)  const D3D12_CPU_DESCRIPTOR_HANDLE *pDestDescriptorRangeStarts,
+            _In_reads_opt_(NumDestDescriptorRanges)  const UINT *pDestDescriptorRangeSizes,
+            _In_  UINT NumSrcDescriptorRanges,
+            _In_reads_(NumSrcDescriptorRanges)  const D3D12_CPU_DESCRIPTOR_HANDLE *pSrcDescriptorRangeStarts,
+            _In_reads_opt_(NumSrcDescriptorRanges)  const UINT *pSrcDescriptorRangeSizes,
+            _In_  D3D12_DESCRIPTOR_HEAP_TYPE DescriptorHeapsType);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CopyDescriptorsSimple)
+        void ( STDMETHODCALLTYPE *CopyDescriptorsSimple )( 
+            ID3D12Device1 * This,
+            _In_  UINT NumDescriptors,
+            _In_  D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptorRangeStart,
+            _In_  D3D12_CPU_DESCRIPTOR_HANDLE SrcDescriptorRangeStart,
+            _In_  D3D12_DESCRIPTOR_HEAP_TYPE DescriptorHeapsType);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, GetResourceAllocationInfo)
+#if !defined(_WIN32)
+        D3D12_RESOURCE_ALLOCATION_INFO ( STDMETHODCALLTYPE *GetResourceAllocationInfo )( 
+            ID3D12Device1 * This,
+            _In_  UINT visibleMask,
+            _In_  UINT numResourceDescs,
+            _In_reads_(numResourceDescs)  const D3D12_RESOURCE_DESC *pResourceDescs);
+        
+#else
+        D3D12_RESOURCE_ALLOCATION_INFO *( STDMETHODCALLTYPE *GetResourceAllocationInfo )( 
+            ID3D12Device1 * This,
+            D3D12_RESOURCE_ALLOCATION_INFO * RetVal,
+            _In_  UINT visibleMask,
+            _In_  UINT numResourceDescs,
+            _In_reads_(numResourceDescs)  const D3D12_RESOURCE_DESC *pResourceDescs);
+        
+#endif
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, GetCustomHeapProperties)
+#if !defined(_WIN32)
+        D3D12_HEAP_PROPERTIES ( STDMETHODCALLTYPE *GetCustomHeapProperties )( 
+            ID3D12Device1 * This,
+            _In_  UINT nodeMask,
+            D3D12_HEAP_TYPE heapType);
+        
+#else
+        D3D12_HEAP_PROPERTIES *( STDMETHODCALLTYPE *GetCustomHeapProperties )( 
+            ID3D12Device1 * This,
+            D3D12_HEAP_PROPERTIES * RetVal,
+            _In_  UINT nodeMask,
+            D3D12_HEAP_TYPE heapType);
+        
+#endif
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CreateCommittedResource)
+        HRESULT ( STDMETHODCALLTYPE *CreateCommittedResource )( 
+            ID3D12Device1 * This,
+            _In_  const D3D12_HEAP_PROPERTIES *pHeapProperties,
+            D3D12_HEAP_FLAGS HeapFlags,
+            _In_  const D3D12_RESOURCE_DESC *pDesc,
+            D3D12_RESOURCE_STATES InitialResourceState,
+            _In_opt_  const D3D12_CLEAR_VALUE *pOptimizedClearValue,
+            REFIID riidResource,
+            _COM_Outptr_opt_  void **ppvResource);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CreateHeap)
+        HRESULT ( STDMETHODCALLTYPE *CreateHeap )( 
+            ID3D12Device1 * This,
+            _In_  const D3D12_HEAP_DESC *pDesc,
+            REFIID riid,
+            _COM_Outptr_opt_  void **ppvHeap);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CreatePlacedResource)
+        HRESULT ( STDMETHODCALLTYPE *CreatePlacedResource )( 
+            ID3D12Device1 * This,
+            _In_  ID3D12Heap *pHeap,
+            UINT64 HeapOffset,
+            _In_  const D3D12_RESOURCE_DESC *pDesc,
+            D3D12_RESOURCE_STATES InitialState,
+            _In_opt_  const D3D12_CLEAR_VALUE *pOptimizedClearValue,
+            REFIID riid,
+            _COM_Outptr_opt_  void **ppvResource);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CreateReservedResource)
+        HRESULT ( STDMETHODCALLTYPE *CreateReservedResource )( 
+            ID3D12Device1 * This,
+            _In_  const D3D12_RESOURCE_DESC *pDesc,
+            D3D12_RESOURCE_STATES InitialState,
+            _In_opt_  const D3D12_CLEAR_VALUE *pOptimizedClearValue,
+            REFIID riid,
+            _COM_Outptr_opt_  void **ppvResource);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CreateSharedHandle)
+        HRESULT ( STDMETHODCALLTYPE *CreateSharedHandle )( 
+            ID3D12Device1 * This,
+            _In_  ID3D12DeviceChild *pObject,
+            _In_opt_  const SECURITY_ATTRIBUTES *pAttributes,
+            DWORD Access,
+            _In_opt_  LPCWSTR Name,
+            _Out_  HANDLE *pHandle);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, OpenSharedHandle)
+        HRESULT ( STDMETHODCALLTYPE *OpenSharedHandle )( 
+            ID3D12Device1 * This,
+            _In_  HANDLE NTHandle,
+            REFIID riid,
+            _COM_Outptr_opt_  void **ppvObj);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, OpenSharedHandleByName)
+        HRESULT ( STDMETHODCALLTYPE *OpenSharedHandleByName )( 
+            ID3D12Device1 * This,
+            _In_  LPCWSTR Name,
+            DWORD Access,
+            /* [annotation][out] */ 
+            _Out_  HANDLE *pNTHandle);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, MakeResident)
+        HRESULT ( STDMETHODCALLTYPE *MakeResident )( 
+            ID3D12Device1 * This,
+            UINT NumObjects,
+            _In_reads_(NumObjects)  ID3D12Pageable *const *ppObjects);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, Evict)
+        HRESULT ( STDMETHODCALLTYPE *Evict )( 
+            ID3D12Device1 * This,
+            UINT NumObjects,
+            _In_reads_(NumObjects)  ID3D12Pageable *const *ppObjects);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CreateFence)
+        HRESULT ( STDMETHODCALLTYPE *CreateFence )( 
+            ID3D12Device1 * This,
+            UINT64 InitialValue,
+            D3D12_FENCE_FLAGS Flags,
+            REFIID riid,
+            _COM_Outptr_  void **ppFence);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, GetDeviceRemovedReason)
+        HRESULT ( STDMETHODCALLTYPE *GetDeviceRemovedReason )( 
+            ID3D12Device1 * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, GetCopyableFootprints)
+        void ( STDMETHODCALLTYPE *GetCopyableFootprints )( 
+            ID3D12Device1 * This,
+            _In_  const D3D12_RESOURCE_DESC *pResourceDesc,
+            _In_range_(0,D3D12_REQ_SUBRESOURCES)  UINT FirstSubresource,
+            _In_range_(0,D3D12_REQ_SUBRESOURCES-FirstSubresource)  UINT NumSubresources,
+            UINT64 BaseOffset,
+            _Out_writes_opt_(NumSubresources)  D3D12_PLACED_SUBRESOURCE_FOOTPRINT *pLayouts,
+            _Out_writes_opt_(NumSubresources)  UINT *pNumRows,
+            _Out_writes_opt_(NumSubresources)  UINT64 *pRowSizeInBytes,
+            _Out_opt_  UINT64 *pTotalBytes);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CreateQueryHeap)
+        HRESULT ( STDMETHODCALLTYPE *CreateQueryHeap )( 
+            ID3D12Device1 * This,
+            _In_  const D3D12_QUERY_HEAP_DESC *pDesc,
+            REFIID riid,
+            _COM_Outptr_opt_  void **ppvHeap);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, SetStablePowerState)
+        HRESULT ( STDMETHODCALLTYPE *SetStablePowerState )( 
+            ID3D12Device1 * This,
+            BOOL Enable);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CreateCommandSignature)
+        HRESULT ( STDMETHODCALLTYPE *CreateCommandSignature )( 
+            ID3D12Device1 * This,
+            _In_  const D3D12_COMMAND_SIGNATURE_DESC *pDesc,
+            _In_opt_  ID3D12RootSignature *pRootSignature,
+            REFIID riid,
+            _COM_Outptr_opt_  void **ppvCommandSignature);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, GetResourceTiling)
+        void ( STDMETHODCALLTYPE *GetResourceTiling )( 
+            ID3D12Device1 * This,
+            _In_  ID3D12Resource *pTiledResource,
+            _Out_opt_  UINT *pNumTilesForEntireResource,
+            _Out_opt_  D3D12_PACKED_MIP_INFO *pPackedMipDesc,
+            _Out_opt_  D3D12_TILE_SHAPE *pStandardTileShapeForNonPackedMips,
+            _Inout_opt_  UINT *pNumSubresourceTilings,
+            _In_  UINT FirstSubresourceTilingToGet,
+            _Out_writes_(*pNumSubresourceTilings)  D3D12_SUBRESOURCE_TILING *pSubresourceTilingsForNonPackedMips);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, GetAdapterLuid)
+#if !defined(_WIN32)
+        LUID ( STDMETHODCALLTYPE *GetAdapterLuid )( 
+            ID3D12Device1 * This);
+        
+#else
+        LUID *( STDMETHODCALLTYPE *GetAdapterLuid )( 
+            ID3D12Device1 * This,
+            LUID * RetVal);
+        
+#endif
+        
+        DECLSPEC_XFGVIRT(ID3D12Device1, CreatePipelineLibrary)
+        HRESULT ( STDMETHODCALLTYPE *CreatePipelineLibrary )( 
+            ID3D12Device1 * This,
+            _In_reads_(BlobLength)  const void *pLibraryBlob,
+            SIZE_T BlobLength,
+            REFIID riid,
+            _COM_Outptr_  void **ppPipelineLibrary);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device1, SetEventOnMultipleFenceCompletion)
+        HRESULT ( STDMETHODCALLTYPE *SetEventOnMultipleFenceCompletion )( 
+            ID3D12Device1 * This,
+            _In_reads_(NumFences)  ID3D12Fence *const *ppFences,
+            _In_reads_(NumFences)  const UINT64 *pFenceValues,
+            UINT NumFences,
+            D3D12_MULTIPLE_FENCE_WAIT_FLAGS Flags,
+            HANDLE hEvent);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device1, SetResidencyPriority)
+        HRESULT ( STDMETHODCALLTYPE *SetResidencyPriority )( 
+            ID3D12Device1 * This,
+            UINT NumObjects,
+            _In_reads_(NumObjects)  ID3D12Pageable *const *ppObjects,
+            _In_reads_(NumObjects)  const D3D12_RESIDENCY_PRIORITY *pPriorities);
+        
+        END_INTERFACE
+    } ID3D12Device1Vtbl;
+
+    interface ID3D12Device1
+    {
+        CONST_VTBL struct ID3D12Device1Vtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define ID3D12Device1_QueryInterface(This,riid,ppvObject)	\
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define ID3D12Device1_AddRef(This)	\
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define ID3D12Device1_Release(This)	\
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#define ID3D12Device1_GetPrivateData(This,guid,pDataSize,pData)	\
+    ( (This)->lpVtbl -> GetPrivateData(This,guid,pDataSize,pData) ) 
+
+#define ID3D12Device1_SetPrivateData(This,guid,DataSize,pData)	\
+    ( (This)->lpVtbl -> SetPrivateData(This,guid,DataSize,pData) ) 
+
+#define ID3D12Device1_SetPrivateDataInterface(This,guid,pData)	\
+    ( (This)->lpVtbl -> SetPrivateDataInterface(This,guid,pData) ) 
+
+#define ID3D12Device1_SetName(This,Name)	\
+    ( (This)->lpVtbl -> SetName(This,Name) ) 
+
+
+#define ID3D12Device1_GetNodeCount(This)	\
+    ( (This)->lpVtbl -> GetNodeCount(This) ) 
+
+#define ID3D12Device1_CreateCommandQueue(This,pDesc,riid,ppCommandQueue)	\
+    ( (This)->lpVtbl -> CreateCommandQueue(This,pDesc,riid,ppCommandQueue) ) 
+
+#define ID3D12Device1_CreateCommandAllocator(This,type,riid,ppCommandAllocator)	\
+    ( (This)->lpVtbl -> CreateCommandAllocator(This,type,riid,ppCommandAllocator) ) 
+
+#define ID3D12Device1_CreateGraphicsPipelineState(This,pDesc,riid,ppPipelineState)	\
+    ( (This)->lpVtbl -> CreateGraphicsPipelineState(This,pDesc,riid,ppPipelineState) ) 
+
+#define ID3D12Device1_CreateComputePipelineState(This,pDesc,riid,ppPipelineState)	\
+    ( (This)->lpVtbl -> CreateComputePipelineState(This,pDesc,riid,ppPipelineState) ) 
+
+#define ID3D12Device1_CreateCommandList(This,nodeMask,type,pCommandAllocator,pInitialState,riid,ppCommandList)	\
+    ( (This)->lpVtbl -> CreateCommandList(This,nodeMask,type,pCommandAllocator,pInitialState,riid,ppCommandList) ) 
+
+#define ID3D12Device1_CheckFeatureSupport(This,Feature,pFeatureSupportData,FeatureSupportDataSize)	\
+    ( (This)->lpVtbl -> CheckFeatureSupport(This,Feature,pFeatureSupportData,FeatureSupportDataSize) ) 
+
+#define ID3D12Device1_CreateDescriptorHeap(This,pDescriptorHeapDesc,riid,ppvHeap)	\
+    ( (This)->lpVtbl -> CreateDescriptorHeap(This,pDescriptorHeapDesc,riid,ppvHeap) ) 
+
+#define ID3D12Device1_GetDescriptorHandleIncrementSize(This,DescriptorHeapType)	\
+    ( (This)->lpVtbl -> GetDescriptorHandleIncrementSize(This,DescriptorHeapType) ) 
+
+#define ID3D12Device1_CreateRootSignature(This,nodeMask,pBlobWithRootSignature,blobLengthInBytes,riid,ppvRootSignature)	\
+    ( (This)->lpVtbl -> CreateRootSignature(This,nodeMask,pBlobWithRootSignature,blobLengthInBytes,riid,ppvRootSignature) ) 
+
+#define ID3D12Device1_CreateConstantBufferView(This,pDesc,DestDescriptor)	\
+    ( (This)->lpVtbl -> CreateConstantBufferView(This,pDesc,DestDescriptor) ) 
+
+#define ID3D12Device1_CreateShaderResourceView(This,pResource,pDesc,DestDescriptor)	\
+    ( (This)->lpVtbl -> CreateShaderResourceView(This,pResource,pDesc,DestDescriptor) ) 
+
+#define ID3D12Device1_CreateUnorderedAccessView(This,pResource,pCounterResource,pDesc,DestDescriptor)	\
+    ( (This)->lpVtbl -> CreateUnorderedAccessView(This,pResource,pCounterResource,pDesc,DestDescriptor) ) 
+
+#define ID3D12Device1_CreateRenderTargetView(This,pResource,pDesc,DestDescriptor)	\
+    ( (This)->lpVtbl -> CreateRenderTargetView(This,pResource,pDesc,DestDescriptor) ) 
+
+#define ID3D12Device1_CreateDepthStencilView(This,pResource,pDesc,DestDescriptor)	\
+    ( (This)->lpVtbl -> CreateDepthStencilView(This,pResource,pDesc,DestDescriptor) ) 
+
+#define ID3D12Device1_CreateSampler(This,pDesc,DestDescriptor)	\
+    ( (This)->lpVtbl -> CreateSampler(This,pDesc,DestDescriptor) ) 
+
+#define ID3D12Device1_CopyDescriptors(This,NumDestDescriptorRanges,pDestDescriptorRangeStarts,pDestDescriptorRangeSizes,NumSrcDescriptorRanges,pSrcDescriptorRangeStarts,pSrcDescriptorRangeSizes,DescriptorHeapsType)	\
+    ( (This)->lpVtbl -> CopyDescriptors(This,NumDestDescriptorRanges,pDestDescriptorRangeStarts,pDestDescriptorRangeSizes,NumSrcDescriptorRanges,pSrcDescriptorRangeStarts,pSrcDescriptorRangeSizes,DescriptorHeapsType) ) 
+
+#define ID3D12Device1_CopyDescriptorsSimple(This,NumDescriptors,DestDescriptorRangeStart,SrcDescriptorRangeStart,DescriptorHeapsType)	\
+    ( (This)->lpVtbl -> CopyDescriptorsSimple(This,NumDescriptors,DestDescriptorRangeStart,SrcDescriptorRangeStart,DescriptorHeapsType) ) 
+#if !defined(_WIN32)
+
+#define ID3D12Device1_GetResourceAllocationInfo(This,visibleMask,numResourceDescs,pResourceDescs)	\
+    ( (This)->lpVtbl -> GetResourceAllocationInfo(This,visibleMask,numResourceDescs,pResourceDescs) ) 
+#else
+#define ID3D12Device1_GetResourceAllocationInfo(This,RetVal,visibleMask,numResourceDescs,pResourceDescs)	\
+    ( (This)->lpVtbl -> GetResourceAllocationInfo(This,RetVal,visibleMask,numResourceDescs,pResourceDescs) ) 
+#endif
+#if !defined(_WIN32)
+
+#define ID3D12Device1_GetCustomHeapProperties(This,nodeMask,heapType)	\
+    ( (This)->lpVtbl -> GetCustomHeapProperties(This,nodeMask,heapType) ) 
+#else
+#define ID3D12Device1_GetCustomHeapProperties(This,RetVal,nodeMask,heapType)	\
+    ( (This)->lpVtbl -> GetCustomHeapProperties(This,RetVal,nodeMask,heapType) ) 
+#endif
+
+#define ID3D12Device1_CreateCommittedResource(This,pHeapProperties,HeapFlags,pDesc,InitialResourceState,pOptimizedClearValue,riidResource,ppvResource)	\
+    ( (This)->lpVtbl -> CreateCommittedResource(This,pHeapProperties,HeapFlags,pDesc,InitialResourceState,pOptimizedClearValue,riidResource,ppvResource) ) 
+
+#define ID3D12Device1_CreateHeap(This,pDesc,riid,ppvHeap)	\
+    ( (This)->lpVtbl -> CreateHeap(This,pDesc,riid,ppvHeap) ) 
+
+#define ID3D12Device1_CreatePlacedResource(This,pHeap,HeapOffset,pDesc,InitialState,pOptimizedClearValue,riid,ppvResource)	\
+    ( (This)->lpVtbl -> CreatePlacedResource(This,pHeap,HeapOffset,pDesc,InitialState,pOptimizedClearValue,riid,ppvResource) ) 
+
+#define ID3D12Device1_CreateReservedResource(This,pDesc,InitialState,pOptimizedClearValue,riid,ppvResource)	\
+    ( (This)->lpVtbl -> CreateReservedResource(This,pDesc,InitialState,pOptimizedClearValue,riid,ppvResource) ) 
+
+#define ID3D12Device1_CreateSharedHandle(This,pObject,pAttributes,Access,Name,pHandle)	\
+    ( (This)->lpVtbl -> CreateSharedHandle(This,pObject,pAttributes,Access,Name,pHandle) ) 
+
+#define ID3D12Device1_OpenSharedHandle(This,NTHandle,riid,ppvObj)	\
+    ( (This)->lpVtbl -> OpenSharedHandle(This,NTHandle,riid,ppvObj) ) 
+
+#define ID3D12Device1_OpenSharedHandleByName(This,Name,Access,pNTHandle)	\
+    ( (This)->lpVtbl -> OpenSharedHandleByName(This,Name,Access,pNTHandle) ) 
+
+#define ID3D12Device1_MakeResident(This,NumObjects,ppObjects)	\
+    ( (This)->lpVtbl -> MakeResident(This,NumObjects,ppObjects) ) 
+
+#define ID3D12Device1_Evict(This,NumObjects,ppObjects)	\
+    ( (This)->lpVtbl -> Evict(This,NumObjects,ppObjects) ) 
+
+#define ID3D12Device1_CreateFence(This,InitialValue,Flags,riid,ppFence)	\
+    ( (This)->lpVtbl -> CreateFence(This,InitialValue,Flags,riid,ppFence) ) 
+
+#define ID3D12Device1_GetDeviceRemovedReason(This)	\
+    ( (This)->lpVtbl -> GetDeviceRemovedReason(This) ) 
+
+#define ID3D12Device1_GetCopyableFootprints(This,pResourceDesc,FirstSubresource,NumSubresources,BaseOffset,pLayouts,pNumRows,pRowSizeInBytes,pTotalBytes)	\
+    ( (This)->lpVtbl -> GetCopyableFootprints(This,pResourceDesc,FirstSubresource,NumSubresources,BaseOffset,pLayouts,pNumRows,pRowSizeInBytes,pTotalBytes) ) 
+
+#define ID3D12Device1_CreateQueryHeap(This,pDesc,riid,ppvHeap)	\
+    ( (This)->lpVtbl -> CreateQueryHeap(This,pDesc,riid,ppvHeap) ) 
+
+#define ID3D12Device1_SetStablePowerState(This,Enable)	\
+    ( (This)->lpVtbl -> SetStablePowerState(This,Enable) ) 
+
+#define ID3D12Device1_CreateCommandSignature(This,pDesc,pRootSignature,riid,ppvCommandSignature)	\
+    ( (This)->lpVtbl -> CreateCommandSignature(This,pDesc,pRootSignature,riid,ppvCommandSignature) ) 
+
+#define ID3D12Device1_GetResourceTiling(This,pTiledResource,pNumTilesForEntireResource,pPackedMipDesc,pStandardTileShapeForNonPackedMips,pNumSubresourceTilings,FirstSubresourceTilingToGet,pSubresourceTilingsForNonPackedMips)	\
+    ( (This)->lpVtbl -> GetResourceTiling(This,pTiledResource,pNumTilesForEntireResource,pPackedMipDesc,pStandardTileShapeForNonPackedMips,pNumSubresourceTilings,FirstSubresourceTilingToGet,pSubresourceTilingsForNonPackedMips) ) 
+#if !defined(_WIN32)
+
+#define ID3D12Device1_GetAdapterLuid(This)	\
+    ( (This)->lpVtbl -> GetAdapterLuid(This) ) 
+#else
+#define ID3D12Device1_GetAdapterLuid(This,RetVal)	\
+    ( (This)->lpVtbl -> GetAdapterLuid(This,RetVal) ) 
+#endif
+
+
+#define ID3D12Device1_CreatePipelineLibrary(This,pLibraryBlob,BlobLength,riid,ppPipelineLibrary)	\
+    ( (This)->lpVtbl -> CreatePipelineLibrary(This,pLibraryBlob,BlobLength,riid,ppPipelineLibrary) ) 
+
+#define ID3D12Device1_SetEventOnMultipleFenceCompletion(This,ppFences,pFenceValues,NumFences,Flags,hEvent)	\
+    ( (This)->lpVtbl -> SetEventOnMultipleFenceCompletion(This,ppFences,pFenceValues,NumFences,Flags,hEvent) ) 
+
+#define ID3D12Device1_SetResidencyPriority(This,NumObjects,ppObjects,pPriorities)	\
+    ( (This)->lpVtbl -> SetResidencyPriority(This,NumObjects,ppObjects,pPriorities) ) 
+
+#endif /* COBJMACROS */
+
+
+#endif 	/* C style interface */
+
+
+
+
+#endif 	/* __ID3D12Device1_INTERFACE_DEFINED__ */
+
+
+#ifndef __ID3D12Device2_INTERFACE_DEFINED__
+#define __ID3D12Device2_INTERFACE_DEFINED__
+
+/* interface ID3D12Device2 */
+/* [unique][local][object][uuid] */ 
+
+
+EXTERN_C const IID IID_ID3D12Device2;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("30baa41e-b15b-475c-a0bb-1af5c5b64328")
+    ID3D12Device2 : public ID3D12Device1
+    {
+    public:
+        virtual HRESULT STDMETHODCALLTYPE CreatePipelineState( 
+            const D3D12_PIPELINE_STATE_STREAM_DESC *pDesc,
+            REFIID riid,
+            _COM_Outptr_  void **ppPipelineState) = 0;
+        
+    };
+    
+    
+#else 	/* C style interface */
+
+    typedef struct ID3D12Device2Vtbl
+    {
+        BEGIN_INTERFACE
+        
+        DECLSPEC_XFGVIRT(IUnknown, QueryInterface)
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            ID3D12Device2 * This,
+            REFIID riid,
+            _COM_Outptr_  void **ppvObject);
+        
+        DECLSPEC_XFGVIRT(IUnknown, AddRef)
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            ID3D12Device2 * This);
+        
+        DECLSPEC_XFGVIRT(IUnknown, Release)
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            ID3D12Device2 * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, GetPrivateData)
+        HRESULT ( STDMETHODCALLTYPE *GetPrivateData )( 
+            ID3D12Device2 * This,
+            _In_  REFGUID guid,
+            _Inout_  UINT *pDataSize,
+            _Out_writes_bytes_opt_( *pDataSize )  void *pData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, SetPrivateData)
+        HRESULT ( STDMETHODCALLTYPE *SetPrivateData )( 
+            ID3D12Device2 * This,
+            _In_  REFGUID guid,
+            _In_  UINT DataSize,
+            _In_reads_bytes_opt_( DataSize )  const void *pData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, SetPrivateDataInterface)
+        HRESULT ( STDMETHODCALLTYPE *SetPrivateDataInterface )( 
+            ID3D12Device2 * This,
+            _In_  REFGUID guid,
+            _In_opt_  const IUnknown *pData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, SetName)
+        HRESULT ( STDMETHODCALLTYPE *SetName )( 
+            ID3D12Device2 * This,
+            _In_z_  LPCWSTR Name);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, GetNodeCount)
+        UINT ( STDMETHODCALLTYPE *GetNodeCount )( 
+            ID3D12Device2 * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CreateCommandQueue)
+        HRESULT ( STDMETHODCALLTYPE *CreateCommandQueue )( 
+            ID3D12Device2 * This,
+            _In_  const D3D12_COMMAND_QUEUE_DESC *pDesc,
+            REFIID riid,
+            _COM_Outptr_  void **ppCommandQueue);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CreateCommandAllocator)
+        HRESULT ( STDMETHODCALLTYPE *CreateCommandAllocator )( 
+            ID3D12Device2 * This,
+            _In_  D3D12_COMMAND_LIST_TYPE type,
+            REFIID riid,
+            _COM_Outptr_  void **ppCommandAllocator);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CreateGraphicsPipelineState)
+        HRESULT ( STDMETHODCALLTYPE *CreateGraphicsPipelineState )( 
+            ID3D12Device2 * This,
+            _In_  const D3D12_GRAPHICS_PIPELINE_STATE_DESC *pDesc,
+            REFIID riid,
+            _COM_Outptr_  void **ppPipelineState);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CreateComputePipelineState)
+        HRESULT ( STDMETHODCALLTYPE *CreateComputePipelineState )( 
+            ID3D12Device2 * This,
+            _In_  const D3D12_COMPUTE_PIPELINE_STATE_DESC *pDesc,
+            REFIID riid,
+            _COM_Outptr_  void **ppPipelineState);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CreateCommandList)
+        HRESULT ( STDMETHODCALLTYPE *CreateCommandList )( 
+            ID3D12Device2 * This,
+            _In_  UINT nodeMask,
+            _In_  D3D12_COMMAND_LIST_TYPE type,
+            _In_  ID3D12CommandAllocator *pCommandAllocator,
+            _In_opt_  ID3D12PipelineState *pInitialState,
+            REFIID riid,
+            _COM_Outptr_  void **ppCommandList);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CheckFeatureSupport)
+        HRESULT ( STDMETHODCALLTYPE *CheckFeatureSupport )( 
+            ID3D12Device2 * This,
+            D3D12_FEATURE Feature,
+            _Inout_updates_bytes_(FeatureSupportDataSize)  void *pFeatureSupportData,
+            UINT FeatureSupportDataSize);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CreateDescriptorHeap)
+        HRESULT ( STDMETHODCALLTYPE *CreateDescriptorHeap )( 
+            ID3D12Device2 * This,
+            _In_  const D3D12_DESCRIPTOR_HEAP_DESC *pDescriptorHeapDesc,
+            REFIID riid,
+            _COM_Outptr_  void **ppvHeap);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, GetDescriptorHandleIncrementSize)
+        UINT ( STDMETHODCALLTYPE *GetDescriptorHandleIncrementSize )( 
+            ID3D12Device2 * This,
+            _In_  D3D12_DESCRIPTOR_HEAP_TYPE DescriptorHeapType);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CreateRootSignature)
+        HRESULT ( STDMETHODCALLTYPE *CreateRootSignature )( 
+            ID3D12Device2 * This,
+            _In_  UINT nodeMask,
+            _In_reads_(blobLengthInBytes)  const void *pBlobWithRootSignature,
+            _In_  SIZE_T blobLengthInBytes,
+            REFIID riid,
+            _COM_Outptr_  void **ppvRootSignature);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CreateConstantBufferView)
+        void ( STDMETHODCALLTYPE *CreateConstantBufferView )( 
+            ID3D12Device2 * This,
+            _In_opt_  const D3D12_CONSTANT_BUFFER_VIEW_DESC *pDesc,
+            _In_  D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CreateShaderResourceView)
+        void ( STDMETHODCALLTYPE *CreateShaderResourceView )( 
+            ID3D12Device2 * This,
+            _In_opt_  ID3D12Resource *pResource,
+            _In_opt_  const D3D12_SHADER_RESOURCE_VIEW_DESC *pDesc,
+            _In_  D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CreateUnorderedAccessView)
+        void ( STDMETHODCALLTYPE *CreateUnorderedAccessView )( 
+            ID3D12Device2 * This,
+            _In_opt_  ID3D12Resource *pResource,
+            _In_opt_  ID3D12Resource *pCounterResource,
+            _In_opt_  const D3D12_UNORDERED_ACCESS_VIEW_DESC *pDesc,
+            _In_  D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CreateRenderTargetView)
+        void ( STDMETHODCALLTYPE *CreateRenderTargetView )( 
+            ID3D12Device2 * This,
+            _In_opt_  ID3D12Resource *pResource,
+            _In_opt_  const D3D12_RENDER_TARGET_VIEW_DESC *pDesc,
+            _In_  D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CreateDepthStencilView)
+        void ( STDMETHODCALLTYPE *CreateDepthStencilView )( 
+            ID3D12Device2 * This,
+            _In_opt_  ID3D12Resource *pResource,
+            _In_opt_  const D3D12_DEPTH_STENCIL_VIEW_DESC *pDesc,
+            _In_  D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CreateSampler)
+        void ( STDMETHODCALLTYPE *CreateSampler )( 
+            ID3D12Device2 * This,
+            _In_  const D3D12_SAMPLER_DESC *pDesc,
+            _In_  D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CopyDescriptors)
+        void ( STDMETHODCALLTYPE *CopyDescriptors )( 
+            ID3D12Device2 * This,
+            _In_  UINT NumDestDescriptorRanges,
+            _In_reads_(NumDestDescriptorRanges)  const D3D12_CPU_DESCRIPTOR_HANDLE *pDestDescriptorRangeStarts,
+            _In_reads_opt_(NumDestDescriptorRanges)  const UINT *pDestDescriptorRangeSizes,
+            _In_  UINT NumSrcDescriptorRanges,
+            _In_reads_(NumSrcDescriptorRanges)  const D3D12_CPU_DESCRIPTOR_HANDLE *pSrcDescriptorRangeStarts,
+            _In_reads_opt_(NumSrcDescriptorRanges)  const UINT *pSrcDescriptorRangeSizes,
+            _In_  D3D12_DESCRIPTOR_HEAP_TYPE DescriptorHeapsType);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CopyDescriptorsSimple)
+        void ( STDMETHODCALLTYPE *CopyDescriptorsSimple )( 
+            ID3D12Device2 * This,
+            _In_  UINT NumDescriptors,
+            _In_  D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptorRangeStart,
+            _In_  D3D12_CPU_DESCRIPTOR_HANDLE SrcDescriptorRangeStart,
+            _In_  D3D12_DESCRIPTOR_HEAP_TYPE DescriptorHeapsType);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, GetResourceAllocationInfo)
+#if !defined(_WIN32)
+        D3D12_RESOURCE_ALLOCATION_INFO ( STDMETHODCALLTYPE *GetResourceAllocationInfo )( 
+            ID3D12Device2 * This,
+            _In_  UINT visibleMask,
+            _In_  UINT numResourceDescs,
+            _In_reads_(numResourceDescs)  const D3D12_RESOURCE_DESC *pResourceDescs);
+        
+#else
+        D3D12_RESOURCE_ALLOCATION_INFO *( STDMETHODCALLTYPE *GetResourceAllocationInfo )( 
+            ID3D12Device2 * This,
+            D3D12_RESOURCE_ALLOCATION_INFO * RetVal,
+            _In_  UINT visibleMask,
+            _In_  UINT numResourceDescs,
+            _In_reads_(numResourceDescs)  const D3D12_RESOURCE_DESC *pResourceDescs);
+        
+#endif
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, GetCustomHeapProperties)
+#if !defined(_WIN32)
+        D3D12_HEAP_PROPERTIES ( STDMETHODCALLTYPE *GetCustomHeapProperties )( 
+            ID3D12Device2 * This,
+            _In_  UINT nodeMask,
+            D3D12_HEAP_TYPE heapType);
+        
+#else
+        D3D12_HEAP_PROPERTIES *( STDMETHODCALLTYPE *GetCustomHeapProperties )( 
+            ID3D12Device2 * This,
+            D3D12_HEAP_PROPERTIES * RetVal,
+            _In_  UINT nodeMask,
+            D3D12_HEAP_TYPE heapType);
+        
+#endif
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CreateCommittedResource)
+        HRESULT ( STDMETHODCALLTYPE *CreateCommittedResource )( 
+            ID3D12Device2 * This,
+            _In_  const D3D12_HEAP_PROPERTIES *pHeapProperties,
+            D3D12_HEAP_FLAGS HeapFlags,
+            _In_  const D3D12_RESOURCE_DESC *pDesc,
+            D3D12_RESOURCE_STATES InitialResourceState,
+            _In_opt_  const D3D12_CLEAR_VALUE *pOptimizedClearValue,
+            REFIID riidResource,
+            _COM_Outptr_opt_  void **ppvResource);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CreateHeap)
+        HRESULT ( STDMETHODCALLTYPE *CreateHeap )( 
+            ID3D12Device2 * This,
+            _In_  const D3D12_HEAP_DESC *pDesc,
+            REFIID riid,
+            _COM_Outptr_opt_  void **ppvHeap);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CreatePlacedResource)
+        HRESULT ( STDMETHODCALLTYPE *CreatePlacedResource )( 
+            ID3D12Device2 * This,
+            _In_  ID3D12Heap *pHeap,
+            UINT64 HeapOffset,
+            _In_  const D3D12_RESOURCE_DESC *pDesc,
+            D3D12_RESOURCE_STATES InitialState,
+            _In_opt_  const D3D12_CLEAR_VALUE *pOptimizedClearValue,
+            REFIID riid,
+            _COM_Outptr_opt_  void **ppvResource);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CreateReservedResource)
+        HRESULT ( STDMETHODCALLTYPE *CreateReservedResource )( 
+            ID3D12Device2 * This,
+            _In_  const D3D12_RESOURCE_DESC *pDesc,
+            D3D12_RESOURCE_STATES InitialState,
+            _In_opt_  const D3D12_CLEAR_VALUE *pOptimizedClearValue,
+            REFIID riid,
+            _COM_Outptr_opt_  void **ppvResource);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CreateSharedHandle)
+        HRESULT ( STDMETHODCALLTYPE *CreateSharedHandle )( 
+            ID3D12Device2 * This,
+            _In_  ID3D12DeviceChild *pObject,
+            _In_opt_  const SECURITY_ATTRIBUTES *pAttributes,
+            DWORD Access,
+            _In_opt_  LPCWSTR Name,
+            _Out_  HANDLE *pHandle);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, OpenSharedHandle)
+        HRESULT ( STDMETHODCALLTYPE *OpenSharedHandle )( 
+            ID3D12Device2 * This,
+            _In_  HANDLE NTHandle,
+            REFIID riid,
+            _COM_Outptr_opt_  void **ppvObj);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, OpenSharedHandleByName)
+        HRESULT ( STDMETHODCALLTYPE *OpenSharedHandleByName )( 
+            ID3D12Device2 * This,
+            _In_  LPCWSTR Name,
+            DWORD Access,
+            /* [annotation][out] */ 
+            _Out_  HANDLE *pNTHandle);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, MakeResident)
+        HRESULT ( STDMETHODCALLTYPE *MakeResident )( 
+            ID3D12Device2 * This,
+            UINT NumObjects,
+            _In_reads_(NumObjects)  ID3D12Pageable *const *ppObjects);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, Evict)
+        HRESULT ( STDMETHODCALLTYPE *Evict )( 
+            ID3D12Device2 * This,
+            UINT NumObjects,
+            _In_reads_(NumObjects)  ID3D12Pageable *const *ppObjects);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CreateFence)
+        HRESULT ( STDMETHODCALLTYPE *CreateFence )( 
+            ID3D12Device2 * This,
+            UINT64 InitialValue,
+            D3D12_FENCE_FLAGS Flags,
+            REFIID riid,
+            _COM_Outptr_  void **ppFence);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, GetDeviceRemovedReason)
+        HRESULT ( STDMETHODCALLTYPE *GetDeviceRemovedReason )( 
+            ID3D12Device2 * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, GetCopyableFootprints)
+        void ( STDMETHODCALLTYPE *GetCopyableFootprints )( 
+            ID3D12Device2 * This,
+            _In_  const D3D12_RESOURCE_DESC *pResourceDesc,
+            _In_range_(0,D3D12_REQ_SUBRESOURCES)  UINT FirstSubresource,
+            _In_range_(0,D3D12_REQ_SUBRESOURCES-FirstSubresource)  UINT NumSubresources,
+            UINT64 BaseOffset,
+            _Out_writes_opt_(NumSubresources)  D3D12_PLACED_SUBRESOURCE_FOOTPRINT *pLayouts,
+            _Out_writes_opt_(NumSubresources)  UINT *pNumRows,
+            _Out_writes_opt_(NumSubresources)  UINT64 *pRowSizeInBytes,
+            _Out_opt_  UINT64 *pTotalBytes);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CreateQueryHeap)
+        HRESULT ( STDMETHODCALLTYPE *CreateQueryHeap )( 
+            ID3D12Device2 * This,
+            _In_  const D3D12_QUERY_HEAP_DESC *pDesc,
+            REFIID riid,
+            _COM_Outptr_opt_  void **ppvHeap);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, SetStablePowerState)
+        HRESULT ( STDMETHODCALLTYPE *SetStablePowerState )( 
+            ID3D12Device2 * This,
+            BOOL Enable);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CreateCommandSignature)
+        HRESULT ( STDMETHODCALLTYPE *CreateCommandSignature )( 
+            ID3D12Device2 * This,
+            _In_  const D3D12_COMMAND_SIGNATURE_DESC *pDesc,
+            _In_opt_  ID3D12RootSignature *pRootSignature,
+            REFIID riid,
+            _COM_Outptr_opt_  void **ppvCommandSignature);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, GetResourceTiling)
+        void ( STDMETHODCALLTYPE *GetResourceTiling )( 
+            ID3D12Device2 * This,
+            _In_  ID3D12Resource *pTiledResource,
+            _Out_opt_  UINT *pNumTilesForEntireResource,
+            _Out_opt_  D3D12_PACKED_MIP_INFO *pPackedMipDesc,
+            _Out_opt_  D3D12_TILE_SHAPE *pStandardTileShapeForNonPackedMips,
+            _Inout_opt_  UINT *pNumSubresourceTilings,
+            _In_  UINT FirstSubresourceTilingToGet,
+            _Out_writes_(*pNumSubresourceTilings)  D3D12_SUBRESOURCE_TILING *pSubresourceTilingsForNonPackedMips);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, GetAdapterLuid)
+#if !defined(_WIN32)
+        LUID ( STDMETHODCALLTYPE *GetAdapterLuid )( 
+            ID3D12Device2 * This);
+        
+#else
+        LUID *( STDMETHODCALLTYPE *GetAdapterLuid )( 
+            ID3D12Device2 * This,
+            LUID * RetVal);
+        
+#endif
+        
+        DECLSPEC_XFGVIRT(ID3D12Device1, CreatePipelineLibrary)
+        HRESULT ( STDMETHODCALLTYPE *CreatePipelineLibrary )( 
+            ID3D12Device2 * This,
+            _In_reads_(BlobLength)  const void *pLibraryBlob,
+            SIZE_T BlobLength,
+            REFIID riid,
+            _COM_Outptr_  void **ppPipelineLibrary);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device1, SetEventOnMultipleFenceCompletion)
+        HRESULT ( STDMETHODCALLTYPE *SetEventOnMultipleFenceCompletion )( 
+            ID3D12Device2 * This,
+            _In_reads_(NumFences)  ID3D12Fence *const *ppFences,
+            _In_reads_(NumFences)  const UINT64 *pFenceValues,
+            UINT NumFences,
+            D3D12_MULTIPLE_FENCE_WAIT_FLAGS Flags,
+            HANDLE hEvent);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device1, SetResidencyPriority)
+        HRESULT ( STDMETHODCALLTYPE *SetResidencyPriority )( 
+            ID3D12Device2 * This,
+            UINT NumObjects,
+            _In_reads_(NumObjects)  ID3D12Pageable *const *ppObjects,
+            _In_reads_(NumObjects)  const D3D12_RESIDENCY_PRIORITY *pPriorities);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device2, CreatePipelineState)
+        HRESULT ( STDMETHODCALLTYPE *CreatePipelineState )( 
+            ID3D12Device2 * This,
+            const D3D12_PIPELINE_STATE_STREAM_DESC *pDesc,
+            REFIID riid,
+            _COM_Outptr_  void **ppPipelineState);
+        
+        END_INTERFACE
+    } ID3D12Device2Vtbl;
+
+    interface ID3D12Device2
+    {
+        CONST_VTBL struct ID3D12Device2Vtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define ID3D12Device2_QueryInterface(This,riid,ppvObject)	\
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define ID3D12Device2_AddRef(This)	\
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define ID3D12Device2_Release(This)	\
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#define ID3D12Device2_GetPrivateData(This,guid,pDataSize,pData)	\
+    ( (This)->lpVtbl -> GetPrivateData(This,guid,pDataSize,pData) ) 
+
+#define ID3D12Device2_SetPrivateData(This,guid,DataSize,pData)	\
+    ( (This)->lpVtbl -> SetPrivateData(This,guid,DataSize,pData) ) 
+
+#define ID3D12Device2_SetPrivateDataInterface(This,guid,pData)	\
+    ( (This)->lpVtbl -> SetPrivateDataInterface(This,guid,pData) ) 
+
+#define ID3D12Device2_SetName(This,Name)	\
+    ( (This)->lpVtbl -> SetName(This,Name) ) 
+
+
+#define ID3D12Device2_GetNodeCount(This)	\
+    ( (This)->lpVtbl -> GetNodeCount(This) ) 
+
+#define ID3D12Device2_CreateCommandQueue(This,pDesc,riid,ppCommandQueue)	\
+    ( (This)->lpVtbl -> CreateCommandQueue(This,pDesc,riid,ppCommandQueue) ) 
+
+#define ID3D12Device2_CreateCommandAllocator(This,type,riid,ppCommandAllocator)	\
+    ( (This)->lpVtbl -> CreateCommandAllocator(This,type,riid,ppCommandAllocator) ) 
+
+#define ID3D12Device2_CreateGraphicsPipelineState(This,pDesc,riid,ppPipelineState)	\
+    ( (This)->lpVtbl -> CreateGraphicsPipelineState(This,pDesc,riid,ppPipelineState) ) 
+
+#define ID3D12Device2_CreateComputePipelineState(This,pDesc,riid,ppPipelineState)	\
+    ( (This)->lpVtbl -> CreateComputePipelineState(This,pDesc,riid,ppPipelineState) ) 
+
+#define ID3D12Device2_CreateCommandList(This,nodeMask,type,pCommandAllocator,pInitialState,riid,ppCommandList)	\
+    ( (This)->lpVtbl -> CreateCommandList(This,nodeMask,type,pCommandAllocator,pInitialState,riid,ppCommandList) ) 
+
+#define ID3D12Device2_CheckFeatureSupport(This,Feature,pFeatureSupportData,FeatureSupportDataSize)	\
+    ( (This)->lpVtbl -> CheckFeatureSupport(This,Feature,pFeatureSupportData,FeatureSupportDataSize) ) 
+
+#define ID3D12Device2_CreateDescriptorHeap(This,pDescriptorHeapDesc,riid,ppvHeap)	\
+    ( (This)->lpVtbl -> CreateDescriptorHeap(This,pDescriptorHeapDesc,riid,ppvHeap) ) 
+
+#define ID3D12Device2_GetDescriptorHandleIncrementSize(This,DescriptorHeapType)	\
+    ( (This)->lpVtbl -> GetDescriptorHandleIncrementSize(This,DescriptorHeapType) ) 
+
+#define ID3D12Device2_CreateRootSignature(This,nodeMask,pBlobWithRootSignature,blobLengthInBytes,riid,ppvRootSignature)	\
+    ( (This)->lpVtbl -> CreateRootSignature(This,nodeMask,pBlobWithRootSignature,blobLengthInBytes,riid,ppvRootSignature) ) 
+
+#define ID3D12Device2_CreateConstantBufferView(This,pDesc,DestDescriptor)	\
+    ( (This)->lpVtbl -> CreateConstantBufferView(This,pDesc,DestDescriptor) ) 
+
+#define ID3D12Device2_CreateShaderResourceView(This,pResource,pDesc,DestDescriptor)	\
+    ( (This)->lpVtbl -> CreateShaderResourceView(This,pResource,pDesc,DestDescriptor) ) 
+
+#define ID3D12Device2_CreateUnorderedAccessView(This,pResource,pCounterResource,pDesc,DestDescriptor)	\
+    ( (This)->lpVtbl -> CreateUnorderedAccessView(This,pResource,pCounterResource,pDesc,DestDescriptor) ) 
+
+#define ID3D12Device2_CreateRenderTargetView(This,pResource,pDesc,DestDescriptor)	\
+    ( (This)->lpVtbl -> CreateRenderTargetView(This,pResource,pDesc,DestDescriptor) ) 
+
+#define ID3D12Device2_CreateDepthStencilView(This,pResource,pDesc,DestDescriptor)	\
+    ( (This)->lpVtbl -> CreateDepthStencilView(This,pResource,pDesc,DestDescriptor) ) 
+
+#define ID3D12Device2_CreateSampler(This,pDesc,DestDescriptor)	\
+    ( (This)->lpVtbl -> CreateSampler(This,pDesc,DestDescriptor) ) 
+
+#define ID3D12Device2_CopyDescriptors(This,NumDestDescriptorRanges,pDestDescriptorRangeStarts,pDestDescriptorRangeSizes,NumSrcDescriptorRanges,pSrcDescriptorRangeStarts,pSrcDescriptorRangeSizes,DescriptorHeapsType)	\
+    ( (This)->lpVtbl -> CopyDescriptors(This,NumDestDescriptorRanges,pDestDescriptorRangeStarts,pDestDescriptorRangeSizes,NumSrcDescriptorRanges,pSrcDescriptorRangeStarts,pSrcDescriptorRangeSizes,DescriptorHeapsType) ) 
+
+#define ID3D12Device2_CopyDescriptorsSimple(This,NumDescriptors,DestDescriptorRangeStart,SrcDescriptorRangeStart,DescriptorHeapsType)	\
+    ( (This)->lpVtbl -> CopyDescriptorsSimple(This,NumDescriptors,DestDescriptorRangeStart,SrcDescriptorRangeStart,DescriptorHeapsType) ) 
+#if !defined(_WIN32)
+
+#define ID3D12Device2_GetResourceAllocationInfo(This,visibleMask,numResourceDescs,pResourceDescs)	\
+    ( (This)->lpVtbl -> GetResourceAllocationInfo(This,visibleMask,numResourceDescs,pResourceDescs) ) 
+#else
+#define ID3D12Device2_GetResourceAllocationInfo(This,RetVal,visibleMask,numResourceDescs,pResourceDescs)	\
+    ( (This)->lpVtbl -> GetResourceAllocationInfo(This,RetVal,visibleMask,numResourceDescs,pResourceDescs) ) 
+#endif
+#if !defined(_WIN32)
+
+#define ID3D12Device2_GetCustomHeapProperties(This,nodeMask,heapType)	\
+    ( (This)->lpVtbl -> GetCustomHeapProperties(This,nodeMask,heapType) ) 
+#else
+#define ID3D12Device2_GetCustomHeapProperties(This,RetVal,nodeMask,heapType)	\
+    ( (This)->lpVtbl -> GetCustomHeapProperties(This,RetVal,nodeMask,heapType) ) 
+#endif
+
+#define ID3D12Device2_CreateCommittedResource(This,pHeapProperties,HeapFlags,pDesc,InitialResourceState,pOptimizedClearValue,riidResource,ppvResource)	\
+    ( (This)->lpVtbl -> CreateCommittedResource(This,pHeapProperties,HeapFlags,pDesc,InitialResourceState,pOptimizedClearValue,riidResource,ppvResource) ) 
+
+#define ID3D12Device2_CreateHeap(This,pDesc,riid,ppvHeap)	\
+    ( (This)->lpVtbl -> CreateHeap(This,pDesc,riid,ppvHeap) ) 
+
+#define ID3D12Device2_CreatePlacedResource(This,pHeap,HeapOffset,pDesc,InitialState,pOptimizedClearValue,riid,ppvResource)	\
+    ( (This)->lpVtbl -> CreatePlacedResource(This,pHeap,HeapOffset,pDesc,InitialState,pOptimizedClearValue,riid,ppvResource) ) 
+
+#define ID3D12Device2_CreateReservedResource(This,pDesc,InitialState,pOptimizedClearValue,riid,ppvResource)	\
+    ( (This)->lpVtbl -> CreateReservedResource(This,pDesc,InitialState,pOptimizedClearValue,riid,ppvResource) ) 
+
+#define ID3D12Device2_CreateSharedHandle(This,pObject,pAttributes,Access,Name,pHandle)	\
+    ( (This)->lpVtbl -> CreateSharedHandle(This,pObject,pAttributes,Access,Name,pHandle) ) 
+
+#define ID3D12Device2_OpenSharedHandle(This,NTHandle,riid,ppvObj)	\
+    ( (This)->lpVtbl -> OpenSharedHandle(This,NTHandle,riid,ppvObj) ) 
+
+#define ID3D12Device2_OpenSharedHandleByName(This,Name,Access,pNTHandle)	\
+    ( (This)->lpVtbl -> OpenSharedHandleByName(This,Name,Access,pNTHandle) ) 
+
+#define ID3D12Device2_MakeResident(This,NumObjects,ppObjects)	\
+    ( (This)->lpVtbl -> MakeResident(This,NumObjects,ppObjects) ) 
+
+#define ID3D12Device2_Evict(This,NumObjects,ppObjects)	\
+    ( (This)->lpVtbl -> Evict(This,NumObjects,ppObjects) ) 
+
+#define ID3D12Device2_CreateFence(This,InitialValue,Flags,riid,ppFence)	\
+    ( (This)->lpVtbl -> CreateFence(This,InitialValue,Flags,riid,ppFence) ) 
+
+#define ID3D12Device2_GetDeviceRemovedReason(This)	\
+    ( (This)->lpVtbl -> GetDeviceRemovedReason(This) ) 
+
+#define ID3D12Device2_GetCopyableFootprints(This,pResourceDesc,FirstSubresource,NumSubresources,BaseOffset,pLayouts,pNumRows,pRowSizeInBytes,pTotalBytes)	\
+    ( (This)->lpVtbl -> GetCopyableFootprints(This,pResourceDesc,FirstSubresource,NumSubresources,BaseOffset,pLayouts,pNumRows,pRowSizeInBytes,pTotalBytes) ) 
+
+#define ID3D12Device2_CreateQueryHeap(This,pDesc,riid,ppvHeap)	\
+    ( (This)->lpVtbl -> CreateQueryHeap(This,pDesc,riid,ppvHeap) ) 
+
+#define ID3D12Device2_SetStablePowerState(This,Enable)	\
+    ( (This)->lpVtbl -> SetStablePowerState(This,Enable) ) 
+
+#define ID3D12Device2_CreateCommandSignature(This,pDesc,pRootSignature,riid,ppvCommandSignature)	\
+    ( (This)->lpVtbl -> CreateCommandSignature(This,pDesc,pRootSignature,riid,ppvCommandSignature) ) 
+
+#define ID3D12Device2_GetResourceTiling(This,pTiledResource,pNumTilesForEntireResource,pPackedMipDesc,pStandardTileShapeForNonPackedMips,pNumSubresourceTilings,FirstSubresourceTilingToGet,pSubresourceTilingsForNonPackedMips)	\
+    ( (This)->lpVtbl -> GetResourceTiling(This,pTiledResource,pNumTilesForEntireResource,pPackedMipDesc,pStandardTileShapeForNonPackedMips,pNumSubresourceTilings,FirstSubresourceTilingToGet,pSubresourceTilingsForNonPackedMips) ) 
+#if !defined(_WIN32)
+
+#define ID3D12Device2_GetAdapterLuid(This)	\
+    ( (This)->lpVtbl -> GetAdapterLuid(This) ) 
+#else
+#define ID3D12Device2_GetAdapterLuid(This,RetVal)	\
+    ( (This)->lpVtbl -> GetAdapterLuid(This,RetVal) ) 
+#endif
+
+
+#define ID3D12Device2_CreatePipelineLibrary(This,pLibraryBlob,BlobLength,riid,ppPipelineLibrary)	\
+    ( (This)->lpVtbl -> CreatePipelineLibrary(This,pLibraryBlob,BlobLength,riid,ppPipelineLibrary) ) 
+
+#define ID3D12Device2_SetEventOnMultipleFenceCompletion(This,ppFences,pFenceValues,NumFences,Flags,hEvent)	\
+    ( (This)->lpVtbl -> SetEventOnMultipleFenceCompletion(This,ppFences,pFenceValues,NumFences,Flags,hEvent) ) 
+
+#define ID3D12Device2_SetResidencyPriority(This,NumObjects,ppObjects,pPriorities)	\
+    ( (This)->lpVtbl -> SetResidencyPriority(This,NumObjects,ppObjects,pPriorities) ) 
+
+
+#define ID3D12Device2_CreatePipelineState(This,pDesc,riid,ppPipelineState)	\
+    ( (This)->lpVtbl -> CreatePipelineState(This,pDesc,riid,ppPipelineState) ) 
+
+#endif /* COBJMACROS */
+
+
+#endif 	/* C style interface */
+
+
+
+
+#endif 	/* __ID3D12Device2_INTERFACE_DEFINED__ */
+
+
+/* interface __MIDL_itf_d3d12_0000_0025 */
+/* [local] */ 
+
+typedef 
+enum D3D12_RESIDENCY_FLAGS
+    {
+        D3D12_RESIDENCY_FLAG_NONE	= 0,
+        D3D12_RESIDENCY_FLAG_DENY_OVERBUDGET	= 0x1
+    } 	D3D12_RESIDENCY_FLAGS;
+
+DEFINE_ENUM_FLAG_OPERATORS( D3D12_RESIDENCY_FLAGS );
+
+
+extern RPC_IF_HANDLE __MIDL_itf_d3d12_0000_0025_v0_0_c_ifspec;
+extern RPC_IF_HANDLE __MIDL_itf_d3d12_0000_0025_v0_0_s_ifspec;
+
+#ifndef __ID3D12Device3_INTERFACE_DEFINED__
+#define __ID3D12Device3_INTERFACE_DEFINED__
+
+/* interface ID3D12Device3 */
+/* [unique][local][object][uuid] */ 
+
+
+EXTERN_C const IID IID_ID3D12Device3;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("81dadc15-2bad-4392-93c5-101345c4aa98")
+    ID3D12Device3 : public ID3D12Device2
+    {
+    public:
+        virtual HRESULT STDMETHODCALLTYPE OpenExistingHeapFromAddress( 
+            _In_  const void *pAddress,
+            REFIID riid,
+            _COM_Outptr_  void **ppvHeap) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE OpenExistingHeapFromFileMapping( 
+            _In_  HANDLE hFileMapping,
+            REFIID riid,
+            _COM_Outptr_  void **ppvHeap) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE EnqueueMakeResident( 
+            D3D12_RESIDENCY_FLAGS Flags,
+            UINT NumObjects,
+            _In_reads_(NumObjects)  ID3D12Pageable *const *ppObjects,
+            _In_  ID3D12Fence *pFenceToSignal,
+            UINT64 FenceValueToSignal) = 0;
+        
+    };
+    
+    
+#else 	/* C style interface */
+
+    typedef struct ID3D12Device3Vtbl
+    {
+        BEGIN_INTERFACE
+        
+        DECLSPEC_XFGVIRT(IUnknown, QueryInterface)
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            ID3D12Device3 * This,
+            REFIID riid,
+            _COM_Outptr_  void **ppvObject);
+        
+        DECLSPEC_XFGVIRT(IUnknown, AddRef)
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            ID3D12Device3 * This);
+        
+        DECLSPEC_XFGVIRT(IUnknown, Release)
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            ID3D12Device3 * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, GetPrivateData)
+        HRESULT ( STDMETHODCALLTYPE *GetPrivateData )( 
+            ID3D12Device3 * This,
+            _In_  REFGUID guid,
+            _Inout_  UINT *pDataSize,
+            _Out_writes_bytes_opt_( *pDataSize )  void *pData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, SetPrivateData)
+        HRESULT ( STDMETHODCALLTYPE *SetPrivateData )( 
+            ID3D12Device3 * This,
+            _In_  REFGUID guid,
+            _In_  UINT DataSize,
+            _In_reads_bytes_opt_( DataSize )  const void *pData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, SetPrivateDataInterface)
+        HRESULT ( STDMETHODCALLTYPE *SetPrivateDataInterface )( 
+            ID3D12Device3 * This,
+            _In_  REFGUID guid,
+            _In_opt_  const IUnknown *pData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, SetName)
+        HRESULT ( STDMETHODCALLTYPE *SetName )( 
+            ID3D12Device3 * This,
+            _In_z_  LPCWSTR Name);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, GetNodeCount)
+        UINT ( STDMETHODCALLTYPE *GetNodeCount )( 
+            ID3D12Device3 * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CreateCommandQueue)
+        HRESULT ( STDMETHODCALLTYPE *CreateCommandQueue )( 
+            ID3D12Device3 * This,
+            _In_  const D3D12_COMMAND_QUEUE_DESC *pDesc,
+            REFIID riid,
+            _COM_Outptr_  void **ppCommandQueue);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CreateCommandAllocator)
+        HRESULT ( STDMETHODCALLTYPE *CreateCommandAllocator )( 
+            ID3D12Device3 * This,
+            _In_  D3D12_COMMAND_LIST_TYPE type,
+            REFIID riid,
+            _COM_Outptr_  void **ppCommandAllocator);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CreateGraphicsPipelineState)
+        HRESULT ( STDMETHODCALLTYPE *CreateGraphicsPipelineState )( 
+            ID3D12Device3 * This,
+            _In_  const D3D12_GRAPHICS_PIPELINE_STATE_DESC *pDesc,
+            REFIID riid,
+            _COM_Outptr_  void **ppPipelineState);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CreateComputePipelineState)
+        HRESULT ( STDMETHODCALLTYPE *CreateComputePipelineState )( 
+            ID3D12Device3 * This,
+            _In_  const D3D12_COMPUTE_PIPELINE_STATE_DESC *pDesc,
+            REFIID riid,
+            _COM_Outptr_  void **ppPipelineState);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CreateCommandList)
+        HRESULT ( STDMETHODCALLTYPE *CreateCommandList )( 
+            ID3D12Device3 * This,
+            _In_  UINT nodeMask,
+            _In_  D3D12_COMMAND_LIST_TYPE type,
+            _In_  ID3D12CommandAllocator *pCommandAllocator,
+            _In_opt_  ID3D12PipelineState *pInitialState,
+            REFIID riid,
+            _COM_Outptr_  void **ppCommandList);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CheckFeatureSupport)
+        HRESULT ( STDMETHODCALLTYPE *CheckFeatureSupport )( 
+            ID3D12Device3 * This,
+            D3D12_FEATURE Feature,
+            _Inout_updates_bytes_(FeatureSupportDataSize)  void *pFeatureSupportData,
+            UINT FeatureSupportDataSize);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CreateDescriptorHeap)
+        HRESULT ( STDMETHODCALLTYPE *CreateDescriptorHeap )( 
+            ID3D12Device3 * This,
+            _In_  const D3D12_DESCRIPTOR_HEAP_DESC *pDescriptorHeapDesc,
+            REFIID riid,
+            _COM_Outptr_  void **ppvHeap);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, GetDescriptorHandleIncrementSize)
+        UINT ( STDMETHODCALLTYPE *GetDescriptorHandleIncrementSize )( 
+            ID3D12Device3 * This,
+            _In_  D3D12_DESCRIPTOR_HEAP_TYPE DescriptorHeapType);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CreateRootSignature)
+        HRESULT ( STDMETHODCALLTYPE *CreateRootSignature )( 
+            ID3D12Device3 * This,
+            _In_  UINT nodeMask,
+            _In_reads_(blobLengthInBytes)  const void *pBlobWithRootSignature,
+            _In_  SIZE_T blobLengthInBytes,
+            REFIID riid,
+            _COM_Outptr_  void **ppvRootSignature);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CreateConstantBufferView)
+        void ( STDMETHODCALLTYPE *CreateConstantBufferView )( 
+            ID3D12Device3 * This,
+            _In_opt_  const D3D12_CONSTANT_BUFFER_VIEW_DESC *pDesc,
+            _In_  D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CreateShaderResourceView)
+        void ( STDMETHODCALLTYPE *CreateShaderResourceView )( 
+            ID3D12Device3 * This,
+            _In_opt_  ID3D12Resource *pResource,
+            _In_opt_  const D3D12_SHADER_RESOURCE_VIEW_DESC *pDesc,
+            _In_  D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CreateUnorderedAccessView)
+        void ( STDMETHODCALLTYPE *CreateUnorderedAccessView )( 
+            ID3D12Device3 * This,
+            _In_opt_  ID3D12Resource *pResource,
+            _In_opt_  ID3D12Resource *pCounterResource,
+            _In_opt_  const D3D12_UNORDERED_ACCESS_VIEW_DESC *pDesc,
+            _In_  D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CreateRenderTargetView)
+        void ( STDMETHODCALLTYPE *CreateRenderTargetView )( 
+            ID3D12Device3 * This,
+            _In_opt_  ID3D12Resource *pResource,
+            _In_opt_  const D3D12_RENDER_TARGET_VIEW_DESC *pDesc,
+            _In_  D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CreateDepthStencilView)
+        void ( STDMETHODCALLTYPE *CreateDepthStencilView )( 
+            ID3D12Device3 * This,
+            _In_opt_  ID3D12Resource *pResource,
+            _In_opt_  const D3D12_DEPTH_STENCIL_VIEW_DESC *pDesc,
+            _In_  D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CreateSampler)
+        void ( STDMETHODCALLTYPE *CreateSampler )( 
+            ID3D12Device3 * This,
+            _In_  const D3D12_SAMPLER_DESC *pDesc,
+            _In_  D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CopyDescriptors)
+        void ( STDMETHODCALLTYPE *CopyDescriptors )( 
+            ID3D12Device3 * This,
+            _In_  UINT NumDestDescriptorRanges,
+            _In_reads_(NumDestDescriptorRanges)  const D3D12_CPU_DESCRIPTOR_HANDLE *pDestDescriptorRangeStarts,
+            _In_reads_opt_(NumDestDescriptorRanges)  const UINT *pDestDescriptorRangeSizes,
+            _In_  UINT NumSrcDescriptorRanges,
+            _In_reads_(NumSrcDescriptorRanges)  const D3D12_CPU_DESCRIPTOR_HANDLE *pSrcDescriptorRangeStarts,
+            _In_reads_opt_(NumSrcDescriptorRanges)  const UINT *pSrcDescriptorRangeSizes,
+            _In_  D3D12_DESCRIPTOR_HEAP_TYPE DescriptorHeapsType);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CopyDescriptorsSimple)
+        void ( STDMETHODCALLTYPE *CopyDescriptorsSimple )( 
+            ID3D12Device3 * This,
+            _In_  UINT NumDescriptors,
+            _In_  D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptorRangeStart,
+            _In_  D3D12_CPU_DESCRIPTOR_HANDLE SrcDescriptorRangeStart,
+            _In_  D3D12_DESCRIPTOR_HEAP_TYPE DescriptorHeapsType);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, GetResourceAllocationInfo)
+#if !defined(_WIN32)
+        D3D12_RESOURCE_ALLOCATION_INFO ( STDMETHODCALLTYPE *GetResourceAllocationInfo )( 
+            ID3D12Device3 * This,
+            _In_  UINT visibleMask,
+            _In_  UINT numResourceDescs,
+            _In_reads_(numResourceDescs)  const D3D12_RESOURCE_DESC *pResourceDescs);
+        
+#else
+        D3D12_RESOURCE_ALLOCATION_INFO *( STDMETHODCALLTYPE *GetResourceAllocationInfo )( 
+            ID3D12Device3 * This,
+            D3D12_RESOURCE_ALLOCATION_INFO * RetVal,
+            _In_  UINT visibleMask,
+            _In_  UINT numResourceDescs,
+            _In_reads_(numResourceDescs)  const D3D12_RESOURCE_DESC *pResourceDescs);
+        
+#endif
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, GetCustomHeapProperties)
+#if !defined(_WIN32)
+        D3D12_HEAP_PROPERTIES ( STDMETHODCALLTYPE *GetCustomHeapProperties )( 
+            ID3D12Device3 * This,
+            _In_  UINT nodeMask,
+            D3D12_HEAP_TYPE heapType);
+        
+#else
+        D3D12_HEAP_PROPERTIES *( STDMETHODCALLTYPE *GetCustomHeapProperties )( 
+            ID3D12Device3 * This,
+            D3D12_HEAP_PROPERTIES * RetVal,
+            _In_  UINT nodeMask,
+            D3D12_HEAP_TYPE heapType);
+        
+#endif
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CreateCommittedResource)
+        HRESULT ( STDMETHODCALLTYPE *CreateCommittedResource )( 
+            ID3D12Device3 * This,
+            _In_  const D3D12_HEAP_PROPERTIES *pHeapProperties,
+            D3D12_HEAP_FLAGS HeapFlags,
+            _In_  const D3D12_RESOURCE_DESC *pDesc,
+            D3D12_RESOURCE_STATES InitialResourceState,
+            _In_opt_  const D3D12_CLEAR_VALUE *pOptimizedClearValue,
+            REFIID riidResource,
+            _COM_Outptr_opt_  void **ppvResource);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CreateHeap)
+        HRESULT ( STDMETHODCALLTYPE *CreateHeap )( 
+            ID3D12Device3 * This,
+            _In_  const D3D12_HEAP_DESC *pDesc,
+            REFIID riid,
+            _COM_Outptr_opt_  void **ppvHeap);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CreatePlacedResource)
+        HRESULT ( STDMETHODCALLTYPE *CreatePlacedResource )( 
+            ID3D12Device3 * This,
+            _In_  ID3D12Heap *pHeap,
+            UINT64 HeapOffset,
+            _In_  const D3D12_RESOURCE_DESC *pDesc,
+            D3D12_RESOURCE_STATES InitialState,
+            _In_opt_  const D3D12_CLEAR_VALUE *pOptimizedClearValue,
+            REFIID riid,
+            _COM_Outptr_opt_  void **ppvResource);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CreateReservedResource)
+        HRESULT ( STDMETHODCALLTYPE *CreateReservedResource )( 
+            ID3D12Device3 * This,
+            _In_  const D3D12_RESOURCE_DESC *pDesc,
+            D3D12_RESOURCE_STATES InitialState,
+            _In_opt_  const D3D12_CLEAR_VALUE *pOptimizedClearValue,
+            REFIID riid,
+            _COM_Outptr_opt_  void **ppvResource);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CreateSharedHandle)
+        HRESULT ( STDMETHODCALLTYPE *CreateSharedHandle )( 
+            ID3D12Device3 * This,
+            _In_  ID3D12DeviceChild *pObject,
+            _In_opt_  const SECURITY_ATTRIBUTES *pAttributes,
+            DWORD Access,
+            _In_opt_  LPCWSTR Name,
+            _Out_  HANDLE *pHandle);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, OpenSharedHandle)
+        HRESULT ( STDMETHODCALLTYPE *OpenSharedHandle )( 
+            ID3D12Device3 * This,
+            _In_  HANDLE NTHandle,
+            REFIID riid,
+            _COM_Outptr_opt_  void **ppvObj);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, OpenSharedHandleByName)
+        HRESULT ( STDMETHODCALLTYPE *OpenSharedHandleByName )( 
+            ID3D12Device3 * This,
+            _In_  LPCWSTR Name,
+            DWORD Access,
+            /* [annotation][out] */ 
+            _Out_  HANDLE *pNTHandle);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, MakeResident)
+        HRESULT ( STDMETHODCALLTYPE *MakeResident )( 
+            ID3D12Device3 * This,
+            UINT NumObjects,
+            _In_reads_(NumObjects)  ID3D12Pageable *const *ppObjects);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, Evict)
+        HRESULT ( STDMETHODCALLTYPE *Evict )( 
+            ID3D12Device3 * This,
+            UINT NumObjects,
+            _In_reads_(NumObjects)  ID3D12Pageable *const *ppObjects);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CreateFence)
+        HRESULT ( STDMETHODCALLTYPE *CreateFence )( 
+            ID3D12Device3 * This,
+            UINT64 InitialValue,
+            D3D12_FENCE_FLAGS Flags,
+            REFIID riid,
+            _COM_Outptr_  void **ppFence);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, GetDeviceRemovedReason)
+        HRESULT ( STDMETHODCALLTYPE *GetDeviceRemovedReason )( 
+            ID3D12Device3 * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, GetCopyableFootprints)
+        void ( STDMETHODCALLTYPE *GetCopyableFootprints )( 
+            ID3D12Device3 * This,
+            _In_  const D3D12_RESOURCE_DESC *pResourceDesc,
+            _In_range_(0,D3D12_REQ_SUBRESOURCES)  UINT FirstSubresource,
+            _In_range_(0,D3D12_REQ_SUBRESOURCES-FirstSubresource)  UINT NumSubresources,
+            UINT64 BaseOffset,
+            _Out_writes_opt_(NumSubresources)  D3D12_PLACED_SUBRESOURCE_FOOTPRINT *pLayouts,
+            _Out_writes_opt_(NumSubresources)  UINT *pNumRows,
+            _Out_writes_opt_(NumSubresources)  UINT64 *pRowSizeInBytes,
+            _Out_opt_  UINT64 *pTotalBytes);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CreateQueryHeap)
+        HRESULT ( STDMETHODCALLTYPE *CreateQueryHeap )( 
+            ID3D12Device3 * This,
+            _In_  const D3D12_QUERY_HEAP_DESC *pDesc,
+            REFIID riid,
+            _COM_Outptr_opt_  void **ppvHeap);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, SetStablePowerState)
+        HRESULT ( STDMETHODCALLTYPE *SetStablePowerState )( 
+            ID3D12Device3 * This,
+            BOOL Enable);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CreateCommandSignature)
+        HRESULT ( STDMETHODCALLTYPE *CreateCommandSignature )( 
+            ID3D12Device3 * This,
+            _In_  const D3D12_COMMAND_SIGNATURE_DESC *pDesc,
+            _In_opt_  ID3D12RootSignature *pRootSignature,
+            REFIID riid,
+            _COM_Outptr_opt_  void **ppvCommandSignature);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, GetResourceTiling)
+        void ( STDMETHODCALLTYPE *GetResourceTiling )( 
+            ID3D12Device3 * This,
+            _In_  ID3D12Resource *pTiledResource,
+            _Out_opt_  UINT *pNumTilesForEntireResource,
+            _Out_opt_  D3D12_PACKED_MIP_INFO *pPackedMipDesc,
+            _Out_opt_  D3D12_TILE_SHAPE *pStandardTileShapeForNonPackedMips,
+            _Inout_opt_  UINT *pNumSubresourceTilings,
+            _In_  UINT FirstSubresourceTilingToGet,
+            _Out_writes_(*pNumSubresourceTilings)  D3D12_SUBRESOURCE_TILING *pSubresourceTilingsForNonPackedMips);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, GetAdapterLuid)
+#if !defined(_WIN32)
+        LUID ( STDMETHODCALLTYPE *GetAdapterLuid )( 
+            ID3D12Device3 * This);
+        
+#else
+        LUID *( STDMETHODCALLTYPE *GetAdapterLuid )( 
+            ID3D12Device3 * This,
+            LUID * RetVal);
+        
+#endif
+        
+        DECLSPEC_XFGVIRT(ID3D12Device1, CreatePipelineLibrary)
+        HRESULT ( STDMETHODCALLTYPE *CreatePipelineLibrary )( 
+            ID3D12Device3 * This,
+            _In_reads_(BlobLength)  const void *pLibraryBlob,
+            SIZE_T BlobLength,
+            REFIID riid,
+            _COM_Outptr_  void **ppPipelineLibrary);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device1, SetEventOnMultipleFenceCompletion)
+        HRESULT ( STDMETHODCALLTYPE *SetEventOnMultipleFenceCompletion )( 
+            ID3D12Device3 * This,
+            _In_reads_(NumFences)  ID3D12Fence *const *ppFences,
+            _In_reads_(NumFences)  const UINT64 *pFenceValues,
+            UINT NumFences,
+            D3D12_MULTIPLE_FENCE_WAIT_FLAGS Flags,
+            HANDLE hEvent);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device1, SetResidencyPriority)
+        HRESULT ( STDMETHODCALLTYPE *SetResidencyPriority )( 
+            ID3D12Device3 * This,
+            UINT NumObjects,
+            _In_reads_(NumObjects)  ID3D12Pageable *const *ppObjects,
+            _In_reads_(NumObjects)  const D3D12_RESIDENCY_PRIORITY *pPriorities);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device2, CreatePipelineState)
+        HRESULT ( STDMETHODCALLTYPE *CreatePipelineState )( 
+            ID3D12Device3 * This,
+            const D3D12_PIPELINE_STATE_STREAM_DESC *pDesc,
+            REFIID riid,
+            _COM_Outptr_  void **ppPipelineState);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device3, OpenExistingHeapFromAddress)
+        HRESULT ( STDMETHODCALLTYPE *OpenExistingHeapFromAddress )( 
+            ID3D12Device3 * This,
+            _In_  const void *pAddress,
+            REFIID riid,
+            _COM_Outptr_  void **ppvHeap);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device3, OpenExistingHeapFromFileMapping)
+        HRESULT ( STDMETHODCALLTYPE *OpenExistingHeapFromFileMapping )( 
+            ID3D12Device3 * This,
+            _In_  HANDLE hFileMapping,
+            REFIID riid,
+            _COM_Outptr_  void **ppvHeap);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device3, EnqueueMakeResident)
+        HRESULT ( STDMETHODCALLTYPE *EnqueueMakeResident )( 
+            ID3D12Device3 * This,
+            D3D12_RESIDENCY_FLAGS Flags,
+            UINT NumObjects,
+            _In_reads_(NumObjects)  ID3D12Pageable *const *ppObjects,
+            _In_  ID3D12Fence *pFenceToSignal,
+            UINT64 FenceValueToSignal);
+        
+        END_INTERFACE
+    } ID3D12Device3Vtbl;
+
+    interface ID3D12Device3
+    {
+        CONST_VTBL struct ID3D12Device3Vtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define ID3D12Device3_QueryInterface(This,riid,ppvObject)	\
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define ID3D12Device3_AddRef(This)	\
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define ID3D12Device3_Release(This)	\
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#define ID3D12Device3_GetPrivateData(This,guid,pDataSize,pData)	\
+    ( (This)->lpVtbl -> GetPrivateData(This,guid,pDataSize,pData) ) 
+
+#define ID3D12Device3_SetPrivateData(This,guid,DataSize,pData)	\
+    ( (This)->lpVtbl -> SetPrivateData(This,guid,DataSize,pData) ) 
+
+#define ID3D12Device3_SetPrivateDataInterface(This,guid,pData)	\
+    ( (This)->lpVtbl -> SetPrivateDataInterface(This,guid,pData) ) 
+
+#define ID3D12Device3_SetName(This,Name)	\
+    ( (This)->lpVtbl -> SetName(This,Name) ) 
+
+
+#define ID3D12Device3_GetNodeCount(This)	\
+    ( (This)->lpVtbl -> GetNodeCount(This) ) 
+
+#define ID3D12Device3_CreateCommandQueue(This,pDesc,riid,ppCommandQueue)	\
+    ( (This)->lpVtbl -> CreateCommandQueue(This,pDesc,riid,ppCommandQueue) ) 
+
+#define ID3D12Device3_CreateCommandAllocator(This,type,riid,ppCommandAllocator)	\
+    ( (This)->lpVtbl -> CreateCommandAllocator(This,type,riid,ppCommandAllocator) ) 
+
+#define ID3D12Device3_CreateGraphicsPipelineState(This,pDesc,riid,ppPipelineState)	\
+    ( (This)->lpVtbl -> CreateGraphicsPipelineState(This,pDesc,riid,ppPipelineState) ) 
+
+#define ID3D12Device3_CreateComputePipelineState(This,pDesc,riid,ppPipelineState)	\
+    ( (This)->lpVtbl -> CreateComputePipelineState(This,pDesc,riid,ppPipelineState) ) 
+
+#define ID3D12Device3_CreateCommandList(This,nodeMask,type,pCommandAllocator,pInitialState,riid,ppCommandList)	\
+    ( (This)->lpVtbl -> CreateCommandList(This,nodeMask,type,pCommandAllocator,pInitialState,riid,ppCommandList) ) 
+
+#define ID3D12Device3_CheckFeatureSupport(This,Feature,pFeatureSupportData,FeatureSupportDataSize)	\
+    ( (This)->lpVtbl -> CheckFeatureSupport(This,Feature,pFeatureSupportData,FeatureSupportDataSize) ) 
+
+#define ID3D12Device3_CreateDescriptorHeap(This,pDescriptorHeapDesc,riid,ppvHeap)	\
+    ( (This)->lpVtbl -> CreateDescriptorHeap(This,pDescriptorHeapDesc,riid,ppvHeap) ) 
+
+#define ID3D12Device3_GetDescriptorHandleIncrementSize(This,DescriptorHeapType)	\
+    ( (This)->lpVtbl -> GetDescriptorHandleIncrementSize(This,DescriptorHeapType) ) 
+
+#define ID3D12Device3_CreateRootSignature(This,nodeMask,pBlobWithRootSignature,blobLengthInBytes,riid,ppvRootSignature)	\
+    ( (This)->lpVtbl -> CreateRootSignature(This,nodeMask,pBlobWithRootSignature,blobLengthInBytes,riid,ppvRootSignature) ) 
+
+#define ID3D12Device3_CreateConstantBufferView(This,pDesc,DestDescriptor)	\
+    ( (This)->lpVtbl -> CreateConstantBufferView(This,pDesc,DestDescriptor) ) 
+
+#define ID3D12Device3_CreateShaderResourceView(This,pResource,pDesc,DestDescriptor)	\
+    ( (This)->lpVtbl -> CreateShaderResourceView(This,pResource,pDesc,DestDescriptor) ) 
+
+#define ID3D12Device3_CreateUnorderedAccessView(This,pResource,pCounterResource,pDesc,DestDescriptor)	\
+    ( (This)->lpVtbl -> CreateUnorderedAccessView(This,pResource,pCounterResource,pDesc,DestDescriptor) ) 
+
+#define ID3D12Device3_CreateRenderTargetView(This,pResource,pDesc,DestDescriptor)	\
+    ( (This)->lpVtbl -> CreateRenderTargetView(This,pResource,pDesc,DestDescriptor) ) 
+
+#define ID3D12Device3_CreateDepthStencilView(This,pResource,pDesc,DestDescriptor)	\
+    ( (This)->lpVtbl -> CreateDepthStencilView(This,pResource,pDesc,DestDescriptor) ) 
+
+#define ID3D12Device3_CreateSampler(This,pDesc,DestDescriptor)	\
+    ( (This)->lpVtbl -> CreateSampler(This,pDesc,DestDescriptor) ) 
+
+#define ID3D12Device3_CopyDescriptors(This,NumDestDescriptorRanges,pDestDescriptorRangeStarts,pDestDescriptorRangeSizes,NumSrcDescriptorRanges,pSrcDescriptorRangeStarts,pSrcDescriptorRangeSizes,DescriptorHeapsType)	\
+    ( (This)->lpVtbl -> CopyDescriptors(This,NumDestDescriptorRanges,pDestDescriptorRangeStarts,pDestDescriptorRangeSizes,NumSrcDescriptorRanges,pSrcDescriptorRangeStarts,pSrcDescriptorRangeSizes,DescriptorHeapsType) ) 
+
+#define ID3D12Device3_CopyDescriptorsSimple(This,NumDescriptors,DestDescriptorRangeStart,SrcDescriptorRangeStart,DescriptorHeapsType)	\
+    ( (This)->lpVtbl -> CopyDescriptorsSimple(This,NumDescriptors,DestDescriptorRangeStart,SrcDescriptorRangeStart,DescriptorHeapsType) ) 
+#if !defined(_WIN32)
+
+#define ID3D12Device3_GetResourceAllocationInfo(This,visibleMask,numResourceDescs,pResourceDescs)	\
+    ( (This)->lpVtbl -> GetResourceAllocationInfo(This,visibleMask,numResourceDescs,pResourceDescs) ) 
+#else
+#define ID3D12Device3_GetResourceAllocationInfo(This,RetVal,visibleMask,numResourceDescs,pResourceDescs)	\
+    ( (This)->lpVtbl -> GetResourceAllocationInfo(This,RetVal,visibleMask,numResourceDescs,pResourceDescs) ) 
+#endif
+#if !defined(_WIN32)
+
+#define ID3D12Device3_GetCustomHeapProperties(This,nodeMask,heapType)	\
+    ( (This)->lpVtbl -> GetCustomHeapProperties(This,nodeMask,heapType) ) 
+#else
+#define ID3D12Device3_GetCustomHeapProperties(This,RetVal,nodeMask,heapType)	\
+    ( (This)->lpVtbl -> GetCustomHeapProperties(This,RetVal,nodeMask,heapType) ) 
+#endif
+
+#define ID3D12Device3_CreateCommittedResource(This,pHeapProperties,HeapFlags,pDesc,InitialResourceState,pOptimizedClearValue,riidResource,ppvResource)	\
+    ( (This)->lpVtbl -> CreateCommittedResource(This,pHeapProperties,HeapFlags,pDesc,InitialResourceState,pOptimizedClearValue,riidResource,ppvResource) ) 
+
+#define ID3D12Device3_CreateHeap(This,pDesc,riid,ppvHeap)	\
+    ( (This)->lpVtbl -> CreateHeap(This,pDesc,riid,ppvHeap) ) 
+
+#define ID3D12Device3_CreatePlacedResource(This,pHeap,HeapOffset,pDesc,InitialState,pOptimizedClearValue,riid,ppvResource)	\
+    ( (This)->lpVtbl -> CreatePlacedResource(This,pHeap,HeapOffset,pDesc,InitialState,pOptimizedClearValue,riid,ppvResource) ) 
+
+#define ID3D12Device3_CreateReservedResource(This,pDesc,InitialState,pOptimizedClearValue,riid,ppvResource)	\
+    ( (This)->lpVtbl -> CreateReservedResource(This,pDesc,InitialState,pOptimizedClearValue,riid,ppvResource) ) 
+
+#define ID3D12Device3_CreateSharedHandle(This,pObject,pAttributes,Access,Name,pHandle)	\
+    ( (This)->lpVtbl -> CreateSharedHandle(This,pObject,pAttributes,Access,Name,pHandle) ) 
+
+#define ID3D12Device3_OpenSharedHandle(This,NTHandle,riid,ppvObj)	\
+    ( (This)->lpVtbl -> OpenSharedHandle(This,NTHandle,riid,ppvObj) ) 
+
+#define ID3D12Device3_OpenSharedHandleByName(This,Name,Access,pNTHandle)	\
+    ( (This)->lpVtbl -> OpenSharedHandleByName(This,Name,Access,pNTHandle) ) 
+
+#define ID3D12Device3_MakeResident(This,NumObjects,ppObjects)	\
+    ( (This)->lpVtbl -> MakeResident(This,NumObjects,ppObjects) ) 
+
+#define ID3D12Device3_Evict(This,NumObjects,ppObjects)	\
+    ( (This)->lpVtbl -> Evict(This,NumObjects,ppObjects) ) 
+
+#define ID3D12Device3_CreateFence(This,InitialValue,Flags,riid,ppFence)	\
+    ( (This)->lpVtbl -> CreateFence(This,InitialValue,Flags,riid,ppFence) ) 
+
+#define ID3D12Device3_GetDeviceRemovedReason(This)	\
+    ( (This)->lpVtbl -> GetDeviceRemovedReason(This) ) 
+
+#define ID3D12Device3_GetCopyableFootprints(This,pResourceDesc,FirstSubresource,NumSubresources,BaseOffset,pLayouts,pNumRows,pRowSizeInBytes,pTotalBytes)	\
+    ( (This)->lpVtbl -> GetCopyableFootprints(This,pResourceDesc,FirstSubresource,NumSubresources,BaseOffset,pLayouts,pNumRows,pRowSizeInBytes,pTotalBytes) ) 
+
+#define ID3D12Device3_CreateQueryHeap(This,pDesc,riid,ppvHeap)	\
+    ( (This)->lpVtbl -> CreateQueryHeap(This,pDesc,riid,ppvHeap) ) 
+
+#define ID3D12Device3_SetStablePowerState(This,Enable)	\
+    ( (This)->lpVtbl -> SetStablePowerState(This,Enable) ) 
+
+#define ID3D12Device3_CreateCommandSignature(This,pDesc,pRootSignature,riid,ppvCommandSignature)	\
+    ( (This)->lpVtbl -> CreateCommandSignature(This,pDesc,pRootSignature,riid,ppvCommandSignature) ) 
+
+#define ID3D12Device3_GetResourceTiling(This,pTiledResource,pNumTilesForEntireResource,pPackedMipDesc,pStandardTileShapeForNonPackedMips,pNumSubresourceTilings,FirstSubresourceTilingToGet,pSubresourceTilingsForNonPackedMips)	\
+    ( (This)->lpVtbl -> GetResourceTiling(This,pTiledResource,pNumTilesForEntireResource,pPackedMipDesc,pStandardTileShapeForNonPackedMips,pNumSubresourceTilings,FirstSubresourceTilingToGet,pSubresourceTilingsForNonPackedMips) ) 
+#if !defined(_WIN32)
+
+#define ID3D12Device3_GetAdapterLuid(This)	\
+    ( (This)->lpVtbl -> GetAdapterLuid(This) ) 
+#else
+#define ID3D12Device3_GetAdapterLuid(This,RetVal)	\
+    ( (This)->lpVtbl -> GetAdapterLuid(This,RetVal) ) 
+#endif
+
+
+#define ID3D12Device3_CreatePipelineLibrary(This,pLibraryBlob,BlobLength,riid,ppPipelineLibrary)	\
+    ( (This)->lpVtbl -> CreatePipelineLibrary(This,pLibraryBlob,BlobLength,riid,ppPipelineLibrary) ) 
+
+#define ID3D12Device3_SetEventOnMultipleFenceCompletion(This,ppFences,pFenceValues,NumFences,Flags,hEvent)	\
+    ( (This)->lpVtbl -> SetEventOnMultipleFenceCompletion(This,ppFences,pFenceValues,NumFences,Flags,hEvent) ) 
+
+#define ID3D12Device3_SetResidencyPriority(This,NumObjects,ppObjects,pPriorities)	\
+    ( (This)->lpVtbl -> SetResidencyPriority(This,NumObjects,ppObjects,pPriorities) ) 
+
+
+#define ID3D12Device3_CreatePipelineState(This,pDesc,riid,ppPipelineState)	\
+    ( (This)->lpVtbl -> CreatePipelineState(This,pDesc,riid,ppPipelineState) ) 
+
+
+#define ID3D12Device3_OpenExistingHeapFromAddress(This,pAddress,riid,ppvHeap)	\
+    ( (This)->lpVtbl -> OpenExistingHeapFromAddress(This,pAddress,riid,ppvHeap) ) 
+
+#define ID3D12Device3_OpenExistingHeapFromFileMapping(This,hFileMapping,riid,ppvHeap)	\
+    ( (This)->lpVtbl -> OpenExistingHeapFromFileMapping(This,hFileMapping,riid,ppvHeap) ) 
+
+#define ID3D12Device3_EnqueueMakeResident(This,Flags,NumObjects,ppObjects,pFenceToSignal,FenceValueToSignal)	\
+    ( (This)->lpVtbl -> EnqueueMakeResident(This,Flags,NumObjects,ppObjects,pFenceToSignal,FenceValueToSignal) ) 
+
+#endif /* COBJMACROS */
+
+
+#endif 	/* C style interface */
+
+
+
+
+#endif 	/* __ID3D12Device3_INTERFACE_DEFINED__ */
+
+
+/* interface __MIDL_itf_d3d12_0000_0026 */
+/* [local] */ 
+
+typedef 
+enum D3D12_COMMAND_LIST_FLAGS
+    {
+        D3D12_COMMAND_LIST_FLAG_NONE	= 0
+    } 	D3D12_COMMAND_LIST_FLAGS;
+
+DEFINE_ENUM_FLAG_OPERATORS( D3D12_COMMAND_LIST_FLAGS );
+typedef 
+enum D3D12_COMMAND_POOL_FLAGS
+    {
+        D3D12_COMMAND_POOL_FLAG_NONE	= 0
+    } 	D3D12_COMMAND_POOL_FLAGS;
+
+DEFINE_ENUM_FLAG_OPERATORS( D3D12_COMMAND_POOL_FLAGS );
+typedef 
+enum D3D12_COMMAND_RECORDER_FLAGS
+    {
+        D3D12_COMMAND_RECORDER_FLAG_NONE	= 0
+    } 	D3D12_COMMAND_RECORDER_FLAGS;
+
+DEFINE_ENUM_FLAG_OPERATORS( D3D12_COMMAND_RECORDER_FLAGS );
+typedef 
+enum D3D12_PROTECTED_SESSION_STATUS
+    {
+        D3D12_PROTECTED_SESSION_STATUS_OK	= 0,
+        D3D12_PROTECTED_SESSION_STATUS_INVALID	= 1
+    } 	D3D12_PROTECTED_SESSION_STATUS;
+
+
+
+extern RPC_IF_HANDLE __MIDL_itf_d3d12_0000_0026_v0_0_c_ifspec;
+extern RPC_IF_HANDLE __MIDL_itf_d3d12_0000_0026_v0_0_s_ifspec;
+
+#ifndef __ID3D12ProtectedSession_INTERFACE_DEFINED__
+#define __ID3D12ProtectedSession_INTERFACE_DEFINED__
+
+/* interface ID3D12ProtectedSession */
+/* [unique][local][object][uuid] */ 
+
+
+EXTERN_C const IID IID_ID3D12ProtectedSession;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("A1533D18-0AC1-4084-85B9-89A96116806B")
+    ID3D12ProtectedSession : public ID3D12DeviceChild
+    {
+    public:
+        virtual HRESULT STDMETHODCALLTYPE GetStatusFence( 
+            REFIID riid,
+            _COM_Outptr_opt_  void **ppFence) = 0;
+        
+        virtual D3D12_PROTECTED_SESSION_STATUS STDMETHODCALLTYPE GetSessionStatus( void) = 0;
+        
+    };
+    
+    
+#else 	/* C style interface */
+
+    typedef struct ID3D12ProtectedSessionVtbl
+    {
+        BEGIN_INTERFACE
+        
+        DECLSPEC_XFGVIRT(IUnknown, QueryInterface)
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            ID3D12ProtectedSession * This,
+            REFIID riid,
+            _COM_Outptr_  void **ppvObject);
+        
+        DECLSPEC_XFGVIRT(IUnknown, AddRef)
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            ID3D12ProtectedSession * This);
+        
+        DECLSPEC_XFGVIRT(IUnknown, Release)
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            ID3D12ProtectedSession * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, GetPrivateData)
+        HRESULT ( STDMETHODCALLTYPE *GetPrivateData )( 
+            ID3D12ProtectedSession * This,
+            _In_  REFGUID guid,
+            _Inout_  UINT *pDataSize,
+            _Out_writes_bytes_opt_( *pDataSize )  void *pData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, SetPrivateData)
+        HRESULT ( STDMETHODCALLTYPE *SetPrivateData )( 
+            ID3D12ProtectedSession * This,
+            _In_  REFGUID guid,
+            _In_  UINT DataSize,
+            _In_reads_bytes_opt_( DataSize )  const void *pData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, SetPrivateDataInterface)
+        HRESULT ( STDMETHODCALLTYPE *SetPrivateDataInterface )( 
+            ID3D12ProtectedSession * This,
+            _In_  REFGUID guid,
+            _In_opt_  const IUnknown *pData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, SetName)
+        HRESULT ( STDMETHODCALLTYPE *SetName )( 
+            ID3D12ProtectedSession * This,
+            _In_z_  LPCWSTR Name);
+        
+        DECLSPEC_XFGVIRT(ID3D12DeviceChild, GetDevice)
+        HRESULT ( STDMETHODCALLTYPE *GetDevice )( 
+            ID3D12ProtectedSession * This,
+            REFIID riid,
+            _COM_Outptr_opt_  void **ppvDevice);
+        
+        DECLSPEC_XFGVIRT(ID3D12ProtectedSession, GetStatusFence)
+        HRESULT ( STDMETHODCALLTYPE *GetStatusFence )( 
+            ID3D12ProtectedSession * This,
+            REFIID riid,
+            _COM_Outptr_opt_  void **ppFence);
+        
+        DECLSPEC_XFGVIRT(ID3D12ProtectedSession, GetSessionStatus)
+        D3D12_PROTECTED_SESSION_STATUS ( STDMETHODCALLTYPE *GetSessionStatus )( 
+            ID3D12ProtectedSession * This);
+        
+        END_INTERFACE
+    } ID3D12ProtectedSessionVtbl;
+
+    interface ID3D12ProtectedSession
+    {
+        CONST_VTBL struct ID3D12ProtectedSessionVtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define ID3D12ProtectedSession_QueryInterface(This,riid,ppvObject)	\
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define ID3D12ProtectedSession_AddRef(This)	\
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define ID3D12ProtectedSession_Release(This)	\
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#define ID3D12ProtectedSession_GetPrivateData(This,guid,pDataSize,pData)	\
+    ( (This)->lpVtbl -> GetPrivateData(This,guid,pDataSize,pData) ) 
+
+#define ID3D12ProtectedSession_SetPrivateData(This,guid,DataSize,pData)	\
+    ( (This)->lpVtbl -> SetPrivateData(This,guid,DataSize,pData) ) 
+
+#define ID3D12ProtectedSession_SetPrivateDataInterface(This,guid,pData)	\
+    ( (This)->lpVtbl -> SetPrivateDataInterface(This,guid,pData) ) 
+
+#define ID3D12ProtectedSession_SetName(This,Name)	\
+    ( (This)->lpVtbl -> SetName(This,Name) ) 
+
+
+#define ID3D12ProtectedSession_GetDevice(This,riid,ppvDevice)	\
+    ( (This)->lpVtbl -> GetDevice(This,riid,ppvDevice) ) 
+
+
+#define ID3D12ProtectedSession_GetStatusFence(This,riid,ppFence)	\
+    ( (This)->lpVtbl -> GetStatusFence(This,riid,ppFence) ) 
+
+#define ID3D12ProtectedSession_GetSessionStatus(This)	\
+    ( (This)->lpVtbl -> GetSessionStatus(This) ) 
+
+#endif /* COBJMACROS */
+
+
+#endif 	/* C style interface */
+
+
+
+
+#endif 	/* __ID3D12ProtectedSession_INTERFACE_DEFINED__ */
+
+
+/* interface __MIDL_itf_d3d12_0000_0027 */
+/* [local] */ 
+
+typedef 
+enum D3D12_PROTECTED_RESOURCE_SESSION_SUPPORT_FLAGS
+    {
+        D3D12_PROTECTED_RESOURCE_SESSION_SUPPORT_FLAG_NONE	= 0,
+        D3D12_PROTECTED_RESOURCE_SESSION_SUPPORT_FLAG_SUPPORTED	= 0x1
+    } 	D3D12_PROTECTED_RESOURCE_SESSION_SUPPORT_FLAGS;
+
+DEFINE_ENUM_FLAG_OPERATORS( D3D12_PROTECTED_RESOURCE_SESSION_SUPPORT_FLAGS );
+typedef struct D3D12_FEATURE_DATA_PROTECTED_RESOURCE_SESSION_SUPPORT
+    {
+    UINT NodeIndex;
+    D3D12_PROTECTED_RESOURCE_SESSION_SUPPORT_FLAGS Support;
+    } 	D3D12_FEATURE_DATA_PROTECTED_RESOURCE_SESSION_SUPPORT;
+
+typedef 
+enum D3D12_PROTECTED_RESOURCE_SESSION_FLAGS
+    {
+        D3D12_PROTECTED_RESOURCE_SESSION_FLAG_NONE	= 0
+    } 	D3D12_PROTECTED_RESOURCE_SESSION_FLAGS;
+
+DEFINE_ENUM_FLAG_OPERATORS( D3D12_PROTECTED_RESOURCE_SESSION_FLAGS );
+typedef struct D3D12_PROTECTED_RESOURCE_SESSION_DESC
+    {
+    UINT NodeMask;
+    D3D12_PROTECTED_RESOURCE_SESSION_FLAGS Flags;
+    } 	D3D12_PROTECTED_RESOURCE_SESSION_DESC;
+
+
+
+extern RPC_IF_HANDLE __MIDL_itf_d3d12_0000_0027_v0_0_c_ifspec;
+extern RPC_IF_HANDLE __MIDL_itf_d3d12_0000_0027_v0_0_s_ifspec;
+
+#ifndef __ID3D12ProtectedResourceSession_INTERFACE_DEFINED__
+#define __ID3D12ProtectedResourceSession_INTERFACE_DEFINED__
+
+/* interface ID3D12ProtectedResourceSession */
+/* [unique][local][object][uuid] */ 
+
+
+EXTERN_C const IID IID_ID3D12ProtectedResourceSession;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("6CD696F4-F289-40CC-8091-5A6C0A099C3D")
+    ID3D12ProtectedResourceSession : public ID3D12ProtectedSession
+    {
+    public:
+#if defined(_MSC_VER) || !defined(_WIN32)
+        virtual D3D12_PROTECTED_RESOURCE_SESSION_DESC STDMETHODCALLTYPE GetDesc( void) = 0;
+#else
+        virtual D3D12_PROTECTED_RESOURCE_SESSION_DESC *STDMETHODCALLTYPE GetDesc( 
+            D3D12_PROTECTED_RESOURCE_SESSION_DESC * RetVal) = 0;
+#endif
+        
+    };
+    
+    
+#else 	/* C style interface */
+
+    typedef struct ID3D12ProtectedResourceSessionVtbl
+    {
+        BEGIN_INTERFACE
+        
+        DECLSPEC_XFGVIRT(IUnknown, QueryInterface)
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            ID3D12ProtectedResourceSession * This,
+            REFIID riid,
+            _COM_Outptr_  void **ppvObject);
+        
+        DECLSPEC_XFGVIRT(IUnknown, AddRef)
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            ID3D12ProtectedResourceSession * This);
+        
+        DECLSPEC_XFGVIRT(IUnknown, Release)
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            ID3D12ProtectedResourceSession * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, GetPrivateData)
+        HRESULT ( STDMETHODCALLTYPE *GetPrivateData )( 
+            ID3D12ProtectedResourceSession * This,
+            _In_  REFGUID guid,
+            _Inout_  UINT *pDataSize,
+            _Out_writes_bytes_opt_( *pDataSize )  void *pData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, SetPrivateData)
+        HRESULT ( STDMETHODCALLTYPE *SetPrivateData )( 
+            ID3D12ProtectedResourceSession * This,
+            _In_  REFGUID guid,
+            _In_  UINT DataSize,
+            _In_reads_bytes_opt_( DataSize )  const void *pData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, SetPrivateDataInterface)
+        HRESULT ( STDMETHODCALLTYPE *SetPrivateDataInterface )( 
+            ID3D12ProtectedResourceSession * This,
+            _In_  REFGUID guid,
+            _In_opt_  const IUnknown *pData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, SetName)
+        HRESULT ( STDMETHODCALLTYPE *SetName )( 
+            ID3D12ProtectedResourceSession * This,
+            _In_z_  LPCWSTR Name);
+        
+        DECLSPEC_XFGVIRT(ID3D12DeviceChild, GetDevice)
+        HRESULT ( STDMETHODCALLTYPE *GetDevice )( 
+            ID3D12ProtectedResourceSession * This,
+            REFIID riid,
+            _COM_Outptr_opt_  void **ppvDevice);
+        
+        DECLSPEC_XFGVIRT(ID3D12ProtectedSession, GetStatusFence)
+        HRESULT ( STDMETHODCALLTYPE *GetStatusFence )( 
+            ID3D12ProtectedResourceSession * This,
+            REFIID riid,
+            _COM_Outptr_opt_  void **ppFence);
+        
+        DECLSPEC_XFGVIRT(ID3D12ProtectedSession, GetSessionStatus)
+        D3D12_PROTECTED_SESSION_STATUS ( STDMETHODCALLTYPE *GetSessionStatus )( 
+            ID3D12ProtectedResourceSession * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12ProtectedResourceSession, GetDesc)
+#if !defined(_WIN32)
+        D3D12_PROTECTED_RESOURCE_SESSION_DESC ( STDMETHODCALLTYPE *GetDesc )( 
+            ID3D12ProtectedResourceSession * This);
+        
+#else
+        D3D12_PROTECTED_RESOURCE_SESSION_DESC *( STDMETHODCALLTYPE *GetDesc )( 
+            ID3D12ProtectedResourceSession * This,
+            D3D12_PROTECTED_RESOURCE_SESSION_DESC * RetVal);
+        
+#endif
+        
+        END_INTERFACE
+    } ID3D12ProtectedResourceSessionVtbl;
+
+    interface ID3D12ProtectedResourceSession
+    {
+        CONST_VTBL struct ID3D12ProtectedResourceSessionVtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define ID3D12ProtectedResourceSession_QueryInterface(This,riid,ppvObject)	\
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define ID3D12ProtectedResourceSession_AddRef(This)	\
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define ID3D12ProtectedResourceSession_Release(This)	\
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#define ID3D12ProtectedResourceSession_GetPrivateData(This,guid,pDataSize,pData)	\
+    ( (This)->lpVtbl -> GetPrivateData(This,guid,pDataSize,pData) ) 
+
+#define ID3D12ProtectedResourceSession_SetPrivateData(This,guid,DataSize,pData)	\
+    ( (This)->lpVtbl -> SetPrivateData(This,guid,DataSize,pData) ) 
+
+#define ID3D12ProtectedResourceSession_SetPrivateDataInterface(This,guid,pData)	\
+    ( (This)->lpVtbl -> SetPrivateDataInterface(This,guid,pData) ) 
+
+#define ID3D12ProtectedResourceSession_SetName(This,Name)	\
+    ( (This)->lpVtbl -> SetName(This,Name) ) 
+
+
+#define ID3D12ProtectedResourceSession_GetDevice(This,riid,ppvDevice)	\
+    ( (This)->lpVtbl -> GetDevice(This,riid,ppvDevice) ) 
+
+
+#define ID3D12ProtectedResourceSession_GetStatusFence(This,riid,ppFence)	\
+    ( (This)->lpVtbl -> GetStatusFence(This,riid,ppFence) ) 
+
+#define ID3D12ProtectedResourceSession_GetSessionStatus(This)	\
+    ( (This)->lpVtbl -> GetSessionStatus(This) ) 
+
+#if !defined(_WIN32)
+
+#define ID3D12ProtectedResourceSession_GetDesc(This)	\
+    ( (This)->lpVtbl -> GetDesc(This) ) 
+#else
+#define ID3D12ProtectedResourceSession_GetDesc(This,RetVal)	\
+    ( (This)->lpVtbl -> GetDesc(This,RetVal) ) 
+#endif
+
+#endif /* COBJMACROS */
+
+
+#endif 	/* C style interface */
+
+
+
+
+#endif 	/* __ID3D12ProtectedResourceSession_INTERFACE_DEFINED__ */
+
+
+#ifndef __ID3D12Device4_INTERFACE_DEFINED__
+#define __ID3D12Device4_INTERFACE_DEFINED__
+
+/* interface ID3D12Device4 */
+/* [unique][local][object][uuid] */ 
+
+
+EXTERN_C const IID IID_ID3D12Device4;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("e865df17-a9ee-46f9-a463-3098315aa2e5")
+    ID3D12Device4 : public ID3D12Device3
+    {
+    public:
+        virtual HRESULT STDMETHODCALLTYPE CreateCommandList1( 
+            _In_  UINT nodeMask,
+            _In_  D3D12_COMMAND_LIST_TYPE type,
+            _In_  D3D12_COMMAND_LIST_FLAGS flags,
+            REFIID riid,
+            _COM_Outptr_  void **ppCommandList) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE CreateProtectedResourceSession( 
+            _In_  const D3D12_PROTECTED_RESOURCE_SESSION_DESC *pDesc,
+            _In_  REFIID riid,
+            _COM_Outptr_  void **ppSession) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE CreateCommittedResource1( 
+            _In_  const D3D12_HEAP_PROPERTIES *pHeapProperties,
+            D3D12_HEAP_FLAGS HeapFlags,
+            _In_  const D3D12_RESOURCE_DESC *pDesc,
+            D3D12_RESOURCE_STATES InitialResourceState,
+            _In_opt_  const D3D12_CLEAR_VALUE *pOptimizedClearValue,
+            _In_opt_  ID3D12ProtectedResourceSession *pProtectedSession,
+            REFIID riidResource,
+            _COM_Outptr_opt_  void **ppvResource) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE CreateHeap1( 
+            _In_  const D3D12_HEAP_DESC *pDesc,
+            _In_opt_  ID3D12ProtectedResourceSession *pProtectedSession,
+            REFIID riid,
+            _COM_Outptr_opt_  void **ppvHeap) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE CreateReservedResource1( 
+            _In_  const D3D12_RESOURCE_DESC *pDesc,
+            D3D12_RESOURCE_STATES InitialState,
+            _In_opt_  const D3D12_CLEAR_VALUE *pOptimizedClearValue,
+            _In_opt_  ID3D12ProtectedResourceSession *pProtectedSession,
+            REFIID riid,
+            _COM_Outptr_opt_  void **ppvResource) = 0;
+        
+#if defined(_MSC_VER) || !defined(_WIN32)
+        virtual D3D12_RESOURCE_ALLOCATION_INFO STDMETHODCALLTYPE GetResourceAllocationInfo1( 
+            UINT visibleMask,
+            UINT numResourceDescs,
+            _In_reads_(numResourceDescs)  const D3D12_RESOURCE_DESC *pResourceDescs,
+            _Out_writes_opt_(numResourceDescs)  D3D12_RESOURCE_ALLOCATION_INFO1 *pResourceAllocationInfo1) = 0;
+#else
+        virtual D3D12_RESOURCE_ALLOCATION_INFO *STDMETHODCALLTYPE GetResourceAllocationInfo1( 
+            D3D12_RESOURCE_ALLOCATION_INFO * RetVal,
+            UINT visibleMask,
+            UINT numResourceDescs,
+            _In_reads_(numResourceDescs)  const D3D12_RESOURCE_DESC *pResourceDescs,
+            _Out_writes_opt_(numResourceDescs)  D3D12_RESOURCE_ALLOCATION_INFO1 *pResourceAllocationInfo1) = 0;
+#endif
+        
+    };
+    
+    
+#else 	/* C style interface */
+
+    typedef struct ID3D12Device4Vtbl
+    {
+        BEGIN_INTERFACE
+        
+        DECLSPEC_XFGVIRT(IUnknown, QueryInterface)
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            ID3D12Device4 * This,
+            REFIID riid,
+            _COM_Outptr_  void **ppvObject);
+        
+        DECLSPEC_XFGVIRT(IUnknown, AddRef)
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            ID3D12Device4 * This);
+        
+        DECLSPEC_XFGVIRT(IUnknown, Release)
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            ID3D12Device4 * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, GetPrivateData)
+        HRESULT ( STDMETHODCALLTYPE *GetPrivateData )( 
+            ID3D12Device4 * This,
+            _In_  REFGUID guid,
+            _Inout_  UINT *pDataSize,
+            _Out_writes_bytes_opt_( *pDataSize )  void *pData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, SetPrivateData)
+        HRESULT ( STDMETHODCALLTYPE *SetPrivateData )( 
+            ID3D12Device4 * This,
+            _In_  REFGUID guid,
+            _In_  UINT DataSize,
+            _In_reads_bytes_opt_( DataSize )  const void *pData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, SetPrivateDataInterface)
+        HRESULT ( STDMETHODCALLTYPE *SetPrivateDataInterface )( 
+            ID3D12Device4 * This,
+            _In_  REFGUID guid,
+            _In_opt_  const IUnknown *pData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, SetName)
+        HRESULT ( STDMETHODCALLTYPE *SetName )( 
+            ID3D12Device4 * This,
+            _In_z_  LPCWSTR Name);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, GetNodeCount)
+        UINT ( STDMETHODCALLTYPE *GetNodeCount )( 
+            ID3D12Device4 * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CreateCommandQueue)
+        HRESULT ( STDMETHODCALLTYPE *CreateCommandQueue )( 
+            ID3D12Device4 * This,
+            _In_  const D3D12_COMMAND_QUEUE_DESC *pDesc,
+            REFIID riid,
+            _COM_Outptr_  void **ppCommandQueue);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CreateCommandAllocator)
+        HRESULT ( STDMETHODCALLTYPE *CreateCommandAllocator )( 
+            ID3D12Device4 * This,
+            _In_  D3D12_COMMAND_LIST_TYPE type,
+            REFIID riid,
+            _COM_Outptr_  void **ppCommandAllocator);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CreateGraphicsPipelineState)
+        HRESULT ( STDMETHODCALLTYPE *CreateGraphicsPipelineState )( 
+            ID3D12Device4 * This,
+            _In_  const D3D12_GRAPHICS_PIPELINE_STATE_DESC *pDesc,
+            REFIID riid,
+            _COM_Outptr_  void **ppPipelineState);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CreateComputePipelineState)
+        HRESULT ( STDMETHODCALLTYPE *CreateComputePipelineState )( 
+            ID3D12Device4 * This,
+            _In_  const D3D12_COMPUTE_PIPELINE_STATE_DESC *pDesc,
+            REFIID riid,
+            _COM_Outptr_  void **ppPipelineState);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CreateCommandList)
+        HRESULT ( STDMETHODCALLTYPE *CreateCommandList )( 
+            ID3D12Device4 * This,
+            _In_  UINT nodeMask,
+            _In_  D3D12_COMMAND_LIST_TYPE type,
+            _In_  ID3D12CommandAllocator *pCommandAllocator,
+            _In_opt_  ID3D12PipelineState *pInitialState,
+            REFIID riid,
+            _COM_Outptr_  void **ppCommandList);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CheckFeatureSupport)
+        HRESULT ( STDMETHODCALLTYPE *CheckFeatureSupport )( 
+            ID3D12Device4 * This,
+            D3D12_FEATURE Feature,
+            _Inout_updates_bytes_(FeatureSupportDataSize)  void *pFeatureSupportData,
+            UINT FeatureSupportDataSize);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CreateDescriptorHeap)
+        HRESULT ( STDMETHODCALLTYPE *CreateDescriptorHeap )( 
+            ID3D12Device4 * This,
+            _In_  const D3D12_DESCRIPTOR_HEAP_DESC *pDescriptorHeapDesc,
+            REFIID riid,
+            _COM_Outptr_  void **ppvHeap);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, GetDescriptorHandleIncrementSize)
+        UINT ( STDMETHODCALLTYPE *GetDescriptorHandleIncrementSize )( 
+            ID3D12Device4 * This,
+            _In_  D3D12_DESCRIPTOR_HEAP_TYPE DescriptorHeapType);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CreateRootSignature)
+        HRESULT ( STDMETHODCALLTYPE *CreateRootSignature )( 
+            ID3D12Device4 * This,
+            _In_  UINT nodeMask,
+            _In_reads_(blobLengthInBytes)  const void *pBlobWithRootSignature,
+            _In_  SIZE_T blobLengthInBytes,
+            REFIID riid,
+            _COM_Outptr_  void **ppvRootSignature);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CreateConstantBufferView)
+        void ( STDMETHODCALLTYPE *CreateConstantBufferView )( 
+            ID3D12Device4 * This,
+            _In_opt_  const D3D12_CONSTANT_BUFFER_VIEW_DESC *pDesc,
+            _In_  D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CreateShaderResourceView)
+        void ( STDMETHODCALLTYPE *CreateShaderResourceView )( 
+            ID3D12Device4 * This,
+            _In_opt_  ID3D12Resource *pResource,
+            _In_opt_  const D3D12_SHADER_RESOURCE_VIEW_DESC *pDesc,
+            _In_  D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CreateUnorderedAccessView)
+        void ( STDMETHODCALLTYPE *CreateUnorderedAccessView )( 
+            ID3D12Device4 * This,
+            _In_opt_  ID3D12Resource *pResource,
+            _In_opt_  ID3D12Resource *pCounterResource,
+            _In_opt_  const D3D12_UNORDERED_ACCESS_VIEW_DESC *pDesc,
+            _In_  D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CreateRenderTargetView)
+        void ( STDMETHODCALLTYPE *CreateRenderTargetView )( 
+            ID3D12Device4 * This,
+            _In_opt_  ID3D12Resource *pResource,
+            _In_opt_  const D3D12_RENDER_TARGET_VIEW_DESC *pDesc,
+            _In_  D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CreateDepthStencilView)
+        void ( STDMETHODCALLTYPE *CreateDepthStencilView )( 
+            ID3D12Device4 * This,
+            _In_opt_  ID3D12Resource *pResource,
+            _In_opt_  const D3D12_DEPTH_STENCIL_VIEW_DESC *pDesc,
+            _In_  D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CreateSampler)
+        void ( STDMETHODCALLTYPE *CreateSampler )( 
+            ID3D12Device4 * This,
+            _In_  const D3D12_SAMPLER_DESC *pDesc,
+            _In_  D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CopyDescriptors)
+        void ( STDMETHODCALLTYPE *CopyDescriptors )( 
+            ID3D12Device4 * This,
+            _In_  UINT NumDestDescriptorRanges,
+            _In_reads_(NumDestDescriptorRanges)  const D3D12_CPU_DESCRIPTOR_HANDLE *pDestDescriptorRangeStarts,
+            _In_reads_opt_(NumDestDescriptorRanges)  const UINT *pDestDescriptorRangeSizes,
+            _In_  UINT NumSrcDescriptorRanges,
+            _In_reads_(NumSrcDescriptorRanges)  const D3D12_CPU_DESCRIPTOR_HANDLE *pSrcDescriptorRangeStarts,
+            _In_reads_opt_(NumSrcDescriptorRanges)  const UINT *pSrcDescriptorRangeSizes,
+            _In_  D3D12_DESCRIPTOR_HEAP_TYPE DescriptorHeapsType);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CopyDescriptorsSimple)
+        void ( STDMETHODCALLTYPE *CopyDescriptorsSimple )( 
+            ID3D12Device4 * This,
+            _In_  UINT NumDescriptors,
+            _In_  D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptorRangeStart,
+            _In_  D3D12_CPU_DESCRIPTOR_HANDLE SrcDescriptorRangeStart,
+            _In_  D3D12_DESCRIPTOR_HEAP_TYPE DescriptorHeapsType);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, GetResourceAllocationInfo)
+#if !defined(_WIN32)
+        D3D12_RESOURCE_ALLOCATION_INFO ( STDMETHODCALLTYPE *GetResourceAllocationInfo )( 
+            ID3D12Device4 * This,
+            _In_  UINT visibleMask,
+            _In_  UINT numResourceDescs,
+            _In_reads_(numResourceDescs)  const D3D12_RESOURCE_DESC *pResourceDescs);
+        
+#else
+        D3D12_RESOURCE_ALLOCATION_INFO *( STDMETHODCALLTYPE *GetResourceAllocationInfo )( 
+            ID3D12Device4 * This,
+            D3D12_RESOURCE_ALLOCATION_INFO * RetVal,
+            _In_  UINT visibleMask,
+            _In_  UINT numResourceDescs,
+            _In_reads_(numResourceDescs)  const D3D12_RESOURCE_DESC *pResourceDescs);
+        
+#endif
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, GetCustomHeapProperties)
+#if !defined(_WIN32)
+        D3D12_HEAP_PROPERTIES ( STDMETHODCALLTYPE *GetCustomHeapProperties )( 
+            ID3D12Device4 * This,
+            _In_  UINT nodeMask,
+            D3D12_HEAP_TYPE heapType);
+        
+#else
+        D3D12_HEAP_PROPERTIES *( STDMETHODCALLTYPE *GetCustomHeapProperties )( 
+            ID3D12Device4 * This,
+            D3D12_HEAP_PROPERTIES * RetVal,
+            _In_  UINT nodeMask,
+            D3D12_HEAP_TYPE heapType);
+        
+#endif
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CreateCommittedResource)
+        HRESULT ( STDMETHODCALLTYPE *CreateCommittedResource )( 
+            ID3D12Device4 * This,
+            _In_  const D3D12_HEAP_PROPERTIES *pHeapProperties,
+            D3D12_HEAP_FLAGS HeapFlags,
+            _In_  const D3D12_RESOURCE_DESC *pDesc,
+            D3D12_RESOURCE_STATES InitialResourceState,
+            _In_opt_  const D3D12_CLEAR_VALUE *pOptimizedClearValue,
+            REFIID riidResource,
+            _COM_Outptr_opt_  void **ppvResource);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CreateHeap)
+        HRESULT ( STDMETHODCALLTYPE *CreateHeap )( 
+            ID3D12Device4 * This,
+            _In_  const D3D12_HEAP_DESC *pDesc,
+            REFIID riid,
+            _COM_Outptr_opt_  void **ppvHeap);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CreatePlacedResource)
+        HRESULT ( STDMETHODCALLTYPE *CreatePlacedResource )( 
+            ID3D12Device4 * This,
+            _In_  ID3D12Heap *pHeap,
+            UINT64 HeapOffset,
+            _In_  const D3D12_RESOURCE_DESC *pDesc,
+            D3D12_RESOURCE_STATES InitialState,
+            _In_opt_  const D3D12_CLEAR_VALUE *pOptimizedClearValue,
+            REFIID riid,
+            _COM_Outptr_opt_  void **ppvResource);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CreateReservedResource)
+        HRESULT ( STDMETHODCALLTYPE *CreateReservedResource )( 
+            ID3D12Device4 * This,
+            _In_  const D3D12_RESOURCE_DESC *pDesc,
+            D3D12_RESOURCE_STATES InitialState,
+            _In_opt_  const D3D12_CLEAR_VALUE *pOptimizedClearValue,
+            REFIID riid,
+            _COM_Outptr_opt_  void **ppvResource);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CreateSharedHandle)
+        HRESULT ( STDMETHODCALLTYPE *CreateSharedHandle )( 
+            ID3D12Device4 * This,
+            _In_  ID3D12DeviceChild *pObject,
+            _In_opt_  const SECURITY_ATTRIBUTES *pAttributes,
+            DWORD Access,
+            _In_opt_  LPCWSTR Name,
+            _Out_  HANDLE *pHandle);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, OpenSharedHandle)
+        HRESULT ( STDMETHODCALLTYPE *OpenSharedHandle )( 
+            ID3D12Device4 * This,
+            _In_  HANDLE NTHandle,
+            REFIID riid,
+            _COM_Outptr_opt_  void **ppvObj);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, OpenSharedHandleByName)
+        HRESULT ( STDMETHODCALLTYPE *OpenSharedHandleByName )( 
+            ID3D12Device4 * This,
+            _In_  LPCWSTR Name,
+            DWORD Access,
+            /* [annotation][out] */ 
+            _Out_  HANDLE *pNTHandle);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, MakeResident)
+        HRESULT ( STDMETHODCALLTYPE *MakeResident )( 
+            ID3D12Device4 * This,
+            UINT NumObjects,
+            _In_reads_(NumObjects)  ID3D12Pageable *const *ppObjects);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, Evict)
+        HRESULT ( STDMETHODCALLTYPE *Evict )( 
+            ID3D12Device4 * This,
+            UINT NumObjects,
+            _In_reads_(NumObjects)  ID3D12Pageable *const *ppObjects);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CreateFence)
+        HRESULT ( STDMETHODCALLTYPE *CreateFence )( 
+            ID3D12Device4 * This,
+            UINT64 InitialValue,
+            D3D12_FENCE_FLAGS Flags,
+            REFIID riid,
+            _COM_Outptr_  void **ppFence);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, GetDeviceRemovedReason)
+        HRESULT ( STDMETHODCALLTYPE *GetDeviceRemovedReason )( 
+            ID3D12Device4 * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, GetCopyableFootprints)
+        void ( STDMETHODCALLTYPE *GetCopyableFootprints )( 
+            ID3D12Device4 * This,
+            _In_  const D3D12_RESOURCE_DESC *pResourceDesc,
+            _In_range_(0,D3D12_REQ_SUBRESOURCES)  UINT FirstSubresource,
+            _In_range_(0,D3D12_REQ_SUBRESOURCES-FirstSubresource)  UINT NumSubresources,
+            UINT64 BaseOffset,
+            _Out_writes_opt_(NumSubresources)  D3D12_PLACED_SUBRESOURCE_FOOTPRINT *pLayouts,
+            _Out_writes_opt_(NumSubresources)  UINT *pNumRows,
+            _Out_writes_opt_(NumSubresources)  UINT64 *pRowSizeInBytes,
+            _Out_opt_  UINT64 *pTotalBytes);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CreateQueryHeap)
+        HRESULT ( STDMETHODCALLTYPE *CreateQueryHeap )( 
+            ID3D12Device4 * This,
+            _In_  const D3D12_QUERY_HEAP_DESC *pDesc,
+            REFIID riid,
+            _COM_Outptr_opt_  void **ppvHeap);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, SetStablePowerState)
+        HRESULT ( STDMETHODCALLTYPE *SetStablePowerState )( 
+            ID3D12Device4 * This,
+            BOOL Enable);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CreateCommandSignature)
+        HRESULT ( STDMETHODCALLTYPE *CreateCommandSignature )( 
+            ID3D12Device4 * This,
+            _In_  const D3D12_COMMAND_SIGNATURE_DESC *pDesc,
+            _In_opt_  ID3D12RootSignature *pRootSignature,
+            REFIID riid,
+            _COM_Outptr_opt_  void **ppvCommandSignature);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, GetResourceTiling)
+        void ( STDMETHODCALLTYPE *GetResourceTiling )( 
+            ID3D12Device4 * This,
+            _In_  ID3D12Resource *pTiledResource,
+            _Out_opt_  UINT *pNumTilesForEntireResource,
+            _Out_opt_  D3D12_PACKED_MIP_INFO *pPackedMipDesc,
+            _Out_opt_  D3D12_TILE_SHAPE *pStandardTileShapeForNonPackedMips,
+            _Inout_opt_  UINT *pNumSubresourceTilings,
+            _In_  UINT FirstSubresourceTilingToGet,
+            _Out_writes_(*pNumSubresourceTilings)  D3D12_SUBRESOURCE_TILING *pSubresourceTilingsForNonPackedMips);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, GetAdapterLuid)
+#if !defined(_WIN32)
+        LUID ( STDMETHODCALLTYPE *GetAdapterLuid )( 
+            ID3D12Device4 * This);
+        
+#else
+        LUID *( STDMETHODCALLTYPE *GetAdapterLuid )( 
+            ID3D12Device4 * This,
+            LUID * RetVal);
+        
+#endif
+        
+        DECLSPEC_XFGVIRT(ID3D12Device1, CreatePipelineLibrary)
+        HRESULT ( STDMETHODCALLTYPE *CreatePipelineLibrary )( 
+            ID3D12Device4 * This,
+            _In_reads_(BlobLength)  const void *pLibraryBlob,
+            SIZE_T BlobLength,
+            REFIID riid,
+            _COM_Outptr_  void **ppPipelineLibrary);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device1, SetEventOnMultipleFenceCompletion)
+        HRESULT ( STDMETHODCALLTYPE *SetEventOnMultipleFenceCompletion )( 
+            ID3D12Device4 * This,
+            _In_reads_(NumFences)  ID3D12Fence *const *ppFences,
+            _In_reads_(NumFences)  const UINT64 *pFenceValues,
+            UINT NumFences,
+            D3D12_MULTIPLE_FENCE_WAIT_FLAGS Flags,
+            HANDLE hEvent);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device1, SetResidencyPriority)
+        HRESULT ( STDMETHODCALLTYPE *SetResidencyPriority )( 
+            ID3D12Device4 * This,
+            UINT NumObjects,
+            _In_reads_(NumObjects)  ID3D12Pageable *const *ppObjects,
+            _In_reads_(NumObjects)  const D3D12_RESIDENCY_PRIORITY *pPriorities);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device2, CreatePipelineState)
+        HRESULT ( STDMETHODCALLTYPE *CreatePipelineState )( 
+            ID3D12Device4 * This,
+            const D3D12_PIPELINE_STATE_STREAM_DESC *pDesc,
+            REFIID riid,
+            _COM_Outptr_  void **ppPipelineState);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device3, OpenExistingHeapFromAddress)
+        HRESULT ( STDMETHODCALLTYPE *OpenExistingHeapFromAddress )( 
+            ID3D12Device4 * This,
+            _In_  const void *pAddress,
+            REFIID riid,
+            _COM_Outptr_  void **ppvHeap);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device3, OpenExistingHeapFromFileMapping)
+        HRESULT ( STDMETHODCALLTYPE *OpenExistingHeapFromFileMapping )( 
+            ID3D12Device4 * This,
+            _In_  HANDLE hFileMapping,
+            REFIID riid,
+            _COM_Outptr_  void **ppvHeap);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device3, EnqueueMakeResident)
+        HRESULT ( STDMETHODCALLTYPE *EnqueueMakeResident )( 
+            ID3D12Device4 * This,
+            D3D12_RESIDENCY_FLAGS Flags,
+            UINT NumObjects,
+            _In_reads_(NumObjects)  ID3D12Pageable *const *ppObjects,
+            _In_  ID3D12Fence *pFenceToSignal,
+            UINT64 FenceValueToSignal);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device4, CreateCommandList1)
+        HRESULT ( STDMETHODCALLTYPE *CreateCommandList1 )( 
+            ID3D12Device4 * This,
+            _In_  UINT nodeMask,
+            _In_  D3D12_COMMAND_LIST_TYPE type,
+            _In_  D3D12_COMMAND_LIST_FLAGS flags,
+            REFIID riid,
+            _COM_Outptr_  void **ppCommandList);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device4, CreateProtectedResourceSession)
+        HRESULT ( STDMETHODCALLTYPE *CreateProtectedResourceSession )( 
+            ID3D12Device4 * This,
+            _In_  const D3D12_PROTECTED_RESOURCE_SESSION_DESC *pDesc,
+            _In_  REFIID riid,
+            _COM_Outptr_  void **ppSession);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device4, CreateCommittedResource1)
+        HRESULT ( STDMETHODCALLTYPE *CreateCommittedResource1 )( 
+            ID3D12Device4 * This,
+            _In_  const D3D12_HEAP_PROPERTIES *pHeapProperties,
+            D3D12_HEAP_FLAGS HeapFlags,
+            _In_  const D3D12_RESOURCE_DESC *pDesc,
+            D3D12_RESOURCE_STATES InitialResourceState,
+            _In_opt_  const D3D12_CLEAR_VALUE *pOptimizedClearValue,
+            _In_opt_  ID3D12ProtectedResourceSession *pProtectedSession,
+            REFIID riidResource,
+            _COM_Outptr_opt_  void **ppvResource);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device4, CreateHeap1)
+        HRESULT ( STDMETHODCALLTYPE *CreateHeap1 )( 
+            ID3D12Device4 * This,
+            _In_  const D3D12_HEAP_DESC *pDesc,
+            _In_opt_  ID3D12ProtectedResourceSession *pProtectedSession,
+            REFIID riid,
+            _COM_Outptr_opt_  void **ppvHeap);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device4, CreateReservedResource1)
+        HRESULT ( STDMETHODCALLTYPE *CreateReservedResource1 )( 
+            ID3D12Device4 * This,
+            _In_  const D3D12_RESOURCE_DESC *pDesc,
+            D3D12_RESOURCE_STATES InitialState,
+            _In_opt_  const D3D12_CLEAR_VALUE *pOptimizedClearValue,
+            _In_opt_  ID3D12ProtectedResourceSession *pProtectedSession,
+            REFIID riid,
+            _COM_Outptr_opt_  void **ppvResource);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device4, GetResourceAllocationInfo1)
+#if !defined(_WIN32)
+        D3D12_RESOURCE_ALLOCATION_INFO ( STDMETHODCALLTYPE *GetResourceAllocationInfo1 )( 
+            ID3D12Device4 * This,
+            UINT visibleMask,
+            UINT numResourceDescs,
+            _In_reads_(numResourceDescs)  const D3D12_RESOURCE_DESC *pResourceDescs,
+            _Out_writes_opt_(numResourceDescs)  D3D12_RESOURCE_ALLOCATION_INFO1 *pResourceAllocationInfo1);
+        
+#else
+        D3D12_RESOURCE_ALLOCATION_INFO *( STDMETHODCALLTYPE *GetResourceAllocationInfo1 )( 
+            ID3D12Device4 * This,
+            D3D12_RESOURCE_ALLOCATION_INFO * RetVal,
+            UINT visibleMask,
+            UINT numResourceDescs,
+            _In_reads_(numResourceDescs)  const D3D12_RESOURCE_DESC *pResourceDescs,
+            _Out_writes_opt_(numResourceDescs)  D3D12_RESOURCE_ALLOCATION_INFO1 *pResourceAllocationInfo1);
+        
+#endif
+        
+        END_INTERFACE
+    } ID3D12Device4Vtbl;
+
+    interface ID3D12Device4
+    {
+        CONST_VTBL struct ID3D12Device4Vtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define ID3D12Device4_QueryInterface(This,riid,ppvObject)	\
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define ID3D12Device4_AddRef(This)	\
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define ID3D12Device4_Release(This)	\
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#define ID3D12Device4_GetPrivateData(This,guid,pDataSize,pData)	\
+    ( (This)->lpVtbl -> GetPrivateData(This,guid,pDataSize,pData) ) 
+
+#define ID3D12Device4_SetPrivateData(This,guid,DataSize,pData)	\
+    ( (This)->lpVtbl -> SetPrivateData(This,guid,DataSize,pData) ) 
+
+#define ID3D12Device4_SetPrivateDataInterface(This,guid,pData)	\
+    ( (This)->lpVtbl -> SetPrivateDataInterface(This,guid,pData) ) 
+
+#define ID3D12Device4_SetName(This,Name)	\
+    ( (This)->lpVtbl -> SetName(This,Name) ) 
+
+
+#define ID3D12Device4_GetNodeCount(This)	\
+    ( (This)->lpVtbl -> GetNodeCount(This) ) 
+
+#define ID3D12Device4_CreateCommandQueue(This,pDesc,riid,ppCommandQueue)	\
+    ( (This)->lpVtbl -> CreateCommandQueue(This,pDesc,riid,ppCommandQueue) ) 
+
+#define ID3D12Device4_CreateCommandAllocator(This,type,riid,ppCommandAllocator)	\
+    ( (This)->lpVtbl -> CreateCommandAllocator(This,type,riid,ppCommandAllocator) ) 
+
+#define ID3D12Device4_CreateGraphicsPipelineState(This,pDesc,riid,ppPipelineState)	\
+    ( (This)->lpVtbl -> CreateGraphicsPipelineState(This,pDesc,riid,ppPipelineState) ) 
+
+#define ID3D12Device4_CreateComputePipelineState(This,pDesc,riid,ppPipelineState)	\
+    ( (This)->lpVtbl -> CreateComputePipelineState(This,pDesc,riid,ppPipelineState) ) 
+
+#define ID3D12Device4_CreateCommandList(This,nodeMask,type,pCommandAllocator,pInitialState,riid,ppCommandList)	\
+    ( (This)->lpVtbl -> CreateCommandList(This,nodeMask,type,pCommandAllocator,pInitialState,riid,ppCommandList) ) 
+
+#define ID3D12Device4_CheckFeatureSupport(This,Feature,pFeatureSupportData,FeatureSupportDataSize)	\
+    ( (This)->lpVtbl -> CheckFeatureSupport(This,Feature,pFeatureSupportData,FeatureSupportDataSize) ) 
+
+#define ID3D12Device4_CreateDescriptorHeap(This,pDescriptorHeapDesc,riid,ppvHeap)	\
+    ( (This)->lpVtbl -> CreateDescriptorHeap(This,pDescriptorHeapDesc,riid,ppvHeap) ) 
+
+#define ID3D12Device4_GetDescriptorHandleIncrementSize(This,DescriptorHeapType)	\
+    ( (This)->lpVtbl -> GetDescriptorHandleIncrementSize(This,DescriptorHeapType) ) 
+
+#define ID3D12Device4_CreateRootSignature(This,nodeMask,pBlobWithRootSignature,blobLengthInBytes,riid,ppvRootSignature)	\
+    ( (This)->lpVtbl -> CreateRootSignature(This,nodeMask,pBlobWithRootSignature,blobLengthInBytes,riid,ppvRootSignature) ) 
+
+#define ID3D12Device4_CreateConstantBufferView(This,pDesc,DestDescriptor)	\
+    ( (This)->lpVtbl -> CreateConstantBufferView(This,pDesc,DestDescriptor) ) 
+
+#define ID3D12Device4_CreateShaderResourceView(This,pResource,pDesc,DestDescriptor)	\
+    ( (This)->lpVtbl -> CreateShaderResourceView(This,pResource,pDesc,DestDescriptor) ) 
+
+#define ID3D12Device4_CreateUnorderedAccessView(This,pResource,pCounterResource,pDesc,DestDescriptor)	\
+    ( (This)->lpVtbl -> CreateUnorderedAccessView(This,pResource,pCounterResource,pDesc,DestDescriptor) ) 
+
+#define ID3D12Device4_CreateRenderTargetView(This,pResource,pDesc,DestDescriptor)	\
+    ( (This)->lpVtbl -> CreateRenderTargetView(This,pResource,pDesc,DestDescriptor) ) 
+
+#define ID3D12Device4_CreateDepthStencilView(This,pResource,pDesc,DestDescriptor)	\
+    ( (This)->lpVtbl -> CreateDepthStencilView(This,pResource,pDesc,DestDescriptor) ) 
+
+#define ID3D12Device4_CreateSampler(This,pDesc,DestDescriptor)	\
+    ( (This)->lpVtbl -> CreateSampler(This,pDesc,DestDescriptor) ) 
+
+#define ID3D12Device4_CopyDescriptors(This,NumDestDescriptorRanges,pDestDescriptorRangeStarts,pDestDescriptorRangeSizes,NumSrcDescriptorRanges,pSrcDescriptorRangeStarts,pSrcDescriptorRangeSizes,DescriptorHeapsType)	\
+    ( (This)->lpVtbl -> CopyDescriptors(This,NumDestDescriptorRanges,pDestDescriptorRangeStarts,pDestDescriptorRangeSizes,NumSrcDescriptorRanges,pSrcDescriptorRangeStarts,pSrcDescriptorRangeSizes,DescriptorHeapsType) ) 
+
+#define ID3D12Device4_CopyDescriptorsSimple(This,NumDescriptors,DestDescriptorRangeStart,SrcDescriptorRangeStart,DescriptorHeapsType)	\
+    ( (This)->lpVtbl -> CopyDescriptorsSimple(This,NumDescriptors,DestDescriptorRangeStart,SrcDescriptorRangeStart,DescriptorHeapsType) ) 
+#if !defined(_WIN32)
+
+#define ID3D12Device4_GetResourceAllocationInfo(This,visibleMask,numResourceDescs,pResourceDescs)	\
+    ( (This)->lpVtbl -> GetResourceAllocationInfo(This,visibleMask,numResourceDescs,pResourceDescs) ) 
+#else
+#define ID3D12Device4_GetResourceAllocationInfo(This,RetVal,visibleMask,numResourceDescs,pResourceDescs)	\
+    ( (This)->lpVtbl -> GetResourceAllocationInfo(This,RetVal,visibleMask,numResourceDescs,pResourceDescs) ) 
+#endif
+#if !defined(_WIN32)
+
+#define ID3D12Device4_GetCustomHeapProperties(This,nodeMask,heapType)	\
+    ( (This)->lpVtbl -> GetCustomHeapProperties(This,nodeMask,heapType) ) 
+#else
+#define ID3D12Device4_GetCustomHeapProperties(This,RetVal,nodeMask,heapType)	\
+    ( (This)->lpVtbl -> GetCustomHeapProperties(This,RetVal,nodeMask,heapType) ) 
+#endif
+
+#define ID3D12Device4_CreateCommittedResource(This,pHeapProperties,HeapFlags,pDesc,InitialResourceState,pOptimizedClearValue,riidResource,ppvResource)	\
+    ( (This)->lpVtbl -> CreateCommittedResource(This,pHeapProperties,HeapFlags,pDesc,InitialResourceState,pOptimizedClearValue,riidResource,ppvResource) ) 
+
+#define ID3D12Device4_CreateHeap(This,pDesc,riid,ppvHeap)	\
+    ( (This)->lpVtbl -> CreateHeap(This,pDesc,riid,ppvHeap) ) 
+
+#define ID3D12Device4_CreatePlacedResource(This,pHeap,HeapOffset,pDesc,InitialState,pOptimizedClearValue,riid,ppvResource)	\
+    ( (This)->lpVtbl -> CreatePlacedResource(This,pHeap,HeapOffset,pDesc,InitialState,pOptimizedClearValue,riid,ppvResource) ) 
+
+#define ID3D12Device4_CreateReservedResource(This,pDesc,InitialState,pOptimizedClearValue,riid,ppvResource)	\
+    ( (This)->lpVtbl -> CreateReservedResource(This,pDesc,InitialState,pOptimizedClearValue,riid,ppvResource) ) 
+
+#define ID3D12Device4_CreateSharedHandle(This,pObject,pAttributes,Access,Name,pHandle)	\
+    ( (This)->lpVtbl -> CreateSharedHandle(This,pObject,pAttributes,Access,Name,pHandle) ) 
+
+#define ID3D12Device4_OpenSharedHandle(This,NTHandle,riid,ppvObj)	\
+    ( (This)->lpVtbl -> OpenSharedHandle(This,NTHandle,riid,ppvObj) ) 
+
+#define ID3D12Device4_OpenSharedHandleByName(This,Name,Access,pNTHandle)	\
+    ( (This)->lpVtbl -> OpenSharedHandleByName(This,Name,Access,pNTHandle) ) 
+
+#define ID3D12Device4_MakeResident(This,NumObjects,ppObjects)	\
+    ( (This)->lpVtbl -> MakeResident(This,NumObjects,ppObjects) ) 
+
+#define ID3D12Device4_Evict(This,NumObjects,ppObjects)	\
+    ( (This)->lpVtbl -> Evict(This,NumObjects,ppObjects) ) 
+
+#define ID3D12Device4_CreateFence(This,InitialValue,Flags,riid,ppFence)	\
+    ( (This)->lpVtbl -> CreateFence(This,InitialValue,Flags,riid,ppFence) ) 
+
+#define ID3D12Device4_GetDeviceRemovedReason(This)	\
+    ( (This)->lpVtbl -> GetDeviceRemovedReason(This) ) 
+
+#define ID3D12Device4_GetCopyableFootprints(This,pResourceDesc,FirstSubresource,NumSubresources,BaseOffset,pLayouts,pNumRows,pRowSizeInBytes,pTotalBytes)	\
+    ( (This)->lpVtbl -> GetCopyableFootprints(This,pResourceDesc,FirstSubresource,NumSubresources,BaseOffset,pLayouts,pNumRows,pRowSizeInBytes,pTotalBytes) ) 
+
+#define ID3D12Device4_CreateQueryHeap(This,pDesc,riid,ppvHeap)	\
+    ( (This)->lpVtbl -> CreateQueryHeap(This,pDesc,riid,ppvHeap) ) 
+
+#define ID3D12Device4_SetStablePowerState(This,Enable)	\
+    ( (This)->lpVtbl -> SetStablePowerState(This,Enable) ) 
+
+#define ID3D12Device4_CreateCommandSignature(This,pDesc,pRootSignature,riid,ppvCommandSignature)	\
+    ( (This)->lpVtbl -> CreateCommandSignature(This,pDesc,pRootSignature,riid,ppvCommandSignature) ) 
+
+#define ID3D12Device4_GetResourceTiling(This,pTiledResource,pNumTilesForEntireResource,pPackedMipDesc,pStandardTileShapeForNonPackedMips,pNumSubresourceTilings,FirstSubresourceTilingToGet,pSubresourceTilingsForNonPackedMips)	\
+    ( (This)->lpVtbl -> GetResourceTiling(This,pTiledResource,pNumTilesForEntireResource,pPackedMipDesc,pStandardTileShapeForNonPackedMips,pNumSubresourceTilings,FirstSubresourceTilingToGet,pSubresourceTilingsForNonPackedMips) ) 
+#if !defined(_WIN32)
+
+#define ID3D12Device4_GetAdapterLuid(This)	\
+    ( (This)->lpVtbl -> GetAdapterLuid(This) ) 
+#else
+#define ID3D12Device4_GetAdapterLuid(This,RetVal)	\
+    ( (This)->lpVtbl -> GetAdapterLuid(This,RetVal) ) 
+#endif
+
+
+#define ID3D12Device4_CreatePipelineLibrary(This,pLibraryBlob,BlobLength,riid,ppPipelineLibrary)	\
+    ( (This)->lpVtbl -> CreatePipelineLibrary(This,pLibraryBlob,BlobLength,riid,ppPipelineLibrary) ) 
+
+#define ID3D12Device4_SetEventOnMultipleFenceCompletion(This,ppFences,pFenceValues,NumFences,Flags,hEvent)	\
+    ( (This)->lpVtbl -> SetEventOnMultipleFenceCompletion(This,ppFences,pFenceValues,NumFences,Flags,hEvent) ) 
+
+#define ID3D12Device4_SetResidencyPriority(This,NumObjects,ppObjects,pPriorities)	\
+    ( (This)->lpVtbl -> SetResidencyPriority(This,NumObjects,ppObjects,pPriorities) ) 
+
+
+#define ID3D12Device4_CreatePipelineState(This,pDesc,riid,ppPipelineState)	\
+    ( (This)->lpVtbl -> CreatePipelineState(This,pDesc,riid,ppPipelineState) ) 
+
+
+#define ID3D12Device4_OpenExistingHeapFromAddress(This,pAddress,riid,ppvHeap)	\
+    ( (This)->lpVtbl -> OpenExistingHeapFromAddress(This,pAddress,riid,ppvHeap) ) 
+
+#define ID3D12Device4_OpenExistingHeapFromFileMapping(This,hFileMapping,riid,ppvHeap)	\
+    ( (This)->lpVtbl -> OpenExistingHeapFromFileMapping(This,hFileMapping,riid,ppvHeap) ) 
+
+#define ID3D12Device4_EnqueueMakeResident(This,Flags,NumObjects,ppObjects,pFenceToSignal,FenceValueToSignal)	\
+    ( (This)->lpVtbl -> EnqueueMakeResident(This,Flags,NumObjects,ppObjects,pFenceToSignal,FenceValueToSignal) ) 
+
+
+#define ID3D12Device4_CreateCommandList1(This,nodeMask,type,flags,riid,ppCommandList)	\
+    ( (This)->lpVtbl -> CreateCommandList1(This,nodeMask,type,flags,riid,ppCommandList) ) 
+
+#define ID3D12Device4_CreateProtectedResourceSession(This,pDesc,riid,ppSession)	\
+    ( (This)->lpVtbl -> CreateProtectedResourceSession(This,pDesc,riid,ppSession) ) 
+
+#define ID3D12Device4_CreateCommittedResource1(This,pHeapProperties,HeapFlags,pDesc,InitialResourceState,pOptimizedClearValue,pProtectedSession,riidResource,ppvResource)	\
+    ( (This)->lpVtbl -> CreateCommittedResource1(This,pHeapProperties,HeapFlags,pDesc,InitialResourceState,pOptimizedClearValue,pProtectedSession,riidResource,ppvResource) ) 
+
+#define ID3D12Device4_CreateHeap1(This,pDesc,pProtectedSession,riid,ppvHeap)	\
+    ( (This)->lpVtbl -> CreateHeap1(This,pDesc,pProtectedSession,riid,ppvHeap) ) 
+
+#define ID3D12Device4_CreateReservedResource1(This,pDesc,InitialState,pOptimizedClearValue,pProtectedSession,riid,ppvResource)	\
+    ( (This)->lpVtbl -> CreateReservedResource1(This,pDesc,InitialState,pOptimizedClearValue,pProtectedSession,riid,ppvResource) ) 
+#if !defined(_WIN32)
+
+#define ID3D12Device4_GetResourceAllocationInfo1(This,visibleMask,numResourceDescs,pResourceDescs,pResourceAllocationInfo1)	\
+    ( (This)->lpVtbl -> GetResourceAllocationInfo1(This,visibleMask,numResourceDescs,pResourceDescs,pResourceAllocationInfo1) ) 
+#else
+#define ID3D12Device4_GetResourceAllocationInfo1(This,RetVal,visibleMask,numResourceDescs,pResourceDescs,pResourceAllocationInfo1)	\
+    ( (This)->lpVtbl -> GetResourceAllocationInfo1(This,RetVal,visibleMask,numResourceDescs,pResourceDescs,pResourceAllocationInfo1) ) 
+#endif
+
+#endif /* COBJMACROS */
+
+
+#endif 	/* C style interface */
+
+
+
+
+#endif 	/* __ID3D12Device4_INTERFACE_DEFINED__ */
+
+
+/* interface __MIDL_itf_d3d12_0000_0029 */
+/* [local] */ 
+
+typedef 
+enum D3D12_LIFETIME_STATE
+    {
+        D3D12_LIFETIME_STATE_IN_USE	= 0,
+        D3D12_LIFETIME_STATE_NOT_IN_USE	= ( D3D12_LIFETIME_STATE_IN_USE + 1 ) 
+    } 	D3D12_LIFETIME_STATE;
+
+
+
+
+extern RPC_IF_HANDLE __MIDL_itf_d3d12_0000_0029_v0_0_c_ifspec;
+extern RPC_IF_HANDLE __MIDL_itf_d3d12_0000_0029_v0_0_s_ifspec;
+
+#ifndef __ID3D12LifetimeOwner_INTERFACE_DEFINED__
+#define __ID3D12LifetimeOwner_INTERFACE_DEFINED__
+
+/* interface ID3D12LifetimeOwner */
+/* [unique][local][object][uuid] */ 
+
+
+EXTERN_C const IID IID_ID3D12LifetimeOwner;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("e667af9f-cd56-4f46-83ce-032e595d70a8")
+    ID3D12LifetimeOwner : public IUnknown
+    {
+    public:
+        virtual void STDMETHODCALLTYPE LifetimeStateUpdated( 
+            D3D12_LIFETIME_STATE NewState) = 0;
+        
+    };
+    
+    
+#else 	/* C style interface */
+
+    typedef struct ID3D12LifetimeOwnerVtbl
+    {
+        BEGIN_INTERFACE
+        
+        DECLSPEC_XFGVIRT(IUnknown, QueryInterface)
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            ID3D12LifetimeOwner * This,
+            REFIID riid,
+            _COM_Outptr_  void **ppvObject);
+        
+        DECLSPEC_XFGVIRT(IUnknown, AddRef)
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            ID3D12LifetimeOwner * This);
+        
+        DECLSPEC_XFGVIRT(IUnknown, Release)
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            ID3D12LifetimeOwner * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12LifetimeOwner, LifetimeStateUpdated)
+        void ( STDMETHODCALLTYPE *LifetimeStateUpdated )( 
+            ID3D12LifetimeOwner * This,
+            D3D12_LIFETIME_STATE NewState);
+        
+        END_INTERFACE
+    } ID3D12LifetimeOwnerVtbl;
+
+    interface ID3D12LifetimeOwner
+    {
+        CONST_VTBL struct ID3D12LifetimeOwnerVtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define ID3D12LifetimeOwner_QueryInterface(This,riid,ppvObject)	\
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define ID3D12LifetimeOwner_AddRef(This)	\
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define ID3D12LifetimeOwner_Release(This)	\
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#define ID3D12LifetimeOwner_LifetimeStateUpdated(This,NewState)	\
+    ( (This)->lpVtbl -> LifetimeStateUpdated(This,NewState) ) 
+
+#endif /* COBJMACROS */
+
+
+#endif 	/* C style interface */
+
+
+
+
+#endif 	/* __ID3D12LifetimeOwner_INTERFACE_DEFINED__ */
+
+
+#ifndef __ID3D12SwapChainAssistant_INTERFACE_DEFINED__
+#define __ID3D12SwapChainAssistant_INTERFACE_DEFINED__
+
+/* interface ID3D12SwapChainAssistant */
+/* [unique][local][object][uuid] */ 
+
+
+EXTERN_C const IID IID_ID3D12SwapChainAssistant;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("f1df64b6-57fd-49cd-8807-c0eb88b45c8f")
+    ID3D12SwapChainAssistant : public IUnknown
+    {
+    public:
+#if defined(_MSC_VER) || !defined(_WIN32)
+        virtual LUID STDMETHODCALLTYPE GetLUID( void) = 0;
+#else
+        virtual LUID *STDMETHODCALLTYPE GetLUID( 
+            LUID * RetVal) = 0;
+#endif
+        
+        virtual HRESULT STDMETHODCALLTYPE GetSwapChainObject( 
+            REFIID riid,
+            _COM_Outptr_  void **ppv) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE GetCurrentResourceAndCommandQueue( 
+            REFIID riidResource,
+            _COM_Outptr_  void **ppvResource,
+            REFIID riidQueue,
+            _COM_Outptr_  void **ppvQueue) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE InsertImplicitSync( void) = 0;
+        
+    };
+    
+    
+#else 	/* C style interface */
+
+    typedef struct ID3D12SwapChainAssistantVtbl
+    {
+        BEGIN_INTERFACE
+        
+        DECLSPEC_XFGVIRT(IUnknown, QueryInterface)
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            ID3D12SwapChainAssistant * This,
+            REFIID riid,
+            _COM_Outptr_  void **ppvObject);
+        
+        DECLSPEC_XFGVIRT(IUnknown, AddRef)
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            ID3D12SwapChainAssistant * This);
+        
+        DECLSPEC_XFGVIRT(IUnknown, Release)
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            ID3D12SwapChainAssistant * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12SwapChainAssistant, GetLUID)
+#if !defined(_WIN32)
+        LUID ( STDMETHODCALLTYPE *GetLUID )( 
+            ID3D12SwapChainAssistant * This);
+        
+#else
+        LUID *( STDMETHODCALLTYPE *GetLUID )( 
+            ID3D12SwapChainAssistant * This,
+            LUID * RetVal);
+        
+#endif
+        
+        DECLSPEC_XFGVIRT(ID3D12SwapChainAssistant, GetSwapChainObject)
+        HRESULT ( STDMETHODCALLTYPE *GetSwapChainObject )( 
+            ID3D12SwapChainAssistant * This,
+            REFIID riid,
+            _COM_Outptr_  void **ppv);
+        
+        DECLSPEC_XFGVIRT(ID3D12SwapChainAssistant, GetCurrentResourceAndCommandQueue)
+        HRESULT ( STDMETHODCALLTYPE *GetCurrentResourceAndCommandQueue )( 
+            ID3D12SwapChainAssistant * This,
+            REFIID riidResource,
+            _COM_Outptr_  void **ppvResource,
+            REFIID riidQueue,
+            _COM_Outptr_  void **ppvQueue);
+        
+        DECLSPEC_XFGVIRT(ID3D12SwapChainAssistant, InsertImplicitSync)
+        HRESULT ( STDMETHODCALLTYPE *InsertImplicitSync )( 
+            ID3D12SwapChainAssistant * This);
+        
+        END_INTERFACE
+    } ID3D12SwapChainAssistantVtbl;
+
+    interface ID3D12SwapChainAssistant
+    {
+        CONST_VTBL struct ID3D12SwapChainAssistantVtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define ID3D12SwapChainAssistant_QueryInterface(This,riid,ppvObject)	\
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define ID3D12SwapChainAssistant_AddRef(This)	\
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define ID3D12SwapChainAssistant_Release(This)	\
+    ( (This)->lpVtbl -> Release(This) ) 
+
+#if !defined(_WIN32)
+
+#define ID3D12SwapChainAssistant_GetLUID(This)	\
+    ( (This)->lpVtbl -> GetLUID(This) ) 
+#else
+#define ID3D12SwapChainAssistant_GetLUID(This,RetVal)	\
+    ( (This)->lpVtbl -> GetLUID(This,RetVal) ) 
+#endif
+
+#define ID3D12SwapChainAssistant_GetSwapChainObject(This,riid,ppv)	\
+    ( (This)->lpVtbl -> GetSwapChainObject(This,riid,ppv) ) 
+
+#define ID3D12SwapChainAssistant_GetCurrentResourceAndCommandQueue(This,riidResource,ppvResource,riidQueue,ppvQueue)	\
+    ( (This)->lpVtbl -> GetCurrentResourceAndCommandQueue(This,riidResource,ppvResource,riidQueue,ppvQueue) ) 
+
+#define ID3D12SwapChainAssistant_InsertImplicitSync(This)	\
+    ( (This)->lpVtbl -> InsertImplicitSync(This) ) 
+
+#endif /* COBJMACROS */
+
+
+#endif 	/* C style interface */
+
+
+
+
+#endif 	/* __ID3D12SwapChainAssistant_INTERFACE_DEFINED__ */
+
+
+#ifndef __ID3D12LifetimeTracker_INTERFACE_DEFINED__
+#define __ID3D12LifetimeTracker_INTERFACE_DEFINED__
+
+/* interface ID3D12LifetimeTracker */
+/* [unique][local][object][uuid] */ 
+
+
+EXTERN_C const IID IID_ID3D12LifetimeTracker;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("3fd03d36-4eb1-424a-a582-494ecb8ba813")
+    ID3D12LifetimeTracker : public ID3D12DeviceChild
+    {
+    public:
+        virtual HRESULT STDMETHODCALLTYPE DestroyOwnedObject( 
+            _In_  ID3D12DeviceChild *pObject) = 0;
+        
+    };
+    
+    
+#else 	/* C style interface */
+
+    typedef struct ID3D12LifetimeTrackerVtbl
+    {
+        BEGIN_INTERFACE
+        
+        DECLSPEC_XFGVIRT(IUnknown, QueryInterface)
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            ID3D12LifetimeTracker * This,
+            REFIID riid,
+            _COM_Outptr_  void **ppvObject);
+        
+        DECLSPEC_XFGVIRT(IUnknown, AddRef)
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            ID3D12LifetimeTracker * This);
+        
+        DECLSPEC_XFGVIRT(IUnknown, Release)
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            ID3D12LifetimeTracker * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, GetPrivateData)
+        HRESULT ( STDMETHODCALLTYPE *GetPrivateData )( 
+            ID3D12LifetimeTracker * This,
+            _In_  REFGUID guid,
+            _Inout_  UINT *pDataSize,
+            _Out_writes_bytes_opt_( *pDataSize )  void *pData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, SetPrivateData)
+        HRESULT ( STDMETHODCALLTYPE *SetPrivateData )( 
+            ID3D12LifetimeTracker * This,
+            _In_  REFGUID guid,
+            _In_  UINT DataSize,
+            _In_reads_bytes_opt_( DataSize )  const void *pData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, SetPrivateDataInterface)
+        HRESULT ( STDMETHODCALLTYPE *SetPrivateDataInterface )( 
+            ID3D12LifetimeTracker * This,
+            _In_  REFGUID guid,
+            _In_opt_  const IUnknown *pData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, SetName)
+        HRESULT ( STDMETHODCALLTYPE *SetName )( 
+            ID3D12LifetimeTracker * This,
+            _In_z_  LPCWSTR Name);
+        
+        DECLSPEC_XFGVIRT(ID3D12DeviceChild, GetDevice)
+        HRESULT ( STDMETHODCALLTYPE *GetDevice )( 
+            ID3D12LifetimeTracker * This,
+            REFIID riid,
+            _COM_Outptr_opt_  void **ppvDevice);
+        
+        DECLSPEC_XFGVIRT(ID3D12LifetimeTracker, DestroyOwnedObject)
+        HRESULT ( STDMETHODCALLTYPE *DestroyOwnedObject )( 
+            ID3D12LifetimeTracker * This,
+            _In_  ID3D12DeviceChild *pObject);
+        
+        END_INTERFACE
+    } ID3D12LifetimeTrackerVtbl;
+
+    interface ID3D12LifetimeTracker
+    {
+        CONST_VTBL struct ID3D12LifetimeTrackerVtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define ID3D12LifetimeTracker_QueryInterface(This,riid,ppvObject)	\
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define ID3D12LifetimeTracker_AddRef(This)	\
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define ID3D12LifetimeTracker_Release(This)	\
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#define ID3D12LifetimeTracker_GetPrivateData(This,guid,pDataSize,pData)	\
+    ( (This)->lpVtbl -> GetPrivateData(This,guid,pDataSize,pData) ) 
+
+#define ID3D12LifetimeTracker_SetPrivateData(This,guid,DataSize,pData)	\
+    ( (This)->lpVtbl -> SetPrivateData(This,guid,DataSize,pData) ) 
+
+#define ID3D12LifetimeTracker_SetPrivateDataInterface(This,guid,pData)	\
+    ( (This)->lpVtbl -> SetPrivateDataInterface(This,guid,pData) ) 
+
+#define ID3D12LifetimeTracker_SetName(This,Name)	\
+    ( (This)->lpVtbl -> SetName(This,Name) ) 
+
+
+#define ID3D12LifetimeTracker_GetDevice(This,riid,ppvDevice)	\
+    ( (This)->lpVtbl -> GetDevice(This,riid,ppvDevice) ) 
+
+
+#define ID3D12LifetimeTracker_DestroyOwnedObject(This,pObject)	\
+    ( (This)->lpVtbl -> DestroyOwnedObject(This,pObject) ) 
+
+#endif /* COBJMACROS */
+
+
+#endif 	/* C style interface */
+
+
+
+
+#endif 	/* __ID3D12LifetimeTracker_INTERFACE_DEFINED__ */
+
+
+/* interface __MIDL_itf_d3d12_0000_0032 */
+/* [local] */ 
+
+typedef 
+enum D3D12_META_COMMAND_PARAMETER_TYPE
+    {
+        D3D12_META_COMMAND_PARAMETER_TYPE_FLOAT	= 0,
+        D3D12_META_COMMAND_PARAMETER_TYPE_UINT64	= 1,
+        D3D12_META_COMMAND_PARAMETER_TYPE_GPU_VIRTUAL_ADDRESS	= 2,
+        D3D12_META_COMMAND_PARAMETER_TYPE_CPU_DESCRIPTOR_HANDLE_HEAP_TYPE_CBV_SRV_UAV	= 3,
+        D3D12_META_COMMAND_PARAMETER_TYPE_GPU_DESCRIPTOR_HANDLE_HEAP_TYPE_CBV_SRV_UAV	= 4
+    } 	D3D12_META_COMMAND_PARAMETER_TYPE;
+
+typedef 
+enum D3D12_META_COMMAND_PARAMETER_FLAGS
+    {
+        D3D12_META_COMMAND_PARAMETER_FLAG_INPUT	= 0x1,
+        D3D12_META_COMMAND_PARAMETER_FLAG_OUTPUT	= 0x2
+    } 	D3D12_META_COMMAND_PARAMETER_FLAGS;
+
+DEFINE_ENUM_FLAG_OPERATORS( D3D12_META_COMMAND_PARAMETER_FLAGS );
+typedef 
+enum D3D12_META_COMMAND_PARAMETER_STAGE
+    {
+        D3D12_META_COMMAND_PARAMETER_STAGE_CREATION	= 0,
+        D3D12_META_COMMAND_PARAMETER_STAGE_INITIALIZATION	= 1,
+        D3D12_META_COMMAND_PARAMETER_STAGE_EXECUTION	= 2
+    } 	D3D12_META_COMMAND_PARAMETER_STAGE;
+
+typedef struct D3D12_META_COMMAND_PARAMETER_DESC
+    {
+    LPCWSTR Name;
+    D3D12_META_COMMAND_PARAMETER_TYPE Type;
+    D3D12_META_COMMAND_PARAMETER_FLAGS Flags;
+    D3D12_RESOURCE_STATES RequiredResourceState;
+    UINT StructureOffset;
+    } 	D3D12_META_COMMAND_PARAMETER_DESC;
+
+typedef 
+enum D3D12_GRAPHICS_STATES
+    {
+        D3D12_GRAPHICS_STATE_NONE	= 0,
+        D3D12_GRAPHICS_STATE_IA_VERTEX_BUFFERS	= ( 1 << 0 ) ,
+        D3D12_GRAPHICS_STATE_IA_INDEX_BUFFER	= ( 1 << 1 ) ,
+        D3D12_GRAPHICS_STATE_IA_PRIMITIVE_TOPOLOGY	= ( 1 << 2 ) ,
+        D3D12_GRAPHICS_STATE_DESCRIPTOR_HEAP	= ( 1 << 3 ) ,
+        D3D12_GRAPHICS_STATE_GRAPHICS_ROOT_SIGNATURE	= ( 1 << 4 ) ,
+        D3D12_GRAPHICS_STATE_COMPUTE_ROOT_SIGNATURE	= ( 1 << 5 ) ,
+        D3D12_GRAPHICS_STATE_RS_VIEWPORTS	= ( 1 << 6 ) ,
+        D3D12_GRAPHICS_STATE_RS_SCISSOR_RECTS	= ( 1 << 7 ) ,
+        D3D12_GRAPHICS_STATE_PREDICATION	= ( 1 << 8 ) ,
+        D3D12_GRAPHICS_STATE_OM_RENDER_TARGETS	= ( 1 << 9 ) ,
+        D3D12_GRAPHICS_STATE_OM_STENCIL_REF	= ( 1 << 10 ) ,
+        D3D12_GRAPHICS_STATE_OM_BLEND_FACTOR	= ( 1 << 11 ) ,
+        D3D12_GRAPHICS_STATE_PIPELINE_STATE	= ( 1 << 12 ) ,
+        D3D12_GRAPHICS_STATE_SO_TARGETS	= ( 1 << 13 ) ,
+        D3D12_GRAPHICS_STATE_OM_DEPTH_BOUNDS	= ( 1 << 14 ) ,
+        D3D12_GRAPHICS_STATE_SAMPLE_POSITIONS	= ( 1 << 15 ) ,
+        D3D12_GRAPHICS_STATE_VIEW_INSTANCE_MASK	= ( 1 << 16 ) 
+    } 	D3D12_GRAPHICS_STATES;
+
+DEFINE_ENUM_FLAG_OPERATORS( D3D12_GRAPHICS_STATES );
+typedef struct D3D12_META_COMMAND_DESC
+    {
+    GUID Id;
+    LPCWSTR Name;
+    D3D12_GRAPHICS_STATES InitializationDirtyState;
+    D3D12_GRAPHICS_STATES ExecutionDirtyState;
+    } 	D3D12_META_COMMAND_DESC;
+
+
+
+extern RPC_IF_HANDLE __MIDL_itf_d3d12_0000_0032_v0_0_c_ifspec;
+extern RPC_IF_HANDLE __MIDL_itf_d3d12_0000_0032_v0_0_s_ifspec;
+
+#ifndef __ID3D12StateObject_INTERFACE_DEFINED__
+#define __ID3D12StateObject_INTERFACE_DEFINED__
+
+/* interface ID3D12StateObject */
+/* [unique][local][object][uuid] */ 
+
+
+EXTERN_C const IID IID_ID3D12StateObject;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("47016943-fca8-4594-93ea-af258b55346d")
+    ID3D12StateObject : public ID3D12Pageable
+    {
+    public:
+    };
+    
+    
+#else 	/* C style interface */
+
+    typedef struct ID3D12StateObjectVtbl
+    {
+        BEGIN_INTERFACE
+        
+        DECLSPEC_XFGVIRT(IUnknown, QueryInterface)
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            ID3D12StateObject * This,
+            REFIID riid,
+            _COM_Outptr_  void **ppvObject);
+        
+        DECLSPEC_XFGVIRT(IUnknown, AddRef)
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            ID3D12StateObject * This);
+        
+        DECLSPEC_XFGVIRT(IUnknown, Release)
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            ID3D12StateObject * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, GetPrivateData)
+        HRESULT ( STDMETHODCALLTYPE *GetPrivateData )( 
+            ID3D12StateObject * This,
+            _In_  REFGUID guid,
+            _Inout_  UINT *pDataSize,
+            _Out_writes_bytes_opt_( *pDataSize )  void *pData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, SetPrivateData)
+        HRESULT ( STDMETHODCALLTYPE *SetPrivateData )( 
+            ID3D12StateObject * This,
+            _In_  REFGUID guid,
+            _In_  UINT DataSize,
+            _In_reads_bytes_opt_( DataSize )  const void *pData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, SetPrivateDataInterface)
+        HRESULT ( STDMETHODCALLTYPE *SetPrivateDataInterface )( 
+            ID3D12StateObject * This,
+            _In_  REFGUID guid,
+            _In_opt_  const IUnknown *pData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, SetName)
+        HRESULT ( STDMETHODCALLTYPE *SetName )( 
+            ID3D12StateObject * This,
+            _In_z_  LPCWSTR Name);
+        
+        DECLSPEC_XFGVIRT(ID3D12DeviceChild, GetDevice)
+        HRESULT ( STDMETHODCALLTYPE *GetDevice )( 
+            ID3D12StateObject * This,
+            REFIID riid,
+            _COM_Outptr_opt_  void **ppvDevice);
+        
+        END_INTERFACE
+    } ID3D12StateObjectVtbl;
+
+    interface ID3D12StateObject
+    {
+        CONST_VTBL struct ID3D12StateObjectVtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define ID3D12StateObject_QueryInterface(This,riid,ppvObject)	\
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define ID3D12StateObject_AddRef(This)	\
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define ID3D12StateObject_Release(This)	\
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#define ID3D12StateObject_GetPrivateData(This,guid,pDataSize,pData)	\
+    ( (This)->lpVtbl -> GetPrivateData(This,guid,pDataSize,pData) ) 
+
+#define ID3D12StateObject_SetPrivateData(This,guid,DataSize,pData)	\
+    ( (This)->lpVtbl -> SetPrivateData(This,guid,DataSize,pData) ) 
+
+#define ID3D12StateObject_SetPrivateDataInterface(This,guid,pData)	\
+    ( (This)->lpVtbl -> SetPrivateDataInterface(This,guid,pData) ) 
+
+#define ID3D12StateObject_SetName(This,Name)	\
+    ( (This)->lpVtbl -> SetName(This,Name) ) 
+
+
+#define ID3D12StateObject_GetDevice(This,riid,ppvDevice)	\
+    ( (This)->lpVtbl -> GetDevice(This,riid,ppvDevice) ) 
+
+
+
+#endif /* COBJMACROS */
+
+
+#endif 	/* C style interface */
+
+
+
+
+#endif 	/* __ID3D12StateObject_INTERFACE_DEFINED__ */
+
+
+#ifndef __ID3D12StateObjectProperties_INTERFACE_DEFINED__
+#define __ID3D12StateObjectProperties_INTERFACE_DEFINED__
+
+/* interface ID3D12StateObjectProperties */
+/* [unique][local][object][uuid] */ 
+
+
+EXTERN_C const IID IID_ID3D12StateObjectProperties;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("de5fa827-9bf9-4f26-89ff-d7f56fde3860")
+    ID3D12StateObjectProperties : public IUnknown
+    {
+    public:
+        virtual void *STDMETHODCALLTYPE GetShaderIdentifier( 
+            _In_  LPCWSTR pExportName) = 0;
+        
+        virtual UINT64 STDMETHODCALLTYPE GetShaderStackSize( 
+            _In_  LPCWSTR pExportName) = 0;
+        
+        virtual UINT64 STDMETHODCALLTYPE GetPipelineStackSize( void) = 0;
+        
+        virtual void STDMETHODCALLTYPE SetPipelineStackSize( 
+            UINT64 PipelineStackSizeInBytes) = 0;
+        
+    };
+    
+    
+#else 	/* C style interface */
+
+    typedef struct ID3D12StateObjectPropertiesVtbl
+    {
+        BEGIN_INTERFACE
+        
+        DECLSPEC_XFGVIRT(IUnknown, QueryInterface)
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            ID3D12StateObjectProperties * This,
+            REFIID riid,
+            _COM_Outptr_  void **ppvObject);
+        
+        DECLSPEC_XFGVIRT(IUnknown, AddRef)
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            ID3D12StateObjectProperties * This);
+        
+        DECLSPEC_XFGVIRT(IUnknown, Release)
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            ID3D12StateObjectProperties * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12StateObjectProperties, GetShaderIdentifier)
+        void *( STDMETHODCALLTYPE *GetShaderIdentifier )( 
+            ID3D12StateObjectProperties * This,
+            _In_  LPCWSTR pExportName);
+        
+        DECLSPEC_XFGVIRT(ID3D12StateObjectProperties, GetShaderStackSize)
+        UINT64 ( STDMETHODCALLTYPE *GetShaderStackSize )( 
+            ID3D12StateObjectProperties * This,
+            _In_  LPCWSTR pExportName);
+        
+        DECLSPEC_XFGVIRT(ID3D12StateObjectProperties, GetPipelineStackSize)
+        UINT64 ( STDMETHODCALLTYPE *GetPipelineStackSize )( 
+            ID3D12StateObjectProperties * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12StateObjectProperties, SetPipelineStackSize)
+        void ( STDMETHODCALLTYPE *SetPipelineStackSize )( 
+            ID3D12StateObjectProperties * This,
+            UINT64 PipelineStackSizeInBytes);
+        
+        END_INTERFACE
+    } ID3D12StateObjectPropertiesVtbl;
+
+    interface ID3D12StateObjectProperties
+    {
+        CONST_VTBL struct ID3D12StateObjectPropertiesVtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define ID3D12StateObjectProperties_QueryInterface(This,riid,ppvObject)	\
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define ID3D12StateObjectProperties_AddRef(This)	\
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define ID3D12StateObjectProperties_Release(This)	\
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#define ID3D12StateObjectProperties_GetShaderIdentifier(This,pExportName)	\
+    ( (This)->lpVtbl -> GetShaderIdentifier(This,pExportName) ) 
+
+#define ID3D12StateObjectProperties_GetShaderStackSize(This,pExportName)	\
+    ( (This)->lpVtbl -> GetShaderStackSize(This,pExportName) ) 
+
+#define ID3D12StateObjectProperties_GetPipelineStackSize(This)	\
+    ( (This)->lpVtbl -> GetPipelineStackSize(This) ) 
+
+#define ID3D12StateObjectProperties_SetPipelineStackSize(This,PipelineStackSizeInBytes)	\
+    ( (This)->lpVtbl -> SetPipelineStackSize(This,PipelineStackSizeInBytes) ) 
+
+#endif /* COBJMACROS */
+
+
+#endif 	/* C style interface */
+
+
+
+
+#endif 	/* __ID3D12StateObjectProperties_INTERFACE_DEFINED__ */
+
+
+/* interface __MIDL_itf_d3d12_0000_0034 */
+/* [local] */ 
+
+typedef 
+enum D3D12_STATE_SUBOBJECT_TYPE
+    {
+        D3D12_STATE_SUBOBJECT_TYPE_STATE_OBJECT_CONFIG	= 0,
+        D3D12_STATE_SUBOBJECT_TYPE_GLOBAL_ROOT_SIGNATURE	= 1,
+        D3D12_STATE_SUBOBJECT_TYPE_LOCAL_ROOT_SIGNATURE	= 2,
+        D3D12_STATE_SUBOBJECT_TYPE_NODE_MASK	= 3,
+        D3D12_STATE_SUBOBJECT_TYPE_DXIL_LIBRARY	= 5,
+        D3D12_STATE_SUBOBJECT_TYPE_EXISTING_COLLECTION	= 6,
+        D3D12_STATE_SUBOBJECT_TYPE_SUBOBJECT_TO_EXPORTS_ASSOCIATION	= 7,
+        D3D12_STATE_SUBOBJECT_TYPE_DXIL_SUBOBJECT_TO_EXPORTS_ASSOCIATION	= 8,
+        D3D12_STATE_SUBOBJECT_TYPE_RAYTRACING_SHADER_CONFIG	= 9,
+        D3D12_STATE_SUBOBJECT_TYPE_RAYTRACING_PIPELINE_CONFIG	= 10,
+        D3D12_STATE_SUBOBJECT_TYPE_HIT_GROUP	= 11,
+        D3D12_STATE_SUBOBJECT_TYPE_RAYTRACING_PIPELINE_CONFIG1	= 12,
+        D3D12_STATE_SUBOBJECT_TYPE_MAX_VALID	= ( D3D12_STATE_SUBOBJECT_TYPE_RAYTRACING_PIPELINE_CONFIG1 + 1 ) 
+    } 	D3D12_STATE_SUBOBJECT_TYPE;
+
+typedef struct D3D12_STATE_SUBOBJECT
+    {
+    D3D12_STATE_SUBOBJECT_TYPE Type;
+    const void *pDesc;
+    } 	D3D12_STATE_SUBOBJECT;
+
+typedef 
+enum D3D12_STATE_OBJECT_FLAGS
+    {
+        D3D12_STATE_OBJECT_FLAG_NONE	= 0,
+        D3D12_STATE_OBJECT_FLAG_ALLOW_LOCAL_DEPENDENCIES_ON_EXTERNAL_DEFINITIONS	= 0x1,
+        D3D12_STATE_OBJECT_FLAG_ALLOW_EXTERNAL_DEPENDENCIES_ON_LOCAL_DEFINITIONS	= 0x2,
+        D3D12_STATE_OBJECT_FLAG_ALLOW_STATE_OBJECT_ADDITIONS	= 0x4
+    } 	D3D12_STATE_OBJECT_FLAGS;
+
+DEFINE_ENUM_FLAG_OPERATORS( D3D12_STATE_OBJECT_FLAGS );
+typedef struct D3D12_STATE_OBJECT_CONFIG
+    {
+    D3D12_STATE_OBJECT_FLAGS Flags;
+    } 	D3D12_STATE_OBJECT_CONFIG;
+
+typedef struct D3D12_GLOBAL_ROOT_SIGNATURE
+    {
+    ID3D12RootSignature *pGlobalRootSignature;
+    } 	D3D12_GLOBAL_ROOT_SIGNATURE;
+
+typedef struct D3D12_LOCAL_ROOT_SIGNATURE
+    {
+    ID3D12RootSignature *pLocalRootSignature;
+    } 	D3D12_LOCAL_ROOT_SIGNATURE;
+
+typedef struct D3D12_NODE_MASK
+    {
+    UINT NodeMask;
+    } 	D3D12_NODE_MASK;
+
+typedef 
+enum D3D12_EXPORT_FLAGS
+    {
+        D3D12_EXPORT_FLAG_NONE	= 0
+    } 	D3D12_EXPORT_FLAGS;
+
+DEFINE_ENUM_FLAG_OPERATORS( D3D12_EXPORT_FLAGS );
+typedef struct D3D12_EXPORT_DESC
+    {
+    LPCWSTR Name;
+    _In_opt_  LPCWSTR ExportToRename;
+    D3D12_EXPORT_FLAGS Flags;
+    } 	D3D12_EXPORT_DESC;
+
+typedef struct D3D12_DXIL_LIBRARY_DESC
+    {
+    D3D12_SHADER_BYTECODE DXILLibrary;
+    UINT NumExports;
+    _In_reads_(NumExports)  D3D12_EXPORT_DESC *pExports;
+    } 	D3D12_DXIL_LIBRARY_DESC;
+
+typedef struct D3D12_EXISTING_COLLECTION_DESC
+    {
+    ID3D12StateObject *pExistingCollection;
+    UINT NumExports;
+    _In_reads_(NumExports)  D3D12_EXPORT_DESC *pExports;
+    } 	D3D12_EXISTING_COLLECTION_DESC;
+
+typedef struct D3D12_SUBOBJECT_TO_EXPORTS_ASSOCIATION
+    {
+    const D3D12_STATE_SUBOBJECT *pSubobjectToAssociate;
+    UINT NumExports;
+    _In_reads_(NumExports)  LPCWSTR *pExports;
+    } 	D3D12_SUBOBJECT_TO_EXPORTS_ASSOCIATION;
+
+typedef struct D3D12_DXIL_SUBOBJECT_TO_EXPORTS_ASSOCIATION
+    {
+    LPCWSTR SubobjectToAssociate;
+    UINT NumExports;
+    _In_reads_(NumExports)  LPCWSTR *pExports;
+    } 	D3D12_DXIL_SUBOBJECT_TO_EXPORTS_ASSOCIATION;
+
+typedef 
+enum D3D12_HIT_GROUP_TYPE
+    {
+        D3D12_HIT_GROUP_TYPE_TRIANGLES	= 0,
+        D3D12_HIT_GROUP_TYPE_PROCEDURAL_PRIMITIVE	= 0x1
+    } 	D3D12_HIT_GROUP_TYPE;
+
+typedef struct D3D12_HIT_GROUP_DESC
+    {
+    LPCWSTR HitGroupExport;
+    D3D12_HIT_GROUP_TYPE Type;
+    _In_opt_  LPCWSTR AnyHitShaderImport;
+    _In_opt_  LPCWSTR ClosestHitShaderImport;
+    _In_opt_  LPCWSTR IntersectionShaderImport;
+    } 	D3D12_HIT_GROUP_DESC;
+
+typedef struct D3D12_RAYTRACING_SHADER_CONFIG
+    {
+    UINT MaxPayloadSizeInBytes;
+    UINT MaxAttributeSizeInBytes;
+    } 	D3D12_RAYTRACING_SHADER_CONFIG;
+
+typedef struct D3D12_RAYTRACING_PIPELINE_CONFIG
+    {
+    UINT MaxTraceRecursionDepth;
+    } 	D3D12_RAYTRACING_PIPELINE_CONFIG;
+
+typedef 
+enum D3D12_RAYTRACING_PIPELINE_FLAGS
+    {
+        D3D12_RAYTRACING_PIPELINE_FLAG_NONE	= 0,
+        D3D12_RAYTRACING_PIPELINE_FLAG_SKIP_TRIANGLES	= 0x100,
+        D3D12_RAYTRACING_PIPELINE_FLAG_SKIP_PROCEDURAL_PRIMITIVES	= 0x200
+    } 	D3D12_RAYTRACING_PIPELINE_FLAGS;
+
+DEFINE_ENUM_FLAG_OPERATORS( D3D12_RAYTRACING_PIPELINE_FLAGS );
+typedef struct D3D12_RAYTRACING_PIPELINE_CONFIG1
+    {
+    UINT MaxTraceRecursionDepth;
+    D3D12_RAYTRACING_PIPELINE_FLAGS Flags;
+    } 	D3D12_RAYTRACING_PIPELINE_CONFIG1;
+
+typedef 
+enum D3D12_STATE_OBJECT_TYPE
+    {
+        D3D12_STATE_OBJECT_TYPE_COLLECTION	= 0,
+        D3D12_STATE_OBJECT_TYPE_RAYTRACING_PIPELINE	= 3
+    } 	D3D12_STATE_OBJECT_TYPE;
+
+typedef struct D3D12_STATE_OBJECT_DESC
+    {
+    D3D12_STATE_OBJECT_TYPE Type;
+    UINT NumSubobjects;
+    _In_reads_(NumSubobjects)  const D3D12_STATE_SUBOBJECT *pSubobjects;
+    } 	D3D12_STATE_OBJECT_DESC;
+
+typedef 
+enum D3D12_RAYTRACING_GEOMETRY_FLAGS
+    {
+        D3D12_RAYTRACING_GEOMETRY_FLAG_NONE	= 0,
+        D3D12_RAYTRACING_GEOMETRY_FLAG_OPAQUE	= 0x1,
+        D3D12_RAYTRACING_GEOMETRY_FLAG_NO_DUPLICATE_ANYHIT_INVOCATION	= 0x2
+    } 	D3D12_RAYTRACING_GEOMETRY_FLAGS;
+
+DEFINE_ENUM_FLAG_OPERATORS( D3D12_RAYTRACING_GEOMETRY_FLAGS );
+typedef 
+enum D3D12_RAYTRACING_GEOMETRY_TYPE
+    {
+        D3D12_RAYTRACING_GEOMETRY_TYPE_TRIANGLES	= 0,
+        D3D12_RAYTRACING_GEOMETRY_TYPE_PROCEDURAL_PRIMITIVE_AABBS	= ( D3D12_RAYTRACING_GEOMETRY_TYPE_TRIANGLES + 1 ) 
+    } 	D3D12_RAYTRACING_GEOMETRY_TYPE;
+
+typedef 
+enum D3D12_RAYTRACING_INSTANCE_FLAGS
+    {
+        D3D12_RAYTRACING_INSTANCE_FLAG_NONE	= 0,
+        D3D12_RAYTRACING_INSTANCE_FLAG_TRIANGLE_CULL_DISABLE	= 0x1,
+        D3D12_RAYTRACING_INSTANCE_FLAG_TRIANGLE_FRONT_COUNTERCLOCKWISE	= 0x2,
+        D3D12_RAYTRACING_INSTANCE_FLAG_FORCE_OPAQUE	= 0x4,
+        D3D12_RAYTRACING_INSTANCE_FLAG_FORCE_NON_OPAQUE	= 0x8
+    } 	D3D12_RAYTRACING_INSTANCE_FLAGS;
+
+DEFINE_ENUM_FLAG_OPERATORS( D3D12_RAYTRACING_INSTANCE_FLAGS );
+typedef struct D3D12_GPU_VIRTUAL_ADDRESS_AND_STRIDE
+    {
+    D3D12_GPU_VIRTUAL_ADDRESS StartAddress;
+    UINT64 StrideInBytes;
+    } 	D3D12_GPU_VIRTUAL_ADDRESS_AND_STRIDE;
+
+typedef struct D3D12_GPU_VIRTUAL_ADDRESS_RANGE
+    {
+    D3D12_GPU_VIRTUAL_ADDRESS StartAddress;
+    UINT64 SizeInBytes;
+    } 	D3D12_GPU_VIRTUAL_ADDRESS_RANGE;
+
+typedef struct D3D12_GPU_VIRTUAL_ADDRESS_RANGE_AND_STRIDE
+    {
+    D3D12_GPU_VIRTUAL_ADDRESS StartAddress;
+    UINT64 SizeInBytes;
+    UINT64 StrideInBytes;
+    } 	D3D12_GPU_VIRTUAL_ADDRESS_RANGE_AND_STRIDE;
+
+typedef struct D3D12_RAYTRACING_GEOMETRY_TRIANGLES_DESC
+    {
+    D3D12_GPU_VIRTUAL_ADDRESS Transform3x4;
+    DXGI_FORMAT IndexFormat;
+    DXGI_FORMAT VertexFormat;
+    UINT IndexCount;
+    UINT VertexCount;
+    D3D12_GPU_VIRTUAL_ADDRESS IndexBuffer;
+    D3D12_GPU_VIRTUAL_ADDRESS_AND_STRIDE VertexBuffer;
+    } 	D3D12_RAYTRACING_GEOMETRY_TRIANGLES_DESC;
+
+typedef struct D3D12_RAYTRACING_AABB
+    {
+    FLOAT MinX;
+    FLOAT MinY;
+    FLOAT MinZ;
+    FLOAT MaxX;
+    FLOAT MaxY;
+    FLOAT MaxZ;
+    } 	D3D12_RAYTRACING_AABB;
+
+typedef struct D3D12_RAYTRACING_GEOMETRY_AABBS_DESC
+    {
+    UINT64 AABBCount;
+    D3D12_GPU_VIRTUAL_ADDRESS_AND_STRIDE AABBs;
+    } 	D3D12_RAYTRACING_GEOMETRY_AABBS_DESC;
+
+typedef 
+enum D3D12_RAYTRACING_ACCELERATION_STRUCTURE_BUILD_FLAGS
+    {
+        D3D12_RAYTRACING_ACCELERATION_STRUCTURE_BUILD_FLAG_NONE	= 0,
+        D3D12_RAYTRACING_ACCELERATION_STRUCTURE_BUILD_FLAG_ALLOW_UPDATE	= 0x1,
+        D3D12_RAYTRACING_ACCELERATION_STRUCTURE_BUILD_FLAG_ALLOW_COMPACTION	= 0x2,
+        D3D12_RAYTRACING_ACCELERATION_STRUCTURE_BUILD_FLAG_PREFER_FAST_TRACE	= 0x4,
+        D3D12_RAYTRACING_ACCELERATION_STRUCTURE_BUILD_FLAG_PREFER_FAST_BUILD	= 0x8,
+        D3D12_RAYTRACING_ACCELERATION_STRUCTURE_BUILD_FLAG_MINIMIZE_MEMORY	= 0x10,
+        D3D12_RAYTRACING_ACCELERATION_STRUCTURE_BUILD_FLAG_PERFORM_UPDATE	= 0x20
+    } 	D3D12_RAYTRACING_ACCELERATION_STRUCTURE_BUILD_FLAGS;
+
+DEFINE_ENUM_FLAG_OPERATORS( D3D12_RAYTRACING_ACCELERATION_STRUCTURE_BUILD_FLAGS );
+typedef 
+enum D3D12_RAYTRACING_ACCELERATION_STRUCTURE_COPY_MODE
+    {
+        D3D12_RAYTRACING_ACCELERATION_STRUCTURE_COPY_MODE_CLONE	= 0,
+        D3D12_RAYTRACING_ACCELERATION_STRUCTURE_COPY_MODE_COMPACT	= 0x1,
+        D3D12_RAYTRACING_ACCELERATION_STRUCTURE_COPY_MODE_VISUALIZATION_DECODE_FOR_TOOLS	= 0x2,
+        D3D12_RAYTRACING_ACCELERATION_STRUCTURE_COPY_MODE_SERIALIZE	= 0x3,
+        D3D12_RAYTRACING_ACCELERATION_STRUCTURE_COPY_MODE_DESERIALIZE	= 0x4
+    } 	D3D12_RAYTRACING_ACCELERATION_STRUCTURE_COPY_MODE;
+
+typedef 
+enum D3D12_RAYTRACING_ACCELERATION_STRUCTURE_TYPE
+    {
+        D3D12_RAYTRACING_ACCELERATION_STRUCTURE_TYPE_TOP_LEVEL	= 0,
+        D3D12_RAYTRACING_ACCELERATION_STRUCTURE_TYPE_BOTTOM_LEVEL	= 0x1
+    } 	D3D12_RAYTRACING_ACCELERATION_STRUCTURE_TYPE;
+
+typedef 
+enum D3D12_ELEMENTS_LAYOUT
+    {
+        D3D12_ELEMENTS_LAYOUT_ARRAY	= 0,
+        D3D12_ELEMENTS_LAYOUT_ARRAY_OF_POINTERS	= 0x1
+    } 	D3D12_ELEMENTS_LAYOUT;
+
+typedef 
+enum D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_TYPE
+    {
+        D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_COMPACTED_SIZE	= 0,
+        D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_TOOLS_VISUALIZATION	= 0x1,
+        D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_SERIALIZATION	= 0x2,
+        D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_CURRENT_SIZE	= 0x3
+    } 	D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_TYPE;
+
+typedef struct D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_DESC
+    {
+    D3D12_GPU_VIRTUAL_ADDRESS DestBuffer;
+    D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_TYPE InfoType;
+    } 	D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_DESC;
+
+typedef struct D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_COMPACTED_SIZE_DESC
+    {
+    UINT64 CompactedSizeInBytes;
+    } 	D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_COMPACTED_SIZE_DESC;
+
+typedef struct D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_TOOLS_VISUALIZATION_DESC
+    {
+    UINT64 DecodedSizeInBytes;
+    } 	D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_TOOLS_VISUALIZATION_DESC;
+
+typedef struct D3D12_BUILD_RAYTRACING_ACCELERATION_STRUCTURE_TOOLS_VISUALIZATION_HEADER
+    {
+    D3D12_RAYTRACING_ACCELERATION_STRUCTURE_TYPE Type;
+    UINT NumDescs;
+    } 	D3D12_BUILD_RAYTRACING_ACCELERATION_STRUCTURE_TOOLS_VISUALIZATION_HEADER;
+
+// Regarding D3D12_BUILD_RAY_TRACING_ACCELERATION_STRUCTURE_TOOLS_VISUALIZATION_HEADER above,
+// depending on Type field, NumDescs above is followed by either:
+//       D3D12_RAY_TRACING_INSTANCE_DESC InstanceDescs[NumDescs]
+//    or D3D12_RAY_TRACING_GEOMETRY_DESC GeometryDescs[NumDescs].
+// There is 4 bytes of padding between GeometryDesc structs in the array so alignment is natural when viewed by CPU.
+
+typedef struct D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_SERIALIZATION_DESC
+    {
+    UINT64 SerializedSizeInBytes;
+    UINT64 NumBottomLevelAccelerationStructurePointers;
+    } 	D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_SERIALIZATION_DESC;
+
+typedef struct D3D12_SERIALIZED_DATA_DRIVER_MATCHING_IDENTIFIER
+    {
+    GUID DriverOpaqueGUID;
+    BYTE DriverOpaqueVersioningData[ 16 ];
+    } 	D3D12_SERIALIZED_DATA_DRIVER_MATCHING_IDENTIFIER;
+
+typedef 
+enum D3D12_SERIALIZED_DATA_TYPE
+    {
+        D3D12_SERIALIZED_DATA_RAYTRACING_ACCELERATION_STRUCTURE	= 0
+    } 	D3D12_SERIALIZED_DATA_TYPE;
+
+typedef 
+enum D3D12_DRIVER_MATCHING_IDENTIFIER_STATUS
+    {
+        D3D12_DRIVER_MATCHING_IDENTIFIER_COMPATIBLE_WITH_DEVICE	= 0,
+        D3D12_DRIVER_MATCHING_IDENTIFIER_UNSUPPORTED_TYPE	= 0x1,
+        D3D12_DRIVER_MATCHING_IDENTIFIER_UNRECOGNIZED	= 0x2,
+        D3D12_DRIVER_MATCHING_IDENTIFIER_INCOMPATIBLE_VERSION	= 0x3,
+        D3D12_DRIVER_MATCHING_IDENTIFIER_INCOMPATIBLE_TYPE	= 0x4
+    } 	D3D12_DRIVER_MATCHING_IDENTIFIER_STATUS;
+
+typedef struct D3D12_SERIALIZED_RAYTRACING_ACCELERATION_STRUCTURE_HEADER
+    {
+    D3D12_SERIALIZED_DATA_DRIVER_MATCHING_IDENTIFIER DriverMatchingIdentifier;
+    UINT64 SerializedSizeInBytesIncludingHeader;
+    UINT64 DeserializedSizeInBytes;
+    UINT64 NumBottomLevelAccelerationStructurePointersAfterHeader;
+    } 	D3D12_SERIALIZED_RAYTRACING_ACCELERATION_STRUCTURE_HEADER;
+
+typedef struct D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_CURRENT_SIZE_DESC
+    {
+    UINT64 CurrentSizeInBytes;
+    } 	D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_CURRENT_SIZE_DESC;
+
+typedef struct D3D12_RAYTRACING_INSTANCE_DESC
+    {
+    FLOAT Transform[ 3 ][ 4 ];
+    UINT InstanceID	: 24;
+    UINT InstanceMask	: 8;
+    UINT InstanceContributionToHitGroupIndex	: 24;
+    UINT Flags	: 8;
+    D3D12_GPU_VIRTUAL_ADDRESS AccelerationStructure;
+    } 	D3D12_RAYTRACING_INSTANCE_DESC;
+
+typedef struct D3D12_RAYTRACING_GEOMETRY_DESC
+    {
+    D3D12_RAYTRACING_GEOMETRY_TYPE Type;
+    D3D12_RAYTRACING_GEOMETRY_FLAGS Flags;
+    union 
+        {
+        D3D12_RAYTRACING_GEOMETRY_TRIANGLES_DESC Triangles;
+        D3D12_RAYTRACING_GEOMETRY_AABBS_DESC AABBs;
+        } 	;
+    } 	D3D12_RAYTRACING_GEOMETRY_DESC;
+
+typedef struct D3D12_BUILD_RAYTRACING_ACCELERATION_STRUCTURE_INPUTS
+    {
+    D3D12_RAYTRACING_ACCELERATION_STRUCTURE_TYPE Type;
+    D3D12_RAYTRACING_ACCELERATION_STRUCTURE_BUILD_FLAGS Flags;
+    UINT NumDescs;
+    D3D12_ELEMENTS_LAYOUT DescsLayout;
+    union 
+        {
+        D3D12_GPU_VIRTUAL_ADDRESS InstanceDescs;
+        const D3D12_RAYTRACING_GEOMETRY_DESC *pGeometryDescs;
+        const D3D12_RAYTRACING_GEOMETRY_DESC *const *ppGeometryDescs;
+        } 	;
+    } 	D3D12_BUILD_RAYTRACING_ACCELERATION_STRUCTURE_INPUTS;
+
+typedef struct D3D12_BUILD_RAYTRACING_ACCELERATION_STRUCTURE_DESC
+    {
+    D3D12_GPU_VIRTUAL_ADDRESS DestAccelerationStructureData;
+    D3D12_BUILD_RAYTRACING_ACCELERATION_STRUCTURE_INPUTS Inputs;
+    _In_opt_  D3D12_GPU_VIRTUAL_ADDRESS SourceAccelerationStructureData;
+    D3D12_GPU_VIRTUAL_ADDRESS ScratchAccelerationStructureData;
+    } 	D3D12_BUILD_RAYTRACING_ACCELERATION_STRUCTURE_DESC;
+
+typedef struct D3D12_RAYTRACING_ACCELERATION_STRUCTURE_PREBUILD_INFO
+    {
+    UINT64 ResultDataMaxSizeInBytes;
+    UINT64 ScratchDataSizeInBytes;
+    UINT64 UpdateScratchDataSizeInBytes;
+    } 	D3D12_RAYTRACING_ACCELERATION_STRUCTURE_PREBUILD_INFO;
+
+typedef 
+enum D3D12_RAY_FLAGS
+    {
+        D3D12_RAY_FLAG_NONE	= 0,
+        D3D12_RAY_FLAG_FORCE_OPAQUE	= 0x1,
+        D3D12_RAY_FLAG_FORCE_NON_OPAQUE	= 0x2,
+        D3D12_RAY_FLAG_ACCEPT_FIRST_HIT_AND_END_SEARCH	= 0x4,
+        D3D12_RAY_FLAG_SKIP_CLOSEST_HIT_SHADER	= 0x8,
+        D3D12_RAY_FLAG_CULL_BACK_FACING_TRIANGLES	= 0x10,
+        D3D12_RAY_FLAG_CULL_FRONT_FACING_TRIANGLES	= 0x20,
+        D3D12_RAY_FLAG_CULL_OPAQUE	= 0x40,
+        D3D12_RAY_FLAG_CULL_NON_OPAQUE	= 0x80,
+        D3D12_RAY_FLAG_SKIP_TRIANGLES	= 0x100,
+        D3D12_RAY_FLAG_SKIP_PROCEDURAL_PRIMITIVES	= 0x200
+    } 	D3D12_RAY_FLAGS;
+
+DEFINE_ENUM_FLAG_OPERATORS( D3D12_RAY_FLAGS );
+typedef 
+enum D3D12_HIT_KIND
+    {
+        D3D12_HIT_KIND_TRIANGLE_FRONT_FACE	= 0xfe,
+        D3D12_HIT_KIND_TRIANGLE_BACK_FACE	= 0xff
+    } 	D3D12_HIT_KIND;
+
+
+
+extern RPC_IF_HANDLE __MIDL_itf_d3d12_0000_0034_v0_0_c_ifspec;
+extern RPC_IF_HANDLE __MIDL_itf_d3d12_0000_0034_v0_0_s_ifspec;
+
+#ifndef __ID3D12Device5_INTERFACE_DEFINED__
+#define __ID3D12Device5_INTERFACE_DEFINED__
+
+/* interface ID3D12Device5 */
+/* [unique][local][object][uuid] */ 
+
+
+EXTERN_C const IID IID_ID3D12Device5;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("8b4f173b-2fea-4b80-8f58-4307191ab95d")
+    ID3D12Device5 : public ID3D12Device4
+    {
+    public:
+        virtual HRESULT STDMETHODCALLTYPE CreateLifetimeTracker( 
+            _In_  ID3D12LifetimeOwner *pOwner,
+            REFIID riid,
+            _COM_Outptr_  void **ppvTracker) = 0;
+        
+        virtual void STDMETHODCALLTYPE RemoveDevice( void) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE EnumerateMetaCommands( 
+            _Inout_  UINT *pNumMetaCommands,
+            _Out_writes_opt_(*pNumMetaCommands)  D3D12_META_COMMAND_DESC *pDescs) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE EnumerateMetaCommandParameters( 
+            _In_  REFGUID CommandId,
+            _In_  D3D12_META_COMMAND_PARAMETER_STAGE Stage,
+            _Out_opt_  UINT *pTotalStructureSizeInBytes,
+            _Inout_  UINT *pParameterCount,
+            _Out_writes_opt_(*pParameterCount)  D3D12_META_COMMAND_PARAMETER_DESC *pParameterDescs) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE CreateMetaCommand( 
+            _In_  REFGUID CommandId,
+            _In_  UINT NodeMask,
+            _In_reads_bytes_opt_(CreationParametersDataSizeInBytes)  const void *pCreationParametersData,
+            _In_  SIZE_T CreationParametersDataSizeInBytes,
+            REFIID riid,
+            _COM_Outptr_  void **ppMetaCommand) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE CreateStateObject( 
+            const D3D12_STATE_OBJECT_DESC *pDesc,
+            REFIID riid,
+            _COM_Outptr_  void **ppStateObject) = 0;
+        
+        virtual void STDMETHODCALLTYPE GetRaytracingAccelerationStructurePrebuildInfo( 
+            _In_  const D3D12_BUILD_RAYTRACING_ACCELERATION_STRUCTURE_INPUTS *pDesc,
+            _Out_  D3D12_RAYTRACING_ACCELERATION_STRUCTURE_PREBUILD_INFO *pInfo) = 0;
+        
+        virtual D3D12_DRIVER_MATCHING_IDENTIFIER_STATUS STDMETHODCALLTYPE CheckDriverMatchingIdentifier( 
+            _In_  D3D12_SERIALIZED_DATA_TYPE SerializedDataType,
+            _In_  const D3D12_SERIALIZED_DATA_DRIVER_MATCHING_IDENTIFIER *pIdentifierToCheck) = 0;
+        
+    };
+    
+    
+#else 	/* C style interface */
+
+    typedef struct ID3D12Device5Vtbl
+    {
+        BEGIN_INTERFACE
+        
+        DECLSPEC_XFGVIRT(IUnknown, QueryInterface)
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            ID3D12Device5 * This,
+            REFIID riid,
+            _COM_Outptr_  void **ppvObject);
+        
+        DECLSPEC_XFGVIRT(IUnknown, AddRef)
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            ID3D12Device5 * This);
+        
+        DECLSPEC_XFGVIRT(IUnknown, Release)
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            ID3D12Device5 * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, GetPrivateData)
+        HRESULT ( STDMETHODCALLTYPE *GetPrivateData )( 
+            ID3D12Device5 * This,
+            _In_  REFGUID guid,
+            _Inout_  UINT *pDataSize,
+            _Out_writes_bytes_opt_( *pDataSize )  void *pData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, SetPrivateData)
+        HRESULT ( STDMETHODCALLTYPE *SetPrivateData )( 
+            ID3D12Device5 * This,
+            _In_  REFGUID guid,
+            _In_  UINT DataSize,
+            _In_reads_bytes_opt_( DataSize )  const void *pData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, SetPrivateDataInterface)
+        HRESULT ( STDMETHODCALLTYPE *SetPrivateDataInterface )( 
+            ID3D12Device5 * This,
+            _In_  REFGUID guid,
+            _In_opt_  const IUnknown *pData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, SetName)
+        HRESULT ( STDMETHODCALLTYPE *SetName )( 
+            ID3D12Device5 * This,
+            _In_z_  LPCWSTR Name);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, GetNodeCount)
+        UINT ( STDMETHODCALLTYPE *GetNodeCount )( 
+            ID3D12Device5 * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CreateCommandQueue)
+        HRESULT ( STDMETHODCALLTYPE *CreateCommandQueue )( 
+            ID3D12Device5 * This,
+            _In_  const D3D12_COMMAND_QUEUE_DESC *pDesc,
+            REFIID riid,
+            _COM_Outptr_  void **ppCommandQueue);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CreateCommandAllocator)
+        HRESULT ( STDMETHODCALLTYPE *CreateCommandAllocator )( 
+            ID3D12Device5 * This,
+            _In_  D3D12_COMMAND_LIST_TYPE type,
+            REFIID riid,
+            _COM_Outptr_  void **ppCommandAllocator);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CreateGraphicsPipelineState)
+        HRESULT ( STDMETHODCALLTYPE *CreateGraphicsPipelineState )( 
+            ID3D12Device5 * This,
+            _In_  const D3D12_GRAPHICS_PIPELINE_STATE_DESC *pDesc,
+            REFIID riid,
+            _COM_Outptr_  void **ppPipelineState);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CreateComputePipelineState)
+        HRESULT ( STDMETHODCALLTYPE *CreateComputePipelineState )( 
+            ID3D12Device5 * This,
+            _In_  const D3D12_COMPUTE_PIPELINE_STATE_DESC *pDesc,
+            REFIID riid,
+            _COM_Outptr_  void **ppPipelineState);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CreateCommandList)
+        HRESULT ( STDMETHODCALLTYPE *CreateCommandList )( 
+            ID3D12Device5 * This,
+            _In_  UINT nodeMask,
+            _In_  D3D12_COMMAND_LIST_TYPE type,
+            _In_  ID3D12CommandAllocator *pCommandAllocator,
+            _In_opt_  ID3D12PipelineState *pInitialState,
+            REFIID riid,
+            _COM_Outptr_  void **ppCommandList);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CheckFeatureSupport)
+        HRESULT ( STDMETHODCALLTYPE *CheckFeatureSupport )( 
+            ID3D12Device5 * This,
+            D3D12_FEATURE Feature,
+            _Inout_updates_bytes_(FeatureSupportDataSize)  void *pFeatureSupportData,
+            UINT FeatureSupportDataSize);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CreateDescriptorHeap)
+        HRESULT ( STDMETHODCALLTYPE *CreateDescriptorHeap )( 
+            ID3D12Device5 * This,
+            _In_  const D3D12_DESCRIPTOR_HEAP_DESC *pDescriptorHeapDesc,
+            REFIID riid,
+            _COM_Outptr_  void **ppvHeap);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, GetDescriptorHandleIncrementSize)
+        UINT ( STDMETHODCALLTYPE *GetDescriptorHandleIncrementSize )( 
+            ID3D12Device5 * This,
+            _In_  D3D12_DESCRIPTOR_HEAP_TYPE DescriptorHeapType);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CreateRootSignature)
+        HRESULT ( STDMETHODCALLTYPE *CreateRootSignature )( 
+            ID3D12Device5 * This,
+            _In_  UINT nodeMask,
+            _In_reads_(blobLengthInBytes)  const void *pBlobWithRootSignature,
+            _In_  SIZE_T blobLengthInBytes,
+            REFIID riid,
+            _COM_Outptr_  void **ppvRootSignature);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CreateConstantBufferView)
+        void ( STDMETHODCALLTYPE *CreateConstantBufferView )( 
+            ID3D12Device5 * This,
+            _In_opt_  const D3D12_CONSTANT_BUFFER_VIEW_DESC *pDesc,
+            _In_  D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CreateShaderResourceView)
+        void ( STDMETHODCALLTYPE *CreateShaderResourceView )( 
+            ID3D12Device5 * This,
+            _In_opt_  ID3D12Resource *pResource,
+            _In_opt_  const D3D12_SHADER_RESOURCE_VIEW_DESC *pDesc,
+            _In_  D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CreateUnorderedAccessView)
+        void ( STDMETHODCALLTYPE *CreateUnorderedAccessView )( 
+            ID3D12Device5 * This,
+            _In_opt_  ID3D12Resource *pResource,
+            _In_opt_  ID3D12Resource *pCounterResource,
+            _In_opt_  const D3D12_UNORDERED_ACCESS_VIEW_DESC *pDesc,
+            _In_  D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CreateRenderTargetView)
+        void ( STDMETHODCALLTYPE *CreateRenderTargetView )( 
+            ID3D12Device5 * This,
+            _In_opt_  ID3D12Resource *pResource,
+            _In_opt_  const D3D12_RENDER_TARGET_VIEW_DESC *pDesc,
+            _In_  D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CreateDepthStencilView)
+        void ( STDMETHODCALLTYPE *CreateDepthStencilView )( 
+            ID3D12Device5 * This,
+            _In_opt_  ID3D12Resource *pResource,
+            _In_opt_  const D3D12_DEPTH_STENCIL_VIEW_DESC *pDesc,
+            _In_  D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CreateSampler)
+        void ( STDMETHODCALLTYPE *CreateSampler )( 
+            ID3D12Device5 * This,
+            _In_  const D3D12_SAMPLER_DESC *pDesc,
+            _In_  D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CopyDescriptors)
+        void ( STDMETHODCALLTYPE *CopyDescriptors )( 
+            ID3D12Device5 * This,
+            _In_  UINT NumDestDescriptorRanges,
+            _In_reads_(NumDestDescriptorRanges)  const D3D12_CPU_DESCRIPTOR_HANDLE *pDestDescriptorRangeStarts,
+            _In_reads_opt_(NumDestDescriptorRanges)  const UINT *pDestDescriptorRangeSizes,
+            _In_  UINT NumSrcDescriptorRanges,
+            _In_reads_(NumSrcDescriptorRanges)  const D3D12_CPU_DESCRIPTOR_HANDLE *pSrcDescriptorRangeStarts,
+            _In_reads_opt_(NumSrcDescriptorRanges)  const UINT *pSrcDescriptorRangeSizes,
+            _In_  D3D12_DESCRIPTOR_HEAP_TYPE DescriptorHeapsType);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CopyDescriptorsSimple)
+        void ( STDMETHODCALLTYPE *CopyDescriptorsSimple )( 
+            ID3D12Device5 * This,
+            _In_  UINT NumDescriptors,
+            _In_  D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptorRangeStart,
+            _In_  D3D12_CPU_DESCRIPTOR_HANDLE SrcDescriptorRangeStart,
+            _In_  D3D12_DESCRIPTOR_HEAP_TYPE DescriptorHeapsType);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, GetResourceAllocationInfo)
+#if !defined(_WIN32)
+        D3D12_RESOURCE_ALLOCATION_INFO ( STDMETHODCALLTYPE *GetResourceAllocationInfo )( 
+            ID3D12Device5 * This,
+            _In_  UINT visibleMask,
+            _In_  UINT numResourceDescs,
+            _In_reads_(numResourceDescs)  const D3D12_RESOURCE_DESC *pResourceDescs);
+        
+#else
+        D3D12_RESOURCE_ALLOCATION_INFO *( STDMETHODCALLTYPE *GetResourceAllocationInfo )( 
+            ID3D12Device5 * This,
+            D3D12_RESOURCE_ALLOCATION_INFO * RetVal,
+            _In_  UINT visibleMask,
+            _In_  UINT numResourceDescs,
+            _In_reads_(numResourceDescs)  const D3D12_RESOURCE_DESC *pResourceDescs);
+        
+#endif
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, GetCustomHeapProperties)
+#if !defined(_WIN32)
+        D3D12_HEAP_PROPERTIES ( STDMETHODCALLTYPE *GetCustomHeapProperties )( 
+            ID3D12Device5 * This,
+            _In_  UINT nodeMask,
+            D3D12_HEAP_TYPE heapType);
+        
+#else
+        D3D12_HEAP_PROPERTIES *( STDMETHODCALLTYPE *GetCustomHeapProperties )( 
+            ID3D12Device5 * This,
+            D3D12_HEAP_PROPERTIES * RetVal,
+            _In_  UINT nodeMask,
+            D3D12_HEAP_TYPE heapType);
+        
+#endif
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CreateCommittedResource)
+        HRESULT ( STDMETHODCALLTYPE *CreateCommittedResource )( 
+            ID3D12Device5 * This,
+            _In_  const D3D12_HEAP_PROPERTIES *pHeapProperties,
+            D3D12_HEAP_FLAGS HeapFlags,
+            _In_  const D3D12_RESOURCE_DESC *pDesc,
+            D3D12_RESOURCE_STATES InitialResourceState,
+            _In_opt_  const D3D12_CLEAR_VALUE *pOptimizedClearValue,
+            REFIID riidResource,
+            _COM_Outptr_opt_  void **ppvResource);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CreateHeap)
+        HRESULT ( STDMETHODCALLTYPE *CreateHeap )( 
+            ID3D12Device5 * This,
+            _In_  const D3D12_HEAP_DESC *pDesc,
+            REFIID riid,
+            _COM_Outptr_opt_  void **ppvHeap);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CreatePlacedResource)
+        HRESULT ( STDMETHODCALLTYPE *CreatePlacedResource )( 
+            ID3D12Device5 * This,
+            _In_  ID3D12Heap *pHeap,
+            UINT64 HeapOffset,
+            _In_  const D3D12_RESOURCE_DESC *pDesc,
+            D3D12_RESOURCE_STATES InitialState,
+            _In_opt_  const D3D12_CLEAR_VALUE *pOptimizedClearValue,
+            REFIID riid,
+            _COM_Outptr_opt_  void **ppvResource);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CreateReservedResource)
+        HRESULT ( STDMETHODCALLTYPE *CreateReservedResource )( 
+            ID3D12Device5 * This,
+            _In_  const D3D12_RESOURCE_DESC *pDesc,
+            D3D12_RESOURCE_STATES InitialState,
+            _In_opt_  const D3D12_CLEAR_VALUE *pOptimizedClearValue,
+            REFIID riid,
+            _COM_Outptr_opt_  void **ppvResource);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CreateSharedHandle)
+        HRESULT ( STDMETHODCALLTYPE *CreateSharedHandle )( 
+            ID3D12Device5 * This,
+            _In_  ID3D12DeviceChild *pObject,
+            _In_opt_  const SECURITY_ATTRIBUTES *pAttributes,
+            DWORD Access,
+            _In_opt_  LPCWSTR Name,
+            _Out_  HANDLE *pHandle);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, OpenSharedHandle)
+        HRESULT ( STDMETHODCALLTYPE *OpenSharedHandle )( 
+            ID3D12Device5 * This,
+            _In_  HANDLE NTHandle,
+            REFIID riid,
+            _COM_Outptr_opt_  void **ppvObj);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, OpenSharedHandleByName)
+        HRESULT ( STDMETHODCALLTYPE *OpenSharedHandleByName )( 
+            ID3D12Device5 * This,
+            _In_  LPCWSTR Name,
+            DWORD Access,
+            /* [annotation][out] */ 
+            _Out_  HANDLE *pNTHandle);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, MakeResident)
+        HRESULT ( STDMETHODCALLTYPE *MakeResident )( 
+            ID3D12Device5 * This,
+            UINT NumObjects,
+            _In_reads_(NumObjects)  ID3D12Pageable *const *ppObjects);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, Evict)
+        HRESULT ( STDMETHODCALLTYPE *Evict )( 
+            ID3D12Device5 * This,
+            UINT NumObjects,
+            _In_reads_(NumObjects)  ID3D12Pageable *const *ppObjects);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CreateFence)
+        HRESULT ( STDMETHODCALLTYPE *CreateFence )( 
+            ID3D12Device5 * This,
+            UINT64 InitialValue,
+            D3D12_FENCE_FLAGS Flags,
+            REFIID riid,
+            _COM_Outptr_  void **ppFence);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, GetDeviceRemovedReason)
+        HRESULT ( STDMETHODCALLTYPE *GetDeviceRemovedReason )( 
+            ID3D12Device5 * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, GetCopyableFootprints)
+        void ( STDMETHODCALLTYPE *GetCopyableFootprints )( 
+            ID3D12Device5 * This,
+            _In_  const D3D12_RESOURCE_DESC *pResourceDesc,
+            _In_range_(0,D3D12_REQ_SUBRESOURCES)  UINT FirstSubresource,
+            _In_range_(0,D3D12_REQ_SUBRESOURCES-FirstSubresource)  UINT NumSubresources,
+            UINT64 BaseOffset,
+            _Out_writes_opt_(NumSubresources)  D3D12_PLACED_SUBRESOURCE_FOOTPRINT *pLayouts,
+            _Out_writes_opt_(NumSubresources)  UINT *pNumRows,
+            _Out_writes_opt_(NumSubresources)  UINT64 *pRowSizeInBytes,
+            _Out_opt_  UINT64 *pTotalBytes);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CreateQueryHeap)
+        HRESULT ( STDMETHODCALLTYPE *CreateQueryHeap )( 
+            ID3D12Device5 * This,
+            _In_  const D3D12_QUERY_HEAP_DESC *pDesc,
+            REFIID riid,
+            _COM_Outptr_opt_  void **ppvHeap);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, SetStablePowerState)
+        HRESULT ( STDMETHODCALLTYPE *SetStablePowerState )( 
+            ID3D12Device5 * This,
+            BOOL Enable);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CreateCommandSignature)
+        HRESULT ( STDMETHODCALLTYPE *CreateCommandSignature )( 
+            ID3D12Device5 * This,
+            _In_  const D3D12_COMMAND_SIGNATURE_DESC *pDesc,
+            _In_opt_  ID3D12RootSignature *pRootSignature,
+            REFIID riid,
+            _COM_Outptr_opt_  void **ppvCommandSignature);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, GetResourceTiling)
+        void ( STDMETHODCALLTYPE *GetResourceTiling )( 
+            ID3D12Device5 * This,
+            _In_  ID3D12Resource *pTiledResource,
+            _Out_opt_  UINT *pNumTilesForEntireResource,
+            _Out_opt_  D3D12_PACKED_MIP_INFO *pPackedMipDesc,
+            _Out_opt_  D3D12_TILE_SHAPE *pStandardTileShapeForNonPackedMips,
+            _Inout_opt_  UINT *pNumSubresourceTilings,
+            _In_  UINT FirstSubresourceTilingToGet,
+            _Out_writes_(*pNumSubresourceTilings)  D3D12_SUBRESOURCE_TILING *pSubresourceTilingsForNonPackedMips);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, GetAdapterLuid)
+#if !defined(_WIN32)
+        LUID ( STDMETHODCALLTYPE *GetAdapterLuid )( 
+            ID3D12Device5 * This);
+        
+#else
+        LUID *( STDMETHODCALLTYPE *GetAdapterLuid )( 
+            ID3D12Device5 * This,
+            LUID * RetVal);
+        
+#endif
+        
+        DECLSPEC_XFGVIRT(ID3D12Device1, CreatePipelineLibrary)
+        HRESULT ( STDMETHODCALLTYPE *CreatePipelineLibrary )( 
+            ID3D12Device5 * This,
+            _In_reads_(BlobLength)  const void *pLibraryBlob,
+            SIZE_T BlobLength,
+            REFIID riid,
+            _COM_Outptr_  void **ppPipelineLibrary);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device1, SetEventOnMultipleFenceCompletion)
+        HRESULT ( STDMETHODCALLTYPE *SetEventOnMultipleFenceCompletion )( 
+            ID3D12Device5 * This,
+            _In_reads_(NumFences)  ID3D12Fence *const *ppFences,
+            _In_reads_(NumFences)  const UINT64 *pFenceValues,
+            UINT NumFences,
+            D3D12_MULTIPLE_FENCE_WAIT_FLAGS Flags,
+            HANDLE hEvent);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device1, SetResidencyPriority)
+        HRESULT ( STDMETHODCALLTYPE *SetResidencyPriority )( 
+            ID3D12Device5 * This,
+            UINT NumObjects,
+            _In_reads_(NumObjects)  ID3D12Pageable *const *ppObjects,
+            _In_reads_(NumObjects)  const D3D12_RESIDENCY_PRIORITY *pPriorities);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device2, CreatePipelineState)
+        HRESULT ( STDMETHODCALLTYPE *CreatePipelineState )( 
+            ID3D12Device5 * This,
+            const D3D12_PIPELINE_STATE_STREAM_DESC *pDesc,
+            REFIID riid,
+            _COM_Outptr_  void **ppPipelineState);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device3, OpenExistingHeapFromAddress)
+        HRESULT ( STDMETHODCALLTYPE *OpenExistingHeapFromAddress )( 
+            ID3D12Device5 * This,
+            _In_  const void *pAddress,
+            REFIID riid,
+            _COM_Outptr_  void **ppvHeap);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device3, OpenExistingHeapFromFileMapping)
+        HRESULT ( STDMETHODCALLTYPE *OpenExistingHeapFromFileMapping )( 
+            ID3D12Device5 * This,
+            _In_  HANDLE hFileMapping,
+            REFIID riid,
+            _COM_Outptr_  void **ppvHeap);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device3, EnqueueMakeResident)
+        HRESULT ( STDMETHODCALLTYPE *EnqueueMakeResident )( 
+            ID3D12Device5 * This,
+            D3D12_RESIDENCY_FLAGS Flags,
+            UINT NumObjects,
+            _In_reads_(NumObjects)  ID3D12Pageable *const *ppObjects,
+            _In_  ID3D12Fence *pFenceToSignal,
+            UINT64 FenceValueToSignal);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device4, CreateCommandList1)
+        HRESULT ( STDMETHODCALLTYPE *CreateCommandList1 )( 
+            ID3D12Device5 * This,
+            _In_  UINT nodeMask,
+            _In_  D3D12_COMMAND_LIST_TYPE type,
+            _In_  D3D12_COMMAND_LIST_FLAGS flags,
+            REFIID riid,
+            _COM_Outptr_  void **ppCommandList);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device4, CreateProtectedResourceSession)
+        HRESULT ( STDMETHODCALLTYPE *CreateProtectedResourceSession )( 
+            ID3D12Device5 * This,
+            _In_  const D3D12_PROTECTED_RESOURCE_SESSION_DESC *pDesc,
+            _In_  REFIID riid,
+            _COM_Outptr_  void **ppSession);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device4, CreateCommittedResource1)
+        HRESULT ( STDMETHODCALLTYPE *CreateCommittedResource1 )( 
+            ID3D12Device5 * This,
+            _In_  const D3D12_HEAP_PROPERTIES *pHeapProperties,
+            D3D12_HEAP_FLAGS HeapFlags,
+            _In_  const D3D12_RESOURCE_DESC *pDesc,
+            D3D12_RESOURCE_STATES InitialResourceState,
+            _In_opt_  const D3D12_CLEAR_VALUE *pOptimizedClearValue,
+            _In_opt_  ID3D12ProtectedResourceSession *pProtectedSession,
+            REFIID riidResource,
+            _COM_Outptr_opt_  void **ppvResource);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device4, CreateHeap1)
+        HRESULT ( STDMETHODCALLTYPE *CreateHeap1 )( 
+            ID3D12Device5 * This,
+            _In_  const D3D12_HEAP_DESC *pDesc,
+            _In_opt_  ID3D12ProtectedResourceSession *pProtectedSession,
+            REFIID riid,
+            _COM_Outptr_opt_  void **ppvHeap);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device4, CreateReservedResource1)
+        HRESULT ( STDMETHODCALLTYPE *CreateReservedResource1 )( 
+            ID3D12Device5 * This,
+            _In_  const D3D12_RESOURCE_DESC *pDesc,
+            D3D12_RESOURCE_STATES InitialState,
+            _In_opt_  const D3D12_CLEAR_VALUE *pOptimizedClearValue,
+            _In_opt_  ID3D12ProtectedResourceSession *pProtectedSession,
+            REFIID riid,
+            _COM_Outptr_opt_  void **ppvResource);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device4, GetResourceAllocationInfo1)
+#if !defined(_WIN32)
+        D3D12_RESOURCE_ALLOCATION_INFO ( STDMETHODCALLTYPE *GetResourceAllocationInfo1 )( 
+            ID3D12Device5 * This,
+            UINT visibleMask,
+            UINT numResourceDescs,
+            _In_reads_(numResourceDescs)  const D3D12_RESOURCE_DESC *pResourceDescs,
+            _Out_writes_opt_(numResourceDescs)  D3D12_RESOURCE_ALLOCATION_INFO1 *pResourceAllocationInfo1);
+        
+#else
+        D3D12_RESOURCE_ALLOCATION_INFO *( STDMETHODCALLTYPE *GetResourceAllocationInfo1 )( 
+            ID3D12Device5 * This,
+            D3D12_RESOURCE_ALLOCATION_INFO * RetVal,
+            UINT visibleMask,
+            UINT numResourceDescs,
+            _In_reads_(numResourceDescs)  const D3D12_RESOURCE_DESC *pResourceDescs,
+            _Out_writes_opt_(numResourceDescs)  D3D12_RESOURCE_ALLOCATION_INFO1 *pResourceAllocationInfo1);
+        
+#endif
+        
+        DECLSPEC_XFGVIRT(ID3D12Device5, CreateLifetimeTracker)
+        HRESULT ( STDMETHODCALLTYPE *CreateLifetimeTracker )( 
+            ID3D12Device5 * This,
+            _In_  ID3D12LifetimeOwner *pOwner,
+            REFIID riid,
+            _COM_Outptr_  void **ppvTracker);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device5, RemoveDevice)
+        void ( STDMETHODCALLTYPE *RemoveDevice )( 
+            ID3D12Device5 * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device5, EnumerateMetaCommands)
+        HRESULT ( STDMETHODCALLTYPE *EnumerateMetaCommands )( 
+            ID3D12Device5 * This,
+            _Inout_  UINT *pNumMetaCommands,
+            _Out_writes_opt_(*pNumMetaCommands)  D3D12_META_COMMAND_DESC *pDescs);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device5, EnumerateMetaCommandParameters)
+        HRESULT ( STDMETHODCALLTYPE *EnumerateMetaCommandParameters )( 
+            ID3D12Device5 * This,
+            _In_  REFGUID CommandId,
+            _In_  D3D12_META_COMMAND_PARAMETER_STAGE Stage,
+            _Out_opt_  UINT *pTotalStructureSizeInBytes,
+            _Inout_  UINT *pParameterCount,
+            _Out_writes_opt_(*pParameterCount)  D3D12_META_COMMAND_PARAMETER_DESC *pParameterDescs);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device5, CreateMetaCommand)
+        HRESULT ( STDMETHODCALLTYPE *CreateMetaCommand )( 
+            ID3D12Device5 * This,
+            _In_  REFGUID CommandId,
+            _In_  UINT NodeMask,
+            _In_reads_bytes_opt_(CreationParametersDataSizeInBytes)  const void *pCreationParametersData,
+            _In_  SIZE_T CreationParametersDataSizeInBytes,
+            REFIID riid,
+            _COM_Outptr_  void **ppMetaCommand);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device5, CreateStateObject)
+        HRESULT ( STDMETHODCALLTYPE *CreateStateObject )( 
+            ID3D12Device5 * This,
+            const D3D12_STATE_OBJECT_DESC *pDesc,
+            REFIID riid,
+            _COM_Outptr_  void **ppStateObject);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device5, GetRaytracingAccelerationStructurePrebuildInfo)
+        void ( STDMETHODCALLTYPE *GetRaytracingAccelerationStructurePrebuildInfo )( 
+            ID3D12Device5 * This,
+            _In_  const D3D12_BUILD_RAYTRACING_ACCELERATION_STRUCTURE_INPUTS *pDesc,
+            _Out_  D3D12_RAYTRACING_ACCELERATION_STRUCTURE_PREBUILD_INFO *pInfo);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device5, CheckDriverMatchingIdentifier)
+        D3D12_DRIVER_MATCHING_IDENTIFIER_STATUS ( STDMETHODCALLTYPE *CheckDriverMatchingIdentifier )( 
+            ID3D12Device5 * This,
+            _In_  D3D12_SERIALIZED_DATA_TYPE SerializedDataType,
+            _In_  const D3D12_SERIALIZED_DATA_DRIVER_MATCHING_IDENTIFIER *pIdentifierToCheck);
+        
+        END_INTERFACE
+    } ID3D12Device5Vtbl;
+
+    interface ID3D12Device5
+    {
+        CONST_VTBL struct ID3D12Device5Vtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define ID3D12Device5_QueryInterface(This,riid,ppvObject)	\
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define ID3D12Device5_AddRef(This)	\
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define ID3D12Device5_Release(This)	\
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#define ID3D12Device5_GetPrivateData(This,guid,pDataSize,pData)	\
+    ( (This)->lpVtbl -> GetPrivateData(This,guid,pDataSize,pData) ) 
+
+#define ID3D12Device5_SetPrivateData(This,guid,DataSize,pData)	\
+    ( (This)->lpVtbl -> SetPrivateData(This,guid,DataSize,pData) ) 
+
+#define ID3D12Device5_SetPrivateDataInterface(This,guid,pData)	\
+    ( (This)->lpVtbl -> SetPrivateDataInterface(This,guid,pData) ) 
+
+#define ID3D12Device5_SetName(This,Name)	\
+    ( (This)->lpVtbl -> SetName(This,Name) ) 
+
+
+#define ID3D12Device5_GetNodeCount(This)	\
+    ( (This)->lpVtbl -> GetNodeCount(This) ) 
+
+#define ID3D12Device5_CreateCommandQueue(This,pDesc,riid,ppCommandQueue)	\
+    ( (This)->lpVtbl -> CreateCommandQueue(This,pDesc,riid,ppCommandQueue) ) 
+
+#define ID3D12Device5_CreateCommandAllocator(This,type,riid,ppCommandAllocator)	\
+    ( (This)->lpVtbl -> CreateCommandAllocator(This,type,riid,ppCommandAllocator) ) 
+
+#define ID3D12Device5_CreateGraphicsPipelineState(This,pDesc,riid,ppPipelineState)	\
+    ( (This)->lpVtbl -> CreateGraphicsPipelineState(This,pDesc,riid,ppPipelineState) ) 
+
+#define ID3D12Device5_CreateComputePipelineState(This,pDesc,riid,ppPipelineState)	\
+    ( (This)->lpVtbl -> CreateComputePipelineState(This,pDesc,riid,ppPipelineState) ) 
+
+#define ID3D12Device5_CreateCommandList(This,nodeMask,type,pCommandAllocator,pInitialState,riid,ppCommandList)	\
+    ( (This)->lpVtbl -> CreateCommandList(This,nodeMask,type,pCommandAllocator,pInitialState,riid,ppCommandList) ) 
+
+#define ID3D12Device5_CheckFeatureSupport(This,Feature,pFeatureSupportData,FeatureSupportDataSize)	\
+    ( (This)->lpVtbl -> CheckFeatureSupport(This,Feature,pFeatureSupportData,FeatureSupportDataSize) ) 
+
+#define ID3D12Device5_CreateDescriptorHeap(This,pDescriptorHeapDesc,riid,ppvHeap)	\
+    ( (This)->lpVtbl -> CreateDescriptorHeap(This,pDescriptorHeapDesc,riid,ppvHeap) ) 
+
+#define ID3D12Device5_GetDescriptorHandleIncrementSize(This,DescriptorHeapType)	\
+    ( (This)->lpVtbl -> GetDescriptorHandleIncrementSize(This,DescriptorHeapType) ) 
+
+#define ID3D12Device5_CreateRootSignature(This,nodeMask,pBlobWithRootSignature,blobLengthInBytes,riid,ppvRootSignature)	\
+    ( (This)->lpVtbl -> CreateRootSignature(This,nodeMask,pBlobWithRootSignature,blobLengthInBytes,riid,ppvRootSignature) ) 
+
+#define ID3D12Device5_CreateConstantBufferView(This,pDesc,DestDescriptor)	\
+    ( (This)->lpVtbl -> CreateConstantBufferView(This,pDesc,DestDescriptor) ) 
+
+#define ID3D12Device5_CreateShaderResourceView(This,pResource,pDesc,DestDescriptor)	\
+    ( (This)->lpVtbl -> CreateShaderResourceView(This,pResource,pDesc,DestDescriptor) ) 
+
+#define ID3D12Device5_CreateUnorderedAccessView(This,pResource,pCounterResource,pDesc,DestDescriptor)	\
+    ( (This)->lpVtbl -> CreateUnorderedAccessView(This,pResource,pCounterResource,pDesc,DestDescriptor) ) 
+
+#define ID3D12Device5_CreateRenderTargetView(This,pResource,pDesc,DestDescriptor)	\
+    ( (This)->lpVtbl -> CreateRenderTargetView(This,pResource,pDesc,DestDescriptor) ) 
+
+#define ID3D12Device5_CreateDepthStencilView(This,pResource,pDesc,DestDescriptor)	\
+    ( (This)->lpVtbl -> CreateDepthStencilView(This,pResource,pDesc,DestDescriptor) ) 
+
+#define ID3D12Device5_CreateSampler(This,pDesc,DestDescriptor)	\
+    ( (This)->lpVtbl -> CreateSampler(This,pDesc,DestDescriptor) ) 
+
+#define ID3D12Device5_CopyDescriptors(This,NumDestDescriptorRanges,pDestDescriptorRangeStarts,pDestDescriptorRangeSizes,NumSrcDescriptorRanges,pSrcDescriptorRangeStarts,pSrcDescriptorRangeSizes,DescriptorHeapsType)	\
+    ( (This)->lpVtbl -> CopyDescriptors(This,NumDestDescriptorRanges,pDestDescriptorRangeStarts,pDestDescriptorRangeSizes,NumSrcDescriptorRanges,pSrcDescriptorRangeStarts,pSrcDescriptorRangeSizes,DescriptorHeapsType) ) 
+
+#define ID3D12Device5_CopyDescriptorsSimple(This,NumDescriptors,DestDescriptorRangeStart,SrcDescriptorRangeStart,DescriptorHeapsType)	\
+    ( (This)->lpVtbl -> CopyDescriptorsSimple(This,NumDescriptors,DestDescriptorRangeStart,SrcDescriptorRangeStart,DescriptorHeapsType) ) 
+#if !defined(_WIN32)
+
+#define ID3D12Device5_GetResourceAllocationInfo(This,visibleMask,numResourceDescs,pResourceDescs)	\
+    ( (This)->lpVtbl -> GetResourceAllocationInfo(This,visibleMask,numResourceDescs,pResourceDescs) ) 
+#else
+#define ID3D12Device5_GetResourceAllocationInfo(This,RetVal,visibleMask,numResourceDescs,pResourceDescs)	\
+    ( (This)->lpVtbl -> GetResourceAllocationInfo(This,RetVal,visibleMask,numResourceDescs,pResourceDescs) ) 
+#endif
+#if !defined(_WIN32)
+
+#define ID3D12Device5_GetCustomHeapProperties(This,nodeMask,heapType)	\
+    ( (This)->lpVtbl -> GetCustomHeapProperties(This,nodeMask,heapType) ) 
+#else
+#define ID3D12Device5_GetCustomHeapProperties(This,RetVal,nodeMask,heapType)	\
+    ( (This)->lpVtbl -> GetCustomHeapProperties(This,RetVal,nodeMask,heapType) ) 
+#endif
+
+#define ID3D12Device5_CreateCommittedResource(This,pHeapProperties,HeapFlags,pDesc,InitialResourceState,pOptimizedClearValue,riidResource,ppvResource)	\
+    ( (This)->lpVtbl -> CreateCommittedResource(This,pHeapProperties,HeapFlags,pDesc,InitialResourceState,pOptimizedClearValue,riidResource,ppvResource) ) 
+
+#define ID3D12Device5_CreateHeap(This,pDesc,riid,ppvHeap)	\
+    ( (This)->lpVtbl -> CreateHeap(This,pDesc,riid,ppvHeap) ) 
+
+#define ID3D12Device5_CreatePlacedResource(This,pHeap,HeapOffset,pDesc,InitialState,pOptimizedClearValue,riid,ppvResource)	\
+    ( (This)->lpVtbl -> CreatePlacedResource(This,pHeap,HeapOffset,pDesc,InitialState,pOptimizedClearValue,riid,ppvResource) ) 
+
+#define ID3D12Device5_CreateReservedResource(This,pDesc,InitialState,pOptimizedClearValue,riid,ppvResource)	\
+    ( (This)->lpVtbl -> CreateReservedResource(This,pDesc,InitialState,pOptimizedClearValue,riid,ppvResource) ) 
+
+#define ID3D12Device5_CreateSharedHandle(This,pObject,pAttributes,Access,Name,pHandle)	\
+    ( (This)->lpVtbl -> CreateSharedHandle(This,pObject,pAttributes,Access,Name,pHandle) ) 
+
+#define ID3D12Device5_OpenSharedHandle(This,NTHandle,riid,ppvObj)	\
+    ( (This)->lpVtbl -> OpenSharedHandle(This,NTHandle,riid,ppvObj) ) 
+
+#define ID3D12Device5_OpenSharedHandleByName(This,Name,Access,pNTHandle)	\
+    ( (This)->lpVtbl -> OpenSharedHandleByName(This,Name,Access,pNTHandle) ) 
+
+#define ID3D12Device5_MakeResident(This,NumObjects,ppObjects)	\
+    ( (This)->lpVtbl -> MakeResident(This,NumObjects,ppObjects) ) 
+
+#define ID3D12Device5_Evict(This,NumObjects,ppObjects)	\
+    ( (This)->lpVtbl -> Evict(This,NumObjects,ppObjects) ) 
+
+#define ID3D12Device5_CreateFence(This,InitialValue,Flags,riid,ppFence)	\
+    ( (This)->lpVtbl -> CreateFence(This,InitialValue,Flags,riid,ppFence) ) 
+
+#define ID3D12Device5_GetDeviceRemovedReason(This)	\
+    ( (This)->lpVtbl -> GetDeviceRemovedReason(This) ) 
+
+#define ID3D12Device5_GetCopyableFootprints(This,pResourceDesc,FirstSubresource,NumSubresources,BaseOffset,pLayouts,pNumRows,pRowSizeInBytes,pTotalBytes)	\
+    ( (This)->lpVtbl -> GetCopyableFootprints(This,pResourceDesc,FirstSubresource,NumSubresources,BaseOffset,pLayouts,pNumRows,pRowSizeInBytes,pTotalBytes) ) 
+
+#define ID3D12Device5_CreateQueryHeap(This,pDesc,riid,ppvHeap)	\
+    ( (This)->lpVtbl -> CreateQueryHeap(This,pDesc,riid,ppvHeap) ) 
+
+#define ID3D12Device5_SetStablePowerState(This,Enable)	\
+    ( (This)->lpVtbl -> SetStablePowerState(This,Enable) ) 
+
+#define ID3D12Device5_CreateCommandSignature(This,pDesc,pRootSignature,riid,ppvCommandSignature)	\
+    ( (This)->lpVtbl -> CreateCommandSignature(This,pDesc,pRootSignature,riid,ppvCommandSignature) ) 
+
+#define ID3D12Device5_GetResourceTiling(This,pTiledResource,pNumTilesForEntireResource,pPackedMipDesc,pStandardTileShapeForNonPackedMips,pNumSubresourceTilings,FirstSubresourceTilingToGet,pSubresourceTilingsForNonPackedMips)	\
+    ( (This)->lpVtbl -> GetResourceTiling(This,pTiledResource,pNumTilesForEntireResource,pPackedMipDesc,pStandardTileShapeForNonPackedMips,pNumSubresourceTilings,FirstSubresourceTilingToGet,pSubresourceTilingsForNonPackedMips) ) 
+#if !defined(_WIN32)
+
+#define ID3D12Device5_GetAdapterLuid(This)	\
+    ( (This)->lpVtbl -> GetAdapterLuid(This) ) 
+#else
+#define ID3D12Device5_GetAdapterLuid(This,RetVal)	\
+    ( (This)->lpVtbl -> GetAdapterLuid(This,RetVal) ) 
+#endif
+
+
+#define ID3D12Device5_CreatePipelineLibrary(This,pLibraryBlob,BlobLength,riid,ppPipelineLibrary)	\
+    ( (This)->lpVtbl -> CreatePipelineLibrary(This,pLibraryBlob,BlobLength,riid,ppPipelineLibrary) ) 
+
+#define ID3D12Device5_SetEventOnMultipleFenceCompletion(This,ppFences,pFenceValues,NumFences,Flags,hEvent)	\
+    ( (This)->lpVtbl -> SetEventOnMultipleFenceCompletion(This,ppFences,pFenceValues,NumFences,Flags,hEvent) ) 
+
+#define ID3D12Device5_SetResidencyPriority(This,NumObjects,ppObjects,pPriorities)	\
+    ( (This)->lpVtbl -> SetResidencyPriority(This,NumObjects,ppObjects,pPriorities) ) 
+
+
+#define ID3D12Device5_CreatePipelineState(This,pDesc,riid,ppPipelineState)	\
+    ( (This)->lpVtbl -> CreatePipelineState(This,pDesc,riid,ppPipelineState) ) 
+
+
+#define ID3D12Device5_OpenExistingHeapFromAddress(This,pAddress,riid,ppvHeap)	\
+    ( (This)->lpVtbl -> OpenExistingHeapFromAddress(This,pAddress,riid,ppvHeap) ) 
+
+#define ID3D12Device5_OpenExistingHeapFromFileMapping(This,hFileMapping,riid,ppvHeap)	\
+    ( (This)->lpVtbl -> OpenExistingHeapFromFileMapping(This,hFileMapping,riid,ppvHeap) ) 
+
+#define ID3D12Device5_EnqueueMakeResident(This,Flags,NumObjects,ppObjects,pFenceToSignal,FenceValueToSignal)	\
+    ( (This)->lpVtbl -> EnqueueMakeResident(This,Flags,NumObjects,ppObjects,pFenceToSignal,FenceValueToSignal) ) 
+
+
+#define ID3D12Device5_CreateCommandList1(This,nodeMask,type,flags,riid,ppCommandList)	\
+    ( (This)->lpVtbl -> CreateCommandList1(This,nodeMask,type,flags,riid,ppCommandList) ) 
+
+#define ID3D12Device5_CreateProtectedResourceSession(This,pDesc,riid,ppSession)	\
+    ( (This)->lpVtbl -> CreateProtectedResourceSession(This,pDesc,riid,ppSession) ) 
+
+#define ID3D12Device5_CreateCommittedResource1(This,pHeapProperties,HeapFlags,pDesc,InitialResourceState,pOptimizedClearValue,pProtectedSession,riidResource,ppvResource)	\
+    ( (This)->lpVtbl -> CreateCommittedResource1(This,pHeapProperties,HeapFlags,pDesc,InitialResourceState,pOptimizedClearValue,pProtectedSession,riidResource,ppvResource) ) 
+
+#define ID3D12Device5_CreateHeap1(This,pDesc,pProtectedSession,riid,ppvHeap)	\
+    ( (This)->lpVtbl -> CreateHeap1(This,pDesc,pProtectedSession,riid,ppvHeap) ) 
+
+#define ID3D12Device5_CreateReservedResource1(This,pDesc,InitialState,pOptimizedClearValue,pProtectedSession,riid,ppvResource)	\
+    ( (This)->lpVtbl -> CreateReservedResource1(This,pDesc,InitialState,pOptimizedClearValue,pProtectedSession,riid,ppvResource) ) 
+#if !defined(_WIN32)
+
+#define ID3D12Device5_GetResourceAllocationInfo1(This,visibleMask,numResourceDescs,pResourceDescs,pResourceAllocationInfo1)	\
+    ( (This)->lpVtbl -> GetResourceAllocationInfo1(This,visibleMask,numResourceDescs,pResourceDescs,pResourceAllocationInfo1) ) 
+#else
+#define ID3D12Device5_GetResourceAllocationInfo1(This,RetVal,visibleMask,numResourceDescs,pResourceDescs,pResourceAllocationInfo1)	\
+    ( (This)->lpVtbl -> GetResourceAllocationInfo1(This,RetVal,visibleMask,numResourceDescs,pResourceDescs,pResourceAllocationInfo1) ) 
+#endif
+
+
+#define ID3D12Device5_CreateLifetimeTracker(This,pOwner,riid,ppvTracker)	\
+    ( (This)->lpVtbl -> CreateLifetimeTracker(This,pOwner,riid,ppvTracker) ) 
+
+#define ID3D12Device5_RemoveDevice(This)	\
+    ( (This)->lpVtbl -> RemoveDevice(This) ) 
+
+#define ID3D12Device5_EnumerateMetaCommands(This,pNumMetaCommands,pDescs)	\
+    ( (This)->lpVtbl -> EnumerateMetaCommands(This,pNumMetaCommands,pDescs) ) 
+
+#define ID3D12Device5_EnumerateMetaCommandParameters(This,CommandId,Stage,pTotalStructureSizeInBytes,pParameterCount,pParameterDescs)	\
+    ( (This)->lpVtbl -> EnumerateMetaCommandParameters(This,CommandId,Stage,pTotalStructureSizeInBytes,pParameterCount,pParameterDescs) ) 
+
+#define ID3D12Device5_CreateMetaCommand(This,CommandId,NodeMask,pCreationParametersData,CreationParametersDataSizeInBytes,riid,ppMetaCommand)	\
+    ( (This)->lpVtbl -> CreateMetaCommand(This,CommandId,NodeMask,pCreationParametersData,CreationParametersDataSizeInBytes,riid,ppMetaCommand) ) 
+
+#define ID3D12Device5_CreateStateObject(This,pDesc,riid,ppStateObject)	\
+    ( (This)->lpVtbl -> CreateStateObject(This,pDesc,riid,ppStateObject) ) 
+
+#define ID3D12Device5_GetRaytracingAccelerationStructurePrebuildInfo(This,pDesc,pInfo)	\
+    ( (This)->lpVtbl -> GetRaytracingAccelerationStructurePrebuildInfo(This,pDesc,pInfo) ) 
+
+#define ID3D12Device5_CheckDriverMatchingIdentifier(This,SerializedDataType,pIdentifierToCheck)	\
+    ( (This)->lpVtbl -> CheckDriverMatchingIdentifier(This,SerializedDataType,pIdentifierToCheck) ) 
+
+#endif /* COBJMACROS */
+
+
+#endif 	/* C style interface */
+
+
+
+
+#endif 	/* __ID3D12Device5_INTERFACE_DEFINED__ */
+
+
+/* interface __MIDL_itf_d3d12_0000_0035 */
+/* [local] */ 
+
+typedef 
+enum D3D12_AUTO_BREADCRUMB_OP
+    {
+        D3D12_AUTO_BREADCRUMB_OP_SETMARKER	= 0,
+        D3D12_AUTO_BREADCRUMB_OP_BEGINEVENT	= 1,
+        D3D12_AUTO_BREADCRUMB_OP_ENDEVENT	= 2,
+        D3D12_AUTO_BREADCRUMB_OP_DRAWINSTANCED	= 3,
+        D3D12_AUTO_BREADCRUMB_OP_DRAWINDEXEDINSTANCED	= 4,
+        D3D12_AUTO_BREADCRUMB_OP_EXECUTEINDIRECT	= 5,
+        D3D12_AUTO_BREADCRUMB_OP_DISPATCH	= 6,
+        D3D12_AUTO_BREADCRUMB_OP_COPYBUFFERREGION	= 7,
+        D3D12_AUTO_BREADCRUMB_OP_COPYTEXTUREREGION	= 8,
+        D3D12_AUTO_BREADCRUMB_OP_COPYRESOURCE	= 9,
+        D3D12_AUTO_BREADCRUMB_OP_COPYTILES	= 10,
+        D3D12_AUTO_BREADCRUMB_OP_RESOLVESUBRESOURCE	= 11,
+        D3D12_AUTO_BREADCRUMB_OP_CLEARRENDERTARGETVIEW	= 12,
+        D3D12_AUTO_BREADCRUMB_OP_CLEARUNORDEREDACCESSVIEW	= 13,
+        D3D12_AUTO_BREADCRUMB_OP_CLEARDEPTHSTENCILVIEW	= 14,
+        D3D12_AUTO_BREADCRUMB_OP_RESOURCEBARRIER	= 15,
+        D3D12_AUTO_BREADCRUMB_OP_EXECUTEBUNDLE	= 16,
+        D3D12_AUTO_BREADCRUMB_OP_PRESENT	= 17,
+        D3D12_AUTO_BREADCRUMB_OP_RESOLVEQUERYDATA	= 18,
+        D3D12_AUTO_BREADCRUMB_OP_BEGINSUBMISSION	= 19,
+        D3D12_AUTO_BREADCRUMB_OP_ENDSUBMISSION	= 20,
+        D3D12_AUTO_BREADCRUMB_OP_DECODEFRAME	= 21,
+        D3D12_AUTO_BREADCRUMB_OP_PROCESSFRAMES	= 22,
+        D3D12_AUTO_BREADCRUMB_OP_ATOMICCOPYBUFFERUINT	= 23,
+        D3D12_AUTO_BREADCRUMB_OP_ATOMICCOPYBUFFERUINT64	= 24,
+        D3D12_AUTO_BREADCRUMB_OP_RESOLVESUBRESOURCEREGION	= 25,
+        D3D12_AUTO_BREADCRUMB_OP_WRITEBUFFERIMMEDIATE	= 26,
+        D3D12_AUTO_BREADCRUMB_OP_DECODEFRAME1	= 27,
+        D3D12_AUTO_BREADCRUMB_OP_SETPROTECTEDRESOURCESESSION	= 28,
+        D3D12_AUTO_BREADCRUMB_OP_DECODEFRAME2	= 29,
+        D3D12_AUTO_BREADCRUMB_OP_PROCESSFRAMES1	= 30,
+        D3D12_AUTO_BREADCRUMB_OP_BUILDRAYTRACINGACCELERATIONSTRUCTURE	= 31,
+        D3D12_AUTO_BREADCRUMB_OP_EMITRAYTRACINGACCELERATIONSTRUCTUREPOSTBUILDINFO	= 32,
+        D3D12_AUTO_BREADCRUMB_OP_COPYRAYTRACINGACCELERATIONSTRUCTURE	= 33,
+        D3D12_AUTO_BREADCRUMB_OP_DISPATCHRAYS	= 34,
+        D3D12_AUTO_BREADCRUMB_OP_INITIALIZEMETACOMMAND	= 35,
+        D3D12_AUTO_BREADCRUMB_OP_EXECUTEMETACOMMAND	= 36,
+        D3D12_AUTO_BREADCRUMB_OP_ESTIMATEMOTION	= 37,
+        D3D12_AUTO_BREADCRUMB_OP_RESOLVEMOTIONVECTORHEAP	= 38,
+        D3D12_AUTO_BREADCRUMB_OP_SETPIPELINESTATE1	= 39,
+        D3D12_AUTO_BREADCRUMB_OP_INITIALIZEEXTENSIONCOMMAND	= 40,
+        D3D12_AUTO_BREADCRUMB_OP_EXECUTEEXTENSIONCOMMAND	= 41,
+        D3D12_AUTO_BREADCRUMB_OP_DISPATCHMESH	= 42,
+        D3D12_AUTO_BREADCRUMB_OP_ENCODEFRAME	= 43,
+        D3D12_AUTO_BREADCRUMB_OP_RESOLVEENCODEROUTPUTMETADATA	= 44
+    } 	D3D12_AUTO_BREADCRUMB_OP;
+
+typedef struct D3D12_AUTO_BREADCRUMB_NODE
+    {
+    const char *pCommandListDebugNameA;
+    const wchar_t *pCommandListDebugNameW;
+    const char *pCommandQueueDebugNameA;
+    const wchar_t *pCommandQueueDebugNameW;
+    ID3D12GraphicsCommandList *pCommandList;
+    ID3D12CommandQueue *pCommandQueue;
+    UINT32 BreadcrumbCount;
+    const UINT32 *pLastBreadcrumbValue;
+    const D3D12_AUTO_BREADCRUMB_OP *pCommandHistory;
+    const struct D3D12_AUTO_BREADCRUMB_NODE *pNext;
+    } 	D3D12_AUTO_BREADCRUMB_NODE;
+
+typedef struct D3D12_DRED_BREADCRUMB_CONTEXT
+    {
+    UINT BreadcrumbIndex;
+    const wchar_t *pContextString;
+    } 	D3D12_DRED_BREADCRUMB_CONTEXT;
+
+typedef struct D3D12_AUTO_BREADCRUMB_NODE1
+    {
+    const char *pCommandListDebugNameA;
+    const wchar_t *pCommandListDebugNameW;
+    const char *pCommandQueueDebugNameA;
+    const wchar_t *pCommandQueueDebugNameW;
+    ID3D12GraphicsCommandList *pCommandList;
+    ID3D12CommandQueue *pCommandQueue;
+    UINT BreadcrumbCount;
+    const UINT *pLastBreadcrumbValue;
+    const D3D12_AUTO_BREADCRUMB_OP *pCommandHistory;
+    const struct D3D12_AUTO_BREADCRUMB_NODE1 *pNext;
+    UINT BreadcrumbContextsCount;
+    D3D12_DRED_BREADCRUMB_CONTEXT *pBreadcrumbContexts;
+    } 	D3D12_AUTO_BREADCRUMB_NODE1;
+
+typedef 
+enum D3D12_DRED_VERSION
+    {
+        D3D12_DRED_VERSION_1_0	= 0x1,
+        D3D12_DRED_VERSION_1_1	= 0x2,
+        D3D12_DRED_VERSION_1_2	= 0x3,
+        D3D12_DRED_VERSION_1_3	= 0x4
+    } 	D3D12_DRED_VERSION;
+
+typedef 
+enum D3D12_DRED_FLAGS
+    {
+        D3D12_DRED_FLAG_NONE	= 0,
+        D3D12_DRED_FLAG_FORCE_ENABLE	= 1,
+        D3D12_DRED_FLAG_DISABLE_AUTOBREADCRUMBS	= 2
+    } 	D3D12_DRED_FLAGS;
+
+DEFINE_ENUM_FLAG_OPERATORS( D3D12_DRED_FLAGS );
+typedef 
+enum D3D12_DRED_ENABLEMENT
+    {
+        D3D12_DRED_ENABLEMENT_SYSTEM_CONTROLLED	= 0,
+        D3D12_DRED_ENABLEMENT_FORCED_OFF	= 1,
+        D3D12_DRED_ENABLEMENT_FORCED_ON	= 2
+    } 	D3D12_DRED_ENABLEMENT;
+
+typedef struct D3D12_DEVICE_REMOVED_EXTENDED_DATA
+    {
+    _In_  D3D12_DRED_FLAGS Flags;
+    _Out_  D3D12_AUTO_BREADCRUMB_NODE *pHeadAutoBreadcrumbNode;
+    } 	D3D12_DEVICE_REMOVED_EXTENDED_DATA;
+
+typedef 
+enum D3D12_DRED_ALLOCATION_TYPE
+    {
+        D3D12_DRED_ALLOCATION_TYPE_COMMAND_QUEUE	= 19,
+        D3D12_DRED_ALLOCATION_TYPE_COMMAND_ALLOCATOR	= 20,
+        D3D12_DRED_ALLOCATION_TYPE_PIPELINE_STATE	= 21,
+        D3D12_DRED_ALLOCATION_TYPE_COMMAND_LIST	= 22,
+        D3D12_DRED_ALLOCATION_TYPE_FENCE	= 23,
+        D3D12_DRED_ALLOCATION_TYPE_DESCRIPTOR_HEAP	= 24,
+        D3D12_DRED_ALLOCATION_TYPE_HEAP	= 25,
+        D3D12_DRED_ALLOCATION_TYPE_QUERY_HEAP	= 27,
+        D3D12_DRED_ALLOCATION_TYPE_COMMAND_SIGNATURE	= 28,
+        D3D12_DRED_ALLOCATION_TYPE_PIPELINE_LIBRARY	= 29,
+        D3D12_DRED_ALLOCATION_TYPE_VIDEO_DECODER	= 30,
+        D3D12_DRED_ALLOCATION_TYPE_VIDEO_PROCESSOR	= 32,
+        D3D12_DRED_ALLOCATION_TYPE_RESOURCE	= 34,
+        D3D12_DRED_ALLOCATION_TYPE_PASS	= 35,
+        D3D12_DRED_ALLOCATION_TYPE_CRYPTOSESSION	= 36,
+        D3D12_DRED_ALLOCATION_TYPE_CRYPTOSESSIONPOLICY	= 37,
+        D3D12_DRED_ALLOCATION_TYPE_PROTECTEDRESOURCESESSION	= 38,
+        D3D12_DRED_ALLOCATION_TYPE_VIDEO_DECODER_HEAP	= 39,
+        D3D12_DRED_ALLOCATION_TYPE_COMMAND_POOL	= 40,
+        D3D12_DRED_ALLOCATION_TYPE_COMMAND_RECORDER	= 41,
+        D3D12_DRED_ALLOCATION_TYPE_STATE_OBJECT	= 42,
+        D3D12_DRED_ALLOCATION_TYPE_METACOMMAND	= 43,
+        D3D12_DRED_ALLOCATION_TYPE_SCHEDULINGGROUP	= 44,
+        D3D12_DRED_ALLOCATION_TYPE_VIDEO_MOTION_ESTIMATOR	= 45,
+        D3D12_DRED_ALLOCATION_TYPE_VIDEO_MOTION_VECTOR_HEAP	= 46,
+        D3D12_DRED_ALLOCATION_TYPE_VIDEO_EXTENSION_COMMAND	= 47,
+        D3D12_DRED_ALLOCATION_TYPE_VIDEO_ENCODER	= 48,
+        D3D12_DRED_ALLOCATION_TYPE_VIDEO_ENCODER_HEAP	= 49,
+        D3D12_DRED_ALLOCATION_TYPE_INVALID	= 0xffffffff
+    } 	D3D12_DRED_ALLOCATION_TYPE;
+
+typedef struct D3D12_DRED_ALLOCATION_NODE
+    {
+    const char *ObjectNameA;
+    const wchar_t *ObjectNameW;
+    D3D12_DRED_ALLOCATION_TYPE AllocationType;
+    const struct D3D12_DRED_ALLOCATION_NODE *pNext;
+    } 	D3D12_DRED_ALLOCATION_NODE;
+
+typedef struct D3D12_DRED_ALLOCATION_NODE1
+    {
+    const char *ObjectNameA;
+    const wchar_t *ObjectNameW;
+    D3D12_DRED_ALLOCATION_TYPE AllocationType;
+    const struct D3D12_DRED_ALLOCATION_NODE1 *pNext;
+    const IUnknown *pObject;
+    } 	D3D12_DRED_ALLOCATION_NODE1;
+
+typedef struct D3D12_DRED_AUTO_BREADCRUMBS_OUTPUT
+    {
+    _Out_  const D3D12_AUTO_BREADCRUMB_NODE *pHeadAutoBreadcrumbNode;
+    } 	D3D12_DRED_AUTO_BREADCRUMBS_OUTPUT;
+
+typedef struct D3D12_DRED_AUTO_BREADCRUMBS_OUTPUT1
+    {
+    _Out_  const D3D12_AUTO_BREADCRUMB_NODE1 *pHeadAutoBreadcrumbNode;
+    } 	D3D12_DRED_AUTO_BREADCRUMBS_OUTPUT1;
+
+typedef struct D3D12_DRED_PAGE_FAULT_OUTPUT
+    {
+    D3D12_GPU_VIRTUAL_ADDRESS PageFaultVA;
+    _Out_  const D3D12_DRED_ALLOCATION_NODE *pHeadExistingAllocationNode;
+    _Out_  const D3D12_DRED_ALLOCATION_NODE *pHeadRecentFreedAllocationNode;
+    } 	D3D12_DRED_PAGE_FAULT_OUTPUT;
+
+typedef struct D3D12_DRED_PAGE_FAULT_OUTPUT1
+    {
+    D3D12_GPU_VIRTUAL_ADDRESS PageFaultVA;
+    _Out_  const D3D12_DRED_ALLOCATION_NODE1 *pHeadExistingAllocationNode;
+    _Out_  const D3D12_DRED_ALLOCATION_NODE1 *pHeadRecentFreedAllocationNode;
+    } 	D3D12_DRED_PAGE_FAULT_OUTPUT1;
+
+typedef 
+enum D3D12_DRED_PAGE_FAULT_FLAGS
+    {
+        D3D12_DRED_PAGE_FAULT_FLAGS_NONE	= 0
+    } 	D3D12_DRED_PAGE_FAULT_FLAGS;
+
+DEFINE_ENUM_FLAG_OPERATORS( D3D12_DRED_PAGE_FAULT_FLAGS );
+typedef 
+enum D3D12_DRED_DEVICE_STATE
+    {
+        D3D12_DRED_DEVICE_STATE_UNKNOWN	= 0,
+        D3D12_DRED_DEVICE_STATE_HUNG	= 3,
+        D3D12_DRED_DEVICE_STATE_FAULT	= 6,
+        D3D12_DRED_DEVICE_STATE_PAGEFAULT	= 7
+    } 	D3D12_DRED_DEVICE_STATE;
+
+typedef struct D3D12_DRED_PAGE_FAULT_OUTPUT2
+    {
+    D3D12_GPU_VIRTUAL_ADDRESS PageFaultVA;
+    _Out_  const D3D12_DRED_ALLOCATION_NODE1 *pHeadExistingAllocationNode;
+    _Out_  const D3D12_DRED_ALLOCATION_NODE1 *pHeadRecentFreedAllocationNode;
+    D3D12_DRED_PAGE_FAULT_FLAGS PageFaultFlags;
+    } 	D3D12_DRED_PAGE_FAULT_OUTPUT2;
+
+typedef struct D3D12_DEVICE_REMOVED_EXTENDED_DATA1
+    {
+    HRESULT DeviceRemovedReason;
+    D3D12_DRED_AUTO_BREADCRUMBS_OUTPUT AutoBreadcrumbsOutput;
+    D3D12_DRED_PAGE_FAULT_OUTPUT PageFaultOutput;
+    } 	D3D12_DEVICE_REMOVED_EXTENDED_DATA1;
+
+typedef struct D3D12_DEVICE_REMOVED_EXTENDED_DATA2
+    {
+    HRESULT DeviceRemovedReason;
+    D3D12_DRED_AUTO_BREADCRUMBS_OUTPUT1 AutoBreadcrumbsOutput;
+    D3D12_DRED_PAGE_FAULT_OUTPUT1 PageFaultOutput;
+    } 	D3D12_DEVICE_REMOVED_EXTENDED_DATA2;
+
+typedef struct D3D12_DEVICE_REMOVED_EXTENDED_DATA3
+    {
+    HRESULT DeviceRemovedReason;
+    D3D12_DRED_AUTO_BREADCRUMBS_OUTPUT1 AutoBreadcrumbsOutput;
+    D3D12_DRED_PAGE_FAULT_OUTPUT2 PageFaultOutput;
+    D3D12_DRED_DEVICE_STATE DeviceState;
+    } 	D3D12_DEVICE_REMOVED_EXTENDED_DATA3;
+
+typedef struct D3D12_VERSIONED_DEVICE_REMOVED_EXTENDED_DATA
+    {
+    D3D12_DRED_VERSION Version;
+    union 
+        {
+        D3D12_DEVICE_REMOVED_EXTENDED_DATA Dred_1_0;
+        D3D12_DEVICE_REMOVED_EXTENDED_DATA1 Dred_1_1;
+        D3D12_DEVICE_REMOVED_EXTENDED_DATA2 Dred_1_2;
+        D3D12_DEVICE_REMOVED_EXTENDED_DATA3 Dred_1_3;
+        } 	;
+    } 	D3D12_VERSIONED_DEVICE_REMOVED_EXTENDED_DATA;
+
+
+
+extern RPC_IF_HANDLE __MIDL_itf_d3d12_0000_0035_v0_0_c_ifspec;
+extern RPC_IF_HANDLE __MIDL_itf_d3d12_0000_0035_v0_0_s_ifspec;
+
+#ifndef __ID3D12DeviceRemovedExtendedDataSettings_INTERFACE_DEFINED__
+#define __ID3D12DeviceRemovedExtendedDataSettings_INTERFACE_DEFINED__
+
+/* interface ID3D12DeviceRemovedExtendedDataSettings */
+/* [unique][local][object][uuid] */ 
+
+
+EXTERN_C const IID IID_ID3D12DeviceRemovedExtendedDataSettings;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("82BC481C-6B9B-4030-AEDB-7EE3D1DF1E63")
+    ID3D12DeviceRemovedExtendedDataSettings : public IUnknown
+    {
+    public:
+        virtual void STDMETHODCALLTYPE SetAutoBreadcrumbsEnablement( 
+            D3D12_DRED_ENABLEMENT Enablement) = 0;
+        
+        virtual void STDMETHODCALLTYPE SetPageFaultEnablement( 
+            D3D12_DRED_ENABLEMENT Enablement) = 0;
+        
+        virtual void STDMETHODCALLTYPE SetWatsonDumpEnablement( 
+            D3D12_DRED_ENABLEMENT Enablement) = 0;
+        
+    };
+    
+    
+#else 	/* C style interface */
+
+    typedef struct ID3D12DeviceRemovedExtendedDataSettingsVtbl
+    {
+        BEGIN_INTERFACE
+        
+        DECLSPEC_XFGVIRT(IUnknown, QueryInterface)
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            ID3D12DeviceRemovedExtendedDataSettings * This,
+            REFIID riid,
+            _COM_Outptr_  void **ppvObject);
+        
+        DECLSPEC_XFGVIRT(IUnknown, AddRef)
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            ID3D12DeviceRemovedExtendedDataSettings * This);
+        
+        DECLSPEC_XFGVIRT(IUnknown, Release)
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            ID3D12DeviceRemovedExtendedDataSettings * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12DeviceRemovedExtendedDataSettings, SetAutoBreadcrumbsEnablement)
+        void ( STDMETHODCALLTYPE *SetAutoBreadcrumbsEnablement )( 
+            ID3D12DeviceRemovedExtendedDataSettings * This,
+            D3D12_DRED_ENABLEMENT Enablement);
+        
+        DECLSPEC_XFGVIRT(ID3D12DeviceRemovedExtendedDataSettings, SetPageFaultEnablement)
+        void ( STDMETHODCALLTYPE *SetPageFaultEnablement )( 
+            ID3D12DeviceRemovedExtendedDataSettings * This,
+            D3D12_DRED_ENABLEMENT Enablement);
+        
+        DECLSPEC_XFGVIRT(ID3D12DeviceRemovedExtendedDataSettings, SetWatsonDumpEnablement)
+        void ( STDMETHODCALLTYPE *SetWatsonDumpEnablement )( 
+            ID3D12DeviceRemovedExtendedDataSettings * This,
+            D3D12_DRED_ENABLEMENT Enablement);
+        
+        END_INTERFACE
+    } ID3D12DeviceRemovedExtendedDataSettingsVtbl;
+
+    interface ID3D12DeviceRemovedExtendedDataSettings
+    {
+        CONST_VTBL struct ID3D12DeviceRemovedExtendedDataSettingsVtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define ID3D12DeviceRemovedExtendedDataSettings_QueryInterface(This,riid,ppvObject)	\
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define ID3D12DeviceRemovedExtendedDataSettings_AddRef(This)	\
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define ID3D12DeviceRemovedExtendedDataSettings_Release(This)	\
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#define ID3D12DeviceRemovedExtendedDataSettings_SetAutoBreadcrumbsEnablement(This,Enablement)	\
+    ( (This)->lpVtbl -> SetAutoBreadcrumbsEnablement(This,Enablement) ) 
+
+#define ID3D12DeviceRemovedExtendedDataSettings_SetPageFaultEnablement(This,Enablement)	\
+    ( (This)->lpVtbl -> SetPageFaultEnablement(This,Enablement) ) 
+
+#define ID3D12DeviceRemovedExtendedDataSettings_SetWatsonDumpEnablement(This,Enablement)	\
+    ( (This)->lpVtbl -> SetWatsonDumpEnablement(This,Enablement) ) 
+
+#endif /* COBJMACROS */
+
+
+#endif 	/* C style interface */
+
+
+
+
+#endif 	/* __ID3D12DeviceRemovedExtendedDataSettings_INTERFACE_DEFINED__ */
+
+
+#ifndef __ID3D12DeviceRemovedExtendedDataSettings1_INTERFACE_DEFINED__
+#define __ID3D12DeviceRemovedExtendedDataSettings1_INTERFACE_DEFINED__
+
+/* interface ID3D12DeviceRemovedExtendedDataSettings1 */
+/* [unique][local][object][uuid] */ 
+
+
+EXTERN_C const IID IID_ID3D12DeviceRemovedExtendedDataSettings1;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("DBD5AE51-3317-4F0A-ADF9-1D7CEDCAAE0B")
+    ID3D12DeviceRemovedExtendedDataSettings1 : public ID3D12DeviceRemovedExtendedDataSettings
+    {
+    public:
+        virtual void STDMETHODCALLTYPE SetBreadcrumbContextEnablement( 
+            D3D12_DRED_ENABLEMENT Enablement) = 0;
+        
+    };
+    
+    
+#else 	/* C style interface */
+
+    typedef struct ID3D12DeviceRemovedExtendedDataSettings1Vtbl
+    {
+        BEGIN_INTERFACE
+        
+        DECLSPEC_XFGVIRT(IUnknown, QueryInterface)
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            ID3D12DeviceRemovedExtendedDataSettings1 * This,
+            REFIID riid,
+            _COM_Outptr_  void **ppvObject);
+        
+        DECLSPEC_XFGVIRT(IUnknown, AddRef)
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            ID3D12DeviceRemovedExtendedDataSettings1 * This);
+        
+        DECLSPEC_XFGVIRT(IUnknown, Release)
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            ID3D12DeviceRemovedExtendedDataSettings1 * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12DeviceRemovedExtendedDataSettings, SetAutoBreadcrumbsEnablement)
+        void ( STDMETHODCALLTYPE *SetAutoBreadcrumbsEnablement )( 
+            ID3D12DeviceRemovedExtendedDataSettings1 * This,
+            D3D12_DRED_ENABLEMENT Enablement);
+        
+        DECLSPEC_XFGVIRT(ID3D12DeviceRemovedExtendedDataSettings, SetPageFaultEnablement)
+        void ( STDMETHODCALLTYPE *SetPageFaultEnablement )( 
+            ID3D12DeviceRemovedExtendedDataSettings1 * This,
+            D3D12_DRED_ENABLEMENT Enablement);
+        
+        DECLSPEC_XFGVIRT(ID3D12DeviceRemovedExtendedDataSettings, SetWatsonDumpEnablement)
+        void ( STDMETHODCALLTYPE *SetWatsonDumpEnablement )( 
+            ID3D12DeviceRemovedExtendedDataSettings1 * This,
+            D3D12_DRED_ENABLEMENT Enablement);
+        
+        DECLSPEC_XFGVIRT(ID3D12DeviceRemovedExtendedDataSettings1, SetBreadcrumbContextEnablement)
+        void ( STDMETHODCALLTYPE *SetBreadcrumbContextEnablement )( 
+            ID3D12DeviceRemovedExtendedDataSettings1 * This,
+            D3D12_DRED_ENABLEMENT Enablement);
+        
+        END_INTERFACE
+    } ID3D12DeviceRemovedExtendedDataSettings1Vtbl;
+
+    interface ID3D12DeviceRemovedExtendedDataSettings1
+    {
+        CONST_VTBL struct ID3D12DeviceRemovedExtendedDataSettings1Vtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define ID3D12DeviceRemovedExtendedDataSettings1_QueryInterface(This,riid,ppvObject)	\
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define ID3D12DeviceRemovedExtendedDataSettings1_AddRef(This)	\
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define ID3D12DeviceRemovedExtendedDataSettings1_Release(This)	\
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#define ID3D12DeviceRemovedExtendedDataSettings1_SetAutoBreadcrumbsEnablement(This,Enablement)	\
+    ( (This)->lpVtbl -> SetAutoBreadcrumbsEnablement(This,Enablement) ) 
+
+#define ID3D12DeviceRemovedExtendedDataSettings1_SetPageFaultEnablement(This,Enablement)	\
+    ( (This)->lpVtbl -> SetPageFaultEnablement(This,Enablement) ) 
+
+#define ID3D12DeviceRemovedExtendedDataSettings1_SetWatsonDumpEnablement(This,Enablement)	\
+    ( (This)->lpVtbl -> SetWatsonDumpEnablement(This,Enablement) ) 
+
+
+#define ID3D12DeviceRemovedExtendedDataSettings1_SetBreadcrumbContextEnablement(This,Enablement)	\
+    ( (This)->lpVtbl -> SetBreadcrumbContextEnablement(This,Enablement) ) 
+
+#endif /* COBJMACROS */
+
+
+#endif 	/* C style interface */
+
+
+
+
+#endif 	/* __ID3D12DeviceRemovedExtendedDataSettings1_INTERFACE_DEFINED__ */
+
+
+#ifndef __ID3D12DeviceRemovedExtendedDataSettings2_INTERFACE_DEFINED__
+#define __ID3D12DeviceRemovedExtendedDataSettings2_INTERFACE_DEFINED__
+
+/* interface ID3D12DeviceRemovedExtendedDataSettings2 */
+/* [unique][local][object][uuid] */ 
+
+
+EXTERN_C const IID IID_ID3D12DeviceRemovedExtendedDataSettings2;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("61552388-01ab-4008-a436-83db189566ea")
+    ID3D12DeviceRemovedExtendedDataSettings2 : public ID3D12DeviceRemovedExtendedDataSettings1
+    {
+    public:
+        virtual void STDMETHODCALLTYPE UseMarkersOnlyAutoBreadcrumbs( 
+            BOOL MarkersOnly) = 0;
+        
+    };
+    
+    
+#else 	/* C style interface */
+
+    typedef struct ID3D12DeviceRemovedExtendedDataSettings2Vtbl
+    {
+        BEGIN_INTERFACE
+        
+        DECLSPEC_XFGVIRT(IUnknown, QueryInterface)
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            ID3D12DeviceRemovedExtendedDataSettings2 * This,
+            REFIID riid,
+            _COM_Outptr_  void **ppvObject);
+        
+        DECLSPEC_XFGVIRT(IUnknown, AddRef)
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            ID3D12DeviceRemovedExtendedDataSettings2 * This);
+        
+        DECLSPEC_XFGVIRT(IUnknown, Release)
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            ID3D12DeviceRemovedExtendedDataSettings2 * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12DeviceRemovedExtendedDataSettings, SetAutoBreadcrumbsEnablement)
+        void ( STDMETHODCALLTYPE *SetAutoBreadcrumbsEnablement )( 
+            ID3D12DeviceRemovedExtendedDataSettings2 * This,
+            D3D12_DRED_ENABLEMENT Enablement);
+        
+        DECLSPEC_XFGVIRT(ID3D12DeviceRemovedExtendedDataSettings, SetPageFaultEnablement)
+        void ( STDMETHODCALLTYPE *SetPageFaultEnablement )( 
+            ID3D12DeviceRemovedExtendedDataSettings2 * This,
+            D3D12_DRED_ENABLEMENT Enablement);
+        
+        DECLSPEC_XFGVIRT(ID3D12DeviceRemovedExtendedDataSettings, SetWatsonDumpEnablement)
+        void ( STDMETHODCALLTYPE *SetWatsonDumpEnablement )( 
+            ID3D12DeviceRemovedExtendedDataSettings2 * This,
+            D3D12_DRED_ENABLEMENT Enablement);
+        
+        DECLSPEC_XFGVIRT(ID3D12DeviceRemovedExtendedDataSettings1, SetBreadcrumbContextEnablement)
+        void ( STDMETHODCALLTYPE *SetBreadcrumbContextEnablement )( 
+            ID3D12DeviceRemovedExtendedDataSettings2 * This,
+            D3D12_DRED_ENABLEMENT Enablement);
+        
+        DECLSPEC_XFGVIRT(ID3D12DeviceRemovedExtendedDataSettings2, UseMarkersOnlyAutoBreadcrumbs)
+        void ( STDMETHODCALLTYPE *UseMarkersOnlyAutoBreadcrumbs )( 
+            ID3D12DeviceRemovedExtendedDataSettings2 * This,
+            BOOL MarkersOnly);
+        
+        END_INTERFACE
+    } ID3D12DeviceRemovedExtendedDataSettings2Vtbl;
+
+    interface ID3D12DeviceRemovedExtendedDataSettings2
+    {
+        CONST_VTBL struct ID3D12DeviceRemovedExtendedDataSettings2Vtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define ID3D12DeviceRemovedExtendedDataSettings2_QueryInterface(This,riid,ppvObject)	\
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define ID3D12DeviceRemovedExtendedDataSettings2_AddRef(This)	\
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define ID3D12DeviceRemovedExtendedDataSettings2_Release(This)	\
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#define ID3D12DeviceRemovedExtendedDataSettings2_SetAutoBreadcrumbsEnablement(This,Enablement)	\
+    ( (This)->lpVtbl -> SetAutoBreadcrumbsEnablement(This,Enablement) ) 
+
+#define ID3D12DeviceRemovedExtendedDataSettings2_SetPageFaultEnablement(This,Enablement)	\
+    ( (This)->lpVtbl -> SetPageFaultEnablement(This,Enablement) ) 
+
+#define ID3D12DeviceRemovedExtendedDataSettings2_SetWatsonDumpEnablement(This,Enablement)	\
+    ( (This)->lpVtbl -> SetWatsonDumpEnablement(This,Enablement) ) 
+
+
+#define ID3D12DeviceRemovedExtendedDataSettings2_SetBreadcrumbContextEnablement(This,Enablement)	\
+    ( (This)->lpVtbl -> SetBreadcrumbContextEnablement(This,Enablement) ) 
+
+
+#define ID3D12DeviceRemovedExtendedDataSettings2_UseMarkersOnlyAutoBreadcrumbs(This,MarkersOnly)	\
+    ( (This)->lpVtbl -> UseMarkersOnlyAutoBreadcrumbs(This,MarkersOnly) ) 
+
+#endif /* COBJMACROS */
+
+
+#endif 	/* C style interface */
+
+
+
+
+#endif 	/* __ID3D12DeviceRemovedExtendedDataSettings2_INTERFACE_DEFINED__ */
+
+
+#ifndef __ID3D12DeviceRemovedExtendedData_INTERFACE_DEFINED__
+#define __ID3D12DeviceRemovedExtendedData_INTERFACE_DEFINED__
+
+/* interface ID3D12DeviceRemovedExtendedData */
+/* [unique][local][object][uuid] */ 
+
+
+EXTERN_C const IID IID_ID3D12DeviceRemovedExtendedData;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("98931D33-5AE8-4791-AA3C-1A73A2934E71")
+    ID3D12DeviceRemovedExtendedData : public IUnknown
+    {
+    public:
+        virtual HRESULT STDMETHODCALLTYPE GetAutoBreadcrumbsOutput( 
+            _Out_  D3D12_DRED_AUTO_BREADCRUMBS_OUTPUT *pOutput) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE GetPageFaultAllocationOutput( 
+            _Out_  D3D12_DRED_PAGE_FAULT_OUTPUT *pOutput) = 0;
+        
+    };
+    
+    
+#else 	/* C style interface */
+
+    typedef struct ID3D12DeviceRemovedExtendedDataVtbl
+    {
+        BEGIN_INTERFACE
+        
+        DECLSPEC_XFGVIRT(IUnknown, QueryInterface)
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            ID3D12DeviceRemovedExtendedData * This,
+            REFIID riid,
+            _COM_Outptr_  void **ppvObject);
+        
+        DECLSPEC_XFGVIRT(IUnknown, AddRef)
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            ID3D12DeviceRemovedExtendedData * This);
+        
+        DECLSPEC_XFGVIRT(IUnknown, Release)
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            ID3D12DeviceRemovedExtendedData * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12DeviceRemovedExtendedData, GetAutoBreadcrumbsOutput)
+        HRESULT ( STDMETHODCALLTYPE *GetAutoBreadcrumbsOutput )( 
+            ID3D12DeviceRemovedExtendedData * This,
+            _Out_  D3D12_DRED_AUTO_BREADCRUMBS_OUTPUT *pOutput);
+        
+        DECLSPEC_XFGVIRT(ID3D12DeviceRemovedExtendedData, GetPageFaultAllocationOutput)
+        HRESULT ( STDMETHODCALLTYPE *GetPageFaultAllocationOutput )( 
+            ID3D12DeviceRemovedExtendedData * This,
+            _Out_  D3D12_DRED_PAGE_FAULT_OUTPUT *pOutput);
+        
+        END_INTERFACE
+    } ID3D12DeviceRemovedExtendedDataVtbl;
+
+    interface ID3D12DeviceRemovedExtendedData
+    {
+        CONST_VTBL struct ID3D12DeviceRemovedExtendedDataVtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define ID3D12DeviceRemovedExtendedData_QueryInterface(This,riid,ppvObject)	\
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define ID3D12DeviceRemovedExtendedData_AddRef(This)	\
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define ID3D12DeviceRemovedExtendedData_Release(This)	\
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#define ID3D12DeviceRemovedExtendedData_GetAutoBreadcrumbsOutput(This,pOutput)	\
+    ( (This)->lpVtbl -> GetAutoBreadcrumbsOutput(This,pOutput) ) 
+
+#define ID3D12DeviceRemovedExtendedData_GetPageFaultAllocationOutput(This,pOutput)	\
+    ( (This)->lpVtbl -> GetPageFaultAllocationOutput(This,pOutput) ) 
+
+#endif /* COBJMACROS */
+
+
+#endif 	/* C style interface */
+
+
+
+
+#endif 	/* __ID3D12DeviceRemovedExtendedData_INTERFACE_DEFINED__ */
+
+
+#ifndef __ID3D12DeviceRemovedExtendedData1_INTERFACE_DEFINED__
+#define __ID3D12DeviceRemovedExtendedData1_INTERFACE_DEFINED__
+
+/* interface ID3D12DeviceRemovedExtendedData1 */
+/* [unique][local][object][uuid] */ 
+
+
+EXTERN_C const IID IID_ID3D12DeviceRemovedExtendedData1;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("9727A022-CF1D-4DDA-9EBA-EFFA653FC506")
+    ID3D12DeviceRemovedExtendedData1 : public ID3D12DeviceRemovedExtendedData
+    {
+    public:
+        virtual HRESULT STDMETHODCALLTYPE GetAutoBreadcrumbsOutput1( 
+            _Out_  D3D12_DRED_AUTO_BREADCRUMBS_OUTPUT1 *pOutput) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE GetPageFaultAllocationOutput1( 
+            _Out_  D3D12_DRED_PAGE_FAULT_OUTPUT1 *pOutput) = 0;
+        
+    };
+    
+    
+#else 	/* C style interface */
+
+    typedef struct ID3D12DeviceRemovedExtendedData1Vtbl
+    {
+        BEGIN_INTERFACE
+        
+        DECLSPEC_XFGVIRT(IUnknown, QueryInterface)
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            ID3D12DeviceRemovedExtendedData1 * This,
+            REFIID riid,
+            _COM_Outptr_  void **ppvObject);
+        
+        DECLSPEC_XFGVIRT(IUnknown, AddRef)
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            ID3D12DeviceRemovedExtendedData1 * This);
+        
+        DECLSPEC_XFGVIRT(IUnknown, Release)
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            ID3D12DeviceRemovedExtendedData1 * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12DeviceRemovedExtendedData, GetAutoBreadcrumbsOutput)
+        HRESULT ( STDMETHODCALLTYPE *GetAutoBreadcrumbsOutput )( 
+            ID3D12DeviceRemovedExtendedData1 * This,
+            _Out_  D3D12_DRED_AUTO_BREADCRUMBS_OUTPUT *pOutput);
+        
+        DECLSPEC_XFGVIRT(ID3D12DeviceRemovedExtendedData, GetPageFaultAllocationOutput)
+        HRESULT ( STDMETHODCALLTYPE *GetPageFaultAllocationOutput )( 
+            ID3D12DeviceRemovedExtendedData1 * This,
+            _Out_  D3D12_DRED_PAGE_FAULT_OUTPUT *pOutput);
+        
+        DECLSPEC_XFGVIRT(ID3D12DeviceRemovedExtendedData1, GetAutoBreadcrumbsOutput1)
+        HRESULT ( STDMETHODCALLTYPE *GetAutoBreadcrumbsOutput1 )( 
+            ID3D12DeviceRemovedExtendedData1 * This,
+            _Out_  D3D12_DRED_AUTO_BREADCRUMBS_OUTPUT1 *pOutput);
+        
+        DECLSPEC_XFGVIRT(ID3D12DeviceRemovedExtendedData1, GetPageFaultAllocationOutput1)
+        HRESULT ( STDMETHODCALLTYPE *GetPageFaultAllocationOutput1 )( 
+            ID3D12DeviceRemovedExtendedData1 * This,
+            _Out_  D3D12_DRED_PAGE_FAULT_OUTPUT1 *pOutput);
+        
+        END_INTERFACE
+    } ID3D12DeviceRemovedExtendedData1Vtbl;
+
+    interface ID3D12DeviceRemovedExtendedData1
+    {
+        CONST_VTBL struct ID3D12DeviceRemovedExtendedData1Vtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define ID3D12DeviceRemovedExtendedData1_QueryInterface(This,riid,ppvObject)	\
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define ID3D12DeviceRemovedExtendedData1_AddRef(This)	\
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define ID3D12DeviceRemovedExtendedData1_Release(This)	\
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#define ID3D12DeviceRemovedExtendedData1_GetAutoBreadcrumbsOutput(This,pOutput)	\
+    ( (This)->lpVtbl -> GetAutoBreadcrumbsOutput(This,pOutput) ) 
+
+#define ID3D12DeviceRemovedExtendedData1_GetPageFaultAllocationOutput(This,pOutput)	\
+    ( (This)->lpVtbl -> GetPageFaultAllocationOutput(This,pOutput) ) 
+
+
+#define ID3D12DeviceRemovedExtendedData1_GetAutoBreadcrumbsOutput1(This,pOutput)	\
+    ( (This)->lpVtbl -> GetAutoBreadcrumbsOutput1(This,pOutput) ) 
+
+#define ID3D12DeviceRemovedExtendedData1_GetPageFaultAllocationOutput1(This,pOutput)	\
+    ( (This)->lpVtbl -> GetPageFaultAllocationOutput1(This,pOutput) ) 
+
+#endif /* COBJMACROS */
+
+
+#endif 	/* C style interface */
+
+
+
+
+#endif 	/* __ID3D12DeviceRemovedExtendedData1_INTERFACE_DEFINED__ */
+
+
+#ifndef __ID3D12DeviceRemovedExtendedData2_INTERFACE_DEFINED__
+#define __ID3D12DeviceRemovedExtendedData2_INTERFACE_DEFINED__
+
+/* interface ID3D12DeviceRemovedExtendedData2 */
+/* [unique][local][object][uuid] */ 
+
+
+EXTERN_C const IID IID_ID3D12DeviceRemovedExtendedData2;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("67FC5816-E4CA-4915-BF18-42541272DA54")
+    ID3D12DeviceRemovedExtendedData2 : public ID3D12DeviceRemovedExtendedData1
+    {
+    public:
+        virtual HRESULT STDMETHODCALLTYPE GetPageFaultAllocationOutput2( 
+            _Out_  D3D12_DRED_PAGE_FAULT_OUTPUT2 *pOutput) = 0;
+        
+        virtual D3D12_DRED_DEVICE_STATE STDMETHODCALLTYPE GetDeviceState( void) = 0;
+        
+    };
+    
+    
+#else 	/* C style interface */
+
+    typedef struct ID3D12DeviceRemovedExtendedData2Vtbl
+    {
+        BEGIN_INTERFACE
+        
+        DECLSPEC_XFGVIRT(IUnknown, QueryInterface)
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            ID3D12DeviceRemovedExtendedData2 * This,
+            REFIID riid,
+            _COM_Outptr_  void **ppvObject);
+        
+        DECLSPEC_XFGVIRT(IUnknown, AddRef)
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            ID3D12DeviceRemovedExtendedData2 * This);
+        
+        DECLSPEC_XFGVIRT(IUnknown, Release)
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            ID3D12DeviceRemovedExtendedData2 * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12DeviceRemovedExtendedData, GetAutoBreadcrumbsOutput)
+        HRESULT ( STDMETHODCALLTYPE *GetAutoBreadcrumbsOutput )( 
+            ID3D12DeviceRemovedExtendedData2 * This,
+            _Out_  D3D12_DRED_AUTO_BREADCRUMBS_OUTPUT *pOutput);
+        
+        DECLSPEC_XFGVIRT(ID3D12DeviceRemovedExtendedData, GetPageFaultAllocationOutput)
+        HRESULT ( STDMETHODCALLTYPE *GetPageFaultAllocationOutput )( 
+            ID3D12DeviceRemovedExtendedData2 * This,
+            _Out_  D3D12_DRED_PAGE_FAULT_OUTPUT *pOutput);
+        
+        DECLSPEC_XFGVIRT(ID3D12DeviceRemovedExtendedData1, GetAutoBreadcrumbsOutput1)
+        HRESULT ( STDMETHODCALLTYPE *GetAutoBreadcrumbsOutput1 )( 
+            ID3D12DeviceRemovedExtendedData2 * This,
+            _Out_  D3D12_DRED_AUTO_BREADCRUMBS_OUTPUT1 *pOutput);
+        
+        DECLSPEC_XFGVIRT(ID3D12DeviceRemovedExtendedData1, GetPageFaultAllocationOutput1)
+        HRESULT ( STDMETHODCALLTYPE *GetPageFaultAllocationOutput1 )( 
+            ID3D12DeviceRemovedExtendedData2 * This,
+            _Out_  D3D12_DRED_PAGE_FAULT_OUTPUT1 *pOutput);
+        
+        DECLSPEC_XFGVIRT(ID3D12DeviceRemovedExtendedData2, GetPageFaultAllocationOutput2)
+        HRESULT ( STDMETHODCALLTYPE *GetPageFaultAllocationOutput2 )( 
+            ID3D12DeviceRemovedExtendedData2 * This,
+            _Out_  D3D12_DRED_PAGE_FAULT_OUTPUT2 *pOutput);
+        
+        DECLSPEC_XFGVIRT(ID3D12DeviceRemovedExtendedData2, GetDeviceState)
+        D3D12_DRED_DEVICE_STATE ( STDMETHODCALLTYPE *GetDeviceState )( 
+            ID3D12DeviceRemovedExtendedData2 * This);
+        
+        END_INTERFACE
+    } ID3D12DeviceRemovedExtendedData2Vtbl;
+
+    interface ID3D12DeviceRemovedExtendedData2
+    {
+        CONST_VTBL struct ID3D12DeviceRemovedExtendedData2Vtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define ID3D12DeviceRemovedExtendedData2_QueryInterface(This,riid,ppvObject)	\
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define ID3D12DeviceRemovedExtendedData2_AddRef(This)	\
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define ID3D12DeviceRemovedExtendedData2_Release(This)	\
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#define ID3D12DeviceRemovedExtendedData2_GetAutoBreadcrumbsOutput(This,pOutput)	\
+    ( (This)->lpVtbl -> GetAutoBreadcrumbsOutput(This,pOutput) ) 
+
+#define ID3D12DeviceRemovedExtendedData2_GetPageFaultAllocationOutput(This,pOutput)	\
+    ( (This)->lpVtbl -> GetPageFaultAllocationOutput(This,pOutput) ) 
+
+
+#define ID3D12DeviceRemovedExtendedData2_GetAutoBreadcrumbsOutput1(This,pOutput)	\
+    ( (This)->lpVtbl -> GetAutoBreadcrumbsOutput1(This,pOutput) ) 
+
+#define ID3D12DeviceRemovedExtendedData2_GetPageFaultAllocationOutput1(This,pOutput)	\
+    ( (This)->lpVtbl -> GetPageFaultAllocationOutput1(This,pOutput) ) 
+
+
+#define ID3D12DeviceRemovedExtendedData2_GetPageFaultAllocationOutput2(This,pOutput)	\
+    ( (This)->lpVtbl -> GetPageFaultAllocationOutput2(This,pOutput) ) 
+
+#define ID3D12DeviceRemovedExtendedData2_GetDeviceState(This)	\
+    ( (This)->lpVtbl -> GetDeviceState(This) ) 
+
+#endif /* COBJMACROS */
+
+
+#endif 	/* C style interface */
+
+
+
+
+#endif 	/* __ID3D12DeviceRemovedExtendedData2_INTERFACE_DEFINED__ */
+
+
+/* interface __MIDL_itf_d3d12_0000_0041 */
+/* [local] */ 
+
+typedef 
+enum D3D12_BACKGROUND_PROCESSING_MODE
+    {
+        D3D12_BACKGROUND_PROCESSING_MODE_ALLOWED	= 0,
+        D3D12_BACKGROUND_PROCESSING_MODE_ALLOW_INTRUSIVE_MEASUREMENTS	= ( D3D12_BACKGROUND_PROCESSING_MODE_ALLOWED + 1 ) ,
+        D3D12_BACKGROUND_PROCESSING_MODE_DISABLE_BACKGROUND_WORK	= ( D3D12_BACKGROUND_PROCESSING_MODE_ALLOW_INTRUSIVE_MEASUREMENTS + 1 ) ,
+        D3D12_BACKGROUND_PROCESSING_MODE_DISABLE_PROFILING_BY_SYSTEM	= ( D3D12_BACKGROUND_PROCESSING_MODE_DISABLE_BACKGROUND_WORK + 1 ) 
+    } 	D3D12_BACKGROUND_PROCESSING_MODE;
+
+typedef 
+enum D3D12_MEASUREMENTS_ACTION
+    {
+        D3D12_MEASUREMENTS_ACTION_KEEP_ALL	= 0,
+        D3D12_MEASUREMENTS_ACTION_COMMIT_RESULTS	= ( D3D12_MEASUREMENTS_ACTION_KEEP_ALL + 1 ) ,
+        D3D12_MEASUREMENTS_ACTION_COMMIT_RESULTS_HIGH_PRIORITY	= ( D3D12_MEASUREMENTS_ACTION_COMMIT_RESULTS + 1 ) ,
+        D3D12_MEASUREMENTS_ACTION_DISCARD_PREVIOUS	= ( D3D12_MEASUREMENTS_ACTION_COMMIT_RESULTS_HIGH_PRIORITY + 1 ) 
+    } 	D3D12_MEASUREMENTS_ACTION;
+
+
+
+extern RPC_IF_HANDLE __MIDL_itf_d3d12_0000_0041_v0_0_c_ifspec;
+extern RPC_IF_HANDLE __MIDL_itf_d3d12_0000_0041_v0_0_s_ifspec;
+
+#ifndef __ID3D12Device6_INTERFACE_DEFINED__
+#define __ID3D12Device6_INTERFACE_DEFINED__
+
+/* interface ID3D12Device6 */
+/* [unique][local][object][uuid] */ 
+
+
+EXTERN_C const IID IID_ID3D12Device6;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("c70b221b-40e4-4a17-89af-025a0727a6dc")
+    ID3D12Device6 : public ID3D12Device5
+    {
+    public:
+        virtual HRESULT STDMETHODCALLTYPE SetBackgroundProcessingMode( 
+            D3D12_BACKGROUND_PROCESSING_MODE Mode,
+            D3D12_MEASUREMENTS_ACTION MeasurementsAction,
+            _In_opt_  HANDLE hEventToSignalUponCompletion,
+            _Out_opt_  BOOL *pbFurtherMeasurementsDesired) = 0;
+        
+    };
+    
+    
+#else 	/* C style interface */
+
+    typedef struct ID3D12Device6Vtbl
+    {
+        BEGIN_INTERFACE
+        
+        DECLSPEC_XFGVIRT(IUnknown, QueryInterface)
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            ID3D12Device6 * This,
+            REFIID riid,
+            _COM_Outptr_  void **ppvObject);
+        
+        DECLSPEC_XFGVIRT(IUnknown, AddRef)
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            ID3D12Device6 * This);
+        
+        DECLSPEC_XFGVIRT(IUnknown, Release)
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            ID3D12Device6 * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, GetPrivateData)
+        HRESULT ( STDMETHODCALLTYPE *GetPrivateData )( 
+            ID3D12Device6 * This,
+            _In_  REFGUID guid,
+            _Inout_  UINT *pDataSize,
+            _Out_writes_bytes_opt_( *pDataSize )  void *pData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, SetPrivateData)
+        HRESULT ( STDMETHODCALLTYPE *SetPrivateData )( 
+            ID3D12Device6 * This,
+            _In_  REFGUID guid,
+            _In_  UINT DataSize,
+            _In_reads_bytes_opt_( DataSize )  const void *pData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, SetPrivateDataInterface)
+        HRESULT ( STDMETHODCALLTYPE *SetPrivateDataInterface )( 
+            ID3D12Device6 * This,
+            _In_  REFGUID guid,
+            _In_opt_  const IUnknown *pData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, SetName)
+        HRESULT ( STDMETHODCALLTYPE *SetName )( 
+            ID3D12Device6 * This,
+            _In_z_  LPCWSTR Name);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, GetNodeCount)
+        UINT ( STDMETHODCALLTYPE *GetNodeCount )( 
+            ID3D12Device6 * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CreateCommandQueue)
+        HRESULT ( STDMETHODCALLTYPE *CreateCommandQueue )( 
+            ID3D12Device6 * This,
+            _In_  const D3D12_COMMAND_QUEUE_DESC *pDesc,
+            REFIID riid,
+            _COM_Outptr_  void **ppCommandQueue);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CreateCommandAllocator)
+        HRESULT ( STDMETHODCALLTYPE *CreateCommandAllocator )( 
+            ID3D12Device6 * This,
+            _In_  D3D12_COMMAND_LIST_TYPE type,
+            REFIID riid,
+            _COM_Outptr_  void **ppCommandAllocator);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CreateGraphicsPipelineState)
+        HRESULT ( STDMETHODCALLTYPE *CreateGraphicsPipelineState )( 
+            ID3D12Device6 * This,
+            _In_  const D3D12_GRAPHICS_PIPELINE_STATE_DESC *pDesc,
+            REFIID riid,
+            _COM_Outptr_  void **ppPipelineState);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CreateComputePipelineState)
+        HRESULT ( STDMETHODCALLTYPE *CreateComputePipelineState )( 
+            ID3D12Device6 * This,
+            _In_  const D3D12_COMPUTE_PIPELINE_STATE_DESC *pDesc,
+            REFIID riid,
+            _COM_Outptr_  void **ppPipelineState);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CreateCommandList)
+        HRESULT ( STDMETHODCALLTYPE *CreateCommandList )( 
+            ID3D12Device6 * This,
+            _In_  UINT nodeMask,
+            _In_  D3D12_COMMAND_LIST_TYPE type,
+            _In_  ID3D12CommandAllocator *pCommandAllocator,
+            _In_opt_  ID3D12PipelineState *pInitialState,
+            REFIID riid,
+            _COM_Outptr_  void **ppCommandList);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CheckFeatureSupport)
+        HRESULT ( STDMETHODCALLTYPE *CheckFeatureSupport )( 
+            ID3D12Device6 * This,
+            D3D12_FEATURE Feature,
+            _Inout_updates_bytes_(FeatureSupportDataSize)  void *pFeatureSupportData,
+            UINT FeatureSupportDataSize);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CreateDescriptorHeap)
+        HRESULT ( STDMETHODCALLTYPE *CreateDescriptorHeap )( 
+            ID3D12Device6 * This,
+            _In_  const D3D12_DESCRIPTOR_HEAP_DESC *pDescriptorHeapDesc,
+            REFIID riid,
+            _COM_Outptr_  void **ppvHeap);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, GetDescriptorHandleIncrementSize)
+        UINT ( STDMETHODCALLTYPE *GetDescriptorHandleIncrementSize )( 
+            ID3D12Device6 * This,
+            _In_  D3D12_DESCRIPTOR_HEAP_TYPE DescriptorHeapType);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CreateRootSignature)
+        HRESULT ( STDMETHODCALLTYPE *CreateRootSignature )( 
+            ID3D12Device6 * This,
+            _In_  UINT nodeMask,
+            _In_reads_(blobLengthInBytes)  const void *pBlobWithRootSignature,
+            _In_  SIZE_T blobLengthInBytes,
+            REFIID riid,
+            _COM_Outptr_  void **ppvRootSignature);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CreateConstantBufferView)
+        void ( STDMETHODCALLTYPE *CreateConstantBufferView )( 
+            ID3D12Device6 * This,
+            _In_opt_  const D3D12_CONSTANT_BUFFER_VIEW_DESC *pDesc,
+            _In_  D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CreateShaderResourceView)
+        void ( STDMETHODCALLTYPE *CreateShaderResourceView )( 
+            ID3D12Device6 * This,
+            _In_opt_  ID3D12Resource *pResource,
+            _In_opt_  const D3D12_SHADER_RESOURCE_VIEW_DESC *pDesc,
+            _In_  D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CreateUnorderedAccessView)
+        void ( STDMETHODCALLTYPE *CreateUnorderedAccessView )( 
+            ID3D12Device6 * This,
+            _In_opt_  ID3D12Resource *pResource,
+            _In_opt_  ID3D12Resource *pCounterResource,
+            _In_opt_  const D3D12_UNORDERED_ACCESS_VIEW_DESC *pDesc,
+            _In_  D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CreateRenderTargetView)
+        void ( STDMETHODCALLTYPE *CreateRenderTargetView )( 
+            ID3D12Device6 * This,
+            _In_opt_  ID3D12Resource *pResource,
+            _In_opt_  const D3D12_RENDER_TARGET_VIEW_DESC *pDesc,
+            _In_  D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CreateDepthStencilView)
+        void ( STDMETHODCALLTYPE *CreateDepthStencilView )( 
+            ID3D12Device6 * This,
+            _In_opt_  ID3D12Resource *pResource,
+            _In_opt_  const D3D12_DEPTH_STENCIL_VIEW_DESC *pDesc,
+            _In_  D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CreateSampler)
+        void ( STDMETHODCALLTYPE *CreateSampler )( 
+            ID3D12Device6 * This,
+            _In_  const D3D12_SAMPLER_DESC *pDesc,
+            _In_  D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CopyDescriptors)
+        void ( STDMETHODCALLTYPE *CopyDescriptors )( 
+            ID3D12Device6 * This,
+            _In_  UINT NumDestDescriptorRanges,
+            _In_reads_(NumDestDescriptorRanges)  const D3D12_CPU_DESCRIPTOR_HANDLE *pDestDescriptorRangeStarts,
+            _In_reads_opt_(NumDestDescriptorRanges)  const UINT *pDestDescriptorRangeSizes,
+            _In_  UINT NumSrcDescriptorRanges,
+            _In_reads_(NumSrcDescriptorRanges)  const D3D12_CPU_DESCRIPTOR_HANDLE *pSrcDescriptorRangeStarts,
+            _In_reads_opt_(NumSrcDescriptorRanges)  const UINT *pSrcDescriptorRangeSizes,
+            _In_  D3D12_DESCRIPTOR_HEAP_TYPE DescriptorHeapsType);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CopyDescriptorsSimple)
+        void ( STDMETHODCALLTYPE *CopyDescriptorsSimple )( 
+            ID3D12Device6 * This,
+            _In_  UINT NumDescriptors,
+            _In_  D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptorRangeStart,
+            _In_  D3D12_CPU_DESCRIPTOR_HANDLE SrcDescriptorRangeStart,
+            _In_  D3D12_DESCRIPTOR_HEAP_TYPE DescriptorHeapsType);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, GetResourceAllocationInfo)
+#if !defined(_WIN32)
+        D3D12_RESOURCE_ALLOCATION_INFO ( STDMETHODCALLTYPE *GetResourceAllocationInfo )( 
+            ID3D12Device6 * This,
+            _In_  UINT visibleMask,
+            _In_  UINT numResourceDescs,
+            _In_reads_(numResourceDescs)  const D3D12_RESOURCE_DESC *pResourceDescs);
+        
+#else
+        D3D12_RESOURCE_ALLOCATION_INFO *( STDMETHODCALLTYPE *GetResourceAllocationInfo )( 
+            ID3D12Device6 * This,
+            D3D12_RESOURCE_ALLOCATION_INFO * RetVal,
+            _In_  UINT visibleMask,
+            _In_  UINT numResourceDescs,
+            _In_reads_(numResourceDescs)  const D3D12_RESOURCE_DESC *pResourceDescs);
+        
+#endif
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, GetCustomHeapProperties)
+#if !defined(_WIN32)
+        D3D12_HEAP_PROPERTIES ( STDMETHODCALLTYPE *GetCustomHeapProperties )( 
+            ID3D12Device6 * This,
+            _In_  UINT nodeMask,
+            D3D12_HEAP_TYPE heapType);
+        
+#else
+        D3D12_HEAP_PROPERTIES *( STDMETHODCALLTYPE *GetCustomHeapProperties )( 
+            ID3D12Device6 * This,
+            D3D12_HEAP_PROPERTIES * RetVal,
+            _In_  UINT nodeMask,
+            D3D12_HEAP_TYPE heapType);
+        
+#endif
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CreateCommittedResource)
+        HRESULT ( STDMETHODCALLTYPE *CreateCommittedResource )( 
+            ID3D12Device6 * This,
+            _In_  const D3D12_HEAP_PROPERTIES *pHeapProperties,
+            D3D12_HEAP_FLAGS HeapFlags,
+            _In_  const D3D12_RESOURCE_DESC *pDesc,
+            D3D12_RESOURCE_STATES InitialResourceState,
+            _In_opt_  const D3D12_CLEAR_VALUE *pOptimizedClearValue,
+            REFIID riidResource,
+            _COM_Outptr_opt_  void **ppvResource);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CreateHeap)
+        HRESULT ( STDMETHODCALLTYPE *CreateHeap )( 
+            ID3D12Device6 * This,
+            _In_  const D3D12_HEAP_DESC *pDesc,
+            REFIID riid,
+            _COM_Outptr_opt_  void **ppvHeap);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CreatePlacedResource)
+        HRESULT ( STDMETHODCALLTYPE *CreatePlacedResource )( 
+            ID3D12Device6 * This,
+            _In_  ID3D12Heap *pHeap,
+            UINT64 HeapOffset,
+            _In_  const D3D12_RESOURCE_DESC *pDesc,
+            D3D12_RESOURCE_STATES InitialState,
+            _In_opt_  const D3D12_CLEAR_VALUE *pOptimizedClearValue,
+            REFIID riid,
+            _COM_Outptr_opt_  void **ppvResource);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CreateReservedResource)
+        HRESULT ( STDMETHODCALLTYPE *CreateReservedResource )( 
+            ID3D12Device6 * This,
+            _In_  const D3D12_RESOURCE_DESC *pDesc,
+            D3D12_RESOURCE_STATES InitialState,
+            _In_opt_  const D3D12_CLEAR_VALUE *pOptimizedClearValue,
+            REFIID riid,
+            _COM_Outptr_opt_  void **ppvResource);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CreateSharedHandle)
+        HRESULT ( STDMETHODCALLTYPE *CreateSharedHandle )( 
+            ID3D12Device6 * This,
+            _In_  ID3D12DeviceChild *pObject,
+            _In_opt_  const SECURITY_ATTRIBUTES *pAttributes,
+            DWORD Access,
+            _In_opt_  LPCWSTR Name,
+            _Out_  HANDLE *pHandle);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, OpenSharedHandle)
+        HRESULT ( STDMETHODCALLTYPE *OpenSharedHandle )( 
+            ID3D12Device6 * This,
+            _In_  HANDLE NTHandle,
+            REFIID riid,
+            _COM_Outptr_opt_  void **ppvObj);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, OpenSharedHandleByName)
+        HRESULT ( STDMETHODCALLTYPE *OpenSharedHandleByName )( 
+            ID3D12Device6 * This,
+            _In_  LPCWSTR Name,
+            DWORD Access,
+            /* [annotation][out] */ 
+            _Out_  HANDLE *pNTHandle);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, MakeResident)
+        HRESULT ( STDMETHODCALLTYPE *MakeResident )( 
+            ID3D12Device6 * This,
+            UINT NumObjects,
+            _In_reads_(NumObjects)  ID3D12Pageable *const *ppObjects);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, Evict)
+        HRESULT ( STDMETHODCALLTYPE *Evict )( 
+            ID3D12Device6 * This,
+            UINT NumObjects,
+            _In_reads_(NumObjects)  ID3D12Pageable *const *ppObjects);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CreateFence)
+        HRESULT ( STDMETHODCALLTYPE *CreateFence )( 
+            ID3D12Device6 * This,
+            UINT64 InitialValue,
+            D3D12_FENCE_FLAGS Flags,
+            REFIID riid,
+            _COM_Outptr_  void **ppFence);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, GetDeviceRemovedReason)
+        HRESULT ( STDMETHODCALLTYPE *GetDeviceRemovedReason )( 
+            ID3D12Device6 * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, GetCopyableFootprints)
+        void ( STDMETHODCALLTYPE *GetCopyableFootprints )( 
+            ID3D12Device6 * This,
+            _In_  const D3D12_RESOURCE_DESC *pResourceDesc,
+            _In_range_(0,D3D12_REQ_SUBRESOURCES)  UINT FirstSubresource,
+            _In_range_(0,D3D12_REQ_SUBRESOURCES-FirstSubresource)  UINT NumSubresources,
+            UINT64 BaseOffset,
+            _Out_writes_opt_(NumSubresources)  D3D12_PLACED_SUBRESOURCE_FOOTPRINT *pLayouts,
+            _Out_writes_opt_(NumSubresources)  UINT *pNumRows,
+            _Out_writes_opt_(NumSubresources)  UINT64 *pRowSizeInBytes,
+            _Out_opt_  UINT64 *pTotalBytes);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CreateQueryHeap)
+        HRESULT ( STDMETHODCALLTYPE *CreateQueryHeap )( 
+            ID3D12Device6 * This,
+            _In_  const D3D12_QUERY_HEAP_DESC *pDesc,
+            REFIID riid,
+            _COM_Outptr_opt_  void **ppvHeap);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, SetStablePowerState)
+        HRESULT ( STDMETHODCALLTYPE *SetStablePowerState )( 
+            ID3D12Device6 * This,
+            BOOL Enable);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CreateCommandSignature)
+        HRESULT ( STDMETHODCALLTYPE *CreateCommandSignature )( 
+            ID3D12Device6 * This,
+            _In_  const D3D12_COMMAND_SIGNATURE_DESC *pDesc,
+            _In_opt_  ID3D12RootSignature *pRootSignature,
+            REFIID riid,
+            _COM_Outptr_opt_  void **ppvCommandSignature);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, GetResourceTiling)
+        void ( STDMETHODCALLTYPE *GetResourceTiling )( 
+            ID3D12Device6 * This,
+            _In_  ID3D12Resource *pTiledResource,
+            _Out_opt_  UINT *pNumTilesForEntireResource,
+            _Out_opt_  D3D12_PACKED_MIP_INFO *pPackedMipDesc,
+            _Out_opt_  D3D12_TILE_SHAPE *pStandardTileShapeForNonPackedMips,
+            _Inout_opt_  UINT *pNumSubresourceTilings,
+            _In_  UINT FirstSubresourceTilingToGet,
+            _Out_writes_(*pNumSubresourceTilings)  D3D12_SUBRESOURCE_TILING *pSubresourceTilingsForNonPackedMips);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, GetAdapterLuid)
+#if !defined(_WIN32)
+        LUID ( STDMETHODCALLTYPE *GetAdapterLuid )( 
+            ID3D12Device6 * This);
+        
+#else
+        LUID *( STDMETHODCALLTYPE *GetAdapterLuid )( 
+            ID3D12Device6 * This,
+            LUID * RetVal);
+        
+#endif
+        
+        DECLSPEC_XFGVIRT(ID3D12Device1, CreatePipelineLibrary)
+        HRESULT ( STDMETHODCALLTYPE *CreatePipelineLibrary )( 
+            ID3D12Device6 * This,
+            _In_reads_(BlobLength)  const void *pLibraryBlob,
+            SIZE_T BlobLength,
+            REFIID riid,
+            _COM_Outptr_  void **ppPipelineLibrary);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device1, SetEventOnMultipleFenceCompletion)
+        HRESULT ( STDMETHODCALLTYPE *SetEventOnMultipleFenceCompletion )( 
+            ID3D12Device6 * This,
+            _In_reads_(NumFences)  ID3D12Fence *const *ppFences,
+            _In_reads_(NumFences)  const UINT64 *pFenceValues,
+            UINT NumFences,
+            D3D12_MULTIPLE_FENCE_WAIT_FLAGS Flags,
+            HANDLE hEvent);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device1, SetResidencyPriority)
+        HRESULT ( STDMETHODCALLTYPE *SetResidencyPriority )( 
+            ID3D12Device6 * This,
+            UINT NumObjects,
+            _In_reads_(NumObjects)  ID3D12Pageable *const *ppObjects,
+            _In_reads_(NumObjects)  const D3D12_RESIDENCY_PRIORITY *pPriorities);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device2, CreatePipelineState)
+        HRESULT ( STDMETHODCALLTYPE *CreatePipelineState )( 
+            ID3D12Device6 * This,
+            const D3D12_PIPELINE_STATE_STREAM_DESC *pDesc,
+            REFIID riid,
+            _COM_Outptr_  void **ppPipelineState);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device3, OpenExistingHeapFromAddress)
+        HRESULT ( STDMETHODCALLTYPE *OpenExistingHeapFromAddress )( 
+            ID3D12Device6 * This,
+            _In_  const void *pAddress,
+            REFIID riid,
+            _COM_Outptr_  void **ppvHeap);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device3, OpenExistingHeapFromFileMapping)
+        HRESULT ( STDMETHODCALLTYPE *OpenExistingHeapFromFileMapping )( 
+            ID3D12Device6 * This,
+            _In_  HANDLE hFileMapping,
+            REFIID riid,
+            _COM_Outptr_  void **ppvHeap);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device3, EnqueueMakeResident)
+        HRESULT ( STDMETHODCALLTYPE *EnqueueMakeResident )( 
+            ID3D12Device6 * This,
+            D3D12_RESIDENCY_FLAGS Flags,
+            UINT NumObjects,
+            _In_reads_(NumObjects)  ID3D12Pageable *const *ppObjects,
+            _In_  ID3D12Fence *pFenceToSignal,
+            UINT64 FenceValueToSignal);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device4, CreateCommandList1)
+        HRESULT ( STDMETHODCALLTYPE *CreateCommandList1 )( 
+            ID3D12Device6 * This,
+            _In_  UINT nodeMask,
+            _In_  D3D12_COMMAND_LIST_TYPE type,
+            _In_  D3D12_COMMAND_LIST_FLAGS flags,
+            REFIID riid,
+            _COM_Outptr_  void **ppCommandList);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device4, CreateProtectedResourceSession)
+        HRESULT ( STDMETHODCALLTYPE *CreateProtectedResourceSession )( 
+            ID3D12Device6 * This,
+            _In_  const D3D12_PROTECTED_RESOURCE_SESSION_DESC *pDesc,
+            _In_  REFIID riid,
+            _COM_Outptr_  void **ppSession);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device4, CreateCommittedResource1)
+        HRESULT ( STDMETHODCALLTYPE *CreateCommittedResource1 )( 
+            ID3D12Device6 * This,
+            _In_  const D3D12_HEAP_PROPERTIES *pHeapProperties,
+            D3D12_HEAP_FLAGS HeapFlags,
+            _In_  const D3D12_RESOURCE_DESC *pDesc,
+            D3D12_RESOURCE_STATES InitialResourceState,
+            _In_opt_  const D3D12_CLEAR_VALUE *pOptimizedClearValue,
+            _In_opt_  ID3D12ProtectedResourceSession *pProtectedSession,
+            REFIID riidResource,
+            _COM_Outptr_opt_  void **ppvResource);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device4, CreateHeap1)
+        HRESULT ( STDMETHODCALLTYPE *CreateHeap1 )( 
+            ID3D12Device6 * This,
+            _In_  const D3D12_HEAP_DESC *pDesc,
+            _In_opt_  ID3D12ProtectedResourceSession *pProtectedSession,
+            REFIID riid,
+            _COM_Outptr_opt_  void **ppvHeap);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device4, CreateReservedResource1)
+        HRESULT ( STDMETHODCALLTYPE *CreateReservedResource1 )( 
+            ID3D12Device6 * This,
+            _In_  const D3D12_RESOURCE_DESC *pDesc,
+            D3D12_RESOURCE_STATES InitialState,
+            _In_opt_  const D3D12_CLEAR_VALUE *pOptimizedClearValue,
+            _In_opt_  ID3D12ProtectedResourceSession *pProtectedSession,
+            REFIID riid,
+            _COM_Outptr_opt_  void **ppvResource);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device4, GetResourceAllocationInfo1)
+#if !defined(_WIN32)
+        D3D12_RESOURCE_ALLOCATION_INFO ( STDMETHODCALLTYPE *GetResourceAllocationInfo1 )( 
+            ID3D12Device6 * This,
+            UINT visibleMask,
+            UINT numResourceDescs,
+            _In_reads_(numResourceDescs)  const D3D12_RESOURCE_DESC *pResourceDescs,
+            _Out_writes_opt_(numResourceDescs)  D3D12_RESOURCE_ALLOCATION_INFO1 *pResourceAllocationInfo1);
+        
+#else
+        D3D12_RESOURCE_ALLOCATION_INFO *( STDMETHODCALLTYPE *GetResourceAllocationInfo1 )( 
+            ID3D12Device6 * This,
+            D3D12_RESOURCE_ALLOCATION_INFO * RetVal,
+            UINT visibleMask,
+            UINT numResourceDescs,
+            _In_reads_(numResourceDescs)  const D3D12_RESOURCE_DESC *pResourceDescs,
+            _Out_writes_opt_(numResourceDescs)  D3D12_RESOURCE_ALLOCATION_INFO1 *pResourceAllocationInfo1);
+        
+#endif
+        
+        DECLSPEC_XFGVIRT(ID3D12Device5, CreateLifetimeTracker)
+        HRESULT ( STDMETHODCALLTYPE *CreateLifetimeTracker )( 
+            ID3D12Device6 * This,
+            _In_  ID3D12LifetimeOwner *pOwner,
+            REFIID riid,
+            _COM_Outptr_  void **ppvTracker);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device5, RemoveDevice)
+        void ( STDMETHODCALLTYPE *RemoveDevice )( 
+            ID3D12Device6 * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device5, EnumerateMetaCommands)
+        HRESULT ( STDMETHODCALLTYPE *EnumerateMetaCommands )( 
+            ID3D12Device6 * This,
+            _Inout_  UINT *pNumMetaCommands,
+            _Out_writes_opt_(*pNumMetaCommands)  D3D12_META_COMMAND_DESC *pDescs);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device5, EnumerateMetaCommandParameters)
+        HRESULT ( STDMETHODCALLTYPE *EnumerateMetaCommandParameters )( 
+            ID3D12Device6 * This,
+            _In_  REFGUID CommandId,
+            _In_  D3D12_META_COMMAND_PARAMETER_STAGE Stage,
+            _Out_opt_  UINT *pTotalStructureSizeInBytes,
+            _Inout_  UINT *pParameterCount,
+            _Out_writes_opt_(*pParameterCount)  D3D12_META_COMMAND_PARAMETER_DESC *pParameterDescs);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device5, CreateMetaCommand)
+        HRESULT ( STDMETHODCALLTYPE *CreateMetaCommand )( 
+            ID3D12Device6 * This,
+            _In_  REFGUID CommandId,
+            _In_  UINT NodeMask,
+            _In_reads_bytes_opt_(CreationParametersDataSizeInBytes)  const void *pCreationParametersData,
+            _In_  SIZE_T CreationParametersDataSizeInBytes,
+            REFIID riid,
+            _COM_Outptr_  void **ppMetaCommand);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device5, CreateStateObject)
+        HRESULT ( STDMETHODCALLTYPE *CreateStateObject )( 
+            ID3D12Device6 * This,
+            const D3D12_STATE_OBJECT_DESC *pDesc,
+            REFIID riid,
+            _COM_Outptr_  void **ppStateObject);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device5, GetRaytracingAccelerationStructurePrebuildInfo)
+        void ( STDMETHODCALLTYPE *GetRaytracingAccelerationStructurePrebuildInfo )( 
+            ID3D12Device6 * This,
+            _In_  const D3D12_BUILD_RAYTRACING_ACCELERATION_STRUCTURE_INPUTS *pDesc,
+            _Out_  D3D12_RAYTRACING_ACCELERATION_STRUCTURE_PREBUILD_INFO *pInfo);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device5, CheckDriverMatchingIdentifier)
+        D3D12_DRIVER_MATCHING_IDENTIFIER_STATUS ( STDMETHODCALLTYPE *CheckDriverMatchingIdentifier )( 
+            ID3D12Device6 * This,
+            _In_  D3D12_SERIALIZED_DATA_TYPE SerializedDataType,
+            _In_  const D3D12_SERIALIZED_DATA_DRIVER_MATCHING_IDENTIFIER *pIdentifierToCheck);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device6, SetBackgroundProcessingMode)
+        HRESULT ( STDMETHODCALLTYPE *SetBackgroundProcessingMode )( 
+            ID3D12Device6 * This,
+            D3D12_BACKGROUND_PROCESSING_MODE Mode,
+            D3D12_MEASUREMENTS_ACTION MeasurementsAction,
+            _In_opt_  HANDLE hEventToSignalUponCompletion,
+            _Out_opt_  BOOL *pbFurtherMeasurementsDesired);
+        
+        END_INTERFACE
+    } ID3D12Device6Vtbl;
+
+    interface ID3D12Device6
+    {
+        CONST_VTBL struct ID3D12Device6Vtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define ID3D12Device6_QueryInterface(This,riid,ppvObject)	\
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define ID3D12Device6_AddRef(This)	\
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define ID3D12Device6_Release(This)	\
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#define ID3D12Device6_GetPrivateData(This,guid,pDataSize,pData)	\
+    ( (This)->lpVtbl -> GetPrivateData(This,guid,pDataSize,pData) ) 
+
+#define ID3D12Device6_SetPrivateData(This,guid,DataSize,pData)	\
+    ( (This)->lpVtbl -> SetPrivateData(This,guid,DataSize,pData) ) 
+
+#define ID3D12Device6_SetPrivateDataInterface(This,guid,pData)	\
+    ( (This)->lpVtbl -> SetPrivateDataInterface(This,guid,pData) ) 
+
+#define ID3D12Device6_SetName(This,Name)	\
+    ( (This)->lpVtbl -> SetName(This,Name) ) 
+
+
+#define ID3D12Device6_GetNodeCount(This)	\
+    ( (This)->lpVtbl -> GetNodeCount(This) ) 
+
+#define ID3D12Device6_CreateCommandQueue(This,pDesc,riid,ppCommandQueue)	\
+    ( (This)->lpVtbl -> CreateCommandQueue(This,pDesc,riid,ppCommandQueue) ) 
+
+#define ID3D12Device6_CreateCommandAllocator(This,type,riid,ppCommandAllocator)	\
+    ( (This)->lpVtbl -> CreateCommandAllocator(This,type,riid,ppCommandAllocator) ) 
+
+#define ID3D12Device6_CreateGraphicsPipelineState(This,pDesc,riid,ppPipelineState)	\
+    ( (This)->lpVtbl -> CreateGraphicsPipelineState(This,pDesc,riid,ppPipelineState) ) 
+
+#define ID3D12Device6_CreateComputePipelineState(This,pDesc,riid,ppPipelineState)	\
+    ( (This)->lpVtbl -> CreateComputePipelineState(This,pDesc,riid,ppPipelineState) ) 
+
+#define ID3D12Device6_CreateCommandList(This,nodeMask,type,pCommandAllocator,pInitialState,riid,ppCommandList)	\
+    ( (This)->lpVtbl -> CreateCommandList(This,nodeMask,type,pCommandAllocator,pInitialState,riid,ppCommandList) ) 
+
+#define ID3D12Device6_CheckFeatureSupport(This,Feature,pFeatureSupportData,FeatureSupportDataSize)	\
+    ( (This)->lpVtbl -> CheckFeatureSupport(This,Feature,pFeatureSupportData,FeatureSupportDataSize) ) 
+
+#define ID3D12Device6_CreateDescriptorHeap(This,pDescriptorHeapDesc,riid,ppvHeap)	\
+    ( (This)->lpVtbl -> CreateDescriptorHeap(This,pDescriptorHeapDesc,riid,ppvHeap) ) 
+
+#define ID3D12Device6_GetDescriptorHandleIncrementSize(This,DescriptorHeapType)	\
+    ( (This)->lpVtbl -> GetDescriptorHandleIncrementSize(This,DescriptorHeapType) ) 
+
+#define ID3D12Device6_CreateRootSignature(This,nodeMask,pBlobWithRootSignature,blobLengthInBytes,riid,ppvRootSignature)	\
+    ( (This)->lpVtbl -> CreateRootSignature(This,nodeMask,pBlobWithRootSignature,blobLengthInBytes,riid,ppvRootSignature) ) 
+
+#define ID3D12Device6_CreateConstantBufferView(This,pDesc,DestDescriptor)	\
+    ( (This)->lpVtbl -> CreateConstantBufferView(This,pDesc,DestDescriptor) ) 
+
+#define ID3D12Device6_CreateShaderResourceView(This,pResource,pDesc,DestDescriptor)	\
+    ( (This)->lpVtbl -> CreateShaderResourceView(This,pResource,pDesc,DestDescriptor) ) 
+
+#define ID3D12Device6_CreateUnorderedAccessView(This,pResource,pCounterResource,pDesc,DestDescriptor)	\
+    ( (This)->lpVtbl -> CreateUnorderedAccessView(This,pResource,pCounterResource,pDesc,DestDescriptor) ) 
+
+#define ID3D12Device6_CreateRenderTargetView(This,pResource,pDesc,DestDescriptor)	\
+    ( (This)->lpVtbl -> CreateRenderTargetView(This,pResource,pDesc,DestDescriptor) ) 
+
+#define ID3D12Device6_CreateDepthStencilView(This,pResource,pDesc,DestDescriptor)	\
+    ( (This)->lpVtbl -> CreateDepthStencilView(This,pResource,pDesc,DestDescriptor) ) 
+
+#define ID3D12Device6_CreateSampler(This,pDesc,DestDescriptor)	\
+    ( (This)->lpVtbl -> CreateSampler(This,pDesc,DestDescriptor) ) 
+
+#define ID3D12Device6_CopyDescriptors(This,NumDestDescriptorRanges,pDestDescriptorRangeStarts,pDestDescriptorRangeSizes,NumSrcDescriptorRanges,pSrcDescriptorRangeStarts,pSrcDescriptorRangeSizes,DescriptorHeapsType)	\
+    ( (This)->lpVtbl -> CopyDescriptors(This,NumDestDescriptorRanges,pDestDescriptorRangeStarts,pDestDescriptorRangeSizes,NumSrcDescriptorRanges,pSrcDescriptorRangeStarts,pSrcDescriptorRangeSizes,DescriptorHeapsType) ) 
+
+#define ID3D12Device6_CopyDescriptorsSimple(This,NumDescriptors,DestDescriptorRangeStart,SrcDescriptorRangeStart,DescriptorHeapsType)	\
+    ( (This)->lpVtbl -> CopyDescriptorsSimple(This,NumDescriptors,DestDescriptorRangeStart,SrcDescriptorRangeStart,DescriptorHeapsType) ) 
+#if !defined(_WIN32)
+
+#define ID3D12Device6_GetResourceAllocationInfo(This,visibleMask,numResourceDescs,pResourceDescs)	\
+    ( (This)->lpVtbl -> GetResourceAllocationInfo(This,visibleMask,numResourceDescs,pResourceDescs) ) 
+#else
+#define ID3D12Device6_GetResourceAllocationInfo(This,RetVal,visibleMask,numResourceDescs,pResourceDescs)	\
+    ( (This)->lpVtbl -> GetResourceAllocationInfo(This,RetVal,visibleMask,numResourceDescs,pResourceDescs) ) 
+#endif
+#if !defined(_WIN32)
+
+#define ID3D12Device6_GetCustomHeapProperties(This,nodeMask,heapType)	\
+    ( (This)->lpVtbl -> GetCustomHeapProperties(This,nodeMask,heapType) ) 
+#else
+#define ID3D12Device6_GetCustomHeapProperties(This,RetVal,nodeMask,heapType)	\
+    ( (This)->lpVtbl -> GetCustomHeapProperties(This,RetVal,nodeMask,heapType) ) 
+#endif
+
+#define ID3D12Device6_CreateCommittedResource(This,pHeapProperties,HeapFlags,pDesc,InitialResourceState,pOptimizedClearValue,riidResource,ppvResource)	\
+    ( (This)->lpVtbl -> CreateCommittedResource(This,pHeapProperties,HeapFlags,pDesc,InitialResourceState,pOptimizedClearValue,riidResource,ppvResource) ) 
+
+#define ID3D12Device6_CreateHeap(This,pDesc,riid,ppvHeap)	\
+    ( (This)->lpVtbl -> CreateHeap(This,pDesc,riid,ppvHeap) ) 
+
+#define ID3D12Device6_CreatePlacedResource(This,pHeap,HeapOffset,pDesc,InitialState,pOptimizedClearValue,riid,ppvResource)	\
+    ( (This)->lpVtbl -> CreatePlacedResource(This,pHeap,HeapOffset,pDesc,InitialState,pOptimizedClearValue,riid,ppvResource) ) 
+
+#define ID3D12Device6_CreateReservedResource(This,pDesc,InitialState,pOptimizedClearValue,riid,ppvResource)	\
+    ( (This)->lpVtbl -> CreateReservedResource(This,pDesc,InitialState,pOptimizedClearValue,riid,ppvResource) ) 
+
+#define ID3D12Device6_CreateSharedHandle(This,pObject,pAttributes,Access,Name,pHandle)	\
+    ( (This)->lpVtbl -> CreateSharedHandle(This,pObject,pAttributes,Access,Name,pHandle) ) 
+
+#define ID3D12Device6_OpenSharedHandle(This,NTHandle,riid,ppvObj)	\
+    ( (This)->lpVtbl -> OpenSharedHandle(This,NTHandle,riid,ppvObj) ) 
+
+#define ID3D12Device6_OpenSharedHandleByName(This,Name,Access,pNTHandle)	\
+    ( (This)->lpVtbl -> OpenSharedHandleByName(This,Name,Access,pNTHandle) ) 
+
+#define ID3D12Device6_MakeResident(This,NumObjects,ppObjects)	\
+    ( (This)->lpVtbl -> MakeResident(This,NumObjects,ppObjects) ) 
+
+#define ID3D12Device6_Evict(This,NumObjects,ppObjects)	\
+    ( (This)->lpVtbl -> Evict(This,NumObjects,ppObjects) ) 
+
+#define ID3D12Device6_CreateFence(This,InitialValue,Flags,riid,ppFence)	\
+    ( (This)->lpVtbl -> CreateFence(This,InitialValue,Flags,riid,ppFence) ) 
+
+#define ID3D12Device6_GetDeviceRemovedReason(This)	\
+    ( (This)->lpVtbl -> GetDeviceRemovedReason(This) ) 
+
+#define ID3D12Device6_GetCopyableFootprints(This,pResourceDesc,FirstSubresource,NumSubresources,BaseOffset,pLayouts,pNumRows,pRowSizeInBytes,pTotalBytes)	\
+    ( (This)->lpVtbl -> GetCopyableFootprints(This,pResourceDesc,FirstSubresource,NumSubresources,BaseOffset,pLayouts,pNumRows,pRowSizeInBytes,pTotalBytes) ) 
+
+#define ID3D12Device6_CreateQueryHeap(This,pDesc,riid,ppvHeap)	\
+    ( (This)->lpVtbl -> CreateQueryHeap(This,pDesc,riid,ppvHeap) ) 
+
+#define ID3D12Device6_SetStablePowerState(This,Enable)	\
+    ( (This)->lpVtbl -> SetStablePowerState(This,Enable) ) 
+
+#define ID3D12Device6_CreateCommandSignature(This,pDesc,pRootSignature,riid,ppvCommandSignature)	\
+    ( (This)->lpVtbl -> CreateCommandSignature(This,pDesc,pRootSignature,riid,ppvCommandSignature) ) 
+
+#define ID3D12Device6_GetResourceTiling(This,pTiledResource,pNumTilesForEntireResource,pPackedMipDesc,pStandardTileShapeForNonPackedMips,pNumSubresourceTilings,FirstSubresourceTilingToGet,pSubresourceTilingsForNonPackedMips)	\
+    ( (This)->lpVtbl -> GetResourceTiling(This,pTiledResource,pNumTilesForEntireResource,pPackedMipDesc,pStandardTileShapeForNonPackedMips,pNumSubresourceTilings,FirstSubresourceTilingToGet,pSubresourceTilingsForNonPackedMips) ) 
+#if !defined(_WIN32)
+
+#define ID3D12Device6_GetAdapterLuid(This)	\
+    ( (This)->lpVtbl -> GetAdapterLuid(This) ) 
+#else
+#define ID3D12Device6_GetAdapterLuid(This,RetVal)	\
+    ( (This)->lpVtbl -> GetAdapterLuid(This,RetVal) ) 
+#endif
+
+
+#define ID3D12Device6_CreatePipelineLibrary(This,pLibraryBlob,BlobLength,riid,ppPipelineLibrary)	\
+    ( (This)->lpVtbl -> CreatePipelineLibrary(This,pLibraryBlob,BlobLength,riid,ppPipelineLibrary) ) 
+
+#define ID3D12Device6_SetEventOnMultipleFenceCompletion(This,ppFences,pFenceValues,NumFences,Flags,hEvent)	\
+    ( (This)->lpVtbl -> SetEventOnMultipleFenceCompletion(This,ppFences,pFenceValues,NumFences,Flags,hEvent) ) 
+
+#define ID3D12Device6_SetResidencyPriority(This,NumObjects,ppObjects,pPriorities)	\
+    ( (This)->lpVtbl -> SetResidencyPriority(This,NumObjects,ppObjects,pPriorities) ) 
+
+
+#define ID3D12Device6_CreatePipelineState(This,pDesc,riid,ppPipelineState)	\
+    ( (This)->lpVtbl -> CreatePipelineState(This,pDesc,riid,ppPipelineState) ) 
+
+
+#define ID3D12Device6_OpenExistingHeapFromAddress(This,pAddress,riid,ppvHeap)	\
+    ( (This)->lpVtbl -> OpenExistingHeapFromAddress(This,pAddress,riid,ppvHeap) ) 
+
+#define ID3D12Device6_OpenExistingHeapFromFileMapping(This,hFileMapping,riid,ppvHeap)	\
+    ( (This)->lpVtbl -> OpenExistingHeapFromFileMapping(This,hFileMapping,riid,ppvHeap) ) 
+
+#define ID3D12Device6_EnqueueMakeResident(This,Flags,NumObjects,ppObjects,pFenceToSignal,FenceValueToSignal)	\
+    ( (This)->lpVtbl -> EnqueueMakeResident(This,Flags,NumObjects,ppObjects,pFenceToSignal,FenceValueToSignal) ) 
+
+
+#define ID3D12Device6_CreateCommandList1(This,nodeMask,type,flags,riid,ppCommandList)	\
+    ( (This)->lpVtbl -> CreateCommandList1(This,nodeMask,type,flags,riid,ppCommandList) ) 
+
+#define ID3D12Device6_CreateProtectedResourceSession(This,pDesc,riid,ppSession)	\
+    ( (This)->lpVtbl -> CreateProtectedResourceSession(This,pDesc,riid,ppSession) ) 
+
+#define ID3D12Device6_CreateCommittedResource1(This,pHeapProperties,HeapFlags,pDesc,InitialResourceState,pOptimizedClearValue,pProtectedSession,riidResource,ppvResource)	\
+    ( (This)->lpVtbl -> CreateCommittedResource1(This,pHeapProperties,HeapFlags,pDesc,InitialResourceState,pOptimizedClearValue,pProtectedSession,riidResource,ppvResource) ) 
+
+#define ID3D12Device6_CreateHeap1(This,pDesc,pProtectedSession,riid,ppvHeap)	\
+    ( (This)->lpVtbl -> CreateHeap1(This,pDesc,pProtectedSession,riid,ppvHeap) ) 
+
+#define ID3D12Device6_CreateReservedResource1(This,pDesc,InitialState,pOptimizedClearValue,pProtectedSession,riid,ppvResource)	\
+    ( (This)->lpVtbl -> CreateReservedResource1(This,pDesc,InitialState,pOptimizedClearValue,pProtectedSession,riid,ppvResource) ) 
+#if !defined(_WIN32)
+
+#define ID3D12Device6_GetResourceAllocationInfo1(This,visibleMask,numResourceDescs,pResourceDescs,pResourceAllocationInfo1)	\
+    ( (This)->lpVtbl -> GetResourceAllocationInfo1(This,visibleMask,numResourceDescs,pResourceDescs,pResourceAllocationInfo1) ) 
+#else
+#define ID3D12Device6_GetResourceAllocationInfo1(This,RetVal,visibleMask,numResourceDescs,pResourceDescs,pResourceAllocationInfo1)	\
+    ( (This)->lpVtbl -> GetResourceAllocationInfo1(This,RetVal,visibleMask,numResourceDescs,pResourceDescs,pResourceAllocationInfo1) ) 
+#endif
+
+
+#define ID3D12Device6_CreateLifetimeTracker(This,pOwner,riid,ppvTracker)	\
+    ( (This)->lpVtbl -> CreateLifetimeTracker(This,pOwner,riid,ppvTracker) ) 
+
+#define ID3D12Device6_RemoveDevice(This)	\
+    ( (This)->lpVtbl -> RemoveDevice(This) ) 
+
+#define ID3D12Device6_EnumerateMetaCommands(This,pNumMetaCommands,pDescs)	\
+    ( (This)->lpVtbl -> EnumerateMetaCommands(This,pNumMetaCommands,pDescs) ) 
+
+#define ID3D12Device6_EnumerateMetaCommandParameters(This,CommandId,Stage,pTotalStructureSizeInBytes,pParameterCount,pParameterDescs)	\
+    ( (This)->lpVtbl -> EnumerateMetaCommandParameters(This,CommandId,Stage,pTotalStructureSizeInBytes,pParameterCount,pParameterDescs) ) 
+
+#define ID3D12Device6_CreateMetaCommand(This,CommandId,NodeMask,pCreationParametersData,CreationParametersDataSizeInBytes,riid,ppMetaCommand)	\
+    ( (This)->lpVtbl -> CreateMetaCommand(This,CommandId,NodeMask,pCreationParametersData,CreationParametersDataSizeInBytes,riid,ppMetaCommand) ) 
+
+#define ID3D12Device6_CreateStateObject(This,pDesc,riid,ppStateObject)	\
+    ( (This)->lpVtbl -> CreateStateObject(This,pDesc,riid,ppStateObject) ) 
+
+#define ID3D12Device6_GetRaytracingAccelerationStructurePrebuildInfo(This,pDesc,pInfo)	\
+    ( (This)->lpVtbl -> GetRaytracingAccelerationStructurePrebuildInfo(This,pDesc,pInfo) ) 
+
+#define ID3D12Device6_CheckDriverMatchingIdentifier(This,SerializedDataType,pIdentifierToCheck)	\
+    ( (This)->lpVtbl -> CheckDriverMatchingIdentifier(This,SerializedDataType,pIdentifierToCheck) ) 
+
+
+#define ID3D12Device6_SetBackgroundProcessingMode(This,Mode,MeasurementsAction,hEventToSignalUponCompletion,pbFurtherMeasurementsDesired)	\
+    ( (This)->lpVtbl -> SetBackgroundProcessingMode(This,Mode,MeasurementsAction,hEventToSignalUponCompletion,pbFurtherMeasurementsDesired) ) 
+
+#endif /* COBJMACROS */
+
+
+#endif 	/* C style interface */
+
+
+
+
+#endif 	/* __ID3D12Device6_INTERFACE_DEFINED__ */
+
+
+/* interface __MIDL_itf_d3d12_0000_0042 */
+/* [local] */ 
+
+DEFINE_GUID(D3D12_PROTECTED_RESOURCES_SESSION_HARDWARE_PROTECTED,                           0x62B0084E, 0xC70E, 0x4DAA, 0xA1, 0x09, 0x30, 0xFF, 0x8D, 0x5A, 0x04, 0x82); 
+typedef struct D3D12_FEATURE_DATA_PROTECTED_RESOURCE_SESSION_TYPE_COUNT
+    {
+    UINT NodeIndex;
+    UINT Count;
+    } 	D3D12_FEATURE_DATA_PROTECTED_RESOURCE_SESSION_TYPE_COUNT;
+
+typedef struct D3D12_FEATURE_DATA_PROTECTED_RESOURCE_SESSION_TYPES
+    {
+    UINT NodeIndex;
+    UINT Count;
+    GUID *pTypes;
+    } 	D3D12_FEATURE_DATA_PROTECTED_RESOURCE_SESSION_TYPES;
+
+typedef struct D3D12_PROTECTED_RESOURCE_SESSION_DESC1
+    {
+    UINT NodeMask;
+    D3D12_PROTECTED_RESOURCE_SESSION_FLAGS Flags;
+    GUID ProtectionType;
+    } 	D3D12_PROTECTED_RESOURCE_SESSION_DESC1;
+
+
+
+extern RPC_IF_HANDLE __MIDL_itf_d3d12_0000_0042_v0_0_c_ifspec;
+extern RPC_IF_HANDLE __MIDL_itf_d3d12_0000_0042_v0_0_s_ifspec;
+
+#ifndef __ID3D12ProtectedResourceSession1_INTERFACE_DEFINED__
+#define __ID3D12ProtectedResourceSession1_INTERFACE_DEFINED__
+
+/* interface ID3D12ProtectedResourceSession1 */
+/* [unique][local][object][uuid] */ 
+
+
+EXTERN_C const IID IID_ID3D12ProtectedResourceSession1;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("D6F12DD6-76FB-406E-8961-4296EEFC0409")
+    ID3D12ProtectedResourceSession1 : public ID3D12ProtectedResourceSession
+    {
+    public:
+#if defined(_MSC_VER) || !defined(_WIN32)
+        virtual D3D12_PROTECTED_RESOURCE_SESSION_DESC1 STDMETHODCALLTYPE GetDesc1( void) = 0;
+#else
+        virtual D3D12_PROTECTED_RESOURCE_SESSION_DESC1 *STDMETHODCALLTYPE GetDesc1( 
+            D3D12_PROTECTED_RESOURCE_SESSION_DESC1 * RetVal) = 0;
+#endif
+        
+    };
+    
+    
+#else 	/* C style interface */
+
+    typedef struct ID3D12ProtectedResourceSession1Vtbl
+    {
+        BEGIN_INTERFACE
+        
+        DECLSPEC_XFGVIRT(IUnknown, QueryInterface)
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            ID3D12ProtectedResourceSession1 * This,
+            REFIID riid,
+            _COM_Outptr_  void **ppvObject);
+        
+        DECLSPEC_XFGVIRT(IUnknown, AddRef)
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            ID3D12ProtectedResourceSession1 * This);
+        
+        DECLSPEC_XFGVIRT(IUnknown, Release)
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            ID3D12ProtectedResourceSession1 * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, GetPrivateData)
+        HRESULT ( STDMETHODCALLTYPE *GetPrivateData )( 
+            ID3D12ProtectedResourceSession1 * This,
+            _In_  REFGUID guid,
+            _Inout_  UINT *pDataSize,
+            _Out_writes_bytes_opt_( *pDataSize )  void *pData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, SetPrivateData)
+        HRESULT ( STDMETHODCALLTYPE *SetPrivateData )( 
+            ID3D12ProtectedResourceSession1 * This,
+            _In_  REFGUID guid,
+            _In_  UINT DataSize,
+            _In_reads_bytes_opt_( DataSize )  const void *pData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, SetPrivateDataInterface)
+        HRESULT ( STDMETHODCALLTYPE *SetPrivateDataInterface )( 
+            ID3D12ProtectedResourceSession1 * This,
+            _In_  REFGUID guid,
+            _In_opt_  const IUnknown *pData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, SetName)
+        HRESULT ( STDMETHODCALLTYPE *SetName )( 
+            ID3D12ProtectedResourceSession1 * This,
+            _In_z_  LPCWSTR Name);
+        
+        DECLSPEC_XFGVIRT(ID3D12DeviceChild, GetDevice)
+        HRESULT ( STDMETHODCALLTYPE *GetDevice )( 
+            ID3D12ProtectedResourceSession1 * This,
+            REFIID riid,
+            _COM_Outptr_opt_  void **ppvDevice);
+        
+        DECLSPEC_XFGVIRT(ID3D12ProtectedSession, GetStatusFence)
+        HRESULT ( STDMETHODCALLTYPE *GetStatusFence )( 
+            ID3D12ProtectedResourceSession1 * This,
+            REFIID riid,
+            _COM_Outptr_opt_  void **ppFence);
+        
+        DECLSPEC_XFGVIRT(ID3D12ProtectedSession, GetSessionStatus)
+        D3D12_PROTECTED_SESSION_STATUS ( STDMETHODCALLTYPE *GetSessionStatus )( 
+            ID3D12ProtectedResourceSession1 * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12ProtectedResourceSession, GetDesc)
+#if !defined(_WIN32)
+        D3D12_PROTECTED_RESOURCE_SESSION_DESC ( STDMETHODCALLTYPE *GetDesc )( 
+            ID3D12ProtectedResourceSession1 * This);
+        
+#else
+        D3D12_PROTECTED_RESOURCE_SESSION_DESC *( STDMETHODCALLTYPE *GetDesc )( 
+            ID3D12ProtectedResourceSession1 * This,
+            D3D12_PROTECTED_RESOURCE_SESSION_DESC * RetVal);
+        
+#endif
+        
+        DECLSPEC_XFGVIRT(ID3D12ProtectedResourceSession1, GetDesc1)
+#if !defined(_WIN32)
+        D3D12_PROTECTED_RESOURCE_SESSION_DESC1 ( STDMETHODCALLTYPE *GetDesc1 )( 
+            ID3D12ProtectedResourceSession1 * This);
+        
+#else
+        D3D12_PROTECTED_RESOURCE_SESSION_DESC1 *( STDMETHODCALLTYPE *GetDesc1 )( 
+            ID3D12ProtectedResourceSession1 * This,
+            D3D12_PROTECTED_RESOURCE_SESSION_DESC1 * RetVal);
+        
+#endif
+        
+        END_INTERFACE
+    } ID3D12ProtectedResourceSession1Vtbl;
+
+    interface ID3D12ProtectedResourceSession1
+    {
+        CONST_VTBL struct ID3D12ProtectedResourceSession1Vtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define ID3D12ProtectedResourceSession1_QueryInterface(This,riid,ppvObject)	\
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define ID3D12ProtectedResourceSession1_AddRef(This)	\
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define ID3D12ProtectedResourceSession1_Release(This)	\
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#define ID3D12ProtectedResourceSession1_GetPrivateData(This,guid,pDataSize,pData)	\
+    ( (This)->lpVtbl -> GetPrivateData(This,guid,pDataSize,pData) ) 
+
+#define ID3D12ProtectedResourceSession1_SetPrivateData(This,guid,DataSize,pData)	\
+    ( (This)->lpVtbl -> SetPrivateData(This,guid,DataSize,pData) ) 
+
+#define ID3D12ProtectedResourceSession1_SetPrivateDataInterface(This,guid,pData)	\
+    ( (This)->lpVtbl -> SetPrivateDataInterface(This,guid,pData) ) 
+
+#define ID3D12ProtectedResourceSession1_SetName(This,Name)	\
+    ( (This)->lpVtbl -> SetName(This,Name) ) 
+
+
+#define ID3D12ProtectedResourceSession1_GetDevice(This,riid,ppvDevice)	\
+    ( (This)->lpVtbl -> GetDevice(This,riid,ppvDevice) ) 
+
+
+#define ID3D12ProtectedResourceSession1_GetStatusFence(This,riid,ppFence)	\
+    ( (This)->lpVtbl -> GetStatusFence(This,riid,ppFence) ) 
+
+#define ID3D12ProtectedResourceSession1_GetSessionStatus(This)	\
+    ( (This)->lpVtbl -> GetSessionStatus(This) ) 
+
+#if !defined(_WIN32)
+
+#define ID3D12ProtectedResourceSession1_GetDesc(This)	\
+    ( (This)->lpVtbl -> GetDesc(This) ) 
+#else
+#define ID3D12ProtectedResourceSession1_GetDesc(This,RetVal)	\
+    ( (This)->lpVtbl -> GetDesc(This,RetVal) ) 
+#endif
+
+#if !defined(_WIN32)
+
+#define ID3D12ProtectedResourceSession1_GetDesc1(This)	\
+    ( (This)->lpVtbl -> GetDesc1(This) ) 
+#else
+#define ID3D12ProtectedResourceSession1_GetDesc1(This,RetVal)	\
+    ( (This)->lpVtbl -> GetDesc1(This,RetVal) ) 
+#endif
+
+#endif /* COBJMACROS */
+
+
+#endif 	/* C style interface */
+
+
+
+
+#endif 	/* __ID3D12ProtectedResourceSession1_INTERFACE_DEFINED__ */
+
+
+#ifndef __ID3D12Device7_INTERFACE_DEFINED__
+#define __ID3D12Device7_INTERFACE_DEFINED__
+
+/* interface ID3D12Device7 */
+/* [unique][local][object][uuid] */ 
+
+
+EXTERN_C const IID IID_ID3D12Device7;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("5c014b53-68a1-4b9b-8bd1-dd6046b9358b")
+    ID3D12Device7 : public ID3D12Device6
+    {
+    public:
+        virtual HRESULT STDMETHODCALLTYPE AddToStateObject( 
+            const D3D12_STATE_OBJECT_DESC *pAddition,
+            ID3D12StateObject *pStateObjectToGrowFrom,
+            REFIID riid,
+            _COM_Outptr_  void **ppNewStateObject) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE CreateProtectedResourceSession1( 
+            _In_  const D3D12_PROTECTED_RESOURCE_SESSION_DESC1 *pDesc,
+            _In_  REFIID riid,
+            _COM_Outptr_  void **ppSession) = 0;
+        
+    };
+    
+    
+#else 	/* C style interface */
+
+    typedef struct ID3D12Device7Vtbl
+    {
+        BEGIN_INTERFACE
+        
+        DECLSPEC_XFGVIRT(IUnknown, QueryInterface)
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            ID3D12Device7 * This,
+            REFIID riid,
+            _COM_Outptr_  void **ppvObject);
+        
+        DECLSPEC_XFGVIRT(IUnknown, AddRef)
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            ID3D12Device7 * This);
+        
+        DECLSPEC_XFGVIRT(IUnknown, Release)
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            ID3D12Device7 * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, GetPrivateData)
+        HRESULT ( STDMETHODCALLTYPE *GetPrivateData )( 
+            ID3D12Device7 * This,
+            _In_  REFGUID guid,
+            _Inout_  UINT *pDataSize,
+            _Out_writes_bytes_opt_( *pDataSize )  void *pData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, SetPrivateData)
+        HRESULT ( STDMETHODCALLTYPE *SetPrivateData )( 
+            ID3D12Device7 * This,
+            _In_  REFGUID guid,
+            _In_  UINT DataSize,
+            _In_reads_bytes_opt_( DataSize )  const void *pData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, SetPrivateDataInterface)
+        HRESULT ( STDMETHODCALLTYPE *SetPrivateDataInterface )( 
+            ID3D12Device7 * This,
+            _In_  REFGUID guid,
+            _In_opt_  const IUnknown *pData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, SetName)
+        HRESULT ( STDMETHODCALLTYPE *SetName )( 
+            ID3D12Device7 * This,
+            _In_z_  LPCWSTR Name);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, GetNodeCount)
+        UINT ( STDMETHODCALLTYPE *GetNodeCount )( 
+            ID3D12Device7 * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CreateCommandQueue)
+        HRESULT ( STDMETHODCALLTYPE *CreateCommandQueue )( 
+            ID3D12Device7 * This,
+            _In_  const D3D12_COMMAND_QUEUE_DESC *pDesc,
+            REFIID riid,
+            _COM_Outptr_  void **ppCommandQueue);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CreateCommandAllocator)
+        HRESULT ( STDMETHODCALLTYPE *CreateCommandAllocator )( 
+            ID3D12Device7 * This,
+            _In_  D3D12_COMMAND_LIST_TYPE type,
+            REFIID riid,
+            _COM_Outptr_  void **ppCommandAllocator);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CreateGraphicsPipelineState)
+        HRESULT ( STDMETHODCALLTYPE *CreateGraphicsPipelineState )( 
+            ID3D12Device7 * This,
+            _In_  const D3D12_GRAPHICS_PIPELINE_STATE_DESC *pDesc,
+            REFIID riid,
+            _COM_Outptr_  void **ppPipelineState);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CreateComputePipelineState)
+        HRESULT ( STDMETHODCALLTYPE *CreateComputePipelineState )( 
+            ID3D12Device7 * This,
+            _In_  const D3D12_COMPUTE_PIPELINE_STATE_DESC *pDesc,
+            REFIID riid,
+            _COM_Outptr_  void **ppPipelineState);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CreateCommandList)
+        HRESULT ( STDMETHODCALLTYPE *CreateCommandList )( 
+            ID3D12Device7 * This,
+            _In_  UINT nodeMask,
+            _In_  D3D12_COMMAND_LIST_TYPE type,
+            _In_  ID3D12CommandAllocator *pCommandAllocator,
+            _In_opt_  ID3D12PipelineState *pInitialState,
+            REFIID riid,
+            _COM_Outptr_  void **ppCommandList);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CheckFeatureSupport)
+        HRESULT ( STDMETHODCALLTYPE *CheckFeatureSupport )( 
+            ID3D12Device7 * This,
+            D3D12_FEATURE Feature,
+            _Inout_updates_bytes_(FeatureSupportDataSize)  void *pFeatureSupportData,
+            UINT FeatureSupportDataSize);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CreateDescriptorHeap)
+        HRESULT ( STDMETHODCALLTYPE *CreateDescriptorHeap )( 
+            ID3D12Device7 * This,
+            _In_  const D3D12_DESCRIPTOR_HEAP_DESC *pDescriptorHeapDesc,
+            REFIID riid,
+            _COM_Outptr_  void **ppvHeap);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, GetDescriptorHandleIncrementSize)
+        UINT ( STDMETHODCALLTYPE *GetDescriptorHandleIncrementSize )( 
+            ID3D12Device7 * This,
+            _In_  D3D12_DESCRIPTOR_HEAP_TYPE DescriptorHeapType);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CreateRootSignature)
+        HRESULT ( STDMETHODCALLTYPE *CreateRootSignature )( 
+            ID3D12Device7 * This,
+            _In_  UINT nodeMask,
+            _In_reads_(blobLengthInBytes)  const void *pBlobWithRootSignature,
+            _In_  SIZE_T blobLengthInBytes,
+            REFIID riid,
+            _COM_Outptr_  void **ppvRootSignature);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CreateConstantBufferView)
+        void ( STDMETHODCALLTYPE *CreateConstantBufferView )( 
+            ID3D12Device7 * This,
+            _In_opt_  const D3D12_CONSTANT_BUFFER_VIEW_DESC *pDesc,
+            _In_  D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CreateShaderResourceView)
+        void ( STDMETHODCALLTYPE *CreateShaderResourceView )( 
+            ID3D12Device7 * This,
+            _In_opt_  ID3D12Resource *pResource,
+            _In_opt_  const D3D12_SHADER_RESOURCE_VIEW_DESC *pDesc,
+            _In_  D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CreateUnorderedAccessView)
+        void ( STDMETHODCALLTYPE *CreateUnorderedAccessView )( 
+            ID3D12Device7 * This,
+            _In_opt_  ID3D12Resource *pResource,
+            _In_opt_  ID3D12Resource *pCounterResource,
+            _In_opt_  const D3D12_UNORDERED_ACCESS_VIEW_DESC *pDesc,
+            _In_  D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CreateRenderTargetView)
+        void ( STDMETHODCALLTYPE *CreateRenderTargetView )( 
+            ID3D12Device7 * This,
+            _In_opt_  ID3D12Resource *pResource,
+            _In_opt_  const D3D12_RENDER_TARGET_VIEW_DESC *pDesc,
+            _In_  D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CreateDepthStencilView)
+        void ( STDMETHODCALLTYPE *CreateDepthStencilView )( 
+            ID3D12Device7 * This,
+            _In_opt_  ID3D12Resource *pResource,
+            _In_opt_  const D3D12_DEPTH_STENCIL_VIEW_DESC *pDesc,
+            _In_  D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CreateSampler)
+        void ( STDMETHODCALLTYPE *CreateSampler )( 
+            ID3D12Device7 * This,
+            _In_  const D3D12_SAMPLER_DESC *pDesc,
+            _In_  D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CopyDescriptors)
+        void ( STDMETHODCALLTYPE *CopyDescriptors )( 
+            ID3D12Device7 * This,
+            _In_  UINT NumDestDescriptorRanges,
+            _In_reads_(NumDestDescriptorRanges)  const D3D12_CPU_DESCRIPTOR_HANDLE *pDestDescriptorRangeStarts,
+            _In_reads_opt_(NumDestDescriptorRanges)  const UINT *pDestDescriptorRangeSizes,
+            _In_  UINT NumSrcDescriptorRanges,
+            _In_reads_(NumSrcDescriptorRanges)  const D3D12_CPU_DESCRIPTOR_HANDLE *pSrcDescriptorRangeStarts,
+            _In_reads_opt_(NumSrcDescriptorRanges)  const UINT *pSrcDescriptorRangeSizes,
+            _In_  D3D12_DESCRIPTOR_HEAP_TYPE DescriptorHeapsType);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CopyDescriptorsSimple)
+        void ( STDMETHODCALLTYPE *CopyDescriptorsSimple )( 
+            ID3D12Device7 * This,
+            _In_  UINT NumDescriptors,
+            _In_  D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptorRangeStart,
+            _In_  D3D12_CPU_DESCRIPTOR_HANDLE SrcDescriptorRangeStart,
+            _In_  D3D12_DESCRIPTOR_HEAP_TYPE DescriptorHeapsType);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, GetResourceAllocationInfo)
+#if !defined(_WIN32)
+        D3D12_RESOURCE_ALLOCATION_INFO ( STDMETHODCALLTYPE *GetResourceAllocationInfo )( 
+            ID3D12Device7 * This,
+            _In_  UINT visibleMask,
+            _In_  UINT numResourceDescs,
+            _In_reads_(numResourceDescs)  const D3D12_RESOURCE_DESC *pResourceDescs);
+        
+#else
+        D3D12_RESOURCE_ALLOCATION_INFO *( STDMETHODCALLTYPE *GetResourceAllocationInfo )( 
+            ID3D12Device7 * This,
+            D3D12_RESOURCE_ALLOCATION_INFO * RetVal,
+            _In_  UINT visibleMask,
+            _In_  UINT numResourceDescs,
+            _In_reads_(numResourceDescs)  const D3D12_RESOURCE_DESC *pResourceDescs);
+        
+#endif
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, GetCustomHeapProperties)
+#if !defined(_WIN32)
+        D3D12_HEAP_PROPERTIES ( STDMETHODCALLTYPE *GetCustomHeapProperties )( 
+            ID3D12Device7 * This,
+            _In_  UINT nodeMask,
+            D3D12_HEAP_TYPE heapType);
+        
+#else
+        D3D12_HEAP_PROPERTIES *( STDMETHODCALLTYPE *GetCustomHeapProperties )( 
+            ID3D12Device7 * This,
+            D3D12_HEAP_PROPERTIES * RetVal,
+            _In_  UINT nodeMask,
+            D3D12_HEAP_TYPE heapType);
+        
+#endif
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CreateCommittedResource)
+        HRESULT ( STDMETHODCALLTYPE *CreateCommittedResource )( 
+            ID3D12Device7 * This,
+            _In_  const D3D12_HEAP_PROPERTIES *pHeapProperties,
+            D3D12_HEAP_FLAGS HeapFlags,
+            _In_  const D3D12_RESOURCE_DESC *pDesc,
+            D3D12_RESOURCE_STATES InitialResourceState,
+            _In_opt_  const D3D12_CLEAR_VALUE *pOptimizedClearValue,
+            REFIID riidResource,
+            _COM_Outptr_opt_  void **ppvResource);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CreateHeap)
+        HRESULT ( STDMETHODCALLTYPE *CreateHeap )( 
+            ID3D12Device7 * This,
+            _In_  const D3D12_HEAP_DESC *pDesc,
+            REFIID riid,
+            _COM_Outptr_opt_  void **ppvHeap);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CreatePlacedResource)
+        HRESULT ( STDMETHODCALLTYPE *CreatePlacedResource )( 
+            ID3D12Device7 * This,
+            _In_  ID3D12Heap *pHeap,
+            UINT64 HeapOffset,
+            _In_  const D3D12_RESOURCE_DESC *pDesc,
+            D3D12_RESOURCE_STATES InitialState,
+            _In_opt_  const D3D12_CLEAR_VALUE *pOptimizedClearValue,
+            REFIID riid,
+            _COM_Outptr_opt_  void **ppvResource);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CreateReservedResource)
+        HRESULT ( STDMETHODCALLTYPE *CreateReservedResource )( 
+            ID3D12Device7 * This,
+            _In_  const D3D12_RESOURCE_DESC *pDesc,
+            D3D12_RESOURCE_STATES InitialState,
+            _In_opt_  const D3D12_CLEAR_VALUE *pOptimizedClearValue,
+            REFIID riid,
+            _COM_Outptr_opt_  void **ppvResource);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CreateSharedHandle)
+        HRESULT ( STDMETHODCALLTYPE *CreateSharedHandle )( 
+            ID3D12Device7 * This,
+            _In_  ID3D12DeviceChild *pObject,
+            _In_opt_  const SECURITY_ATTRIBUTES *pAttributes,
+            DWORD Access,
+            _In_opt_  LPCWSTR Name,
+            _Out_  HANDLE *pHandle);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, OpenSharedHandle)
+        HRESULT ( STDMETHODCALLTYPE *OpenSharedHandle )( 
+            ID3D12Device7 * This,
+            _In_  HANDLE NTHandle,
+            REFIID riid,
+            _COM_Outptr_opt_  void **ppvObj);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, OpenSharedHandleByName)
+        HRESULT ( STDMETHODCALLTYPE *OpenSharedHandleByName )( 
+            ID3D12Device7 * This,
+            _In_  LPCWSTR Name,
+            DWORD Access,
+            /* [annotation][out] */ 
+            _Out_  HANDLE *pNTHandle);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, MakeResident)
+        HRESULT ( STDMETHODCALLTYPE *MakeResident )( 
+            ID3D12Device7 * This,
+            UINT NumObjects,
+            _In_reads_(NumObjects)  ID3D12Pageable *const *ppObjects);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, Evict)
+        HRESULT ( STDMETHODCALLTYPE *Evict )( 
+            ID3D12Device7 * This,
+            UINT NumObjects,
+            _In_reads_(NumObjects)  ID3D12Pageable *const *ppObjects);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CreateFence)
+        HRESULT ( STDMETHODCALLTYPE *CreateFence )( 
+            ID3D12Device7 * This,
+            UINT64 InitialValue,
+            D3D12_FENCE_FLAGS Flags,
+            REFIID riid,
+            _COM_Outptr_  void **ppFence);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, GetDeviceRemovedReason)
+        HRESULT ( STDMETHODCALLTYPE *GetDeviceRemovedReason )( 
+            ID3D12Device7 * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, GetCopyableFootprints)
+        void ( STDMETHODCALLTYPE *GetCopyableFootprints )( 
+            ID3D12Device7 * This,
+            _In_  const D3D12_RESOURCE_DESC *pResourceDesc,
+            _In_range_(0,D3D12_REQ_SUBRESOURCES)  UINT FirstSubresource,
+            _In_range_(0,D3D12_REQ_SUBRESOURCES-FirstSubresource)  UINT NumSubresources,
+            UINT64 BaseOffset,
+            _Out_writes_opt_(NumSubresources)  D3D12_PLACED_SUBRESOURCE_FOOTPRINT *pLayouts,
+            _Out_writes_opt_(NumSubresources)  UINT *pNumRows,
+            _Out_writes_opt_(NumSubresources)  UINT64 *pRowSizeInBytes,
+            _Out_opt_  UINT64 *pTotalBytes);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CreateQueryHeap)
+        HRESULT ( STDMETHODCALLTYPE *CreateQueryHeap )( 
+            ID3D12Device7 * This,
+            _In_  const D3D12_QUERY_HEAP_DESC *pDesc,
+            REFIID riid,
+            _COM_Outptr_opt_  void **ppvHeap);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, SetStablePowerState)
+        HRESULT ( STDMETHODCALLTYPE *SetStablePowerState )( 
+            ID3D12Device7 * This,
+            BOOL Enable);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CreateCommandSignature)
+        HRESULT ( STDMETHODCALLTYPE *CreateCommandSignature )( 
+            ID3D12Device7 * This,
+            _In_  const D3D12_COMMAND_SIGNATURE_DESC *pDesc,
+            _In_opt_  ID3D12RootSignature *pRootSignature,
+            REFIID riid,
+            _COM_Outptr_opt_  void **ppvCommandSignature);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, GetResourceTiling)
+        void ( STDMETHODCALLTYPE *GetResourceTiling )( 
+            ID3D12Device7 * This,
+            _In_  ID3D12Resource *pTiledResource,
+            _Out_opt_  UINT *pNumTilesForEntireResource,
+            _Out_opt_  D3D12_PACKED_MIP_INFO *pPackedMipDesc,
+            _Out_opt_  D3D12_TILE_SHAPE *pStandardTileShapeForNonPackedMips,
+            _Inout_opt_  UINT *pNumSubresourceTilings,
+            _In_  UINT FirstSubresourceTilingToGet,
+            _Out_writes_(*pNumSubresourceTilings)  D3D12_SUBRESOURCE_TILING *pSubresourceTilingsForNonPackedMips);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, GetAdapterLuid)
+#if !defined(_WIN32)
+        LUID ( STDMETHODCALLTYPE *GetAdapterLuid )( 
+            ID3D12Device7 * This);
+        
+#else
+        LUID *( STDMETHODCALLTYPE *GetAdapterLuid )( 
+            ID3D12Device7 * This,
+            LUID * RetVal);
+        
+#endif
+        
+        DECLSPEC_XFGVIRT(ID3D12Device1, CreatePipelineLibrary)
+        HRESULT ( STDMETHODCALLTYPE *CreatePipelineLibrary )( 
+            ID3D12Device7 * This,
+            _In_reads_(BlobLength)  const void *pLibraryBlob,
+            SIZE_T BlobLength,
+            REFIID riid,
+            _COM_Outptr_  void **ppPipelineLibrary);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device1, SetEventOnMultipleFenceCompletion)
+        HRESULT ( STDMETHODCALLTYPE *SetEventOnMultipleFenceCompletion )( 
+            ID3D12Device7 * This,
+            _In_reads_(NumFences)  ID3D12Fence *const *ppFences,
+            _In_reads_(NumFences)  const UINT64 *pFenceValues,
+            UINT NumFences,
+            D3D12_MULTIPLE_FENCE_WAIT_FLAGS Flags,
+            HANDLE hEvent);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device1, SetResidencyPriority)
+        HRESULT ( STDMETHODCALLTYPE *SetResidencyPriority )( 
+            ID3D12Device7 * This,
+            UINT NumObjects,
+            _In_reads_(NumObjects)  ID3D12Pageable *const *ppObjects,
+            _In_reads_(NumObjects)  const D3D12_RESIDENCY_PRIORITY *pPriorities);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device2, CreatePipelineState)
+        HRESULT ( STDMETHODCALLTYPE *CreatePipelineState )( 
+            ID3D12Device7 * This,
+            const D3D12_PIPELINE_STATE_STREAM_DESC *pDesc,
+            REFIID riid,
+            _COM_Outptr_  void **ppPipelineState);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device3, OpenExistingHeapFromAddress)
+        HRESULT ( STDMETHODCALLTYPE *OpenExistingHeapFromAddress )( 
+            ID3D12Device7 * This,
+            _In_  const void *pAddress,
+            REFIID riid,
+            _COM_Outptr_  void **ppvHeap);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device3, OpenExistingHeapFromFileMapping)
+        HRESULT ( STDMETHODCALLTYPE *OpenExistingHeapFromFileMapping )( 
+            ID3D12Device7 * This,
+            _In_  HANDLE hFileMapping,
+            REFIID riid,
+            _COM_Outptr_  void **ppvHeap);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device3, EnqueueMakeResident)
+        HRESULT ( STDMETHODCALLTYPE *EnqueueMakeResident )( 
+            ID3D12Device7 * This,
+            D3D12_RESIDENCY_FLAGS Flags,
+            UINT NumObjects,
+            _In_reads_(NumObjects)  ID3D12Pageable *const *ppObjects,
+            _In_  ID3D12Fence *pFenceToSignal,
+            UINT64 FenceValueToSignal);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device4, CreateCommandList1)
+        HRESULT ( STDMETHODCALLTYPE *CreateCommandList1 )( 
+            ID3D12Device7 * This,
+            _In_  UINT nodeMask,
+            _In_  D3D12_COMMAND_LIST_TYPE type,
+            _In_  D3D12_COMMAND_LIST_FLAGS flags,
+            REFIID riid,
+            _COM_Outptr_  void **ppCommandList);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device4, CreateProtectedResourceSession)
+        HRESULT ( STDMETHODCALLTYPE *CreateProtectedResourceSession )( 
+            ID3D12Device7 * This,
+            _In_  const D3D12_PROTECTED_RESOURCE_SESSION_DESC *pDesc,
+            _In_  REFIID riid,
+            _COM_Outptr_  void **ppSession);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device4, CreateCommittedResource1)
+        HRESULT ( STDMETHODCALLTYPE *CreateCommittedResource1 )( 
+            ID3D12Device7 * This,
+            _In_  const D3D12_HEAP_PROPERTIES *pHeapProperties,
+            D3D12_HEAP_FLAGS HeapFlags,
+            _In_  const D3D12_RESOURCE_DESC *pDesc,
+            D3D12_RESOURCE_STATES InitialResourceState,
+            _In_opt_  const D3D12_CLEAR_VALUE *pOptimizedClearValue,
+            _In_opt_  ID3D12ProtectedResourceSession *pProtectedSession,
+            REFIID riidResource,
+            _COM_Outptr_opt_  void **ppvResource);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device4, CreateHeap1)
+        HRESULT ( STDMETHODCALLTYPE *CreateHeap1 )( 
+            ID3D12Device7 * This,
+            _In_  const D3D12_HEAP_DESC *pDesc,
+            _In_opt_  ID3D12ProtectedResourceSession *pProtectedSession,
+            REFIID riid,
+            _COM_Outptr_opt_  void **ppvHeap);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device4, CreateReservedResource1)
+        HRESULT ( STDMETHODCALLTYPE *CreateReservedResource1 )( 
+            ID3D12Device7 * This,
+            _In_  const D3D12_RESOURCE_DESC *pDesc,
+            D3D12_RESOURCE_STATES InitialState,
+            _In_opt_  const D3D12_CLEAR_VALUE *pOptimizedClearValue,
+            _In_opt_  ID3D12ProtectedResourceSession *pProtectedSession,
+            REFIID riid,
+            _COM_Outptr_opt_  void **ppvResource);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device4, GetResourceAllocationInfo1)
+#if !defined(_WIN32)
+        D3D12_RESOURCE_ALLOCATION_INFO ( STDMETHODCALLTYPE *GetResourceAllocationInfo1 )( 
+            ID3D12Device7 * This,
+            UINT visibleMask,
+            UINT numResourceDescs,
+            _In_reads_(numResourceDescs)  const D3D12_RESOURCE_DESC *pResourceDescs,
+            _Out_writes_opt_(numResourceDescs)  D3D12_RESOURCE_ALLOCATION_INFO1 *pResourceAllocationInfo1);
+        
+#else
+        D3D12_RESOURCE_ALLOCATION_INFO *( STDMETHODCALLTYPE *GetResourceAllocationInfo1 )( 
+            ID3D12Device7 * This,
+            D3D12_RESOURCE_ALLOCATION_INFO * RetVal,
+            UINT visibleMask,
+            UINT numResourceDescs,
+            _In_reads_(numResourceDescs)  const D3D12_RESOURCE_DESC *pResourceDescs,
+            _Out_writes_opt_(numResourceDescs)  D3D12_RESOURCE_ALLOCATION_INFO1 *pResourceAllocationInfo1);
+        
+#endif
+        
+        DECLSPEC_XFGVIRT(ID3D12Device5, CreateLifetimeTracker)
+        HRESULT ( STDMETHODCALLTYPE *CreateLifetimeTracker )( 
+            ID3D12Device7 * This,
+            _In_  ID3D12LifetimeOwner *pOwner,
+            REFIID riid,
+            _COM_Outptr_  void **ppvTracker);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device5, RemoveDevice)
+        void ( STDMETHODCALLTYPE *RemoveDevice )( 
+            ID3D12Device7 * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device5, EnumerateMetaCommands)
+        HRESULT ( STDMETHODCALLTYPE *EnumerateMetaCommands )( 
+            ID3D12Device7 * This,
+            _Inout_  UINT *pNumMetaCommands,
+            _Out_writes_opt_(*pNumMetaCommands)  D3D12_META_COMMAND_DESC *pDescs);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device5, EnumerateMetaCommandParameters)
+        HRESULT ( STDMETHODCALLTYPE *EnumerateMetaCommandParameters )( 
+            ID3D12Device7 * This,
+            _In_  REFGUID CommandId,
+            _In_  D3D12_META_COMMAND_PARAMETER_STAGE Stage,
+            _Out_opt_  UINT *pTotalStructureSizeInBytes,
+            _Inout_  UINT *pParameterCount,
+            _Out_writes_opt_(*pParameterCount)  D3D12_META_COMMAND_PARAMETER_DESC *pParameterDescs);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device5, CreateMetaCommand)
+        HRESULT ( STDMETHODCALLTYPE *CreateMetaCommand )( 
+            ID3D12Device7 * This,
+            _In_  REFGUID CommandId,
+            _In_  UINT NodeMask,
+            _In_reads_bytes_opt_(CreationParametersDataSizeInBytes)  const void *pCreationParametersData,
+            _In_  SIZE_T CreationParametersDataSizeInBytes,
+            REFIID riid,
+            _COM_Outptr_  void **ppMetaCommand);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device5, CreateStateObject)
+        HRESULT ( STDMETHODCALLTYPE *CreateStateObject )( 
+            ID3D12Device7 * This,
+            const D3D12_STATE_OBJECT_DESC *pDesc,
+            REFIID riid,
+            _COM_Outptr_  void **ppStateObject);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device5, GetRaytracingAccelerationStructurePrebuildInfo)
+        void ( STDMETHODCALLTYPE *GetRaytracingAccelerationStructurePrebuildInfo )( 
+            ID3D12Device7 * This,
+            _In_  const D3D12_BUILD_RAYTRACING_ACCELERATION_STRUCTURE_INPUTS *pDesc,
+            _Out_  D3D12_RAYTRACING_ACCELERATION_STRUCTURE_PREBUILD_INFO *pInfo);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device5, CheckDriverMatchingIdentifier)
+        D3D12_DRIVER_MATCHING_IDENTIFIER_STATUS ( STDMETHODCALLTYPE *CheckDriverMatchingIdentifier )( 
+            ID3D12Device7 * This,
+            _In_  D3D12_SERIALIZED_DATA_TYPE SerializedDataType,
+            _In_  const D3D12_SERIALIZED_DATA_DRIVER_MATCHING_IDENTIFIER *pIdentifierToCheck);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device6, SetBackgroundProcessingMode)
+        HRESULT ( STDMETHODCALLTYPE *SetBackgroundProcessingMode )( 
+            ID3D12Device7 * This,
+            D3D12_BACKGROUND_PROCESSING_MODE Mode,
+            D3D12_MEASUREMENTS_ACTION MeasurementsAction,
+            _In_opt_  HANDLE hEventToSignalUponCompletion,
+            _Out_opt_  BOOL *pbFurtherMeasurementsDesired);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device7, AddToStateObject)
+        HRESULT ( STDMETHODCALLTYPE *AddToStateObject )( 
+            ID3D12Device7 * This,
+            const D3D12_STATE_OBJECT_DESC *pAddition,
+            ID3D12StateObject *pStateObjectToGrowFrom,
+            REFIID riid,
+            _COM_Outptr_  void **ppNewStateObject);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device7, CreateProtectedResourceSession1)
+        HRESULT ( STDMETHODCALLTYPE *CreateProtectedResourceSession1 )( 
+            ID3D12Device7 * This,
+            _In_  const D3D12_PROTECTED_RESOURCE_SESSION_DESC1 *pDesc,
+            _In_  REFIID riid,
+            _COM_Outptr_  void **ppSession);
+        
+        END_INTERFACE
+    } ID3D12Device7Vtbl;
+
+    interface ID3D12Device7
+    {
+        CONST_VTBL struct ID3D12Device7Vtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define ID3D12Device7_QueryInterface(This,riid,ppvObject)	\
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define ID3D12Device7_AddRef(This)	\
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define ID3D12Device7_Release(This)	\
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#define ID3D12Device7_GetPrivateData(This,guid,pDataSize,pData)	\
+    ( (This)->lpVtbl -> GetPrivateData(This,guid,pDataSize,pData) ) 
+
+#define ID3D12Device7_SetPrivateData(This,guid,DataSize,pData)	\
+    ( (This)->lpVtbl -> SetPrivateData(This,guid,DataSize,pData) ) 
+
+#define ID3D12Device7_SetPrivateDataInterface(This,guid,pData)	\
+    ( (This)->lpVtbl -> SetPrivateDataInterface(This,guid,pData) ) 
+
+#define ID3D12Device7_SetName(This,Name)	\
+    ( (This)->lpVtbl -> SetName(This,Name) ) 
+
+
+#define ID3D12Device7_GetNodeCount(This)	\
+    ( (This)->lpVtbl -> GetNodeCount(This) ) 
+
+#define ID3D12Device7_CreateCommandQueue(This,pDesc,riid,ppCommandQueue)	\
+    ( (This)->lpVtbl -> CreateCommandQueue(This,pDesc,riid,ppCommandQueue) ) 
+
+#define ID3D12Device7_CreateCommandAllocator(This,type,riid,ppCommandAllocator)	\
+    ( (This)->lpVtbl -> CreateCommandAllocator(This,type,riid,ppCommandAllocator) ) 
+
+#define ID3D12Device7_CreateGraphicsPipelineState(This,pDesc,riid,ppPipelineState)	\
+    ( (This)->lpVtbl -> CreateGraphicsPipelineState(This,pDesc,riid,ppPipelineState) ) 
+
+#define ID3D12Device7_CreateComputePipelineState(This,pDesc,riid,ppPipelineState)	\
+    ( (This)->lpVtbl -> CreateComputePipelineState(This,pDesc,riid,ppPipelineState) ) 
+
+#define ID3D12Device7_CreateCommandList(This,nodeMask,type,pCommandAllocator,pInitialState,riid,ppCommandList)	\
+    ( (This)->lpVtbl -> CreateCommandList(This,nodeMask,type,pCommandAllocator,pInitialState,riid,ppCommandList) ) 
+
+#define ID3D12Device7_CheckFeatureSupport(This,Feature,pFeatureSupportData,FeatureSupportDataSize)	\
+    ( (This)->lpVtbl -> CheckFeatureSupport(This,Feature,pFeatureSupportData,FeatureSupportDataSize) ) 
+
+#define ID3D12Device7_CreateDescriptorHeap(This,pDescriptorHeapDesc,riid,ppvHeap)	\
+    ( (This)->lpVtbl -> CreateDescriptorHeap(This,pDescriptorHeapDesc,riid,ppvHeap) ) 
+
+#define ID3D12Device7_GetDescriptorHandleIncrementSize(This,DescriptorHeapType)	\
+    ( (This)->lpVtbl -> GetDescriptorHandleIncrementSize(This,DescriptorHeapType) ) 
+
+#define ID3D12Device7_CreateRootSignature(This,nodeMask,pBlobWithRootSignature,blobLengthInBytes,riid,ppvRootSignature)	\
+    ( (This)->lpVtbl -> CreateRootSignature(This,nodeMask,pBlobWithRootSignature,blobLengthInBytes,riid,ppvRootSignature) ) 
+
+#define ID3D12Device7_CreateConstantBufferView(This,pDesc,DestDescriptor)	\
+    ( (This)->lpVtbl -> CreateConstantBufferView(This,pDesc,DestDescriptor) ) 
+
+#define ID3D12Device7_CreateShaderResourceView(This,pResource,pDesc,DestDescriptor)	\
+    ( (This)->lpVtbl -> CreateShaderResourceView(This,pResource,pDesc,DestDescriptor) ) 
+
+#define ID3D12Device7_CreateUnorderedAccessView(This,pResource,pCounterResource,pDesc,DestDescriptor)	\
+    ( (This)->lpVtbl -> CreateUnorderedAccessView(This,pResource,pCounterResource,pDesc,DestDescriptor) ) 
+
+#define ID3D12Device7_CreateRenderTargetView(This,pResource,pDesc,DestDescriptor)	\
+    ( (This)->lpVtbl -> CreateRenderTargetView(This,pResource,pDesc,DestDescriptor) ) 
+
+#define ID3D12Device7_CreateDepthStencilView(This,pResource,pDesc,DestDescriptor)	\
+    ( (This)->lpVtbl -> CreateDepthStencilView(This,pResource,pDesc,DestDescriptor) ) 
+
+#define ID3D12Device7_CreateSampler(This,pDesc,DestDescriptor)	\
+    ( (This)->lpVtbl -> CreateSampler(This,pDesc,DestDescriptor) ) 
+
+#define ID3D12Device7_CopyDescriptors(This,NumDestDescriptorRanges,pDestDescriptorRangeStarts,pDestDescriptorRangeSizes,NumSrcDescriptorRanges,pSrcDescriptorRangeStarts,pSrcDescriptorRangeSizes,DescriptorHeapsType)	\
+    ( (This)->lpVtbl -> CopyDescriptors(This,NumDestDescriptorRanges,pDestDescriptorRangeStarts,pDestDescriptorRangeSizes,NumSrcDescriptorRanges,pSrcDescriptorRangeStarts,pSrcDescriptorRangeSizes,DescriptorHeapsType) ) 
+
+#define ID3D12Device7_CopyDescriptorsSimple(This,NumDescriptors,DestDescriptorRangeStart,SrcDescriptorRangeStart,DescriptorHeapsType)	\
+    ( (This)->lpVtbl -> CopyDescriptorsSimple(This,NumDescriptors,DestDescriptorRangeStart,SrcDescriptorRangeStart,DescriptorHeapsType) ) 
+#if !defined(_WIN32)
+
+#define ID3D12Device7_GetResourceAllocationInfo(This,visibleMask,numResourceDescs,pResourceDescs)	\
+    ( (This)->lpVtbl -> GetResourceAllocationInfo(This,visibleMask,numResourceDescs,pResourceDescs) ) 
+#else
+#define ID3D12Device7_GetResourceAllocationInfo(This,RetVal,visibleMask,numResourceDescs,pResourceDescs)	\
+    ( (This)->lpVtbl -> GetResourceAllocationInfo(This,RetVal,visibleMask,numResourceDescs,pResourceDescs) ) 
+#endif
+#if !defined(_WIN32)
+
+#define ID3D12Device7_GetCustomHeapProperties(This,nodeMask,heapType)	\
+    ( (This)->lpVtbl -> GetCustomHeapProperties(This,nodeMask,heapType) ) 
+#else
+#define ID3D12Device7_GetCustomHeapProperties(This,RetVal,nodeMask,heapType)	\
+    ( (This)->lpVtbl -> GetCustomHeapProperties(This,RetVal,nodeMask,heapType) ) 
+#endif
+
+#define ID3D12Device7_CreateCommittedResource(This,pHeapProperties,HeapFlags,pDesc,InitialResourceState,pOptimizedClearValue,riidResource,ppvResource)	\
+    ( (This)->lpVtbl -> CreateCommittedResource(This,pHeapProperties,HeapFlags,pDesc,InitialResourceState,pOptimizedClearValue,riidResource,ppvResource) ) 
+
+#define ID3D12Device7_CreateHeap(This,pDesc,riid,ppvHeap)	\
+    ( (This)->lpVtbl -> CreateHeap(This,pDesc,riid,ppvHeap) ) 
+
+#define ID3D12Device7_CreatePlacedResource(This,pHeap,HeapOffset,pDesc,InitialState,pOptimizedClearValue,riid,ppvResource)	\
+    ( (This)->lpVtbl -> CreatePlacedResource(This,pHeap,HeapOffset,pDesc,InitialState,pOptimizedClearValue,riid,ppvResource) ) 
+
+#define ID3D12Device7_CreateReservedResource(This,pDesc,InitialState,pOptimizedClearValue,riid,ppvResource)	\
+    ( (This)->lpVtbl -> CreateReservedResource(This,pDesc,InitialState,pOptimizedClearValue,riid,ppvResource) ) 
+
+#define ID3D12Device7_CreateSharedHandle(This,pObject,pAttributes,Access,Name,pHandle)	\
+    ( (This)->lpVtbl -> CreateSharedHandle(This,pObject,pAttributes,Access,Name,pHandle) ) 
+
+#define ID3D12Device7_OpenSharedHandle(This,NTHandle,riid,ppvObj)	\
+    ( (This)->lpVtbl -> OpenSharedHandle(This,NTHandle,riid,ppvObj) ) 
+
+#define ID3D12Device7_OpenSharedHandleByName(This,Name,Access,pNTHandle)	\
+    ( (This)->lpVtbl -> OpenSharedHandleByName(This,Name,Access,pNTHandle) ) 
+
+#define ID3D12Device7_MakeResident(This,NumObjects,ppObjects)	\
+    ( (This)->lpVtbl -> MakeResident(This,NumObjects,ppObjects) ) 
+
+#define ID3D12Device7_Evict(This,NumObjects,ppObjects)	\
+    ( (This)->lpVtbl -> Evict(This,NumObjects,ppObjects) ) 
+
+#define ID3D12Device7_CreateFence(This,InitialValue,Flags,riid,ppFence)	\
+    ( (This)->lpVtbl -> CreateFence(This,InitialValue,Flags,riid,ppFence) ) 
+
+#define ID3D12Device7_GetDeviceRemovedReason(This)	\
+    ( (This)->lpVtbl -> GetDeviceRemovedReason(This) ) 
+
+#define ID3D12Device7_GetCopyableFootprints(This,pResourceDesc,FirstSubresource,NumSubresources,BaseOffset,pLayouts,pNumRows,pRowSizeInBytes,pTotalBytes)	\
+    ( (This)->lpVtbl -> GetCopyableFootprints(This,pResourceDesc,FirstSubresource,NumSubresources,BaseOffset,pLayouts,pNumRows,pRowSizeInBytes,pTotalBytes) ) 
+
+#define ID3D12Device7_CreateQueryHeap(This,pDesc,riid,ppvHeap)	\
+    ( (This)->lpVtbl -> CreateQueryHeap(This,pDesc,riid,ppvHeap) ) 
+
+#define ID3D12Device7_SetStablePowerState(This,Enable)	\
+    ( (This)->lpVtbl -> SetStablePowerState(This,Enable) ) 
+
+#define ID3D12Device7_CreateCommandSignature(This,pDesc,pRootSignature,riid,ppvCommandSignature)	\
+    ( (This)->lpVtbl -> CreateCommandSignature(This,pDesc,pRootSignature,riid,ppvCommandSignature) ) 
+
+#define ID3D12Device7_GetResourceTiling(This,pTiledResource,pNumTilesForEntireResource,pPackedMipDesc,pStandardTileShapeForNonPackedMips,pNumSubresourceTilings,FirstSubresourceTilingToGet,pSubresourceTilingsForNonPackedMips)	\
+    ( (This)->lpVtbl -> GetResourceTiling(This,pTiledResource,pNumTilesForEntireResource,pPackedMipDesc,pStandardTileShapeForNonPackedMips,pNumSubresourceTilings,FirstSubresourceTilingToGet,pSubresourceTilingsForNonPackedMips) ) 
+#if !defined(_WIN32)
+
+#define ID3D12Device7_GetAdapterLuid(This)	\
+    ( (This)->lpVtbl -> GetAdapterLuid(This) ) 
+#else
+#define ID3D12Device7_GetAdapterLuid(This,RetVal)	\
+    ( (This)->lpVtbl -> GetAdapterLuid(This,RetVal) ) 
+#endif
+
+
+#define ID3D12Device7_CreatePipelineLibrary(This,pLibraryBlob,BlobLength,riid,ppPipelineLibrary)	\
+    ( (This)->lpVtbl -> CreatePipelineLibrary(This,pLibraryBlob,BlobLength,riid,ppPipelineLibrary) ) 
+
+#define ID3D12Device7_SetEventOnMultipleFenceCompletion(This,ppFences,pFenceValues,NumFences,Flags,hEvent)	\
+    ( (This)->lpVtbl -> SetEventOnMultipleFenceCompletion(This,ppFences,pFenceValues,NumFences,Flags,hEvent) ) 
+
+#define ID3D12Device7_SetResidencyPriority(This,NumObjects,ppObjects,pPriorities)	\
+    ( (This)->lpVtbl -> SetResidencyPriority(This,NumObjects,ppObjects,pPriorities) ) 
+
+
+#define ID3D12Device7_CreatePipelineState(This,pDesc,riid,ppPipelineState)	\
+    ( (This)->lpVtbl -> CreatePipelineState(This,pDesc,riid,ppPipelineState) ) 
+
+
+#define ID3D12Device7_OpenExistingHeapFromAddress(This,pAddress,riid,ppvHeap)	\
+    ( (This)->lpVtbl -> OpenExistingHeapFromAddress(This,pAddress,riid,ppvHeap) ) 
+
+#define ID3D12Device7_OpenExistingHeapFromFileMapping(This,hFileMapping,riid,ppvHeap)	\
+    ( (This)->lpVtbl -> OpenExistingHeapFromFileMapping(This,hFileMapping,riid,ppvHeap) ) 
+
+#define ID3D12Device7_EnqueueMakeResident(This,Flags,NumObjects,ppObjects,pFenceToSignal,FenceValueToSignal)	\
+    ( (This)->lpVtbl -> EnqueueMakeResident(This,Flags,NumObjects,ppObjects,pFenceToSignal,FenceValueToSignal) ) 
+
+
+#define ID3D12Device7_CreateCommandList1(This,nodeMask,type,flags,riid,ppCommandList)	\
+    ( (This)->lpVtbl -> CreateCommandList1(This,nodeMask,type,flags,riid,ppCommandList) ) 
+
+#define ID3D12Device7_CreateProtectedResourceSession(This,pDesc,riid,ppSession)	\
+    ( (This)->lpVtbl -> CreateProtectedResourceSession(This,pDesc,riid,ppSession) ) 
+
+#define ID3D12Device7_CreateCommittedResource1(This,pHeapProperties,HeapFlags,pDesc,InitialResourceState,pOptimizedClearValue,pProtectedSession,riidResource,ppvResource)	\
+    ( (This)->lpVtbl -> CreateCommittedResource1(This,pHeapProperties,HeapFlags,pDesc,InitialResourceState,pOptimizedClearValue,pProtectedSession,riidResource,ppvResource) ) 
+
+#define ID3D12Device7_CreateHeap1(This,pDesc,pProtectedSession,riid,ppvHeap)	\
+    ( (This)->lpVtbl -> CreateHeap1(This,pDesc,pProtectedSession,riid,ppvHeap) ) 
+
+#define ID3D12Device7_CreateReservedResource1(This,pDesc,InitialState,pOptimizedClearValue,pProtectedSession,riid,ppvResource)	\
+    ( (This)->lpVtbl -> CreateReservedResource1(This,pDesc,InitialState,pOptimizedClearValue,pProtectedSession,riid,ppvResource) ) 
+#if !defined(_WIN32)
+
+#define ID3D12Device7_GetResourceAllocationInfo1(This,visibleMask,numResourceDescs,pResourceDescs,pResourceAllocationInfo1)	\
+    ( (This)->lpVtbl -> GetResourceAllocationInfo1(This,visibleMask,numResourceDescs,pResourceDescs,pResourceAllocationInfo1) ) 
+#else
+#define ID3D12Device7_GetResourceAllocationInfo1(This,RetVal,visibleMask,numResourceDescs,pResourceDescs,pResourceAllocationInfo1)	\
+    ( (This)->lpVtbl -> GetResourceAllocationInfo1(This,RetVal,visibleMask,numResourceDescs,pResourceDescs,pResourceAllocationInfo1) ) 
+#endif
+
+
+#define ID3D12Device7_CreateLifetimeTracker(This,pOwner,riid,ppvTracker)	\
+    ( (This)->lpVtbl -> CreateLifetimeTracker(This,pOwner,riid,ppvTracker) ) 
+
+#define ID3D12Device7_RemoveDevice(This)	\
+    ( (This)->lpVtbl -> RemoveDevice(This) ) 
+
+#define ID3D12Device7_EnumerateMetaCommands(This,pNumMetaCommands,pDescs)	\
+    ( (This)->lpVtbl -> EnumerateMetaCommands(This,pNumMetaCommands,pDescs) ) 
+
+#define ID3D12Device7_EnumerateMetaCommandParameters(This,CommandId,Stage,pTotalStructureSizeInBytes,pParameterCount,pParameterDescs)	\
+    ( (This)->lpVtbl -> EnumerateMetaCommandParameters(This,CommandId,Stage,pTotalStructureSizeInBytes,pParameterCount,pParameterDescs) ) 
+
+#define ID3D12Device7_CreateMetaCommand(This,CommandId,NodeMask,pCreationParametersData,CreationParametersDataSizeInBytes,riid,ppMetaCommand)	\
+    ( (This)->lpVtbl -> CreateMetaCommand(This,CommandId,NodeMask,pCreationParametersData,CreationParametersDataSizeInBytes,riid,ppMetaCommand) ) 
+
+#define ID3D12Device7_CreateStateObject(This,pDesc,riid,ppStateObject)	\
+    ( (This)->lpVtbl -> CreateStateObject(This,pDesc,riid,ppStateObject) ) 
+
+#define ID3D12Device7_GetRaytracingAccelerationStructurePrebuildInfo(This,pDesc,pInfo)	\
+    ( (This)->lpVtbl -> GetRaytracingAccelerationStructurePrebuildInfo(This,pDesc,pInfo) ) 
+
+#define ID3D12Device7_CheckDriverMatchingIdentifier(This,SerializedDataType,pIdentifierToCheck)	\
+    ( (This)->lpVtbl -> CheckDriverMatchingIdentifier(This,SerializedDataType,pIdentifierToCheck) ) 
+
+
+#define ID3D12Device7_SetBackgroundProcessingMode(This,Mode,MeasurementsAction,hEventToSignalUponCompletion,pbFurtherMeasurementsDesired)	\
+    ( (This)->lpVtbl -> SetBackgroundProcessingMode(This,Mode,MeasurementsAction,hEventToSignalUponCompletion,pbFurtherMeasurementsDesired) ) 
+
+
+#define ID3D12Device7_AddToStateObject(This,pAddition,pStateObjectToGrowFrom,riid,ppNewStateObject)	\
+    ( (This)->lpVtbl -> AddToStateObject(This,pAddition,pStateObjectToGrowFrom,riid,ppNewStateObject) ) 
+
+#define ID3D12Device7_CreateProtectedResourceSession1(This,pDesc,riid,ppSession)	\
+    ( (This)->lpVtbl -> CreateProtectedResourceSession1(This,pDesc,riid,ppSession) ) 
+
+#endif /* COBJMACROS */
+
+
+#endif 	/* C style interface */
+
+
+
+
+#endif 	/* __ID3D12Device7_INTERFACE_DEFINED__ */
+
+
+#ifndef __ID3D12Device8_INTERFACE_DEFINED__
+#define __ID3D12Device8_INTERFACE_DEFINED__
+
+/* interface ID3D12Device8 */
+/* [unique][local][object][uuid] */ 
+
+
+EXTERN_C const IID IID_ID3D12Device8;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("9218E6BB-F944-4F7E-A75C-B1B2C7B701F3")
+    ID3D12Device8 : public ID3D12Device7
+    {
+    public:
+#if defined(_MSC_VER) || !defined(_WIN32)
+        virtual D3D12_RESOURCE_ALLOCATION_INFO STDMETHODCALLTYPE GetResourceAllocationInfo2( 
+            UINT visibleMask,
+            UINT numResourceDescs,
+            _In_reads_(numResourceDescs)  const D3D12_RESOURCE_DESC1 *pResourceDescs,
+            _Out_writes_opt_(numResourceDescs)  D3D12_RESOURCE_ALLOCATION_INFO1 *pResourceAllocationInfo1) = 0;
+#else
+        virtual D3D12_RESOURCE_ALLOCATION_INFO *STDMETHODCALLTYPE GetResourceAllocationInfo2( 
+            D3D12_RESOURCE_ALLOCATION_INFO * RetVal,
+            UINT visibleMask,
+            UINT numResourceDescs,
+            _In_reads_(numResourceDescs)  const D3D12_RESOURCE_DESC1 *pResourceDescs,
+            _Out_writes_opt_(numResourceDescs)  D3D12_RESOURCE_ALLOCATION_INFO1 *pResourceAllocationInfo1) = 0;
+#endif
+        
+        virtual HRESULT STDMETHODCALLTYPE CreateCommittedResource2( 
+            _In_  const D3D12_HEAP_PROPERTIES *pHeapProperties,
+            D3D12_HEAP_FLAGS HeapFlags,
+            _In_  const D3D12_RESOURCE_DESC1 *pDesc,
+            D3D12_RESOURCE_STATES InitialResourceState,
+            _In_opt_  const D3D12_CLEAR_VALUE *pOptimizedClearValue,
+            _In_opt_  ID3D12ProtectedResourceSession *pProtectedSession,
+            REFIID riidResource,
+            _COM_Outptr_opt_  void **ppvResource) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE CreatePlacedResource1( 
+            _In_  ID3D12Heap *pHeap,
+            UINT64 HeapOffset,
+            _In_  const D3D12_RESOURCE_DESC1 *pDesc,
+            D3D12_RESOURCE_STATES InitialState,
+            _In_opt_  const D3D12_CLEAR_VALUE *pOptimizedClearValue,
+            REFIID riid,
+            _COM_Outptr_opt_  void **ppvResource) = 0;
+        
+        virtual void STDMETHODCALLTYPE CreateSamplerFeedbackUnorderedAccessView( 
+            _In_opt_  ID3D12Resource *pTargetedResource,
+            _In_opt_  ID3D12Resource *pFeedbackResource,
+            _In_  D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor) = 0;
+        
+        virtual void STDMETHODCALLTYPE GetCopyableFootprints1( 
+            _In_  const D3D12_RESOURCE_DESC1 *pResourceDesc,
+            _In_range_(0,D3D12_REQ_SUBRESOURCES)  UINT FirstSubresource,
+            _In_range_(0,D3D12_REQ_SUBRESOURCES-FirstSubresource)  UINT NumSubresources,
+            UINT64 BaseOffset,
+            _Out_writes_opt_(NumSubresources)  D3D12_PLACED_SUBRESOURCE_FOOTPRINT *pLayouts,
+            _Out_writes_opt_(NumSubresources)  UINT *pNumRows,
+            _Out_writes_opt_(NumSubresources)  UINT64 *pRowSizeInBytes,
+            _Out_opt_  UINT64 *pTotalBytes) = 0;
+        
+    };
+    
+    
+#else 	/* C style interface */
+
+    typedef struct ID3D12Device8Vtbl
+    {
+        BEGIN_INTERFACE
+        
+        DECLSPEC_XFGVIRT(IUnknown, QueryInterface)
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            ID3D12Device8 * This,
+            REFIID riid,
+            _COM_Outptr_  void **ppvObject);
+        
+        DECLSPEC_XFGVIRT(IUnknown, AddRef)
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            ID3D12Device8 * This);
+        
+        DECLSPEC_XFGVIRT(IUnknown, Release)
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            ID3D12Device8 * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, GetPrivateData)
+        HRESULT ( STDMETHODCALLTYPE *GetPrivateData )( 
+            ID3D12Device8 * This,
+            _In_  REFGUID guid,
+            _Inout_  UINT *pDataSize,
+            _Out_writes_bytes_opt_( *pDataSize )  void *pData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, SetPrivateData)
+        HRESULT ( STDMETHODCALLTYPE *SetPrivateData )( 
+            ID3D12Device8 * This,
+            _In_  REFGUID guid,
+            _In_  UINT DataSize,
+            _In_reads_bytes_opt_( DataSize )  const void *pData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, SetPrivateDataInterface)
+        HRESULT ( STDMETHODCALLTYPE *SetPrivateDataInterface )( 
+            ID3D12Device8 * This,
+            _In_  REFGUID guid,
+            _In_opt_  const IUnknown *pData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, SetName)
+        HRESULT ( STDMETHODCALLTYPE *SetName )( 
+            ID3D12Device8 * This,
+            _In_z_  LPCWSTR Name);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, GetNodeCount)
+        UINT ( STDMETHODCALLTYPE *GetNodeCount )( 
+            ID3D12Device8 * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CreateCommandQueue)
+        HRESULT ( STDMETHODCALLTYPE *CreateCommandQueue )( 
+            ID3D12Device8 * This,
+            _In_  const D3D12_COMMAND_QUEUE_DESC *pDesc,
+            REFIID riid,
+            _COM_Outptr_  void **ppCommandQueue);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CreateCommandAllocator)
+        HRESULT ( STDMETHODCALLTYPE *CreateCommandAllocator )( 
+            ID3D12Device8 * This,
+            _In_  D3D12_COMMAND_LIST_TYPE type,
+            REFIID riid,
+            _COM_Outptr_  void **ppCommandAllocator);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CreateGraphicsPipelineState)
+        HRESULT ( STDMETHODCALLTYPE *CreateGraphicsPipelineState )( 
+            ID3D12Device8 * This,
+            _In_  const D3D12_GRAPHICS_PIPELINE_STATE_DESC *pDesc,
+            REFIID riid,
+            _COM_Outptr_  void **ppPipelineState);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CreateComputePipelineState)
+        HRESULT ( STDMETHODCALLTYPE *CreateComputePipelineState )( 
+            ID3D12Device8 * This,
+            _In_  const D3D12_COMPUTE_PIPELINE_STATE_DESC *pDesc,
+            REFIID riid,
+            _COM_Outptr_  void **ppPipelineState);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CreateCommandList)
+        HRESULT ( STDMETHODCALLTYPE *CreateCommandList )( 
+            ID3D12Device8 * This,
+            _In_  UINT nodeMask,
+            _In_  D3D12_COMMAND_LIST_TYPE type,
+            _In_  ID3D12CommandAllocator *pCommandAllocator,
+            _In_opt_  ID3D12PipelineState *pInitialState,
+            REFIID riid,
+            _COM_Outptr_  void **ppCommandList);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CheckFeatureSupport)
+        HRESULT ( STDMETHODCALLTYPE *CheckFeatureSupport )( 
+            ID3D12Device8 * This,
+            D3D12_FEATURE Feature,
+            _Inout_updates_bytes_(FeatureSupportDataSize)  void *pFeatureSupportData,
+            UINT FeatureSupportDataSize);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CreateDescriptorHeap)
+        HRESULT ( STDMETHODCALLTYPE *CreateDescriptorHeap )( 
+            ID3D12Device8 * This,
+            _In_  const D3D12_DESCRIPTOR_HEAP_DESC *pDescriptorHeapDesc,
+            REFIID riid,
+            _COM_Outptr_  void **ppvHeap);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, GetDescriptorHandleIncrementSize)
+        UINT ( STDMETHODCALLTYPE *GetDescriptorHandleIncrementSize )( 
+            ID3D12Device8 * This,
+            _In_  D3D12_DESCRIPTOR_HEAP_TYPE DescriptorHeapType);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CreateRootSignature)
+        HRESULT ( STDMETHODCALLTYPE *CreateRootSignature )( 
+            ID3D12Device8 * This,
+            _In_  UINT nodeMask,
+            _In_reads_(blobLengthInBytes)  const void *pBlobWithRootSignature,
+            _In_  SIZE_T blobLengthInBytes,
+            REFIID riid,
+            _COM_Outptr_  void **ppvRootSignature);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CreateConstantBufferView)
+        void ( STDMETHODCALLTYPE *CreateConstantBufferView )( 
+            ID3D12Device8 * This,
+            _In_opt_  const D3D12_CONSTANT_BUFFER_VIEW_DESC *pDesc,
+            _In_  D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CreateShaderResourceView)
+        void ( STDMETHODCALLTYPE *CreateShaderResourceView )( 
+            ID3D12Device8 * This,
+            _In_opt_  ID3D12Resource *pResource,
+            _In_opt_  const D3D12_SHADER_RESOURCE_VIEW_DESC *pDesc,
+            _In_  D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CreateUnorderedAccessView)
+        void ( STDMETHODCALLTYPE *CreateUnorderedAccessView )( 
+            ID3D12Device8 * This,
+            _In_opt_  ID3D12Resource *pResource,
+            _In_opt_  ID3D12Resource *pCounterResource,
+            _In_opt_  const D3D12_UNORDERED_ACCESS_VIEW_DESC *pDesc,
+            _In_  D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CreateRenderTargetView)
+        void ( STDMETHODCALLTYPE *CreateRenderTargetView )( 
+            ID3D12Device8 * This,
+            _In_opt_  ID3D12Resource *pResource,
+            _In_opt_  const D3D12_RENDER_TARGET_VIEW_DESC *pDesc,
+            _In_  D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CreateDepthStencilView)
+        void ( STDMETHODCALLTYPE *CreateDepthStencilView )( 
+            ID3D12Device8 * This,
+            _In_opt_  ID3D12Resource *pResource,
+            _In_opt_  const D3D12_DEPTH_STENCIL_VIEW_DESC *pDesc,
+            _In_  D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CreateSampler)
+        void ( STDMETHODCALLTYPE *CreateSampler )( 
+            ID3D12Device8 * This,
+            _In_  const D3D12_SAMPLER_DESC *pDesc,
+            _In_  D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CopyDescriptors)
+        void ( STDMETHODCALLTYPE *CopyDescriptors )( 
+            ID3D12Device8 * This,
+            _In_  UINT NumDestDescriptorRanges,
+            _In_reads_(NumDestDescriptorRanges)  const D3D12_CPU_DESCRIPTOR_HANDLE *pDestDescriptorRangeStarts,
+            _In_reads_opt_(NumDestDescriptorRanges)  const UINT *pDestDescriptorRangeSizes,
+            _In_  UINT NumSrcDescriptorRanges,
+            _In_reads_(NumSrcDescriptorRanges)  const D3D12_CPU_DESCRIPTOR_HANDLE *pSrcDescriptorRangeStarts,
+            _In_reads_opt_(NumSrcDescriptorRanges)  const UINT *pSrcDescriptorRangeSizes,
+            _In_  D3D12_DESCRIPTOR_HEAP_TYPE DescriptorHeapsType);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CopyDescriptorsSimple)
+        void ( STDMETHODCALLTYPE *CopyDescriptorsSimple )( 
+            ID3D12Device8 * This,
+            _In_  UINT NumDescriptors,
+            _In_  D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptorRangeStart,
+            _In_  D3D12_CPU_DESCRIPTOR_HANDLE SrcDescriptorRangeStart,
+            _In_  D3D12_DESCRIPTOR_HEAP_TYPE DescriptorHeapsType);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, GetResourceAllocationInfo)
+#if !defined(_WIN32)
+        D3D12_RESOURCE_ALLOCATION_INFO ( STDMETHODCALLTYPE *GetResourceAllocationInfo )( 
+            ID3D12Device8 * This,
+            _In_  UINT visibleMask,
+            _In_  UINT numResourceDescs,
+            _In_reads_(numResourceDescs)  const D3D12_RESOURCE_DESC *pResourceDescs);
+        
+#else
+        D3D12_RESOURCE_ALLOCATION_INFO *( STDMETHODCALLTYPE *GetResourceAllocationInfo )( 
+            ID3D12Device8 * This,
+            D3D12_RESOURCE_ALLOCATION_INFO * RetVal,
+            _In_  UINT visibleMask,
+            _In_  UINT numResourceDescs,
+            _In_reads_(numResourceDescs)  const D3D12_RESOURCE_DESC *pResourceDescs);
+        
+#endif
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, GetCustomHeapProperties)
+#if !defined(_WIN32)
+        D3D12_HEAP_PROPERTIES ( STDMETHODCALLTYPE *GetCustomHeapProperties )( 
+            ID3D12Device8 * This,
+            _In_  UINT nodeMask,
+            D3D12_HEAP_TYPE heapType);
+        
+#else
+        D3D12_HEAP_PROPERTIES *( STDMETHODCALLTYPE *GetCustomHeapProperties )( 
+            ID3D12Device8 * This,
+            D3D12_HEAP_PROPERTIES * RetVal,
+            _In_  UINT nodeMask,
+            D3D12_HEAP_TYPE heapType);
+        
+#endif
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CreateCommittedResource)
+        HRESULT ( STDMETHODCALLTYPE *CreateCommittedResource )( 
+            ID3D12Device8 * This,
+            _In_  const D3D12_HEAP_PROPERTIES *pHeapProperties,
+            D3D12_HEAP_FLAGS HeapFlags,
+            _In_  const D3D12_RESOURCE_DESC *pDesc,
+            D3D12_RESOURCE_STATES InitialResourceState,
+            _In_opt_  const D3D12_CLEAR_VALUE *pOptimizedClearValue,
+            REFIID riidResource,
+            _COM_Outptr_opt_  void **ppvResource);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CreateHeap)
+        HRESULT ( STDMETHODCALLTYPE *CreateHeap )( 
+            ID3D12Device8 * This,
+            _In_  const D3D12_HEAP_DESC *pDesc,
+            REFIID riid,
+            _COM_Outptr_opt_  void **ppvHeap);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CreatePlacedResource)
+        HRESULT ( STDMETHODCALLTYPE *CreatePlacedResource )( 
+            ID3D12Device8 * This,
+            _In_  ID3D12Heap *pHeap,
+            UINT64 HeapOffset,
+            _In_  const D3D12_RESOURCE_DESC *pDesc,
+            D3D12_RESOURCE_STATES InitialState,
+            _In_opt_  const D3D12_CLEAR_VALUE *pOptimizedClearValue,
+            REFIID riid,
+            _COM_Outptr_opt_  void **ppvResource);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CreateReservedResource)
+        HRESULT ( STDMETHODCALLTYPE *CreateReservedResource )( 
+            ID3D12Device8 * This,
+            _In_  const D3D12_RESOURCE_DESC *pDesc,
+            D3D12_RESOURCE_STATES InitialState,
+            _In_opt_  const D3D12_CLEAR_VALUE *pOptimizedClearValue,
+            REFIID riid,
+            _COM_Outptr_opt_  void **ppvResource);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CreateSharedHandle)
+        HRESULT ( STDMETHODCALLTYPE *CreateSharedHandle )( 
+            ID3D12Device8 * This,
+            _In_  ID3D12DeviceChild *pObject,
+            _In_opt_  const SECURITY_ATTRIBUTES *pAttributes,
+            DWORD Access,
+            _In_opt_  LPCWSTR Name,
+            _Out_  HANDLE *pHandle);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, OpenSharedHandle)
+        HRESULT ( STDMETHODCALLTYPE *OpenSharedHandle )( 
+            ID3D12Device8 * This,
+            _In_  HANDLE NTHandle,
+            REFIID riid,
+            _COM_Outptr_opt_  void **ppvObj);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, OpenSharedHandleByName)
+        HRESULT ( STDMETHODCALLTYPE *OpenSharedHandleByName )( 
+            ID3D12Device8 * This,
+            _In_  LPCWSTR Name,
+            DWORD Access,
+            /* [annotation][out] */ 
+            _Out_  HANDLE *pNTHandle);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, MakeResident)
+        HRESULT ( STDMETHODCALLTYPE *MakeResident )( 
+            ID3D12Device8 * This,
+            UINT NumObjects,
+            _In_reads_(NumObjects)  ID3D12Pageable *const *ppObjects);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, Evict)
+        HRESULT ( STDMETHODCALLTYPE *Evict )( 
+            ID3D12Device8 * This,
+            UINT NumObjects,
+            _In_reads_(NumObjects)  ID3D12Pageable *const *ppObjects);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CreateFence)
+        HRESULT ( STDMETHODCALLTYPE *CreateFence )( 
+            ID3D12Device8 * This,
+            UINT64 InitialValue,
+            D3D12_FENCE_FLAGS Flags,
+            REFIID riid,
+            _COM_Outptr_  void **ppFence);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, GetDeviceRemovedReason)
+        HRESULT ( STDMETHODCALLTYPE *GetDeviceRemovedReason )( 
+            ID3D12Device8 * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, GetCopyableFootprints)
+        void ( STDMETHODCALLTYPE *GetCopyableFootprints )( 
+            ID3D12Device8 * This,
+            _In_  const D3D12_RESOURCE_DESC *pResourceDesc,
+            _In_range_(0,D3D12_REQ_SUBRESOURCES)  UINT FirstSubresource,
+            _In_range_(0,D3D12_REQ_SUBRESOURCES-FirstSubresource)  UINT NumSubresources,
+            UINT64 BaseOffset,
+            _Out_writes_opt_(NumSubresources)  D3D12_PLACED_SUBRESOURCE_FOOTPRINT *pLayouts,
+            _Out_writes_opt_(NumSubresources)  UINT *pNumRows,
+            _Out_writes_opt_(NumSubresources)  UINT64 *pRowSizeInBytes,
+            _Out_opt_  UINT64 *pTotalBytes);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CreateQueryHeap)
+        HRESULT ( STDMETHODCALLTYPE *CreateQueryHeap )( 
+            ID3D12Device8 * This,
+            _In_  const D3D12_QUERY_HEAP_DESC *pDesc,
+            REFIID riid,
+            _COM_Outptr_opt_  void **ppvHeap);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, SetStablePowerState)
+        HRESULT ( STDMETHODCALLTYPE *SetStablePowerState )( 
+            ID3D12Device8 * This,
+            BOOL Enable);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CreateCommandSignature)
+        HRESULT ( STDMETHODCALLTYPE *CreateCommandSignature )( 
+            ID3D12Device8 * This,
+            _In_  const D3D12_COMMAND_SIGNATURE_DESC *pDesc,
+            _In_opt_  ID3D12RootSignature *pRootSignature,
+            REFIID riid,
+            _COM_Outptr_opt_  void **ppvCommandSignature);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, GetResourceTiling)
+        void ( STDMETHODCALLTYPE *GetResourceTiling )( 
+            ID3D12Device8 * This,
+            _In_  ID3D12Resource *pTiledResource,
+            _Out_opt_  UINT *pNumTilesForEntireResource,
+            _Out_opt_  D3D12_PACKED_MIP_INFO *pPackedMipDesc,
+            _Out_opt_  D3D12_TILE_SHAPE *pStandardTileShapeForNonPackedMips,
+            _Inout_opt_  UINT *pNumSubresourceTilings,
+            _In_  UINT FirstSubresourceTilingToGet,
+            _Out_writes_(*pNumSubresourceTilings)  D3D12_SUBRESOURCE_TILING *pSubresourceTilingsForNonPackedMips);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, GetAdapterLuid)
+#if !defined(_WIN32)
+        LUID ( STDMETHODCALLTYPE *GetAdapterLuid )( 
+            ID3D12Device8 * This);
+        
+#else
+        LUID *( STDMETHODCALLTYPE *GetAdapterLuid )( 
+            ID3D12Device8 * This,
+            LUID * RetVal);
+        
+#endif
+        
+        DECLSPEC_XFGVIRT(ID3D12Device1, CreatePipelineLibrary)
+        HRESULT ( STDMETHODCALLTYPE *CreatePipelineLibrary )( 
+            ID3D12Device8 * This,
+            _In_reads_(BlobLength)  const void *pLibraryBlob,
+            SIZE_T BlobLength,
+            REFIID riid,
+            _COM_Outptr_  void **ppPipelineLibrary);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device1, SetEventOnMultipleFenceCompletion)
+        HRESULT ( STDMETHODCALLTYPE *SetEventOnMultipleFenceCompletion )( 
+            ID3D12Device8 * This,
+            _In_reads_(NumFences)  ID3D12Fence *const *ppFences,
+            _In_reads_(NumFences)  const UINT64 *pFenceValues,
+            UINT NumFences,
+            D3D12_MULTIPLE_FENCE_WAIT_FLAGS Flags,
+            HANDLE hEvent);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device1, SetResidencyPriority)
+        HRESULT ( STDMETHODCALLTYPE *SetResidencyPriority )( 
+            ID3D12Device8 * This,
+            UINT NumObjects,
+            _In_reads_(NumObjects)  ID3D12Pageable *const *ppObjects,
+            _In_reads_(NumObjects)  const D3D12_RESIDENCY_PRIORITY *pPriorities);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device2, CreatePipelineState)
+        HRESULT ( STDMETHODCALLTYPE *CreatePipelineState )( 
+            ID3D12Device8 * This,
+            const D3D12_PIPELINE_STATE_STREAM_DESC *pDesc,
+            REFIID riid,
+            _COM_Outptr_  void **ppPipelineState);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device3, OpenExistingHeapFromAddress)
+        HRESULT ( STDMETHODCALLTYPE *OpenExistingHeapFromAddress )( 
+            ID3D12Device8 * This,
+            _In_  const void *pAddress,
+            REFIID riid,
+            _COM_Outptr_  void **ppvHeap);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device3, OpenExistingHeapFromFileMapping)
+        HRESULT ( STDMETHODCALLTYPE *OpenExistingHeapFromFileMapping )( 
+            ID3D12Device8 * This,
+            _In_  HANDLE hFileMapping,
+            REFIID riid,
+            _COM_Outptr_  void **ppvHeap);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device3, EnqueueMakeResident)
+        HRESULT ( STDMETHODCALLTYPE *EnqueueMakeResident )( 
+            ID3D12Device8 * This,
+            D3D12_RESIDENCY_FLAGS Flags,
+            UINT NumObjects,
+            _In_reads_(NumObjects)  ID3D12Pageable *const *ppObjects,
+            _In_  ID3D12Fence *pFenceToSignal,
+            UINT64 FenceValueToSignal);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device4, CreateCommandList1)
+        HRESULT ( STDMETHODCALLTYPE *CreateCommandList1 )( 
+            ID3D12Device8 * This,
+            _In_  UINT nodeMask,
+            _In_  D3D12_COMMAND_LIST_TYPE type,
+            _In_  D3D12_COMMAND_LIST_FLAGS flags,
+            REFIID riid,
+            _COM_Outptr_  void **ppCommandList);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device4, CreateProtectedResourceSession)
+        HRESULT ( STDMETHODCALLTYPE *CreateProtectedResourceSession )( 
+            ID3D12Device8 * This,
+            _In_  const D3D12_PROTECTED_RESOURCE_SESSION_DESC *pDesc,
+            _In_  REFIID riid,
+            _COM_Outptr_  void **ppSession);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device4, CreateCommittedResource1)
+        HRESULT ( STDMETHODCALLTYPE *CreateCommittedResource1 )( 
+            ID3D12Device8 * This,
+            _In_  const D3D12_HEAP_PROPERTIES *pHeapProperties,
+            D3D12_HEAP_FLAGS HeapFlags,
+            _In_  const D3D12_RESOURCE_DESC *pDesc,
+            D3D12_RESOURCE_STATES InitialResourceState,
+            _In_opt_  const D3D12_CLEAR_VALUE *pOptimizedClearValue,
+            _In_opt_  ID3D12ProtectedResourceSession *pProtectedSession,
+            REFIID riidResource,
+            _COM_Outptr_opt_  void **ppvResource);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device4, CreateHeap1)
+        HRESULT ( STDMETHODCALLTYPE *CreateHeap1 )( 
+            ID3D12Device8 * This,
+            _In_  const D3D12_HEAP_DESC *pDesc,
+            _In_opt_  ID3D12ProtectedResourceSession *pProtectedSession,
+            REFIID riid,
+            _COM_Outptr_opt_  void **ppvHeap);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device4, CreateReservedResource1)
+        HRESULT ( STDMETHODCALLTYPE *CreateReservedResource1 )( 
+            ID3D12Device8 * This,
+            _In_  const D3D12_RESOURCE_DESC *pDesc,
+            D3D12_RESOURCE_STATES InitialState,
+            _In_opt_  const D3D12_CLEAR_VALUE *pOptimizedClearValue,
+            _In_opt_  ID3D12ProtectedResourceSession *pProtectedSession,
+            REFIID riid,
+            _COM_Outptr_opt_  void **ppvResource);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device4, GetResourceAllocationInfo1)
+#if !defined(_WIN32)
+        D3D12_RESOURCE_ALLOCATION_INFO ( STDMETHODCALLTYPE *GetResourceAllocationInfo1 )( 
+            ID3D12Device8 * This,
+            UINT visibleMask,
+            UINT numResourceDescs,
+            _In_reads_(numResourceDescs)  const D3D12_RESOURCE_DESC *pResourceDescs,
+            _Out_writes_opt_(numResourceDescs)  D3D12_RESOURCE_ALLOCATION_INFO1 *pResourceAllocationInfo1);
+        
+#else
+        D3D12_RESOURCE_ALLOCATION_INFO *( STDMETHODCALLTYPE *GetResourceAllocationInfo1 )( 
+            ID3D12Device8 * This,
+            D3D12_RESOURCE_ALLOCATION_INFO * RetVal,
+            UINT visibleMask,
+            UINT numResourceDescs,
+            _In_reads_(numResourceDescs)  const D3D12_RESOURCE_DESC *pResourceDescs,
+            _Out_writes_opt_(numResourceDescs)  D3D12_RESOURCE_ALLOCATION_INFO1 *pResourceAllocationInfo1);
+        
+#endif
+        
+        DECLSPEC_XFGVIRT(ID3D12Device5, CreateLifetimeTracker)
+        HRESULT ( STDMETHODCALLTYPE *CreateLifetimeTracker )( 
+            ID3D12Device8 * This,
+            _In_  ID3D12LifetimeOwner *pOwner,
+            REFIID riid,
+            _COM_Outptr_  void **ppvTracker);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device5, RemoveDevice)
+        void ( STDMETHODCALLTYPE *RemoveDevice )( 
+            ID3D12Device8 * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device5, EnumerateMetaCommands)
+        HRESULT ( STDMETHODCALLTYPE *EnumerateMetaCommands )( 
+            ID3D12Device8 * This,
+            _Inout_  UINT *pNumMetaCommands,
+            _Out_writes_opt_(*pNumMetaCommands)  D3D12_META_COMMAND_DESC *pDescs);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device5, EnumerateMetaCommandParameters)
+        HRESULT ( STDMETHODCALLTYPE *EnumerateMetaCommandParameters )( 
+            ID3D12Device8 * This,
+            _In_  REFGUID CommandId,
+            _In_  D3D12_META_COMMAND_PARAMETER_STAGE Stage,
+            _Out_opt_  UINT *pTotalStructureSizeInBytes,
+            _Inout_  UINT *pParameterCount,
+            _Out_writes_opt_(*pParameterCount)  D3D12_META_COMMAND_PARAMETER_DESC *pParameterDescs);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device5, CreateMetaCommand)
+        HRESULT ( STDMETHODCALLTYPE *CreateMetaCommand )( 
+            ID3D12Device8 * This,
+            _In_  REFGUID CommandId,
+            _In_  UINT NodeMask,
+            _In_reads_bytes_opt_(CreationParametersDataSizeInBytes)  const void *pCreationParametersData,
+            _In_  SIZE_T CreationParametersDataSizeInBytes,
+            REFIID riid,
+            _COM_Outptr_  void **ppMetaCommand);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device5, CreateStateObject)
+        HRESULT ( STDMETHODCALLTYPE *CreateStateObject )( 
+            ID3D12Device8 * This,
+            const D3D12_STATE_OBJECT_DESC *pDesc,
+            REFIID riid,
+            _COM_Outptr_  void **ppStateObject);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device5, GetRaytracingAccelerationStructurePrebuildInfo)
+        void ( STDMETHODCALLTYPE *GetRaytracingAccelerationStructurePrebuildInfo )( 
+            ID3D12Device8 * This,
+            _In_  const D3D12_BUILD_RAYTRACING_ACCELERATION_STRUCTURE_INPUTS *pDesc,
+            _Out_  D3D12_RAYTRACING_ACCELERATION_STRUCTURE_PREBUILD_INFO *pInfo);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device5, CheckDriverMatchingIdentifier)
+        D3D12_DRIVER_MATCHING_IDENTIFIER_STATUS ( STDMETHODCALLTYPE *CheckDriverMatchingIdentifier )( 
+            ID3D12Device8 * This,
+            _In_  D3D12_SERIALIZED_DATA_TYPE SerializedDataType,
+            _In_  const D3D12_SERIALIZED_DATA_DRIVER_MATCHING_IDENTIFIER *pIdentifierToCheck);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device6, SetBackgroundProcessingMode)
+        HRESULT ( STDMETHODCALLTYPE *SetBackgroundProcessingMode )( 
+            ID3D12Device8 * This,
+            D3D12_BACKGROUND_PROCESSING_MODE Mode,
+            D3D12_MEASUREMENTS_ACTION MeasurementsAction,
+            _In_opt_  HANDLE hEventToSignalUponCompletion,
+            _Out_opt_  BOOL *pbFurtherMeasurementsDesired);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device7, AddToStateObject)
+        HRESULT ( STDMETHODCALLTYPE *AddToStateObject )( 
+            ID3D12Device8 * This,
+            const D3D12_STATE_OBJECT_DESC *pAddition,
+            ID3D12StateObject *pStateObjectToGrowFrom,
+            REFIID riid,
+            _COM_Outptr_  void **ppNewStateObject);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device7, CreateProtectedResourceSession1)
+        HRESULT ( STDMETHODCALLTYPE *CreateProtectedResourceSession1 )( 
+            ID3D12Device8 * This,
+            _In_  const D3D12_PROTECTED_RESOURCE_SESSION_DESC1 *pDesc,
+            _In_  REFIID riid,
+            _COM_Outptr_  void **ppSession);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device8, GetResourceAllocationInfo2)
+#if !defined(_WIN32)
+        D3D12_RESOURCE_ALLOCATION_INFO ( STDMETHODCALLTYPE *GetResourceAllocationInfo2 )( 
+            ID3D12Device8 * This,
+            UINT visibleMask,
+            UINT numResourceDescs,
+            _In_reads_(numResourceDescs)  const D3D12_RESOURCE_DESC1 *pResourceDescs,
+            _Out_writes_opt_(numResourceDescs)  D3D12_RESOURCE_ALLOCATION_INFO1 *pResourceAllocationInfo1);
+        
+#else
+        D3D12_RESOURCE_ALLOCATION_INFO *( STDMETHODCALLTYPE *GetResourceAllocationInfo2 )( 
+            ID3D12Device8 * This,
+            D3D12_RESOURCE_ALLOCATION_INFO * RetVal,
+            UINT visibleMask,
+            UINT numResourceDescs,
+            _In_reads_(numResourceDescs)  const D3D12_RESOURCE_DESC1 *pResourceDescs,
+            _Out_writes_opt_(numResourceDescs)  D3D12_RESOURCE_ALLOCATION_INFO1 *pResourceAllocationInfo1);
+        
+#endif
+        
+        DECLSPEC_XFGVIRT(ID3D12Device8, CreateCommittedResource2)
+        HRESULT ( STDMETHODCALLTYPE *CreateCommittedResource2 )( 
+            ID3D12Device8 * This,
+            _In_  const D3D12_HEAP_PROPERTIES *pHeapProperties,
+            D3D12_HEAP_FLAGS HeapFlags,
+            _In_  const D3D12_RESOURCE_DESC1 *pDesc,
+            D3D12_RESOURCE_STATES InitialResourceState,
+            _In_opt_  const D3D12_CLEAR_VALUE *pOptimizedClearValue,
+            _In_opt_  ID3D12ProtectedResourceSession *pProtectedSession,
+            REFIID riidResource,
+            _COM_Outptr_opt_  void **ppvResource);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device8, CreatePlacedResource1)
+        HRESULT ( STDMETHODCALLTYPE *CreatePlacedResource1 )( 
+            ID3D12Device8 * This,
+            _In_  ID3D12Heap *pHeap,
+            UINT64 HeapOffset,
+            _In_  const D3D12_RESOURCE_DESC1 *pDesc,
+            D3D12_RESOURCE_STATES InitialState,
+            _In_opt_  const D3D12_CLEAR_VALUE *pOptimizedClearValue,
+            REFIID riid,
+            _COM_Outptr_opt_  void **ppvResource);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device8, CreateSamplerFeedbackUnorderedAccessView)
+        void ( STDMETHODCALLTYPE *CreateSamplerFeedbackUnorderedAccessView )( 
+            ID3D12Device8 * This,
+            _In_opt_  ID3D12Resource *pTargetedResource,
+            _In_opt_  ID3D12Resource *pFeedbackResource,
+            _In_  D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device8, GetCopyableFootprints1)
+        void ( STDMETHODCALLTYPE *GetCopyableFootprints1 )( 
+            ID3D12Device8 * This,
+            _In_  const D3D12_RESOURCE_DESC1 *pResourceDesc,
+            _In_range_(0,D3D12_REQ_SUBRESOURCES)  UINT FirstSubresource,
+            _In_range_(0,D3D12_REQ_SUBRESOURCES-FirstSubresource)  UINT NumSubresources,
+            UINT64 BaseOffset,
+            _Out_writes_opt_(NumSubresources)  D3D12_PLACED_SUBRESOURCE_FOOTPRINT *pLayouts,
+            _Out_writes_opt_(NumSubresources)  UINT *pNumRows,
+            _Out_writes_opt_(NumSubresources)  UINT64 *pRowSizeInBytes,
+            _Out_opt_  UINT64 *pTotalBytes);
+        
+        END_INTERFACE
+    } ID3D12Device8Vtbl;
+
+    interface ID3D12Device8
+    {
+        CONST_VTBL struct ID3D12Device8Vtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define ID3D12Device8_QueryInterface(This,riid,ppvObject)	\
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define ID3D12Device8_AddRef(This)	\
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define ID3D12Device8_Release(This)	\
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#define ID3D12Device8_GetPrivateData(This,guid,pDataSize,pData)	\
+    ( (This)->lpVtbl -> GetPrivateData(This,guid,pDataSize,pData) ) 
+
+#define ID3D12Device8_SetPrivateData(This,guid,DataSize,pData)	\
+    ( (This)->lpVtbl -> SetPrivateData(This,guid,DataSize,pData) ) 
+
+#define ID3D12Device8_SetPrivateDataInterface(This,guid,pData)	\
+    ( (This)->lpVtbl -> SetPrivateDataInterface(This,guid,pData) ) 
+
+#define ID3D12Device8_SetName(This,Name)	\
+    ( (This)->lpVtbl -> SetName(This,Name) ) 
+
+
+#define ID3D12Device8_GetNodeCount(This)	\
+    ( (This)->lpVtbl -> GetNodeCount(This) ) 
+
+#define ID3D12Device8_CreateCommandQueue(This,pDesc,riid,ppCommandQueue)	\
+    ( (This)->lpVtbl -> CreateCommandQueue(This,pDesc,riid,ppCommandQueue) ) 
+
+#define ID3D12Device8_CreateCommandAllocator(This,type,riid,ppCommandAllocator)	\
+    ( (This)->lpVtbl -> CreateCommandAllocator(This,type,riid,ppCommandAllocator) ) 
+
+#define ID3D12Device8_CreateGraphicsPipelineState(This,pDesc,riid,ppPipelineState)	\
+    ( (This)->lpVtbl -> CreateGraphicsPipelineState(This,pDesc,riid,ppPipelineState) ) 
+
+#define ID3D12Device8_CreateComputePipelineState(This,pDesc,riid,ppPipelineState)	\
+    ( (This)->lpVtbl -> CreateComputePipelineState(This,pDesc,riid,ppPipelineState) ) 
+
+#define ID3D12Device8_CreateCommandList(This,nodeMask,type,pCommandAllocator,pInitialState,riid,ppCommandList)	\
+    ( (This)->lpVtbl -> CreateCommandList(This,nodeMask,type,pCommandAllocator,pInitialState,riid,ppCommandList) ) 
+
+#define ID3D12Device8_CheckFeatureSupport(This,Feature,pFeatureSupportData,FeatureSupportDataSize)	\
+    ( (This)->lpVtbl -> CheckFeatureSupport(This,Feature,pFeatureSupportData,FeatureSupportDataSize) ) 
+
+#define ID3D12Device8_CreateDescriptorHeap(This,pDescriptorHeapDesc,riid,ppvHeap)	\
+    ( (This)->lpVtbl -> CreateDescriptorHeap(This,pDescriptorHeapDesc,riid,ppvHeap) ) 
+
+#define ID3D12Device8_GetDescriptorHandleIncrementSize(This,DescriptorHeapType)	\
+    ( (This)->lpVtbl -> GetDescriptorHandleIncrementSize(This,DescriptorHeapType) ) 
+
+#define ID3D12Device8_CreateRootSignature(This,nodeMask,pBlobWithRootSignature,blobLengthInBytes,riid,ppvRootSignature)	\
+    ( (This)->lpVtbl -> CreateRootSignature(This,nodeMask,pBlobWithRootSignature,blobLengthInBytes,riid,ppvRootSignature) ) 
+
+#define ID3D12Device8_CreateConstantBufferView(This,pDesc,DestDescriptor)	\
+    ( (This)->lpVtbl -> CreateConstantBufferView(This,pDesc,DestDescriptor) ) 
+
+#define ID3D12Device8_CreateShaderResourceView(This,pResource,pDesc,DestDescriptor)	\
+    ( (This)->lpVtbl -> CreateShaderResourceView(This,pResource,pDesc,DestDescriptor) ) 
+
+#define ID3D12Device8_CreateUnorderedAccessView(This,pResource,pCounterResource,pDesc,DestDescriptor)	\
+    ( (This)->lpVtbl -> CreateUnorderedAccessView(This,pResource,pCounterResource,pDesc,DestDescriptor) ) 
+
+#define ID3D12Device8_CreateRenderTargetView(This,pResource,pDesc,DestDescriptor)	\
+    ( (This)->lpVtbl -> CreateRenderTargetView(This,pResource,pDesc,DestDescriptor) ) 
+
+#define ID3D12Device8_CreateDepthStencilView(This,pResource,pDesc,DestDescriptor)	\
+    ( (This)->lpVtbl -> CreateDepthStencilView(This,pResource,pDesc,DestDescriptor) ) 
+
+#define ID3D12Device8_CreateSampler(This,pDesc,DestDescriptor)	\
+    ( (This)->lpVtbl -> CreateSampler(This,pDesc,DestDescriptor) ) 
+
+#define ID3D12Device8_CopyDescriptors(This,NumDestDescriptorRanges,pDestDescriptorRangeStarts,pDestDescriptorRangeSizes,NumSrcDescriptorRanges,pSrcDescriptorRangeStarts,pSrcDescriptorRangeSizes,DescriptorHeapsType)	\
+    ( (This)->lpVtbl -> CopyDescriptors(This,NumDestDescriptorRanges,pDestDescriptorRangeStarts,pDestDescriptorRangeSizes,NumSrcDescriptorRanges,pSrcDescriptorRangeStarts,pSrcDescriptorRangeSizes,DescriptorHeapsType) ) 
+
+#define ID3D12Device8_CopyDescriptorsSimple(This,NumDescriptors,DestDescriptorRangeStart,SrcDescriptorRangeStart,DescriptorHeapsType)	\
+    ( (This)->lpVtbl -> CopyDescriptorsSimple(This,NumDescriptors,DestDescriptorRangeStart,SrcDescriptorRangeStart,DescriptorHeapsType) ) 
+#if !defined(_WIN32)
+
+#define ID3D12Device8_GetResourceAllocationInfo(This,visibleMask,numResourceDescs,pResourceDescs)	\
+    ( (This)->lpVtbl -> GetResourceAllocationInfo(This,visibleMask,numResourceDescs,pResourceDescs) ) 
+#else
+#define ID3D12Device8_GetResourceAllocationInfo(This,RetVal,visibleMask,numResourceDescs,pResourceDescs)	\
+    ( (This)->lpVtbl -> GetResourceAllocationInfo(This,RetVal,visibleMask,numResourceDescs,pResourceDescs) ) 
+#endif
+#if !defined(_WIN32)
+
+#define ID3D12Device8_GetCustomHeapProperties(This,nodeMask,heapType)	\
+    ( (This)->lpVtbl -> GetCustomHeapProperties(This,nodeMask,heapType) ) 
+#else
+#define ID3D12Device8_GetCustomHeapProperties(This,RetVal,nodeMask,heapType)	\
+    ( (This)->lpVtbl -> GetCustomHeapProperties(This,RetVal,nodeMask,heapType) ) 
+#endif
+
+#define ID3D12Device8_CreateCommittedResource(This,pHeapProperties,HeapFlags,pDesc,InitialResourceState,pOptimizedClearValue,riidResource,ppvResource)	\
+    ( (This)->lpVtbl -> CreateCommittedResource(This,pHeapProperties,HeapFlags,pDesc,InitialResourceState,pOptimizedClearValue,riidResource,ppvResource) ) 
+
+#define ID3D12Device8_CreateHeap(This,pDesc,riid,ppvHeap)	\
+    ( (This)->lpVtbl -> CreateHeap(This,pDesc,riid,ppvHeap) ) 
+
+#define ID3D12Device8_CreatePlacedResource(This,pHeap,HeapOffset,pDesc,InitialState,pOptimizedClearValue,riid,ppvResource)	\
+    ( (This)->lpVtbl -> CreatePlacedResource(This,pHeap,HeapOffset,pDesc,InitialState,pOptimizedClearValue,riid,ppvResource) ) 
+
+#define ID3D12Device8_CreateReservedResource(This,pDesc,InitialState,pOptimizedClearValue,riid,ppvResource)	\
+    ( (This)->lpVtbl -> CreateReservedResource(This,pDesc,InitialState,pOptimizedClearValue,riid,ppvResource) ) 
+
+#define ID3D12Device8_CreateSharedHandle(This,pObject,pAttributes,Access,Name,pHandle)	\
+    ( (This)->lpVtbl -> CreateSharedHandle(This,pObject,pAttributes,Access,Name,pHandle) ) 
+
+#define ID3D12Device8_OpenSharedHandle(This,NTHandle,riid,ppvObj)	\
+    ( (This)->lpVtbl -> OpenSharedHandle(This,NTHandle,riid,ppvObj) ) 
+
+#define ID3D12Device8_OpenSharedHandleByName(This,Name,Access,pNTHandle)	\
+    ( (This)->lpVtbl -> OpenSharedHandleByName(This,Name,Access,pNTHandle) ) 
+
+#define ID3D12Device8_MakeResident(This,NumObjects,ppObjects)	\
+    ( (This)->lpVtbl -> MakeResident(This,NumObjects,ppObjects) ) 
+
+#define ID3D12Device8_Evict(This,NumObjects,ppObjects)	\
+    ( (This)->lpVtbl -> Evict(This,NumObjects,ppObjects) ) 
+
+#define ID3D12Device8_CreateFence(This,InitialValue,Flags,riid,ppFence)	\
+    ( (This)->lpVtbl -> CreateFence(This,InitialValue,Flags,riid,ppFence) ) 
+
+#define ID3D12Device8_GetDeviceRemovedReason(This)	\
+    ( (This)->lpVtbl -> GetDeviceRemovedReason(This) ) 
+
+#define ID3D12Device8_GetCopyableFootprints(This,pResourceDesc,FirstSubresource,NumSubresources,BaseOffset,pLayouts,pNumRows,pRowSizeInBytes,pTotalBytes)	\
+    ( (This)->lpVtbl -> GetCopyableFootprints(This,pResourceDesc,FirstSubresource,NumSubresources,BaseOffset,pLayouts,pNumRows,pRowSizeInBytes,pTotalBytes) ) 
+
+#define ID3D12Device8_CreateQueryHeap(This,pDesc,riid,ppvHeap)	\
+    ( (This)->lpVtbl -> CreateQueryHeap(This,pDesc,riid,ppvHeap) ) 
+
+#define ID3D12Device8_SetStablePowerState(This,Enable)	\
+    ( (This)->lpVtbl -> SetStablePowerState(This,Enable) ) 
+
+#define ID3D12Device8_CreateCommandSignature(This,pDesc,pRootSignature,riid,ppvCommandSignature)	\
+    ( (This)->lpVtbl -> CreateCommandSignature(This,pDesc,pRootSignature,riid,ppvCommandSignature) ) 
+
+#define ID3D12Device8_GetResourceTiling(This,pTiledResource,pNumTilesForEntireResource,pPackedMipDesc,pStandardTileShapeForNonPackedMips,pNumSubresourceTilings,FirstSubresourceTilingToGet,pSubresourceTilingsForNonPackedMips)	\
+    ( (This)->lpVtbl -> GetResourceTiling(This,pTiledResource,pNumTilesForEntireResource,pPackedMipDesc,pStandardTileShapeForNonPackedMips,pNumSubresourceTilings,FirstSubresourceTilingToGet,pSubresourceTilingsForNonPackedMips) ) 
+#if !defined(_WIN32)
+
+#define ID3D12Device8_GetAdapterLuid(This)	\
+    ( (This)->lpVtbl -> GetAdapterLuid(This) ) 
+#else
+#define ID3D12Device8_GetAdapterLuid(This,RetVal)	\
+    ( (This)->lpVtbl -> GetAdapterLuid(This,RetVal) ) 
+#endif
+
+
+#define ID3D12Device8_CreatePipelineLibrary(This,pLibraryBlob,BlobLength,riid,ppPipelineLibrary)	\
+    ( (This)->lpVtbl -> CreatePipelineLibrary(This,pLibraryBlob,BlobLength,riid,ppPipelineLibrary) ) 
+
+#define ID3D12Device8_SetEventOnMultipleFenceCompletion(This,ppFences,pFenceValues,NumFences,Flags,hEvent)	\
+    ( (This)->lpVtbl -> SetEventOnMultipleFenceCompletion(This,ppFences,pFenceValues,NumFences,Flags,hEvent) ) 
+
+#define ID3D12Device8_SetResidencyPriority(This,NumObjects,ppObjects,pPriorities)	\
+    ( (This)->lpVtbl -> SetResidencyPriority(This,NumObjects,ppObjects,pPriorities) ) 
+
+
+#define ID3D12Device8_CreatePipelineState(This,pDesc,riid,ppPipelineState)	\
+    ( (This)->lpVtbl -> CreatePipelineState(This,pDesc,riid,ppPipelineState) ) 
+
+
+#define ID3D12Device8_OpenExistingHeapFromAddress(This,pAddress,riid,ppvHeap)	\
+    ( (This)->lpVtbl -> OpenExistingHeapFromAddress(This,pAddress,riid,ppvHeap) ) 
+
+#define ID3D12Device8_OpenExistingHeapFromFileMapping(This,hFileMapping,riid,ppvHeap)	\
+    ( (This)->lpVtbl -> OpenExistingHeapFromFileMapping(This,hFileMapping,riid,ppvHeap) ) 
+
+#define ID3D12Device8_EnqueueMakeResident(This,Flags,NumObjects,ppObjects,pFenceToSignal,FenceValueToSignal)	\
+    ( (This)->lpVtbl -> EnqueueMakeResident(This,Flags,NumObjects,ppObjects,pFenceToSignal,FenceValueToSignal) ) 
+
+
+#define ID3D12Device8_CreateCommandList1(This,nodeMask,type,flags,riid,ppCommandList)	\
+    ( (This)->lpVtbl -> CreateCommandList1(This,nodeMask,type,flags,riid,ppCommandList) ) 
+
+#define ID3D12Device8_CreateProtectedResourceSession(This,pDesc,riid,ppSession)	\
+    ( (This)->lpVtbl -> CreateProtectedResourceSession(This,pDesc,riid,ppSession) ) 
+
+#define ID3D12Device8_CreateCommittedResource1(This,pHeapProperties,HeapFlags,pDesc,InitialResourceState,pOptimizedClearValue,pProtectedSession,riidResource,ppvResource)	\
+    ( (This)->lpVtbl -> CreateCommittedResource1(This,pHeapProperties,HeapFlags,pDesc,InitialResourceState,pOptimizedClearValue,pProtectedSession,riidResource,ppvResource) ) 
+
+#define ID3D12Device8_CreateHeap1(This,pDesc,pProtectedSession,riid,ppvHeap)	\
+    ( (This)->lpVtbl -> CreateHeap1(This,pDesc,pProtectedSession,riid,ppvHeap) ) 
+
+#define ID3D12Device8_CreateReservedResource1(This,pDesc,InitialState,pOptimizedClearValue,pProtectedSession,riid,ppvResource)	\
+    ( (This)->lpVtbl -> CreateReservedResource1(This,pDesc,InitialState,pOptimizedClearValue,pProtectedSession,riid,ppvResource) ) 
+#if !defined(_WIN32)
+
+#define ID3D12Device8_GetResourceAllocationInfo1(This,visibleMask,numResourceDescs,pResourceDescs,pResourceAllocationInfo1)	\
+    ( (This)->lpVtbl -> GetResourceAllocationInfo1(This,visibleMask,numResourceDescs,pResourceDescs,pResourceAllocationInfo1) ) 
+#else
+#define ID3D12Device8_GetResourceAllocationInfo1(This,RetVal,visibleMask,numResourceDescs,pResourceDescs,pResourceAllocationInfo1)	\
+    ( (This)->lpVtbl -> GetResourceAllocationInfo1(This,RetVal,visibleMask,numResourceDescs,pResourceDescs,pResourceAllocationInfo1) ) 
+#endif
+
+
+#define ID3D12Device8_CreateLifetimeTracker(This,pOwner,riid,ppvTracker)	\
+    ( (This)->lpVtbl -> CreateLifetimeTracker(This,pOwner,riid,ppvTracker) ) 
+
+#define ID3D12Device8_RemoveDevice(This)	\
+    ( (This)->lpVtbl -> RemoveDevice(This) ) 
+
+#define ID3D12Device8_EnumerateMetaCommands(This,pNumMetaCommands,pDescs)	\
+    ( (This)->lpVtbl -> EnumerateMetaCommands(This,pNumMetaCommands,pDescs) ) 
+
+#define ID3D12Device8_EnumerateMetaCommandParameters(This,CommandId,Stage,pTotalStructureSizeInBytes,pParameterCount,pParameterDescs)	\
+    ( (This)->lpVtbl -> EnumerateMetaCommandParameters(This,CommandId,Stage,pTotalStructureSizeInBytes,pParameterCount,pParameterDescs) ) 
+
+#define ID3D12Device8_CreateMetaCommand(This,CommandId,NodeMask,pCreationParametersData,CreationParametersDataSizeInBytes,riid,ppMetaCommand)	\
+    ( (This)->lpVtbl -> CreateMetaCommand(This,CommandId,NodeMask,pCreationParametersData,CreationParametersDataSizeInBytes,riid,ppMetaCommand) ) 
+
+#define ID3D12Device8_CreateStateObject(This,pDesc,riid,ppStateObject)	\
+    ( (This)->lpVtbl -> CreateStateObject(This,pDesc,riid,ppStateObject) ) 
+
+#define ID3D12Device8_GetRaytracingAccelerationStructurePrebuildInfo(This,pDesc,pInfo)	\
+    ( (This)->lpVtbl -> GetRaytracingAccelerationStructurePrebuildInfo(This,pDesc,pInfo) ) 
+
+#define ID3D12Device8_CheckDriverMatchingIdentifier(This,SerializedDataType,pIdentifierToCheck)	\
+    ( (This)->lpVtbl -> CheckDriverMatchingIdentifier(This,SerializedDataType,pIdentifierToCheck) ) 
+
+
+#define ID3D12Device8_SetBackgroundProcessingMode(This,Mode,MeasurementsAction,hEventToSignalUponCompletion,pbFurtherMeasurementsDesired)	\
+    ( (This)->lpVtbl -> SetBackgroundProcessingMode(This,Mode,MeasurementsAction,hEventToSignalUponCompletion,pbFurtherMeasurementsDesired) ) 
+
+
+#define ID3D12Device8_AddToStateObject(This,pAddition,pStateObjectToGrowFrom,riid,ppNewStateObject)	\
+    ( (This)->lpVtbl -> AddToStateObject(This,pAddition,pStateObjectToGrowFrom,riid,ppNewStateObject) ) 
+
+#define ID3D12Device8_CreateProtectedResourceSession1(This,pDesc,riid,ppSession)	\
+    ( (This)->lpVtbl -> CreateProtectedResourceSession1(This,pDesc,riid,ppSession) ) 
+
+#if !defined(_WIN32)
+
+#define ID3D12Device8_GetResourceAllocationInfo2(This,visibleMask,numResourceDescs,pResourceDescs,pResourceAllocationInfo1)	\
+    ( (This)->lpVtbl -> GetResourceAllocationInfo2(This,visibleMask,numResourceDescs,pResourceDescs,pResourceAllocationInfo1) ) 
+#else
+#define ID3D12Device8_GetResourceAllocationInfo2(This,RetVal,visibleMask,numResourceDescs,pResourceDescs,pResourceAllocationInfo1)	\
+    ( (This)->lpVtbl -> GetResourceAllocationInfo2(This,RetVal,visibleMask,numResourceDescs,pResourceDescs,pResourceAllocationInfo1) ) 
+#endif
+
+#define ID3D12Device8_CreateCommittedResource2(This,pHeapProperties,HeapFlags,pDesc,InitialResourceState,pOptimizedClearValue,pProtectedSession,riidResource,ppvResource)	\
+    ( (This)->lpVtbl -> CreateCommittedResource2(This,pHeapProperties,HeapFlags,pDesc,InitialResourceState,pOptimizedClearValue,pProtectedSession,riidResource,ppvResource) ) 
+
+#define ID3D12Device8_CreatePlacedResource1(This,pHeap,HeapOffset,pDesc,InitialState,pOptimizedClearValue,riid,ppvResource)	\
+    ( (This)->lpVtbl -> CreatePlacedResource1(This,pHeap,HeapOffset,pDesc,InitialState,pOptimizedClearValue,riid,ppvResource) ) 
+
+#define ID3D12Device8_CreateSamplerFeedbackUnorderedAccessView(This,pTargetedResource,pFeedbackResource,DestDescriptor)	\
+    ( (This)->lpVtbl -> CreateSamplerFeedbackUnorderedAccessView(This,pTargetedResource,pFeedbackResource,DestDescriptor) ) 
+
+#define ID3D12Device8_GetCopyableFootprints1(This,pResourceDesc,FirstSubresource,NumSubresources,BaseOffset,pLayouts,pNumRows,pRowSizeInBytes,pTotalBytes)	\
+    ( (This)->lpVtbl -> GetCopyableFootprints1(This,pResourceDesc,FirstSubresource,NumSubresources,BaseOffset,pLayouts,pNumRows,pRowSizeInBytes,pTotalBytes) ) 
+
+#endif /* COBJMACROS */
+
+
+#endif 	/* C style interface */
+
+
+
+
+#endif 	/* __ID3D12Device8_INTERFACE_DEFINED__ */
+
+
+#ifndef __ID3D12Resource1_INTERFACE_DEFINED__
+#define __ID3D12Resource1_INTERFACE_DEFINED__
+
+/* interface ID3D12Resource1 */
+/* [unique][local][object][uuid] */ 
+
+
+EXTERN_C const IID IID_ID3D12Resource1;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("9D5E227A-4430-4161-88B3-3ECA6BB16E19")
+    ID3D12Resource1 : public ID3D12Resource
+    {
+    public:
+        virtual HRESULT STDMETHODCALLTYPE GetProtectedResourceSession( 
+            REFIID riid,
+            _COM_Outptr_opt_  void **ppProtectedSession) = 0;
+        
+    };
+    
+    
+#else 	/* C style interface */
+
+    typedef struct ID3D12Resource1Vtbl
+    {
+        BEGIN_INTERFACE
+        
+        DECLSPEC_XFGVIRT(IUnknown, QueryInterface)
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            ID3D12Resource1 * This,
+            REFIID riid,
+            _COM_Outptr_  void **ppvObject);
+        
+        DECLSPEC_XFGVIRT(IUnknown, AddRef)
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            ID3D12Resource1 * This);
+        
+        DECLSPEC_XFGVIRT(IUnknown, Release)
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            ID3D12Resource1 * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, GetPrivateData)
+        HRESULT ( STDMETHODCALLTYPE *GetPrivateData )( 
+            ID3D12Resource1 * This,
+            _In_  REFGUID guid,
+            _Inout_  UINT *pDataSize,
+            _Out_writes_bytes_opt_( *pDataSize )  void *pData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, SetPrivateData)
+        HRESULT ( STDMETHODCALLTYPE *SetPrivateData )( 
+            ID3D12Resource1 * This,
+            _In_  REFGUID guid,
+            _In_  UINT DataSize,
+            _In_reads_bytes_opt_( DataSize )  const void *pData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, SetPrivateDataInterface)
+        HRESULT ( STDMETHODCALLTYPE *SetPrivateDataInterface )( 
+            ID3D12Resource1 * This,
+            _In_  REFGUID guid,
+            _In_opt_  const IUnknown *pData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, SetName)
+        HRESULT ( STDMETHODCALLTYPE *SetName )( 
+            ID3D12Resource1 * This,
+            _In_z_  LPCWSTR Name);
+        
+        DECLSPEC_XFGVIRT(ID3D12DeviceChild, GetDevice)
+        HRESULT ( STDMETHODCALLTYPE *GetDevice )( 
+            ID3D12Resource1 * This,
+            REFIID riid,
+            _COM_Outptr_opt_  void **ppvDevice);
+        
+        DECLSPEC_XFGVIRT(ID3D12Resource, Map)
+        HRESULT ( STDMETHODCALLTYPE *Map )( 
+            ID3D12Resource1 * This,
+            UINT Subresource,
+            _In_opt_  const D3D12_RANGE *pReadRange,
+            _Outptr_opt_result_bytebuffer_(_Inexpressible_("Dependent on resource"))  void **ppData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Resource, Unmap)
+        void ( STDMETHODCALLTYPE *Unmap )( 
+            ID3D12Resource1 * This,
+            UINT Subresource,
+            _In_opt_  const D3D12_RANGE *pWrittenRange);
+        
+        DECLSPEC_XFGVIRT(ID3D12Resource, GetDesc)
+#if !defined(_WIN32)
+        D3D12_RESOURCE_DESC ( STDMETHODCALLTYPE *GetDesc )( 
+            ID3D12Resource1 * This);
+        
+#else
+        D3D12_RESOURCE_DESC *( STDMETHODCALLTYPE *GetDesc )( 
+            ID3D12Resource1 * This,
+            D3D12_RESOURCE_DESC * RetVal);
+        
+#endif
+        
+        DECLSPEC_XFGVIRT(ID3D12Resource, GetGPUVirtualAddress)
+        D3D12_GPU_VIRTUAL_ADDRESS ( STDMETHODCALLTYPE *GetGPUVirtualAddress )( 
+            ID3D12Resource1 * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12Resource, WriteToSubresource)
+        HRESULT ( STDMETHODCALLTYPE *WriteToSubresource )( 
+            ID3D12Resource1 * This,
+            UINT DstSubresource,
+            _In_opt_  const D3D12_BOX *pDstBox,
+            _In_  const void *pSrcData,
+            UINT SrcRowPitch,
+            UINT SrcDepthPitch);
+        
+        DECLSPEC_XFGVIRT(ID3D12Resource, ReadFromSubresource)
+        HRESULT ( STDMETHODCALLTYPE *ReadFromSubresource )( 
+            ID3D12Resource1 * This,
+            _Out_  void *pDstData,
+            UINT DstRowPitch,
+            UINT DstDepthPitch,
+            UINT SrcSubresource,
+            _In_opt_  const D3D12_BOX *pSrcBox);
+        
+        DECLSPEC_XFGVIRT(ID3D12Resource, GetHeapProperties)
+        HRESULT ( STDMETHODCALLTYPE *GetHeapProperties )( 
+            ID3D12Resource1 * This,
+            _Out_opt_  D3D12_HEAP_PROPERTIES *pHeapProperties,
+            _Out_opt_  D3D12_HEAP_FLAGS *pHeapFlags);
+        
+        DECLSPEC_XFGVIRT(ID3D12Resource1, GetProtectedResourceSession)
+        HRESULT ( STDMETHODCALLTYPE *GetProtectedResourceSession )( 
+            ID3D12Resource1 * This,
+            REFIID riid,
+            _COM_Outptr_opt_  void **ppProtectedSession);
+        
+        END_INTERFACE
+    } ID3D12Resource1Vtbl;
+
+    interface ID3D12Resource1
+    {
+        CONST_VTBL struct ID3D12Resource1Vtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define ID3D12Resource1_QueryInterface(This,riid,ppvObject)	\
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define ID3D12Resource1_AddRef(This)	\
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define ID3D12Resource1_Release(This)	\
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#define ID3D12Resource1_GetPrivateData(This,guid,pDataSize,pData)	\
+    ( (This)->lpVtbl -> GetPrivateData(This,guid,pDataSize,pData) ) 
+
+#define ID3D12Resource1_SetPrivateData(This,guid,DataSize,pData)	\
+    ( (This)->lpVtbl -> SetPrivateData(This,guid,DataSize,pData) ) 
+
+#define ID3D12Resource1_SetPrivateDataInterface(This,guid,pData)	\
+    ( (This)->lpVtbl -> SetPrivateDataInterface(This,guid,pData) ) 
+
+#define ID3D12Resource1_SetName(This,Name)	\
+    ( (This)->lpVtbl -> SetName(This,Name) ) 
+
+
+#define ID3D12Resource1_GetDevice(This,riid,ppvDevice)	\
+    ( (This)->lpVtbl -> GetDevice(This,riid,ppvDevice) ) 
+
+
+
+#define ID3D12Resource1_Map(This,Subresource,pReadRange,ppData)	\
+    ( (This)->lpVtbl -> Map(This,Subresource,pReadRange,ppData) ) 
+
+#define ID3D12Resource1_Unmap(This,Subresource,pWrittenRange)	\
+    ( (This)->lpVtbl -> Unmap(This,Subresource,pWrittenRange) ) 
+#if !defined(_WIN32)
+
+#define ID3D12Resource1_GetDesc(This)	\
+    ( (This)->lpVtbl -> GetDesc(This) ) 
+#else
+#define ID3D12Resource1_GetDesc(This,RetVal)	\
+    ( (This)->lpVtbl -> GetDesc(This,RetVal) ) 
+#endif
+
+#define ID3D12Resource1_GetGPUVirtualAddress(This)	\
+    ( (This)->lpVtbl -> GetGPUVirtualAddress(This) ) 
+
+#define ID3D12Resource1_WriteToSubresource(This,DstSubresource,pDstBox,pSrcData,SrcRowPitch,SrcDepthPitch)	\
+    ( (This)->lpVtbl -> WriteToSubresource(This,DstSubresource,pDstBox,pSrcData,SrcRowPitch,SrcDepthPitch) ) 
+
+#define ID3D12Resource1_ReadFromSubresource(This,pDstData,DstRowPitch,DstDepthPitch,SrcSubresource,pSrcBox)	\
+    ( (This)->lpVtbl -> ReadFromSubresource(This,pDstData,DstRowPitch,DstDepthPitch,SrcSubresource,pSrcBox) ) 
+
+#define ID3D12Resource1_GetHeapProperties(This,pHeapProperties,pHeapFlags)	\
+    ( (This)->lpVtbl -> GetHeapProperties(This,pHeapProperties,pHeapFlags) ) 
+
+
+#define ID3D12Resource1_GetProtectedResourceSession(This,riid,ppProtectedSession)	\
+    ( (This)->lpVtbl -> GetProtectedResourceSession(This,riid,ppProtectedSession) ) 
+
+#endif /* COBJMACROS */
+
+
+#endif 	/* C style interface */
+
+
+
+
+#endif 	/* __ID3D12Resource1_INTERFACE_DEFINED__ */
+
+
+#ifndef __ID3D12Resource2_INTERFACE_DEFINED__
+#define __ID3D12Resource2_INTERFACE_DEFINED__
+
+/* interface ID3D12Resource2 */
+/* [unique][local][object][uuid] */ 
+
+
+EXTERN_C const IID IID_ID3D12Resource2;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("BE36EC3B-EA85-4AEB-A45A-E9D76404A495")
+    ID3D12Resource2 : public ID3D12Resource1
+    {
+    public:
+#if defined(_MSC_VER) || !defined(_WIN32)
+        virtual D3D12_RESOURCE_DESC1 STDMETHODCALLTYPE GetDesc1( void) = 0;
+#else
+        virtual D3D12_RESOURCE_DESC1 *STDMETHODCALLTYPE GetDesc1( 
+            D3D12_RESOURCE_DESC1 * RetVal) = 0;
+#endif
+        
+    };
+    
+    
+#else 	/* C style interface */
+
+    typedef struct ID3D12Resource2Vtbl
+    {
+        BEGIN_INTERFACE
+        
+        DECLSPEC_XFGVIRT(IUnknown, QueryInterface)
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            ID3D12Resource2 * This,
+            REFIID riid,
+            _COM_Outptr_  void **ppvObject);
+        
+        DECLSPEC_XFGVIRT(IUnknown, AddRef)
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            ID3D12Resource2 * This);
+        
+        DECLSPEC_XFGVIRT(IUnknown, Release)
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            ID3D12Resource2 * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, GetPrivateData)
+        HRESULT ( STDMETHODCALLTYPE *GetPrivateData )( 
+            ID3D12Resource2 * This,
+            _In_  REFGUID guid,
+            _Inout_  UINT *pDataSize,
+            _Out_writes_bytes_opt_( *pDataSize )  void *pData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, SetPrivateData)
+        HRESULT ( STDMETHODCALLTYPE *SetPrivateData )( 
+            ID3D12Resource2 * This,
+            _In_  REFGUID guid,
+            _In_  UINT DataSize,
+            _In_reads_bytes_opt_( DataSize )  const void *pData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, SetPrivateDataInterface)
+        HRESULT ( STDMETHODCALLTYPE *SetPrivateDataInterface )( 
+            ID3D12Resource2 * This,
+            _In_  REFGUID guid,
+            _In_opt_  const IUnknown *pData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, SetName)
+        HRESULT ( STDMETHODCALLTYPE *SetName )( 
+            ID3D12Resource2 * This,
+            _In_z_  LPCWSTR Name);
+        
+        DECLSPEC_XFGVIRT(ID3D12DeviceChild, GetDevice)
+        HRESULT ( STDMETHODCALLTYPE *GetDevice )( 
+            ID3D12Resource2 * This,
+            REFIID riid,
+            _COM_Outptr_opt_  void **ppvDevice);
+        
+        DECLSPEC_XFGVIRT(ID3D12Resource, Map)
+        HRESULT ( STDMETHODCALLTYPE *Map )( 
+            ID3D12Resource2 * This,
+            UINT Subresource,
+            _In_opt_  const D3D12_RANGE *pReadRange,
+            _Outptr_opt_result_bytebuffer_(_Inexpressible_("Dependent on resource"))  void **ppData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Resource, Unmap)
+        void ( STDMETHODCALLTYPE *Unmap )( 
+            ID3D12Resource2 * This,
+            UINT Subresource,
+            _In_opt_  const D3D12_RANGE *pWrittenRange);
+        
+        DECLSPEC_XFGVIRT(ID3D12Resource, GetDesc)
+#if !defined(_WIN32)
+        D3D12_RESOURCE_DESC ( STDMETHODCALLTYPE *GetDesc )( 
+            ID3D12Resource2 * This);
+        
+#else
+        D3D12_RESOURCE_DESC *( STDMETHODCALLTYPE *GetDesc )( 
+            ID3D12Resource2 * This,
+            D3D12_RESOURCE_DESC * RetVal);
+        
+#endif
+        
+        DECLSPEC_XFGVIRT(ID3D12Resource, GetGPUVirtualAddress)
+        D3D12_GPU_VIRTUAL_ADDRESS ( STDMETHODCALLTYPE *GetGPUVirtualAddress )( 
+            ID3D12Resource2 * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12Resource, WriteToSubresource)
+        HRESULT ( STDMETHODCALLTYPE *WriteToSubresource )( 
+            ID3D12Resource2 * This,
+            UINT DstSubresource,
+            _In_opt_  const D3D12_BOX *pDstBox,
+            _In_  const void *pSrcData,
+            UINT SrcRowPitch,
+            UINT SrcDepthPitch);
+        
+        DECLSPEC_XFGVIRT(ID3D12Resource, ReadFromSubresource)
+        HRESULT ( STDMETHODCALLTYPE *ReadFromSubresource )( 
+            ID3D12Resource2 * This,
+            _Out_  void *pDstData,
+            UINT DstRowPitch,
+            UINT DstDepthPitch,
+            UINT SrcSubresource,
+            _In_opt_  const D3D12_BOX *pSrcBox);
+        
+        DECLSPEC_XFGVIRT(ID3D12Resource, GetHeapProperties)
+        HRESULT ( STDMETHODCALLTYPE *GetHeapProperties )( 
+            ID3D12Resource2 * This,
+            _Out_opt_  D3D12_HEAP_PROPERTIES *pHeapProperties,
+            _Out_opt_  D3D12_HEAP_FLAGS *pHeapFlags);
+        
+        DECLSPEC_XFGVIRT(ID3D12Resource1, GetProtectedResourceSession)
+        HRESULT ( STDMETHODCALLTYPE *GetProtectedResourceSession )( 
+            ID3D12Resource2 * This,
+            REFIID riid,
+            _COM_Outptr_opt_  void **ppProtectedSession);
+        
+        DECLSPEC_XFGVIRT(ID3D12Resource2, GetDesc1)
+#if !defined(_WIN32)
+        D3D12_RESOURCE_DESC1 ( STDMETHODCALLTYPE *GetDesc1 )( 
+            ID3D12Resource2 * This);
+        
+#else
+        D3D12_RESOURCE_DESC1 *( STDMETHODCALLTYPE *GetDesc1 )( 
+            ID3D12Resource2 * This,
+            D3D12_RESOURCE_DESC1 * RetVal);
+        
+#endif
+        
+        END_INTERFACE
+    } ID3D12Resource2Vtbl;
+
+    interface ID3D12Resource2
+    {
+        CONST_VTBL struct ID3D12Resource2Vtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define ID3D12Resource2_QueryInterface(This,riid,ppvObject)	\
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define ID3D12Resource2_AddRef(This)	\
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define ID3D12Resource2_Release(This)	\
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#define ID3D12Resource2_GetPrivateData(This,guid,pDataSize,pData)	\
+    ( (This)->lpVtbl -> GetPrivateData(This,guid,pDataSize,pData) ) 
+
+#define ID3D12Resource2_SetPrivateData(This,guid,DataSize,pData)	\
+    ( (This)->lpVtbl -> SetPrivateData(This,guid,DataSize,pData) ) 
+
+#define ID3D12Resource2_SetPrivateDataInterface(This,guid,pData)	\
+    ( (This)->lpVtbl -> SetPrivateDataInterface(This,guid,pData) ) 
+
+#define ID3D12Resource2_SetName(This,Name)	\
+    ( (This)->lpVtbl -> SetName(This,Name) ) 
+
+
+#define ID3D12Resource2_GetDevice(This,riid,ppvDevice)	\
+    ( (This)->lpVtbl -> GetDevice(This,riid,ppvDevice) ) 
+
+
+
+#define ID3D12Resource2_Map(This,Subresource,pReadRange,ppData)	\
+    ( (This)->lpVtbl -> Map(This,Subresource,pReadRange,ppData) ) 
+
+#define ID3D12Resource2_Unmap(This,Subresource,pWrittenRange)	\
+    ( (This)->lpVtbl -> Unmap(This,Subresource,pWrittenRange) ) 
+#if !defined(_WIN32)
+
+#define ID3D12Resource2_GetDesc(This)	\
+    ( (This)->lpVtbl -> GetDesc(This) ) 
+#else
+#define ID3D12Resource2_GetDesc(This,RetVal)	\
+    ( (This)->lpVtbl -> GetDesc(This,RetVal) ) 
+#endif
+
+#define ID3D12Resource2_GetGPUVirtualAddress(This)	\
+    ( (This)->lpVtbl -> GetGPUVirtualAddress(This) ) 
+
+#define ID3D12Resource2_WriteToSubresource(This,DstSubresource,pDstBox,pSrcData,SrcRowPitch,SrcDepthPitch)	\
+    ( (This)->lpVtbl -> WriteToSubresource(This,DstSubresource,pDstBox,pSrcData,SrcRowPitch,SrcDepthPitch) ) 
+
+#define ID3D12Resource2_ReadFromSubresource(This,pDstData,DstRowPitch,DstDepthPitch,SrcSubresource,pSrcBox)	\
+    ( (This)->lpVtbl -> ReadFromSubresource(This,pDstData,DstRowPitch,DstDepthPitch,SrcSubresource,pSrcBox) ) 
+
+#define ID3D12Resource2_GetHeapProperties(This,pHeapProperties,pHeapFlags)	\
+    ( (This)->lpVtbl -> GetHeapProperties(This,pHeapProperties,pHeapFlags) ) 
+
+
+#define ID3D12Resource2_GetProtectedResourceSession(This,riid,ppProtectedSession)	\
+    ( (This)->lpVtbl -> GetProtectedResourceSession(This,riid,ppProtectedSession) ) 
+
+#if !defined(_WIN32)
+
+#define ID3D12Resource2_GetDesc1(This)	\
+    ( (This)->lpVtbl -> GetDesc1(This) ) 
+#else
+#define ID3D12Resource2_GetDesc1(This,RetVal)	\
+    ( (This)->lpVtbl -> GetDesc1(This,RetVal) ) 
+#endif
+
+#endif /* COBJMACROS */
+
+
+#endif 	/* C style interface */
+
+
+
+
+#endif 	/* __ID3D12Resource2_INTERFACE_DEFINED__ */
+
+
+#ifndef __ID3D12Heap1_INTERFACE_DEFINED__
+#define __ID3D12Heap1_INTERFACE_DEFINED__
+
+/* interface ID3D12Heap1 */
+/* [unique][local][object][uuid] */ 
+
+
+EXTERN_C const IID IID_ID3D12Heap1;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("572F7389-2168-49E3-9693-D6DF5871BF6D")
+    ID3D12Heap1 : public ID3D12Heap
+    {
+    public:
+        virtual HRESULT STDMETHODCALLTYPE GetProtectedResourceSession( 
+            REFIID riid,
+            _COM_Outptr_opt_  void **ppProtectedSession) = 0;
+        
+    };
+    
+    
+#else 	/* C style interface */
+
+    typedef struct ID3D12Heap1Vtbl
+    {
+        BEGIN_INTERFACE
+        
+        DECLSPEC_XFGVIRT(IUnknown, QueryInterface)
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            ID3D12Heap1 * This,
+            REFIID riid,
+            _COM_Outptr_  void **ppvObject);
+        
+        DECLSPEC_XFGVIRT(IUnknown, AddRef)
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            ID3D12Heap1 * This);
+        
+        DECLSPEC_XFGVIRT(IUnknown, Release)
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            ID3D12Heap1 * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, GetPrivateData)
+        HRESULT ( STDMETHODCALLTYPE *GetPrivateData )( 
+            ID3D12Heap1 * This,
+            _In_  REFGUID guid,
+            _Inout_  UINT *pDataSize,
+            _Out_writes_bytes_opt_( *pDataSize )  void *pData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, SetPrivateData)
+        HRESULT ( STDMETHODCALLTYPE *SetPrivateData )( 
+            ID3D12Heap1 * This,
+            _In_  REFGUID guid,
+            _In_  UINT DataSize,
+            _In_reads_bytes_opt_( DataSize )  const void *pData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, SetPrivateDataInterface)
+        HRESULT ( STDMETHODCALLTYPE *SetPrivateDataInterface )( 
+            ID3D12Heap1 * This,
+            _In_  REFGUID guid,
+            _In_opt_  const IUnknown *pData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, SetName)
+        HRESULT ( STDMETHODCALLTYPE *SetName )( 
+            ID3D12Heap1 * This,
+            _In_z_  LPCWSTR Name);
+        
+        DECLSPEC_XFGVIRT(ID3D12DeviceChild, GetDevice)
+        HRESULT ( STDMETHODCALLTYPE *GetDevice )( 
+            ID3D12Heap1 * This,
+            REFIID riid,
+            _COM_Outptr_opt_  void **ppvDevice);
+        
+        DECLSPEC_XFGVIRT(ID3D12Heap, GetDesc)
+#if !defined(_WIN32)
+        D3D12_HEAP_DESC ( STDMETHODCALLTYPE *GetDesc )( 
+            ID3D12Heap1 * This);
+        
+#else
+        D3D12_HEAP_DESC *( STDMETHODCALLTYPE *GetDesc )( 
+            ID3D12Heap1 * This,
+            D3D12_HEAP_DESC * RetVal);
+        
+#endif
+        
+        DECLSPEC_XFGVIRT(ID3D12Heap1, GetProtectedResourceSession)
+        HRESULT ( STDMETHODCALLTYPE *GetProtectedResourceSession )( 
+            ID3D12Heap1 * This,
+            REFIID riid,
+            _COM_Outptr_opt_  void **ppProtectedSession);
+        
+        END_INTERFACE
+    } ID3D12Heap1Vtbl;
+
+    interface ID3D12Heap1
+    {
+        CONST_VTBL struct ID3D12Heap1Vtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define ID3D12Heap1_QueryInterface(This,riid,ppvObject)	\
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define ID3D12Heap1_AddRef(This)	\
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define ID3D12Heap1_Release(This)	\
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#define ID3D12Heap1_GetPrivateData(This,guid,pDataSize,pData)	\
+    ( (This)->lpVtbl -> GetPrivateData(This,guid,pDataSize,pData) ) 
+
+#define ID3D12Heap1_SetPrivateData(This,guid,DataSize,pData)	\
+    ( (This)->lpVtbl -> SetPrivateData(This,guid,DataSize,pData) ) 
+
+#define ID3D12Heap1_SetPrivateDataInterface(This,guid,pData)	\
+    ( (This)->lpVtbl -> SetPrivateDataInterface(This,guid,pData) ) 
+
+#define ID3D12Heap1_SetName(This,Name)	\
+    ( (This)->lpVtbl -> SetName(This,Name) ) 
+
+
+#define ID3D12Heap1_GetDevice(This,riid,ppvDevice)	\
+    ( (This)->lpVtbl -> GetDevice(This,riid,ppvDevice) ) 
+
+
+#if !defined(_WIN32)
+
+#define ID3D12Heap1_GetDesc(This)	\
+    ( (This)->lpVtbl -> GetDesc(This) ) 
+#else
+#define ID3D12Heap1_GetDesc(This,RetVal)	\
+    ( (This)->lpVtbl -> GetDesc(This,RetVal) ) 
+#endif
+
+
+#define ID3D12Heap1_GetProtectedResourceSession(This,riid,ppProtectedSession)	\
+    ( (This)->lpVtbl -> GetProtectedResourceSession(This,riid,ppProtectedSession) ) 
+
+#endif /* COBJMACROS */
+
+
+#endif 	/* C style interface */
+
+
+
+
+#endif 	/* __ID3D12Heap1_INTERFACE_DEFINED__ */
+
+
+#ifndef __ID3D12GraphicsCommandList3_INTERFACE_DEFINED__
+#define __ID3D12GraphicsCommandList3_INTERFACE_DEFINED__
+
+/* interface ID3D12GraphicsCommandList3 */
+/* [unique][local][object][uuid] */ 
+
+
+EXTERN_C const IID IID_ID3D12GraphicsCommandList3;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("6FDA83A7-B84C-4E38-9AC8-C7BD22016B3D")
+    ID3D12GraphicsCommandList3 : public ID3D12GraphicsCommandList2
+    {
+    public:
+        virtual void STDMETHODCALLTYPE SetProtectedResourceSession( 
+            _In_opt_  ID3D12ProtectedResourceSession *pProtectedResourceSession) = 0;
+        
+    };
+    
+    
+#else 	/* C style interface */
+
+    typedef struct ID3D12GraphicsCommandList3Vtbl
+    {
+        BEGIN_INTERFACE
+        
+        DECLSPEC_XFGVIRT(IUnknown, QueryInterface)
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            ID3D12GraphicsCommandList3 * This,
+            REFIID riid,
+            _COM_Outptr_  void **ppvObject);
+        
+        DECLSPEC_XFGVIRT(IUnknown, AddRef)
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            ID3D12GraphicsCommandList3 * This);
+        
+        DECLSPEC_XFGVIRT(IUnknown, Release)
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            ID3D12GraphicsCommandList3 * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, GetPrivateData)
+        HRESULT ( STDMETHODCALLTYPE *GetPrivateData )( 
+            ID3D12GraphicsCommandList3 * This,
+            _In_  REFGUID guid,
+            _Inout_  UINT *pDataSize,
+            _Out_writes_bytes_opt_( *pDataSize )  void *pData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, SetPrivateData)
+        HRESULT ( STDMETHODCALLTYPE *SetPrivateData )( 
+            ID3D12GraphicsCommandList3 * This,
+            _In_  REFGUID guid,
+            _In_  UINT DataSize,
+            _In_reads_bytes_opt_( DataSize )  const void *pData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, SetPrivateDataInterface)
+        HRESULT ( STDMETHODCALLTYPE *SetPrivateDataInterface )( 
+            ID3D12GraphicsCommandList3 * This,
+            _In_  REFGUID guid,
+            _In_opt_  const IUnknown *pData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, SetName)
+        HRESULT ( STDMETHODCALLTYPE *SetName )( 
+            ID3D12GraphicsCommandList3 * This,
+            _In_z_  LPCWSTR Name);
+        
+        DECLSPEC_XFGVIRT(ID3D12DeviceChild, GetDevice)
+        HRESULT ( STDMETHODCALLTYPE *GetDevice )( 
+            ID3D12GraphicsCommandList3 * This,
+            REFIID riid,
+            _COM_Outptr_opt_  void **ppvDevice);
+        
+        DECLSPEC_XFGVIRT(ID3D12CommandList, GetType)
+        D3D12_COMMAND_LIST_TYPE ( STDMETHODCALLTYPE *GetType )( 
+            ID3D12GraphicsCommandList3 * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, Close)
+        HRESULT ( STDMETHODCALLTYPE *Close )( 
+            ID3D12GraphicsCommandList3 * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, Reset)
+        HRESULT ( STDMETHODCALLTYPE *Reset )( 
+            ID3D12GraphicsCommandList3 * This,
+            _In_  ID3D12CommandAllocator *pAllocator,
+            _In_opt_  ID3D12PipelineState *pInitialState);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, ClearState)
+        void ( STDMETHODCALLTYPE *ClearState )( 
+            ID3D12GraphicsCommandList3 * This,
+            _In_opt_  ID3D12PipelineState *pPipelineState);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, DrawInstanced)
+        void ( STDMETHODCALLTYPE *DrawInstanced )( 
+            ID3D12GraphicsCommandList3 * This,
+            _In_  UINT VertexCountPerInstance,
+            _In_  UINT InstanceCount,
+            _In_  UINT StartVertexLocation,
+            _In_  UINT StartInstanceLocation);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, DrawIndexedInstanced)
+        void ( STDMETHODCALLTYPE *DrawIndexedInstanced )( 
+            ID3D12GraphicsCommandList3 * This,
+            _In_  UINT IndexCountPerInstance,
+            _In_  UINT InstanceCount,
+            _In_  UINT StartIndexLocation,
+            _In_  INT BaseVertexLocation,
+            _In_  UINT StartInstanceLocation);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, Dispatch)
+        void ( STDMETHODCALLTYPE *Dispatch )( 
+            ID3D12GraphicsCommandList3 * This,
+            _In_  UINT ThreadGroupCountX,
+            _In_  UINT ThreadGroupCountY,
+            _In_  UINT ThreadGroupCountZ);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, CopyBufferRegion)
+        void ( STDMETHODCALLTYPE *CopyBufferRegion )( 
+            ID3D12GraphicsCommandList3 * This,
+            _In_  ID3D12Resource *pDstBuffer,
+            UINT64 DstOffset,
+            _In_  ID3D12Resource *pSrcBuffer,
+            UINT64 SrcOffset,
+            UINT64 NumBytes);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, CopyTextureRegion)
+        void ( STDMETHODCALLTYPE *CopyTextureRegion )( 
+            ID3D12GraphicsCommandList3 * This,
+            _In_  const D3D12_TEXTURE_COPY_LOCATION *pDst,
+            UINT DstX,
+            UINT DstY,
+            UINT DstZ,
+            _In_  const D3D12_TEXTURE_COPY_LOCATION *pSrc,
+            _In_opt_  const D3D12_BOX *pSrcBox);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, CopyResource)
+        void ( STDMETHODCALLTYPE *CopyResource )( 
+            ID3D12GraphicsCommandList3 * This,
+            _In_  ID3D12Resource *pDstResource,
+            _In_  ID3D12Resource *pSrcResource);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, CopyTiles)
+        void ( STDMETHODCALLTYPE *CopyTiles )( 
+            ID3D12GraphicsCommandList3 * This,
+            _In_  ID3D12Resource *pTiledResource,
+            _In_  const D3D12_TILED_RESOURCE_COORDINATE *pTileRegionStartCoordinate,
+            _In_  const D3D12_TILE_REGION_SIZE *pTileRegionSize,
+            _In_  ID3D12Resource *pBuffer,
+            UINT64 BufferStartOffsetInBytes,
+            D3D12_TILE_COPY_FLAGS Flags);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, ResolveSubresource)
+        void ( STDMETHODCALLTYPE *ResolveSubresource )( 
+            ID3D12GraphicsCommandList3 * This,
+            _In_  ID3D12Resource *pDstResource,
+            _In_  UINT DstSubresource,
+            _In_  ID3D12Resource *pSrcResource,
+            _In_  UINT SrcSubresource,
+            _In_  DXGI_FORMAT Format);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, IASetPrimitiveTopology)
+        void ( STDMETHODCALLTYPE *IASetPrimitiveTopology )( 
+            ID3D12GraphicsCommandList3 * This,
+            _In_  D3D12_PRIMITIVE_TOPOLOGY PrimitiveTopology);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, RSSetViewports)
+        void ( STDMETHODCALLTYPE *RSSetViewports )( 
+            ID3D12GraphicsCommandList3 * This,
+            _In_range_(0, D3D12_VIEWPORT_AND_SCISSORRECT_OBJECT_COUNT_PER_PIPELINE)  UINT NumViewports,
+            _In_reads_( NumViewports)  const D3D12_VIEWPORT *pViewports);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, RSSetScissorRects)
+        void ( STDMETHODCALLTYPE *RSSetScissorRects )( 
+            ID3D12GraphicsCommandList3 * This,
+            _In_range_(0, D3D12_VIEWPORT_AND_SCISSORRECT_OBJECT_COUNT_PER_PIPELINE)  UINT NumRects,
+            _In_reads_( NumRects)  const D3D12_RECT *pRects);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, OMSetBlendFactor)
+        void ( STDMETHODCALLTYPE *OMSetBlendFactor )( 
+            ID3D12GraphicsCommandList3 * This,
+            _In_reads_opt_(4)  const FLOAT BlendFactor[ 4 ]);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, OMSetStencilRef)
+        void ( STDMETHODCALLTYPE *OMSetStencilRef )( 
+            ID3D12GraphicsCommandList3 * This,
+            _In_  UINT StencilRef);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetPipelineState)
+        void ( STDMETHODCALLTYPE *SetPipelineState )( 
+            ID3D12GraphicsCommandList3 * This,
+            _In_  ID3D12PipelineState *pPipelineState);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, ResourceBarrier)
+        void ( STDMETHODCALLTYPE *ResourceBarrier )( 
+            ID3D12GraphicsCommandList3 * This,
+            _In_  UINT NumBarriers,
+            _In_reads_(NumBarriers)  const D3D12_RESOURCE_BARRIER *pBarriers);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, ExecuteBundle)
+        void ( STDMETHODCALLTYPE *ExecuteBundle )( 
+            ID3D12GraphicsCommandList3 * This,
+            _In_  ID3D12GraphicsCommandList *pCommandList);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetDescriptorHeaps)
+        void ( STDMETHODCALLTYPE *SetDescriptorHeaps )( 
+            ID3D12GraphicsCommandList3 * This,
+            _In_  UINT NumDescriptorHeaps,
+            _In_reads_(NumDescriptorHeaps)  ID3D12DescriptorHeap *const *ppDescriptorHeaps);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetComputeRootSignature)
+        void ( STDMETHODCALLTYPE *SetComputeRootSignature )( 
+            ID3D12GraphicsCommandList3 * This,
+            _In_opt_  ID3D12RootSignature *pRootSignature);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetGraphicsRootSignature)
+        void ( STDMETHODCALLTYPE *SetGraphicsRootSignature )( 
+            ID3D12GraphicsCommandList3 * This,
+            _In_opt_  ID3D12RootSignature *pRootSignature);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetComputeRootDescriptorTable)
+        void ( STDMETHODCALLTYPE *SetComputeRootDescriptorTable )( 
+            ID3D12GraphicsCommandList3 * This,
+            _In_  UINT RootParameterIndex,
+            _In_  D3D12_GPU_DESCRIPTOR_HANDLE BaseDescriptor);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetGraphicsRootDescriptorTable)
+        void ( STDMETHODCALLTYPE *SetGraphicsRootDescriptorTable )( 
+            ID3D12GraphicsCommandList3 * This,
+            _In_  UINT RootParameterIndex,
+            _In_  D3D12_GPU_DESCRIPTOR_HANDLE BaseDescriptor);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetComputeRoot32BitConstant)
+        void ( STDMETHODCALLTYPE *SetComputeRoot32BitConstant )( 
+            ID3D12GraphicsCommandList3 * This,
+            _In_  UINT RootParameterIndex,
+            _In_  UINT SrcData,
+            _In_  UINT DestOffsetIn32BitValues);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetGraphicsRoot32BitConstant)
+        void ( STDMETHODCALLTYPE *SetGraphicsRoot32BitConstant )( 
+            ID3D12GraphicsCommandList3 * This,
+            _In_  UINT RootParameterIndex,
+            _In_  UINT SrcData,
+            _In_  UINT DestOffsetIn32BitValues);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetComputeRoot32BitConstants)
+        void ( STDMETHODCALLTYPE *SetComputeRoot32BitConstants )( 
+            ID3D12GraphicsCommandList3 * This,
+            _In_  UINT RootParameterIndex,
+            _In_  UINT Num32BitValuesToSet,
+            _In_reads_(Num32BitValuesToSet*sizeof(UINT))  const void *pSrcData,
+            _In_  UINT DestOffsetIn32BitValues);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetGraphicsRoot32BitConstants)
+        void ( STDMETHODCALLTYPE *SetGraphicsRoot32BitConstants )( 
+            ID3D12GraphicsCommandList3 * This,
+            _In_  UINT RootParameterIndex,
+            _In_  UINT Num32BitValuesToSet,
+            _In_reads_(Num32BitValuesToSet*sizeof(UINT))  const void *pSrcData,
+            _In_  UINT DestOffsetIn32BitValues);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetComputeRootConstantBufferView)
+        void ( STDMETHODCALLTYPE *SetComputeRootConstantBufferView )( 
+            ID3D12GraphicsCommandList3 * This,
+            _In_  UINT RootParameterIndex,
+            _In_  D3D12_GPU_VIRTUAL_ADDRESS BufferLocation);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetGraphicsRootConstantBufferView)
+        void ( STDMETHODCALLTYPE *SetGraphicsRootConstantBufferView )( 
+            ID3D12GraphicsCommandList3 * This,
+            _In_  UINT RootParameterIndex,
+            _In_  D3D12_GPU_VIRTUAL_ADDRESS BufferLocation);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetComputeRootShaderResourceView)
+        void ( STDMETHODCALLTYPE *SetComputeRootShaderResourceView )( 
+            ID3D12GraphicsCommandList3 * This,
+            _In_  UINT RootParameterIndex,
+            _In_  D3D12_GPU_VIRTUAL_ADDRESS BufferLocation);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetGraphicsRootShaderResourceView)
+        void ( STDMETHODCALLTYPE *SetGraphicsRootShaderResourceView )( 
+            ID3D12GraphicsCommandList3 * This,
+            _In_  UINT RootParameterIndex,
+            _In_  D3D12_GPU_VIRTUAL_ADDRESS BufferLocation);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetComputeRootUnorderedAccessView)
+        void ( STDMETHODCALLTYPE *SetComputeRootUnorderedAccessView )( 
+            ID3D12GraphicsCommandList3 * This,
+            _In_  UINT RootParameterIndex,
+            _In_  D3D12_GPU_VIRTUAL_ADDRESS BufferLocation);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetGraphicsRootUnorderedAccessView)
+        void ( STDMETHODCALLTYPE *SetGraphicsRootUnorderedAccessView )( 
+            ID3D12GraphicsCommandList3 * This,
+            _In_  UINT RootParameterIndex,
+            _In_  D3D12_GPU_VIRTUAL_ADDRESS BufferLocation);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, IASetIndexBuffer)
+        void ( STDMETHODCALLTYPE *IASetIndexBuffer )( 
+            ID3D12GraphicsCommandList3 * This,
+            _In_opt_  const D3D12_INDEX_BUFFER_VIEW *pView);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, IASetVertexBuffers)
+        void ( STDMETHODCALLTYPE *IASetVertexBuffers )( 
+            ID3D12GraphicsCommandList3 * This,
+            _In_  UINT StartSlot,
+            _In_  UINT NumViews,
+            _In_reads_opt_(NumViews)  const D3D12_VERTEX_BUFFER_VIEW *pViews);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SOSetTargets)
+        void ( STDMETHODCALLTYPE *SOSetTargets )( 
+            ID3D12GraphicsCommandList3 * This,
+            _In_  UINT StartSlot,
+            _In_  UINT NumViews,
+            _In_reads_opt_(NumViews)  const D3D12_STREAM_OUTPUT_BUFFER_VIEW *pViews);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, OMSetRenderTargets)
+        void ( STDMETHODCALLTYPE *OMSetRenderTargets )( 
+            ID3D12GraphicsCommandList3 * This,
+            _In_  UINT NumRenderTargetDescriptors,
+            _In_opt_  const D3D12_CPU_DESCRIPTOR_HANDLE *pRenderTargetDescriptors,
+            _In_  BOOL RTsSingleHandleToDescriptorRange,
+            _In_opt_  const D3D12_CPU_DESCRIPTOR_HANDLE *pDepthStencilDescriptor);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, ClearDepthStencilView)
+        void ( STDMETHODCALLTYPE *ClearDepthStencilView )( 
+            ID3D12GraphicsCommandList3 * This,
+            _In_  D3D12_CPU_DESCRIPTOR_HANDLE DepthStencilView,
+            _In_  D3D12_CLEAR_FLAGS ClearFlags,
+            _In_  FLOAT Depth,
+            _In_  UINT8 Stencil,
+            _In_  UINT NumRects,
+            _In_reads_(NumRects)  const D3D12_RECT *pRects);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, ClearRenderTargetView)
+        void ( STDMETHODCALLTYPE *ClearRenderTargetView )( 
+            ID3D12GraphicsCommandList3 * This,
+            _In_  D3D12_CPU_DESCRIPTOR_HANDLE RenderTargetView,
+            _In_  const FLOAT ColorRGBA[ 4 ],
+            _In_  UINT NumRects,
+            _In_reads_(NumRects)  const D3D12_RECT *pRects);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, ClearUnorderedAccessViewUint)
+        void ( STDMETHODCALLTYPE *ClearUnorderedAccessViewUint )( 
+            ID3D12GraphicsCommandList3 * This,
+            _In_  D3D12_GPU_DESCRIPTOR_HANDLE ViewGPUHandleInCurrentHeap,
+            _In_  D3D12_CPU_DESCRIPTOR_HANDLE ViewCPUHandle,
+            _In_  ID3D12Resource *pResource,
+            _In_  const UINT Values[ 4 ],
+            _In_  UINT NumRects,
+            _In_reads_(NumRects)  const D3D12_RECT *pRects);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, ClearUnorderedAccessViewFloat)
+        void ( STDMETHODCALLTYPE *ClearUnorderedAccessViewFloat )( 
+            ID3D12GraphicsCommandList3 * This,
+            _In_  D3D12_GPU_DESCRIPTOR_HANDLE ViewGPUHandleInCurrentHeap,
+            _In_  D3D12_CPU_DESCRIPTOR_HANDLE ViewCPUHandle,
+            _In_  ID3D12Resource *pResource,
+            _In_  const FLOAT Values[ 4 ],
+            _In_  UINT NumRects,
+            _In_reads_(NumRects)  const D3D12_RECT *pRects);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, DiscardResource)
+        void ( STDMETHODCALLTYPE *DiscardResource )( 
+            ID3D12GraphicsCommandList3 * This,
+            _In_  ID3D12Resource *pResource,
+            _In_opt_  const D3D12_DISCARD_REGION *pRegion);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, BeginQuery)
+        void ( STDMETHODCALLTYPE *BeginQuery )( 
+            ID3D12GraphicsCommandList3 * This,
+            _In_  ID3D12QueryHeap *pQueryHeap,
+            _In_  D3D12_QUERY_TYPE Type,
+            _In_  UINT Index);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, EndQuery)
+        void ( STDMETHODCALLTYPE *EndQuery )( 
+            ID3D12GraphicsCommandList3 * This,
+            _In_  ID3D12QueryHeap *pQueryHeap,
+            _In_  D3D12_QUERY_TYPE Type,
+            _In_  UINT Index);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, ResolveQueryData)
+        void ( STDMETHODCALLTYPE *ResolveQueryData )( 
+            ID3D12GraphicsCommandList3 * This,
+            _In_  ID3D12QueryHeap *pQueryHeap,
+            _In_  D3D12_QUERY_TYPE Type,
+            _In_  UINT StartIndex,
+            _In_  UINT NumQueries,
+            _In_  ID3D12Resource *pDestinationBuffer,
+            _In_  UINT64 AlignedDestinationBufferOffset);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetPredication)
+        void ( STDMETHODCALLTYPE *SetPredication )( 
+            ID3D12GraphicsCommandList3 * This,
+            _In_opt_  ID3D12Resource *pBuffer,
+            _In_  UINT64 AlignedBufferOffset,
+            _In_  D3D12_PREDICATION_OP Operation);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetMarker)
+        void ( STDMETHODCALLTYPE *SetMarker )( 
+            ID3D12GraphicsCommandList3 * This,
+            UINT Metadata,
+            _In_reads_bytes_opt_(Size)  const void *pData,
+            UINT Size);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, BeginEvent)
+        void ( STDMETHODCALLTYPE *BeginEvent )( 
+            ID3D12GraphicsCommandList3 * This,
+            UINT Metadata,
+            _In_reads_bytes_opt_(Size)  const void *pData,
+            UINT Size);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, EndEvent)
+        void ( STDMETHODCALLTYPE *EndEvent )( 
+            ID3D12GraphicsCommandList3 * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, ExecuteIndirect)
+        void ( STDMETHODCALLTYPE *ExecuteIndirect )( 
+            ID3D12GraphicsCommandList3 * This,
+            _In_  ID3D12CommandSignature *pCommandSignature,
+            _In_  UINT MaxCommandCount,
+            _In_  ID3D12Resource *pArgumentBuffer,
+            _In_  UINT64 ArgumentBufferOffset,
+            _In_opt_  ID3D12Resource *pCountBuffer,
+            _In_  UINT64 CountBufferOffset);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList1, AtomicCopyBufferUINT)
+        void ( STDMETHODCALLTYPE *AtomicCopyBufferUINT )( 
+            ID3D12GraphicsCommandList3 * This,
+            _In_  ID3D12Resource *pDstBuffer,
+            UINT64 DstOffset,
+            _In_  ID3D12Resource *pSrcBuffer,
+            UINT64 SrcOffset,
+            UINT Dependencies,
+            _In_reads_(Dependencies)  ID3D12Resource *const *ppDependentResources,
+            _In_reads_(Dependencies)  const D3D12_SUBRESOURCE_RANGE_UINT64 *pDependentSubresourceRanges);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList1, AtomicCopyBufferUINT64)
+        void ( STDMETHODCALLTYPE *AtomicCopyBufferUINT64 )( 
+            ID3D12GraphicsCommandList3 * This,
+            _In_  ID3D12Resource *pDstBuffer,
+            UINT64 DstOffset,
+            _In_  ID3D12Resource *pSrcBuffer,
+            UINT64 SrcOffset,
+            UINT Dependencies,
+            _In_reads_(Dependencies)  ID3D12Resource *const *ppDependentResources,
+            _In_reads_(Dependencies)  const D3D12_SUBRESOURCE_RANGE_UINT64 *pDependentSubresourceRanges);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList1, OMSetDepthBounds)
+        void ( STDMETHODCALLTYPE *OMSetDepthBounds )( 
+            ID3D12GraphicsCommandList3 * This,
+            _In_  FLOAT Min,
+            _In_  FLOAT Max);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList1, SetSamplePositions)
+        void ( STDMETHODCALLTYPE *SetSamplePositions )( 
+            ID3D12GraphicsCommandList3 * This,
+            _In_  UINT NumSamplesPerPixel,
+            _In_  UINT NumPixels,
+            _In_reads_(NumSamplesPerPixel*NumPixels)  D3D12_SAMPLE_POSITION *pSamplePositions);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList1, ResolveSubresourceRegion)
+        void ( STDMETHODCALLTYPE *ResolveSubresourceRegion )( 
+            ID3D12GraphicsCommandList3 * This,
+            _In_  ID3D12Resource *pDstResource,
+            _In_  UINT DstSubresource,
+            _In_  UINT DstX,
+            _In_  UINT DstY,
+            _In_  ID3D12Resource *pSrcResource,
+            _In_  UINT SrcSubresource,
+            _In_opt_  D3D12_RECT *pSrcRect,
+            _In_  DXGI_FORMAT Format,
+            _In_  D3D12_RESOLVE_MODE ResolveMode);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList1, SetViewInstanceMask)
+        void ( STDMETHODCALLTYPE *SetViewInstanceMask )( 
+            ID3D12GraphicsCommandList3 * This,
+            _In_  UINT Mask);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList2, WriteBufferImmediate)
+        void ( STDMETHODCALLTYPE *WriteBufferImmediate )( 
+            ID3D12GraphicsCommandList3 * This,
+            UINT Count,
+            _In_reads_(Count)  const D3D12_WRITEBUFFERIMMEDIATE_PARAMETER *pParams,
+            _In_reads_opt_(Count)  const D3D12_WRITEBUFFERIMMEDIATE_MODE *pModes);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList3, SetProtectedResourceSession)
+        void ( STDMETHODCALLTYPE *SetProtectedResourceSession )( 
+            ID3D12GraphicsCommandList3 * This,
+            _In_opt_  ID3D12ProtectedResourceSession *pProtectedResourceSession);
+        
+        END_INTERFACE
+    } ID3D12GraphicsCommandList3Vtbl;
+
+    interface ID3D12GraphicsCommandList3
+    {
+        CONST_VTBL struct ID3D12GraphicsCommandList3Vtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define ID3D12GraphicsCommandList3_QueryInterface(This,riid,ppvObject)	\
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define ID3D12GraphicsCommandList3_AddRef(This)	\
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define ID3D12GraphicsCommandList3_Release(This)	\
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#define ID3D12GraphicsCommandList3_GetPrivateData(This,guid,pDataSize,pData)	\
+    ( (This)->lpVtbl -> GetPrivateData(This,guid,pDataSize,pData) ) 
+
+#define ID3D12GraphicsCommandList3_SetPrivateData(This,guid,DataSize,pData)	\
+    ( (This)->lpVtbl -> SetPrivateData(This,guid,DataSize,pData) ) 
+
+#define ID3D12GraphicsCommandList3_SetPrivateDataInterface(This,guid,pData)	\
+    ( (This)->lpVtbl -> SetPrivateDataInterface(This,guid,pData) ) 
+
+#define ID3D12GraphicsCommandList3_SetName(This,Name)	\
+    ( (This)->lpVtbl -> SetName(This,Name) ) 
+
+
+#define ID3D12GraphicsCommandList3_GetDevice(This,riid,ppvDevice)	\
+    ( (This)->lpVtbl -> GetDevice(This,riid,ppvDevice) ) 
+
+
+#define ID3D12GraphicsCommandList3_GetType(This)	\
+    ( (This)->lpVtbl -> GetType(This) ) 
+
+
+#define ID3D12GraphicsCommandList3_Close(This)	\
+    ( (This)->lpVtbl -> Close(This) ) 
+
+#define ID3D12GraphicsCommandList3_Reset(This,pAllocator,pInitialState)	\
+    ( (This)->lpVtbl -> Reset(This,pAllocator,pInitialState) ) 
+
+#define ID3D12GraphicsCommandList3_ClearState(This,pPipelineState)	\
+    ( (This)->lpVtbl -> ClearState(This,pPipelineState) ) 
+
+#define ID3D12GraphicsCommandList3_DrawInstanced(This,VertexCountPerInstance,InstanceCount,StartVertexLocation,StartInstanceLocation)	\
+    ( (This)->lpVtbl -> DrawInstanced(This,VertexCountPerInstance,InstanceCount,StartVertexLocation,StartInstanceLocation) ) 
+
+#define ID3D12GraphicsCommandList3_DrawIndexedInstanced(This,IndexCountPerInstance,InstanceCount,StartIndexLocation,BaseVertexLocation,StartInstanceLocation)	\
+    ( (This)->lpVtbl -> DrawIndexedInstanced(This,IndexCountPerInstance,InstanceCount,StartIndexLocation,BaseVertexLocation,StartInstanceLocation) ) 
+
+#define ID3D12GraphicsCommandList3_Dispatch(This,ThreadGroupCountX,ThreadGroupCountY,ThreadGroupCountZ)	\
+    ( (This)->lpVtbl -> Dispatch(This,ThreadGroupCountX,ThreadGroupCountY,ThreadGroupCountZ) ) 
+
+#define ID3D12GraphicsCommandList3_CopyBufferRegion(This,pDstBuffer,DstOffset,pSrcBuffer,SrcOffset,NumBytes)	\
+    ( (This)->lpVtbl -> CopyBufferRegion(This,pDstBuffer,DstOffset,pSrcBuffer,SrcOffset,NumBytes) ) 
+
+#define ID3D12GraphicsCommandList3_CopyTextureRegion(This,pDst,DstX,DstY,DstZ,pSrc,pSrcBox)	\
+    ( (This)->lpVtbl -> CopyTextureRegion(This,pDst,DstX,DstY,DstZ,pSrc,pSrcBox) ) 
+
+#define ID3D12GraphicsCommandList3_CopyResource(This,pDstResource,pSrcResource)	\
+    ( (This)->lpVtbl -> CopyResource(This,pDstResource,pSrcResource) ) 
+
+#define ID3D12GraphicsCommandList3_CopyTiles(This,pTiledResource,pTileRegionStartCoordinate,pTileRegionSize,pBuffer,BufferStartOffsetInBytes,Flags)	\
+    ( (This)->lpVtbl -> CopyTiles(This,pTiledResource,pTileRegionStartCoordinate,pTileRegionSize,pBuffer,BufferStartOffsetInBytes,Flags) ) 
+
+#define ID3D12GraphicsCommandList3_ResolveSubresource(This,pDstResource,DstSubresource,pSrcResource,SrcSubresource,Format)	\
+    ( (This)->lpVtbl -> ResolveSubresource(This,pDstResource,DstSubresource,pSrcResource,SrcSubresource,Format) ) 
+
+#define ID3D12GraphicsCommandList3_IASetPrimitiveTopology(This,PrimitiveTopology)	\
+    ( (This)->lpVtbl -> IASetPrimitiveTopology(This,PrimitiveTopology) ) 
+
+#define ID3D12GraphicsCommandList3_RSSetViewports(This,NumViewports,pViewports)	\
+    ( (This)->lpVtbl -> RSSetViewports(This,NumViewports,pViewports) ) 
+
+#define ID3D12GraphicsCommandList3_RSSetScissorRects(This,NumRects,pRects)	\
+    ( (This)->lpVtbl -> RSSetScissorRects(This,NumRects,pRects) ) 
+
+#define ID3D12GraphicsCommandList3_OMSetBlendFactor(This,BlendFactor)	\
+    ( (This)->lpVtbl -> OMSetBlendFactor(This,BlendFactor) ) 
+
+#define ID3D12GraphicsCommandList3_OMSetStencilRef(This,StencilRef)	\
+    ( (This)->lpVtbl -> OMSetStencilRef(This,StencilRef) ) 
+
+#define ID3D12GraphicsCommandList3_SetPipelineState(This,pPipelineState)	\
+    ( (This)->lpVtbl -> SetPipelineState(This,pPipelineState) ) 
+
+#define ID3D12GraphicsCommandList3_ResourceBarrier(This,NumBarriers,pBarriers)	\
+    ( (This)->lpVtbl -> ResourceBarrier(This,NumBarriers,pBarriers) ) 
+
+#define ID3D12GraphicsCommandList3_ExecuteBundle(This,pCommandList)	\
+    ( (This)->lpVtbl -> ExecuteBundle(This,pCommandList) ) 
+
+#define ID3D12GraphicsCommandList3_SetDescriptorHeaps(This,NumDescriptorHeaps,ppDescriptorHeaps)	\
+    ( (This)->lpVtbl -> SetDescriptorHeaps(This,NumDescriptorHeaps,ppDescriptorHeaps) ) 
+
+#define ID3D12GraphicsCommandList3_SetComputeRootSignature(This,pRootSignature)	\
+    ( (This)->lpVtbl -> SetComputeRootSignature(This,pRootSignature) ) 
+
+#define ID3D12GraphicsCommandList3_SetGraphicsRootSignature(This,pRootSignature)	\
+    ( (This)->lpVtbl -> SetGraphicsRootSignature(This,pRootSignature) ) 
+
+#define ID3D12GraphicsCommandList3_SetComputeRootDescriptorTable(This,RootParameterIndex,BaseDescriptor)	\
+    ( (This)->lpVtbl -> SetComputeRootDescriptorTable(This,RootParameterIndex,BaseDescriptor) ) 
+
+#define ID3D12GraphicsCommandList3_SetGraphicsRootDescriptorTable(This,RootParameterIndex,BaseDescriptor)	\
+    ( (This)->lpVtbl -> SetGraphicsRootDescriptorTable(This,RootParameterIndex,BaseDescriptor) ) 
+
+#define ID3D12GraphicsCommandList3_SetComputeRoot32BitConstant(This,RootParameterIndex,SrcData,DestOffsetIn32BitValues)	\
+    ( (This)->lpVtbl -> SetComputeRoot32BitConstant(This,RootParameterIndex,SrcData,DestOffsetIn32BitValues) ) 
+
+#define ID3D12GraphicsCommandList3_SetGraphicsRoot32BitConstant(This,RootParameterIndex,SrcData,DestOffsetIn32BitValues)	\
+    ( (This)->lpVtbl -> SetGraphicsRoot32BitConstant(This,RootParameterIndex,SrcData,DestOffsetIn32BitValues) ) 
+
+#define ID3D12GraphicsCommandList3_SetComputeRoot32BitConstants(This,RootParameterIndex,Num32BitValuesToSet,pSrcData,DestOffsetIn32BitValues)	\
+    ( (This)->lpVtbl -> SetComputeRoot32BitConstants(This,RootParameterIndex,Num32BitValuesToSet,pSrcData,DestOffsetIn32BitValues) ) 
+
+#define ID3D12GraphicsCommandList3_SetGraphicsRoot32BitConstants(This,RootParameterIndex,Num32BitValuesToSet,pSrcData,DestOffsetIn32BitValues)	\
+    ( (This)->lpVtbl -> SetGraphicsRoot32BitConstants(This,RootParameterIndex,Num32BitValuesToSet,pSrcData,DestOffsetIn32BitValues) ) 
+
+#define ID3D12GraphicsCommandList3_SetComputeRootConstantBufferView(This,RootParameterIndex,BufferLocation)	\
+    ( (This)->lpVtbl -> SetComputeRootConstantBufferView(This,RootParameterIndex,BufferLocation) ) 
+
+#define ID3D12GraphicsCommandList3_SetGraphicsRootConstantBufferView(This,RootParameterIndex,BufferLocation)	\
+    ( (This)->lpVtbl -> SetGraphicsRootConstantBufferView(This,RootParameterIndex,BufferLocation) ) 
+
+#define ID3D12GraphicsCommandList3_SetComputeRootShaderResourceView(This,RootParameterIndex,BufferLocation)	\
+    ( (This)->lpVtbl -> SetComputeRootShaderResourceView(This,RootParameterIndex,BufferLocation) ) 
+
+#define ID3D12GraphicsCommandList3_SetGraphicsRootShaderResourceView(This,RootParameterIndex,BufferLocation)	\
+    ( (This)->lpVtbl -> SetGraphicsRootShaderResourceView(This,RootParameterIndex,BufferLocation) ) 
+
+#define ID3D12GraphicsCommandList3_SetComputeRootUnorderedAccessView(This,RootParameterIndex,BufferLocation)	\
+    ( (This)->lpVtbl -> SetComputeRootUnorderedAccessView(This,RootParameterIndex,BufferLocation) ) 
+
+#define ID3D12GraphicsCommandList3_SetGraphicsRootUnorderedAccessView(This,RootParameterIndex,BufferLocation)	\
+    ( (This)->lpVtbl -> SetGraphicsRootUnorderedAccessView(This,RootParameterIndex,BufferLocation) ) 
+
+#define ID3D12GraphicsCommandList3_IASetIndexBuffer(This,pView)	\
+    ( (This)->lpVtbl -> IASetIndexBuffer(This,pView) ) 
+
+#define ID3D12GraphicsCommandList3_IASetVertexBuffers(This,StartSlot,NumViews,pViews)	\
+    ( (This)->lpVtbl -> IASetVertexBuffers(This,StartSlot,NumViews,pViews) ) 
+
+#define ID3D12GraphicsCommandList3_SOSetTargets(This,StartSlot,NumViews,pViews)	\
+    ( (This)->lpVtbl -> SOSetTargets(This,StartSlot,NumViews,pViews) ) 
+
+#define ID3D12GraphicsCommandList3_OMSetRenderTargets(This,NumRenderTargetDescriptors,pRenderTargetDescriptors,RTsSingleHandleToDescriptorRange,pDepthStencilDescriptor)	\
+    ( (This)->lpVtbl -> OMSetRenderTargets(This,NumRenderTargetDescriptors,pRenderTargetDescriptors,RTsSingleHandleToDescriptorRange,pDepthStencilDescriptor) ) 
+
+#define ID3D12GraphicsCommandList3_ClearDepthStencilView(This,DepthStencilView,ClearFlags,Depth,Stencil,NumRects,pRects)	\
+    ( (This)->lpVtbl -> ClearDepthStencilView(This,DepthStencilView,ClearFlags,Depth,Stencil,NumRects,pRects) ) 
+
+#define ID3D12GraphicsCommandList3_ClearRenderTargetView(This,RenderTargetView,ColorRGBA,NumRects,pRects)	\
+    ( (This)->lpVtbl -> ClearRenderTargetView(This,RenderTargetView,ColorRGBA,NumRects,pRects) ) 
+
+#define ID3D12GraphicsCommandList3_ClearUnorderedAccessViewUint(This,ViewGPUHandleInCurrentHeap,ViewCPUHandle,pResource,Values,NumRects,pRects)	\
+    ( (This)->lpVtbl -> ClearUnorderedAccessViewUint(This,ViewGPUHandleInCurrentHeap,ViewCPUHandle,pResource,Values,NumRects,pRects) ) 
+
+#define ID3D12GraphicsCommandList3_ClearUnorderedAccessViewFloat(This,ViewGPUHandleInCurrentHeap,ViewCPUHandle,pResource,Values,NumRects,pRects)	\
+    ( (This)->lpVtbl -> ClearUnorderedAccessViewFloat(This,ViewGPUHandleInCurrentHeap,ViewCPUHandle,pResource,Values,NumRects,pRects) ) 
+
+#define ID3D12GraphicsCommandList3_DiscardResource(This,pResource,pRegion)	\
+    ( (This)->lpVtbl -> DiscardResource(This,pResource,pRegion) ) 
+
+#define ID3D12GraphicsCommandList3_BeginQuery(This,pQueryHeap,Type,Index)	\
+    ( (This)->lpVtbl -> BeginQuery(This,pQueryHeap,Type,Index) ) 
+
+#define ID3D12GraphicsCommandList3_EndQuery(This,pQueryHeap,Type,Index)	\
+    ( (This)->lpVtbl -> EndQuery(This,pQueryHeap,Type,Index) ) 
+
+#define ID3D12GraphicsCommandList3_ResolveQueryData(This,pQueryHeap,Type,StartIndex,NumQueries,pDestinationBuffer,AlignedDestinationBufferOffset)	\
+    ( (This)->lpVtbl -> ResolveQueryData(This,pQueryHeap,Type,StartIndex,NumQueries,pDestinationBuffer,AlignedDestinationBufferOffset) ) 
+
+#define ID3D12GraphicsCommandList3_SetPredication(This,pBuffer,AlignedBufferOffset,Operation)	\
+    ( (This)->lpVtbl -> SetPredication(This,pBuffer,AlignedBufferOffset,Operation) ) 
+
+#define ID3D12GraphicsCommandList3_SetMarker(This,Metadata,pData,Size)	\
+    ( (This)->lpVtbl -> SetMarker(This,Metadata,pData,Size) ) 
+
+#define ID3D12GraphicsCommandList3_BeginEvent(This,Metadata,pData,Size)	\
+    ( (This)->lpVtbl -> BeginEvent(This,Metadata,pData,Size) ) 
+
+#define ID3D12GraphicsCommandList3_EndEvent(This)	\
+    ( (This)->lpVtbl -> EndEvent(This) ) 
+
+#define ID3D12GraphicsCommandList3_ExecuteIndirect(This,pCommandSignature,MaxCommandCount,pArgumentBuffer,ArgumentBufferOffset,pCountBuffer,CountBufferOffset)	\
+    ( (This)->lpVtbl -> ExecuteIndirect(This,pCommandSignature,MaxCommandCount,pArgumentBuffer,ArgumentBufferOffset,pCountBuffer,CountBufferOffset) ) 
+
+
+#define ID3D12GraphicsCommandList3_AtomicCopyBufferUINT(This,pDstBuffer,DstOffset,pSrcBuffer,SrcOffset,Dependencies,ppDependentResources,pDependentSubresourceRanges)	\
+    ( (This)->lpVtbl -> AtomicCopyBufferUINT(This,pDstBuffer,DstOffset,pSrcBuffer,SrcOffset,Dependencies,ppDependentResources,pDependentSubresourceRanges) ) 
+
+#define ID3D12GraphicsCommandList3_AtomicCopyBufferUINT64(This,pDstBuffer,DstOffset,pSrcBuffer,SrcOffset,Dependencies,ppDependentResources,pDependentSubresourceRanges)	\
+    ( (This)->lpVtbl -> AtomicCopyBufferUINT64(This,pDstBuffer,DstOffset,pSrcBuffer,SrcOffset,Dependencies,ppDependentResources,pDependentSubresourceRanges) ) 
+
+#define ID3D12GraphicsCommandList3_OMSetDepthBounds(This,Min,Max)	\
+    ( (This)->lpVtbl -> OMSetDepthBounds(This,Min,Max) ) 
+
+#define ID3D12GraphicsCommandList3_SetSamplePositions(This,NumSamplesPerPixel,NumPixels,pSamplePositions)	\
+    ( (This)->lpVtbl -> SetSamplePositions(This,NumSamplesPerPixel,NumPixels,pSamplePositions) ) 
+
+#define ID3D12GraphicsCommandList3_ResolveSubresourceRegion(This,pDstResource,DstSubresource,DstX,DstY,pSrcResource,SrcSubresource,pSrcRect,Format,ResolveMode)	\
+    ( (This)->lpVtbl -> ResolveSubresourceRegion(This,pDstResource,DstSubresource,DstX,DstY,pSrcResource,SrcSubresource,pSrcRect,Format,ResolveMode) ) 
+
+#define ID3D12GraphicsCommandList3_SetViewInstanceMask(This,Mask)	\
+    ( (This)->lpVtbl -> SetViewInstanceMask(This,Mask) ) 
+
+
+#define ID3D12GraphicsCommandList3_WriteBufferImmediate(This,Count,pParams,pModes)	\
+    ( (This)->lpVtbl -> WriteBufferImmediate(This,Count,pParams,pModes) ) 
+
+
+#define ID3D12GraphicsCommandList3_SetProtectedResourceSession(This,pProtectedResourceSession)	\
+    ( (This)->lpVtbl -> SetProtectedResourceSession(This,pProtectedResourceSession) ) 
+
+#endif /* COBJMACROS */
+
+
+#endif 	/* C style interface */
+
+
+
+
+#endif 	/* __ID3D12GraphicsCommandList3_INTERFACE_DEFINED__ */
+
+
+/* interface __MIDL_itf_d3d12_0000_0049 */
+/* [local] */ 
+
+typedef 
+enum D3D12_RENDER_PASS_BEGINNING_ACCESS_TYPE
+    {
+        D3D12_RENDER_PASS_BEGINNING_ACCESS_TYPE_DISCARD	= 0,
+        D3D12_RENDER_PASS_BEGINNING_ACCESS_TYPE_PRESERVE	= ( D3D12_RENDER_PASS_BEGINNING_ACCESS_TYPE_DISCARD + 1 ) ,
+        D3D12_RENDER_PASS_BEGINNING_ACCESS_TYPE_CLEAR	= ( D3D12_RENDER_PASS_BEGINNING_ACCESS_TYPE_PRESERVE + 1 ) ,
+        D3D12_RENDER_PASS_BEGINNING_ACCESS_TYPE_NO_ACCESS	= ( D3D12_RENDER_PASS_BEGINNING_ACCESS_TYPE_CLEAR + 1 ) 
+    } 	D3D12_RENDER_PASS_BEGINNING_ACCESS_TYPE;
+
+typedef struct D3D12_RENDER_PASS_BEGINNING_ACCESS_CLEAR_PARAMETERS
+    {
+    D3D12_CLEAR_VALUE ClearValue;
+    } 	D3D12_RENDER_PASS_BEGINNING_ACCESS_CLEAR_PARAMETERS;
+
+typedef struct D3D12_RENDER_PASS_BEGINNING_ACCESS
+    {
+    D3D12_RENDER_PASS_BEGINNING_ACCESS_TYPE Type;
+    union 
+        {
+        D3D12_RENDER_PASS_BEGINNING_ACCESS_CLEAR_PARAMETERS Clear;
+        } 	;
+    } 	D3D12_RENDER_PASS_BEGINNING_ACCESS;
+
+typedef 
+enum D3D12_RENDER_PASS_ENDING_ACCESS_TYPE
+    {
+        D3D12_RENDER_PASS_ENDING_ACCESS_TYPE_DISCARD	= 0,
+        D3D12_RENDER_PASS_ENDING_ACCESS_TYPE_PRESERVE	= ( D3D12_RENDER_PASS_ENDING_ACCESS_TYPE_DISCARD + 1 ) ,
+        D3D12_RENDER_PASS_ENDING_ACCESS_TYPE_RESOLVE	= ( D3D12_RENDER_PASS_ENDING_ACCESS_TYPE_PRESERVE + 1 ) ,
+        D3D12_RENDER_PASS_ENDING_ACCESS_TYPE_NO_ACCESS	= ( D3D12_RENDER_PASS_ENDING_ACCESS_TYPE_RESOLVE + 1 ) 
+    } 	D3D12_RENDER_PASS_ENDING_ACCESS_TYPE;
+
+typedef struct D3D12_RENDER_PASS_ENDING_ACCESS_RESOLVE_SUBRESOURCE_PARAMETERS
+    {
+    UINT SrcSubresource;
+    UINT DstSubresource;
+    UINT DstX;
+    UINT DstY;
+    D3D12_RECT SrcRect;
+    } 	D3D12_RENDER_PASS_ENDING_ACCESS_RESOLVE_SUBRESOURCE_PARAMETERS;
+
+typedef struct D3D12_RENDER_PASS_ENDING_ACCESS_RESOLVE_PARAMETERS
+    {
+    ID3D12Resource *pSrcResource;
+    ID3D12Resource *pDstResource;
+    UINT SubresourceCount;
+    _Field_size_full_(SubresourceCount)  const D3D12_RENDER_PASS_ENDING_ACCESS_RESOLVE_SUBRESOURCE_PARAMETERS *pSubresourceParameters;
+    DXGI_FORMAT Format;
+    D3D12_RESOLVE_MODE ResolveMode;
+    BOOL PreserveResolveSource;
+    } 	D3D12_RENDER_PASS_ENDING_ACCESS_RESOLVE_PARAMETERS;
+
+typedef struct D3D12_RENDER_PASS_ENDING_ACCESS
+    {
+    D3D12_RENDER_PASS_ENDING_ACCESS_TYPE Type;
+    union 
+        {
+        D3D12_RENDER_PASS_ENDING_ACCESS_RESOLVE_PARAMETERS Resolve;
+        } 	;
+    } 	D3D12_RENDER_PASS_ENDING_ACCESS;
+
+typedef struct D3D12_RENDER_PASS_RENDER_TARGET_DESC
+    {
+    D3D12_CPU_DESCRIPTOR_HANDLE cpuDescriptor;
+    D3D12_RENDER_PASS_BEGINNING_ACCESS BeginningAccess;
+    D3D12_RENDER_PASS_ENDING_ACCESS EndingAccess;
+    } 	D3D12_RENDER_PASS_RENDER_TARGET_DESC;
+
+typedef struct D3D12_RENDER_PASS_DEPTH_STENCIL_DESC
+    {
+    D3D12_CPU_DESCRIPTOR_HANDLE cpuDescriptor;
+    D3D12_RENDER_PASS_BEGINNING_ACCESS DepthBeginningAccess;
+    D3D12_RENDER_PASS_BEGINNING_ACCESS StencilBeginningAccess;
+    D3D12_RENDER_PASS_ENDING_ACCESS DepthEndingAccess;
+    D3D12_RENDER_PASS_ENDING_ACCESS StencilEndingAccess;
+    } 	D3D12_RENDER_PASS_DEPTH_STENCIL_DESC;
+
+typedef 
+enum D3D12_RENDER_PASS_FLAGS
+    {
+        D3D12_RENDER_PASS_FLAG_NONE	= 0,
+        D3D12_RENDER_PASS_FLAG_ALLOW_UAV_WRITES	= 0x1,
+        D3D12_RENDER_PASS_FLAG_SUSPENDING_PASS	= 0x2,
+        D3D12_RENDER_PASS_FLAG_RESUMING_PASS	= 0x4
+    } 	D3D12_RENDER_PASS_FLAGS;
+
+DEFINE_ENUM_FLAG_OPERATORS( D3D12_RENDER_PASS_FLAGS );
+
+
+extern RPC_IF_HANDLE __MIDL_itf_d3d12_0000_0049_v0_0_c_ifspec;
+extern RPC_IF_HANDLE __MIDL_itf_d3d12_0000_0049_v0_0_s_ifspec;
+
+#ifndef __ID3D12MetaCommand_INTERFACE_DEFINED__
+#define __ID3D12MetaCommand_INTERFACE_DEFINED__
+
+/* interface ID3D12MetaCommand */
+/* [unique][local][object][uuid] */ 
+
+
+EXTERN_C const IID IID_ID3D12MetaCommand;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("DBB84C27-36CE-4FC9-B801-F048C46AC570")
+    ID3D12MetaCommand : public ID3D12Pageable
+    {
+    public:
+        virtual UINT64 STDMETHODCALLTYPE GetRequiredParameterResourceSize( 
+            _In_  D3D12_META_COMMAND_PARAMETER_STAGE Stage,
+            _In_  UINT ParameterIndex) = 0;
+        
+    };
+    
+    
+#else 	/* C style interface */
+
+    typedef struct ID3D12MetaCommandVtbl
+    {
+        BEGIN_INTERFACE
+        
+        DECLSPEC_XFGVIRT(IUnknown, QueryInterface)
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            ID3D12MetaCommand * This,
+            REFIID riid,
+            _COM_Outptr_  void **ppvObject);
+        
+        DECLSPEC_XFGVIRT(IUnknown, AddRef)
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            ID3D12MetaCommand * This);
+        
+        DECLSPEC_XFGVIRT(IUnknown, Release)
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            ID3D12MetaCommand * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, GetPrivateData)
+        HRESULT ( STDMETHODCALLTYPE *GetPrivateData )( 
+            ID3D12MetaCommand * This,
+            _In_  REFGUID guid,
+            _Inout_  UINT *pDataSize,
+            _Out_writes_bytes_opt_( *pDataSize )  void *pData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, SetPrivateData)
+        HRESULT ( STDMETHODCALLTYPE *SetPrivateData )( 
+            ID3D12MetaCommand * This,
+            _In_  REFGUID guid,
+            _In_  UINT DataSize,
+            _In_reads_bytes_opt_( DataSize )  const void *pData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, SetPrivateDataInterface)
+        HRESULT ( STDMETHODCALLTYPE *SetPrivateDataInterface )( 
+            ID3D12MetaCommand * This,
+            _In_  REFGUID guid,
+            _In_opt_  const IUnknown *pData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, SetName)
+        HRESULT ( STDMETHODCALLTYPE *SetName )( 
+            ID3D12MetaCommand * This,
+            _In_z_  LPCWSTR Name);
+        
+        DECLSPEC_XFGVIRT(ID3D12DeviceChild, GetDevice)
+        HRESULT ( STDMETHODCALLTYPE *GetDevice )( 
+            ID3D12MetaCommand * This,
+            REFIID riid,
+            _COM_Outptr_opt_  void **ppvDevice);
+        
+        DECLSPEC_XFGVIRT(ID3D12MetaCommand, GetRequiredParameterResourceSize)
+        UINT64 ( STDMETHODCALLTYPE *GetRequiredParameterResourceSize )( 
+            ID3D12MetaCommand * This,
+            _In_  D3D12_META_COMMAND_PARAMETER_STAGE Stage,
+            _In_  UINT ParameterIndex);
+        
+        END_INTERFACE
+    } ID3D12MetaCommandVtbl;
+
+    interface ID3D12MetaCommand
+    {
+        CONST_VTBL struct ID3D12MetaCommandVtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define ID3D12MetaCommand_QueryInterface(This,riid,ppvObject)	\
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define ID3D12MetaCommand_AddRef(This)	\
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define ID3D12MetaCommand_Release(This)	\
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#define ID3D12MetaCommand_GetPrivateData(This,guid,pDataSize,pData)	\
+    ( (This)->lpVtbl -> GetPrivateData(This,guid,pDataSize,pData) ) 
+
+#define ID3D12MetaCommand_SetPrivateData(This,guid,DataSize,pData)	\
+    ( (This)->lpVtbl -> SetPrivateData(This,guid,DataSize,pData) ) 
+
+#define ID3D12MetaCommand_SetPrivateDataInterface(This,guid,pData)	\
+    ( (This)->lpVtbl -> SetPrivateDataInterface(This,guid,pData) ) 
+
+#define ID3D12MetaCommand_SetName(This,Name)	\
+    ( (This)->lpVtbl -> SetName(This,Name) ) 
+
+
+#define ID3D12MetaCommand_GetDevice(This,riid,ppvDevice)	\
+    ( (This)->lpVtbl -> GetDevice(This,riid,ppvDevice) ) 
+
+
+
+#define ID3D12MetaCommand_GetRequiredParameterResourceSize(This,Stage,ParameterIndex)	\
+    ( (This)->lpVtbl -> GetRequiredParameterResourceSize(This,Stage,ParameterIndex) ) 
+
+#endif /* COBJMACROS */
+
+
+#endif 	/* C style interface */
+
+
+
+
+#endif 	/* __ID3D12MetaCommand_INTERFACE_DEFINED__ */
+
+
+/* interface __MIDL_itf_d3d12_0000_0050 */
+/* [local] */ 
+
+typedef struct D3D12_DISPATCH_RAYS_DESC
+    {
+    D3D12_GPU_VIRTUAL_ADDRESS_RANGE RayGenerationShaderRecord;
+    D3D12_GPU_VIRTUAL_ADDRESS_RANGE_AND_STRIDE MissShaderTable;
+    D3D12_GPU_VIRTUAL_ADDRESS_RANGE_AND_STRIDE HitGroupTable;
+    D3D12_GPU_VIRTUAL_ADDRESS_RANGE_AND_STRIDE CallableShaderTable;
+    UINT Width;
+    UINT Height;
+    UINT Depth;
+    } 	D3D12_DISPATCH_RAYS_DESC;
+
+
+
+extern RPC_IF_HANDLE __MIDL_itf_d3d12_0000_0050_v0_0_c_ifspec;
+extern RPC_IF_HANDLE __MIDL_itf_d3d12_0000_0050_v0_0_s_ifspec;
+
+#ifndef __ID3D12GraphicsCommandList4_INTERFACE_DEFINED__
+#define __ID3D12GraphicsCommandList4_INTERFACE_DEFINED__
+
+/* interface ID3D12GraphicsCommandList4 */
+/* [unique][local][object][uuid] */ 
+
+
+EXTERN_C const IID IID_ID3D12GraphicsCommandList4;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("8754318e-d3a9-4541-98cf-645b50dc4874")
+    ID3D12GraphicsCommandList4 : public ID3D12GraphicsCommandList3
+    {
+    public:
+        virtual void STDMETHODCALLTYPE BeginRenderPass( 
+            _In_  UINT NumRenderTargets,
+            _In_reads_opt_(NumRenderTargets)  const D3D12_RENDER_PASS_RENDER_TARGET_DESC *pRenderTargets,
+            _In_opt_  const D3D12_RENDER_PASS_DEPTH_STENCIL_DESC *pDepthStencil,
+            D3D12_RENDER_PASS_FLAGS Flags) = 0;
+        
+        virtual void STDMETHODCALLTYPE EndRenderPass( void) = 0;
+        
+        virtual void STDMETHODCALLTYPE InitializeMetaCommand( 
+            _In_  ID3D12MetaCommand *pMetaCommand,
+            _In_reads_bytes_opt_(InitializationParametersDataSizeInBytes)  const void *pInitializationParametersData,
+            _In_  SIZE_T InitializationParametersDataSizeInBytes) = 0;
+        
+        virtual void STDMETHODCALLTYPE ExecuteMetaCommand( 
+            _In_  ID3D12MetaCommand *pMetaCommand,
+            _In_reads_bytes_opt_(ExecutionParametersDataSizeInBytes)  const void *pExecutionParametersData,
+            _In_  SIZE_T ExecutionParametersDataSizeInBytes) = 0;
+        
+        virtual void STDMETHODCALLTYPE BuildRaytracingAccelerationStructure( 
+            _In_  const D3D12_BUILD_RAYTRACING_ACCELERATION_STRUCTURE_DESC *pDesc,
+            _In_  UINT NumPostbuildInfoDescs,
+            _In_reads_opt_(NumPostbuildInfoDescs)  const D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_DESC *pPostbuildInfoDescs) = 0;
+        
+        virtual void STDMETHODCALLTYPE EmitRaytracingAccelerationStructurePostbuildInfo( 
+            _In_  const D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_DESC *pDesc,
+            _In_  UINT NumSourceAccelerationStructures,
+            _In_reads_( NumSourceAccelerationStructures )  const D3D12_GPU_VIRTUAL_ADDRESS *pSourceAccelerationStructureData) = 0;
+        
+        virtual void STDMETHODCALLTYPE CopyRaytracingAccelerationStructure( 
+            _In_  D3D12_GPU_VIRTUAL_ADDRESS DestAccelerationStructureData,
+            _In_  D3D12_GPU_VIRTUAL_ADDRESS SourceAccelerationStructureData,
+            _In_  D3D12_RAYTRACING_ACCELERATION_STRUCTURE_COPY_MODE Mode) = 0;
+        
+        virtual void STDMETHODCALLTYPE SetPipelineState1( 
+            _In_  ID3D12StateObject *pStateObject) = 0;
+        
+        virtual void STDMETHODCALLTYPE DispatchRays( 
+            _In_  const D3D12_DISPATCH_RAYS_DESC *pDesc) = 0;
+        
+    };
+    
+    
+#else 	/* C style interface */
+
+    typedef struct ID3D12GraphicsCommandList4Vtbl
+    {
+        BEGIN_INTERFACE
+        
+        DECLSPEC_XFGVIRT(IUnknown, QueryInterface)
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            ID3D12GraphicsCommandList4 * This,
+            REFIID riid,
+            _COM_Outptr_  void **ppvObject);
+        
+        DECLSPEC_XFGVIRT(IUnknown, AddRef)
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            ID3D12GraphicsCommandList4 * This);
+        
+        DECLSPEC_XFGVIRT(IUnknown, Release)
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            ID3D12GraphicsCommandList4 * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, GetPrivateData)
+        HRESULT ( STDMETHODCALLTYPE *GetPrivateData )( 
+            ID3D12GraphicsCommandList4 * This,
+            _In_  REFGUID guid,
+            _Inout_  UINT *pDataSize,
+            _Out_writes_bytes_opt_( *pDataSize )  void *pData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, SetPrivateData)
+        HRESULT ( STDMETHODCALLTYPE *SetPrivateData )( 
+            ID3D12GraphicsCommandList4 * This,
+            _In_  REFGUID guid,
+            _In_  UINT DataSize,
+            _In_reads_bytes_opt_( DataSize )  const void *pData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, SetPrivateDataInterface)
+        HRESULT ( STDMETHODCALLTYPE *SetPrivateDataInterface )( 
+            ID3D12GraphicsCommandList4 * This,
+            _In_  REFGUID guid,
+            _In_opt_  const IUnknown *pData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, SetName)
+        HRESULT ( STDMETHODCALLTYPE *SetName )( 
+            ID3D12GraphicsCommandList4 * This,
+            _In_z_  LPCWSTR Name);
+        
+        DECLSPEC_XFGVIRT(ID3D12DeviceChild, GetDevice)
+        HRESULT ( STDMETHODCALLTYPE *GetDevice )( 
+            ID3D12GraphicsCommandList4 * This,
+            REFIID riid,
+            _COM_Outptr_opt_  void **ppvDevice);
+        
+        DECLSPEC_XFGVIRT(ID3D12CommandList, GetType)
+        D3D12_COMMAND_LIST_TYPE ( STDMETHODCALLTYPE *GetType )( 
+            ID3D12GraphicsCommandList4 * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, Close)
+        HRESULT ( STDMETHODCALLTYPE *Close )( 
+            ID3D12GraphicsCommandList4 * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, Reset)
+        HRESULT ( STDMETHODCALLTYPE *Reset )( 
+            ID3D12GraphicsCommandList4 * This,
+            _In_  ID3D12CommandAllocator *pAllocator,
+            _In_opt_  ID3D12PipelineState *pInitialState);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, ClearState)
+        void ( STDMETHODCALLTYPE *ClearState )( 
+            ID3D12GraphicsCommandList4 * This,
+            _In_opt_  ID3D12PipelineState *pPipelineState);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, DrawInstanced)
+        void ( STDMETHODCALLTYPE *DrawInstanced )( 
+            ID3D12GraphicsCommandList4 * This,
+            _In_  UINT VertexCountPerInstance,
+            _In_  UINT InstanceCount,
+            _In_  UINT StartVertexLocation,
+            _In_  UINT StartInstanceLocation);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, DrawIndexedInstanced)
+        void ( STDMETHODCALLTYPE *DrawIndexedInstanced )( 
+            ID3D12GraphicsCommandList4 * This,
+            _In_  UINT IndexCountPerInstance,
+            _In_  UINT InstanceCount,
+            _In_  UINT StartIndexLocation,
+            _In_  INT BaseVertexLocation,
+            _In_  UINT StartInstanceLocation);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, Dispatch)
+        void ( STDMETHODCALLTYPE *Dispatch )( 
+            ID3D12GraphicsCommandList4 * This,
+            _In_  UINT ThreadGroupCountX,
+            _In_  UINT ThreadGroupCountY,
+            _In_  UINT ThreadGroupCountZ);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, CopyBufferRegion)
+        void ( STDMETHODCALLTYPE *CopyBufferRegion )( 
+            ID3D12GraphicsCommandList4 * This,
+            _In_  ID3D12Resource *pDstBuffer,
+            UINT64 DstOffset,
+            _In_  ID3D12Resource *pSrcBuffer,
+            UINT64 SrcOffset,
+            UINT64 NumBytes);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, CopyTextureRegion)
+        void ( STDMETHODCALLTYPE *CopyTextureRegion )( 
+            ID3D12GraphicsCommandList4 * This,
+            _In_  const D3D12_TEXTURE_COPY_LOCATION *pDst,
+            UINT DstX,
+            UINT DstY,
+            UINT DstZ,
+            _In_  const D3D12_TEXTURE_COPY_LOCATION *pSrc,
+            _In_opt_  const D3D12_BOX *pSrcBox);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, CopyResource)
+        void ( STDMETHODCALLTYPE *CopyResource )( 
+            ID3D12GraphicsCommandList4 * This,
+            _In_  ID3D12Resource *pDstResource,
+            _In_  ID3D12Resource *pSrcResource);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, CopyTiles)
+        void ( STDMETHODCALLTYPE *CopyTiles )( 
+            ID3D12GraphicsCommandList4 * This,
+            _In_  ID3D12Resource *pTiledResource,
+            _In_  const D3D12_TILED_RESOURCE_COORDINATE *pTileRegionStartCoordinate,
+            _In_  const D3D12_TILE_REGION_SIZE *pTileRegionSize,
+            _In_  ID3D12Resource *pBuffer,
+            UINT64 BufferStartOffsetInBytes,
+            D3D12_TILE_COPY_FLAGS Flags);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, ResolveSubresource)
+        void ( STDMETHODCALLTYPE *ResolveSubresource )( 
+            ID3D12GraphicsCommandList4 * This,
+            _In_  ID3D12Resource *pDstResource,
+            _In_  UINT DstSubresource,
+            _In_  ID3D12Resource *pSrcResource,
+            _In_  UINT SrcSubresource,
+            _In_  DXGI_FORMAT Format);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, IASetPrimitiveTopology)
+        void ( STDMETHODCALLTYPE *IASetPrimitiveTopology )( 
+            ID3D12GraphicsCommandList4 * This,
+            _In_  D3D12_PRIMITIVE_TOPOLOGY PrimitiveTopology);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, RSSetViewports)
+        void ( STDMETHODCALLTYPE *RSSetViewports )( 
+            ID3D12GraphicsCommandList4 * This,
+            _In_range_(0, D3D12_VIEWPORT_AND_SCISSORRECT_OBJECT_COUNT_PER_PIPELINE)  UINT NumViewports,
+            _In_reads_( NumViewports)  const D3D12_VIEWPORT *pViewports);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, RSSetScissorRects)
+        void ( STDMETHODCALLTYPE *RSSetScissorRects )( 
+            ID3D12GraphicsCommandList4 * This,
+            _In_range_(0, D3D12_VIEWPORT_AND_SCISSORRECT_OBJECT_COUNT_PER_PIPELINE)  UINT NumRects,
+            _In_reads_( NumRects)  const D3D12_RECT *pRects);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, OMSetBlendFactor)
+        void ( STDMETHODCALLTYPE *OMSetBlendFactor )( 
+            ID3D12GraphicsCommandList4 * This,
+            _In_reads_opt_(4)  const FLOAT BlendFactor[ 4 ]);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, OMSetStencilRef)
+        void ( STDMETHODCALLTYPE *OMSetStencilRef )( 
+            ID3D12GraphicsCommandList4 * This,
+            _In_  UINT StencilRef);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetPipelineState)
+        void ( STDMETHODCALLTYPE *SetPipelineState )( 
+            ID3D12GraphicsCommandList4 * This,
+            _In_  ID3D12PipelineState *pPipelineState);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, ResourceBarrier)
+        void ( STDMETHODCALLTYPE *ResourceBarrier )( 
+            ID3D12GraphicsCommandList4 * This,
+            _In_  UINT NumBarriers,
+            _In_reads_(NumBarriers)  const D3D12_RESOURCE_BARRIER *pBarriers);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, ExecuteBundle)
+        void ( STDMETHODCALLTYPE *ExecuteBundle )( 
+            ID3D12GraphicsCommandList4 * This,
+            _In_  ID3D12GraphicsCommandList *pCommandList);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetDescriptorHeaps)
+        void ( STDMETHODCALLTYPE *SetDescriptorHeaps )( 
+            ID3D12GraphicsCommandList4 * This,
+            _In_  UINT NumDescriptorHeaps,
+            _In_reads_(NumDescriptorHeaps)  ID3D12DescriptorHeap *const *ppDescriptorHeaps);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetComputeRootSignature)
+        void ( STDMETHODCALLTYPE *SetComputeRootSignature )( 
+            ID3D12GraphicsCommandList4 * This,
+            _In_opt_  ID3D12RootSignature *pRootSignature);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetGraphicsRootSignature)
+        void ( STDMETHODCALLTYPE *SetGraphicsRootSignature )( 
+            ID3D12GraphicsCommandList4 * This,
+            _In_opt_  ID3D12RootSignature *pRootSignature);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetComputeRootDescriptorTable)
+        void ( STDMETHODCALLTYPE *SetComputeRootDescriptorTable )( 
+            ID3D12GraphicsCommandList4 * This,
+            _In_  UINT RootParameterIndex,
+            _In_  D3D12_GPU_DESCRIPTOR_HANDLE BaseDescriptor);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetGraphicsRootDescriptorTable)
+        void ( STDMETHODCALLTYPE *SetGraphicsRootDescriptorTable )( 
+            ID3D12GraphicsCommandList4 * This,
+            _In_  UINT RootParameterIndex,
+            _In_  D3D12_GPU_DESCRIPTOR_HANDLE BaseDescriptor);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetComputeRoot32BitConstant)
+        void ( STDMETHODCALLTYPE *SetComputeRoot32BitConstant )( 
+            ID3D12GraphicsCommandList4 * This,
+            _In_  UINT RootParameterIndex,
+            _In_  UINT SrcData,
+            _In_  UINT DestOffsetIn32BitValues);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetGraphicsRoot32BitConstant)
+        void ( STDMETHODCALLTYPE *SetGraphicsRoot32BitConstant )( 
+            ID3D12GraphicsCommandList4 * This,
+            _In_  UINT RootParameterIndex,
+            _In_  UINT SrcData,
+            _In_  UINT DestOffsetIn32BitValues);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetComputeRoot32BitConstants)
+        void ( STDMETHODCALLTYPE *SetComputeRoot32BitConstants )( 
+            ID3D12GraphicsCommandList4 * This,
+            _In_  UINT RootParameterIndex,
+            _In_  UINT Num32BitValuesToSet,
+            _In_reads_(Num32BitValuesToSet*sizeof(UINT))  const void *pSrcData,
+            _In_  UINT DestOffsetIn32BitValues);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetGraphicsRoot32BitConstants)
+        void ( STDMETHODCALLTYPE *SetGraphicsRoot32BitConstants )( 
+            ID3D12GraphicsCommandList4 * This,
+            _In_  UINT RootParameterIndex,
+            _In_  UINT Num32BitValuesToSet,
+            _In_reads_(Num32BitValuesToSet*sizeof(UINT))  const void *pSrcData,
+            _In_  UINT DestOffsetIn32BitValues);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetComputeRootConstantBufferView)
+        void ( STDMETHODCALLTYPE *SetComputeRootConstantBufferView )( 
+            ID3D12GraphicsCommandList4 * This,
+            _In_  UINT RootParameterIndex,
+            _In_  D3D12_GPU_VIRTUAL_ADDRESS BufferLocation);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetGraphicsRootConstantBufferView)
+        void ( STDMETHODCALLTYPE *SetGraphicsRootConstantBufferView )( 
+            ID3D12GraphicsCommandList4 * This,
+            _In_  UINT RootParameterIndex,
+            _In_  D3D12_GPU_VIRTUAL_ADDRESS BufferLocation);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetComputeRootShaderResourceView)
+        void ( STDMETHODCALLTYPE *SetComputeRootShaderResourceView )( 
+            ID3D12GraphicsCommandList4 * This,
+            _In_  UINT RootParameterIndex,
+            _In_  D3D12_GPU_VIRTUAL_ADDRESS BufferLocation);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetGraphicsRootShaderResourceView)
+        void ( STDMETHODCALLTYPE *SetGraphicsRootShaderResourceView )( 
+            ID3D12GraphicsCommandList4 * This,
+            _In_  UINT RootParameterIndex,
+            _In_  D3D12_GPU_VIRTUAL_ADDRESS BufferLocation);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetComputeRootUnorderedAccessView)
+        void ( STDMETHODCALLTYPE *SetComputeRootUnorderedAccessView )( 
+            ID3D12GraphicsCommandList4 * This,
+            _In_  UINT RootParameterIndex,
+            _In_  D3D12_GPU_VIRTUAL_ADDRESS BufferLocation);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetGraphicsRootUnorderedAccessView)
+        void ( STDMETHODCALLTYPE *SetGraphicsRootUnorderedAccessView )( 
+            ID3D12GraphicsCommandList4 * This,
+            _In_  UINT RootParameterIndex,
+            _In_  D3D12_GPU_VIRTUAL_ADDRESS BufferLocation);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, IASetIndexBuffer)
+        void ( STDMETHODCALLTYPE *IASetIndexBuffer )( 
+            ID3D12GraphicsCommandList4 * This,
+            _In_opt_  const D3D12_INDEX_BUFFER_VIEW *pView);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, IASetVertexBuffers)
+        void ( STDMETHODCALLTYPE *IASetVertexBuffers )( 
+            ID3D12GraphicsCommandList4 * This,
+            _In_  UINT StartSlot,
+            _In_  UINT NumViews,
+            _In_reads_opt_(NumViews)  const D3D12_VERTEX_BUFFER_VIEW *pViews);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SOSetTargets)
+        void ( STDMETHODCALLTYPE *SOSetTargets )( 
+            ID3D12GraphicsCommandList4 * This,
+            _In_  UINT StartSlot,
+            _In_  UINT NumViews,
+            _In_reads_opt_(NumViews)  const D3D12_STREAM_OUTPUT_BUFFER_VIEW *pViews);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, OMSetRenderTargets)
+        void ( STDMETHODCALLTYPE *OMSetRenderTargets )( 
+            ID3D12GraphicsCommandList4 * This,
+            _In_  UINT NumRenderTargetDescriptors,
+            _In_opt_  const D3D12_CPU_DESCRIPTOR_HANDLE *pRenderTargetDescriptors,
+            _In_  BOOL RTsSingleHandleToDescriptorRange,
+            _In_opt_  const D3D12_CPU_DESCRIPTOR_HANDLE *pDepthStencilDescriptor);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, ClearDepthStencilView)
+        void ( STDMETHODCALLTYPE *ClearDepthStencilView )( 
+            ID3D12GraphicsCommandList4 * This,
+            _In_  D3D12_CPU_DESCRIPTOR_HANDLE DepthStencilView,
+            _In_  D3D12_CLEAR_FLAGS ClearFlags,
+            _In_  FLOAT Depth,
+            _In_  UINT8 Stencil,
+            _In_  UINT NumRects,
+            _In_reads_(NumRects)  const D3D12_RECT *pRects);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, ClearRenderTargetView)
+        void ( STDMETHODCALLTYPE *ClearRenderTargetView )( 
+            ID3D12GraphicsCommandList4 * This,
+            _In_  D3D12_CPU_DESCRIPTOR_HANDLE RenderTargetView,
+            _In_  const FLOAT ColorRGBA[ 4 ],
+            _In_  UINT NumRects,
+            _In_reads_(NumRects)  const D3D12_RECT *pRects);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, ClearUnorderedAccessViewUint)
+        void ( STDMETHODCALLTYPE *ClearUnorderedAccessViewUint )( 
+            ID3D12GraphicsCommandList4 * This,
+            _In_  D3D12_GPU_DESCRIPTOR_HANDLE ViewGPUHandleInCurrentHeap,
+            _In_  D3D12_CPU_DESCRIPTOR_HANDLE ViewCPUHandle,
+            _In_  ID3D12Resource *pResource,
+            _In_  const UINT Values[ 4 ],
+            _In_  UINT NumRects,
+            _In_reads_(NumRects)  const D3D12_RECT *pRects);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, ClearUnorderedAccessViewFloat)
+        void ( STDMETHODCALLTYPE *ClearUnorderedAccessViewFloat )( 
+            ID3D12GraphicsCommandList4 * This,
+            _In_  D3D12_GPU_DESCRIPTOR_HANDLE ViewGPUHandleInCurrentHeap,
+            _In_  D3D12_CPU_DESCRIPTOR_HANDLE ViewCPUHandle,
+            _In_  ID3D12Resource *pResource,
+            _In_  const FLOAT Values[ 4 ],
+            _In_  UINT NumRects,
+            _In_reads_(NumRects)  const D3D12_RECT *pRects);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, DiscardResource)
+        void ( STDMETHODCALLTYPE *DiscardResource )( 
+            ID3D12GraphicsCommandList4 * This,
+            _In_  ID3D12Resource *pResource,
+            _In_opt_  const D3D12_DISCARD_REGION *pRegion);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, BeginQuery)
+        void ( STDMETHODCALLTYPE *BeginQuery )( 
+            ID3D12GraphicsCommandList4 * This,
+            _In_  ID3D12QueryHeap *pQueryHeap,
+            _In_  D3D12_QUERY_TYPE Type,
+            _In_  UINT Index);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, EndQuery)
+        void ( STDMETHODCALLTYPE *EndQuery )( 
+            ID3D12GraphicsCommandList4 * This,
+            _In_  ID3D12QueryHeap *pQueryHeap,
+            _In_  D3D12_QUERY_TYPE Type,
+            _In_  UINT Index);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, ResolveQueryData)
+        void ( STDMETHODCALLTYPE *ResolveQueryData )( 
+            ID3D12GraphicsCommandList4 * This,
+            _In_  ID3D12QueryHeap *pQueryHeap,
+            _In_  D3D12_QUERY_TYPE Type,
+            _In_  UINT StartIndex,
+            _In_  UINT NumQueries,
+            _In_  ID3D12Resource *pDestinationBuffer,
+            _In_  UINT64 AlignedDestinationBufferOffset);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetPredication)
+        void ( STDMETHODCALLTYPE *SetPredication )( 
+            ID3D12GraphicsCommandList4 * This,
+            _In_opt_  ID3D12Resource *pBuffer,
+            _In_  UINT64 AlignedBufferOffset,
+            _In_  D3D12_PREDICATION_OP Operation);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetMarker)
+        void ( STDMETHODCALLTYPE *SetMarker )( 
+            ID3D12GraphicsCommandList4 * This,
+            UINT Metadata,
+            _In_reads_bytes_opt_(Size)  const void *pData,
+            UINT Size);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, BeginEvent)
+        void ( STDMETHODCALLTYPE *BeginEvent )( 
+            ID3D12GraphicsCommandList4 * This,
+            UINT Metadata,
+            _In_reads_bytes_opt_(Size)  const void *pData,
+            UINT Size);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, EndEvent)
+        void ( STDMETHODCALLTYPE *EndEvent )( 
+            ID3D12GraphicsCommandList4 * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, ExecuteIndirect)
+        void ( STDMETHODCALLTYPE *ExecuteIndirect )( 
+            ID3D12GraphicsCommandList4 * This,
+            _In_  ID3D12CommandSignature *pCommandSignature,
+            _In_  UINT MaxCommandCount,
+            _In_  ID3D12Resource *pArgumentBuffer,
+            _In_  UINT64 ArgumentBufferOffset,
+            _In_opt_  ID3D12Resource *pCountBuffer,
+            _In_  UINT64 CountBufferOffset);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList1, AtomicCopyBufferUINT)
+        void ( STDMETHODCALLTYPE *AtomicCopyBufferUINT )( 
+            ID3D12GraphicsCommandList4 * This,
+            _In_  ID3D12Resource *pDstBuffer,
+            UINT64 DstOffset,
+            _In_  ID3D12Resource *pSrcBuffer,
+            UINT64 SrcOffset,
+            UINT Dependencies,
+            _In_reads_(Dependencies)  ID3D12Resource *const *ppDependentResources,
+            _In_reads_(Dependencies)  const D3D12_SUBRESOURCE_RANGE_UINT64 *pDependentSubresourceRanges);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList1, AtomicCopyBufferUINT64)
+        void ( STDMETHODCALLTYPE *AtomicCopyBufferUINT64 )( 
+            ID3D12GraphicsCommandList4 * This,
+            _In_  ID3D12Resource *pDstBuffer,
+            UINT64 DstOffset,
+            _In_  ID3D12Resource *pSrcBuffer,
+            UINT64 SrcOffset,
+            UINT Dependencies,
+            _In_reads_(Dependencies)  ID3D12Resource *const *ppDependentResources,
+            _In_reads_(Dependencies)  const D3D12_SUBRESOURCE_RANGE_UINT64 *pDependentSubresourceRanges);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList1, OMSetDepthBounds)
+        void ( STDMETHODCALLTYPE *OMSetDepthBounds )( 
+            ID3D12GraphicsCommandList4 * This,
+            _In_  FLOAT Min,
+            _In_  FLOAT Max);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList1, SetSamplePositions)
+        void ( STDMETHODCALLTYPE *SetSamplePositions )( 
+            ID3D12GraphicsCommandList4 * This,
+            _In_  UINT NumSamplesPerPixel,
+            _In_  UINT NumPixels,
+            _In_reads_(NumSamplesPerPixel*NumPixels)  D3D12_SAMPLE_POSITION *pSamplePositions);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList1, ResolveSubresourceRegion)
+        void ( STDMETHODCALLTYPE *ResolveSubresourceRegion )( 
+            ID3D12GraphicsCommandList4 * This,
+            _In_  ID3D12Resource *pDstResource,
+            _In_  UINT DstSubresource,
+            _In_  UINT DstX,
+            _In_  UINT DstY,
+            _In_  ID3D12Resource *pSrcResource,
+            _In_  UINT SrcSubresource,
+            _In_opt_  D3D12_RECT *pSrcRect,
+            _In_  DXGI_FORMAT Format,
+            _In_  D3D12_RESOLVE_MODE ResolveMode);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList1, SetViewInstanceMask)
+        void ( STDMETHODCALLTYPE *SetViewInstanceMask )( 
+            ID3D12GraphicsCommandList4 * This,
+            _In_  UINT Mask);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList2, WriteBufferImmediate)
+        void ( STDMETHODCALLTYPE *WriteBufferImmediate )( 
+            ID3D12GraphicsCommandList4 * This,
+            UINT Count,
+            _In_reads_(Count)  const D3D12_WRITEBUFFERIMMEDIATE_PARAMETER *pParams,
+            _In_reads_opt_(Count)  const D3D12_WRITEBUFFERIMMEDIATE_MODE *pModes);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList3, SetProtectedResourceSession)
+        void ( STDMETHODCALLTYPE *SetProtectedResourceSession )( 
+            ID3D12GraphicsCommandList4 * This,
+            _In_opt_  ID3D12ProtectedResourceSession *pProtectedResourceSession);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList4, BeginRenderPass)
+        void ( STDMETHODCALLTYPE *BeginRenderPass )( 
+            ID3D12GraphicsCommandList4 * This,
+            _In_  UINT NumRenderTargets,
+            _In_reads_opt_(NumRenderTargets)  const D3D12_RENDER_PASS_RENDER_TARGET_DESC *pRenderTargets,
+            _In_opt_  const D3D12_RENDER_PASS_DEPTH_STENCIL_DESC *pDepthStencil,
+            D3D12_RENDER_PASS_FLAGS Flags);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList4, EndRenderPass)
+        void ( STDMETHODCALLTYPE *EndRenderPass )( 
+            ID3D12GraphicsCommandList4 * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList4, InitializeMetaCommand)
+        void ( STDMETHODCALLTYPE *InitializeMetaCommand )( 
+            ID3D12GraphicsCommandList4 * This,
+            _In_  ID3D12MetaCommand *pMetaCommand,
+            _In_reads_bytes_opt_(InitializationParametersDataSizeInBytes)  const void *pInitializationParametersData,
+            _In_  SIZE_T InitializationParametersDataSizeInBytes);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList4, ExecuteMetaCommand)
+        void ( STDMETHODCALLTYPE *ExecuteMetaCommand )( 
+            ID3D12GraphicsCommandList4 * This,
+            _In_  ID3D12MetaCommand *pMetaCommand,
+            _In_reads_bytes_opt_(ExecutionParametersDataSizeInBytes)  const void *pExecutionParametersData,
+            _In_  SIZE_T ExecutionParametersDataSizeInBytes);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList4, BuildRaytracingAccelerationStructure)
+        void ( STDMETHODCALLTYPE *BuildRaytracingAccelerationStructure )( 
+            ID3D12GraphicsCommandList4 * This,
+            _In_  const D3D12_BUILD_RAYTRACING_ACCELERATION_STRUCTURE_DESC *pDesc,
+            _In_  UINT NumPostbuildInfoDescs,
+            _In_reads_opt_(NumPostbuildInfoDescs)  const D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_DESC *pPostbuildInfoDescs);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList4, EmitRaytracingAccelerationStructurePostbuildInfo)
+        void ( STDMETHODCALLTYPE *EmitRaytracingAccelerationStructurePostbuildInfo )( 
+            ID3D12GraphicsCommandList4 * This,
+            _In_  const D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_DESC *pDesc,
+            _In_  UINT NumSourceAccelerationStructures,
+            _In_reads_( NumSourceAccelerationStructures )  const D3D12_GPU_VIRTUAL_ADDRESS *pSourceAccelerationStructureData);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList4, CopyRaytracingAccelerationStructure)
+        void ( STDMETHODCALLTYPE *CopyRaytracingAccelerationStructure )( 
+            ID3D12GraphicsCommandList4 * This,
+            _In_  D3D12_GPU_VIRTUAL_ADDRESS DestAccelerationStructureData,
+            _In_  D3D12_GPU_VIRTUAL_ADDRESS SourceAccelerationStructureData,
+            _In_  D3D12_RAYTRACING_ACCELERATION_STRUCTURE_COPY_MODE Mode);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList4, SetPipelineState1)
+        void ( STDMETHODCALLTYPE *SetPipelineState1 )( 
+            ID3D12GraphicsCommandList4 * This,
+            _In_  ID3D12StateObject *pStateObject);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList4, DispatchRays)
+        void ( STDMETHODCALLTYPE *DispatchRays )( 
+            ID3D12GraphicsCommandList4 * This,
+            _In_  const D3D12_DISPATCH_RAYS_DESC *pDesc);
+        
+        END_INTERFACE
+    } ID3D12GraphicsCommandList4Vtbl;
+
+    interface ID3D12GraphicsCommandList4
+    {
+        CONST_VTBL struct ID3D12GraphicsCommandList4Vtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define ID3D12GraphicsCommandList4_QueryInterface(This,riid,ppvObject)	\
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define ID3D12GraphicsCommandList4_AddRef(This)	\
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define ID3D12GraphicsCommandList4_Release(This)	\
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#define ID3D12GraphicsCommandList4_GetPrivateData(This,guid,pDataSize,pData)	\
+    ( (This)->lpVtbl -> GetPrivateData(This,guid,pDataSize,pData) ) 
+
+#define ID3D12GraphicsCommandList4_SetPrivateData(This,guid,DataSize,pData)	\
+    ( (This)->lpVtbl -> SetPrivateData(This,guid,DataSize,pData) ) 
+
+#define ID3D12GraphicsCommandList4_SetPrivateDataInterface(This,guid,pData)	\
+    ( (This)->lpVtbl -> SetPrivateDataInterface(This,guid,pData) ) 
+
+#define ID3D12GraphicsCommandList4_SetName(This,Name)	\
+    ( (This)->lpVtbl -> SetName(This,Name) ) 
+
+
+#define ID3D12GraphicsCommandList4_GetDevice(This,riid,ppvDevice)	\
+    ( (This)->lpVtbl -> GetDevice(This,riid,ppvDevice) ) 
+
+
+#define ID3D12GraphicsCommandList4_GetType(This)	\
+    ( (This)->lpVtbl -> GetType(This) ) 
+
+
+#define ID3D12GraphicsCommandList4_Close(This)	\
+    ( (This)->lpVtbl -> Close(This) ) 
+
+#define ID3D12GraphicsCommandList4_Reset(This,pAllocator,pInitialState)	\
+    ( (This)->lpVtbl -> Reset(This,pAllocator,pInitialState) ) 
+
+#define ID3D12GraphicsCommandList4_ClearState(This,pPipelineState)	\
+    ( (This)->lpVtbl -> ClearState(This,pPipelineState) ) 
+
+#define ID3D12GraphicsCommandList4_DrawInstanced(This,VertexCountPerInstance,InstanceCount,StartVertexLocation,StartInstanceLocation)	\
+    ( (This)->lpVtbl -> DrawInstanced(This,VertexCountPerInstance,InstanceCount,StartVertexLocation,StartInstanceLocation) ) 
+
+#define ID3D12GraphicsCommandList4_DrawIndexedInstanced(This,IndexCountPerInstance,InstanceCount,StartIndexLocation,BaseVertexLocation,StartInstanceLocation)	\
+    ( (This)->lpVtbl -> DrawIndexedInstanced(This,IndexCountPerInstance,InstanceCount,StartIndexLocation,BaseVertexLocation,StartInstanceLocation) ) 
+
+#define ID3D12GraphicsCommandList4_Dispatch(This,ThreadGroupCountX,ThreadGroupCountY,ThreadGroupCountZ)	\
+    ( (This)->lpVtbl -> Dispatch(This,ThreadGroupCountX,ThreadGroupCountY,ThreadGroupCountZ) ) 
+
+#define ID3D12GraphicsCommandList4_CopyBufferRegion(This,pDstBuffer,DstOffset,pSrcBuffer,SrcOffset,NumBytes)	\
+    ( (This)->lpVtbl -> CopyBufferRegion(This,pDstBuffer,DstOffset,pSrcBuffer,SrcOffset,NumBytes) ) 
+
+#define ID3D12GraphicsCommandList4_CopyTextureRegion(This,pDst,DstX,DstY,DstZ,pSrc,pSrcBox)	\
+    ( (This)->lpVtbl -> CopyTextureRegion(This,pDst,DstX,DstY,DstZ,pSrc,pSrcBox) ) 
+
+#define ID3D12GraphicsCommandList4_CopyResource(This,pDstResource,pSrcResource)	\
+    ( (This)->lpVtbl -> CopyResource(This,pDstResource,pSrcResource) ) 
+
+#define ID3D12GraphicsCommandList4_CopyTiles(This,pTiledResource,pTileRegionStartCoordinate,pTileRegionSize,pBuffer,BufferStartOffsetInBytes,Flags)	\
+    ( (This)->lpVtbl -> CopyTiles(This,pTiledResource,pTileRegionStartCoordinate,pTileRegionSize,pBuffer,BufferStartOffsetInBytes,Flags) ) 
+
+#define ID3D12GraphicsCommandList4_ResolveSubresource(This,pDstResource,DstSubresource,pSrcResource,SrcSubresource,Format)	\
+    ( (This)->lpVtbl -> ResolveSubresource(This,pDstResource,DstSubresource,pSrcResource,SrcSubresource,Format) ) 
+
+#define ID3D12GraphicsCommandList4_IASetPrimitiveTopology(This,PrimitiveTopology)	\
+    ( (This)->lpVtbl -> IASetPrimitiveTopology(This,PrimitiveTopology) ) 
+
+#define ID3D12GraphicsCommandList4_RSSetViewports(This,NumViewports,pViewports)	\
+    ( (This)->lpVtbl -> RSSetViewports(This,NumViewports,pViewports) ) 
+
+#define ID3D12GraphicsCommandList4_RSSetScissorRects(This,NumRects,pRects)	\
+    ( (This)->lpVtbl -> RSSetScissorRects(This,NumRects,pRects) ) 
+
+#define ID3D12GraphicsCommandList4_OMSetBlendFactor(This,BlendFactor)	\
+    ( (This)->lpVtbl -> OMSetBlendFactor(This,BlendFactor) ) 
+
+#define ID3D12GraphicsCommandList4_OMSetStencilRef(This,StencilRef)	\
+    ( (This)->lpVtbl -> OMSetStencilRef(This,StencilRef) ) 
+
+#define ID3D12GraphicsCommandList4_SetPipelineState(This,pPipelineState)	\
+    ( (This)->lpVtbl -> SetPipelineState(This,pPipelineState) ) 
+
+#define ID3D12GraphicsCommandList4_ResourceBarrier(This,NumBarriers,pBarriers)	\
+    ( (This)->lpVtbl -> ResourceBarrier(This,NumBarriers,pBarriers) ) 
+
+#define ID3D12GraphicsCommandList4_ExecuteBundle(This,pCommandList)	\
+    ( (This)->lpVtbl -> ExecuteBundle(This,pCommandList) ) 
+
+#define ID3D12GraphicsCommandList4_SetDescriptorHeaps(This,NumDescriptorHeaps,ppDescriptorHeaps)	\
+    ( (This)->lpVtbl -> SetDescriptorHeaps(This,NumDescriptorHeaps,ppDescriptorHeaps) ) 
+
+#define ID3D12GraphicsCommandList4_SetComputeRootSignature(This,pRootSignature)	\
+    ( (This)->lpVtbl -> SetComputeRootSignature(This,pRootSignature) ) 
+
+#define ID3D12GraphicsCommandList4_SetGraphicsRootSignature(This,pRootSignature)	\
+    ( (This)->lpVtbl -> SetGraphicsRootSignature(This,pRootSignature) ) 
+
+#define ID3D12GraphicsCommandList4_SetComputeRootDescriptorTable(This,RootParameterIndex,BaseDescriptor)	\
+    ( (This)->lpVtbl -> SetComputeRootDescriptorTable(This,RootParameterIndex,BaseDescriptor) ) 
+
+#define ID3D12GraphicsCommandList4_SetGraphicsRootDescriptorTable(This,RootParameterIndex,BaseDescriptor)	\
+    ( (This)->lpVtbl -> SetGraphicsRootDescriptorTable(This,RootParameterIndex,BaseDescriptor) ) 
+
+#define ID3D12GraphicsCommandList4_SetComputeRoot32BitConstant(This,RootParameterIndex,SrcData,DestOffsetIn32BitValues)	\
+    ( (This)->lpVtbl -> SetComputeRoot32BitConstant(This,RootParameterIndex,SrcData,DestOffsetIn32BitValues) ) 
+
+#define ID3D12GraphicsCommandList4_SetGraphicsRoot32BitConstant(This,RootParameterIndex,SrcData,DestOffsetIn32BitValues)	\
+    ( (This)->lpVtbl -> SetGraphicsRoot32BitConstant(This,RootParameterIndex,SrcData,DestOffsetIn32BitValues) ) 
+
+#define ID3D12GraphicsCommandList4_SetComputeRoot32BitConstants(This,RootParameterIndex,Num32BitValuesToSet,pSrcData,DestOffsetIn32BitValues)	\
+    ( (This)->lpVtbl -> SetComputeRoot32BitConstants(This,RootParameterIndex,Num32BitValuesToSet,pSrcData,DestOffsetIn32BitValues) ) 
+
+#define ID3D12GraphicsCommandList4_SetGraphicsRoot32BitConstants(This,RootParameterIndex,Num32BitValuesToSet,pSrcData,DestOffsetIn32BitValues)	\
+    ( (This)->lpVtbl -> SetGraphicsRoot32BitConstants(This,RootParameterIndex,Num32BitValuesToSet,pSrcData,DestOffsetIn32BitValues) ) 
+
+#define ID3D12GraphicsCommandList4_SetComputeRootConstantBufferView(This,RootParameterIndex,BufferLocation)	\
+    ( (This)->lpVtbl -> SetComputeRootConstantBufferView(This,RootParameterIndex,BufferLocation) ) 
+
+#define ID3D12GraphicsCommandList4_SetGraphicsRootConstantBufferView(This,RootParameterIndex,BufferLocation)	\
+    ( (This)->lpVtbl -> SetGraphicsRootConstantBufferView(This,RootParameterIndex,BufferLocation) ) 
+
+#define ID3D12GraphicsCommandList4_SetComputeRootShaderResourceView(This,RootParameterIndex,BufferLocation)	\
+    ( (This)->lpVtbl -> SetComputeRootShaderResourceView(This,RootParameterIndex,BufferLocation) ) 
+
+#define ID3D12GraphicsCommandList4_SetGraphicsRootShaderResourceView(This,RootParameterIndex,BufferLocation)	\
+    ( (This)->lpVtbl -> SetGraphicsRootShaderResourceView(This,RootParameterIndex,BufferLocation) ) 
+
+#define ID3D12GraphicsCommandList4_SetComputeRootUnorderedAccessView(This,RootParameterIndex,BufferLocation)	\
+    ( (This)->lpVtbl -> SetComputeRootUnorderedAccessView(This,RootParameterIndex,BufferLocation) ) 
+
+#define ID3D12GraphicsCommandList4_SetGraphicsRootUnorderedAccessView(This,RootParameterIndex,BufferLocation)	\
+    ( (This)->lpVtbl -> SetGraphicsRootUnorderedAccessView(This,RootParameterIndex,BufferLocation) ) 
+
+#define ID3D12GraphicsCommandList4_IASetIndexBuffer(This,pView)	\
+    ( (This)->lpVtbl -> IASetIndexBuffer(This,pView) ) 
+
+#define ID3D12GraphicsCommandList4_IASetVertexBuffers(This,StartSlot,NumViews,pViews)	\
+    ( (This)->lpVtbl -> IASetVertexBuffers(This,StartSlot,NumViews,pViews) ) 
+
+#define ID3D12GraphicsCommandList4_SOSetTargets(This,StartSlot,NumViews,pViews)	\
+    ( (This)->lpVtbl -> SOSetTargets(This,StartSlot,NumViews,pViews) ) 
+
+#define ID3D12GraphicsCommandList4_OMSetRenderTargets(This,NumRenderTargetDescriptors,pRenderTargetDescriptors,RTsSingleHandleToDescriptorRange,pDepthStencilDescriptor)	\
+    ( (This)->lpVtbl -> OMSetRenderTargets(This,NumRenderTargetDescriptors,pRenderTargetDescriptors,RTsSingleHandleToDescriptorRange,pDepthStencilDescriptor) ) 
+
+#define ID3D12GraphicsCommandList4_ClearDepthStencilView(This,DepthStencilView,ClearFlags,Depth,Stencil,NumRects,pRects)	\
+    ( (This)->lpVtbl -> ClearDepthStencilView(This,DepthStencilView,ClearFlags,Depth,Stencil,NumRects,pRects) ) 
+
+#define ID3D12GraphicsCommandList4_ClearRenderTargetView(This,RenderTargetView,ColorRGBA,NumRects,pRects)	\
+    ( (This)->lpVtbl -> ClearRenderTargetView(This,RenderTargetView,ColorRGBA,NumRects,pRects) ) 
+
+#define ID3D12GraphicsCommandList4_ClearUnorderedAccessViewUint(This,ViewGPUHandleInCurrentHeap,ViewCPUHandle,pResource,Values,NumRects,pRects)	\
+    ( (This)->lpVtbl -> ClearUnorderedAccessViewUint(This,ViewGPUHandleInCurrentHeap,ViewCPUHandle,pResource,Values,NumRects,pRects) ) 
+
+#define ID3D12GraphicsCommandList4_ClearUnorderedAccessViewFloat(This,ViewGPUHandleInCurrentHeap,ViewCPUHandle,pResource,Values,NumRects,pRects)	\
+    ( (This)->lpVtbl -> ClearUnorderedAccessViewFloat(This,ViewGPUHandleInCurrentHeap,ViewCPUHandle,pResource,Values,NumRects,pRects) ) 
+
+#define ID3D12GraphicsCommandList4_DiscardResource(This,pResource,pRegion)	\
+    ( (This)->lpVtbl -> DiscardResource(This,pResource,pRegion) ) 
+
+#define ID3D12GraphicsCommandList4_BeginQuery(This,pQueryHeap,Type,Index)	\
+    ( (This)->lpVtbl -> BeginQuery(This,pQueryHeap,Type,Index) ) 
+
+#define ID3D12GraphicsCommandList4_EndQuery(This,pQueryHeap,Type,Index)	\
+    ( (This)->lpVtbl -> EndQuery(This,pQueryHeap,Type,Index) ) 
+
+#define ID3D12GraphicsCommandList4_ResolveQueryData(This,pQueryHeap,Type,StartIndex,NumQueries,pDestinationBuffer,AlignedDestinationBufferOffset)	\
+    ( (This)->lpVtbl -> ResolveQueryData(This,pQueryHeap,Type,StartIndex,NumQueries,pDestinationBuffer,AlignedDestinationBufferOffset) ) 
+
+#define ID3D12GraphicsCommandList4_SetPredication(This,pBuffer,AlignedBufferOffset,Operation)	\
+    ( (This)->lpVtbl -> SetPredication(This,pBuffer,AlignedBufferOffset,Operation) ) 
+
+#define ID3D12GraphicsCommandList4_SetMarker(This,Metadata,pData,Size)	\
+    ( (This)->lpVtbl -> SetMarker(This,Metadata,pData,Size) ) 
+
+#define ID3D12GraphicsCommandList4_BeginEvent(This,Metadata,pData,Size)	\
+    ( (This)->lpVtbl -> BeginEvent(This,Metadata,pData,Size) ) 
+
+#define ID3D12GraphicsCommandList4_EndEvent(This)	\
+    ( (This)->lpVtbl -> EndEvent(This) ) 
+
+#define ID3D12GraphicsCommandList4_ExecuteIndirect(This,pCommandSignature,MaxCommandCount,pArgumentBuffer,ArgumentBufferOffset,pCountBuffer,CountBufferOffset)	\
+    ( (This)->lpVtbl -> ExecuteIndirect(This,pCommandSignature,MaxCommandCount,pArgumentBuffer,ArgumentBufferOffset,pCountBuffer,CountBufferOffset) ) 
+
+
+#define ID3D12GraphicsCommandList4_AtomicCopyBufferUINT(This,pDstBuffer,DstOffset,pSrcBuffer,SrcOffset,Dependencies,ppDependentResources,pDependentSubresourceRanges)	\
+    ( (This)->lpVtbl -> AtomicCopyBufferUINT(This,pDstBuffer,DstOffset,pSrcBuffer,SrcOffset,Dependencies,ppDependentResources,pDependentSubresourceRanges) ) 
+
+#define ID3D12GraphicsCommandList4_AtomicCopyBufferUINT64(This,pDstBuffer,DstOffset,pSrcBuffer,SrcOffset,Dependencies,ppDependentResources,pDependentSubresourceRanges)	\
+    ( (This)->lpVtbl -> AtomicCopyBufferUINT64(This,pDstBuffer,DstOffset,pSrcBuffer,SrcOffset,Dependencies,ppDependentResources,pDependentSubresourceRanges) ) 
+
+#define ID3D12GraphicsCommandList4_OMSetDepthBounds(This,Min,Max)	\
+    ( (This)->lpVtbl -> OMSetDepthBounds(This,Min,Max) ) 
+
+#define ID3D12GraphicsCommandList4_SetSamplePositions(This,NumSamplesPerPixel,NumPixels,pSamplePositions)	\
+    ( (This)->lpVtbl -> SetSamplePositions(This,NumSamplesPerPixel,NumPixels,pSamplePositions) ) 
+
+#define ID3D12GraphicsCommandList4_ResolveSubresourceRegion(This,pDstResource,DstSubresource,DstX,DstY,pSrcResource,SrcSubresource,pSrcRect,Format,ResolveMode)	\
+    ( (This)->lpVtbl -> ResolveSubresourceRegion(This,pDstResource,DstSubresource,DstX,DstY,pSrcResource,SrcSubresource,pSrcRect,Format,ResolveMode) ) 
+
+#define ID3D12GraphicsCommandList4_SetViewInstanceMask(This,Mask)	\
+    ( (This)->lpVtbl -> SetViewInstanceMask(This,Mask) ) 
+
+
+#define ID3D12GraphicsCommandList4_WriteBufferImmediate(This,Count,pParams,pModes)	\
+    ( (This)->lpVtbl -> WriteBufferImmediate(This,Count,pParams,pModes) ) 
+
+
+#define ID3D12GraphicsCommandList4_SetProtectedResourceSession(This,pProtectedResourceSession)	\
+    ( (This)->lpVtbl -> SetProtectedResourceSession(This,pProtectedResourceSession) ) 
+
+
+#define ID3D12GraphicsCommandList4_BeginRenderPass(This,NumRenderTargets,pRenderTargets,pDepthStencil,Flags)	\
+    ( (This)->lpVtbl -> BeginRenderPass(This,NumRenderTargets,pRenderTargets,pDepthStencil,Flags) ) 
+
+#define ID3D12GraphicsCommandList4_EndRenderPass(This)	\
+    ( (This)->lpVtbl -> EndRenderPass(This) ) 
+
+#define ID3D12GraphicsCommandList4_InitializeMetaCommand(This,pMetaCommand,pInitializationParametersData,InitializationParametersDataSizeInBytes)	\
+    ( (This)->lpVtbl -> InitializeMetaCommand(This,pMetaCommand,pInitializationParametersData,InitializationParametersDataSizeInBytes) ) 
+
+#define ID3D12GraphicsCommandList4_ExecuteMetaCommand(This,pMetaCommand,pExecutionParametersData,ExecutionParametersDataSizeInBytes)	\
+    ( (This)->lpVtbl -> ExecuteMetaCommand(This,pMetaCommand,pExecutionParametersData,ExecutionParametersDataSizeInBytes) ) 
+
+#define ID3D12GraphicsCommandList4_BuildRaytracingAccelerationStructure(This,pDesc,NumPostbuildInfoDescs,pPostbuildInfoDescs)	\
+    ( (This)->lpVtbl -> BuildRaytracingAccelerationStructure(This,pDesc,NumPostbuildInfoDescs,pPostbuildInfoDescs) ) 
+
+#define ID3D12GraphicsCommandList4_EmitRaytracingAccelerationStructurePostbuildInfo(This,pDesc,NumSourceAccelerationStructures,pSourceAccelerationStructureData)	\
+    ( (This)->lpVtbl -> EmitRaytracingAccelerationStructurePostbuildInfo(This,pDesc,NumSourceAccelerationStructures,pSourceAccelerationStructureData) ) 
+
+#define ID3D12GraphicsCommandList4_CopyRaytracingAccelerationStructure(This,DestAccelerationStructureData,SourceAccelerationStructureData,Mode)	\
+    ( (This)->lpVtbl -> CopyRaytracingAccelerationStructure(This,DestAccelerationStructureData,SourceAccelerationStructureData,Mode) ) 
+
+#define ID3D12GraphicsCommandList4_SetPipelineState1(This,pStateObject)	\
+    ( (This)->lpVtbl -> SetPipelineState1(This,pStateObject) ) 
+
+#define ID3D12GraphicsCommandList4_DispatchRays(This,pDesc)	\
+    ( (This)->lpVtbl -> DispatchRays(This,pDesc) ) 
+
+#endif /* COBJMACROS */
+
+
+#endif 	/* C style interface */
+
+
+
+
+#endif 	/* __ID3D12GraphicsCommandList4_INTERFACE_DEFINED__ */
+
+
+/* interface __MIDL_itf_d3d12_0000_0051 */
+/* [local] */ 
+
+typedef 
+enum D3D12_SHADER_CACHE_MODE
+    {
+        D3D12_SHADER_CACHE_MODE_MEMORY	= 0,
+        D3D12_SHADER_CACHE_MODE_DISK	= ( D3D12_SHADER_CACHE_MODE_MEMORY + 1 ) 
+    } 	D3D12_SHADER_CACHE_MODE;
+
+typedef 
+enum D3D12_SHADER_CACHE_FLAGS
+    {
+        D3D12_SHADER_CACHE_FLAG_NONE	= 0,
+        D3D12_SHADER_CACHE_FLAG_DRIVER_VERSIONED	= 0x1,
+        D3D12_SHADER_CACHE_FLAG_USE_WORKING_DIR	= 0x2
+    } 	D3D12_SHADER_CACHE_FLAGS;
+
+DEFINE_ENUM_FLAG_OPERATORS( D3D12_SHADER_CACHE_FLAGS );
+typedef struct D3D12_SHADER_CACHE_SESSION_DESC
+    {
+    GUID Identifier;
+    D3D12_SHADER_CACHE_MODE Mode;
+    D3D12_SHADER_CACHE_FLAGS Flags;
+    UINT MaximumInMemoryCacheSizeBytes;
+    UINT MaximumInMemoryCacheEntries;
+    UINT MaximumValueFileSizeBytes;
+    UINT64 Version;
+    } 	D3D12_SHADER_CACHE_SESSION_DESC;
+
+typedef 
+enum D3D12_BARRIER_LAYOUT
+    {
+        D3D12_BARRIER_LAYOUT_UNDEFINED	= 0xffffffff,
+        D3D12_BARRIER_LAYOUT_COMMON	= 0,
+        D3D12_BARRIER_LAYOUT_PRESENT	= 0,
+        D3D12_BARRIER_LAYOUT_GENERIC_READ	= ( D3D12_BARRIER_LAYOUT_PRESENT + 1 ) ,
+        D3D12_BARRIER_LAYOUT_RENDER_TARGET	= ( D3D12_BARRIER_LAYOUT_GENERIC_READ + 1 ) ,
+        D3D12_BARRIER_LAYOUT_UNORDERED_ACCESS	= ( D3D12_BARRIER_LAYOUT_RENDER_TARGET + 1 ) ,
+        D3D12_BARRIER_LAYOUT_DEPTH_STENCIL_WRITE	= ( D3D12_BARRIER_LAYOUT_UNORDERED_ACCESS + 1 ) ,
+        D3D12_BARRIER_LAYOUT_DEPTH_STENCIL_READ	= ( D3D12_BARRIER_LAYOUT_DEPTH_STENCIL_WRITE + 1 ) ,
+        D3D12_BARRIER_LAYOUT_SHADER_RESOURCE	= ( D3D12_BARRIER_LAYOUT_DEPTH_STENCIL_READ + 1 ) ,
+        D3D12_BARRIER_LAYOUT_COPY_SOURCE	= ( D3D12_BARRIER_LAYOUT_SHADER_RESOURCE + 1 ) ,
+        D3D12_BARRIER_LAYOUT_COPY_DEST	= ( D3D12_BARRIER_LAYOUT_COPY_SOURCE + 1 ) ,
+        D3D12_BARRIER_LAYOUT_RESOLVE_SOURCE	= ( D3D12_BARRIER_LAYOUT_COPY_DEST + 1 ) ,
+        D3D12_BARRIER_LAYOUT_RESOLVE_DEST	= ( D3D12_BARRIER_LAYOUT_RESOLVE_SOURCE + 1 ) ,
+        D3D12_BARRIER_LAYOUT_SHADING_RATE_SOURCE	= ( D3D12_BARRIER_LAYOUT_RESOLVE_DEST + 1 ) ,
+        D3D12_BARRIER_LAYOUT_VIDEO_DECODE_READ	= ( D3D12_BARRIER_LAYOUT_SHADING_RATE_SOURCE + 1 ) ,
+        D3D12_BARRIER_LAYOUT_VIDEO_DECODE_WRITE	= ( D3D12_BARRIER_LAYOUT_VIDEO_DECODE_READ + 1 ) ,
+        D3D12_BARRIER_LAYOUT_VIDEO_PROCESS_READ	= ( D3D12_BARRIER_LAYOUT_VIDEO_DECODE_WRITE + 1 ) ,
+        D3D12_BARRIER_LAYOUT_VIDEO_PROCESS_WRITE	= ( D3D12_BARRIER_LAYOUT_VIDEO_PROCESS_READ + 1 ) ,
+        D3D12_BARRIER_LAYOUT_VIDEO_ENCODE_READ	= ( D3D12_BARRIER_LAYOUT_VIDEO_PROCESS_WRITE + 1 ) ,
+        D3D12_BARRIER_LAYOUT_VIDEO_ENCODE_WRITE	= ( D3D12_BARRIER_LAYOUT_VIDEO_ENCODE_READ + 1 ) ,
+        D3D12_BARRIER_LAYOUT_DIRECT_QUEUE_COMMON	= ( D3D12_BARRIER_LAYOUT_VIDEO_ENCODE_WRITE + 1 ) ,
+        D3D12_BARRIER_LAYOUT_DIRECT_QUEUE_GENERIC_READ	= ( D3D12_BARRIER_LAYOUT_DIRECT_QUEUE_COMMON + 1 ) ,
+        D3D12_BARRIER_LAYOUT_DIRECT_QUEUE_UNORDERED_ACCESS	= ( D3D12_BARRIER_LAYOUT_DIRECT_QUEUE_GENERIC_READ + 1 ) ,
+        D3D12_BARRIER_LAYOUT_DIRECT_QUEUE_SHADER_RESOURCE	= ( D3D12_BARRIER_LAYOUT_DIRECT_QUEUE_UNORDERED_ACCESS + 1 ) ,
+        D3D12_BARRIER_LAYOUT_DIRECT_QUEUE_COPY_SOURCE	= ( D3D12_BARRIER_LAYOUT_DIRECT_QUEUE_SHADER_RESOURCE + 1 ) ,
+        D3D12_BARRIER_LAYOUT_DIRECT_QUEUE_COPY_DEST	= ( D3D12_BARRIER_LAYOUT_DIRECT_QUEUE_COPY_SOURCE + 1 ) ,
+        D3D12_BARRIER_LAYOUT_COMPUTE_QUEUE_COMMON	= ( D3D12_BARRIER_LAYOUT_DIRECT_QUEUE_COPY_DEST + 1 ) ,
+        D3D12_BARRIER_LAYOUT_COMPUTE_QUEUE_GENERIC_READ	= ( D3D12_BARRIER_LAYOUT_COMPUTE_QUEUE_COMMON + 1 ) ,
+        D3D12_BARRIER_LAYOUT_COMPUTE_QUEUE_UNORDERED_ACCESS	= ( D3D12_BARRIER_LAYOUT_COMPUTE_QUEUE_GENERIC_READ + 1 ) ,
+        D3D12_BARRIER_LAYOUT_COMPUTE_QUEUE_SHADER_RESOURCE	= ( D3D12_BARRIER_LAYOUT_COMPUTE_QUEUE_UNORDERED_ACCESS + 1 ) ,
+        D3D12_BARRIER_LAYOUT_COMPUTE_QUEUE_COPY_SOURCE	= ( D3D12_BARRIER_LAYOUT_COMPUTE_QUEUE_SHADER_RESOURCE + 1 ) ,
+        D3D12_BARRIER_LAYOUT_COMPUTE_QUEUE_COPY_DEST	= ( D3D12_BARRIER_LAYOUT_COMPUTE_QUEUE_COPY_SOURCE + 1 ) ,
+        D3D12_BARRIER_LAYOUT_VIDEO_QUEUE_COMMON	= ( D3D12_BARRIER_LAYOUT_COMPUTE_QUEUE_COPY_DEST + 1 ) 
+    } 	D3D12_BARRIER_LAYOUT;
+
+typedef 
+enum D3D12_BARRIER_SYNC
+    {
+        D3D12_BARRIER_SYNC_NONE	= 0,
+        D3D12_BARRIER_SYNC_ALL	= 0x1,
+        D3D12_BARRIER_SYNC_DRAW	= 0x2,
+        D3D12_BARRIER_SYNC_INPUT_ASSEMBLER	= 0x4,
+        D3D12_BARRIER_SYNC_VERTEX_SHADING	= 0x8,
+        D3D12_BARRIER_SYNC_PIXEL_SHADING	= 0x10,
+        D3D12_BARRIER_SYNC_DEPTH_STENCIL	= 0x20,
+        D3D12_BARRIER_SYNC_RENDER_TARGET	= 0x40,
+        D3D12_BARRIER_SYNC_COMPUTE_SHADING	= 0x80,
+        D3D12_BARRIER_SYNC_RAYTRACING	= 0x100,
+        D3D12_BARRIER_SYNC_COPY	= 0x200,
+        D3D12_BARRIER_SYNC_RESOLVE	= 0x400,
+        D3D12_BARRIER_SYNC_EXECUTE_INDIRECT	= 0x800,
+        D3D12_BARRIER_SYNC_PREDICATION	= 0x800,
+        D3D12_BARRIER_SYNC_ALL_SHADING	= 0x1000,
+        D3D12_BARRIER_SYNC_NON_PIXEL_SHADING	= 0x2000,
+        D3D12_BARRIER_SYNC_EMIT_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO	= 0x4000,
+        D3D12_BARRIER_SYNC_CLEAR_UNORDERED_ACCESS_VIEW	= 0x8000,
+        D3D12_BARRIER_SYNC_VIDEO_DECODE	= 0x100000,
+        D3D12_BARRIER_SYNC_VIDEO_PROCESS	= 0x200000,
+        D3D12_BARRIER_SYNC_VIDEO_ENCODE	= 0x400000,
+        D3D12_BARRIER_SYNC_BUILD_RAYTRACING_ACCELERATION_STRUCTURE	= 0x800000,
+        D3D12_BARRIER_SYNC_COPY_RAYTRACING_ACCELERATION_STRUCTURE	= 0x1000000,
+        D3D12_BARRIER_SYNC_SPLIT	= 0x80000000
+    } 	D3D12_BARRIER_SYNC;
+
+DEFINE_ENUM_FLAG_OPERATORS( D3D12_BARRIER_SYNC );
+typedef 
+enum D3D12_BARRIER_ACCESS
+    {
+        D3D12_BARRIER_ACCESS_COMMON	= 0,
+        D3D12_BARRIER_ACCESS_VERTEX_BUFFER	= 0x1,
+        D3D12_BARRIER_ACCESS_CONSTANT_BUFFER	= 0x2,
+        D3D12_BARRIER_ACCESS_INDEX_BUFFER	= 0x4,
+        D3D12_BARRIER_ACCESS_RENDER_TARGET	= 0x8,
+        D3D12_BARRIER_ACCESS_UNORDERED_ACCESS	= 0x10,
+        D3D12_BARRIER_ACCESS_DEPTH_STENCIL_WRITE	= 0x20,
+        D3D12_BARRIER_ACCESS_DEPTH_STENCIL_READ	= 0x40,
+        D3D12_BARRIER_ACCESS_SHADER_RESOURCE	= 0x80,
+        D3D12_BARRIER_ACCESS_STREAM_OUTPUT	= 0x100,
+        D3D12_BARRIER_ACCESS_INDIRECT_ARGUMENT	= 0x200,
+        D3D12_BARRIER_ACCESS_PREDICATION	= 0x200,
+        D3D12_BARRIER_ACCESS_COPY_DEST	= 0x400,
+        D3D12_BARRIER_ACCESS_COPY_SOURCE	= 0x800,
+        D3D12_BARRIER_ACCESS_RESOLVE_DEST	= 0x1000,
+        D3D12_BARRIER_ACCESS_RESOLVE_SOURCE	= 0x2000,
+        D3D12_BARRIER_ACCESS_RAYTRACING_ACCELERATION_STRUCTURE_READ	= 0x4000,
+        D3D12_BARRIER_ACCESS_RAYTRACING_ACCELERATION_STRUCTURE_WRITE	= 0x8000,
+        D3D12_BARRIER_ACCESS_SHADING_RATE_SOURCE	= 0x10000,
+        D3D12_BARRIER_ACCESS_VIDEO_DECODE_READ	= 0x20000,
+        D3D12_BARRIER_ACCESS_VIDEO_DECODE_WRITE	= 0x40000,
+        D3D12_BARRIER_ACCESS_VIDEO_PROCESS_READ	= 0x80000,
+        D3D12_BARRIER_ACCESS_VIDEO_PROCESS_WRITE	= 0x100000,
+        D3D12_BARRIER_ACCESS_VIDEO_ENCODE_READ	= 0x200000,
+        D3D12_BARRIER_ACCESS_VIDEO_ENCODE_WRITE	= 0x400000,
+        D3D12_BARRIER_ACCESS_NO_ACCESS	= 0x80000000
+    } 	D3D12_BARRIER_ACCESS;
+
+DEFINE_ENUM_FLAG_OPERATORS( D3D12_BARRIER_ACCESS );
+typedef 
+enum D3D12_BARRIER_TYPE
+    {
+        D3D12_BARRIER_TYPE_GLOBAL	= 0,
+        D3D12_BARRIER_TYPE_TEXTURE	= ( D3D12_BARRIER_TYPE_GLOBAL + 1 ) ,
+        D3D12_BARRIER_TYPE_BUFFER	= ( D3D12_BARRIER_TYPE_TEXTURE + 1 ) 
+    } 	D3D12_BARRIER_TYPE;
+
+typedef 
+enum D3D12_TEXTURE_BARRIER_FLAGS
+    {
+        D3D12_TEXTURE_BARRIER_FLAG_NONE	= 0,
+        D3D12_TEXTURE_BARRIER_FLAG_DISCARD	= 0x1
+    } 	D3D12_TEXTURE_BARRIER_FLAGS;
+
+DEFINE_ENUM_FLAG_OPERATORS( D3D12_TEXTURE_BARRIER_FLAGS );
+typedef struct D3D12_BARRIER_SUBRESOURCE_RANGE
+    {
+    UINT IndexOrFirstMipLevel;
+    UINT NumMipLevels;
+    UINT FirstArraySlice;
+    UINT NumArraySlices;
+    UINT FirstPlane;
+    UINT NumPlanes;
+    } 	D3D12_BARRIER_SUBRESOURCE_RANGE;
+
+typedef struct D3D12_GLOBAL_BARRIER
+    {
+    D3D12_BARRIER_SYNC SyncBefore;
+    D3D12_BARRIER_SYNC SyncAfter;
+    D3D12_BARRIER_ACCESS AccessBefore;
+    D3D12_BARRIER_ACCESS AccessAfter;
+    } 	D3D12_GLOBAL_BARRIER;
+
+typedef struct D3D12_TEXTURE_BARRIER
+    {
+    D3D12_BARRIER_SYNC SyncBefore;
+    D3D12_BARRIER_SYNC SyncAfter;
+    D3D12_BARRIER_ACCESS AccessBefore;
+    D3D12_BARRIER_ACCESS AccessAfter;
+    D3D12_BARRIER_LAYOUT LayoutBefore;
+    D3D12_BARRIER_LAYOUT LayoutAfter;
+    _In_  ID3D12Resource *pResource;
+    D3D12_BARRIER_SUBRESOURCE_RANGE Subresources;
+    D3D12_TEXTURE_BARRIER_FLAGS Flags;
+    } 	D3D12_TEXTURE_BARRIER;
+
+typedef struct D3D12_BUFFER_BARRIER
+    {
+    D3D12_BARRIER_SYNC SyncBefore;
+    D3D12_BARRIER_SYNC SyncAfter;
+    D3D12_BARRIER_ACCESS AccessBefore;
+    D3D12_BARRIER_ACCESS AccessAfter;
+    _In_  ID3D12Resource *pResource;
+    UINT64 Offset;
+    UINT64 Size;
+    } 	D3D12_BUFFER_BARRIER;
+
+typedef struct D3D12_BARRIER_GROUP
+    {
+    D3D12_BARRIER_TYPE Type;
+    UINT32 NumBarriers;
+    union 
+        {
+        _In_reads_(NumBarriers)  const D3D12_GLOBAL_BARRIER *pGlobalBarriers;
+        _In_reads_(NumBarriers)  const D3D12_TEXTURE_BARRIER *pTextureBarriers;
+        _In_reads_(NumBarriers)  const D3D12_BUFFER_BARRIER *pBufferBarriers;
+        } 	;
+    } 	D3D12_BARRIER_GROUP;
+
+
+
+extern RPC_IF_HANDLE __MIDL_itf_d3d12_0000_0051_v0_0_c_ifspec;
+extern RPC_IF_HANDLE __MIDL_itf_d3d12_0000_0051_v0_0_s_ifspec;
+
+#ifndef __ID3D12ShaderCacheSession_INTERFACE_DEFINED__
+#define __ID3D12ShaderCacheSession_INTERFACE_DEFINED__
+
+/* interface ID3D12ShaderCacheSession */
+/* [unique][local][object][uuid] */ 
+
+
+EXTERN_C const IID IID_ID3D12ShaderCacheSession;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("28e2495d-0f64-4ae4-a6ec-129255dc49a8")
+    ID3D12ShaderCacheSession : public ID3D12DeviceChild
+    {
+    public:
+        virtual HRESULT STDMETHODCALLTYPE FindValue( 
+            /* [annotation][in] */ 
+            _In_reads_bytes_(KeySize)  const void *pKey,
+            UINT KeySize,
+            /* [annotation][out] */ 
+            _Out_writes_bytes_(*pValueSize)  void *pValue,
+            _Inout_  UINT *pValueSize) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE StoreValue( 
+            /* [annotation][in] */ 
+            _In_reads_bytes_(KeySize)  const void *pKey,
+            UINT KeySize,
+            /* [annotation][in] */ 
+            _In_reads_bytes_(ValueSize)  const void *pValue,
+            UINT ValueSize) = 0;
+        
+        virtual void STDMETHODCALLTYPE SetDeleteOnDestroy( void) = 0;
+        
+#if defined(_MSC_VER) || !defined(_WIN32)
+        virtual D3D12_SHADER_CACHE_SESSION_DESC STDMETHODCALLTYPE GetDesc( void) = 0;
+#else
+        virtual D3D12_SHADER_CACHE_SESSION_DESC *STDMETHODCALLTYPE GetDesc( 
+            D3D12_SHADER_CACHE_SESSION_DESC * RetVal) = 0;
+#endif
+        
+    };
+    
+    
+#else 	/* C style interface */
+
+    typedef struct ID3D12ShaderCacheSessionVtbl
+    {
+        BEGIN_INTERFACE
+        
+        DECLSPEC_XFGVIRT(IUnknown, QueryInterface)
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            ID3D12ShaderCacheSession * This,
+            REFIID riid,
+            _COM_Outptr_  void **ppvObject);
+        
+        DECLSPEC_XFGVIRT(IUnknown, AddRef)
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            ID3D12ShaderCacheSession * This);
+        
+        DECLSPEC_XFGVIRT(IUnknown, Release)
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            ID3D12ShaderCacheSession * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, GetPrivateData)
+        HRESULT ( STDMETHODCALLTYPE *GetPrivateData )( 
+            ID3D12ShaderCacheSession * This,
+            _In_  REFGUID guid,
+            _Inout_  UINT *pDataSize,
+            _Out_writes_bytes_opt_( *pDataSize )  void *pData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, SetPrivateData)
+        HRESULT ( STDMETHODCALLTYPE *SetPrivateData )( 
+            ID3D12ShaderCacheSession * This,
+            _In_  REFGUID guid,
+            _In_  UINT DataSize,
+            _In_reads_bytes_opt_( DataSize )  const void *pData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, SetPrivateDataInterface)
+        HRESULT ( STDMETHODCALLTYPE *SetPrivateDataInterface )( 
+            ID3D12ShaderCacheSession * This,
+            _In_  REFGUID guid,
+            _In_opt_  const IUnknown *pData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, SetName)
+        HRESULT ( STDMETHODCALLTYPE *SetName )( 
+            ID3D12ShaderCacheSession * This,
+            _In_z_  LPCWSTR Name);
+        
+        DECLSPEC_XFGVIRT(ID3D12DeviceChild, GetDevice)
+        HRESULT ( STDMETHODCALLTYPE *GetDevice )( 
+            ID3D12ShaderCacheSession * This,
+            REFIID riid,
+            _COM_Outptr_opt_  void **ppvDevice);
+        
+        DECLSPEC_XFGVIRT(ID3D12ShaderCacheSession, FindValue)
+        HRESULT ( STDMETHODCALLTYPE *FindValue )( 
+            ID3D12ShaderCacheSession * This,
+            /* [annotation][in] */ 
+            _In_reads_bytes_(KeySize)  const void *pKey,
+            UINT KeySize,
+            /* [annotation][out] */ 
+            _Out_writes_bytes_(*pValueSize)  void *pValue,
+            _Inout_  UINT *pValueSize);
+        
+        DECLSPEC_XFGVIRT(ID3D12ShaderCacheSession, StoreValue)
+        HRESULT ( STDMETHODCALLTYPE *StoreValue )( 
+            ID3D12ShaderCacheSession * This,
+            /* [annotation][in] */ 
+            _In_reads_bytes_(KeySize)  const void *pKey,
+            UINT KeySize,
+            /* [annotation][in] */ 
+            _In_reads_bytes_(ValueSize)  const void *pValue,
+            UINT ValueSize);
+        
+        DECLSPEC_XFGVIRT(ID3D12ShaderCacheSession, SetDeleteOnDestroy)
+        void ( STDMETHODCALLTYPE *SetDeleteOnDestroy )( 
+            ID3D12ShaderCacheSession * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12ShaderCacheSession, GetDesc)
+#if !defined(_WIN32)
+        D3D12_SHADER_CACHE_SESSION_DESC ( STDMETHODCALLTYPE *GetDesc )( 
+            ID3D12ShaderCacheSession * This);
+        
+#else
+        D3D12_SHADER_CACHE_SESSION_DESC *( STDMETHODCALLTYPE *GetDesc )( 
+            ID3D12ShaderCacheSession * This,
+            D3D12_SHADER_CACHE_SESSION_DESC * RetVal);
+        
+#endif
+        
+        END_INTERFACE
+    } ID3D12ShaderCacheSessionVtbl;
+
+    interface ID3D12ShaderCacheSession
+    {
+        CONST_VTBL struct ID3D12ShaderCacheSessionVtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define ID3D12ShaderCacheSession_QueryInterface(This,riid,ppvObject)	\
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define ID3D12ShaderCacheSession_AddRef(This)	\
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define ID3D12ShaderCacheSession_Release(This)	\
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#define ID3D12ShaderCacheSession_GetPrivateData(This,guid,pDataSize,pData)	\
+    ( (This)->lpVtbl -> GetPrivateData(This,guid,pDataSize,pData) ) 
+
+#define ID3D12ShaderCacheSession_SetPrivateData(This,guid,DataSize,pData)	\
+    ( (This)->lpVtbl -> SetPrivateData(This,guid,DataSize,pData) ) 
+
+#define ID3D12ShaderCacheSession_SetPrivateDataInterface(This,guid,pData)	\
+    ( (This)->lpVtbl -> SetPrivateDataInterface(This,guid,pData) ) 
+
+#define ID3D12ShaderCacheSession_SetName(This,Name)	\
+    ( (This)->lpVtbl -> SetName(This,Name) ) 
+
+
+#define ID3D12ShaderCacheSession_GetDevice(This,riid,ppvDevice)	\
+    ( (This)->lpVtbl -> GetDevice(This,riid,ppvDevice) ) 
+
+
+#define ID3D12ShaderCacheSession_FindValue(This,pKey,KeySize,pValue,pValueSize)	\
+    ( (This)->lpVtbl -> FindValue(This,pKey,KeySize,pValue,pValueSize) ) 
+
+#define ID3D12ShaderCacheSession_StoreValue(This,pKey,KeySize,pValue,ValueSize)	\
+    ( (This)->lpVtbl -> StoreValue(This,pKey,KeySize,pValue,ValueSize) ) 
+
+#define ID3D12ShaderCacheSession_SetDeleteOnDestroy(This)	\
+    ( (This)->lpVtbl -> SetDeleteOnDestroy(This) ) 
+#if !defined(_WIN32)
+
+#define ID3D12ShaderCacheSession_GetDesc(This)	\
+    ( (This)->lpVtbl -> GetDesc(This) ) 
+#else
+#define ID3D12ShaderCacheSession_GetDesc(This,RetVal)	\
+    ( (This)->lpVtbl -> GetDesc(This,RetVal) ) 
+#endif
+
+#endif /* COBJMACROS */
+
+
+#endif 	/* C style interface */
+
+
+
+
+#endif 	/* __ID3D12ShaderCacheSession_INTERFACE_DEFINED__ */
+
+
+/* interface __MIDL_itf_d3d12_0000_0052 */
+/* [local] */ 
+
+typedef 
+enum D3D12_SHADER_CACHE_KIND_FLAGS
+    {
+        D3D12_SHADER_CACHE_KIND_FLAG_IMPLICIT_D3D_CACHE_FOR_DRIVER	= 0x1,
+        D3D12_SHADER_CACHE_KIND_FLAG_IMPLICIT_D3D_CONVERSIONS	= 0x2,
+        D3D12_SHADER_CACHE_KIND_FLAG_IMPLICIT_DRIVER_MANAGED	= 0x4,
+        D3D12_SHADER_CACHE_KIND_FLAG_APPLICATION_MANAGED	= 0x8
+    } 	D3D12_SHADER_CACHE_KIND_FLAGS;
+
+DEFINE_ENUM_FLAG_OPERATORS( D3D12_SHADER_CACHE_KIND_FLAGS );
+typedef 
+enum D3D12_SHADER_CACHE_CONTROL_FLAGS
+    {
+        D3D12_SHADER_CACHE_CONTROL_FLAG_DISABLE	= 0x1,
+        D3D12_SHADER_CACHE_CONTROL_FLAG_ENABLE	= 0x2,
+        D3D12_SHADER_CACHE_CONTROL_FLAG_CLEAR	= 0x4
+    } 	D3D12_SHADER_CACHE_CONTROL_FLAGS;
+
+DEFINE_ENUM_FLAG_OPERATORS( D3D12_SHADER_CACHE_CONTROL_FLAGS );
+
+
+extern RPC_IF_HANDLE __MIDL_itf_d3d12_0000_0052_v0_0_c_ifspec;
+extern RPC_IF_HANDLE __MIDL_itf_d3d12_0000_0052_v0_0_s_ifspec;
+
+#ifndef __ID3D12Device9_INTERFACE_DEFINED__
+#define __ID3D12Device9_INTERFACE_DEFINED__
+
+/* interface ID3D12Device9 */
+/* [unique][local][object][uuid] */ 
+
+
+EXTERN_C const IID IID_ID3D12Device9;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("4c80e962-f032-4f60-bc9e-ebc2cfa1d83c")
+    ID3D12Device9 : public ID3D12Device8
+    {
+    public:
+        virtual HRESULT STDMETHODCALLTYPE CreateShaderCacheSession( 
+            _In_  const D3D12_SHADER_CACHE_SESSION_DESC *pDesc,
+            REFIID riid,
+            _COM_Outptr_opt_  void **ppvSession) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE ShaderCacheControl( 
+            D3D12_SHADER_CACHE_KIND_FLAGS Kinds,
+            D3D12_SHADER_CACHE_CONTROL_FLAGS Control) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE CreateCommandQueue1( 
+            _In_  const D3D12_COMMAND_QUEUE_DESC *pDesc,
+            REFIID CreatorID,
+            REFIID riid,
+            _COM_Outptr_  void **ppCommandQueue) = 0;
+        
+    };
+    
+    
+#else 	/* C style interface */
+
+    typedef struct ID3D12Device9Vtbl
+    {
+        BEGIN_INTERFACE
+        
+        DECLSPEC_XFGVIRT(IUnknown, QueryInterface)
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            ID3D12Device9 * This,
+            REFIID riid,
+            _COM_Outptr_  void **ppvObject);
+        
+        DECLSPEC_XFGVIRT(IUnknown, AddRef)
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            ID3D12Device9 * This);
+        
+        DECLSPEC_XFGVIRT(IUnknown, Release)
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            ID3D12Device9 * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, GetPrivateData)
+        HRESULT ( STDMETHODCALLTYPE *GetPrivateData )( 
+            ID3D12Device9 * This,
+            _In_  REFGUID guid,
+            _Inout_  UINT *pDataSize,
+            _Out_writes_bytes_opt_( *pDataSize )  void *pData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, SetPrivateData)
+        HRESULT ( STDMETHODCALLTYPE *SetPrivateData )( 
+            ID3D12Device9 * This,
+            _In_  REFGUID guid,
+            _In_  UINT DataSize,
+            _In_reads_bytes_opt_( DataSize )  const void *pData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, SetPrivateDataInterface)
+        HRESULT ( STDMETHODCALLTYPE *SetPrivateDataInterface )( 
+            ID3D12Device9 * This,
+            _In_  REFGUID guid,
+            _In_opt_  const IUnknown *pData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, SetName)
+        HRESULT ( STDMETHODCALLTYPE *SetName )( 
+            ID3D12Device9 * This,
+            _In_z_  LPCWSTR Name);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, GetNodeCount)
+        UINT ( STDMETHODCALLTYPE *GetNodeCount )( 
+            ID3D12Device9 * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CreateCommandQueue)
+        HRESULT ( STDMETHODCALLTYPE *CreateCommandQueue )( 
+            ID3D12Device9 * This,
+            _In_  const D3D12_COMMAND_QUEUE_DESC *pDesc,
+            REFIID riid,
+            _COM_Outptr_  void **ppCommandQueue);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CreateCommandAllocator)
+        HRESULT ( STDMETHODCALLTYPE *CreateCommandAllocator )( 
+            ID3D12Device9 * This,
+            _In_  D3D12_COMMAND_LIST_TYPE type,
+            REFIID riid,
+            _COM_Outptr_  void **ppCommandAllocator);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CreateGraphicsPipelineState)
+        HRESULT ( STDMETHODCALLTYPE *CreateGraphicsPipelineState )( 
+            ID3D12Device9 * This,
+            _In_  const D3D12_GRAPHICS_PIPELINE_STATE_DESC *pDesc,
+            REFIID riid,
+            _COM_Outptr_  void **ppPipelineState);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CreateComputePipelineState)
+        HRESULT ( STDMETHODCALLTYPE *CreateComputePipelineState )( 
+            ID3D12Device9 * This,
+            _In_  const D3D12_COMPUTE_PIPELINE_STATE_DESC *pDesc,
+            REFIID riid,
+            _COM_Outptr_  void **ppPipelineState);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CreateCommandList)
+        HRESULT ( STDMETHODCALLTYPE *CreateCommandList )( 
+            ID3D12Device9 * This,
+            _In_  UINT nodeMask,
+            _In_  D3D12_COMMAND_LIST_TYPE type,
+            _In_  ID3D12CommandAllocator *pCommandAllocator,
+            _In_opt_  ID3D12PipelineState *pInitialState,
+            REFIID riid,
+            _COM_Outptr_  void **ppCommandList);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CheckFeatureSupport)
+        HRESULT ( STDMETHODCALLTYPE *CheckFeatureSupport )( 
+            ID3D12Device9 * This,
+            D3D12_FEATURE Feature,
+            _Inout_updates_bytes_(FeatureSupportDataSize)  void *pFeatureSupportData,
+            UINT FeatureSupportDataSize);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CreateDescriptorHeap)
+        HRESULT ( STDMETHODCALLTYPE *CreateDescriptorHeap )( 
+            ID3D12Device9 * This,
+            _In_  const D3D12_DESCRIPTOR_HEAP_DESC *pDescriptorHeapDesc,
+            REFIID riid,
+            _COM_Outptr_  void **ppvHeap);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, GetDescriptorHandleIncrementSize)
+        UINT ( STDMETHODCALLTYPE *GetDescriptorHandleIncrementSize )( 
+            ID3D12Device9 * This,
+            _In_  D3D12_DESCRIPTOR_HEAP_TYPE DescriptorHeapType);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CreateRootSignature)
+        HRESULT ( STDMETHODCALLTYPE *CreateRootSignature )( 
+            ID3D12Device9 * This,
+            _In_  UINT nodeMask,
+            _In_reads_(blobLengthInBytes)  const void *pBlobWithRootSignature,
+            _In_  SIZE_T blobLengthInBytes,
+            REFIID riid,
+            _COM_Outptr_  void **ppvRootSignature);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CreateConstantBufferView)
+        void ( STDMETHODCALLTYPE *CreateConstantBufferView )( 
+            ID3D12Device9 * This,
+            _In_opt_  const D3D12_CONSTANT_BUFFER_VIEW_DESC *pDesc,
+            _In_  D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CreateShaderResourceView)
+        void ( STDMETHODCALLTYPE *CreateShaderResourceView )( 
+            ID3D12Device9 * This,
+            _In_opt_  ID3D12Resource *pResource,
+            _In_opt_  const D3D12_SHADER_RESOURCE_VIEW_DESC *pDesc,
+            _In_  D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CreateUnorderedAccessView)
+        void ( STDMETHODCALLTYPE *CreateUnorderedAccessView )( 
+            ID3D12Device9 * This,
+            _In_opt_  ID3D12Resource *pResource,
+            _In_opt_  ID3D12Resource *pCounterResource,
+            _In_opt_  const D3D12_UNORDERED_ACCESS_VIEW_DESC *pDesc,
+            _In_  D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CreateRenderTargetView)
+        void ( STDMETHODCALLTYPE *CreateRenderTargetView )( 
+            ID3D12Device9 * This,
+            _In_opt_  ID3D12Resource *pResource,
+            _In_opt_  const D3D12_RENDER_TARGET_VIEW_DESC *pDesc,
+            _In_  D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CreateDepthStencilView)
+        void ( STDMETHODCALLTYPE *CreateDepthStencilView )( 
+            ID3D12Device9 * This,
+            _In_opt_  ID3D12Resource *pResource,
+            _In_opt_  const D3D12_DEPTH_STENCIL_VIEW_DESC *pDesc,
+            _In_  D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CreateSampler)
+        void ( STDMETHODCALLTYPE *CreateSampler )( 
+            ID3D12Device9 * This,
+            _In_  const D3D12_SAMPLER_DESC *pDesc,
+            _In_  D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CopyDescriptors)
+        void ( STDMETHODCALLTYPE *CopyDescriptors )( 
+            ID3D12Device9 * This,
+            _In_  UINT NumDestDescriptorRanges,
+            _In_reads_(NumDestDescriptorRanges)  const D3D12_CPU_DESCRIPTOR_HANDLE *pDestDescriptorRangeStarts,
+            _In_reads_opt_(NumDestDescriptorRanges)  const UINT *pDestDescriptorRangeSizes,
+            _In_  UINT NumSrcDescriptorRanges,
+            _In_reads_(NumSrcDescriptorRanges)  const D3D12_CPU_DESCRIPTOR_HANDLE *pSrcDescriptorRangeStarts,
+            _In_reads_opt_(NumSrcDescriptorRanges)  const UINT *pSrcDescriptorRangeSizes,
+            _In_  D3D12_DESCRIPTOR_HEAP_TYPE DescriptorHeapsType);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CopyDescriptorsSimple)
+        void ( STDMETHODCALLTYPE *CopyDescriptorsSimple )( 
+            ID3D12Device9 * This,
+            _In_  UINT NumDescriptors,
+            _In_  D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptorRangeStart,
+            _In_  D3D12_CPU_DESCRIPTOR_HANDLE SrcDescriptorRangeStart,
+            _In_  D3D12_DESCRIPTOR_HEAP_TYPE DescriptorHeapsType);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, GetResourceAllocationInfo)
+#if !defined(_WIN32)
+        D3D12_RESOURCE_ALLOCATION_INFO ( STDMETHODCALLTYPE *GetResourceAllocationInfo )( 
+            ID3D12Device9 * This,
+            _In_  UINT visibleMask,
+            _In_  UINT numResourceDescs,
+            _In_reads_(numResourceDescs)  const D3D12_RESOURCE_DESC *pResourceDescs);
+        
+#else
+        D3D12_RESOURCE_ALLOCATION_INFO *( STDMETHODCALLTYPE *GetResourceAllocationInfo )( 
+            ID3D12Device9 * This,
+            D3D12_RESOURCE_ALLOCATION_INFO * RetVal,
+            _In_  UINT visibleMask,
+            _In_  UINT numResourceDescs,
+            _In_reads_(numResourceDescs)  const D3D12_RESOURCE_DESC *pResourceDescs);
+        
+#endif
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, GetCustomHeapProperties)
+#if !defined(_WIN32)
+        D3D12_HEAP_PROPERTIES ( STDMETHODCALLTYPE *GetCustomHeapProperties )( 
+            ID3D12Device9 * This,
+            _In_  UINT nodeMask,
+            D3D12_HEAP_TYPE heapType);
+        
+#else
+        D3D12_HEAP_PROPERTIES *( STDMETHODCALLTYPE *GetCustomHeapProperties )( 
+            ID3D12Device9 * This,
+            D3D12_HEAP_PROPERTIES * RetVal,
+            _In_  UINT nodeMask,
+            D3D12_HEAP_TYPE heapType);
+        
+#endif
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CreateCommittedResource)
+        HRESULT ( STDMETHODCALLTYPE *CreateCommittedResource )( 
+            ID3D12Device9 * This,
+            _In_  const D3D12_HEAP_PROPERTIES *pHeapProperties,
+            D3D12_HEAP_FLAGS HeapFlags,
+            _In_  const D3D12_RESOURCE_DESC *pDesc,
+            D3D12_RESOURCE_STATES InitialResourceState,
+            _In_opt_  const D3D12_CLEAR_VALUE *pOptimizedClearValue,
+            REFIID riidResource,
+            _COM_Outptr_opt_  void **ppvResource);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CreateHeap)
+        HRESULT ( STDMETHODCALLTYPE *CreateHeap )( 
+            ID3D12Device9 * This,
+            _In_  const D3D12_HEAP_DESC *pDesc,
+            REFIID riid,
+            _COM_Outptr_opt_  void **ppvHeap);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CreatePlacedResource)
+        HRESULT ( STDMETHODCALLTYPE *CreatePlacedResource )( 
+            ID3D12Device9 * This,
+            _In_  ID3D12Heap *pHeap,
+            UINT64 HeapOffset,
+            _In_  const D3D12_RESOURCE_DESC *pDesc,
+            D3D12_RESOURCE_STATES InitialState,
+            _In_opt_  const D3D12_CLEAR_VALUE *pOptimizedClearValue,
+            REFIID riid,
+            _COM_Outptr_opt_  void **ppvResource);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CreateReservedResource)
+        HRESULT ( STDMETHODCALLTYPE *CreateReservedResource )( 
+            ID3D12Device9 * This,
+            _In_  const D3D12_RESOURCE_DESC *pDesc,
+            D3D12_RESOURCE_STATES InitialState,
+            _In_opt_  const D3D12_CLEAR_VALUE *pOptimizedClearValue,
+            REFIID riid,
+            _COM_Outptr_opt_  void **ppvResource);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CreateSharedHandle)
+        HRESULT ( STDMETHODCALLTYPE *CreateSharedHandle )( 
+            ID3D12Device9 * This,
+            _In_  ID3D12DeviceChild *pObject,
+            _In_opt_  const SECURITY_ATTRIBUTES *pAttributes,
+            DWORD Access,
+            _In_opt_  LPCWSTR Name,
+            _Out_  HANDLE *pHandle);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, OpenSharedHandle)
+        HRESULT ( STDMETHODCALLTYPE *OpenSharedHandle )( 
+            ID3D12Device9 * This,
+            _In_  HANDLE NTHandle,
+            REFIID riid,
+            _COM_Outptr_opt_  void **ppvObj);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, OpenSharedHandleByName)
+        HRESULT ( STDMETHODCALLTYPE *OpenSharedHandleByName )( 
+            ID3D12Device9 * This,
+            _In_  LPCWSTR Name,
+            DWORD Access,
+            /* [annotation][out] */ 
+            _Out_  HANDLE *pNTHandle);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, MakeResident)
+        HRESULT ( STDMETHODCALLTYPE *MakeResident )( 
+            ID3D12Device9 * This,
+            UINT NumObjects,
+            _In_reads_(NumObjects)  ID3D12Pageable *const *ppObjects);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, Evict)
+        HRESULT ( STDMETHODCALLTYPE *Evict )( 
+            ID3D12Device9 * This,
+            UINT NumObjects,
+            _In_reads_(NumObjects)  ID3D12Pageable *const *ppObjects);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CreateFence)
+        HRESULT ( STDMETHODCALLTYPE *CreateFence )( 
+            ID3D12Device9 * This,
+            UINT64 InitialValue,
+            D3D12_FENCE_FLAGS Flags,
+            REFIID riid,
+            _COM_Outptr_  void **ppFence);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, GetDeviceRemovedReason)
+        HRESULT ( STDMETHODCALLTYPE *GetDeviceRemovedReason )( 
+            ID3D12Device9 * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, GetCopyableFootprints)
+        void ( STDMETHODCALLTYPE *GetCopyableFootprints )( 
+            ID3D12Device9 * This,
+            _In_  const D3D12_RESOURCE_DESC *pResourceDesc,
+            _In_range_(0,D3D12_REQ_SUBRESOURCES)  UINT FirstSubresource,
+            _In_range_(0,D3D12_REQ_SUBRESOURCES-FirstSubresource)  UINT NumSubresources,
+            UINT64 BaseOffset,
+            _Out_writes_opt_(NumSubresources)  D3D12_PLACED_SUBRESOURCE_FOOTPRINT *pLayouts,
+            _Out_writes_opt_(NumSubresources)  UINT *pNumRows,
+            _Out_writes_opt_(NumSubresources)  UINT64 *pRowSizeInBytes,
+            _Out_opt_  UINT64 *pTotalBytes);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CreateQueryHeap)
+        HRESULT ( STDMETHODCALLTYPE *CreateQueryHeap )( 
+            ID3D12Device9 * This,
+            _In_  const D3D12_QUERY_HEAP_DESC *pDesc,
+            REFIID riid,
+            _COM_Outptr_opt_  void **ppvHeap);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, SetStablePowerState)
+        HRESULT ( STDMETHODCALLTYPE *SetStablePowerState )( 
+            ID3D12Device9 * This,
+            BOOL Enable);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CreateCommandSignature)
+        HRESULT ( STDMETHODCALLTYPE *CreateCommandSignature )( 
+            ID3D12Device9 * This,
+            _In_  const D3D12_COMMAND_SIGNATURE_DESC *pDesc,
+            _In_opt_  ID3D12RootSignature *pRootSignature,
+            REFIID riid,
+            _COM_Outptr_opt_  void **ppvCommandSignature);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, GetResourceTiling)
+        void ( STDMETHODCALLTYPE *GetResourceTiling )( 
+            ID3D12Device9 * This,
+            _In_  ID3D12Resource *pTiledResource,
+            _Out_opt_  UINT *pNumTilesForEntireResource,
+            _Out_opt_  D3D12_PACKED_MIP_INFO *pPackedMipDesc,
+            _Out_opt_  D3D12_TILE_SHAPE *pStandardTileShapeForNonPackedMips,
+            _Inout_opt_  UINT *pNumSubresourceTilings,
+            _In_  UINT FirstSubresourceTilingToGet,
+            _Out_writes_(*pNumSubresourceTilings)  D3D12_SUBRESOURCE_TILING *pSubresourceTilingsForNonPackedMips);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, GetAdapterLuid)
+#if !defined(_WIN32)
+        LUID ( STDMETHODCALLTYPE *GetAdapterLuid )( 
+            ID3D12Device9 * This);
+        
+#else
+        LUID *( STDMETHODCALLTYPE *GetAdapterLuid )( 
+            ID3D12Device9 * This,
+            LUID * RetVal);
+        
+#endif
+        
+        DECLSPEC_XFGVIRT(ID3D12Device1, CreatePipelineLibrary)
+        HRESULT ( STDMETHODCALLTYPE *CreatePipelineLibrary )( 
+            ID3D12Device9 * This,
+            _In_reads_(BlobLength)  const void *pLibraryBlob,
+            SIZE_T BlobLength,
+            REFIID riid,
+            _COM_Outptr_  void **ppPipelineLibrary);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device1, SetEventOnMultipleFenceCompletion)
+        HRESULT ( STDMETHODCALLTYPE *SetEventOnMultipleFenceCompletion )( 
+            ID3D12Device9 * This,
+            _In_reads_(NumFences)  ID3D12Fence *const *ppFences,
+            _In_reads_(NumFences)  const UINT64 *pFenceValues,
+            UINT NumFences,
+            D3D12_MULTIPLE_FENCE_WAIT_FLAGS Flags,
+            HANDLE hEvent);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device1, SetResidencyPriority)
+        HRESULT ( STDMETHODCALLTYPE *SetResidencyPriority )( 
+            ID3D12Device9 * This,
+            UINT NumObjects,
+            _In_reads_(NumObjects)  ID3D12Pageable *const *ppObjects,
+            _In_reads_(NumObjects)  const D3D12_RESIDENCY_PRIORITY *pPriorities);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device2, CreatePipelineState)
+        HRESULT ( STDMETHODCALLTYPE *CreatePipelineState )( 
+            ID3D12Device9 * This,
+            const D3D12_PIPELINE_STATE_STREAM_DESC *pDesc,
+            REFIID riid,
+            _COM_Outptr_  void **ppPipelineState);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device3, OpenExistingHeapFromAddress)
+        HRESULT ( STDMETHODCALLTYPE *OpenExistingHeapFromAddress )( 
+            ID3D12Device9 * This,
+            _In_  const void *pAddress,
+            REFIID riid,
+            _COM_Outptr_  void **ppvHeap);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device3, OpenExistingHeapFromFileMapping)
+        HRESULT ( STDMETHODCALLTYPE *OpenExistingHeapFromFileMapping )( 
+            ID3D12Device9 * This,
+            _In_  HANDLE hFileMapping,
+            REFIID riid,
+            _COM_Outptr_  void **ppvHeap);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device3, EnqueueMakeResident)
+        HRESULT ( STDMETHODCALLTYPE *EnqueueMakeResident )( 
+            ID3D12Device9 * This,
+            D3D12_RESIDENCY_FLAGS Flags,
+            UINT NumObjects,
+            _In_reads_(NumObjects)  ID3D12Pageable *const *ppObjects,
+            _In_  ID3D12Fence *pFenceToSignal,
+            UINT64 FenceValueToSignal);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device4, CreateCommandList1)
+        HRESULT ( STDMETHODCALLTYPE *CreateCommandList1 )( 
+            ID3D12Device9 * This,
+            _In_  UINT nodeMask,
+            _In_  D3D12_COMMAND_LIST_TYPE type,
+            _In_  D3D12_COMMAND_LIST_FLAGS flags,
+            REFIID riid,
+            _COM_Outptr_  void **ppCommandList);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device4, CreateProtectedResourceSession)
+        HRESULT ( STDMETHODCALLTYPE *CreateProtectedResourceSession )( 
+            ID3D12Device9 * This,
+            _In_  const D3D12_PROTECTED_RESOURCE_SESSION_DESC *pDesc,
+            _In_  REFIID riid,
+            _COM_Outptr_  void **ppSession);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device4, CreateCommittedResource1)
+        HRESULT ( STDMETHODCALLTYPE *CreateCommittedResource1 )( 
+            ID3D12Device9 * This,
+            _In_  const D3D12_HEAP_PROPERTIES *pHeapProperties,
+            D3D12_HEAP_FLAGS HeapFlags,
+            _In_  const D3D12_RESOURCE_DESC *pDesc,
+            D3D12_RESOURCE_STATES InitialResourceState,
+            _In_opt_  const D3D12_CLEAR_VALUE *pOptimizedClearValue,
+            _In_opt_  ID3D12ProtectedResourceSession *pProtectedSession,
+            REFIID riidResource,
+            _COM_Outptr_opt_  void **ppvResource);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device4, CreateHeap1)
+        HRESULT ( STDMETHODCALLTYPE *CreateHeap1 )( 
+            ID3D12Device9 * This,
+            _In_  const D3D12_HEAP_DESC *pDesc,
+            _In_opt_  ID3D12ProtectedResourceSession *pProtectedSession,
+            REFIID riid,
+            _COM_Outptr_opt_  void **ppvHeap);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device4, CreateReservedResource1)
+        HRESULT ( STDMETHODCALLTYPE *CreateReservedResource1 )( 
+            ID3D12Device9 * This,
+            _In_  const D3D12_RESOURCE_DESC *pDesc,
+            D3D12_RESOURCE_STATES InitialState,
+            _In_opt_  const D3D12_CLEAR_VALUE *pOptimizedClearValue,
+            _In_opt_  ID3D12ProtectedResourceSession *pProtectedSession,
+            REFIID riid,
+            _COM_Outptr_opt_  void **ppvResource);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device4, GetResourceAllocationInfo1)
+#if !defined(_WIN32)
+        D3D12_RESOURCE_ALLOCATION_INFO ( STDMETHODCALLTYPE *GetResourceAllocationInfo1 )( 
+            ID3D12Device9 * This,
+            UINT visibleMask,
+            UINT numResourceDescs,
+            _In_reads_(numResourceDescs)  const D3D12_RESOURCE_DESC *pResourceDescs,
+            _Out_writes_opt_(numResourceDescs)  D3D12_RESOURCE_ALLOCATION_INFO1 *pResourceAllocationInfo1);
+        
+#else
+        D3D12_RESOURCE_ALLOCATION_INFO *( STDMETHODCALLTYPE *GetResourceAllocationInfo1 )( 
+            ID3D12Device9 * This,
+            D3D12_RESOURCE_ALLOCATION_INFO * RetVal,
+            UINT visibleMask,
+            UINT numResourceDescs,
+            _In_reads_(numResourceDescs)  const D3D12_RESOURCE_DESC *pResourceDescs,
+            _Out_writes_opt_(numResourceDescs)  D3D12_RESOURCE_ALLOCATION_INFO1 *pResourceAllocationInfo1);
+        
+#endif
+        
+        DECLSPEC_XFGVIRT(ID3D12Device5, CreateLifetimeTracker)
+        HRESULT ( STDMETHODCALLTYPE *CreateLifetimeTracker )( 
+            ID3D12Device9 * This,
+            _In_  ID3D12LifetimeOwner *pOwner,
+            REFIID riid,
+            _COM_Outptr_  void **ppvTracker);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device5, RemoveDevice)
+        void ( STDMETHODCALLTYPE *RemoveDevice )( 
+            ID3D12Device9 * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device5, EnumerateMetaCommands)
+        HRESULT ( STDMETHODCALLTYPE *EnumerateMetaCommands )( 
+            ID3D12Device9 * This,
+            _Inout_  UINT *pNumMetaCommands,
+            _Out_writes_opt_(*pNumMetaCommands)  D3D12_META_COMMAND_DESC *pDescs);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device5, EnumerateMetaCommandParameters)
+        HRESULT ( STDMETHODCALLTYPE *EnumerateMetaCommandParameters )( 
+            ID3D12Device9 * This,
+            _In_  REFGUID CommandId,
+            _In_  D3D12_META_COMMAND_PARAMETER_STAGE Stage,
+            _Out_opt_  UINT *pTotalStructureSizeInBytes,
+            _Inout_  UINT *pParameterCount,
+            _Out_writes_opt_(*pParameterCount)  D3D12_META_COMMAND_PARAMETER_DESC *pParameterDescs);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device5, CreateMetaCommand)
+        HRESULT ( STDMETHODCALLTYPE *CreateMetaCommand )( 
+            ID3D12Device9 * This,
+            _In_  REFGUID CommandId,
+            _In_  UINT NodeMask,
+            _In_reads_bytes_opt_(CreationParametersDataSizeInBytes)  const void *pCreationParametersData,
+            _In_  SIZE_T CreationParametersDataSizeInBytes,
+            REFIID riid,
+            _COM_Outptr_  void **ppMetaCommand);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device5, CreateStateObject)
+        HRESULT ( STDMETHODCALLTYPE *CreateStateObject )( 
+            ID3D12Device9 * This,
+            const D3D12_STATE_OBJECT_DESC *pDesc,
+            REFIID riid,
+            _COM_Outptr_  void **ppStateObject);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device5, GetRaytracingAccelerationStructurePrebuildInfo)
+        void ( STDMETHODCALLTYPE *GetRaytracingAccelerationStructurePrebuildInfo )( 
+            ID3D12Device9 * This,
+            _In_  const D3D12_BUILD_RAYTRACING_ACCELERATION_STRUCTURE_INPUTS *pDesc,
+            _Out_  D3D12_RAYTRACING_ACCELERATION_STRUCTURE_PREBUILD_INFO *pInfo);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device5, CheckDriverMatchingIdentifier)
+        D3D12_DRIVER_MATCHING_IDENTIFIER_STATUS ( STDMETHODCALLTYPE *CheckDriverMatchingIdentifier )( 
+            ID3D12Device9 * This,
+            _In_  D3D12_SERIALIZED_DATA_TYPE SerializedDataType,
+            _In_  const D3D12_SERIALIZED_DATA_DRIVER_MATCHING_IDENTIFIER *pIdentifierToCheck);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device6, SetBackgroundProcessingMode)
+        HRESULT ( STDMETHODCALLTYPE *SetBackgroundProcessingMode )( 
+            ID3D12Device9 * This,
+            D3D12_BACKGROUND_PROCESSING_MODE Mode,
+            D3D12_MEASUREMENTS_ACTION MeasurementsAction,
+            _In_opt_  HANDLE hEventToSignalUponCompletion,
+            _Out_opt_  BOOL *pbFurtherMeasurementsDesired);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device7, AddToStateObject)
+        HRESULT ( STDMETHODCALLTYPE *AddToStateObject )( 
+            ID3D12Device9 * This,
+            const D3D12_STATE_OBJECT_DESC *pAddition,
+            ID3D12StateObject *pStateObjectToGrowFrom,
+            REFIID riid,
+            _COM_Outptr_  void **ppNewStateObject);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device7, CreateProtectedResourceSession1)
+        HRESULT ( STDMETHODCALLTYPE *CreateProtectedResourceSession1 )( 
+            ID3D12Device9 * This,
+            _In_  const D3D12_PROTECTED_RESOURCE_SESSION_DESC1 *pDesc,
+            _In_  REFIID riid,
+            _COM_Outptr_  void **ppSession);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device8, GetResourceAllocationInfo2)
+#if !defined(_WIN32)
+        D3D12_RESOURCE_ALLOCATION_INFO ( STDMETHODCALLTYPE *GetResourceAllocationInfo2 )( 
+            ID3D12Device9 * This,
+            UINT visibleMask,
+            UINT numResourceDescs,
+            _In_reads_(numResourceDescs)  const D3D12_RESOURCE_DESC1 *pResourceDescs,
+            _Out_writes_opt_(numResourceDescs)  D3D12_RESOURCE_ALLOCATION_INFO1 *pResourceAllocationInfo1);
+        
+#else
+        D3D12_RESOURCE_ALLOCATION_INFO *( STDMETHODCALLTYPE *GetResourceAllocationInfo2 )( 
+            ID3D12Device9 * This,
+            D3D12_RESOURCE_ALLOCATION_INFO * RetVal,
+            UINT visibleMask,
+            UINT numResourceDescs,
+            _In_reads_(numResourceDescs)  const D3D12_RESOURCE_DESC1 *pResourceDescs,
+            _Out_writes_opt_(numResourceDescs)  D3D12_RESOURCE_ALLOCATION_INFO1 *pResourceAllocationInfo1);
+        
+#endif
+        
+        DECLSPEC_XFGVIRT(ID3D12Device8, CreateCommittedResource2)
+        HRESULT ( STDMETHODCALLTYPE *CreateCommittedResource2 )( 
+            ID3D12Device9 * This,
+            _In_  const D3D12_HEAP_PROPERTIES *pHeapProperties,
+            D3D12_HEAP_FLAGS HeapFlags,
+            _In_  const D3D12_RESOURCE_DESC1 *pDesc,
+            D3D12_RESOURCE_STATES InitialResourceState,
+            _In_opt_  const D3D12_CLEAR_VALUE *pOptimizedClearValue,
+            _In_opt_  ID3D12ProtectedResourceSession *pProtectedSession,
+            REFIID riidResource,
+            _COM_Outptr_opt_  void **ppvResource);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device8, CreatePlacedResource1)
+        HRESULT ( STDMETHODCALLTYPE *CreatePlacedResource1 )( 
+            ID3D12Device9 * This,
+            _In_  ID3D12Heap *pHeap,
+            UINT64 HeapOffset,
+            _In_  const D3D12_RESOURCE_DESC1 *pDesc,
+            D3D12_RESOURCE_STATES InitialState,
+            _In_opt_  const D3D12_CLEAR_VALUE *pOptimizedClearValue,
+            REFIID riid,
+            _COM_Outptr_opt_  void **ppvResource);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device8, CreateSamplerFeedbackUnorderedAccessView)
+        void ( STDMETHODCALLTYPE *CreateSamplerFeedbackUnorderedAccessView )( 
+            ID3D12Device9 * This,
+            _In_opt_  ID3D12Resource *pTargetedResource,
+            _In_opt_  ID3D12Resource *pFeedbackResource,
+            _In_  D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device8, GetCopyableFootprints1)
+        void ( STDMETHODCALLTYPE *GetCopyableFootprints1 )( 
+            ID3D12Device9 * This,
+            _In_  const D3D12_RESOURCE_DESC1 *pResourceDesc,
+            _In_range_(0,D3D12_REQ_SUBRESOURCES)  UINT FirstSubresource,
+            _In_range_(0,D3D12_REQ_SUBRESOURCES-FirstSubresource)  UINT NumSubresources,
+            UINT64 BaseOffset,
+            _Out_writes_opt_(NumSubresources)  D3D12_PLACED_SUBRESOURCE_FOOTPRINT *pLayouts,
+            _Out_writes_opt_(NumSubresources)  UINT *pNumRows,
+            _Out_writes_opt_(NumSubresources)  UINT64 *pRowSizeInBytes,
+            _Out_opt_  UINT64 *pTotalBytes);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device9, CreateShaderCacheSession)
+        HRESULT ( STDMETHODCALLTYPE *CreateShaderCacheSession )( 
+            ID3D12Device9 * This,
+            _In_  const D3D12_SHADER_CACHE_SESSION_DESC *pDesc,
+            REFIID riid,
+            _COM_Outptr_opt_  void **ppvSession);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device9, ShaderCacheControl)
+        HRESULT ( STDMETHODCALLTYPE *ShaderCacheControl )( 
+            ID3D12Device9 * This,
+            D3D12_SHADER_CACHE_KIND_FLAGS Kinds,
+            D3D12_SHADER_CACHE_CONTROL_FLAGS Control);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device9, CreateCommandQueue1)
+        HRESULT ( STDMETHODCALLTYPE *CreateCommandQueue1 )( 
+            ID3D12Device9 * This,
+            _In_  const D3D12_COMMAND_QUEUE_DESC *pDesc,
+            REFIID CreatorID,
+            REFIID riid,
+            _COM_Outptr_  void **ppCommandQueue);
+        
+        END_INTERFACE
+    } ID3D12Device9Vtbl;
+
+    interface ID3D12Device9
+    {
+        CONST_VTBL struct ID3D12Device9Vtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define ID3D12Device9_QueryInterface(This,riid,ppvObject)	\
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define ID3D12Device9_AddRef(This)	\
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define ID3D12Device9_Release(This)	\
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#define ID3D12Device9_GetPrivateData(This,guid,pDataSize,pData)	\
+    ( (This)->lpVtbl -> GetPrivateData(This,guid,pDataSize,pData) ) 
+
+#define ID3D12Device9_SetPrivateData(This,guid,DataSize,pData)	\
+    ( (This)->lpVtbl -> SetPrivateData(This,guid,DataSize,pData) ) 
+
+#define ID3D12Device9_SetPrivateDataInterface(This,guid,pData)	\
+    ( (This)->lpVtbl -> SetPrivateDataInterface(This,guid,pData) ) 
+
+#define ID3D12Device9_SetName(This,Name)	\
+    ( (This)->lpVtbl -> SetName(This,Name) ) 
+
+
+#define ID3D12Device9_GetNodeCount(This)	\
+    ( (This)->lpVtbl -> GetNodeCount(This) ) 
+
+#define ID3D12Device9_CreateCommandQueue(This,pDesc,riid,ppCommandQueue)	\
+    ( (This)->lpVtbl -> CreateCommandQueue(This,pDesc,riid,ppCommandQueue) ) 
+
+#define ID3D12Device9_CreateCommandAllocator(This,type,riid,ppCommandAllocator)	\
+    ( (This)->lpVtbl -> CreateCommandAllocator(This,type,riid,ppCommandAllocator) ) 
+
+#define ID3D12Device9_CreateGraphicsPipelineState(This,pDesc,riid,ppPipelineState)	\
+    ( (This)->lpVtbl -> CreateGraphicsPipelineState(This,pDesc,riid,ppPipelineState) ) 
+
+#define ID3D12Device9_CreateComputePipelineState(This,pDesc,riid,ppPipelineState)	\
+    ( (This)->lpVtbl -> CreateComputePipelineState(This,pDesc,riid,ppPipelineState) ) 
+
+#define ID3D12Device9_CreateCommandList(This,nodeMask,type,pCommandAllocator,pInitialState,riid,ppCommandList)	\
+    ( (This)->lpVtbl -> CreateCommandList(This,nodeMask,type,pCommandAllocator,pInitialState,riid,ppCommandList) ) 
+
+#define ID3D12Device9_CheckFeatureSupport(This,Feature,pFeatureSupportData,FeatureSupportDataSize)	\
+    ( (This)->lpVtbl -> CheckFeatureSupport(This,Feature,pFeatureSupportData,FeatureSupportDataSize) ) 
+
+#define ID3D12Device9_CreateDescriptorHeap(This,pDescriptorHeapDesc,riid,ppvHeap)	\
+    ( (This)->lpVtbl -> CreateDescriptorHeap(This,pDescriptorHeapDesc,riid,ppvHeap) ) 
+
+#define ID3D12Device9_GetDescriptorHandleIncrementSize(This,DescriptorHeapType)	\
+    ( (This)->lpVtbl -> GetDescriptorHandleIncrementSize(This,DescriptorHeapType) ) 
+
+#define ID3D12Device9_CreateRootSignature(This,nodeMask,pBlobWithRootSignature,blobLengthInBytes,riid,ppvRootSignature)	\
+    ( (This)->lpVtbl -> CreateRootSignature(This,nodeMask,pBlobWithRootSignature,blobLengthInBytes,riid,ppvRootSignature) ) 
+
+#define ID3D12Device9_CreateConstantBufferView(This,pDesc,DestDescriptor)	\
+    ( (This)->lpVtbl -> CreateConstantBufferView(This,pDesc,DestDescriptor) ) 
+
+#define ID3D12Device9_CreateShaderResourceView(This,pResource,pDesc,DestDescriptor)	\
+    ( (This)->lpVtbl -> CreateShaderResourceView(This,pResource,pDesc,DestDescriptor) ) 
+
+#define ID3D12Device9_CreateUnorderedAccessView(This,pResource,pCounterResource,pDesc,DestDescriptor)	\
+    ( (This)->lpVtbl -> CreateUnorderedAccessView(This,pResource,pCounterResource,pDesc,DestDescriptor) ) 
+
+#define ID3D12Device9_CreateRenderTargetView(This,pResource,pDesc,DestDescriptor)	\
+    ( (This)->lpVtbl -> CreateRenderTargetView(This,pResource,pDesc,DestDescriptor) ) 
+
+#define ID3D12Device9_CreateDepthStencilView(This,pResource,pDesc,DestDescriptor)	\
+    ( (This)->lpVtbl -> CreateDepthStencilView(This,pResource,pDesc,DestDescriptor) ) 
+
+#define ID3D12Device9_CreateSampler(This,pDesc,DestDescriptor)	\
+    ( (This)->lpVtbl -> CreateSampler(This,pDesc,DestDescriptor) ) 
+
+#define ID3D12Device9_CopyDescriptors(This,NumDestDescriptorRanges,pDestDescriptorRangeStarts,pDestDescriptorRangeSizes,NumSrcDescriptorRanges,pSrcDescriptorRangeStarts,pSrcDescriptorRangeSizes,DescriptorHeapsType)	\
+    ( (This)->lpVtbl -> CopyDescriptors(This,NumDestDescriptorRanges,pDestDescriptorRangeStarts,pDestDescriptorRangeSizes,NumSrcDescriptorRanges,pSrcDescriptorRangeStarts,pSrcDescriptorRangeSizes,DescriptorHeapsType) ) 
+
+#define ID3D12Device9_CopyDescriptorsSimple(This,NumDescriptors,DestDescriptorRangeStart,SrcDescriptorRangeStart,DescriptorHeapsType)	\
+    ( (This)->lpVtbl -> CopyDescriptorsSimple(This,NumDescriptors,DestDescriptorRangeStart,SrcDescriptorRangeStart,DescriptorHeapsType) ) 
+#if !defined(_WIN32)
+
+#define ID3D12Device9_GetResourceAllocationInfo(This,visibleMask,numResourceDescs,pResourceDescs)	\
+    ( (This)->lpVtbl -> GetResourceAllocationInfo(This,visibleMask,numResourceDescs,pResourceDescs) ) 
+#else
+#define ID3D12Device9_GetResourceAllocationInfo(This,RetVal,visibleMask,numResourceDescs,pResourceDescs)	\
+    ( (This)->lpVtbl -> GetResourceAllocationInfo(This,RetVal,visibleMask,numResourceDescs,pResourceDescs) ) 
+#endif
+#if !defined(_WIN32)
+
+#define ID3D12Device9_GetCustomHeapProperties(This,nodeMask,heapType)	\
+    ( (This)->lpVtbl -> GetCustomHeapProperties(This,nodeMask,heapType) ) 
+#else
+#define ID3D12Device9_GetCustomHeapProperties(This,RetVal,nodeMask,heapType)	\
+    ( (This)->lpVtbl -> GetCustomHeapProperties(This,RetVal,nodeMask,heapType) ) 
+#endif
+
+#define ID3D12Device9_CreateCommittedResource(This,pHeapProperties,HeapFlags,pDesc,InitialResourceState,pOptimizedClearValue,riidResource,ppvResource)	\
+    ( (This)->lpVtbl -> CreateCommittedResource(This,pHeapProperties,HeapFlags,pDesc,InitialResourceState,pOptimizedClearValue,riidResource,ppvResource) ) 
+
+#define ID3D12Device9_CreateHeap(This,pDesc,riid,ppvHeap)	\
+    ( (This)->lpVtbl -> CreateHeap(This,pDesc,riid,ppvHeap) ) 
+
+#define ID3D12Device9_CreatePlacedResource(This,pHeap,HeapOffset,pDesc,InitialState,pOptimizedClearValue,riid,ppvResource)	\
+    ( (This)->lpVtbl -> CreatePlacedResource(This,pHeap,HeapOffset,pDesc,InitialState,pOptimizedClearValue,riid,ppvResource) ) 
+
+#define ID3D12Device9_CreateReservedResource(This,pDesc,InitialState,pOptimizedClearValue,riid,ppvResource)	\
+    ( (This)->lpVtbl -> CreateReservedResource(This,pDesc,InitialState,pOptimizedClearValue,riid,ppvResource) ) 
+
+#define ID3D12Device9_CreateSharedHandle(This,pObject,pAttributes,Access,Name,pHandle)	\
+    ( (This)->lpVtbl -> CreateSharedHandle(This,pObject,pAttributes,Access,Name,pHandle) ) 
+
+#define ID3D12Device9_OpenSharedHandle(This,NTHandle,riid,ppvObj)	\
+    ( (This)->lpVtbl -> OpenSharedHandle(This,NTHandle,riid,ppvObj) ) 
+
+#define ID3D12Device9_OpenSharedHandleByName(This,Name,Access,pNTHandle)	\
+    ( (This)->lpVtbl -> OpenSharedHandleByName(This,Name,Access,pNTHandle) ) 
+
+#define ID3D12Device9_MakeResident(This,NumObjects,ppObjects)	\
+    ( (This)->lpVtbl -> MakeResident(This,NumObjects,ppObjects) ) 
+
+#define ID3D12Device9_Evict(This,NumObjects,ppObjects)	\
+    ( (This)->lpVtbl -> Evict(This,NumObjects,ppObjects) ) 
+
+#define ID3D12Device9_CreateFence(This,InitialValue,Flags,riid,ppFence)	\
+    ( (This)->lpVtbl -> CreateFence(This,InitialValue,Flags,riid,ppFence) ) 
+
+#define ID3D12Device9_GetDeviceRemovedReason(This)	\
+    ( (This)->lpVtbl -> GetDeviceRemovedReason(This) ) 
+
+#define ID3D12Device9_GetCopyableFootprints(This,pResourceDesc,FirstSubresource,NumSubresources,BaseOffset,pLayouts,pNumRows,pRowSizeInBytes,pTotalBytes)	\
+    ( (This)->lpVtbl -> GetCopyableFootprints(This,pResourceDesc,FirstSubresource,NumSubresources,BaseOffset,pLayouts,pNumRows,pRowSizeInBytes,pTotalBytes) ) 
+
+#define ID3D12Device9_CreateQueryHeap(This,pDesc,riid,ppvHeap)	\
+    ( (This)->lpVtbl -> CreateQueryHeap(This,pDesc,riid,ppvHeap) ) 
+
+#define ID3D12Device9_SetStablePowerState(This,Enable)	\
+    ( (This)->lpVtbl -> SetStablePowerState(This,Enable) ) 
+
+#define ID3D12Device9_CreateCommandSignature(This,pDesc,pRootSignature,riid,ppvCommandSignature)	\
+    ( (This)->lpVtbl -> CreateCommandSignature(This,pDesc,pRootSignature,riid,ppvCommandSignature) ) 
+
+#define ID3D12Device9_GetResourceTiling(This,pTiledResource,pNumTilesForEntireResource,pPackedMipDesc,pStandardTileShapeForNonPackedMips,pNumSubresourceTilings,FirstSubresourceTilingToGet,pSubresourceTilingsForNonPackedMips)	\
+    ( (This)->lpVtbl -> GetResourceTiling(This,pTiledResource,pNumTilesForEntireResource,pPackedMipDesc,pStandardTileShapeForNonPackedMips,pNumSubresourceTilings,FirstSubresourceTilingToGet,pSubresourceTilingsForNonPackedMips) ) 
+#if !defined(_WIN32)
+
+#define ID3D12Device9_GetAdapterLuid(This)	\
+    ( (This)->lpVtbl -> GetAdapterLuid(This) ) 
+#else
+#define ID3D12Device9_GetAdapterLuid(This,RetVal)	\
+    ( (This)->lpVtbl -> GetAdapterLuid(This,RetVal) ) 
+#endif
+
+
+#define ID3D12Device9_CreatePipelineLibrary(This,pLibraryBlob,BlobLength,riid,ppPipelineLibrary)	\
+    ( (This)->lpVtbl -> CreatePipelineLibrary(This,pLibraryBlob,BlobLength,riid,ppPipelineLibrary) ) 
+
+#define ID3D12Device9_SetEventOnMultipleFenceCompletion(This,ppFences,pFenceValues,NumFences,Flags,hEvent)	\
+    ( (This)->lpVtbl -> SetEventOnMultipleFenceCompletion(This,ppFences,pFenceValues,NumFences,Flags,hEvent) ) 
+
+#define ID3D12Device9_SetResidencyPriority(This,NumObjects,ppObjects,pPriorities)	\
+    ( (This)->lpVtbl -> SetResidencyPriority(This,NumObjects,ppObjects,pPriorities) ) 
+
+
+#define ID3D12Device9_CreatePipelineState(This,pDesc,riid,ppPipelineState)	\
+    ( (This)->lpVtbl -> CreatePipelineState(This,pDesc,riid,ppPipelineState) ) 
+
+
+#define ID3D12Device9_OpenExistingHeapFromAddress(This,pAddress,riid,ppvHeap)	\
+    ( (This)->lpVtbl -> OpenExistingHeapFromAddress(This,pAddress,riid,ppvHeap) ) 
+
+#define ID3D12Device9_OpenExistingHeapFromFileMapping(This,hFileMapping,riid,ppvHeap)	\
+    ( (This)->lpVtbl -> OpenExistingHeapFromFileMapping(This,hFileMapping,riid,ppvHeap) ) 
+
+#define ID3D12Device9_EnqueueMakeResident(This,Flags,NumObjects,ppObjects,pFenceToSignal,FenceValueToSignal)	\
+    ( (This)->lpVtbl -> EnqueueMakeResident(This,Flags,NumObjects,ppObjects,pFenceToSignal,FenceValueToSignal) ) 
+
+
+#define ID3D12Device9_CreateCommandList1(This,nodeMask,type,flags,riid,ppCommandList)	\
+    ( (This)->lpVtbl -> CreateCommandList1(This,nodeMask,type,flags,riid,ppCommandList) ) 
+
+#define ID3D12Device9_CreateProtectedResourceSession(This,pDesc,riid,ppSession)	\
+    ( (This)->lpVtbl -> CreateProtectedResourceSession(This,pDesc,riid,ppSession) ) 
+
+#define ID3D12Device9_CreateCommittedResource1(This,pHeapProperties,HeapFlags,pDesc,InitialResourceState,pOptimizedClearValue,pProtectedSession,riidResource,ppvResource)	\
+    ( (This)->lpVtbl -> CreateCommittedResource1(This,pHeapProperties,HeapFlags,pDesc,InitialResourceState,pOptimizedClearValue,pProtectedSession,riidResource,ppvResource) ) 
+
+#define ID3D12Device9_CreateHeap1(This,pDesc,pProtectedSession,riid,ppvHeap)	\
+    ( (This)->lpVtbl -> CreateHeap1(This,pDesc,pProtectedSession,riid,ppvHeap) ) 
+
+#define ID3D12Device9_CreateReservedResource1(This,pDesc,InitialState,pOptimizedClearValue,pProtectedSession,riid,ppvResource)	\
+    ( (This)->lpVtbl -> CreateReservedResource1(This,pDesc,InitialState,pOptimizedClearValue,pProtectedSession,riid,ppvResource) ) 
+#if !defined(_WIN32)
+
+#define ID3D12Device9_GetResourceAllocationInfo1(This,visibleMask,numResourceDescs,pResourceDescs,pResourceAllocationInfo1)	\
+    ( (This)->lpVtbl -> GetResourceAllocationInfo1(This,visibleMask,numResourceDescs,pResourceDescs,pResourceAllocationInfo1) ) 
+#else
+#define ID3D12Device9_GetResourceAllocationInfo1(This,RetVal,visibleMask,numResourceDescs,pResourceDescs,pResourceAllocationInfo1)	\
+    ( (This)->lpVtbl -> GetResourceAllocationInfo1(This,RetVal,visibleMask,numResourceDescs,pResourceDescs,pResourceAllocationInfo1) ) 
+#endif
+
+
+#define ID3D12Device9_CreateLifetimeTracker(This,pOwner,riid,ppvTracker)	\
+    ( (This)->lpVtbl -> CreateLifetimeTracker(This,pOwner,riid,ppvTracker) ) 
+
+#define ID3D12Device9_RemoveDevice(This)	\
+    ( (This)->lpVtbl -> RemoveDevice(This) ) 
+
+#define ID3D12Device9_EnumerateMetaCommands(This,pNumMetaCommands,pDescs)	\
+    ( (This)->lpVtbl -> EnumerateMetaCommands(This,pNumMetaCommands,pDescs) ) 
+
+#define ID3D12Device9_EnumerateMetaCommandParameters(This,CommandId,Stage,pTotalStructureSizeInBytes,pParameterCount,pParameterDescs)	\
+    ( (This)->lpVtbl -> EnumerateMetaCommandParameters(This,CommandId,Stage,pTotalStructureSizeInBytes,pParameterCount,pParameterDescs) ) 
+
+#define ID3D12Device9_CreateMetaCommand(This,CommandId,NodeMask,pCreationParametersData,CreationParametersDataSizeInBytes,riid,ppMetaCommand)	\
+    ( (This)->lpVtbl -> CreateMetaCommand(This,CommandId,NodeMask,pCreationParametersData,CreationParametersDataSizeInBytes,riid,ppMetaCommand) ) 
+
+#define ID3D12Device9_CreateStateObject(This,pDesc,riid,ppStateObject)	\
+    ( (This)->lpVtbl -> CreateStateObject(This,pDesc,riid,ppStateObject) ) 
+
+#define ID3D12Device9_GetRaytracingAccelerationStructurePrebuildInfo(This,pDesc,pInfo)	\
+    ( (This)->lpVtbl -> GetRaytracingAccelerationStructurePrebuildInfo(This,pDesc,pInfo) ) 
+
+#define ID3D12Device9_CheckDriverMatchingIdentifier(This,SerializedDataType,pIdentifierToCheck)	\
+    ( (This)->lpVtbl -> CheckDriverMatchingIdentifier(This,SerializedDataType,pIdentifierToCheck) ) 
+
+
+#define ID3D12Device9_SetBackgroundProcessingMode(This,Mode,MeasurementsAction,hEventToSignalUponCompletion,pbFurtherMeasurementsDesired)	\
+    ( (This)->lpVtbl -> SetBackgroundProcessingMode(This,Mode,MeasurementsAction,hEventToSignalUponCompletion,pbFurtherMeasurementsDesired) ) 
+
+
+#define ID3D12Device9_AddToStateObject(This,pAddition,pStateObjectToGrowFrom,riid,ppNewStateObject)	\
+    ( (This)->lpVtbl -> AddToStateObject(This,pAddition,pStateObjectToGrowFrom,riid,ppNewStateObject) ) 
+
+#define ID3D12Device9_CreateProtectedResourceSession1(This,pDesc,riid,ppSession)	\
+    ( (This)->lpVtbl -> CreateProtectedResourceSession1(This,pDesc,riid,ppSession) ) 
+
+#if !defined(_WIN32)
+
+#define ID3D12Device9_GetResourceAllocationInfo2(This,visibleMask,numResourceDescs,pResourceDescs,pResourceAllocationInfo1)	\
+    ( (This)->lpVtbl -> GetResourceAllocationInfo2(This,visibleMask,numResourceDescs,pResourceDescs,pResourceAllocationInfo1) ) 
+#else
+#define ID3D12Device9_GetResourceAllocationInfo2(This,RetVal,visibleMask,numResourceDescs,pResourceDescs,pResourceAllocationInfo1)	\
+    ( (This)->lpVtbl -> GetResourceAllocationInfo2(This,RetVal,visibleMask,numResourceDescs,pResourceDescs,pResourceAllocationInfo1) ) 
+#endif
+
+#define ID3D12Device9_CreateCommittedResource2(This,pHeapProperties,HeapFlags,pDesc,InitialResourceState,pOptimizedClearValue,pProtectedSession,riidResource,ppvResource)	\
+    ( (This)->lpVtbl -> CreateCommittedResource2(This,pHeapProperties,HeapFlags,pDesc,InitialResourceState,pOptimizedClearValue,pProtectedSession,riidResource,ppvResource) ) 
+
+#define ID3D12Device9_CreatePlacedResource1(This,pHeap,HeapOffset,pDesc,InitialState,pOptimizedClearValue,riid,ppvResource)	\
+    ( (This)->lpVtbl -> CreatePlacedResource1(This,pHeap,HeapOffset,pDesc,InitialState,pOptimizedClearValue,riid,ppvResource) ) 
+
+#define ID3D12Device9_CreateSamplerFeedbackUnorderedAccessView(This,pTargetedResource,pFeedbackResource,DestDescriptor)	\
+    ( (This)->lpVtbl -> CreateSamplerFeedbackUnorderedAccessView(This,pTargetedResource,pFeedbackResource,DestDescriptor) ) 
+
+#define ID3D12Device9_GetCopyableFootprints1(This,pResourceDesc,FirstSubresource,NumSubresources,BaseOffset,pLayouts,pNumRows,pRowSizeInBytes,pTotalBytes)	\
+    ( (This)->lpVtbl -> GetCopyableFootprints1(This,pResourceDesc,FirstSubresource,NumSubresources,BaseOffset,pLayouts,pNumRows,pRowSizeInBytes,pTotalBytes) ) 
+
+
+#define ID3D12Device9_CreateShaderCacheSession(This,pDesc,riid,ppvSession)	\
+    ( (This)->lpVtbl -> CreateShaderCacheSession(This,pDesc,riid,ppvSession) ) 
+
+#define ID3D12Device9_ShaderCacheControl(This,Kinds,Control)	\
+    ( (This)->lpVtbl -> ShaderCacheControl(This,Kinds,Control) ) 
+
+#define ID3D12Device9_CreateCommandQueue1(This,pDesc,CreatorID,riid,ppCommandQueue)	\
+    ( (This)->lpVtbl -> CreateCommandQueue1(This,pDesc,CreatorID,riid,ppCommandQueue) ) 
+
+#endif /* COBJMACROS */
+
+
+#endif 	/* C style interface */
+
+
+
+
+#endif 	/* __ID3D12Device9_INTERFACE_DEFINED__ */
+
+
+#ifndef __ID3D12Device10_INTERFACE_DEFINED__
+#define __ID3D12Device10_INTERFACE_DEFINED__
+
+/* interface ID3D12Device10 */
+/* [unique][local][object][uuid] */ 
+
+
+EXTERN_C const IID IID_ID3D12Device10;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("517f8718-aa66-49f9-b02b-a7ab89c06031")
+    ID3D12Device10 : public ID3D12Device9
+    {
+    public:
+        virtual HRESULT STDMETHODCALLTYPE CreateCommittedResource3( 
+            _In_  const D3D12_HEAP_PROPERTIES *pHeapProperties,
+            D3D12_HEAP_FLAGS HeapFlags,
+            _In_  const D3D12_RESOURCE_DESC1 *pDesc,
+            D3D12_BARRIER_LAYOUT InitialLayout,
+            _In_opt_  const D3D12_CLEAR_VALUE *pOptimizedClearValue,
+            _In_opt_  ID3D12ProtectedResourceSession *pProtectedSession,
+            UINT32 NumCastableFormats,
+            _In_opt_count_(NumCastableFormats)  DXGI_FORMAT *pCastableFormats,
+            REFIID riidResource,
+            _COM_Outptr_opt_  void **ppvResource) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE CreatePlacedResource2( 
+            _In_  ID3D12Heap *pHeap,
+            UINT64 HeapOffset,
+            _In_  const D3D12_RESOURCE_DESC1 *pDesc,
+            D3D12_BARRIER_LAYOUT InitialLayout,
+            _In_opt_  const D3D12_CLEAR_VALUE *pOptimizedClearValue,
+            UINT32 NumCastableFormats,
+            _In_opt_count_(NumCastableFormats)  DXGI_FORMAT *pCastableFormats,
+            REFIID riid,
+            _COM_Outptr_opt_  void **ppvResource) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE CreateReservedResource2( 
+            _In_  const D3D12_RESOURCE_DESC *pDesc,
+            D3D12_BARRIER_LAYOUT InitialLayout,
+            _In_opt_  const D3D12_CLEAR_VALUE *pOptimizedClearValue,
+            _In_opt_  ID3D12ProtectedResourceSession *pProtectedSession,
+            UINT32 NumCastableFormats,
+            _In_opt_count_(NumCastableFormats)  DXGI_FORMAT *pCastableFormats,
+            REFIID riid,
+            _COM_Outptr_opt_  void **ppvResource) = 0;
+        
+    };
+    
+    
+#else 	/* C style interface */
+
+    typedef struct ID3D12Device10Vtbl
+    {
+        BEGIN_INTERFACE
+        
+        DECLSPEC_XFGVIRT(IUnknown, QueryInterface)
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            ID3D12Device10 * This,
+            REFIID riid,
+            _COM_Outptr_  void **ppvObject);
+        
+        DECLSPEC_XFGVIRT(IUnknown, AddRef)
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            ID3D12Device10 * This);
+        
+        DECLSPEC_XFGVIRT(IUnknown, Release)
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            ID3D12Device10 * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, GetPrivateData)
+        HRESULT ( STDMETHODCALLTYPE *GetPrivateData )( 
+            ID3D12Device10 * This,
+            _In_  REFGUID guid,
+            _Inout_  UINT *pDataSize,
+            _Out_writes_bytes_opt_( *pDataSize )  void *pData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, SetPrivateData)
+        HRESULT ( STDMETHODCALLTYPE *SetPrivateData )( 
+            ID3D12Device10 * This,
+            _In_  REFGUID guid,
+            _In_  UINT DataSize,
+            _In_reads_bytes_opt_( DataSize )  const void *pData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, SetPrivateDataInterface)
+        HRESULT ( STDMETHODCALLTYPE *SetPrivateDataInterface )( 
+            ID3D12Device10 * This,
+            _In_  REFGUID guid,
+            _In_opt_  const IUnknown *pData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, SetName)
+        HRESULT ( STDMETHODCALLTYPE *SetName )( 
+            ID3D12Device10 * This,
+            _In_z_  LPCWSTR Name);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, GetNodeCount)
+        UINT ( STDMETHODCALLTYPE *GetNodeCount )( 
+            ID3D12Device10 * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CreateCommandQueue)
+        HRESULT ( STDMETHODCALLTYPE *CreateCommandQueue )( 
+            ID3D12Device10 * This,
+            _In_  const D3D12_COMMAND_QUEUE_DESC *pDesc,
+            REFIID riid,
+            _COM_Outptr_  void **ppCommandQueue);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CreateCommandAllocator)
+        HRESULT ( STDMETHODCALLTYPE *CreateCommandAllocator )( 
+            ID3D12Device10 * This,
+            _In_  D3D12_COMMAND_LIST_TYPE type,
+            REFIID riid,
+            _COM_Outptr_  void **ppCommandAllocator);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CreateGraphicsPipelineState)
+        HRESULT ( STDMETHODCALLTYPE *CreateGraphicsPipelineState )( 
+            ID3D12Device10 * This,
+            _In_  const D3D12_GRAPHICS_PIPELINE_STATE_DESC *pDesc,
+            REFIID riid,
+            _COM_Outptr_  void **ppPipelineState);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CreateComputePipelineState)
+        HRESULT ( STDMETHODCALLTYPE *CreateComputePipelineState )( 
+            ID3D12Device10 * This,
+            _In_  const D3D12_COMPUTE_PIPELINE_STATE_DESC *pDesc,
+            REFIID riid,
+            _COM_Outptr_  void **ppPipelineState);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CreateCommandList)
+        HRESULT ( STDMETHODCALLTYPE *CreateCommandList )( 
+            ID3D12Device10 * This,
+            _In_  UINT nodeMask,
+            _In_  D3D12_COMMAND_LIST_TYPE type,
+            _In_  ID3D12CommandAllocator *pCommandAllocator,
+            _In_opt_  ID3D12PipelineState *pInitialState,
+            REFIID riid,
+            _COM_Outptr_  void **ppCommandList);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CheckFeatureSupport)
+        HRESULT ( STDMETHODCALLTYPE *CheckFeatureSupport )( 
+            ID3D12Device10 * This,
+            D3D12_FEATURE Feature,
+            _Inout_updates_bytes_(FeatureSupportDataSize)  void *pFeatureSupportData,
+            UINT FeatureSupportDataSize);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CreateDescriptorHeap)
+        HRESULT ( STDMETHODCALLTYPE *CreateDescriptorHeap )( 
+            ID3D12Device10 * This,
+            _In_  const D3D12_DESCRIPTOR_HEAP_DESC *pDescriptorHeapDesc,
+            REFIID riid,
+            _COM_Outptr_  void **ppvHeap);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, GetDescriptorHandleIncrementSize)
+        UINT ( STDMETHODCALLTYPE *GetDescriptorHandleIncrementSize )( 
+            ID3D12Device10 * This,
+            _In_  D3D12_DESCRIPTOR_HEAP_TYPE DescriptorHeapType);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CreateRootSignature)
+        HRESULT ( STDMETHODCALLTYPE *CreateRootSignature )( 
+            ID3D12Device10 * This,
+            _In_  UINT nodeMask,
+            _In_reads_(blobLengthInBytes)  const void *pBlobWithRootSignature,
+            _In_  SIZE_T blobLengthInBytes,
+            REFIID riid,
+            _COM_Outptr_  void **ppvRootSignature);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CreateConstantBufferView)
+        void ( STDMETHODCALLTYPE *CreateConstantBufferView )( 
+            ID3D12Device10 * This,
+            _In_opt_  const D3D12_CONSTANT_BUFFER_VIEW_DESC *pDesc,
+            _In_  D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CreateShaderResourceView)
+        void ( STDMETHODCALLTYPE *CreateShaderResourceView )( 
+            ID3D12Device10 * This,
+            _In_opt_  ID3D12Resource *pResource,
+            _In_opt_  const D3D12_SHADER_RESOURCE_VIEW_DESC *pDesc,
+            _In_  D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CreateUnorderedAccessView)
+        void ( STDMETHODCALLTYPE *CreateUnorderedAccessView )( 
+            ID3D12Device10 * This,
+            _In_opt_  ID3D12Resource *pResource,
+            _In_opt_  ID3D12Resource *pCounterResource,
+            _In_opt_  const D3D12_UNORDERED_ACCESS_VIEW_DESC *pDesc,
+            _In_  D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CreateRenderTargetView)
+        void ( STDMETHODCALLTYPE *CreateRenderTargetView )( 
+            ID3D12Device10 * This,
+            _In_opt_  ID3D12Resource *pResource,
+            _In_opt_  const D3D12_RENDER_TARGET_VIEW_DESC *pDesc,
+            _In_  D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CreateDepthStencilView)
+        void ( STDMETHODCALLTYPE *CreateDepthStencilView )( 
+            ID3D12Device10 * This,
+            _In_opt_  ID3D12Resource *pResource,
+            _In_opt_  const D3D12_DEPTH_STENCIL_VIEW_DESC *pDesc,
+            _In_  D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CreateSampler)
+        void ( STDMETHODCALLTYPE *CreateSampler )( 
+            ID3D12Device10 * This,
+            _In_  const D3D12_SAMPLER_DESC *pDesc,
+            _In_  D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CopyDescriptors)
+        void ( STDMETHODCALLTYPE *CopyDescriptors )( 
+            ID3D12Device10 * This,
+            _In_  UINT NumDestDescriptorRanges,
+            _In_reads_(NumDestDescriptorRanges)  const D3D12_CPU_DESCRIPTOR_HANDLE *pDestDescriptorRangeStarts,
+            _In_reads_opt_(NumDestDescriptorRanges)  const UINT *pDestDescriptorRangeSizes,
+            _In_  UINT NumSrcDescriptorRanges,
+            _In_reads_(NumSrcDescriptorRanges)  const D3D12_CPU_DESCRIPTOR_HANDLE *pSrcDescriptorRangeStarts,
+            _In_reads_opt_(NumSrcDescriptorRanges)  const UINT *pSrcDescriptorRangeSizes,
+            _In_  D3D12_DESCRIPTOR_HEAP_TYPE DescriptorHeapsType);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CopyDescriptorsSimple)
+        void ( STDMETHODCALLTYPE *CopyDescriptorsSimple )( 
+            ID3D12Device10 * This,
+            _In_  UINT NumDescriptors,
+            _In_  D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptorRangeStart,
+            _In_  D3D12_CPU_DESCRIPTOR_HANDLE SrcDescriptorRangeStart,
+            _In_  D3D12_DESCRIPTOR_HEAP_TYPE DescriptorHeapsType);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, GetResourceAllocationInfo)
+#if !defined(_WIN32)
+        D3D12_RESOURCE_ALLOCATION_INFO ( STDMETHODCALLTYPE *GetResourceAllocationInfo )( 
+            ID3D12Device10 * This,
+            _In_  UINT visibleMask,
+            _In_  UINT numResourceDescs,
+            _In_reads_(numResourceDescs)  const D3D12_RESOURCE_DESC *pResourceDescs);
+        
+#else
+        D3D12_RESOURCE_ALLOCATION_INFO *( STDMETHODCALLTYPE *GetResourceAllocationInfo )( 
+            ID3D12Device10 * This,
+            D3D12_RESOURCE_ALLOCATION_INFO * RetVal,
+            _In_  UINT visibleMask,
+            _In_  UINT numResourceDescs,
+            _In_reads_(numResourceDescs)  const D3D12_RESOURCE_DESC *pResourceDescs);
+        
+#endif
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, GetCustomHeapProperties)
+#if !defined(_WIN32)
+        D3D12_HEAP_PROPERTIES ( STDMETHODCALLTYPE *GetCustomHeapProperties )( 
+            ID3D12Device10 * This,
+            _In_  UINT nodeMask,
+            D3D12_HEAP_TYPE heapType);
+        
+#else
+        D3D12_HEAP_PROPERTIES *( STDMETHODCALLTYPE *GetCustomHeapProperties )( 
+            ID3D12Device10 * This,
+            D3D12_HEAP_PROPERTIES * RetVal,
+            _In_  UINT nodeMask,
+            D3D12_HEAP_TYPE heapType);
+        
+#endif
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CreateCommittedResource)
+        HRESULT ( STDMETHODCALLTYPE *CreateCommittedResource )( 
+            ID3D12Device10 * This,
+            _In_  const D3D12_HEAP_PROPERTIES *pHeapProperties,
+            D3D12_HEAP_FLAGS HeapFlags,
+            _In_  const D3D12_RESOURCE_DESC *pDesc,
+            D3D12_RESOURCE_STATES InitialResourceState,
+            _In_opt_  const D3D12_CLEAR_VALUE *pOptimizedClearValue,
+            REFIID riidResource,
+            _COM_Outptr_opt_  void **ppvResource);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CreateHeap)
+        HRESULT ( STDMETHODCALLTYPE *CreateHeap )( 
+            ID3D12Device10 * This,
+            _In_  const D3D12_HEAP_DESC *pDesc,
+            REFIID riid,
+            _COM_Outptr_opt_  void **ppvHeap);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CreatePlacedResource)
+        HRESULT ( STDMETHODCALLTYPE *CreatePlacedResource )( 
+            ID3D12Device10 * This,
+            _In_  ID3D12Heap *pHeap,
+            UINT64 HeapOffset,
+            _In_  const D3D12_RESOURCE_DESC *pDesc,
+            D3D12_RESOURCE_STATES InitialState,
+            _In_opt_  const D3D12_CLEAR_VALUE *pOptimizedClearValue,
+            REFIID riid,
+            _COM_Outptr_opt_  void **ppvResource);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CreateReservedResource)
+        HRESULT ( STDMETHODCALLTYPE *CreateReservedResource )( 
+            ID3D12Device10 * This,
+            _In_  const D3D12_RESOURCE_DESC *pDesc,
+            D3D12_RESOURCE_STATES InitialState,
+            _In_opt_  const D3D12_CLEAR_VALUE *pOptimizedClearValue,
+            REFIID riid,
+            _COM_Outptr_opt_  void **ppvResource);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CreateSharedHandle)
+        HRESULT ( STDMETHODCALLTYPE *CreateSharedHandle )( 
+            ID3D12Device10 * This,
+            _In_  ID3D12DeviceChild *pObject,
+            _In_opt_  const SECURITY_ATTRIBUTES *pAttributes,
+            DWORD Access,
+            _In_opt_  LPCWSTR Name,
+            _Out_  HANDLE *pHandle);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, OpenSharedHandle)
+        HRESULT ( STDMETHODCALLTYPE *OpenSharedHandle )( 
+            ID3D12Device10 * This,
+            _In_  HANDLE NTHandle,
+            REFIID riid,
+            _COM_Outptr_opt_  void **ppvObj);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, OpenSharedHandleByName)
+        HRESULT ( STDMETHODCALLTYPE *OpenSharedHandleByName )( 
+            ID3D12Device10 * This,
+            _In_  LPCWSTR Name,
+            DWORD Access,
+            /* [annotation][out] */ 
+            _Out_  HANDLE *pNTHandle);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, MakeResident)
+        HRESULT ( STDMETHODCALLTYPE *MakeResident )( 
+            ID3D12Device10 * This,
+            UINT NumObjects,
+            _In_reads_(NumObjects)  ID3D12Pageable *const *ppObjects);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, Evict)
+        HRESULT ( STDMETHODCALLTYPE *Evict )( 
+            ID3D12Device10 * This,
+            UINT NumObjects,
+            _In_reads_(NumObjects)  ID3D12Pageable *const *ppObjects);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CreateFence)
+        HRESULT ( STDMETHODCALLTYPE *CreateFence )( 
+            ID3D12Device10 * This,
+            UINT64 InitialValue,
+            D3D12_FENCE_FLAGS Flags,
+            REFIID riid,
+            _COM_Outptr_  void **ppFence);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, GetDeviceRemovedReason)
+        HRESULT ( STDMETHODCALLTYPE *GetDeviceRemovedReason )( 
+            ID3D12Device10 * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, GetCopyableFootprints)
+        void ( STDMETHODCALLTYPE *GetCopyableFootprints )( 
+            ID3D12Device10 * This,
+            _In_  const D3D12_RESOURCE_DESC *pResourceDesc,
+            _In_range_(0,D3D12_REQ_SUBRESOURCES)  UINT FirstSubresource,
+            _In_range_(0,D3D12_REQ_SUBRESOURCES-FirstSubresource)  UINT NumSubresources,
+            UINT64 BaseOffset,
+            _Out_writes_opt_(NumSubresources)  D3D12_PLACED_SUBRESOURCE_FOOTPRINT *pLayouts,
+            _Out_writes_opt_(NumSubresources)  UINT *pNumRows,
+            _Out_writes_opt_(NumSubresources)  UINT64 *pRowSizeInBytes,
+            _Out_opt_  UINT64 *pTotalBytes);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CreateQueryHeap)
+        HRESULT ( STDMETHODCALLTYPE *CreateQueryHeap )( 
+            ID3D12Device10 * This,
+            _In_  const D3D12_QUERY_HEAP_DESC *pDesc,
+            REFIID riid,
+            _COM_Outptr_opt_  void **ppvHeap);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, SetStablePowerState)
+        HRESULT ( STDMETHODCALLTYPE *SetStablePowerState )( 
+            ID3D12Device10 * This,
+            BOOL Enable);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CreateCommandSignature)
+        HRESULT ( STDMETHODCALLTYPE *CreateCommandSignature )( 
+            ID3D12Device10 * This,
+            _In_  const D3D12_COMMAND_SIGNATURE_DESC *pDesc,
+            _In_opt_  ID3D12RootSignature *pRootSignature,
+            REFIID riid,
+            _COM_Outptr_opt_  void **ppvCommandSignature);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, GetResourceTiling)
+        void ( STDMETHODCALLTYPE *GetResourceTiling )( 
+            ID3D12Device10 * This,
+            _In_  ID3D12Resource *pTiledResource,
+            _Out_opt_  UINT *pNumTilesForEntireResource,
+            _Out_opt_  D3D12_PACKED_MIP_INFO *pPackedMipDesc,
+            _Out_opt_  D3D12_TILE_SHAPE *pStandardTileShapeForNonPackedMips,
+            _Inout_opt_  UINT *pNumSubresourceTilings,
+            _In_  UINT FirstSubresourceTilingToGet,
+            _Out_writes_(*pNumSubresourceTilings)  D3D12_SUBRESOURCE_TILING *pSubresourceTilingsForNonPackedMips);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, GetAdapterLuid)
+#if !defined(_WIN32)
+        LUID ( STDMETHODCALLTYPE *GetAdapterLuid )( 
+            ID3D12Device10 * This);
+        
+#else
+        LUID *( STDMETHODCALLTYPE *GetAdapterLuid )( 
+            ID3D12Device10 * This,
+            LUID * RetVal);
+        
+#endif
+        
+        DECLSPEC_XFGVIRT(ID3D12Device1, CreatePipelineLibrary)
+        HRESULT ( STDMETHODCALLTYPE *CreatePipelineLibrary )( 
+            ID3D12Device10 * This,
+            _In_reads_(BlobLength)  const void *pLibraryBlob,
+            SIZE_T BlobLength,
+            REFIID riid,
+            _COM_Outptr_  void **ppPipelineLibrary);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device1, SetEventOnMultipleFenceCompletion)
+        HRESULT ( STDMETHODCALLTYPE *SetEventOnMultipleFenceCompletion )( 
+            ID3D12Device10 * This,
+            _In_reads_(NumFences)  ID3D12Fence *const *ppFences,
+            _In_reads_(NumFences)  const UINT64 *pFenceValues,
+            UINT NumFences,
+            D3D12_MULTIPLE_FENCE_WAIT_FLAGS Flags,
+            HANDLE hEvent);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device1, SetResidencyPriority)
+        HRESULT ( STDMETHODCALLTYPE *SetResidencyPriority )( 
+            ID3D12Device10 * This,
+            UINT NumObjects,
+            _In_reads_(NumObjects)  ID3D12Pageable *const *ppObjects,
+            _In_reads_(NumObjects)  const D3D12_RESIDENCY_PRIORITY *pPriorities);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device2, CreatePipelineState)
+        HRESULT ( STDMETHODCALLTYPE *CreatePipelineState )( 
+            ID3D12Device10 * This,
+            const D3D12_PIPELINE_STATE_STREAM_DESC *pDesc,
+            REFIID riid,
+            _COM_Outptr_  void **ppPipelineState);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device3, OpenExistingHeapFromAddress)
+        HRESULT ( STDMETHODCALLTYPE *OpenExistingHeapFromAddress )( 
+            ID3D12Device10 * This,
+            _In_  const void *pAddress,
+            REFIID riid,
+            _COM_Outptr_  void **ppvHeap);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device3, OpenExistingHeapFromFileMapping)
+        HRESULT ( STDMETHODCALLTYPE *OpenExistingHeapFromFileMapping )( 
+            ID3D12Device10 * This,
+            _In_  HANDLE hFileMapping,
+            REFIID riid,
+            _COM_Outptr_  void **ppvHeap);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device3, EnqueueMakeResident)
+        HRESULT ( STDMETHODCALLTYPE *EnqueueMakeResident )( 
+            ID3D12Device10 * This,
+            D3D12_RESIDENCY_FLAGS Flags,
+            UINT NumObjects,
+            _In_reads_(NumObjects)  ID3D12Pageable *const *ppObjects,
+            _In_  ID3D12Fence *pFenceToSignal,
+            UINT64 FenceValueToSignal);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device4, CreateCommandList1)
+        HRESULT ( STDMETHODCALLTYPE *CreateCommandList1 )( 
+            ID3D12Device10 * This,
+            _In_  UINT nodeMask,
+            _In_  D3D12_COMMAND_LIST_TYPE type,
+            _In_  D3D12_COMMAND_LIST_FLAGS flags,
+            REFIID riid,
+            _COM_Outptr_  void **ppCommandList);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device4, CreateProtectedResourceSession)
+        HRESULT ( STDMETHODCALLTYPE *CreateProtectedResourceSession )( 
+            ID3D12Device10 * This,
+            _In_  const D3D12_PROTECTED_RESOURCE_SESSION_DESC *pDesc,
+            _In_  REFIID riid,
+            _COM_Outptr_  void **ppSession);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device4, CreateCommittedResource1)
+        HRESULT ( STDMETHODCALLTYPE *CreateCommittedResource1 )( 
+            ID3D12Device10 * This,
+            _In_  const D3D12_HEAP_PROPERTIES *pHeapProperties,
+            D3D12_HEAP_FLAGS HeapFlags,
+            _In_  const D3D12_RESOURCE_DESC *pDesc,
+            D3D12_RESOURCE_STATES InitialResourceState,
+            _In_opt_  const D3D12_CLEAR_VALUE *pOptimizedClearValue,
+            _In_opt_  ID3D12ProtectedResourceSession *pProtectedSession,
+            REFIID riidResource,
+            _COM_Outptr_opt_  void **ppvResource);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device4, CreateHeap1)
+        HRESULT ( STDMETHODCALLTYPE *CreateHeap1 )( 
+            ID3D12Device10 * This,
+            _In_  const D3D12_HEAP_DESC *pDesc,
+            _In_opt_  ID3D12ProtectedResourceSession *pProtectedSession,
+            REFIID riid,
+            _COM_Outptr_opt_  void **ppvHeap);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device4, CreateReservedResource1)
+        HRESULT ( STDMETHODCALLTYPE *CreateReservedResource1 )( 
+            ID3D12Device10 * This,
+            _In_  const D3D12_RESOURCE_DESC *pDesc,
+            D3D12_RESOURCE_STATES InitialState,
+            _In_opt_  const D3D12_CLEAR_VALUE *pOptimizedClearValue,
+            _In_opt_  ID3D12ProtectedResourceSession *pProtectedSession,
+            REFIID riid,
+            _COM_Outptr_opt_  void **ppvResource);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device4, GetResourceAllocationInfo1)
+#if !defined(_WIN32)
+        D3D12_RESOURCE_ALLOCATION_INFO ( STDMETHODCALLTYPE *GetResourceAllocationInfo1 )( 
+            ID3D12Device10 * This,
+            UINT visibleMask,
+            UINT numResourceDescs,
+            _In_reads_(numResourceDescs)  const D3D12_RESOURCE_DESC *pResourceDescs,
+            _Out_writes_opt_(numResourceDescs)  D3D12_RESOURCE_ALLOCATION_INFO1 *pResourceAllocationInfo1);
+        
+#else
+        D3D12_RESOURCE_ALLOCATION_INFO *( STDMETHODCALLTYPE *GetResourceAllocationInfo1 )( 
+            ID3D12Device10 * This,
+            D3D12_RESOURCE_ALLOCATION_INFO * RetVal,
+            UINT visibleMask,
+            UINT numResourceDescs,
+            _In_reads_(numResourceDescs)  const D3D12_RESOURCE_DESC *pResourceDescs,
+            _Out_writes_opt_(numResourceDescs)  D3D12_RESOURCE_ALLOCATION_INFO1 *pResourceAllocationInfo1);
+        
+#endif
+        
+        DECLSPEC_XFGVIRT(ID3D12Device5, CreateLifetimeTracker)
+        HRESULT ( STDMETHODCALLTYPE *CreateLifetimeTracker )( 
+            ID3D12Device10 * This,
+            _In_  ID3D12LifetimeOwner *pOwner,
+            REFIID riid,
+            _COM_Outptr_  void **ppvTracker);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device5, RemoveDevice)
+        void ( STDMETHODCALLTYPE *RemoveDevice )( 
+            ID3D12Device10 * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device5, EnumerateMetaCommands)
+        HRESULT ( STDMETHODCALLTYPE *EnumerateMetaCommands )( 
+            ID3D12Device10 * This,
+            _Inout_  UINT *pNumMetaCommands,
+            _Out_writes_opt_(*pNumMetaCommands)  D3D12_META_COMMAND_DESC *pDescs);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device5, EnumerateMetaCommandParameters)
+        HRESULT ( STDMETHODCALLTYPE *EnumerateMetaCommandParameters )( 
+            ID3D12Device10 * This,
+            _In_  REFGUID CommandId,
+            _In_  D3D12_META_COMMAND_PARAMETER_STAGE Stage,
+            _Out_opt_  UINT *pTotalStructureSizeInBytes,
+            _Inout_  UINT *pParameterCount,
+            _Out_writes_opt_(*pParameterCount)  D3D12_META_COMMAND_PARAMETER_DESC *pParameterDescs);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device5, CreateMetaCommand)
+        HRESULT ( STDMETHODCALLTYPE *CreateMetaCommand )( 
+            ID3D12Device10 * This,
+            _In_  REFGUID CommandId,
+            _In_  UINT NodeMask,
+            _In_reads_bytes_opt_(CreationParametersDataSizeInBytes)  const void *pCreationParametersData,
+            _In_  SIZE_T CreationParametersDataSizeInBytes,
+            REFIID riid,
+            _COM_Outptr_  void **ppMetaCommand);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device5, CreateStateObject)
+        HRESULT ( STDMETHODCALLTYPE *CreateStateObject )( 
+            ID3D12Device10 * This,
+            const D3D12_STATE_OBJECT_DESC *pDesc,
+            REFIID riid,
+            _COM_Outptr_  void **ppStateObject);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device5, GetRaytracingAccelerationStructurePrebuildInfo)
+        void ( STDMETHODCALLTYPE *GetRaytracingAccelerationStructurePrebuildInfo )( 
+            ID3D12Device10 * This,
+            _In_  const D3D12_BUILD_RAYTRACING_ACCELERATION_STRUCTURE_INPUTS *pDesc,
+            _Out_  D3D12_RAYTRACING_ACCELERATION_STRUCTURE_PREBUILD_INFO *pInfo);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device5, CheckDriverMatchingIdentifier)
+        D3D12_DRIVER_MATCHING_IDENTIFIER_STATUS ( STDMETHODCALLTYPE *CheckDriverMatchingIdentifier )( 
+            ID3D12Device10 * This,
+            _In_  D3D12_SERIALIZED_DATA_TYPE SerializedDataType,
+            _In_  const D3D12_SERIALIZED_DATA_DRIVER_MATCHING_IDENTIFIER *pIdentifierToCheck);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device6, SetBackgroundProcessingMode)
+        HRESULT ( STDMETHODCALLTYPE *SetBackgroundProcessingMode )( 
+            ID3D12Device10 * This,
+            D3D12_BACKGROUND_PROCESSING_MODE Mode,
+            D3D12_MEASUREMENTS_ACTION MeasurementsAction,
+            _In_opt_  HANDLE hEventToSignalUponCompletion,
+            _Out_opt_  BOOL *pbFurtherMeasurementsDesired);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device7, AddToStateObject)
+        HRESULT ( STDMETHODCALLTYPE *AddToStateObject )( 
+            ID3D12Device10 * This,
+            const D3D12_STATE_OBJECT_DESC *pAddition,
+            ID3D12StateObject *pStateObjectToGrowFrom,
+            REFIID riid,
+            _COM_Outptr_  void **ppNewStateObject);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device7, CreateProtectedResourceSession1)
+        HRESULT ( STDMETHODCALLTYPE *CreateProtectedResourceSession1 )( 
+            ID3D12Device10 * This,
+            _In_  const D3D12_PROTECTED_RESOURCE_SESSION_DESC1 *pDesc,
+            _In_  REFIID riid,
+            _COM_Outptr_  void **ppSession);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device8, GetResourceAllocationInfo2)
+#if !defined(_WIN32)
+        D3D12_RESOURCE_ALLOCATION_INFO ( STDMETHODCALLTYPE *GetResourceAllocationInfo2 )( 
+            ID3D12Device10 * This,
+            UINT visibleMask,
+            UINT numResourceDescs,
+            _In_reads_(numResourceDescs)  const D3D12_RESOURCE_DESC1 *pResourceDescs,
+            _Out_writes_opt_(numResourceDescs)  D3D12_RESOURCE_ALLOCATION_INFO1 *pResourceAllocationInfo1);
+        
+#else
+        D3D12_RESOURCE_ALLOCATION_INFO *( STDMETHODCALLTYPE *GetResourceAllocationInfo2 )( 
+            ID3D12Device10 * This,
+            D3D12_RESOURCE_ALLOCATION_INFO * RetVal,
+            UINT visibleMask,
+            UINT numResourceDescs,
+            _In_reads_(numResourceDescs)  const D3D12_RESOURCE_DESC1 *pResourceDescs,
+            _Out_writes_opt_(numResourceDescs)  D3D12_RESOURCE_ALLOCATION_INFO1 *pResourceAllocationInfo1);
+        
+#endif
+        
+        DECLSPEC_XFGVIRT(ID3D12Device8, CreateCommittedResource2)
+        HRESULT ( STDMETHODCALLTYPE *CreateCommittedResource2 )( 
+            ID3D12Device10 * This,
+            _In_  const D3D12_HEAP_PROPERTIES *pHeapProperties,
+            D3D12_HEAP_FLAGS HeapFlags,
+            _In_  const D3D12_RESOURCE_DESC1 *pDesc,
+            D3D12_RESOURCE_STATES InitialResourceState,
+            _In_opt_  const D3D12_CLEAR_VALUE *pOptimizedClearValue,
+            _In_opt_  ID3D12ProtectedResourceSession *pProtectedSession,
+            REFIID riidResource,
+            _COM_Outptr_opt_  void **ppvResource);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device8, CreatePlacedResource1)
+        HRESULT ( STDMETHODCALLTYPE *CreatePlacedResource1 )( 
+            ID3D12Device10 * This,
+            _In_  ID3D12Heap *pHeap,
+            UINT64 HeapOffset,
+            _In_  const D3D12_RESOURCE_DESC1 *pDesc,
+            D3D12_RESOURCE_STATES InitialState,
+            _In_opt_  const D3D12_CLEAR_VALUE *pOptimizedClearValue,
+            REFIID riid,
+            _COM_Outptr_opt_  void **ppvResource);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device8, CreateSamplerFeedbackUnorderedAccessView)
+        void ( STDMETHODCALLTYPE *CreateSamplerFeedbackUnorderedAccessView )( 
+            ID3D12Device10 * This,
+            _In_opt_  ID3D12Resource *pTargetedResource,
+            _In_opt_  ID3D12Resource *pFeedbackResource,
+            _In_  D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device8, GetCopyableFootprints1)
+        void ( STDMETHODCALLTYPE *GetCopyableFootprints1 )( 
+            ID3D12Device10 * This,
+            _In_  const D3D12_RESOURCE_DESC1 *pResourceDesc,
+            _In_range_(0,D3D12_REQ_SUBRESOURCES)  UINT FirstSubresource,
+            _In_range_(0,D3D12_REQ_SUBRESOURCES-FirstSubresource)  UINT NumSubresources,
+            UINT64 BaseOffset,
+            _Out_writes_opt_(NumSubresources)  D3D12_PLACED_SUBRESOURCE_FOOTPRINT *pLayouts,
+            _Out_writes_opt_(NumSubresources)  UINT *pNumRows,
+            _Out_writes_opt_(NumSubresources)  UINT64 *pRowSizeInBytes,
+            _Out_opt_  UINT64 *pTotalBytes);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device9, CreateShaderCacheSession)
+        HRESULT ( STDMETHODCALLTYPE *CreateShaderCacheSession )( 
+            ID3D12Device10 * This,
+            _In_  const D3D12_SHADER_CACHE_SESSION_DESC *pDesc,
+            REFIID riid,
+            _COM_Outptr_opt_  void **ppvSession);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device9, ShaderCacheControl)
+        HRESULT ( STDMETHODCALLTYPE *ShaderCacheControl )( 
+            ID3D12Device10 * This,
+            D3D12_SHADER_CACHE_KIND_FLAGS Kinds,
+            D3D12_SHADER_CACHE_CONTROL_FLAGS Control);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device9, CreateCommandQueue1)
+        HRESULT ( STDMETHODCALLTYPE *CreateCommandQueue1 )( 
+            ID3D12Device10 * This,
+            _In_  const D3D12_COMMAND_QUEUE_DESC *pDesc,
+            REFIID CreatorID,
+            REFIID riid,
+            _COM_Outptr_  void **ppCommandQueue);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device10, CreateCommittedResource3)
+        HRESULT ( STDMETHODCALLTYPE *CreateCommittedResource3 )( 
+            ID3D12Device10 * This,
+            _In_  const D3D12_HEAP_PROPERTIES *pHeapProperties,
+            D3D12_HEAP_FLAGS HeapFlags,
+            _In_  const D3D12_RESOURCE_DESC1 *pDesc,
+            D3D12_BARRIER_LAYOUT InitialLayout,
+            _In_opt_  const D3D12_CLEAR_VALUE *pOptimizedClearValue,
+            _In_opt_  ID3D12ProtectedResourceSession *pProtectedSession,
+            UINT32 NumCastableFormats,
+            _In_opt_count_(NumCastableFormats)  DXGI_FORMAT *pCastableFormats,
+            REFIID riidResource,
+            _COM_Outptr_opt_  void **ppvResource);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device10, CreatePlacedResource2)
+        HRESULT ( STDMETHODCALLTYPE *CreatePlacedResource2 )( 
+            ID3D12Device10 * This,
+            _In_  ID3D12Heap *pHeap,
+            UINT64 HeapOffset,
+            _In_  const D3D12_RESOURCE_DESC1 *pDesc,
+            D3D12_BARRIER_LAYOUT InitialLayout,
+            _In_opt_  const D3D12_CLEAR_VALUE *pOptimizedClearValue,
+            UINT32 NumCastableFormats,
+            _In_opt_count_(NumCastableFormats)  DXGI_FORMAT *pCastableFormats,
+            REFIID riid,
+            _COM_Outptr_opt_  void **ppvResource);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device10, CreateReservedResource2)
+        HRESULT ( STDMETHODCALLTYPE *CreateReservedResource2 )( 
+            ID3D12Device10 * This,
+            _In_  const D3D12_RESOURCE_DESC *pDesc,
+            D3D12_BARRIER_LAYOUT InitialLayout,
+            _In_opt_  const D3D12_CLEAR_VALUE *pOptimizedClearValue,
+            _In_opt_  ID3D12ProtectedResourceSession *pProtectedSession,
+            UINT32 NumCastableFormats,
+            _In_opt_count_(NumCastableFormats)  DXGI_FORMAT *pCastableFormats,
+            REFIID riid,
+            _COM_Outptr_opt_  void **ppvResource);
+        
+        END_INTERFACE
+    } ID3D12Device10Vtbl;
+
+    interface ID3D12Device10
+    {
+        CONST_VTBL struct ID3D12Device10Vtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define ID3D12Device10_QueryInterface(This,riid,ppvObject)	\
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define ID3D12Device10_AddRef(This)	\
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define ID3D12Device10_Release(This)	\
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#define ID3D12Device10_GetPrivateData(This,guid,pDataSize,pData)	\
+    ( (This)->lpVtbl -> GetPrivateData(This,guid,pDataSize,pData) ) 
+
+#define ID3D12Device10_SetPrivateData(This,guid,DataSize,pData)	\
+    ( (This)->lpVtbl -> SetPrivateData(This,guid,DataSize,pData) ) 
+
+#define ID3D12Device10_SetPrivateDataInterface(This,guid,pData)	\
+    ( (This)->lpVtbl -> SetPrivateDataInterface(This,guid,pData) ) 
+
+#define ID3D12Device10_SetName(This,Name)	\
+    ( (This)->lpVtbl -> SetName(This,Name) ) 
+
+
+#define ID3D12Device10_GetNodeCount(This)	\
+    ( (This)->lpVtbl -> GetNodeCount(This) ) 
+
+#define ID3D12Device10_CreateCommandQueue(This,pDesc,riid,ppCommandQueue)	\
+    ( (This)->lpVtbl -> CreateCommandQueue(This,pDesc,riid,ppCommandQueue) ) 
+
+#define ID3D12Device10_CreateCommandAllocator(This,type,riid,ppCommandAllocator)	\
+    ( (This)->lpVtbl -> CreateCommandAllocator(This,type,riid,ppCommandAllocator) ) 
+
+#define ID3D12Device10_CreateGraphicsPipelineState(This,pDesc,riid,ppPipelineState)	\
+    ( (This)->lpVtbl -> CreateGraphicsPipelineState(This,pDesc,riid,ppPipelineState) ) 
+
+#define ID3D12Device10_CreateComputePipelineState(This,pDesc,riid,ppPipelineState)	\
+    ( (This)->lpVtbl -> CreateComputePipelineState(This,pDesc,riid,ppPipelineState) ) 
+
+#define ID3D12Device10_CreateCommandList(This,nodeMask,type,pCommandAllocator,pInitialState,riid,ppCommandList)	\
+    ( (This)->lpVtbl -> CreateCommandList(This,nodeMask,type,pCommandAllocator,pInitialState,riid,ppCommandList) ) 
+
+#define ID3D12Device10_CheckFeatureSupport(This,Feature,pFeatureSupportData,FeatureSupportDataSize)	\
+    ( (This)->lpVtbl -> CheckFeatureSupport(This,Feature,pFeatureSupportData,FeatureSupportDataSize) ) 
+
+#define ID3D12Device10_CreateDescriptorHeap(This,pDescriptorHeapDesc,riid,ppvHeap)	\
+    ( (This)->lpVtbl -> CreateDescriptorHeap(This,pDescriptorHeapDesc,riid,ppvHeap) ) 
+
+#define ID3D12Device10_GetDescriptorHandleIncrementSize(This,DescriptorHeapType)	\
+    ( (This)->lpVtbl -> GetDescriptorHandleIncrementSize(This,DescriptorHeapType) ) 
+
+#define ID3D12Device10_CreateRootSignature(This,nodeMask,pBlobWithRootSignature,blobLengthInBytes,riid,ppvRootSignature)	\
+    ( (This)->lpVtbl -> CreateRootSignature(This,nodeMask,pBlobWithRootSignature,blobLengthInBytes,riid,ppvRootSignature) ) 
+
+#define ID3D12Device10_CreateConstantBufferView(This,pDesc,DestDescriptor)	\
+    ( (This)->lpVtbl -> CreateConstantBufferView(This,pDesc,DestDescriptor) ) 
+
+#define ID3D12Device10_CreateShaderResourceView(This,pResource,pDesc,DestDescriptor)	\
+    ( (This)->lpVtbl -> CreateShaderResourceView(This,pResource,pDesc,DestDescriptor) ) 
+
+#define ID3D12Device10_CreateUnorderedAccessView(This,pResource,pCounterResource,pDesc,DestDescriptor)	\
+    ( (This)->lpVtbl -> CreateUnorderedAccessView(This,pResource,pCounterResource,pDesc,DestDescriptor) ) 
+
+#define ID3D12Device10_CreateRenderTargetView(This,pResource,pDesc,DestDescriptor)	\
+    ( (This)->lpVtbl -> CreateRenderTargetView(This,pResource,pDesc,DestDescriptor) ) 
+
+#define ID3D12Device10_CreateDepthStencilView(This,pResource,pDesc,DestDescriptor)	\
+    ( (This)->lpVtbl -> CreateDepthStencilView(This,pResource,pDesc,DestDescriptor) ) 
+
+#define ID3D12Device10_CreateSampler(This,pDesc,DestDescriptor)	\
+    ( (This)->lpVtbl -> CreateSampler(This,pDesc,DestDescriptor) ) 
+
+#define ID3D12Device10_CopyDescriptors(This,NumDestDescriptorRanges,pDestDescriptorRangeStarts,pDestDescriptorRangeSizes,NumSrcDescriptorRanges,pSrcDescriptorRangeStarts,pSrcDescriptorRangeSizes,DescriptorHeapsType)	\
+    ( (This)->lpVtbl -> CopyDescriptors(This,NumDestDescriptorRanges,pDestDescriptorRangeStarts,pDestDescriptorRangeSizes,NumSrcDescriptorRanges,pSrcDescriptorRangeStarts,pSrcDescriptorRangeSizes,DescriptorHeapsType) ) 
+
+#define ID3D12Device10_CopyDescriptorsSimple(This,NumDescriptors,DestDescriptorRangeStart,SrcDescriptorRangeStart,DescriptorHeapsType)	\
+    ( (This)->lpVtbl -> CopyDescriptorsSimple(This,NumDescriptors,DestDescriptorRangeStart,SrcDescriptorRangeStart,DescriptorHeapsType) ) 
+#if !defined(_WIN32)
+
+#define ID3D12Device10_GetResourceAllocationInfo(This,visibleMask,numResourceDescs,pResourceDescs)	\
+    ( (This)->lpVtbl -> GetResourceAllocationInfo(This,visibleMask,numResourceDescs,pResourceDescs) ) 
+#else
+#define ID3D12Device10_GetResourceAllocationInfo(This,RetVal,visibleMask,numResourceDescs,pResourceDescs)	\
+    ( (This)->lpVtbl -> GetResourceAllocationInfo(This,RetVal,visibleMask,numResourceDescs,pResourceDescs) ) 
+#endif
+#if !defined(_WIN32)
+
+#define ID3D12Device10_GetCustomHeapProperties(This,nodeMask,heapType)	\
+    ( (This)->lpVtbl -> GetCustomHeapProperties(This,nodeMask,heapType) ) 
+#else
+#define ID3D12Device10_GetCustomHeapProperties(This,RetVal,nodeMask,heapType)	\
+    ( (This)->lpVtbl -> GetCustomHeapProperties(This,RetVal,nodeMask,heapType) ) 
+#endif
+
+#define ID3D12Device10_CreateCommittedResource(This,pHeapProperties,HeapFlags,pDesc,InitialResourceState,pOptimizedClearValue,riidResource,ppvResource)	\
+    ( (This)->lpVtbl -> CreateCommittedResource(This,pHeapProperties,HeapFlags,pDesc,InitialResourceState,pOptimizedClearValue,riidResource,ppvResource) ) 
+
+#define ID3D12Device10_CreateHeap(This,pDesc,riid,ppvHeap)	\
+    ( (This)->lpVtbl -> CreateHeap(This,pDesc,riid,ppvHeap) ) 
+
+#define ID3D12Device10_CreatePlacedResource(This,pHeap,HeapOffset,pDesc,InitialState,pOptimizedClearValue,riid,ppvResource)	\
+    ( (This)->lpVtbl -> CreatePlacedResource(This,pHeap,HeapOffset,pDesc,InitialState,pOptimizedClearValue,riid,ppvResource) ) 
+
+#define ID3D12Device10_CreateReservedResource(This,pDesc,InitialState,pOptimizedClearValue,riid,ppvResource)	\
+    ( (This)->lpVtbl -> CreateReservedResource(This,pDesc,InitialState,pOptimizedClearValue,riid,ppvResource) ) 
+
+#define ID3D12Device10_CreateSharedHandle(This,pObject,pAttributes,Access,Name,pHandle)	\
+    ( (This)->lpVtbl -> CreateSharedHandle(This,pObject,pAttributes,Access,Name,pHandle) ) 
+
+#define ID3D12Device10_OpenSharedHandle(This,NTHandle,riid,ppvObj)	\
+    ( (This)->lpVtbl -> OpenSharedHandle(This,NTHandle,riid,ppvObj) ) 
+
+#define ID3D12Device10_OpenSharedHandleByName(This,Name,Access,pNTHandle)	\
+    ( (This)->lpVtbl -> OpenSharedHandleByName(This,Name,Access,pNTHandle) ) 
+
+#define ID3D12Device10_MakeResident(This,NumObjects,ppObjects)	\
+    ( (This)->lpVtbl -> MakeResident(This,NumObjects,ppObjects) ) 
+
+#define ID3D12Device10_Evict(This,NumObjects,ppObjects)	\
+    ( (This)->lpVtbl -> Evict(This,NumObjects,ppObjects) ) 
+
+#define ID3D12Device10_CreateFence(This,InitialValue,Flags,riid,ppFence)	\
+    ( (This)->lpVtbl -> CreateFence(This,InitialValue,Flags,riid,ppFence) ) 
+
+#define ID3D12Device10_GetDeviceRemovedReason(This)	\
+    ( (This)->lpVtbl -> GetDeviceRemovedReason(This) ) 
+
+#define ID3D12Device10_GetCopyableFootprints(This,pResourceDesc,FirstSubresource,NumSubresources,BaseOffset,pLayouts,pNumRows,pRowSizeInBytes,pTotalBytes)	\
+    ( (This)->lpVtbl -> GetCopyableFootprints(This,pResourceDesc,FirstSubresource,NumSubresources,BaseOffset,pLayouts,pNumRows,pRowSizeInBytes,pTotalBytes) ) 
+
+#define ID3D12Device10_CreateQueryHeap(This,pDesc,riid,ppvHeap)	\
+    ( (This)->lpVtbl -> CreateQueryHeap(This,pDesc,riid,ppvHeap) ) 
+
+#define ID3D12Device10_SetStablePowerState(This,Enable)	\
+    ( (This)->lpVtbl -> SetStablePowerState(This,Enable) ) 
+
+#define ID3D12Device10_CreateCommandSignature(This,pDesc,pRootSignature,riid,ppvCommandSignature)	\
+    ( (This)->lpVtbl -> CreateCommandSignature(This,pDesc,pRootSignature,riid,ppvCommandSignature) ) 
+
+#define ID3D12Device10_GetResourceTiling(This,pTiledResource,pNumTilesForEntireResource,pPackedMipDesc,pStandardTileShapeForNonPackedMips,pNumSubresourceTilings,FirstSubresourceTilingToGet,pSubresourceTilingsForNonPackedMips)	\
+    ( (This)->lpVtbl -> GetResourceTiling(This,pTiledResource,pNumTilesForEntireResource,pPackedMipDesc,pStandardTileShapeForNonPackedMips,pNumSubresourceTilings,FirstSubresourceTilingToGet,pSubresourceTilingsForNonPackedMips) ) 
+#if !defined(_WIN32)
+
+#define ID3D12Device10_GetAdapterLuid(This)	\
+    ( (This)->lpVtbl -> GetAdapterLuid(This) ) 
+#else
+#define ID3D12Device10_GetAdapterLuid(This,RetVal)	\
+    ( (This)->lpVtbl -> GetAdapterLuid(This,RetVal) ) 
+#endif
+
+
+#define ID3D12Device10_CreatePipelineLibrary(This,pLibraryBlob,BlobLength,riid,ppPipelineLibrary)	\
+    ( (This)->lpVtbl -> CreatePipelineLibrary(This,pLibraryBlob,BlobLength,riid,ppPipelineLibrary) ) 
+
+#define ID3D12Device10_SetEventOnMultipleFenceCompletion(This,ppFences,pFenceValues,NumFences,Flags,hEvent)	\
+    ( (This)->lpVtbl -> SetEventOnMultipleFenceCompletion(This,ppFences,pFenceValues,NumFences,Flags,hEvent) ) 
+
+#define ID3D12Device10_SetResidencyPriority(This,NumObjects,ppObjects,pPriorities)	\
+    ( (This)->lpVtbl -> SetResidencyPriority(This,NumObjects,ppObjects,pPriorities) ) 
+
+
+#define ID3D12Device10_CreatePipelineState(This,pDesc,riid,ppPipelineState)	\
+    ( (This)->lpVtbl -> CreatePipelineState(This,pDesc,riid,ppPipelineState) ) 
+
+
+#define ID3D12Device10_OpenExistingHeapFromAddress(This,pAddress,riid,ppvHeap)	\
+    ( (This)->lpVtbl -> OpenExistingHeapFromAddress(This,pAddress,riid,ppvHeap) ) 
+
+#define ID3D12Device10_OpenExistingHeapFromFileMapping(This,hFileMapping,riid,ppvHeap)	\
+    ( (This)->lpVtbl -> OpenExistingHeapFromFileMapping(This,hFileMapping,riid,ppvHeap) ) 
+
+#define ID3D12Device10_EnqueueMakeResident(This,Flags,NumObjects,ppObjects,pFenceToSignal,FenceValueToSignal)	\
+    ( (This)->lpVtbl -> EnqueueMakeResident(This,Flags,NumObjects,ppObjects,pFenceToSignal,FenceValueToSignal) ) 
+
+
+#define ID3D12Device10_CreateCommandList1(This,nodeMask,type,flags,riid,ppCommandList)	\
+    ( (This)->lpVtbl -> CreateCommandList1(This,nodeMask,type,flags,riid,ppCommandList) ) 
+
+#define ID3D12Device10_CreateProtectedResourceSession(This,pDesc,riid,ppSession)	\
+    ( (This)->lpVtbl -> CreateProtectedResourceSession(This,pDesc,riid,ppSession) ) 
+
+#define ID3D12Device10_CreateCommittedResource1(This,pHeapProperties,HeapFlags,pDesc,InitialResourceState,pOptimizedClearValue,pProtectedSession,riidResource,ppvResource)	\
+    ( (This)->lpVtbl -> CreateCommittedResource1(This,pHeapProperties,HeapFlags,pDesc,InitialResourceState,pOptimizedClearValue,pProtectedSession,riidResource,ppvResource) ) 
+
+#define ID3D12Device10_CreateHeap1(This,pDesc,pProtectedSession,riid,ppvHeap)	\
+    ( (This)->lpVtbl -> CreateHeap1(This,pDesc,pProtectedSession,riid,ppvHeap) ) 
+
+#define ID3D12Device10_CreateReservedResource1(This,pDesc,InitialState,pOptimizedClearValue,pProtectedSession,riid,ppvResource)	\
+    ( (This)->lpVtbl -> CreateReservedResource1(This,pDesc,InitialState,pOptimizedClearValue,pProtectedSession,riid,ppvResource) ) 
+#if !defined(_WIN32)
+
+#define ID3D12Device10_GetResourceAllocationInfo1(This,visibleMask,numResourceDescs,pResourceDescs,pResourceAllocationInfo1)	\
+    ( (This)->lpVtbl -> GetResourceAllocationInfo1(This,visibleMask,numResourceDescs,pResourceDescs,pResourceAllocationInfo1) ) 
+#else
+#define ID3D12Device10_GetResourceAllocationInfo1(This,RetVal,visibleMask,numResourceDescs,pResourceDescs,pResourceAllocationInfo1)	\
+    ( (This)->lpVtbl -> GetResourceAllocationInfo1(This,RetVal,visibleMask,numResourceDescs,pResourceDescs,pResourceAllocationInfo1) ) 
+#endif
+
+
+#define ID3D12Device10_CreateLifetimeTracker(This,pOwner,riid,ppvTracker)	\
+    ( (This)->lpVtbl -> CreateLifetimeTracker(This,pOwner,riid,ppvTracker) ) 
+
+#define ID3D12Device10_RemoveDevice(This)	\
+    ( (This)->lpVtbl -> RemoveDevice(This) ) 
+
+#define ID3D12Device10_EnumerateMetaCommands(This,pNumMetaCommands,pDescs)	\
+    ( (This)->lpVtbl -> EnumerateMetaCommands(This,pNumMetaCommands,pDescs) ) 
+
+#define ID3D12Device10_EnumerateMetaCommandParameters(This,CommandId,Stage,pTotalStructureSizeInBytes,pParameterCount,pParameterDescs)	\
+    ( (This)->lpVtbl -> EnumerateMetaCommandParameters(This,CommandId,Stage,pTotalStructureSizeInBytes,pParameterCount,pParameterDescs) ) 
+
+#define ID3D12Device10_CreateMetaCommand(This,CommandId,NodeMask,pCreationParametersData,CreationParametersDataSizeInBytes,riid,ppMetaCommand)	\
+    ( (This)->lpVtbl -> CreateMetaCommand(This,CommandId,NodeMask,pCreationParametersData,CreationParametersDataSizeInBytes,riid,ppMetaCommand) ) 
+
+#define ID3D12Device10_CreateStateObject(This,pDesc,riid,ppStateObject)	\
+    ( (This)->lpVtbl -> CreateStateObject(This,pDesc,riid,ppStateObject) ) 
+
+#define ID3D12Device10_GetRaytracingAccelerationStructurePrebuildInfo(This,pDesc,pInfo)	\
+    ( (This)->lpVtbl -> GetRaytracingAccelerationStructurePrebuildInfo(This,pDesc,pInfo) ) 
+
+#define ID3D12Device10_CheckDriverMatchingIdentifier(This,SerializedDataType,pIdentifierToCheck)	\
+    ( (This)->lpVtbl -> CheckDriverMatchingIdentifier(This,SerializedDataType,pIdentifierToCheck) ) 
+
+
+#define ID3D12Device10_SetBackgroundProcessingMode(This,Mode,MeasurementsAction,hEventToSignalUponCompletion,pbFurtherMeasurementsDesired)	\
+    ( (This)->lpVtbl -> SetBackgroundProcessingMode(This,Mode,MeasurementsAction,hEventToSignalUponCompletion,pbFurtherMeasurementsDesired) ) 
+
+
+#define ID3D12Device10_AddToStateObject(This,pAddition,pStateObjectToGrowFrom,riid,ppNewStateObject)	\
+    ( (This)->lpVtbl -> AddToStateObject(This,pAddition,pStateObjectToGrowFrom,riid,ppNewStateObject) ) 
+
+#define ID3D12Device10_CreateProtectedResourceSession1(This,pDesc,riid,ppSession)	\
+    ( (This)->lpVtbl -> CreateProtectedResourceSession1(This,pDesc,riid,ppSession) ) 
+
+#if !defined(_WIN32)
+
+#define ID3D12Device10_GetResourceAllocationInfo2(This,visibleMask,numResourceDescs,pResourceDescs,pResourceAllocationInfo1)	\
+    ( (This)->lpVtbl -> GetResourceAllocationInfo2(This,visibleMask,numResourceDescs,pResourceDescs,pResourceAllocationInfo1) ) 
+#else
+#define ID3D12Device10_GetResourceAllocationInfo2(This,RetVal,visibleMask,numResourceDescs,pResourceDescs,pResourceAllocationInfo1)	\
+    ( (This)->lpVtbl -> GetResourceAllocationInfo2(This,RetVal,visibleMask,numResourceDescs,pResourceDescs,pResourceAllocationInfo1) ) 
+#endif
+
+#define ID3D12Device10_CreateCommittedResource2(This,pHeapProperties,HeapFlags,pDesc,InitialResourceState,pOptimizedClearValue,pProtectedSession,riidResource,ppvResource)	\
+    ( (This)->lpVtbl -> CreateCommittedResource2(This,pHeapProperties,HeapFlags,pDesc,InitialResourceState,pOptimizedClearValue,pProtectedSession,riidResource,ppvResource) ) 
+
+#define ID3D12Device10_CreatePlacedResource1(This,pHeap,HeapOffset,pDesc,InitialState,pOptimizedClearValue,riid,ppvResource)	\
+    ( (This)->lpVtbl -> CreatePlacedResource1(This,pHeap,HeapOffset,pDesc,InitialState,pOptimizedClearValue,riid,ppvResource) ) 
+
+#define ID3D12Device10_CreateSamplerFeedbackUnorderedAccessView(This,pTargetedResource,pFeedbackResource,DestDescriptor)	\
+    ( (This)->lpVtbl -> CreateSamplerFeedbackUnorderedAccessView(This,pTargetedResource,pFeedbackResource,DestDescriptor) ) 
+
+#define ID3D12Device10_GetCopyableFootprints1(This,pResourceDesc,FirstSubresource,NumSubresources,BaseOffset,pLayouts,pNumRows,pRowSizeInBytes,pTotalBytes)	\
+    ( (This)->lpVtbl -> GetCopyableFootprints1(This,pResourceDesc,FirstSubresource,NumSubresources,BaseOffset,pLayouts,pNumRows,pRowSizeInBytes,pTotalBytes) ) 
+
+
+#define ID3D12Device10_CreateShaderCacheSession(This,pDesc,riid,ppvSession)	\
+    ( (This)->lpVtbl -> CreateShaderCacheSession(This,pDesc,riid,ppvSession) ) 
+
+#define ID3D12Device10_ShaderCacheControl(This,Kinds,Control)	\
+    ( (This)->lpVtbl -> ShaderCacheControl(This,Kinds,Control) ) 
+
+#define ID3D12Device10_CreateCommandQueue1(This,pDesc,CreatorID,riid,ppCommandQueue)	\
+    ( (This)->lpVtbl -> CreateCommandQueue1(This,pDesc,CreatorID,riid,ppCommandQueue) ) 
+
+
+#define ID3D12Device10_CreateCommittedResource3(This,pHeapProperties,HeapFlags,pDesc,InitialLayout,pOptimizedClearValue,pProtectedSession,NumCastableFormats,pCastableFormats,riidResource,ppvResource)	\
+    ( (This)->lpVtbl -> CreateCommittedResource3(This,pHeapProperties,HeapFlags,pDesc,InitialLayout,pOptimizedClearValue,pProtectedSession,NumCastableFormats,pCastableFormats,riidResource,ppvResource) ) 
+
+#define ID3D12Device10_CreatePlacedResource2(This,pHeap,HeapOffset,pDesc,InitialLayout,pOptimizedClearValue,NumCastableFormats,pCastableFormats,riid,ppvResource)	\
+    ( (This)->lpVtbl -> CreatePlacedResource2(This,pHeap,HeapOffset,pDesc,InitialLayout,pOptimizedClearValue,NumCastableFormats,pCastableFormats,riid,ppvResource) ) 
+
+#define ID3D12Device10_CreateReservedResource2(This,pDesc,InitialLayout,pOptimizedClearValue,pProtectedSession,NumCastableFormats,pCastableFormats,riid,ppvResource)	\
+    ( (This)->lpVtbl -> CreateReservedResource2(This,pDesc,InitialLayout,pOptimizedClearValue,pProtectedSession,NumCastableFormats,pCastableFormats,riid,ppvResource) ) 
+
+#endif /* COBJMACROS */
+
+
+#endif 	/* C style interface */
+
+
+
+
+#endif 	/* __ID3D12Device10_INTERFACE_DEFINED__ */
+
+
+#ifndef __ID3D12Device11_INTERFACE_DEFINED__
+#define __ID3D12Device11_INTERFACE_DEFINED__
+
+/* interface ID3D12Device11 */
+/* [unique][local][object][uuid] */ 
+
+
+EXTERN_C const IID IID_ID3D12Device11;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("5405c344-d457-444e-b4dd-2366e45aee39")
+    ID3D12Device11 : public ID3D12Device10
+    {
+    public:
+        virtual void STDMETHODCALLTYPE CreateSampler2( 
+            _In_  const D3D12_SAMPLER_DESC2 *pDesc,
+            _In_  D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor) = 0;
+        
+    };
+    
+    
+#else 	/* C style interface */
+
+    typedef struct ID3D12Device11Vtbl
+    {
+        BEGIN_INTERFACE
+        
+        DECLSPEC_XFGVIRT(IUnknown, QueryInterface)
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            ID3D12Device11 * This,
+            REFIID riid,
+            _COM_Outptr_  void **ppvObject);
+        
+        DECLSPEC_XFGVIRT(IUnknown, AddRef)
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            ID3D12Device11 * This);
+        
+        DECLSPEC_XFGVIRT(IUnknown, Release)
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            ID3D12Device11 * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, GetPrivateData)
+        HRESULT ( STDMETHODCALLTYPE *GetPrivateData )( 
+            ID3D12Device11 * This,
+            _In_  REFGUID guid,
+            _Inout_  UINT *pDataSize,
+            _Out_writes_bytes_opt_( *pDataSize )  void *pData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, SetPrivateData)
+        HRESULT ( STDMETHODCALLTYPE *SetPrivateData )( 
+            ID3D12Device11 * This,
+            _In_  REFGUID guid,
+            _In_  UINT DataSize,
+            _In_reads_bytes_opt_( DataSize )  const void *pData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, SetPrivateDataInterface)
+        HRESULT ( STDMETHODCALLTYPE *SetPrivateDataInterface )( 
+            ID3D12Device11 * This,
+            _In_  REFGUID guid,
+            _In_opt_  const IUnknown *pData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, SetName)
+        HRESULT ( STDMETHODCALLTYPE *SetName )( 
+            ID3D12Device11 * This,
+            _In_z_  LPCWSTR Name);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, GetNodeCount)
+        UINT ( STDMETHODCALLTYPE *GetNodeCount )( 
+            ID3D12Device11 * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CreateCommandQueue)
+        HRESULT ( STDMETHODCALLTYPE *CreateCommandQueue )( 
+            ID3D12Device11 * This,
+            _In_  const D3D12_COMMAND_QUEUE_DESC *pDesc,
+            REFIID riid,
+            _COM_Outptr_  void **ppCommandQueue);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CreateCommandAllocator)
+        HRESULT ( STDMETHODCALLTYPE *CreateCommandAllocator )( 
+            ID3D12Device11 * This,
+            _In_  D3D12_COMMAND_LIST_TYPE type,
+            REFIID riid,
+            _COM_Outptr_  void **ppCommandAllocator);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CreateGraphicsPipelineState)
+        HRESULT ( STDMETHODCALLTYPE *CreateGraphicsPipelineState )( 
+            ID3D12Device11 * This,
+            _In_  const D3D12_GRAPHICS_PIPELINE_STATE_DESC *pDesc,
+            REFIID riid,
+            _COM_Outptr_  void **ppPipelineState);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CreateComputePipelineState)
+        HRESULT ( STDMETHODCALLTYPE *CreateComputePipelineState )( 
+            ID3D12Device11 * This,
+            _In_  const D3D12_COMPUTE_PIPELINE_STATE_DESC *pDesc,
+            REFIID riid,
+            _COM_Outptr_  void **ppPipelineState);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CreateCommandList)
+        HRESULT ( STDMETHODCALLTYPE *CreateCommandList )( 
+            ID3D12Device11 * This,
+            _In_  UINT nodeMask,
+            _In_  D3D12_COMMAND_LIST_TYPE type,
+            _In_  ID3D12CommandAllocator *pCommandAllocator,
+            _In_opt_  ID3D12PipelineState *pInitialState,
+            REFIID riid,
+            _COM_Outptr_  void **ppCommandList);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CheckFeatureSupport)
+        HRESULT ( STDMETHODCALLTYPE *CheckFeatureSupport )( 
+            ID3D12Device11 * This,
+            D3D12_FEATURE Feature,
+            _Inout_updates_bytes_(FeatureSupportDataSize)  void *pFeatureSupportData,
+            UINT FeatureSupportDataSize);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CreateDescriptorHeap)
+        HRESULT ( STDMETHODCALLTYPE *CreateDescriptorHeap )( 
+            ID3D12Device11 * This,
+            _In_  const D3D12_DESCRIPTOR_HEAP_DESC *pDescriptorHeapDesc,
+            REFIID riid,
+            _COM_Outptr_  void **ppvHeap);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, GetDescriptorHandleIncrementSize)
+        UINT ( STDMETHODCALLTYPE *GetDescriptorHandleIncrementSize )( 
+            ID3D12Device11 * This,
+            _In_  D3D12_DESCRIPTOR_HEAP_TYPE DescriptorHeapType);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CreateRootSignature)
+        HRESULT ( STDMETHODCALLTYPE *CreateRootSignature )( 
+            ID3D12Device11 * This,
+            _In_  UINT nodeMask,
+            _In_reads_(blobLengthInBytes)  const void *pBlobWithRootSignature,
+            _In_  SIZE_T blobLengthInBytes,
+            REFIID riid,
+            _COM_Outptr_  void **ppvRootSignature);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CreateConstantBufferView)
+        void ( STDMETHODCALLTYPE *CreateConstantBufferView )( 
+            ID3D12Device11 * This,
+            _In_opt_  const D3D12_CONSTANT_BUFFER_VIEW_DESC *pDesc,
+            _In_  D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CreateShaderResourceView)
+        void ( STDMETHODCALLTYPE *CreateShaderResourceView )( 
+            ID3D12Device11 * This,
+            _In_opt_  ID3D12Resource *pResource,
+            _In_opt_  const D3D12_SHADER_RESOURCE_VIEW_DESC *pDesc,
+            _In_  D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CreateUnorderedAccessView)
+        void ( STDMETHODCALLTYPE *CreateUnorderedAccessView )( 
+            ID3D12Device11 * This,
+            _In_opt_  ID3D12Resource *pResource,
+            _In_opt_  ID3D12Resource *pCounterResource,
+            _In_opt_  const D3D12_UNORDERED_ACCESS_VIEW_DESC *pDesc,
+            _In_  D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CreateRenderTargetView)
+        void ( STDMETHODCALLTYPE *CreateRenderTargetView )( 
+            ID3D12Device11 * This,
+            _In_opt_  ID3D12Resource *pResource,
+            _In_opt_  const D3D12_RENDER_TARGET_VIEW_DESC *pDesc,
+            _In_  D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CreateDepthStencilView)
+        void ( STDMETHODCALLTYPE *CreateDepthStencilView )( 
+            ID3D12Device11 * This,
+            _In_opt_  ID3D12Resource *pResource,
+            _In_opt_  const D3D12_DEPTH_STENCIL_VIEW_DESC *pDesc,
+            _In_  D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CreateSampler)
+        void ( STDMETHODCALLTYPE *CreateSampler )( 
+            ID3D12Device11 * This,
+            _In_  const D3D12_SAMPLER_DESC *pDesc,
+            _In_  D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CopyDescriptors)
+        void ( STDMETHODCALLTYPE *CopyDescriptors )( 
+            ID3D12Device11 * This,
+            _In_  UINT NumDestDescriptorRanges,
+            _In_reads_(NumDestDescriptorRanges)  const D3D12_CPU_DESCRIPTOR_HANDLE *pDestDescriptorRangeStarts,
+            _In_reads_opt_(NumDestDescriptorRanges)  const UINT *pDestDescriptorRangeSizes,
+            _In_  UINT NumSrcDescriptorRanges,
+            _In_reads_(NumSrcDescriptorRanges)  const D3D12_CPU_DESCRIPTOR_HANDLE *pSrcDescriptorRangeStarts,
+            _In_reads_opt_(NumSrcDescriptorRanges)  const UINT *pSrcDescriptorRangeSizes,
+            _In_  D3D12_DESCRIPTOR_HEAP_TYPE DescriptorHeapsType);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CopyDescriptorsSimple)
+        void ( STDMETHODCALLTYPE *CopyDescriptorsSimple )( 
+            ID3D12Device11 * This,
+            _In_  UINT NumDescriptors,
+            _In_  D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptorRangeStart,
+            _In_  D3D12_CPU_DESCRIPTOR_HANDLE SrcDescriptorRangeStart,
+            _In_  D3D12_DESCRIPTOR_HEAP_TYPE DescriptorHeapsType);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, GetResourceAllocationInfo)
+#if !defined(_WIN32)
+        D3D12_RESOURCE_ALLOCATION_INFO ( STDMETHODCALLTYPE *GetResourceAllocationInfo )( 
+            ID3D12Device11 * This,
+            _In_  UINT visibleMask,
+            _In_  UINT numResourceDescs,
+            _In_reads_(numResourceDescs)  const D3D12_RESOURCE_DESC *pResourceDescs);
+        
+#else
+        D3D12_RESOURCE_ALLOCATION_INFO *( STDMETHODCALLTYPE *GetResourceAllocationInfo )( 
+            ID3D12Device11 * This,
+            D3D12_RESOURCE_ALLOCATION_INFO * RetVal,
+            _In_  UINT visibleMask,
+            _In_  UINT numResourceDescs,
+            _In_reads_(numResourceDescs)  const D3D12_RESOURCE_DESC *pResourceDescs);
+        
+#endif
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, GetCustomHeapProperties)
+#if !defined(_WIN32)
+        D3D12_HEAP_PROPERTIES ( STDMETHODCALLTYPE *GetCustomHeapProperties )( 
+            ID3D12Device11 * This,
+            _In_  UINT nodeMask,
+            D3D12_HEAP_TYPE heapType);
+        
+#else
+        D3D12_HEAP_PROPERTIES *( STDMETHODCALLTYPE *GetCustomHeapProperties )( 
+            ID3D12Device11 * This,
+            D3D12_HEAP_PROPERTIES * RetVal,
+            _In_  UINT nodeMask,
+            D3D12_HEAP_TYPE heapType);
+        
+#endif
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CreateCommittedResource)
+        HRESULT ( STDMETHODCALLTYPE *CreateCommittedResource )( 
+            ID3D12Device11 * This,
+            _In_  const D3D12_HEAP_PROPERTIES *pHeapProperties,
+            D3D12_HEAP_FLAGS HeapFlags,
+            _In_  const D3D12_RESOURCE_DESC *pDesc,
+            D3D12_RESOURCE_STATES InitialResourceState,
+            _In_opt_  const D3D12_CLEAR_VALUE *pOptimizedClearValue,
+            REFIID riidResource,
+            _COM_Outptr_opt_  void **ppvResource);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CreateHeap)
+        HRESULT ( STDMETHODCALLTYPE *CreateHeap )( 
+            ID3D12Device11 * This,
+            _In_  const D3D12_HEAP_DESC *pDesc,
+            REFIID riid,
+            _COM_Outptr_opt_  void **ppvHeap);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CreatePlacedResource)
+        HRESULT ( STDMETHODCALLTYPE *CreatePlacedResource )( 
+            ID3D12Device11 * This,
+            _In_  ID3D12Heap *pHeap,
+            UINT64 HeapOffset,
+            _In_  const D3D12_RESOURCE_DESC *pDesc,
+            D3D12_RESOURCE_STATES InitialState,
+            _In_opt_  const D3D12_CLEAR_VALUE *pOptimizedClearValue,
+            REFIID riid,
+            _COM_Outptr_opt_  void **ppvResource);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CreateReservedResource)
+        HRESULT ( STDMETHODCALLTYPE *CreateReservedResource )( 
+            ID3D12Device11 * This,
+            _In_  const D3D12_RESOURCE_DESC *pDesc,
+            D3D12_RESOURCE_STATES InitialState,
+            _In_opt_  const D3D12_CLEAR_VALUE *pOptimizedClearValue,
+            REFIID riid,
+            _COM_Outptr_opt_  void **ppvResource);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CreateSharedHandle)
+        HRESULT ( STDMETHODCALLTYPE *CreateSharedHandle )( 
+            ID3D12Device11 * This,
+            _In_  ID3D12DeviceChild *pObject,
+            _In_opt_  const SECURITY_ATTRIBUTES *pAttributes,
+            DWORD Access,
+            _In_opt_  LPCWSTR Name,
+            _Out_  HANDLE *pHandle);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, OpenSharedHandle)
+        HRESULT ( STDMETHODCALLTYPE *OpenSharedHandle )( 
+            ID3D12Device11 * This,
+            _In_  HANDLE NTHandle,
+            REFIID riid,
+            _COM_Outptr_opt_  void **ppvObj);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, OpenSharedHandleByName)
+        HRESULT ( STDMETHODCALLTYPE *OpenSharedHandleByName )( 
+            ID3D12Device11 * This,
+            _In_  LPCWSTR Name,
+            DWORD Access,
+            /* [annotation][out] */ 
+            _Out_  HANDLE *pNTHandle);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, MakeResident)
+        HRESULT ( STDMETHODCALLTYPE *MakeResident )( 
+            ID3D12Device11 * This,
+            UINT NumObjects,
+            _In_reads_(NumObjects)  ID3D12Pageable *const *ppObjects);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, Evict)
+        HRESULT ( STDMETHODCALLTYPE *Evict )( 
+            ID3D12Device11 * This,
+            UINT NumObjects,
+            _In_reads_(NumObjects)  ID3D12Pageable *const *ppObjects);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CreateFence)
+        HRESULT ( STDMETHODCALLTYPE *CreateFence )( 
+            ID3D12Device11 * This,
+            UINT64 InitialValue,
+            D3D12_FENCE_FLAGS Flags,
+            REFIID riid,
+            _COM_Outptr_  void **ppFence);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, GetDeviceRemovedReason)
+        HRESULT ( STDMETHODCALLTYPE *GetDeviceRemovedReason )( 
+            ID3D12Device11 * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, GetCopyableFootprints)
+        void ( STDMETHODCALLTYPE *GetCopyableFootprints )( 
+            ID3D12Device11 * This,
+            _In_  const D3D12_RESOURCE_DESC *pResourceDesc,
+            _In_range_(0,D3D12_REQ_SUBRESOURCES)  UINT FirstSubresource,
+            _In_range_(0,D3D12_REQ_SUBRESOURCES-FirstSubresource)  UINT NumSubresources,
+            UINT64 BaseOffset,
+            _Out_writes_opt_(NumSubresources)  D3D12_PLACED_SUBRESOURCE_FOOTPRINT *pLayouts,
+            _Out_writes_opt_(NumSubresources)  UINT *pNumRows,
+            _Out_writes_opt_(NumSubresources)  UINT64 *pRowSizeInBytes,
+            _Out_opt_  UINT64 *pTotalBytes);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CreateQueryHeap)
+        HRESULT ( STDMETHODCALLTYPE *CreateQueryHeap )( 
+            ID3D12Device11 * This,
+            _In_  const D3D12_QUERY_HEAP_DESC *pDesc,
+            REFIID riid,
+            _COM_Outptr_opt_  void **ppvHeap);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, SetStablePowerState)
+        HRESULT ( STDMETHODCALLTYPE *SetStablePowerState )( 
+            ID3D12Device11 * This,
+            BOOL Enable);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, CreateCommandSignature)
+        HRESULT ( STDMETHODCALLTYPE *CreateCommandSignature )( 
+            ID3D12Device11 * This,
+            _In_  const D3D12_COMMAND_SIGNATURE_DESC *pDesc,
+            _In_opt_  ID3D12RootSignature *pRootSignature,
+            REFIID riid,
+            _COM_Outptr_opt_  void **ppvCommandSignature);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, GetResourceTiling)
+        void ( STDMETHODCALLTYPE *GetResourceTiling )( 
+            ID3D12Device11 * This,
+            _In_  ID3D12Resource *pTiledResource,
+            _Out_opt_  UINT *pNumTilesForEntireResource,
+            _Out_opt_  D3D12_PACKED_MIP_INFO *pPackedMipDesc,
+            _Out_opt_  D3D12_TILE_SHAPE *pStandardTileShapeForNonPackedMips,
+            _Inout_opt_  UINT *pNumSubresourceTilings,
+            _In_  UINT FirstSubresourceTilingToGet,
+            _Out_writes_(*pNumSubresourceTilings)  D3D12_SUBRESOURCE_TILING *pSubresourceTilingsForNonPackedMips);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device, GetAdapterLuid)
+#if !defined(_WIN32)
+        LUID ( STDMETHODCALLTYPE *GetAdapterLuid )( 
+            ID3D12Device11 * This);
+        
+#else
+        LUID *( STDMETHODCALLTYPE *GetAdapterLuid )( 
+            ID3D12Device11 * This,
+            LUID * RetVal);
+        
+#endif
+        
+        DECLSPEC_XFGVIRT(ID3D12Device1, CreatePipelineLibrary)
+        HRESULT ( STDMETHODCALLTYPE *CreatePipelineLibrary )( 
+            ID3D12Device11 * This,
+            _In_reads_(BlobLength)  const void *pLibraryBlob,
+            SIZE_T BlobLength,
+            REFIID riid,
+            _COM_Outptr_  void **ppPipelineLibrary);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device1, SetEventOnMultipleFenceCompletion)
+        HRESULT ( STDMETHODCALLTYPE *SetEventOnMultipleFenceCompletion )( 
+            ID3D12Device11 * This,
+            _In_reads_(NumFences)  ID3D12Fence *const *ppFences,
+            _In_reads_(NumFences)  const UINT64 *pFenceValues,
+            UINT NumFences,
+            D3D12_MULTIPLE_FENCE_WAIT_FLAGS Flags,
+            HANDLE hEvent);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device1, SetResidencyPriority)
+        HRESULT ( STDMETHODCALLTYPE *SetResidencyPriority )( 
+            ID3D12Device11 * This,
+            UINT NumObjects,
+            _In_reads_(NumObjects)  ID3D12Pageable *const *ppObjects,
+            _In_reads_(NumObjects)  const D3D12_RESIDENCY_PRIORITY *pPriorities);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device2, CreatePipelineState)
+        HRESULT ( STDMETHODCALLTYPE *CreatePipelineState )( 
+            ID3D12Device11 * This,
+            const D3D12_PIPELINE_STATE_STREAM_DESC *pDesc,
+            REFIID riid,
+            _COM_Outptr_  void **ppPipelineState);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device3, OpenExistingHeapFromAddress)
+        HRESULT ( STDMETHODCALLTYPE *OpenExistingHeapFromAddress )( 
+            ID3D12Device11 * This,
+            _In_  const void *pAddress,
+            REFIID riid,
+            _COM_Outptr_  void **ppvHeap);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device3, OpenExistingHeapFromFileMapping)
+        HRESULT ( STDMETHODCALLTYPE *OpenExistingHeapFromFileMapping )( 
+            ID3D12Device11 * This,
+            _In_  HANDLE hFileMapping,
+            REFIID riid,
+            _COM_Outptr_  void **ppvHeap);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device3, EnqueueMakeResident)
+        HRESULT ( STDMETHODCALLTYPE *EnqueueMakeResident )( 
+            ID3D12Device11 * This,
+            D3D12_RESIDENCY_FLAGS Flags,
+            UINT NumObjects,
+            _In_reads_(NumObjects)  ID3D12Pageable *const *ppObjects,
+            _In_  ID3D12Fence *pFenceToSignal,
+            UINT64 FenceValueToSignal);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device4, CreateCommandList1)
+        HRESULT ( STDMETHODCALLTYPE *CreateCommandList1 )( 
+            ID3D12Device11 * This,
+            _In_  UINT nodeMask,
+            _In_  D3D12_COMMAND_LIST_TYPE type,
+            _In_  D3D12_COMMAND_LIST_FLAGS flags,
+            REFIID riid,
+            _COM_Outptr_  void **ppCommandList);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device4, CreateProtectedResourceSession)
+        HRESULT ( STDMETHODCALLTYPE *CreateProtectedResourceSession )( 
+            ID3D12Device11 * This,
+            _In_  const D3D12_PROTECTED_RESOURCE_SESSION_DESC *pDesc,
+            _In_  REFIID riid,
+            _COM_Outptr_  void **ppSession);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device4, CreateCommittedResource1)
+        HRESULT ( STDMETHODCALLTYPE *CreateCommittedResource1 )( 
+            ID3D12Device11 * This,
+            _In_  const D3D12_HEAP_PROPERTIES *pHeapProperties,
+            D3D12_HEAP_FLAGS HeapFlags,
+            _In_  const D3D12_RESOURCE_DESC *pDesc,
+            D3D12_RESOURCE_STATES InitialResourceState,
+            _In_opt_  const D3D12_CLEAR_VALUE *pOptimizedClearValue,
+            _In_opt_  ID3D12ProtectedResourceSession *pProtectedSession,
+            REFIID riidResource,
+            _COM_Outptr_opt_  void **ppvResource);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device4, CreateHeap1)
+        HRESULT ( STDMETHODCALLTYPE *CreateHeap1 )( 
+            ID3D12Device11 * This,
+            _In_  const D3D12_HEAP_DESC *pDesc,
+            _In_opt_  ID3D12ProtectedResourceSession *pProtectedSession,
+            REFIID riid,
+            _COM_Outptr_opt_  void **ppvHeap);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device4, CreateReservedResource1)
+        HRESULT ( STDMETHODCALLTYPE *CreateReservedResource1 )( 
+            ID3D12Device11 * This,
+            _In_  const D3D12_RESOURCE_DESC *pDesc,
+            D3D12_RESOURCE_STATES InitialState,
+            _In_opt_  const D3D12_CLEAR_VALUE *pOptimizedClearValue,
+            _In_opt_  ID3D12ProtectedResourceSession *pProtectedSession,
+            REFIID riid,
+            _COM_Outptr_opt_  void **ppvResource);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device4, GetResourceAllocationInfo1)
+#if !defined(_WIN32)
+        D3D12_RESOURCE_ALLOCATION_INFO ( STDMETHODCALLTYPE *GetResourceAllocationInfo1 )( 
+            ID3D12Device11 * This,
+            UINT visibleMask,
+            UINT numResourceDescs,
+            _In_reads_(numResourceDescs)  const D3D12_RESOURCE_DESC *pResourceDescs,
+            _Out_writes_opt_(numResourceDescs)  D3D12_RESOURCE_ALLOCATION_INFO1 *pResourceAllocationInfo1);
+        
+#else
+        D3D12_RESOURCE_ALLOCATION_INFO *( STDMETHODCALLTYPE *GetResourceAllocationInfo1 )( 
+            ID3D12Device11 * This,
+            D3D12_RESOURCE_ALLOCATION_INFO * RetVal,
+            UINT visibleMask,
+            UINT numResourceDescs,
+            _In_reads_(numResourceDescs)  const D3D12_RESOURCE_DESC *pResourceDescs,
+            _Out_writes_opt_(numResourceDescs)  D3D12_RESOURCE_ALLOCATION_INFO1 *pResourceAllocationInfo1);
+        
+#endif
+        
+        DECLSPEC_XFGVIRT(ID3D12Device5, CreateLifetimeTracker)
+        HRESULT ( STDMETHODCALLTYPE *CreateLifetimeTracker )( 
+            ID3D12Device11 * This,
+            _In_  ID3D12LifetimeOwner *pOwner,
+            REFIID riid,
+            _COM_Outptr_  void **ppvTracker);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device5, RemoveDevice)
+        void ( STDMETHODCALLTYPE *RemoveDevice )( 
+            ID3D12Device11 * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device5, EnumerateMetaCommands)
+        HRESULT ( STDMETHODCALLTYPE *EnumerateMetaCommands )( 
+            ID3D12Device11 * This,
+            _Inout_  UINT *pNumMetaCommands,
+            _Out_writes_opt_(*pNumMetaCommands)  D3D12_META_COMMAND_DESC *pDescs);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device5, EnumerateMetaCommandParameters)
+        HRESULT ( STDMETHODCALLTYPE *EnumerateMetaCommandParameters )( 
+            ID3D12Device11 * This,
+            _In_  REFGUID CommandId,
+            _In_  D3D12_META_COMMAND_PARAMETER_STAGE Stage,
+            _Out_opt_  UINT *pTotalStructureSizeInBytes,
+            _Inout_  UINT *pParameterCount,
+            _Out_writes_opt_(*pParameterCount)  D3D12_META_COMMAND_PARAMETER_DESC *pParameterDescs);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device5, CreateMetaCommand)
+        HRESULT ( STDMETHODCALLTYPE *CreateMetaCommand )( 
+            ID3D12Device11 * This,
+            _In_  REFGUID CommandId,
+            _In_  UINT NodeMask,
+            _In_reads_bytes_opt_(CreationParametersDataSizeInBytes)  const void *pCreationParametersData,
+            _In_  SIZE_T CreationParametersDataSizeInBytes,
+            REFIID riid,
+            _COM_Outptr_  void **ppMetaCommand);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device5, CreateStateObject)
+        HRESULT ( STDMETHODCALLTYPE *CreateStateObject )( 
+            ID3D12Device11 * This,
+            const D3D12_STATE_OBJECT_DESC *pDesc,
+            REFIID riid,
+            _COM_Outptr_  void **ppStateObject);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device5, GetRaytracingAccelerationStructurePrebuildInfo)
+        void ( STDMETHODCALLTYPE *GetRaytracingAccelerationStructurePrebuildInfo )( 
+            ID3D12Device11 * This,
+            _In_  const D3D12_BUILD_RAYTRACING_ACCELERATION_STRUCTURE_INPUTS *pDesc,
+            _Out_  D3D12_RAYTRACING_ACCELERATION_STRUCTURE_PREBUILD_INFO *pInfo);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device5, CheckDriverMatchingIdentifier)
+        D3D12_DRIVER_MATCHING_IDENTIFIER_STATUS ( STDMETHODCALLTYPE *CheckDriverMatchingIdentifier )( 
+            ID3D12Device11 * This,
+            _In_  D3D12_SERIALIZED_DATA_TYPE SerializedDataType,
+            _In_  const D3D12_SERIALIZED_DATA_DRIVER_MATCHING_IDENTIFIER *pIdentifierToCheck);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device6, SetBackgroundProcessingMode)
+        HRESULT ( STDMETHODCALLTYPE *SetBackgroundProcessingMode )( 
+            ID3D12Device11 * This,
+            D3D12_BACKGROUND_PROCESSING_MODE Mode,
+            D3D12_MEASUREMENTS_ACTION MeasurementsAction,
+            _In_opt_  HANDLE hEventToSignalUponCompletion,
+            _Out_opt_  BOOL *pbFurtherMeasurementsDesired);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device7, AddToStateObject)
+        HRESULT ( STDMETHODCALLTYPE *AddToStateObject )( 
+            ID3D12Device11 * This,
+            const D3D12_STATE_OBJECT_DESC *pAddition,
+            ID3D12StateObject *pStateObjectToGrowFrom,
+            REFIID riid,
+            _COM_Outptr_  void **ppNewStateObject);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device7, CreateProtectedResourceSession1)
+        HRESULT ( STDMETHODCALLTYPE *CreateProtectedResourceSession1 )( 
+            ID3D12Device11 * This,
+            _In_  const D3D12_PROTECTED_RESOURCE_SESSION_DESC1 *pDesc,
+            _In_  REFIID riid,
+            _COM_Outptr_  void **ppSession);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device8, GetResourceAllocationInfo2)
+#if !defined(_WIN32)
+        D3D12_RESOURCE_ALLOCATION_INFO ( STDMETHODCALLTYPE *GetResourceAllocationInfo2 )( 
+            ID3D12Device11 * This,
+            UINT visibleMask,
+            UINT numResourceDescs,
+            _In_reads_(numResourceDescs)  const D3D12_RESOURCE_DESC1 *pResourceDescs,
+            _Out_writes_opt_(numResourceDescs)  D3D12_RESOURCE_ALLOCATION_INFO1 *pResourceAllocationInfo1);
+        
+#else
+        D3D12_RESOURCE_ALLOCATION_INFO *( STDMETHODCALLTYPE *GetResourceAllocationInfo2 )( 
+            ID3D12Device11 * This,
+            D3D12_RESOURCE_ALLOCATION_INFO * RetVal,
+            UINT visibleMask,
+            UINT numResourceDescs,
+            _In_reads_(numResourceDescs)  const D3D12_RESOURCE_DESC1 *pResourceDescs,
+            _Out_writes_opt_(numResourceDescs)  D3D12_RESOURCE_ALLOCATION_INFO1 *pResourceAllocationInfo1);
+        
+#endif
+        
+        DECLSPEC_XFGVIRT(ID3D12Device8, CreateCommittedResource2)
+        HRESULT ( STDMETHODCALLTYPE *CreateCommittedResource2 )( 
+            ID3D12Device11 * This,
+            _In_  const D3D12_HEAP_PROPERTIES *pHeapProperties,
+            D3D12_HEAP_FLAGS HeapFlags,
+            _In_  const D3D12_RESOURCE_DESC1 *pDesc,
+            D3D12_RESOURCE_STATES InitialResourceState,
+            _In_opt_  const D3D12_CLEAR_VALUE *pOptimizedClearValue,
+            _In_opt_  ID3D12ProtectedResourceSession *pProtectedSession,
+            REFIID riidResource,
+            _COM_Outptr_opt_  void **ppvResource);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device8, CreatePlacedResource1)
+        HRESULT ( STDMETHODCALLTYPE *CreatePlacedResource1 )( 
+            ID3D12Device11 * This,
+            _In_  ID3D12Heap *pHeap,
+            UINT64 HeapOffset,
+            _In_  const D3D12_RESOURCE_DESC1 *pDesc,
+            D3D12_RESOURCE_STATES InitialState,
+            _In_opt_  const D3D12_CLEAR_VALUE *pOptimizedClearValue,
+            REFIID riid,
+            _COM_Outptr_opt_  void **ppvResource);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device8, CreateSamplerFeedbackUnorderedAccessView)
+        void ( STDMETHODCALLTYPE *CreateSamplerFeedbackUnorderedAccessView )( 
+            ID3D12Device11 * This,
+            _In_opt_  ID3D12Resource *pTargetedResource,
+            _In_opt_  ID3D12Resource *pFeedbackResource,
+            _In_  D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device8, GetCopyableFootprints1)
+        void ( STDMETHODCALLTYPE *GetCopyableFootprints1 )( 
+            ID3D12Device11 * This,
+            _In_  const D3D12_RESOURCE_DESC1 *pResourceDesc,
+            _In_range_(0,D3D12_REQ_SUBRESOURCES)  UINT FirstSubresource,
+            _In_range_(0,D3D12_REQ_SUBRESOURCES-FirstSubresource)  UINT NumSubresources,
+            UINT64 BaseOffset,
+            _Out_writes_opt_(NumSubresources)  D3D12_PLACED_SUBRESOURCE_FOOTPRINT *pLayouts,
+            _Out_writes_opt_(NumSubresources)  UINT *pNumRows,
+            _Out_writes_opt_(NumSubresources)  UINT64 *pRowSizeInBytes,
+            _Out_opt_  UINT64 *pTotalBytes);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device9, CreateShaderCacheSession)
+        HRESULT ( STDMETHODCALLTYPE *CreateShaderCacheSession )( 
+            ID3D12Device11 * This,
+            _In_  const D3D12_SHADER_CACHE_SESSION_DESC *pDesc,
+            REFIID riid,
+            _COM_Outptr_opt_  void **ppvSession);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device9, ShaderCacheControl)
+        HRESULT ( STDMETHODCALLTYPE *ShaderCacheControl )( 
+            ID3D12Device11 * This,
+            D3D12_SHADER_CACHE_KIND_FLAGS Kinds,
+            D3D12_SHADER_CACHE_CONTROL_FLAGS Control);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device9, CreateCommandQueue1)
+        HRESULT ( STDMETHODCALLTYPE *CreateCommandQueue1 )( 
+            ID3D12Device11 * This,
+            _In_  const D3D12_COMMAND_QUEUE_DESC *pDesc,
+            REFIID CreatorID,
+            REFIID riid,
+            _COM_Outptr_  void **ppCommandQueue);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device10, CreateCommittedResource3)
+        HRESULT ( STDMETHODCALLTYPE *CreateCommittedResource3 )( 
+            ID3D12Device11 * This,
+            _In_  const D3D12_HEAP_PROPERTIES *pHeapProperties,
+            D3D12_HEAP_FLAGS HeapFlags,
+            _In_  const D3D12_RESOURCE_DESC1 *pDesc,
+            D3D12_BARRIER_LAYOUT InitialLayout,
+            _In_opt_  const D3D12_CLEAR_VALUE *pOptimizedClearValue,
+            _In_opt_  ID3D12ProtectedResourceSession *pProtectedSession,
+            UINT32 NumCastableFormats,
+            _In_opt_count_(NumCastableFormats)  DXGI_FORMAT *pCastableFormats,
+            REFIID riidResource,
+            _COM_Outptr_opt_  void **ppvResource);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device10, CreatePlacedResource2)
+        HRESULT ( STDMETHODCALLTYPE *CreatePlacedResource2 )( 
+            ID3D12Device11 * This,
+            _In_  ID3D12Heap *pHeap,
+            UINT64 HeapOffset,
+            _In_  const D3D12_RESOURCE_DESC1 *pDesc,
+            D3D12_BARRIER_LAYOUT InitialLayout,
+            _In_opt_  const D3D12_CLEAR_VALUE *pOptimizedClearValue,
+            UINT32 NumCastableFormats,
+            _In_opt_count_(NumCastableFormats)  DXGI_FORMAT *pCastableFormats,
+            REFIID riid,
+            _COM_Outptr_opt_  void **ppvResource);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device10, CreateReservedResource2)
+        HRESULT ( STDMETHODCALLTYPE *CreateReservedResource2 )( 
+            ID3D12Device11 * This,
+            _In_  const D3D12_RESOURCE_DESC *pDesc,
+            D3D12_BARRIER_LAYOUT InitialLayout,
+            _In_opt_  const D3D12_CLEAR_VALUE *pOptimizedClearValue,
+            _In_opt_  ID3D12ProtectedResourceSession *pProtectedSession,
+            UINT32 NumCastableFormats,
+            _In_opt_count_(NumCastableFormats)  DXGI_FORMAT *pCastableFormats,
+            REFIID riid,
+            _COM_Outptr_opt_  void **ppvResource);
+        
+        DECLSPEC_XFGVIRT(ID3D12Device11, CreateSampler2)
+        void ( STDMETHODCALLTYPE *CreateSampler2 )( 
+            ID3D12Device11 * This,
+            _In_  const D3D12_SAMPLER_DESC2 *pDesc,
+            _In_  D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor);
+        
+        END_INTERFACE
+    } ID3D12Device11Vtbl;
+
+    interface ID3D12Device11
+    {
+        CONST_VTBL struct ID3D12Device11Vtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define ID3D12Device11_QueryInterface(This,riid,ppvObject)	\
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define ID3D12Device11_AddRef(This)	\
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define ID3D12Device11_Release(This)	\
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#define ID3D12Device11_GetPrivateData(This,guid,pDataSize,pData)	\
+    ( (This)->lpVtbl -> GetPrivateData(This,guid,pDataSize,pData) ) 
+
+#define ID3D12Device11_SetPrivateData(This,guid,DataSize,pData)	\
+    ( (This)->lpVtbl -> SetPrivateData(This,guid,DataSize,pData) ) 
+
+#define ID3D12Device11_SetPrivateDataInterface(This,guid,pData)	\
+    ( (This)->lpVtbl -> SetPrivateDataInterface(This,guid,pData) ) 
+
+#define ID3D12Device11_SetName(This,Name)	\
+    ( (This)->lpVtbl -> SetName(This,Name) ) 
+
+
+#define ID3D12Device11_GetNodeCount(This)	\
+    ( (This)->lpVtbl -> GetNodeCount(This) ) 
+
+#define ID3D12Device11_CreateCommandQueue(This,pDesc,riid,ppCommandQueue)	\
+    ( (This)->lpVtbl -> CreateCommandQueue(This,pDesc,riid,ppCommandQueue) ) 
+
+#define ID3D12Device11_CreateCommandAllocator(This,type,riid,ppCommandAllocator)	\
+    ( (This)->lpVtbl -> CreateCommandAllocator(This,type,riid,ppCommandAllocator) ) 
+
+#define ID3D12Device11_CreateGraphicsPipelineState(This,pDesc,riid,ppPipelineState)	\
+    ( (This)->lpVtbl -> CreateGraphicsPipelineState(This,pDesc,riid,ppPipelineState) ) 
+
+#define ID3D12Device11_CreateComputePipelineState(This,pDesc,riid,ppPipelineState)	\
+    ( (This)->lpVtbl -> CreateComputePipelineState(This,pDesc,riid,ppPipelineState) ) 
+
+#define ID3D12Device11_CreateCommandList(This,nodeMask,type,pCommandAllocator,pInitialState,riid,ppCommandList)	\
+    ( (This)->lpVtbl -> CreateCommandList(This,nodeMask,type,pCommandAllocator,pInitialState,riid,ppCommandList) ) 
+
+#define ID3D12Device11_CheckFeatureSupport(This,Feature,pFeatureSupportData,FeatureSupportDataSize)	\
+    ( (This)->lpVtbl -> CheckFeatureSupport(This,Feature,pFeatureSupportData,FeatureSupportDataSize) ) 
+
+#define ID3D12Device11_CreateDescriptorHeap(This,pDescriptorHeapDesc,riid,ppvHeap)	\
+    ( (This)->lpVtbl -> CreateDescriptorHeap(This,pDescriptorHeapDesc,riid,ppvHeap) ) 
+
+#define ID3D12Device11_GetDescriptorHandleIncrementSize(This,DescriptorHeapType)	\
+    ( (This)->lpVtbl -> GetDescriptorHandleIncrementSize(This,DescriptorHeapType) ) 
+
+#define ID3D12Device11_CreateRootSignature(This,nodeMask,pBlobWithRootSignature,blobLengthInBytes,riid,ppvRootSignature)	\
+    ( (This)->lpVtbl -> CreateRootSignature(This,nodeMask,pBlobWithRootSignature,blobLengthInBytes,riid,ppvRootSignature) ) 
+
+#define ID3D12Device11_CreateConstantBufferView(This,pDesc,DestDescriptor)	\
+    ( (This)->lpVtbl -> CreateConstantBufferView(This,pDesc,DestDescriptor) ) 
+
+#define ID3D12Device11_CreateShaderResourceView(This,pResource,pDesc,DestDescriptor)	\
+    ( (This)->lpVtbl -> CreateShaderResourceView(This,pResource,pDesc,DestDescriptor) ) 
+
+#define ID3D12Device11_CreateUnorderedAccessView(This,pResource,pCounterResource,pDesc,DestDescriptor)	\
+    ( (This)->lpVtbl -> CreateUnorderedAccessView(This,pResource,pCounterResource,pDesc,DestDescriptor) ) 
+
+#define ID3D12Device11_CreateRenderTargetView(This,pResource,pDesc,DestDescriptor)	\
+    ( (This)->lpVtbl -> CreateRenderTargetView(This,pResource,pDesc,DestDescriptor) ) 
+
+#define ID3D12Device11_CreateDepthStencilView(This,pResource,pDesc,DestDescriptor)	\
+    ( (This)->lpVtbl -> CreateDepthStencilView(This,pResource,pDesc,DestDescriptor) ) 
+
+#define ID3D12Device11_CreateSampler(This,pDesc,DestDescriptor)	\
+    ( (This)->lpVtbl -> CreateSampler(This,pDesc,DestDescriptor) ) 
+
+#define ID3D12Device11_CopyDescriptors(This,NumDestDescriptorRanges,pDestDescriptorRangeStarts,pDestDescriptorRangeSizes,NumSrcDescriptorRanges,pSrcDescriptorRangeStarts,pSrcDescriptorRangeSizes,DescriptorHeapsType)	\
+    ( (This)->lpVtbl -> CopyDescriptors(This,NumDestDescriptorRanges,pDestDescriptorRangeStarts,pDestDescriptorRangeSizes,NumSrcDescriptorRanges,pSrcDescriptorRangeStarts,pSrcDescriptorRangeSizes,DescriptorHeapsType) ) 
+
+#define ID3D12Device11_CopyDescriptorsSimple(This,NumDescriptors,DestDescriptorRangeStart,SrcDescriptorRangeStart,DescriptorHeapsType)	\
+    ( (This)->lpVtbl -> CopyDescriptorsSimple(This,NumDescriptors,DestDescriptorRangeStart,SrcDescriptorRangeStart,DescriptorHeapsType) ) 
+#if !defined(_WIN32)
+
+#define ID3D12Device11_GetResourceAllocationInfo(This,visibleMask,numResourceDescs,pResourceDescs)	\
+    ( (This)->lpVtbl -> GetResourceAllocationInfo(This,visibleMask,numResourceDescs,pResourceDescs) ) 
+#else
+#define ID3D12Device11_GetResourceAllocationInfo(This,RetVal,visibleMask,numResourceDescs,pResourceDescs)	\
+    ( (This)->lpVtbl -> GetResourceAllocationInfo(This,RetVal,visibleMask,numResourceDescs,pResourceDescs) ) 
+#endif
+#if !defined(_WIN32)
+
+#define ID3D12Device11_GetCustomHeapProperties(This,nodeMask,heapType)	\
+    ( (This)->lpVtbl -> GetCustomHeapProperties(This,nodeMask,heapType) ) 
+#else
+#define ID3D12Device11_GetCustomHeapProperties(This,RetVal,nodeMask,heapType)	\
+    ( (This)->lpVtbl -> GetCustomHeapProperties(This,RetVal,nodeMask,heapType) ) 
+#endif
+
+#define ID3D12Device11_CreateCommittedResource(This,pHeapProperties,HeapFlags,pDesc,InitialResourceState,pOptimizedClearValue,riidResource,ppvResource)	\
+    ( (This)->lpVtbl -> CreateCommittedResource(This,pHeapProperties,HeapFlags,pDesc,InitialResourceState,pOptimizedClearValue,riidResource,ppvResource) ) 
+
+#define ID3D12Device11_CreateHeap(This,pDesc,riid,ppvHeap)	\
+    ( (This)->lpVtbl -> CreateHeap(This,pDesc,riid,ppvHeap) ) 
+
+#define ID3D12Device11_CreatePlacedResource(This,pHeap,HeapOffset,pDesc,InitialState,pOptimizedClearValue,riid,ppvResource)	\
+    ( (This)->lpVtbl -> CreatePlacedResource(This,pHeap,HeapOffset,pDesc,InitialState,pOptimizedClearValue,riid,ppvResource) ) 
+
+#define ID3D12Device11_CreateReservedResource(This,pDesc,InitialState,pOptimizedClearValue,riid,ppvResource)	\
+    ( (This)->lpVtbl -> CreateReservedResource(This,pDesc,InitialState,pOptimizedClearValue,riid,ppvResource) ) 
+
+#define ID3D12Device11_CreateSharedHandle(This,pObject,pAttributes,Access,Name,pHandle)	\
+    ( (This)->lpVtbl -> CreateSharedHandle(This,pObject,pAttributes,Access,Name,pHandle) ) 
+
+#define ID3D12Device11_OpenSharedHandle(This,NTHandle,riid,ppvObj)	\
+    ( (This)->lpVtbl -> OpenSharedHandle(This,NTHandle,riid,ppvObj) ) 
+
+#define ID3D12Device11_OpenSharedHandleByName(This,Name,Access,pNTHandle)	\
+    ( (This)->lpVtbl -> OpenSharedHandleByName(This,Name,Access,pNTHandle) ) 
+
+#define ID3D12Device11_MakeResident(This,NumObjects,ppObjects)	\
+    ( (This)->lpVtbl -> MakeResident(This,NumObjects,ppObjects) ) 
+
+#define ID3D12Device11_Evict(This,NumObjects,ppObjects)	\
+    ( (This)->lpVtbl -> Evict(This,NumObjects,ppObjects) ) 
+
+#define ID3D12Device11_CreateFence(This,InitialValue,Flags,riid,ppFence)	\
+    ( (This)->lpVtbl -> CreateFence(This,InitialValue,Flags,riid,ppFence) ) 
+
+#define ID3D12Device11_GetDeviceRemovedReason(This)	\
+    ( (This)->lpVtbl -> GetDeviceRemovedReason(This) ) 
+
+#define ID3D12Device11_GetCopyableFootprints(This,pResourceDesc,FirstSubresource,NumSubresources,BaseOffset,pLayouts,pNumRows,pRowSizeInBytes,pTotalBytes)	\
+    ( (This)->lpVtbl -> GetCopyableFootprints(This,pResourceDesc,FirstSubresource,NumSubresources,BaseOffset,pLayouts,pNumRows,pRowSizeInBytes,pTotalBytes) ) 
+
+#define ID3D12Device11_CreateQueryHeap(This,pDesc,riid,ppvHeap)	\
+    ( (This)->lpVtbl -> CreateQueryHeap(This,pDesc,riid,ppvHeap) ) 
+
+#define ID3D12Device11_SetStablePowerState(This,Enable)	\
+    ( (This)->lpVtbl -> SetStablePowerState(This,Enable) ) 
+
+#define ID3D12Device11_CreateCommandSignature(This,pDesc,pRootSignature,riid,ppvCommandSignature)	\
+    ( (This)->lpVtbl -> CreateCommandSignature(This,pDesc,pRootSignature,riid,ppvCommandSignature) ) 
+
+#define ID3D12Device11_GetResourceTiling(This,pTiledResource,pNumTilesForEntireResource,pPackedMipDesc,pStandardTileShapeForNonPackedMips,pNumSubresourceTilings,FirstSubresourceTilingToGet,pSubresourceTilingsForNonPackedMips)	\
+    ( (This)->lpVtbl -> GetResourceTiling(This,pTiledResource,pNumTilesForEntireResource,pPackedMipDesc,pStandardTileShapeForNonPackedMips,pNumSubresourceTilings,FirstSubresourceTilingToGet,pSubresourceTilingsForNonPackedMips) ) 
+#if !defined(_WIN32)
+
+#define ID3D12Device11_GetAdapterLuid(This)	\
+    ( (This)->lpVtbl -> GetAdapterLuid(This) ) 
+#else
+#define ID3D12Device11_GetAdapterLuid(This,RetVal)	\
+    ( (This)->lpVtbl -> GetAdapterLuid(This,RetVal) ) 
+#endif
+
+
+#define ID3D12Device11_CreatePipelineLibrary(This,pLibraryBlob,BlobLength,riid,ppPipelineLibrary)	\
+    ( (This)->lpVtbl -> CreatePipelineLibrary(This,pLibraryBlob,BlobLength,riid,ppPipelineLibrary) ) 
+
+#define ID3D12Device11_SetEventOnMultipleFenceCompletion(This,ppFences,pFenceValues,NumFences,Flags,hEvent)	\
+    ( (This)->lpVtbl -> SetEventOnMultipleFenceCompletion(This,ppFences,pFenceValues,NumFences,Flags,hEvent) ) 
+
+#define ID3D12Device11_SetResidencyPriority(This,NumObjects,ppObjects,pPriorities)	\
+    ( (This)->lpVtbl -> SetResidencyPriority(This,NumObjects,ppObjects,pPriorities) ) 
+
+
+#define ID3D12Device11_CreatePipelineState(This,pDesc,riid,ppPipelineState)	\
+    ( (This)->lpVtbl -> CreatePipelineState(This,pDesc,riid,ppPipelineState) ) 
+
+
+#define ID3D12Device11_OpenExistingHeapFromAddress(This,pAddress,riid,ppvHeap)	\
+    ( (This)->lpVtbl -> OpenExistingHeapFromAddress(This,pAddress,riid,ppvHeap) ) 
+
+#define ID3D12Device11_OpenExistingHeapFromFileMapping(This,hFileMapping,riid,ppvHeap)	\
+    ( (This)->lpVtbl -> OpenExistingHeapFromFileMapping(This,hFileMapping,riid,ppvHeap) ) 
+
+#define ID3D12Device11_EnqueueMakeResident(This,Flags,NumObjects,ppObjects,pFenceToSignal,FenceValueToSignal)	\
+    ( (This)->lpVtbl -> EnqueueMakeResident(This,Flags,NumObjects,ppObjects,pFenceToSignal,FenceValueToSignal) ) 
+
+
+#define ID3D12Device11_CreateCommandList1(This,nodeMask,type,flags,riid,ppCommandList)	\
+    ( (This)->lpVtbl -> CreateCommandList1(This,nodeMask,type,flags,riid,ppCommandList) ) 
+
+#define ID3D12Device11_CreateProtectedResourceSession(This,pDesc,riid,ppSession)	\
+    ( (This)->lpVtbl -> CreateProtectedResourceSession(This,pDesc,riid,ppSession) ) 
+
+#define ID3D12Device11_CreateCommittedResource1(This,pHeapProperties,HeapFlags,pDesc,InitialResourceState,pOptimizedClearValue,pProtectedSession,riidResource,ppvResource)	\
+    ( (This)->lpVtbl -> CreateCommittedResource1(This,pHeapProperties,HeapFlags,pDesc,InitialResourceState,pOptimizedClearValue,pProtectedSession,riidResource,ppvResource) ) 
+
+#define ID3D12Device11_CreateHeap1(This,pDesc,pProtectedSession,riid,ppvHeap)	\
+    ( (This)->lpVtbl -> CreateHeap1(This,pDesc,pProtectedSession,riid,ppvHeap) ) 
+
+#define ID3D12Device11_CreateReservedResource1(This,pDesc,InitialState,pOptimizedClearValue,pProtectedSession,riid,ppvResource)	\
+    ( (This)->lpVtbl -> CreateReservedResource1(This,pDesc,InitialState,pOptimizedClearValue,pProtectedSession,riid,ppvResource) ) 
+#if !defined(_WIN32)
+
+#define ID3D12Device11_GetResourceAllocationInfo1(This,visibleMask,numResourceDescs,pResourceDescs,pResourceAllocationInfo1)	\
+    ( (This)->lpVtbl -> GetResourceAllocationInfo1(This,visibleMask,numResourceDescs,pResourceDescs,pResourceAllocationInfo1) ) 
+#else
+#define ID3D12Device11_GetResourceAllocationInfo1(This,RetVal,visibleMask,numResourceDescs,pResourceDescs,pResourceAllocationInfo1)	\
+    ( (This)->lpVtbl -> GetResourceAllocationInfo1(This,RetVal,visibleMask,numResourceDescs,pResourceDescs,pResourceAllocationInfo1) ) 
+#endif
+
+
+#define ID3D12Device11_CreateLifetimeTracker(This,pOwner,riid,ppvTracker)	\
+    ( (This)->lpVtbl -> CreateLifetimeTracker(This,pOwner,riid,ppvTracker) ) 
+
+#define ID3D12Device11_RemoveDevice(This)	\
+    ( (This)->lpVtbl -> RemoveDevice(This) ) 
+
+#define ID3D12Device11_EnumerateMetaCommands(This,pNumMetaCommands,pDescs)	\
+    ( (This)->lpVtbl -> EnumerateMetaCommands(This,pNumMetaCommands,pDescs) ) 
+
+#define ID3D12Device11_EnumerateMetaCommandParameters(This,CommandId,Stage,pTotalStructureSizeInBytes,pParameterCount,pParameterDescs)	\
+    ( (This)->lpVtbl -> EnumerateMetaCommandParameters(This,CommandId,Stage,pTotalStructureSizeInBytes,pParameterCount,pParameterDescs) ) 
+
+#define ID3D12Device11_CreateMetaCommand(This,CommandId,NodeMask,pCreationParametersData,CreationParametersDataSizeInBytes,riid,ppMetaCommand)	\
+    ( (This)->lpVtbl -> CreateMetaCommand(This,CommandId,NodeMask,pCreationParametersData,CreationParametersDataSizeInBytes,riid,ppMetaCommand) ) 
+
+#define ID3D12Device11_CreateStateObject(This,pDesc,riid,ppStateObject)	\
+    ( (This)->lpVtbl -> CreateStateObject(This,pDesc,riid,ppStateObject) ) 
+
+#define ID3D12Device11_GetRaytracingAccelerationStructurePrebuildInfo(This,pDesc,pInfo)	\
+    ( (This)->lpVtbl -> GetRaytracingAccelerationStructurePrebuildInfo(This,pDesc,pInfo) ) 
+
+#define ID3D12Device11_CheckDriverMatchingIdentifier(This,SerializedDataType,pIdentifierToCheck)	\
+    ( (This)->lpVtbl -> CheckDriverMatchingIdentifier(This,SerializedDataType,pIdentifierToCheck) ) 
+
+
+#define ID3D12Device11_SetBackgroundProcessingMode(This,Mode,MeasurementsAction,hEventToSignalUponCompletion,pbFurtherMeasurementsDesired)	\
+    ( (This)->lpVtbl -> SetBackgroundProcessingMode(This,Mode,MeasurementsAction,hEventToSignalUponCompletion,pbFurtherMeasurementsDesired) ) 
+
+
+#define ID3D12Device11_AddToStateObject(This,pAddition,pStateObjectToGrowFrom,riid,ppNewStateObject)	\
+    ( (This)->lpVtbl -> AddToStateObject(This,pAddition,pStateObjectToGrowFrom,riid,ppNewStateObject) ) 
+
+#define ID3D12Device11_CreateProtectedResourceSession1(This,pDesc,riid,ppSession)	\
+    ( (This)->lpVtbl -> CreateProtectedResourceSession1(This,pDesc,riid,ppSession) ) 
+
+#if !defined(_WIN32)
+
+#define ID3D12Device11_GetResourceAllocationInfo2(This,visibleMask,numResourceDescs,pResourceDescs,pResourceAllocationInfo1)	\
+    ( (This)->lpVtbl -> GetResourceAllocationInfo2(This,visibleMask,numResourceDescs,pResourceDescs,pResourceAllocationInfo1) ) 
+#else
+#define ID3D12Device11_GetResourceAllocationInfo2(This,RetVal,visibleMask,numResourceDescs,pResourceDescs,pResourceAllocationInfo1)	\
+    ( (This)->lpVtbl -> GetResourceAllocationInfo2(This,RetVal,visibleMask,numResourceDescs,pResourceDescs,pResourceAllocationInfo1) ) 
+#endif
+
+#define ID3D12Device11_CreateCommittedResource2(This,pHeapProperties,HeapFlags,pDesc,InitialResourceState,pOptimizedClearValue,pProtectedSession,riidResource,ppvResource)	\
+    ( (This)->lpVtbl -> CreateCommittedResource2(This,pHeapProperties,HeapFlags,pDesc,InitialResourceState,pOptimizedClearValue,pProtectedSession,riidResource,ppvResource) ) 
+
+#define ID3D12Device11_CreatePlacedResource1(This,pHeap,HeapOffset,pDesc,InitialState,pOptimizedClearValue,riid,ppvResource)	\
+    ( (This)->lpVtbl -> CreatePlacedResource1(This,pHeap,HeapOffset,pDesc,InitialState,pOptimizedClearValue,riid,ppvResource) ) 
+
+#define ID3D12Device11_CreateSamplerFeedbackUnorderedAccessView(This,pTargetedResource,pFeedbackResource,DestDescriptor)	\
+    ( (This)->lpVtbl -> CreateSamplerFeedbackUnorderedAccessView(This,pTargetedResource,pFeedbackResource,DestDescriptor) ) 
+
+#define ID3D12Device11_GetCopyableFootprints1(This,pResourceDesc,FirstSubresource,NumSubresources,BaseOffset,pLayouts,pNumRows,pRowSizeInBytes,pTotalBytes)	\
+    ( (This)->lpVtbl -> GetCopyableFootprints1(This,pResourceDesc,FirstSubresource,NumSubresources,BaseOffset,pLayouts,pNumRows,pRowSizeInBytes,pTotalBytes) ) 
+
+
+#define ID3D12Device11_CreateShaderCacheSession(This,pDesc,riid,ppvSession)	\
+    ( (This)->lpVtbl -> CreateShaderCacheSession(This,pDesc,riid,ppvSession) ) 
+
+#define ID3D12Device11_ShaderCacheControl(This,Kinds,Control)	\
+    ( (This)->lpVtbl -> ShaderCacheControl(This,Kinds,Control) ) 
+
+#define ID3D12Device11_CreateCommandQueue1(This,pDesc,CreatorID,riid,ppCommandQueue)	\
+    ( (This)->lpVtbl -> CreateCommandQueue1(This,pDesc,CreatorID,riid,ppCommandQueue) ) 
+
+
+#define ID3D12Device11_CreateCommittedResource3(This,pHeapProperties,HeapFlags,pDesc,InitialLayout,pOptimizedClearValue,pProtectedSession,NumCastableFormats,pCastableFormats,riidResource,ppvResource)	\
+    ( (This)->lpVtbl -> CreateCommittedResource3(This,pHeapProperties,HeapFlags,pDesc,InitialLayout,pOptimizedClearValue,pProtectedSession,NumCastableFormats,pCastableFormats,riidResource,ppvResource) ) 
+
+#define ID3D12Device11_CreatePlacedResource2(This,pHeap,HeapOffset,pDesc,InitialLayout,pOptimizedClearValue,NumCastableFormats,pCastableFormats,riid,ppvResource)	\
+    ( (This)->lpVtbl -> CreatePlacedResource2(This,pHeap,HeapOffset,pDesc,InitialLayout,pOptimizedClearValue,NumCastableFormats,pCastableFormats,riid,ppvResource) ) 
+
+#define ID3D12Device11_CreateReservedResource2(This,pDesc,InitialLayout,pOptimizedClearValue,pProtectedSession,NumCastableFormats,pCastableFormats,riid,ppvResource)	\
+    ( (This)->lpVtbl -> CreateReservedResource2(This,pDesc,InitialLayout,pOptimizedClearValue,pProtectedSession,NumCastableFormats,pCastableFormats,riid,ppvResource) ) 
+
+
+#define ID3D12Device11_CreateSampler2(This,pDesc,DestDescriptor)	\
+    ( (This)->lpVtbl -> CreateSampler2(This,pDesc,DestDescriptor) ) 
+
+#endif /* COBJMACROS */
+
+
+#endif 	/* C style interface */
+
+
+
+
+#endif 	/* __ID3D12Device11_INTERFACE_DEFINED__ */
+
+
+#ifndef __ID3D12VirtualizationGuestDevice_INTERFACE_DEFINED__
+#define __ID3D12VirtualizationGuestDevice_INTERFACE_DEFINED__
+
+/* interface ID3D12VirtualizationGuestDevice */
+/* [unique][local][object][uuid] */ 
+
+
+EXTERN_C const IID IID_ID3D12VirtualizationGuestDevice;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("bc66d368-7373-4943-8757-fc87dc79e476")
+    ID3D12VirtualizationGuestDevice : public IUnknown
+    {
+    public:
+        virtual HRESULT STDMETHODCALLTYPE ShareWithHost( 
+            _In_  ID3D12DeviceChild *pObject,
+            _Out_  HANDLE *pHandle) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE CreateFenceFd( 
+            _In_  ID3D12Fence *pFence,
+            UINT64 FenceValue,
+            _Out_  int *pFenceFd) = 0;
+        
+    };
+    
+    
+#else 	/* C style interface */
+
+    typedef struct ID3D12VirtualizationGuestDeviceVtbl
+    {
+        BEGIN_INTERFACE
+        
+        DECLSPEC_XFGVIRT(IUnknown, QueryInterface)
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            ID3D12VirtualizationGuestDevice * This,
+            REFIID riid,
+            _COM_Outptr_  void **ppvObject);
+        
+        DECLSPEC_XFGVIRT(IUnknown, AddRef)
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            ID3D12VirtualizationGuestDevice * This);
+        
+        DECLSPEC_XFGVIRT(IUnknown, Release)
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            ID3D12VirtualizationGuestDevice * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12VirtualizationGuestDevice, ShareWithHost)
+        HRESULT ( STDMETHODCALLTYPE *ShareWithHost )( 
+            ID3D12VirtualizationGuestDevice * This,
+            _In_  ID3D12DeviceChild *pObject,
+            _Out_  HANDLE *pHandle);
+        
+        DECLSPEC_XFGVIRT(ID3D12VirtualizationGuestDevice, CreateFenceFd)
+        HRESULT ( STDMETHODCALLTYPE *CreateFenceFd )( 
+            ID3D12VirtualizationGuestDevice * This,
+            _In_  ID3D12Fence *pFence,
+            UINT64 FenceValue,
+            _Out_  int *pFenceFd);
+        
+        END_INTERFACE
+    } ID3D12VirtualizationGuestDeviceVtbl;
+
+    interface ID3D12VirtualizationGuestDevice
+    {
+        CONST_VTBL struct ID3D12VirtualizationGuestDeviceVtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define ID3D12VirtualizationGuestDevice_QueryInterface(This,riid,ppvObject)	\
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define ID3D12VirtualizationGuestDevice_AddRef(This)	\
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define ID3D12VirtualizationGuestDevice_Release(This)	\
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#define ID3D12VirtualizationGuestDevice_ShareWithHost(This,pObject,pHandle)	\
+    ( (This)->lpVtbl -> ShareWithHost(This,pObject,pHandle) ) 
+
+#define ID3D12VirtualizationGuestDevice_CreateFenceFd(This,pFence,FenceValue,pFenceFd)	\
+    ( (This)->lpVtbl -> CreateFenceFd(This,pFence,FenceValue,pFenceFd) ) 
+
+#endif /* COBJMACROS */
+
+
+#endif 	/* C style interface */
+
+
+
+
+#endif 	/* __ID3D12VirtualizationGuestDevice_INTERFACE_DEFINED__ */
+
+
+#ifndef __ID3D12Tools_INTERFACE_DEFINED__
+#define __ID3D12Tools_INTERFACE_DEFINED__
+
+/* interface ID3D12Tools */
+/* [unique][local][object][uuid] */ 
+
+
+EXTERN_C const IID IID_ID3D12Tools;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("7071e1f0-e84b-4b33-974f-12fa49de65c5")
+    ID3D12Tools : public IUnknown
+    {
+    public:
+        virtual void STDMETHODCALLTYPE EnableShaderInstrumentation( 
+            BOOL bEnable) = 0;
+        
+        virtual BOOL STDMETHODCALLTYPE ShaderInstrumentationEnabled( void) = 0;
+        
+    };
+    
+    
+#else 	/* C style interface */
+
+    typedef struct ID3D12ToolsVtbl
+    {
+        BEGIN_INTERFACE
+        
+        DECLSPEC_XFGVIRT(IUnknown, QueryInterface)
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            ID3D12Tools * This,
+            REFIID riid,
+            _COM_Outptr_  void **ppvObject);
+        
+        DECLSPEC_XFGVIRT(IUnknown, AddRef)
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            ID3D12Tools * This);
+        
+        DECLSPEC_XFGVIRT(IUnknown, Release)
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            ID3D12Tools * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12Tools, EnableShaderInstrumentation)
+        void ( STDMETHODCALLTYPE *EnableShaderInstrumentation )( 
+            ID3D12Tools * This,
+            BOOL bEnable);
+        
+        DECLSPEC_XFGVIRT(ID3D12Tools, ShaderInstrumentationEnabled)
+        BOOL ( STDMETHODCALLTYPE *ShaderInstrumentationEnabled )( 
+            ID3D12Tools * This);
+        
+        END_INTERFACE
+    } ID3D12ToolsVtbl;
+
+    interface ID3D12Tools
+    {
+        CONST_VTBL struct ID3D12ToolsVtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define ID3D12Tools_QueryInterface(This,riid,ppvObject)	\
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define ID3D12Tools_AddRef(This)	\
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define ID3D12Tools_Release(This)	\
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#define ID3D12Tools_EnableShaderInstrumentation(This,bEnable)	\
+    ( (This)->lpVtbl -> EnableShaderInstrumentation(This,bEnable) ) 
+
+#define ID3D12Tools_ShaderInstrumentationEnabled(This)	\
+    ( (This)->lpVtbl -> ShaderInstrumentationEnabled(This) ) 
+
+#endif /* COBJMACROS */
+
+
+#endif 	/* C style interface */
+
+
+
+
+#endif 	/* __ID3D12Tools_INTERFACE_DEFINED__ */
+
+
+/* interface __MIDL_itf_d3d12_0000_0057 */
+/* [local] */ 
+
+typedef struct D3D12_SUBRESOURCE_DATA
+    {
+    const void *pData;
+    LONG_PTR RowPitch;
+    LONG_PTR SlicePitch;
+    } 	D3D12_SUBRESOURCE_DATA;
+
+typedef struct D3D12_MEMCPY_DEST
+    {
+    void *pData;
+    SIZE_T RowPitch;
+    SIZE_T SlicePitch;
+    } 	D3D12_MEMCPY_DEST;
+
+#if !defined( D3D12_IGNORE_SDK_LAYERS ) 
+#include "d3d12sdklayers.h" 
+#endif 
+
+///////////////////////////////////////////////////////////////////////////
+// D3D12CreateDevice
+// ------------------
+//
+// pAdapter
+//      If NULL, D3D12CreateDevice will choose the primary adapter.
+//      If non-NULL, D3D12CreateDevice will use the provided adapter.
+// MinimumFeatureLevel
+//      The minimum feature level required for successful device creation.
+// riid
+//      The interface IID of the device to be returned. Expected: ID3D12Device.
+// ppDevice
+//      Pointer to returned interface. May be NULL.
+//
+// Return Values
+//  Any of those documented for 
+//          CreateDXGIFactory1
+//          IDXGIFactory::EnumAdapters
+//          D3D12CreateDevice
+//
+///////////////////////////////////////////////////////////////////////////
+typedef HRESULT (WINAPI* PFN_D3D12_CREATE_DEVICE)( _In_opt_ IUnknown*, 
+    D3D_FEATURE_LEVEL, 
+    _In_ REFIID, _COM_Outptr_opt_ void** );
+
+HRESULT WINAPI D3D12CreateDevice(
+    _In_opt_ IUnknown* pAdapter,
+    D3D_FEATURE_LEVEL MinimumFeatureLevel,
+    _In_ REFIID riid, // Expected: ID3D12Device
+    _COM_Outptr_opt_ void** ppDevice );
+
+
+typedef HRESULT (WINAPI* PFN_D3D12_GET_DEBUG_INTERFACE)( _In_ REFIID, _COM_Outptr_opt_ void** );
+
+HRESULT WINAPI D3D12GetDebugInterface( _In_ REFIID riid, _COM_Outptr_opt_ void** ppvDebug );
+
+// --------------------------------------------------------------------------------------------------------------------------------
+// D3D12EnableExperimentalFeatures
+//
+// Pass in a list of feature GUIDs to be enabled together.
+// 
+// If a particular feature requires some configuration information on enablement, it will have
+// a configuration struct that can be passed alongside the GUID.
+// 
+// Some features might use an interface IID as the GUID.  For these, once the feature is enabled via
+// D3D12EnableExperimentalFeatures, D3D12GetDebugInterface can then be called with the IID to retrieve the interface
+// for manipulating the feature.  This allows for control that might not cleanly be expressed by just 
+// the configuration struct that D3D12EnableExperimentalFeatures provides.
+//
+// If this method is called and a change to existing feature enablement is made, 
+// all current D3D12 devices are set to DEVICE_REMOVED state, since under the covers there is really only one
+// singleton device for a process.  Removing the devices when configuration changes prevents
+// mismatched expectations of how a device is supposed to work after it has been created from the app's point of view.
+//
+// The call returns E_NOINTERFACE if an unrecognized feature is passed in or Windows Developer mode is not on.
+// The call returns E_INVALIDARG if the configuration of a feature is incorrect, the set of features passed
+// in are known to be incompatible with each other, or other errors.
+// Returns S_OK otherwise.
+//
+// --------------------------------------------------------------------------------------------------------------------------------
+HRESULT WINAPI D3D12EnableExperimentalFeatures(
+    UINT                                    NumFeatures,
+    _In_count_(NumFeatures) const IID*     pIIDs,
+    _In_opt_count_(NumFeatures) void*      pConfigurationStructs,
+    _In_opt_count_(NumFeatures) UINT*      pConfigurationStructSizes);
+
+// --------------------------------------------------------------------------------------------------------------------------------
+// Experimental Feature: D3D12ExperimentalShaderModels
+//
+// Use with D3D12EnableExperimentalFeatures to enable experimental shader model support,
+// meaning shader models that haven't been finalized for use in retail.
+//
+// Enabling D3D12ExperimentalShaderModels needs no configuration struct, pass NULL in the pConfigurationStructs array.
+//
+// --------------------------------------------------------------------------------------------------------------------------------
+static const UUID D3D12ExperimentalShaderModels = { /* 76f5573e-f13a-40f5-b297-81ce9e18933f */
+    0x76f5573e,
+    0xf13a,
+    0x40f5,
+    { 0xb2, 0x97, 0x81, 0xce, 0x9e, 0x18, 0x93, 0x3f }
+};
+// --------------------------------------------------------------------------------------------------------------------------------
+// Experimental Feature: D3D12TiledResourceTier4
+//
+// Use with D3D12EnableExperimentalFeatures to enable tiled resource tier 4 support,
+// meaning texture tile data-inheritance is allowed.
+//
+// Enabling D3D12TiledResourceTier4 needs no configuration struct, pass NULL in the pConfigurationStructs array.
+//
+// --------------------------------------------------------------------------------------------------------------------------------
+static const UUID D3D12TiledResourceTier4 = { /* c9c4725f-a81a-4f56-8c5b-c51039d694fb */
+    0xc9c4725f,
+    0xa81a,
+    0x4f56,
+    { 0x8c, 0x5b, 0xc5, 0x10, 0x39, 0xd6, 0x94, 0xfb }
+};
+// --------------------------------------------------------------------------------------------------------------------------------
+// D3D12GetInterface
+//
+// Retrieve Global D3D12 Interface.
+//
+
+DEFINE_GUID(CLSID_D3D12Debug,                        0xf2352aeb, 0xdd84, 0x49fe, 0xb9, 0x7b, 0xa9, 0xdc, 0xfd, 0xcc, 0x1b, 0x4f);
+DEFINE_GUID(CLSID_D3D12Tools,                        0xe38216b1, 0x3c8c, 0x4833, 0xaa, 0x09, 0x0a, 0x06, 0xb6, 0x5d, 0x96, 0xc8);
+DEFINE_GUID(CLSID_D3D12DeviceRemovedExtendedData,    0x4a75bbc4, 0x9ff4, 0x4ad8, 0x9f, 0x18, 0xab, 0xae, 0x84, 0xdc, 0x5f, 0xf2);
+DEFINE_GUID(CLSID_D3D12SDKConfiguration,             0x7cda6aca, 0xa03e, 0x49c8, 0x94, 0x58, 0x03, 0x34, 0xd2, 0x0e, 0x07, 0xce);
+DEFINE_GUID(CLSID_D3D12DeviceFactory,                0x114863bf, 0xc386, 0x4aee, 0xb3, 0x9d, 0x8f, 0x0b, 0xbb, 0x06, 0x29, 0x55);
+
+typedef HRESULT (WINAPI* PFN_D3D12_GET_INTERFACE)( _In_ REFCLSID, _In_ REFIID, _COM_Outptr_opt_ void** );
+
+HRESULT WINAPI D3D12GetInterface( _In_ REFCLSID rclsid, _In_ REFIID riid, _COM_Outptr_opt_ void** ppvDebug );
+
+
+
+extern RPC_IF_HANDLE __MIDL_itf_d3d12_0000_0057_v0_0_c_ifspec;
+extern RPC_IF_HANDLE __MIDL_itf_d3d12_0000_0057_v0_0_s_ifspec;
+
+#ifndef __ID3D12SDKConfiguration_INTERFACE_DEFINED__
+#define __ID3D12SDKConfiguration_INTERFACE_DEFINED__
+
+/* interface ID3D12SDKConfiguration */
+/* [unique][local][object][uuid] */ 
+
+
+EXTERN_C const IID IID_ID3D12SDKConfiguration;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("e9eb5314-33aa-42b2-a718-d77f58b1f1c7")
+    ID3D12SDKConfiguration : public IUnknown
+    {
+    public:
+        virtual HRESULT STDMETHODCALLTYPE SetSDKVersion( 
+            UINT SDKVersion,
+            _In_z_  LPCSTR SDKPath) = 0;
+        
+    };
+    
+    
+#else 	/* C style interface */
+
+    typedef struct ID3D12SDKConfigurationVtbl
+    {
+        BEGIN_INTERFACE
+        
+        DECLSPEC_XFGVIRT(IUnknown, QueryInterface)
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            ID3D12SDKConfiguration * This,
+            REFIID riid,
+            _COM_Outptr_  void **ppvObject);
+        
+        DECLSPEC_XFGVIRT(IUnknown, AddRef)
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            ID3D12SDKConfiguration * This);
+        
+        DECLSPEC_XFGVIRT(IUnknown, Release)
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            ID3D12SDKConfiguration * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12SDKConfiguration, SetSDKVersion)
+        HRESULT ( STDMETHODCALLTYPE *SetSDKVersion )( 
+            ID3D12SDKConfiguration * This,
+            UINT SDKVersion,
+            _In_z_  LPCSTR SDKPath);
+        
+        END_INTERFACE
+    } ID3D12SDKConfigurationVtbl;
+
+    interface ID3D12SDKConfiguration
+    {
+        CONST_VTBL struct ID3D12SDKConfigurationVtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define ID3D12SDKConfiguration_QueryInterface(This,riid,ppvObject)	\
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define ID3D12SDKConfiguration_AddRef(This)	\
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define ID3D12SDKConfiguration_Release(This)	\
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#define ID3D12SDKConfiguration_SetSDKVersion(This,SDKVersion,SDKPath)	\
+    ( (This)->lpVtbl -> SetSDKVersion(This,SDKVersion,SDKPath) ) 
+
+#endif /* COBJMACROS */
+
+
+#endif 	/* C style interface */
+
+
+
+
+#endif 	/* __ID3D12SDKConfiguration_INTERFACE_DEFINED__ */
+
+
+#ifndef __ID3D12SDKConfiguration1_INTERFACE_DEFINED__
+#define __ID3D12SDKConfiguration1_INTERFACE_DEFINED__
+
+/* interface ID3D12SDKConfiguration1 */
+/* [unique][local][object][uuid] */ 
+
+
+EXTERN_C const IID IID_ID3D12SDKConfiguration1;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("8aaf9303-ad25-48b9-9a57-d9c37e009d9f")
+    ID3D12SDKConfiguration1 : public ID3D12SDKConfiguration
+    {
+    public:
+        virtual HRESULT STDMETHODCALLTYPE CreateDeviceFactory( 
+            UINT SDKVersion,
+            _In_  LPCSTR SDKPath,
+            REFIID riid,
+            _COM_Outptr_  void **ppvFactory) = 0;
+        
+        virtual void STDMETHODCALLTYPE FreeUnusedSDKs( void) = 0;
+        
+    };
+    
+    
+#else 	/* C style interface */
+
+    typedef struct ID3D12SDKConfiguration1Vtbl
+    {
+        BEGIN_INTERFACE
+        
+        DECLSPEC_XFGVIRT(IUnknown, QueryInterface)
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            ID3D12SDKConfiguration1 * This,
+            REFIID riid,
+            _COM_Outptr_  void **ppvObject);
+        
+        DECLSPEC_XFGVIRT(IUnknown, AddRef)
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            ID3D12SDKConfiguration1 * This);
+        
+        DECLSPEC_XFGVIRT(IUnknown, Release)
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            ID3D12SDKConfiguration1 * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12SDKConfiguration, SetSDKVersion)
+        HRESULT ( STDMETHODCALLTYPE *SetSDKVersion )( 
+            ID3D12SDKConfiguration1 * This,
+            UINT SDKVersion,
+            _In_z_  LPCSTR SDKPath);
+        
+        DECLSPEC_XFGVIRT(ID3D12SDKConfiguration1, CreateDeviceFactory)
+        HRESULT ( STDMETHODCALLTYPE *CreateDeviceFactory )( 
+            ID3D12SDKConfiguration1 * This,
+            UINT SDKVersion,
+            _In_  LPCSTR SDKPath,
+            REFIID riid,
+            _COM_Outptr_  void **ppvFactory);
+        
+        DECLSPEC_XFGVIRT(ID3D12SDKConfiguration1, FreeUnusedSDKs)
+        void ( STDMETHODCALLTYPE *FreeUnusedSDKs )( 
+            ID3D12SDKConfiguration1 * This);
+        
+        END_INTERFACE
+    } ID3D12SDKConfiguration1Vtbl;
+
+    interface ID3D12SDKConfiguration1
+    {
+        CONST_VTBL struct ID3D12SDKConfiguration1Vtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define ID3D12SDKConfiguration1_QueryInterface(This,riid,ppvObject)	\
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define ID3D12SDKConfiguration1_AddRef(This)	\
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define ID3D12SDKConfiguration1_Release(This)	\
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#define ID3D12SDKConfiguration1_SetSDKVersion(This,SDKVersion,SDKPath)	\
+    ( (This)->lpVtbl -> SetSDKVersion(This,SDKVersion,SDKPath) ) 
+
+
+#define ID3D12SDKConfiguration1_CreateDeviceFactory(This,SDKVersion,SDKPath,riid,ppvFactory)	\
+    ( (This)->lpVtbl -> CreateDeviceFactory(This,SDKVersion,SDKPath,riid,ppvFactory) ) 
+
+#define ID3D12SDKConfiguration1_FreeUnusedSDKs(This)	\
+    ( (This)->lpVtbl -> FreeUnusedSDKs(This) ) 
+
+#endif /* COBJMACROS */
+
+
+#endif 	/* C style interface */
+
+
+
+
+#endif 	/* __ID3D12SDKConfiguration1_INTERFACE_DEFINED__ */
+
+
+/* interface __MIDL_itf_d3d12_0000_0059 */
+/* [local] */ 
+
+typedef 
+enum D3D12_DEVICE_FACTORY_FLAGS
+    {
+        D3D12_DEVICE_FACTORY_FLAG_NONE	= 0,
+        D3D12_DEVICE_FACTORY_FLAG_ALLOW_RETURNING_EXISTING_DEVICE	= 0x1,
+        D3D12_DEVICE_FACTORY_FLAG_ALLOW_RETURNING_INCOMPATIBLE_EXISTING_DEVICE	= 0x2,
+        D3D12_DEVICE_FACTORY_FLAG_DISALLOW_STORING_NEW_DEVICE_AS_SINGLETON	= 0x4
+    } 	D3D12_DEVICE_FACTORY_FLAGS;
+
+DEFINE_ENUM_FLAG_OPERATORS( D3D12_DEVICE_FACTORY_FLAGS );
+
+
+extern RPC_IF_HANDLE __MIDL_itf_d3d12_0000_0059_v0_0_c_ifspec;
+extern RPC_IF_HANDLE __MIDL_itf_d3d12_0000_0059_v0_0_s_ifspec;
+
+#ifndef __ID3D12DeviceFactory_INTERFACE_DEFINED__
+#define __ID3D12DeviceFactory_INTERFACE_DEFINED__
+
+/* interface ID3D12DeviceFactory */
+/* [unique][local][object][uuid] */ 
+
+
+EXTERN_C const IID IID_ID3D12DeviceFactory;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("61f307d3-d34e-4e7c-8374-3ba4de23cccb")
+    ID3D12DeviceFactory : public IUnknown
+    {
+    public:
+        virtual HRESULT STDMETHODCALLTYPE InitializeFromGlobalState( void) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE ApplyToGlobalState( void) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE SetFlags( 
+            D3D12_DEVICE_FACTORY_FLAGS flags) = 0;
+        
+        virtual D3D12_DEVICE_FACTORY_FLAGS STDMETHODCALLTYPE GetFlags( void) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE GetConfigurationInterface( 
+            REFCLSID clsid,
+            REFIID iid,
+            _COM_Outptr_  void **ppv) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE EnableExperimentalFeatures( 
+            UINT NumFeatures,
+            _In_reads_(NumFeatures)  const IID *pIIDs,
+            _In_reads_opt_(NumFeatures)  void *pConfigurationStructs,
+            _In_reads_opt_(NumFeatures)  UINT *pConfigurationStructSizes) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE CreateDevice( 
+            _In_opt_  IUnknown *adapter,
+            D3D_FEATURE_LEVEL FeatureLevel,
+            REFIID riid,
+            _COM_Outptr_opt_  void **ppvDevice) = 0;
+        
+    };
+    
+    
+#else 	/* C style interface */
+
+    typedef struct ID3D12DeviceFactoryVtbl
+    {
+        BEGIN_INTERFACE
+        
+        DECLSPEC_XFGVIRT(IUnknown, QueryInterface)
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            ID3D12DeviceFactory * This,
+            REFIID riid,
+            _COM_Outptr_  void **ppvObject);
+        
+        DECLSPEC_XFGVIRT(IUnknown, AddRef)
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            ID3D12DeviceFactory * This);
+        
+        DECLSPEC_XFGVIRT(IUnknown, Release)
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            ID3D12DeviceFactory * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12DeviceFactory, InitializeFromGlobalState)
+        HRESULT ( STDMETHODCALLTYPE *InitializeFromGlobalState )( 
+            ID3D12DeviceFactory * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12DeviceFactory, ApplyToGlobalState)
+        HRESULT ( STDMETHODCALLTYPE *ApplyToGlobalState )( 
+            ID3D12DeviceFactory * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12DeviceFactory, SetFlags)
+        HRESULT ( STDMETHODCALLTYPE *SetFlags )( 
+            ID3D12DeviceFactory * This,
+            D3D12_DEVICE_FACTORY_FLAGS flags);
+        
+        DECLSPEC_XFGVIRT(ID3D12DeviceFactory, GetFlags)
+        D3D12_DEVICE_FACTORY_FLAGS ( STDMETHODCALLTYPE *GetFlags )( 
+            ID3D12DeviceFactory * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12DeviceFactory, GetConfigurationInterface)
+        HRESULT ( STDMETHODCALLTYPE *GetConfigurationInterface )( 
+            ID3D12DeviceFactory * This,
+            REFCLSID clsid,
+            REFIID iid,
+            _COM_Outptr_  void **ppv);
+        
+        DECLSPEC_XFGVIRT(ID3D12DeviceFactory, EnableExperimentalFeatures)
+        HRESULT ( STDMETHODCALLTYPE *EnableExperimentalFeatures )( 
+            ID3D12DeviceFactory * This,
+            UINT NumFeatures,
+            _In_reads_(NumFeatures)  const IID *pIIDs,
+            _In_reads_opt_(NumFeatures)  void *pConfigurationStructs,
+            _In_reads_opt_(NumFeatures)  UINT *pConfigurationStructSizes);
+        
+        DECLSPEC_XFGVIRT(ID3D12DeviceFactory, CreateDevice)
+        HRESULT ( STDMETHODCALLTYPE *CreateDevice )( 
+            ID3D12DeviceFactory * This,
+            _In_opt_  IUnknown *adapter,
+            D3D_FEATURE_LEVEL FeatureLevel,
+            REFIID riid,
+            _COM_Outptr_opt_  void **ppvDevice);
+        
+        END_INTERFACE
+    } ID3D12DeviceFactoryVtbl;
+
+    interface ID3D12DeviceFactory
+    {
+        CONST_VTBL struct ID3D12DeviceFactoryVtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define ID3D12DeviceFactory_QueryInterface(This,riid,ppvObject)	\
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define ID3D12DeviceFactory_AddRef(This)	\
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define ID3D12DeviceFactory_Release(This)	\
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#define ID3D12DeviceFactory_InitializeFromGlobalState(This)	\
+    ( (This)->lpVtbl -> InitializeFromGlobalState(This) ) 
+
+#define ID3D12DeviceFactory_ApplyToGlobalState(This)	\
+    ( (This)->lpVtbl -> ApplyToGlobalState(This) ) 
+
+#define ID3D12DeviceFactory_SetFlags(This,flags)	\
+    ( (This)->lpVtbl -> SetFlags(This,flags) ) 
+
+#define ID3D12DeviceFactory_GetFlags(This)	\
+    ( (This)->lpVtbl -> GetFlags(This) ) 
+
+#define ID3D12DeviceFactory_GetConfigurationInterface(This,clsid,iid,ppv)	\
+    ( (This)->lpVtbl -> GetConfigurationInterface(This,clsid,iid,ppv) ) 
+
+#define ID3D12DeviceFactory_EnableExperimentalFeatures(This,NumFeatures,pIIDs,pConfigurationStructs,pConfigurationStructSizes)	\
+    ( (This)->lpVtbl -> EnableExperimentalFeatures(This,NumFeatures,pIIDs,pConfigurationStructs,pConfigurationStructSizes) ) 
+
+#define ID3D12DeviceFactory_CreateDevice(This,adapter,FeatureLevel,riid,ppvDevice)	\
+    ( (This)->lpVtbl -> CreateDevice(This,adapter,FeatureLevel,riid,ppvDevice) ) 
+
+#endif /* COBJMACROS */
+
+
+#endif 	/* C style interface */
+
+
+
+
+#endif 	/* __ID3D12DeviceFactory_INTERFACE_DEFINED__ */
+
+
+/* interface __MIDL_itf_d3d12_0000_0060 */
+/* [local] */ 
+
+typedef 
+enum D3D12_DEVICE_FLAGS
+    {
+        D3D12_DEVICE_FLAG_NONE	= 0,
+        D3D12_DEVICE_FLAG_DEBUG_LAYER_ENABLED	= 0x1,
+        D3D12_DEVICE_FLAG_GPU_BASED_VALIDATION_ENABLED	= 0x2,
+        D3D12_DEVICE_FLAG_SYNCHRONIZED_COMMAND_QUEUE_VALIDATION_DISABLED	= 0x4,
+        D3D12_DEVICE_FLAG_DRED_AUTO_BREADCRUMBS_ENABLED	= 0x8,
+        D3D12_DEVICE_FLAG_DRED_PAGE_FAULT_REPORTING_ENABLED	= 0x10,
+        D3D12_DEVICE_FLAG_DRED_WATSON_REPORTING_ENABLED	= 0x20,
+        D3D12_DEVICE_FLAG_DRED_BREADCRUMB_CONTEXT_ENABLED	= 0x40,
+        D3D12_DEVICE_FLAG_DRED_USE_MARKERS_ONLY_BREADCRUMBS	= 0x80,
+        D3D12_DEVICE_FLAG_SHADER_INSTRUMENTATION_ENABLED	= 0x100,
+        D3D12_DEVICE_FLAG_AUTO_DEBUG_NAME_ENABLED	= 0x200,
+        D3D12_DEVICE_FLAG_FORCE_LEGACY_STATE_VALIDATION	= 0x400
+    } 	D3D12_DEVICE_FLAGS;
+
+DEFINE_ENUM_FLAG_OPERATORS( D3D12_DEVICE_FLAGS );
+typedef struct D3D12_DEVICE_CONFIGURATION_DESC
+    {
+    D3D12_DEVICE_FLAGS Flags;
+    UINT GpuBasedValidationFlags;
+    UINT SDKVersion;
+    UINT NumEnabledExperimentalFeatures;
+    } 	D3D12_DEVICE_CONFIGURATION_DESC;
+
+
+
+extern RPC_IF_HANDLE __MIDL_itf_d3d12_0000_0060_v0_0_c_ifspec;
+extern RPC_IF_HANDLE __MIDL_itf_d3d12_0000_0060_v0_0_s_ifspec;
+
+#ifndef __ID3D12DeviceConfiguration_INTERFACE_DEFINED__
+#define __ID3D12DeviceConfiguration_INTERFACE_DEFINED__
+
+/* interface ID3D12DeviceConfiguration */
+/* [unique][local][object][uuid] */ 
+
+
+EXTERN_C const IID IID_ID3D12DeviceConfiguration;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("78dbf87b-f766-422b-a61c-c8c446bdb9ad")
+    ID3D12DeviceConfiguration : public IUnknown
+    {
+    public:
+#if defined(_MSC_VER) || !defined(_WIN32)
+        virtual D3D12_DEVICE_CONFIGURATION_DESC STDMETHODCALLTYPE GetDesc( void) = 0;
+#else
+        virtual D3D12_DEVICE_CONFIGURATION_DESC *STDMETHODCALLTYPE GetDesc( 
+            D3D12_DEVICE_CONFIGURATION_DESC * RetVal) = 0;
+#endif
+        
+        virtual HRESULT STDMETHODCALLTYPE GetEnabledExperimentalFeatures( 
+            _Out_writes_(NumGuids)  GUID *pGuids,
+            UINT NumGuids) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE SerializeVersionedRootSignature( 
+            _In_  const D3D12_VERSIONED_ROOT_SIGNATURE_DESC *pDesc,
+            _COM_Outptr_  ID3DBlob **ppResult,
+            _Always_(_Outptr_opt_result_maybenull_)  ID3DBlob **ppError) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE CreateVersionedRootSignatureDeserializer( 
+            _In_reads_bytes_(Size)  const void *pBlob,
+            SIZE_T Size,
+            REFIID riid,
+            _COM_Outptr_  void **ppvDeserializer) = 0;
+        
+    };
+    
+    
+#else 	/* C style interface */
+
+    typedef struct ID3D12DeviceConfigurationVtbl
+    {
+        BEGIN_INTERFACE
+        
+        DECLSPEC_XFGVIRT(IUnknown, QueryInterface)
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            ID3D12DeviceConfiguration * This,
+            REFIID riid,
+            _COM_Outptr_  void **ppvObject);
+        
+        DECLSPEC_XFGVIRT(IUnknown, AddRef)
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            ID3D12DeviceConfiguration * This);
+        
+        DECLSPEC_XFGVIRT(IUnknown, Release)
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            ID3D12DeviceConfiguration * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12DeviceConfiguration, GetDesc)
+#if !defined(_WIN32)
+        D3D12_DEVICE_CONFIGURATION_DESC ( STDMETHODCALLTYPE *GetDesc )( 
+            ID3D12DeviceConfiguration * This);
+        
+#else
+        D3D12_DEVICE_CONFIGURATION_DESC *( STDMETHODCALLTYPE *GetDesc )( 
+            ID3D12DeviceConfiguration * This,
+            D3D12_DEVICE_CONFIGURATION_DESC * RetVal);
+        
+#endif
+        
+        DECLSPEC_XFGVIRT(ID3D12DeviceConfiguration, GetEnabledExperimentalFeatures)
+        HRESULT ( STDMETHODCALLTYPE *GetEnabledExperimentalFeatures )( 
+            ID3D12DeviceConfiguration * This,
+            _Out_writes_(NumGuids)  GUID *pGuids,
+            UINT NumGuids);
+        
+        DECLSPEC_XFGVIRT(ID3D12DeviceConfiguration, SerializeVersionedRootSignature)
+        HRESULT ( STDMETHODCALLTYPE *SerializeVersionedRootSignature )( 
+            ID3D12DeviceConfiguration * This,
+            _In_  const D3D12_VERSIONED_ROOT_SIGNATURE_DESC *pDesc,
+            _COM_Outptr_  ID3DBlob **ppResult,
+            _Always_(_Outptr_opt_result_maybenull_)  ID3DBlob **ppError);
+        
+        DECLSPEC_XFGVIRT(ID3D12DeviceConfiguration, CreateVersionedRootSignatureDeserializer)
+        HRESULT ( STDMETHODCALLTYPE *CreateVersionedRootSignatureDeserializer )( 
+            ID3D12DeviceConfiguration * This,
+            _In_reads_bytes_(Size)  const void *pBlob,
+            SIZE_T Size,
+            REFIID riid,
+            _COM_Outptr_  void **ppvDeserializer);
+        
+        END_INTERFACE
+    } ID3D12DeviceConfigurationVtbl;
+
+    interface ID3D12DeviceConfiguration
+    {
+        CONST_VTBL struct ID3D12DeviceConfigurationVtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define ID3D12DeviceConfiguration_QueryInterface(This,riid,ppvObject)	\
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define ID3D12DeviceConfiguration_AddRef(This)	\
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define ID3D12DeviceConfiguration_Release(This)	\
+    ( (This)->lpVtbl -> Release(This) ) 
+
+#if !defined(_WIN32)
+
+#define ID3D12DeviceConfiguration_GetDesc(This)	\
+    ( (This)->lpVtbl -> GetDesc(This) ) 
+#else
+#define ID3D12DeviceConfiguration_GetDesc(This,RetVal)	\
+    ( (This)->lpVtbl -> GetDesc(This,RetVal) ) 
+#endif
+
+#define ID3D12DeviceConfiguration_GetEnabledExperimentalFeatures(This,pGuids,NumGuids)	\
+    ( (This)->lpVtbl -> GetEnabledExperimentalFeatures(This,pGuids,NumGuids) ) 
+
+#define ID3D12DeviceConfiguration_SerializeVersionedRootSignature(This,pDesc,ppResult,ppError)	\
+    ( (This)->lpVtbl -> SerializeVersionedRootSignature(This,pDesc,ppResult,ppError) ) 
+
+#define ID3D12DeviceConfiguration_CreateVersionedRootSignatureDeserializer(This,pBlob,Size,riid,ppvDeserializer)	\
+    ( (This)->lpVtbl -> CreateVersionedRootSignatureDeserializer(This,pBlob,Size,riid,ppvDeserializer) ) 
+
+#endif /* COBJMACROS */
+
+
+#endif 	/* C style interface */
+
+
+
+
+#endif 	/* __ID3D12DeviceConfiguration_INTERFACE_DEFINED__ */
+
+
+/* interface __MIDL_itf_d3d12_0000_0061 */
+/* [local] */ 
+
+typedef 
+enum D3D12_AXIS_SHADING_RATE
+    {
+        D3D12_AXIS_SHADING_RATE_1X	= 0,
+        D3D12_AXIS_SHADING_RATE_2X	= 0x1,
+        D3D12_AXIS_SHADING_RATE_4X	= 0x2
+    } 	D3D12_AXIS_SHADING_RATE;
+
+#define D3D12_SHADING_RATE_X_AXIS_SHIFT 2
+#define D3D12_SHADING_RATE_VALID_MASK 3
+#define D3D12_MAKE_COARSE_SHADING_RATE(x,y) ((x) << D3D12_SHADING_RATE_X_AXIS_SHIFT | (y))
+#define D3D12_GET_COARSE_SHADING_RATE_X_AXIS(x) (((x) >> D3D12_SHADING_RATE_X_AXIS_SHIFT) & D3D12_SHADING_RATE_VALID_MASK)
+#define D3D12_GET_COARSE_SHADING_RATE_Y_AXIS(y) ((y) & D3D12_SHADING_RATE_VALID_MASK)
+typedef 
+enum D3D12_SHADING_RATE
+    {
+        D3D12_SHADING_RATE_1X1	= 0,
+        D3D12_SHADING_RATE_1X2	= 0x1,
+        D3D12_SHADING_RATE_2X1	= 0x4,
+        D3D12_SHADING_RATE_2X2	= 0x5,
+        D3D12_SHADING_RATE_2X4	= 0x6,
+        D3D12_SHADING_RATE_4X2	= 0x9,
+        D3D12_SHADING_RATE_4X4	= 0xa
+    } 	D3D12_SHADING_RATE;
+
+typedef 
+enum D3D12_SHADING_RATE_COMBINER
+    {
+        D3D12_SHADING_RATE_COMBINER_PASSTHROUGH	= 0,
+        D3D12_SHADING_RATE_COMBINER_OVERRIDE	= 1,
+        D3D12_SHADING_RATE_COMBINER_MIN	= 2,
+        D3D12_SHADING_RATE_COMBINER_MAX	= 3,
+        D3D12_SHADING_RATE_COMBINER_SUM	= 4
+    } 	D3D12_SHADING_RATE_COMBINER;
+
+
+
+extern RPC_IF_HANDLE __MIDL_itf_d3d12_0000_0061_v0_0_c_ifspec;
+extern RPC_IF_HANDLE __MIDL_itf_d3d12_0000_0061_v0_0_s_ifspec;
+
+#ifndef __ID3D12GraphicsCommandList5_INTERFACE_DEFINED__
+#define __ID3D12GraphicsCommandList5_INTERFACE_DEFINED__
+
+/* interface ID3D12GraphicsCommandList5 */
+/* [unique][local][object][uuid] */ 
+
+
+EXTERN_C const IID IID_ID3D12GraphicsCommandList5;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("55050859-4024-474c-87f5-6472eaee44ea")
+    ID3D12GraphicsCommandList5 : public ID3D12GraphicsCommandList4
+    {
+    public:
+        virtual void STDMETHODCALLTYPE RSSetShadingRate( 
+            _In_  D3D12_SHADING_RATE baseShadingRate,
+            _In_reads_opt_(D3D12_RS_SET_SHADING_RATE_COMBINER_COUNT)  const D3D12_SHADING_RATE_COMBINER *combiners) = 0;
+        
+        virtual void STDMETHODCALLTYPE RSSetShadingRateImage( 
+            _In_opt_  ID3D12Resource *shadingRateImage) = 0;
+        
+    };
+    
+    
+#else 	/* C style interface */
+
+    typedef struct ID3D12GraphicsCommandList5Vtbl
+    {
+        BEGIN_INTERFACE
+        
+        DECLSPEC_XFGVIRT(IUnknown, QueryInterface)
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            ID3D12GraphicsCommandList5 * This,
+            REFIID riid,
+            _COM_Outptr_  void **ppvObject);
+        
+        DECLSPEC_XFGVIRT(IUnknown, AddRef)
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            ID3D12GraphicsCommandList5 * This);
+        
+        DECLSPEC_XFGVIRT(IUnknown, Release)
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            ID3D12GraphicsCommandList5 * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, GetPrivateData)
+        HRESULT ( STDMETHODCALLTYPE *GetPrivateData )( 
+            ID3D12GraphicsCommandList5 * This,
+            _In_  REFGUID guid,
+            _Inout_  UINT *pDataSize,
+            _Out_writes_bytes_opt_( *pDataSize )  void *pData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, SetPrivateData)
+        HRESULT ( STDMETHODCALLTYPE *SetPrivateData )( 
+            ID3D12GraphicsCommandList5 * This,
+            _In_  REFGUID guid,
+            _In_  UINT DataSize,
+            _In_reads_bytes_opt_( DataSize )  const void *pData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, SetPrivateDataInterface)
+        HRESULT ( STDMETHODCALLTYPE *SetPrivateDataInterface )( 
+            ID3D12GraphicsCommandList5 * This,
+            _In_  REFGUID guid,
+            _In_opt_  const IUnknown *pData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, SetName)
+        HRESULT ( STDMETHODCALLTYPE *SetName )( 
+            ID3D12GraphicsCommandList5 * This,
+            _In_z_  LPCWSTR Name);
+        
+        DECLSPEC_XFGVIRT(ID3D12DeviceChild, GetDevice)
+        HRESULT ( STDMETHODCALLTYPE *GetDevice )( 
+            ID3D12GraphicsCommandList5 * This,
+            REFIID riid,
+            _COM_Outptr_opt_  void **ppvDevice);
+        
+        DECLSPEC_XFGVIRT(ID3D12CommandList, GetType)
+        D3D12_COMMAND_LIST_TYPE ( STDMETHODCALLTYPE *GetType )( 
+            ID3D12GraphicsCommandList5 * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, Close)
+        HRESULT ( STDMETHODCALLTYPE *Close )( 
+            ID3D12GraphicsCommandList5 * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, Reset)
+        HRESULT ( STDMETHODCALLTYPE *Reset )( 
+            ID3D12GraphicsCommandList5 * This,
+            _In_  ID3D12CommandAllocator *pAllocator,
+            _In_opt_  ID3D12PipelineState *pInitialState);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, ClearState)
+        void ( STDMETHODCALLTYPE *ClearState )( 
+            ID3D12GraphicsCommandList5 * This,
+            _In_opt_  ID3D12PipelineState *pPipelineState);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, DrawInstanced)
+        void ( STDMETHODCALLTYPE *DrawInstanced )( 
+            ID3D12GraphicsCommandList5 * This,
+            _In_  UINT VertexCountPerInstance,
+            _In_  UINT InstanceCount,
+            _In_  UINT StartVertexLocation,
+            _In_  UINT StartInstanceLocation);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, DrawIndexedInstanced)
+        void ( STDMETHODCALLTYPE *DrawIndexedInstanced )( 
+            ID3D12GraphicsCommandList5 * This,
+            _In_  UINT IndexCountPerInstance,
+            _In_  UINT InstanceCount,
+            _In_  UINT StartIndexLocation,
+            _In_  INT BaseVertexLocation,
+            _In_  UINT StartInstanceLocation);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, Dispatch)
+        void ( STDMETHODCALLTYPE *Dispatch )( 
+            ID3D12GraphicsCommandList5 * This,
+            _In_  UINT ThreadGroupCountX,
+            _In_  UINT ThreadGroupCountY,
+            _In_  UINT ThreadGroupCountZ);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, CopyBufferRegion)
+        void ( STDMETHODCALLTYPE *CopyBufferRegion )( 
+            ID3D12GraphicsCommandList5 * This,
+            _In_  ID3D12Resource *pDstBuffer,
+            UINT64 DstOffset,
+            _In_  ID3D12Resource *pSrcBuffer,
+            UINT64 SrcOffset,
+            UINT64 NumBytes);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, CopyTextureRegion)
+        void ( STDMETHODCALLTYPE *CopyTextureRegion )( 
+            ID3D12GraphicsCommandList5 * This,
+            _In_  const D3D12_TEXTURE_COPY_LOCATION *pDst,
+            UINT DstX,
+            UINT DstY,
+            UINT DstZ,
+            _In_  const D3D12_TEXTURE_COPY_LOCATION *pSrc,
+            _In_opt_  const D3D12_BOX *pSrcBox);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, CopyResource)
+        void ( STDMETHODCALLTYPE *CopyResource )( 
+            ID3D12GraphicsCommandList5 * This,
+            _In_  ID3D12Resource *pDstResource,
+            _In_  ID3D12Resource *pSrcResource);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, CopyTiles)
+        void ( STDMETHODCALLTYPE *CopyTiles )( 
+            ID3D12GraphicsCommandList5 * This,
+            _In_  ID3D12Resource *pTiledResource,
+            _In_  const D3D12_TILED_RESOURCE_COORDINATE *pTileRegionStartCoordinate,
+            _In_  const D3D12_TILE_REGION_SIZE *pTileRegionSize,
+            _In_  ID3D12Resource *pBuffer,
+            UINT64 BufferStartOffsetInBytes,
+            D3D12_TILE_COPY_FLAGS Flags);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, ResolveSubresource)
+        void ( STDMETHODCALLTYPE *ResolveSubresource )( 
+            ID3D12GraphicsCommandList5 * This,
+            _In_  ID3D12Resource *pDstResource,
+            _In_  UINT DstSubresource,
+            _In_  ID3D12Resource *pSrcResource,
+            _In_  UINT SrcSubresource,
+            _In_  DXGI_FORMAT Format);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, IASetPrimitiveTopology)
+        void ( STDMETHODCALLTYPE *IASetPrimitiveTopology )( 
+            ID3D12GraphicsCommandList5 * This,
+            _In_  D3D12_PRIMITIVE_TOPOLOGY PrimitiveTopology);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, RSSetViewports)
+        void ( STDMETHODCALLTYPE *RSSetViewports )( 
+            ID3D12GraphicsCommandList5 * This,
+            _In_range_(0, D3D12_VIEWPORT_AND_SCISSORRECT_OBJECT_COUNT_PER_PIPELINE)  UINT NumViewports,
+            _In_reads_( NumViewports)  const D3D12_VIEWPORT *pViewports);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, RSSetScissorRects)
+        void ( STDMETHODCALLTYPE *RSSetScissorRects )( 
+            ID3D12GraphicsCommandList5 * This,
+            _In_range_(0, D3D12_VIEWPORT_AND_SCISSORRECT_OBJECT_COUNT_PER_PIPELINE)  UINT NumRects,
+            _In_reads_( NumRects)  const D3D12_RECT *pRects);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, OMSetBlendFactor)
+        void ( STDMETHODCALLTYPE *OMSetBlendFactor )( 
+            ID3D12GraphicsCommandList5 * This,
+            _In_reads_opt_(4)  const FLOAT BlendFactor[ 4 ]);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, OMSetStencilRef)
+        void ( STDMETHODCALLTYPE *OMSetStencilRef )( 
+            ID3D12GraphicsCommandList5 * This,
+            _In_  UINT StencilRef);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetPipelineState)
+        void ( STDMETHODCALLTYPE *SetPipelineState )( 
+            ID3D12GraphicsCommandList5 * This,
+            _In_  ID3D12PipelineState *pPipelineState);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, ResourceBarrier)
+        void ( STDMETHODCALLTYPE *ResourceBarrier )( 
+            ID3D12GraphicsCommandList5 * This,
+            _In_  UINT NumBarriers,
+            _In_reads_(NumBarriers)  const D3D12_RESOURCE_BARRIER *pBarriers);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, ExecuteBundle)
+        void ( STDMETHODCALLTYPE *ExecuteBundle )( 
+            ID3D12GraphicsCommandList5 * This,
+            _In_  ID3D12GraphicsCommandList *pCommandList);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetDescriptorHeaps)
+        void ( STDMETHODCALLTYPE *SetDescriptorHeaps )( 
+            ID3D12GraphicsCommandList5 * This,
+            _In_  UINT NumDescriptorHeaps,
+            _In_reads_(NumDescriptorHeaps)  ID3D12DescriptorHeap *const *ppDescriptorHeaps);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetComputeRootSignature)
+        void ( STDMETHODCALLTYPE *SetComputeRootSignature )( 
+            ID3D12GraphicsCommandList5 * This,
+            _In_opt_  ID3D12RootSignature *pRootSignature);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetGraphicsRootSignature)
+        void ( STDMETHODCALLTYPE *SetGraphicsRootSignature )( 
+            ID3D12GraphicsCommandList5 * This,
+            _In_opt_  ID3D12RootSignature *pRootSignature);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetComputeRootDescriptorTable)
+        void ( STDMETHODCALLTYPE *SetComputeRootDescriptorTable )( 
+            ID3D12GraphicsCommandList5 * This,
+            _In_  UINT RootParameterIndex,
+            _In_  D3D12_GPU_DESCRIPTOR_HANDLE BaseDescriptor);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetGraphicsRootDescriptorTable)
+        void ( STDMETHODCALLTYPE *SetGraphicsRootDescriptorTable )( 
+            ID3D12GraphicsCommandList5 * This,
+            _In_  UINT RootParameterIndex,
+            _In_  D3D12_GPU_DESCRIPTOR_HANDLE BaseDescriptor);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetComputeRoot32BitConstant)
+        void ( STDMETHODCALLTYPE *SetComputeRoot32BitConstant )( 
+            ID3D12GraphicsCommandList5 * This,
+            _In_  UINT RootParameterIndex,
+            _In_  UINT SrcData,
+            _In_  UINT DestOffsetIn32BitValues);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetGraphicsRoot32BitConstant)
+        void ( STDMETHODCALLTYPE *SetGraphicsRoot32BitConstant )( 
+            ID3D12GraphicsCommandList5 * This,
+            _In_  UINT RootParameterIndex,
+            _In_  UINT SrcData,
+            _In_  UINT DestOffsetIn32BitValues);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetComputeRoot32BitConstants)
+        void ( STDMETHODCALLTYPE *SetComputeRoot32BitConstants )( 
+            ID3D12GraphicsCommandList5 * This,
+            _In_  UINT RootParameterIndex,
+            _In_  UINT Num32BitValuesToSet,
+            _In_reads_(Num32BitValuesToSet*sizeof(UINT))  const void *pSrcData,
+            _In_  UINT DestOffsetIn32BitValues);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetGraphicsRoot32BitConstants)
+        void ( STDMETHODCALLTYPE *SetGraphicsRoot32BitConstants )( 
+            ID3D12GraphicsCommandList5 * This,
+            _In_  UINT RootParameterIndex,
+            _In_  UINT Num32BitValuesToSet,
+            _In_reads_(Num32BitValuesToSet*sizeof(UINT))  const void *pSrcData,
+            _In_  UINT DestOffsetIn32BitValues);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetComputeRootConstantBufferView)
+        void ( STDMETHODCALLTYPE *SetComputeRootConstantBufferView )( 
+            ID3D12GraphicsCommandList5 * This,
+            _In_  UINT RootParameterIndex,
+            _In_  D3D12_GPU_VIRTUAL_ADDRESS BufferLocation);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetGraphicsRootConstantBufferView)
+        void ( STDMETHODCALLTYPE *SetGraphicsRootConstantBufferView )( 
+            ID3D12GraphicsCommandList5 * This,
+            _In_  UINT RootParameterIndex,
+            _In_  D3D12_GPU_VIRTUAL_ADDRESS BufferLocation);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetComputeRootShaderResourceView)
+        void ( STDMETHODCALLTYPE *SetComputeRootShaderResourceView )( 
+            ID3D12GraphicsCommandList5 * This,
+            _In_  UINT RootParameterIndex,
+            _In_  D3D12_GPU_VIRTUAL_ADDRESS BufferLocation);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetGraphicsRootShaderResourceView)
+        void ( STDMETHODCALLTYPE *SetGraphicsRootShaderResourceView )( 
+            ID3D12GraphicsCommandList5 * This,
+            _In_  UINT RootParameterIndex,
+            _In_  D3D12_GPU_VIRTUAL_ADDRESS BufferLocation);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetComputeRootUnorderedAccessView)
+        void ( STDMETHODCALLTYPE *SetComputeRootUnorderedAccessView )( 
+            ID3D12GraphicsCommandList5 * This,
+            _In_  UINT RootParameterIndex,
+            _In_  D3D12_GPU_VIRTUAL_ADDRESS BufferLocation);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetGraphicsRootUnorderedAccessView)
+        void ( STDMETHODCALLTYPE *SetGraphicsRootUnorderedAccessView )( 
+            ID3D12GraphicsCommandList5 * This,
+            _In_  UINT RootParameterIndex,
+            _In_  D3D12_GPU_VIRTUAL_ADDRESS BufferLocation);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, IASetIndexBuffer)
+        void ( STDMETHODCALLTYPE *IASetIndexBuffer )( 
+            ID3D12GraphicsCommandList5 * This,
+            _In_opt_  const D3D12_INDEX_BUFFER_VIEW *pView);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, IASetVertexBuffers)
+        void ( STDMETHODCALLTYPE *IASetVertexBuffers )( 
+            ID3D12GraphicsCommandList5 * This,
+            _In_  UINT StartSlot,
+            _In_  UINT NumViews,
+            _In_reads_opt_(NumViews)  const D3D12_VERTEX_BUFFER_VIEW *pViews);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SOSetTargets)
+        void ( STDMETHODCALLTYPE *SOSetTargets )( 
+            ID3D12GraphicsCommandList5 * This,
+            _In_  UINT StartSlot,
+            _In_  UINT NumViews,
+            _In_reads_opt_(NumViews)  const D3D12_STREAM_OUTPUT_BUFFER_VIEW *pViews);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, OMSetRenderTargets)
+        void ( STDMETHODCALLTYPE *OMSetRenderTargets )( 
+            ID3D12GraphicsCommandList5 * This,
+            _In_  UINT NumRenderTargetDescriptors,
+            _In_opt_  const D3D12_CPU_DESCRIPTOR_HANDLE *pRenderTargetDescriptors,
+            _In_  BOOL RTsSingleHandleToDescriptorRange,
+            _In_opt_  const D3D12_CPU_DESCRIPTOR_HANDLE *pDepthStencilDescriptor);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, ClearDepthStencilView)
+        void ( STDMETHODCALLTYPE *ClearDepthStencilView )( 
+            ID3D12GraphicsCommandList5 * This,
+            _In_  D3D12_CPU_DESCRIPTOR_HANDLE DepthStencilView,
+            _In_  D3D12_CLEAR_FLAGS ClearFlags,
+            _In_  FLOAT Depth,
+            _In_  UINT8 Stencil,
+            _In_  UINT NumRects,
+            _In_reads_(NumRects)  const D3D12_RECT *pRects);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, ClearRenderTargetView)
+        void ( STDMETHODCALLTYPE *ClearRenderTargetView )( 
+            ID3D12GraphicsCommandList5 * This,
+            _In_  D3D12_CPU_DESCRIPTOR_HANDLE RenderTargetView,
+            _In_  const FLOAT ColorRGBA[ 4 ],
+            _In_  UINT NumRects,
+            _In_reads_(NumRects)  const D3D12_RECT *pRects);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, ClearUnorderedAccessViewUint)
+        void ( STDMETHODCALLTYPE *ClearUnorderedAccessViewUint )( 
+            ID3D12GraphicsCommandList5 * This,
+            _In_  D3D12_GPU_DESCRIPTOR_HANDLE ViewGPUHandleInCurrentHeap,
+            _In_  D3D12_CPU_DESCRIPTOR_HANDLE ViewCPUHandle,
+            _In_  ID3D12Resource *pResource,
+            _In_  const UINT Values[ 4 ],
+            _In_  UINT NumRects,
+            _In_reads_(NumRects)  const D3D12_RECT *pRects);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, ClearUnorderedAccessViewFloat)
+        void ( STDMETHODCALLTYPE *ClearUnorderedAccessViewFloat )( 
+            ID3D12GraphicsCommandList5 * This,
+            _In_  D3D12_GPU_DESCRIPTOR_HANDLE ViewGPUHandleInCurrentHeap,
+            _In_  D3D12_CPU_DESCRIPTOR_HANDLE ViewCPUHandle,
+            _In_  ID3D12Resource *pResource,
+            _In_  const FLOAT Values[ 4 ],
+            _In_  UINT NumRects,
+            _In_reads_(NumRects)  const D3D12_RECT *pRects);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, DiscardResource)
+        void ( STDMETHODCALLTYPE *DiscardResource )( 
+            ID3D12GraphicsCommandList5 * This,
+            _In_  ID3D12Resource *pResource,
+            _In_opt_  const D3D12_DISCARD_REGION *pRegion);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, BeginQuery)
+        void ( STDMETHODCALLTYPE *BeginQuery )( 
+            ID3D12GraphicsCommandList5 * This,
+            _In_  ID3D12QueryHeap *pQueryHeap,
+            _In_  D3D12_QUERY_TYPE Type,
+            _In_  UINT Index);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, EndQuery)
+        void ( STDMETHODCALLTYPE *EndQuery )( 
+            ID3D12GraphicsCommandList5 * This,
+            _In_  ID3D12QueryHeap *pQueryHeap,
+            _In_  D3D12_QUERY_TYPE Type,
+            _In_  UINT Index);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, ResolveQueryData)
+        void ( STDMETHODCALLTYPE *ResolveQueryData )( 
+            ID3D12GraphicsCommandList5 * This,
+            _In_  ID3D12QueryHeap *pQueryHeap,
+            _In_  D3D12_QUERY_TYPE Type,
+            _In_  UINT StartIndex,
+            _In_  UINT NumQueries,
+            _In_  ID3D12Resource *pDestinationBuffer,
+            _In_  UINT64 AlignedDestinationBufferOffset);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetPredication)
+        void ( STDMETHODCALLTYPE *SetPredication )( 
+            ID3D12GraphicsCommandList5 * This,
+            _In_opt_  ID3D12Resource *pBuffer,
+            _In_  UINT64 AlignedBufferOffset,
+            _In_  D3D12_PREDICATION_OP Operation);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetMarker)
+        void ( STDMETHODCALLTYPE *SetMarker )( 
+            ID3D12GraphicsCommandList5 * This,
+            UINT Metadata,
+            _In_reads_bytes_opt_(Size)  const void *pData,
+            UINT Size);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, BeginEvent)
+        void ( STDMETHODCALLTYPE *BeginEvent )( 
+            ID3D12GraphicsCommandList5 * This,
+            UINT Metadata,
+            _In_reads_bytes_opt_(Size)  const void *pData,
+            UINT Size);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, EndEvent)
+        void ( STDMETHODCALLTYPE *EndEvent )( 
+            ID3D12GraphicsCommandList5 * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, ExecuteIndirect)
+        void ( STDMETHODCALLTYPE *ExecuteIndirect )( 
+            ID3D12GraphicsCommandList5 * This,
+            _In_  ID3D12CommandSignature *pCommandSignature,
+            _In_  UINT MaxCommandCount,
+            _In_  ID3D12Resource *pArgumentBuffer,
+            _In_  UINT64 ArgumentBufferOffset,
+            _In_opt_  ID3D12Resource *pCountBuffer,
+            _In_  UINT64 CountBufferOffset);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList1, AtomicCopyBufferUINT)
+        void ( STDMETHODCALLTYPE *AtomicCopyBufferUINT )( 
+            ID3D12GraphicsCommandList5 * This,
+            _In_  ID3D12Resource *pDstBuffer,
+            UINT64 DstOffset,
+            _In_  ID3D12Resource *pSrcBuffer,
+            UINT64 SrcOffset,
+            UINT Dependencies,
+            _In_reads_(Dependencies)  ID3D12Resource *const *ppDependentResources,
+            _In_reads_(Dependencies)  const D3D12_SUBRESOURCE_RANGE_UINT64 *pDependentSubresourceRanges);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList1, AtomicCopyBufferUINT64)
+        void ( STDMETHODCALLTYPE *AtomicCopyBufferUINT64 )( 
+            ID3D12GraphicsCommandList5 * This,
+            _In_  ID3D12Resource *pDstBuffer,
+            UINT64 DstOffset,
+            _In_  ID3D12Resource *pSrcBuffer,
+            UINT64 SrcOffset,
+            UINT Dependencies,
+            _In_reads_(Dependencies)  ID3D12Resource *const *ppDependentResources,
+            _In_reads_(Dependencies)  const D3D12_SUBRESOURCE_RANGE_UINT64 *pDependentSubresourceRanges);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList1, OMSetDepthBounds)
+        void ( STDMETHODCALLTYPE *OMSetDepthBounds )( 
+            ID3D12GraphicsCommandList5 * This,
+            _In_  FLOAT Min,
+            _In_  FLOAT Max);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList1, SetSamplePositions)
+        void ( STDMETHODCALLTYPE *SetSamplePositions )( 
+            ID3D12GraphicsCommandList5 * This,
+            _In_  UINT NumSamplesPerPixel,
+            _In_  UINT NumPixels,
+            _In_reads_(NumSamplesPerPixel*NumPixels)  D3D12_SAMPLE_POSITION *pSamplePositions);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList1, ResolveSubresourceRegion)
+        void ( STDMETHODCALLTYPE *ResolveSubresourceRegion )( 
+            ID3D12GraphicsCommandList5 * This,
+            _In_  ID3D12Resource *pDstResource,
+            _In_  UINT DstSubresource,
+            _In_  UINT DstX,
+            _In_  UINT DstY,
+            _In_  ID3D12Resource *pSrcResource,
+            _In_  UINT SrcSubresource,
+            _In_opt_  D3D12_RECT *pSrcRect,
+            _In_  DXGI_FORMAT Format,
+            _In_  D3D12_RESOLVE_MODE ResolveMode);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList1, SetViewInstanceMask)
+        void ( STDMETHODCALLTYPE *SetViewInstanceMask )( 
+            ID3D12GraphicsCommandList5 * This,
+            _In_  UINT Mask);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList2, WriteBufferImmediate)
+        void ( STDMETHODCALLTYPE *WriteBufferImmediate )( 
+            ID3D12GraphicsCommandList5 * This,
+            UINT Count,
+            _In_reads_(Count)  const D3D12_WRITEBUFFERIMMEDIATE_PARAMETER *pParams,
+            _In_reads_opt_(Count)  const D3D12_WRITEBUFFERIMMEDIATE_MODE *pModes);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList3, SetProtectedResourceSession)
+        void ( STDMETHODCALLTYPE *SetProtectedResourceSession )( 
+            ID3D12GraphicsCommandList5 * This,
+            _In_opt_  ID3D12ProtectedResourceSession *pProtectedResourceSession);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList4, BeginRenderPass)
+        void ( STDMETHODCALLTYPE *BeginRenderPass )( 
+            ID3D12GraphicsCommandList5 * This,
+            _In_  UINT NumRenderTargets,
+            _In_reads_opt_(NumRenderTargets)  const D3D12_RENDER_PASS_RENDER_TARGET_DESC *pRenderTargets,
+            _In_opt_  const D3D12_RENDER_PASS_DEPTH_STENCIL_DESC *pDepthStencil,
+            D3D12_RENDER_PASS_FLAGS Flags);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList4, EndRenderPass)
+        void ( STDMETHODCALLTYPE *EndRenderPass )( 
+            ID3D12GraphicsCommandList5 * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList4, InitializeMetaCommand)
+        void ( STDMETHODCALLTYPE *InitializeMetaCommand )( 
+            ID3D12GraphicsCommandList5 * This,
+            _In_  ID3D12MetaCommand *pMetaCommand,
+            _In_reads_bytes_opt_(InitializationParametersDataSizeInBytes)  const void *pInitializationParametersData,
+            _In_  SIZE_T InitializationParametersDataSizeInBytes);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList4, ExecuteMetaCommand)
+        void ( STDMETHODCALLTYPE *ExecuteMetaCommand )( 
+            ID3D12GraphicsCommandList5 * This,
+            _In_  ID3D12MetaCommand *pMetaCommand,
+            _In_reads_bytes_opt_(ExecutionParametersDataSizeInBytes)  const void *pExecutionParametersData,
+            _In_  SIZE_T ExecutionParametersDataSizeInBytes);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList4, BuildRaytracingAccelerationStructure)
+        void ( STDMETHODCALLTYPE *BuildRaytracingAccelerationStructure )( 
+            ID3D12GraphicsCommandList5 * This,
+            _In_  const D3D12_BUILD_RAYTRACING_ACCELERATION_STRUCTURE_DESC *pDesc,
+            _In_  UINT NumPostbuildInfoDescs,
+            _In_reads_opt_(NumPostbuildInfoDescs)  const D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_DESC *pPostbuildInfoDescs);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList4, EmitRaytracingAccelerationStructurePostbuildInfo)
+        void ( STDMETHODCALLTYPE *EmitRaytracingAccelerationStructurePostbuildInfo )( 
+            ID3D12GraphicsCommandList5 * This,
+            _In_  const D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_DESC *pDesc,
+            _In_  UINT NumSourceAccelerationStructures,
+            _In_reads_( NumSourceAccelerationStructures )  const D3D12_GPU_VIRTUAL_ADDRESS *pSourceAccelerationStructureData);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList4, CopyRaytracingAccelerationStructure)
+        void ( STDMETHODCALLTYPE *CopyRaytracingAccelerationStructure )( 
+            ID3D12GraphicsCommandList5 * This,
+            _In_  D3D12_GPU_VIRTUAL_ADDRESS DestAccelerationStructureData,
+            _In_  D3D12_GPU_VIRTUAL_ADDRESS SourceAccelerationStructureData,
+            _In_  D3D12_RAYTRACING_ACCELERATION_STRUCTURE_COPY_MODE Mode);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList4, SetPipelineState1)
+        void ( STDMETHODCALLTYPE *SetPipelineState1 )( 
+            ID3D12GraphicsCommandList5 * This,
+            _In_  ID3D12StateObject *pStateObject);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList4, DispatchRays)
+        void ( STDMETHODCALLTYPE *DispatchRays )( 
+            ID3D12GraphicsCommandList5 * This,
+            _In_  const D3D12_DISPATCH_RAYS_DESC *pDesc);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList5, RSSetShadingRate)
+        void ( STDMETHODCALLTYPE *RSSetShadingRate )( 
+            ID3D12GraphicsCommandList5 * This,
+            _In_  D3D12_SHADING_RATE baseShadingRate,
+            _In_reads_opt_(D3D12_RS_SET_SHADING_RATE_COMBINER_COUNT)  const D3D12_SHADING_RATE_COMBINER *combiners);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList5, RSSetShadingRateImage)
+        void ( STDMETHODCALLTYPE *RSSetShadingRateImage )( 
+            ID3D12GraphicsCommandList5 * This,
+            _In_opt_  ID3D12Resource *shadingRateImage);
+        
+        END_INTERFACE
+    } ID3D12GraphicsCommandList5Vtbl;
+
+    interface ID3D12GraphicsCommandList5
+    {
+        CONST_VTBL struct ID3D12GraphicsCommandList5Vtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define ID3D12GraphicsCommandList5_QueryInterface(This,riid,ppvObject)	\
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define ID3D12GraphicsCommandList5_AddRef(This)	\
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define ID3D12GraphicsCommandList5_Release(This)	\
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#define ID3D12GraphicsCommandList5_GetPrivateData(This,guid,pDataSize,pData)	\
+    ( (This)->lpVtbl -> GetPrivateData(This,guid,pDataSize,pData) ) 
+
+#define ID3D12GraphicsCommandList5_SetPrivateData(This,guid,DataSize,pData)	\
+    ( (This)->lpVtbl -> SetPrivateData(This,guid,DataSize,pData) ) 
+
+#define ID3D12GraphicsCommandList5_SetPrivateDataInterface(This,guid,pData)	\
+    ( (This)->lpVtbl -> SetPrivateDataInterface(This,guid,pData) ) 
+
+#define ID3D12GraphicsCommandList5_SetName(This,Name)	\
+    ( (This)->lpVtbl -> SetName(This,Name) ) 
+
+
+#define ID3D12GraphicsCommandList5_GetDevice(This,riid,ppvDevice)	\
+    ( (This)->lpVtbl -> GetDevice(This,riid,ppvDevice) ) 
+
+
+#define ID3D12GraphicsCommandList5_GetType(This)	\
+    ( (This)->lpVtbl -> GetType(This) ) 
+
+
+#define ID3D12GraphicsCommandList5_Close(This)	\
+    ( (This)->lpVtbl -> Close(This) ) 
+
+#define ID3D12GraphicsCommandList5_Reset(This,pAllocator,pInitialState)	\
+    ( (This)->lpVtbl -> Reset(This,pAllocator,pInitialState) ) 
+
+#define ID3D12GraphicsCommandList5_ClearState(This,pPipelineState)	\
+    ( (This)->lpVtbl -> ClearState(This,pPipelineState) ) 
+
+#define ID3D12GraphicsCommandList5_DrawInstanced(This,VertexCountPerInstance,InstanceCount,StartVertexLocation,StartInstanceLocation)	\
+    ( (This)->lpVtbl -> DrawInstanced(This,VertexCountPerInstance,InstanceCount,StartVertexLocation,StartInstanceLocation) ) 
+
+#define ID3D12GraphicsCommandList5_DrawIndexedInstanced(This,IndexCountPerInstance,InstanceCount,StartIndexLocation,BaseVertexLocation,StartInstanceLocation)	\
+    ( (This)->lpVtbl -> DrawIndexedInstanced(This,IndexCountPerInstance,InstanceCount,StartIndexLocation,BaseVertexLocation,StartInstanceLocation) ) 
+
+#define ID3D12GraphicsCommandList5_Dispatch(This,ThreadGroupCountX,ThreadGroupCountY,ThreadGroupCountZ)	\
+    ( (This)->lpVtbl -> Dispatch(This,ThreadGroupCountX,ThreadGroupCountY,ThreadGroupCountZ) ) 
+
+#define ID3D12GraphicsCommandList5_CopyBufferRegion(This,pDstBuffer,DstOffset,pSrcBuffer,SrcOffset,NumBytes)	\
+    ( (This)->lpVtbl -> CopyBufferRegion(This,pDstBuffer,DstOffset,pSrcBuffer,SrcOffset,NumBytes) ) 
+
+#define ID3D12GraphicsCommandList5_CopyTextureRegion(This,pDst,DstX,DstY,DstZ,pSrc,pSrcBox)	\
+    ( (This)->lpVtbl -> CopyTextureRegion(This,pDst,DstX,DstY,DstZ,pSrc,pSrcBox) ) 
+
+#define ID3D12GraphicsCommandList5_CopyResource(This,pDstResource,pSrcResource)	\
+    ( (This)->lpVtbl -> CopyResource(This,pDstResource,pSrcResource) ) 
+
+#define ID3D12GraphicsCommandList5_CopyTiles(This,pTiledResource,pTileRegionStartCoordinate,pTileRegionSize,pBuffer,BufferStartOffsetInBytes,Flags)	\
+    ( (This)->lpVtbl -> CopyTiles(This,pTiledResource,pTileRegionStartCoordinate,pTileRegionSize,pBuffer,BufferStartOffsetInBytes,Flags) ) 
+
+#define ID3D12GraphicsCommandList5_ResolveSubresource(This,pDstResource,DstSubresource,pSrcResource,SrcSubresource,Format)	\
+    ( (This)->lpVtbl -> ResolveSubresource(This,pDstResource,DstSubresource,pSrcResource,SrcSubresource,Format) ) 
+
+#define ID3D12GraphicsCommandList5_IASetPrimitiveTopology(This,PrimitiveTopology)	\
+    ( (This)->lpVtbl -> IASetPrimitiveTopology(This,PrimitiveTopology) ) 
+
+#define ID3D12GraphicsCommandList5_RSSetViewports(This,NumViewports,pViewports)	\
+    ( (This)->lpVtbl -> RSSetViewports(This,NumViewports,pViewports) ) 
+
+#define ID3D12GraphicsCommandList5_RSSetScissorRects(This,NumRects,pRects)	\
+    ( (This)->lpVtbl -> RSSetScissorRects(This,NumRects,pRects) ) 
+
+#define ID3D12GraphicsCommandList5_OMSetBlendFactor(This,BlendFactor)	\
+    ( (This)->lpVtbl -> OMSetBlendFactor(This,BlendFactor) ) 
+
+#define ID3D12GraphicsCommandList5_OMSetStencilRef(This,StencilRef)	\
+    ( (This)->lpVtbl -> OMSetStencilRef(This,StencilRef) ) 
+
+#define ID3D12GraphicsCommandList5_SetPipelineState(This,pPipelineState)	\
+    ( (This)->lpVtbl -> SetPipelineState(This,pPipelineState) ) 
+
+#define ID3D12GraphicsCommandList5_ResourceBarrier(This,NumBarriers,pBarriers)	\
+    ( (This)->lpVtbl -> ResourceBarrier(This,NumBarriers,pBarriers) ) 
+
+#define ID3D12GraphicsCommandList5_ExecuteBundle(This,pCommandList)	\
+    ( (This)->lpVtbl -> ExecuteBundle(This,pCommandList) ) 
+
+#define ID3D12GraphicsCommandList5_SetDescriptorHeaps(This,NumDescriptorHeaps,ppDescriptorHeaps)	\
+    ( (This)->lpVtbl -> SetDescriptorHeaps(This,NumDescriptorHeaps,ppDescriptorHeaps) ) 
+
+#define ID3D12GraphicsCommandList5_SetComputeRootSignature(This,pRootSignature)	\
+    ( (This)->lpVtbl -> SetComputeRootSignature(This,pRootSignature) ) 
+
+#define ID3D12GraphicsCommandList5_SetGraphicsRootSignature(This,pRootSignature)	\
+    ( (This)->lpVtbl -> SetGraphicsRootSignature(This,pRootSignature) ) 
+
+#define ID3D12GraphicsCommandList5_SetComputeRootDescriptorTable(This,RootParameterIndex,BaseDescriptor)	\
+    ( (This)->lpVtbl -> SetComputeRootDescriptorTable(This,RootParameterIndex,BaseDescriptor) ) 
+
+#define ID3D12GraphicsCommandList5_SetGraphicsRootDescriptorTable(This,RootParameterIndex,BaseDescriptor)	\
+    ( (This)->lpVtbl -> SetGraphicsRootDescriptorTable(This,RootParameterIndex,BaseDescriptor) ) 
+
+#define ID3D12GraphicsCommandList5_SetComputeRoot32BitConstant(This,RootParameterIndex,SrcData,DestOffsetIn32BitValues)	\
+    ( (This)->lpVtbl -> SetComputeRoot32BitConstant(This,RootParameterIndex,SrcData,DestOffsetIn32BitValues) ) 
+
+#define ID3D12GraphicsCommandList5_SetGraphicsRoot32BitConstant(This,RootParameterIndex,SrcData,DestOffsetIn32BitValues)	\
+    ( (This)->lpVtbl -> SetGraphicsRoot32BitConstant(This,RootParameterIndex,SrcData,DestOffsetIn32BitValues) ) 
+
+#define ID3D12GraphicsCommandList5_SetComputeRoot32BitConstants(This,RootParameterIndex,Num32BitValuesToSet,pSrcData,DestOffsetIn32BitValues)	\
+    ( (This)->lpVtbl -> SetComputeRoot32BitConstants(This,RootParameterIndex,Num32BitValuesToSet,pSrcData,DestOffsetIn32BitValues) ) 
+
+#define ID3D12GraphicsCommandList5_SetGraphicsRoot32BitConstants(This,RootParameterIndex,Num32BitValuesToSet,pSrcData,DestOffsetIn32BitValues)	\
+    ( (This)->lpVtbl -> SetGraphicsRoot32BitConstants(This,RootParameterIndex,Num32BitValuesToSet,pSrcData,DestOffsetIn32BitValues) ) 
+
+#define ID3D12GraphicsCommandList5_SetComputeRootConstantBufferView(This,RootParameterIndex,BufferLocation)	\
+    ( (This)->lpVtbl -> SetComputeRootConstantBufferView(This,RootParameterIndex,BufferLocation) ) 
+
+#define ID3D12GraphicsCommandList5_SetGraphicsRootConstantBufferView(This,RootParameterIndex,BufferLocation)	\
+    ( (This)->lpVtbl -> SetGraphicsRootConstantBufferView(This,RootParameterIndex,BufferLocation) ) 
+
+#define ID3D12GraphicsCommandList5_SetComputeRootShaderResourceView(This,RootParameterIndex,BufferLocation)	\
+    ( (This)->lpVtbl -> SetComputeRootShaderResourceView(This,RootParameterIndex,BufferLocation) ) 
+
+#define ID3D12GraphicsCommandList5_SetGraphicsRootShaderResourceView(This,RootParameterIndex,BufferLocation)	\
+    ( (This)->lpVtbl -> SetGraphicsRootShaderResourceView(This,RootParameterIndex,BufferLocation) ) 
+
+#define ID3D12GraphicsCommandList5_SetComputeRootUnorderedAccessView(This,RootParameterIndex,BufferLocation)	\
+    ( (This)->lpVtbl -> SetComputeRootUnorderedAccessView(This,RootParameterIndex,BufferLocation) ) 
+
+#define ID3D12GraphicsCommandList5_SetGraphicsRootUnorderedAccessView(This,RootParameterIndex,BufferLocation)	\
+    ( (This)->lpVtbl -> SetGraphicsRootUnorderedAccessView(This,RootParameterIndex,BufferLocation) ) 
+
+#define ID3D12GraphicsCommandList5_IASetIndexBuffer(This,pView)	\
+    ( (This)->lpVtbl -> IASetIndexBuffer(This,pView) ) 
+
+#define ID3D12GraphicsCommandList5_IASetVertexBuffers(This,StartSlot,NumViews,pViews)	\
+    ( (This)->lpVtbl -> IASetVertexBuffers(This,StartSlot,NumViews,pViews) ) 
+
+#define ID3D12GraphicsCommandList5_SOSetTargets(This,StartSlot,NumViews,pViews)	\
+    ( (This)->lpVtbl -> SOSetTargets(This,StartSlot,NumViews,pViews) ) 
+
+#define ID3D12GraphicsCommandList5_OMSetRenderTargets(This,NumRenderTargetDescriptors,pRenderTargetDescriptors,RTsSingleHandleToDescriptorRange,pDepthStencilDescriptor)	\
+    ( (This)->lpVtbl -> OMSetRenderTargets(This,NumRenderTargetDescriptors,pRenderTargetDescriptors,RTsSingleHandleToDescriptorRange,pDepthStencilDescriptor) ) 
+
+#define ID3D12GraphicsCommandList5_ClearDepthStencilView(This,DepthStencilView,ClearFlags,Depth,Stencil,NumRects,pRects)	\
+    ( (This)->lpVtbl -> ClearDepthStencilView(This,DepthStencilView,ClearFlags,Depth,Stencil,NumRects,pRects) ) 
+
+#define ID3D12GraphicsCommandList5_ClearRenderTargetView(This,RenderTargetView,ColorRGBA,NumRects,pRects)	\
+    ( (This)->lpVtbl -> ClearRenderTargetView(This,RenderTargetView,ColorRGBA,NumRects,pRects) ) 
+
+#define ID3D12GraphicsCommandList5_ClearUnorderedAccessViewUint(This,ViewGPUHandleInCurrentHeap,ViewCPUHandle,pResource,Values,NumRects,pRects)	\
+    ( (This)->lpVtbl -> ClearUnorderedAccessViewUint(This,ViewGPUHandleInCurrentHeap,ViewCPUHandle,pResource,Values,NumRects,pRects) ) 
+
+#define ID3D12GraphicsCommandList5_ClearUnorderedAccessViewFloat(This,ViewGPUHandleInCurrentHeap,ViewCPUHandle,pResource,Values,NumRects,pRects)	\
+    ( (This)->lpVtbl -> ClearUnorderedAccessViewFloat(This,ViewGPUHandleInCurrentHeap,ViewCPUHandle,pResource,Values,NumRects,pRects) ) 
+
+#define ID3D12GraphicsCommandList5_DiscardResource(This,pResource,pRegion)	\
+    ( (This)->lpVtbl -> DiscardResource(This,pResource,pRegion) ) 
+
+#define ID3D12GraphicsCommandList5_BeginQuery(This,pQueryHeap,Type,Index)	\
+    ( (This)->lpVtbl -> BeginQuery(This,pQueryHeap,Type,Index) ) 
+
+#define ID3D12GraphicsCommandList5_EndQuery(This,pQueryHeap,Type,Index)	\
+    ( (This)->lpVtbl -> EndQuery(This,pQueryHeap,Type,Index) ) 
+
+#define ID3D12GraphicsCommandList5_ResolveQueryData(This,pQueryHeap,Type,StartIndex,NumQueries,pDestinationBuffer,AlignedDestinationBufferOffset)	\
+    ( (This)->lpVtbl -> ResolveQueryData(This,pQueryHeap,Type,StartIndex,NumQueries,pDestinationBuffer,AlignedDestinationBufferOffset) ) 
+
+#define ID3D12GraphicsCommandList5_SetPredication(This,pBuffer,AlignedBufferOffset,Operation)	\
+    ( (This)->lpVtbl -> SetPredication(This,pBuffer,AlignedBufferOffset,Operation) ) 
+
+#define ID3D12GraphicsCommandList5_SetMarker(This,Metadata,pData,Size)	\
+    ( (This)->lpVtbl -> SetMarker(This,Metadata,pData,Size) ) 
+
+#define ID3D12GraphicsCommandList5_BeginEvent(This,Metadata,pData,Size)	\
+    ( (This)->lpVtbl -> BeginEvent(This,Metadata,pData,Size) ) 
+
+#define ID3D12GraphicsCommandList5_EndEvent(This)	\
+    ( (This)->lpVtbl -> EndEvent(This) ) 
+
+#define ID3D12GraphicsCommandList5_ExecuteIndirect(This,pCommandSignature,MaxCommandCount,pArgumentBuffer,ArgumentBufferOffset,pCountBuffer,CountBufferOffset)	\
+    ( (This)->lpVtbl -> ExecuteIndirect(This,pCommandSignature,MaxCommandCount,pArgumentBuffer,ArgumentBufferOffset,pCountBuffer,CountBufferOffset) ) 
+
+
+#define ID3D12GraphicsCommandList5_AtomicCopyBufferUINT(This,pDstBuffer,DstOffset,pSrcBuffer,SrcOffset,Dependencies,ppDependentResources,pDependentSubresourceRanges)	\
+    ( (This)->lpVtbl -> AtomicCopyBufferUINT(This,pDstBuffer,DstOffset,pSrcBuffer,SrcOffset,Dependencies,ppDependentResources,pDependentSubresourceRanges) ) 
+
+#define ID3D12GraphicsCommandList5_AtomicCopyBufferUINT64(This,pDstBuffer,DstOffset,pSrcBuffer,SrcOffset,Dependencies,ppDependentResources,pDependentSubresourceRanges)	\
+    ( (This)->lpVtbl -> AtomicCopyBufferUINT64(This,pDstBuffer,DstOffset,pSrcBuffer,SrcOffset,Dependencies,ppDependentResources,pDependentSubresourceRanges) ) 
+
+#define ID3D12GraphicsCommandList5_OMSetDepthBounds(This,Min,Max)	\
+    ( (This)->lpVtbl -> OMSetDepthBounds(This,Min,Max) ) 
+
+#define ID3D12GraphicsCommandList5_SetSamplePositions(This,NumSamplesPerPixel,NumPixels,pSamplePositions)	\
+    ( (This)->lpVtbl -> SetSamplePositions(This,NumSamplesPerPixel,NumPixels,pSamplePositions) ) 
+
+#define ID3D12GraphicsCommandList5_ResolveSubresourceRegion(This,pDstResource,DstSubresource,DstX,DstY,pSrcResource,SrcSubresource,pSrcRect,Format,ResolveMode)	\
+    ( (This)->lpVtbl -> ResolveSubresourceRegion(This,pDstResource,DstSubresource,DstX,DstY,pSrcResource,SrcSubresource,pSrcRect,Format,ResolveMode) ) 
+
+#define ID3D12GraphicsCommandList5_SetViewInstanceMask(This,Mask)	\
+    ( (This)->lpVtbl -> SetViewInstanceMask(This,Mask) ) 
+
+
+#define ID3D12GraphicsCommandList5_WriteBufferImmediate(This,Count,pParams,pModes)	\
+    ( (This)->lpVtbl -> WriteBufferImmediate(This,Count,pParams,pModes) ) 
+
+
+#define ID3D12GraphicsCommandList5_SetProtectedResourceSession(This,pProtectedResourceSession)	\
+    ( (This)->lpVtbl -> SetProtectedResourceSession(This,pProtectedResourceSession) ) 
+
+
+#define ID3D12GraphicsCommandList5_BeginRenderPass(This,NumRenderTargets,pRenderTargets,pDepthStencil,Flags)	\
+    ( (This)->lpVtbl -> BeginRenderPass(This,NumRenderTargets,pRenderTargets,pDepthStencil,Flags) ) 
+
+#define ID3D12GraphicsCommandList5_EndRenderPass(This)	\
+    ( (This)->lpVtbl -> EndRenderPass(This) ) 
+
+#define ID3D12GraphicsCommandList5_InitializeMetaCommand(This,pMetaCommand,pInitializationParametersData,InitializationParametersDataSizeInBytes)	\
+    ( (This)->lpVtbl -> InitializeMetaCommand(This,pMetaCommand,pInitializationParametersData,InitializationParametersDataSizeInBytes) ) 
+
+#define ID3D12GraphicsCommandList5_ExecuteMetaCommand(This,pMetaCommand,pExecutionParametersData,ExecutionParametersDataSizeInBytes)	\
+    ( (This)->lpVtbl -> ExecuteMetaCommand(This,pMetaCommand,pExecutionParametersData,ExecutionParametersDataSizeInBytes) ) 
+
+#define ID3D12GraphicsCommandList5_BuildRaytracingAccelerationStructure(This,pDesc,NumPostbuildInfoDescs,pPostbuildInfoDescs)	\
+    ( (This)->lpVtbl -> BuildRaytracingAccelerationStructure(This,pDesc,NumPostbuildInfoDescs,pPostbuildInfoDescs) ) 
+
+#define ID3D12GraphicsCommandList5_EmitRaytracingAccelerationStructurePostbuildInfo(This,pDesc,NumSourceAccelerationStructures,pSourceAccelerationStructureData)	\
+    ( (This)->lpVtbl -> EmitRaytracingAccelerationStructurePostbuildInfo(This,pDesc,NumSourceAccelerationStructures,pSourceAccelerationStructureData) ) 
+
+#define ID3D12GraphicsCommandList5_CopyRaytracingAccelerationStructure(This,DestAccelerationStructureData,SourceAccelerationStructureData,Mode)	\
+    ( (This)->lpVtbl -> CopyRaytracingAccelerationStructure(This,DestAccelerationStructureData,SourceAccelerationStructureData,Mode) ) 
+
+#define ID3D12GraphicsCommandList5_SetPipelineState1(This,pStateObject)	\
+    ( (This)->lpVtbl -> SetPipelineState1(This,pStateObject) ) 
+
+#define ID3D12GraphicsCommandList5_DispatchRays(This,pDesc)	\
+    ( (This)->lpVtbl -> DispatchRays(This,pDesc) ) 
+
+
+#define ID3D12GraphicsCommandList5_RSSetShadingRate(This,baseShadingRate,combiners)	\
+    ( (This)->lpVtbl -> RSSetShadingRate(This,baseShadingRate,combiners) ) 
+
+#define ID3D12GraphicsCommandList5_RSSetShadingRateImage(This,shadingRateImage)	\
+    ( (This)->lpVtbl -> RSSetShadingRateImage(This,shadingRateImage) ) 
+
+#endif /* COBJMACROS */
+
+
+#endif 	/* C style interface */
+
+
+
+
+#endif 	/* __ID3D12GraphicsCommandList5_INTERFACE_DEFINED__ */
+
+
+/* interface __MIDL_itf_d3d12_0000_0062 */
+/* [local] */ 
+
+typedef struct D3D12_DISPATCH_MESH_ARGUMENTS
+    {
+    UINT ThreadGroupCountX;
+    UINT ThreadGroupCountY;
+    UINT ThreadGroupCountZ;
+    } 	D3D12_DISPATCH_MESH_ARGUMENTS;
+
+
+
+extern RPC_IF_HANDLE __MIDL_itf_d3d12_0000_0062_v0_0_c_ifspec;
+extern RPC_IF_HANDLE __MIDL_itf_d3d12_0000_0062_v0_0_s_ifspec;
+
+#ifndef __ID3D12GraphicsCommandList6_INTERFACE_DEFINED__
+#define __ID3D12GraphicsCommandList6_INTERFACE_DEFINED__
+
+/* interface ID3D12GraphicsCommandList6 */
+/* [unique][local][object][uuid] */ 
+
+
+EXTERN_C const IID IID_ID3D12GraphicsCommandList6;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("c3827890-e548-4cfa-96cf-5689a9370f80")
+    ID3D12GraphicsCommandList6 : public ID3D12GraphicsCommandList5
+    {
+    public:
+        virtual void STDMETHODCALLTYPE DispatchMesh( 
+            _In_  UINT ThreadGroupCountX,
+            _In_  UINT ThreadGroupCountY,
+            _In_  UINT ThreadGroupCountZ) = 0;
+        
+    };
+    
+    
+#else 	/* C style interface */
+
+    typedef struct ID3D12GraphicsCommandList6Vtbl
+    {
+        BEGIN_INTERFACE
+        
+        DECLSPEC_XFGVIRT(IUnknown, QueryInterface)
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            ID3D12GraphicsCommandList6 * This,
+            REFIID riid,
+            _COM_Outptr_  void **ppvObject);
+        
+        DECLSPEC_XFGVIRT(IUnknown, AddRef)
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            ID3D12GraphicsCommandList6 * This);
+        
+        DECLSPEC_XFGVIRT(IUnknown, Release)
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            ID3D12GraphicsCommandList6 * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, GetPrivateData)
+        HRESULT ( STDMETHODCALLTYPE *GetPrivateData )( 
+            ID3D12GraphicsCommandList6 * This,
+            _In_  REFGUID guid,
+            _Inout_  UINT *pDataSize,
+            _Out_writes_bytes_opt_( *pDataSize )  void *pData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, SetPrivateData)
+        HRESULT ( STDMETHODCALLTYPE *SetPrivateData )( 
+            ID3D12GraphicsCommandList6 * This,
+            _In_  REFGUID guid,
+            _In_  UINT DataSize,
+            _In_reads_bytes_opt_( DataSize )  const void *pData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, SetPrivateDataInterface)
+        HRESULT ( STDMETHODCALLTYPE *SetPrivateDataInterface )( 
+            ID3D12GraphicsCommandList6 * This,
+            _In_  REFGUID guid,
+            _In_opt_  const IUnknown *pData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, SetName)
+        HRESULT ( STDMETHODCALLTYPE *SetName )( 
+            ID3D12GraphicsCommandList6 * This,
+            _In_z_  LPCWSTR Name);
+        
+        DECLSPEC_XFGVIRT(ID3D12DeviceChild, GetDevice)
+        HRESULT ( STDMETHODCALLTYPE *GetDevice )( 
+            ID3D12GraphicsCommandList6 * This,
+            REFIID riid,
+            _COM_Outptr_opt_  void **ppvDevice);
+        
+        DECLSPEC_XFGVIRT(ID3D12CommandList, GetType)
+        D3D12_COMMAND_LIST_TYPE ( STDMETHODCALLTYPE *GetType )( 
+            ID3D12GraphicsCommandList6 * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, Close)
+        HRESULT ( STDMETHODCALLTYPE *Close )( 
+            ID3D12GraphicsCommandList6 * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, Reset)
+        HRESULT ( STDMETHODCALLTYPE *Reset )( 
+            ID3D12GraphicsCommandList6 * This,
+            _In_  ID3D12CommandAllocator *pAllocator,
+            _In_opt_  ID3D12PipelineState *pInitialState);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, ClearState)
+        void ( STDMETHODCALLTYPE *ClearState )( 
+            ID3D12GraphicsCommandList6 * This,
+            _In_opt_  ID3D12PipelineState *pPipelineState);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, DrawInstanced)
+        void ( STDMETHODCALLTYPE *DrawInstanced )( 
+            ID3D12GraphicsCommandList6 * This,
+            _In_  UINT VertexCountPerInstance,
+            _In_  UINT InstanceCount,
+            _In_  UINT StartVertexLocation,
+            _In_  UINT StartInstanceLocation);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, DrawIndexedInstanced)
+        void ( STDMETHODCALLTYPE *DrawIndexedInstanced )( 
+            ID3D12GraphicsCommandList6 * This,
+            _In_  UINT IndexCountPerInstance,
+            _In_  UINT InstanceCount,
+            _In_  UINT StartIndexLocation,
+            _In_  INT BaseVertexLocation,
+            _In_  UINT StartInstanceLocation);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, Dispatch)
+        void ( STDMETHODCALLTYPE *Dispatch )( 
+            ID3D12GraphicsCommandList6 * This,
+            _In_  UINT ThreadGroupCountX,
+            _In_  UINT ThreadGroupCountY,
+            _In_  UINT ThreadGroupCountZ);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, CopyBufferRegion)
+        void ( STDMETHODCALLTYPE *CopyBufferRegion )( 
+            ID3D12GraphicsCommandList6 * This,
+            _In_  ID3D12Resource *pDstBuffer,
+            UINT64 DstOffset,
+            _In_  ID3D12Resource *pSrcBuffer,
+            UINT64 SrcOffset,
+            UINT64 NumBytes);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, CopyTextureRegion)
+        void ( STDMETHODCALLTYPE *CopyTextureRegion )( 
+            ID3D12GraphicsCommandList6 * This,
+            _In_  const D3D12_TEXTURE_COPY_LOCATION *pDst,
+            UINT DstX,
+            UINT DstY,
+            UINT DstZ,
+            _In_  const D3D12_TEXTURE_COPY_LOCATION *pSrc,
+            _In_opt_  const D3D12_BOX *pSrcBox);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, CopyResource)
+        void ( STDMETHODCALLTYPE *CopyResource )( 
+            ID3D12GraphicsCommandList6 * This,
+            _In_  ID3D12Resource *pDstResource,
+            _In_  ID3D12Resource *pSrcResource);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, CopyTiles)
+        void ( STDMETHODCALLTYPE *CopyTiles )( 
+            ID3D12GraphicsCommandList6 * This,
+            _In_  ID3D12Resource *pTiledResource,
+            _In_  const D3D12_TILED_RESOURCE_COORDINATE *pTileRegionStartCoordinate,
+            _In_  const D3D12_TILE_REGION_SIZE *pTileRegionSize,
+            _In_  ID3D12Resource *pBuffer,
+            UINT64 BufferStartOffsetInBytes,
+            D3D12_TILE_COPY_FLAGS Flags);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, ResolveSubresource)
+        void ( STDMETHODCALLTYPE *ResolveSubresource )( 
+            ID3D12GraphicsCommandList6 * This,
+            _In_  ID3D12Resource *pDstResource,
+            _In_  UINT DstSubresource,
+            _In_  ID3D12Resource *pSrcResource,
+            _In_  UINT SrcSubresource,
+            _In_  DXGI_FORMAT Format);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, IASetPrimitiveTopology)
+        void ( STDMETHODCALLTYPE *IASetPrimitiveTopology )( 
+            ID3D12GraphicsCommandList6 * This,
+            _In_  D3D12_PRIMITIVE_TOPOLOGY PrimitiveTopology);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, RSSetViewports)
+        void ( STDMETHODCALLTYPE *RSSetViewports )( 
+            ID3D12GraphicsCommandList6 * This,
+            _In_range_(0, D3D12_VIEWPORT_AND_SCISSORRECT_OBJECT_COUNT_PER_PIPELINE)  UINT NumViewports,
+            _In_reads_( NumViewports)  const D3D12_VIEWPORT *pViewports);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, RSSetScissorRects)
+        void ( STDMETHODCALLTYPE *RSSetScissorRects )( 
+            ID3D12GraphicsCommandList6 * This,
+            _In_range_(0, D3D12_VIEWPORT_AND_SCISSORRECT_OBJECT_COUNT_PER_PIPELINE)  UINT NumRects,
+            _In_reads_( NumRects)  const D3D12_RECT *pRects);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, OMSetBlendFactor)
+        void ( STDMETHODCALLTYPE *OMSetBlendFactor )( 
+            ID3D12GraphicsCommandList6 * This,
+            _In_reads_opt_(4)  const FLOAT BlendFactor[ 4 ]);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, OMSetStencilRef)
+        void ( STDMETHODCALLTYPE *OMSetStencilRef )( 
+            ID3D12GraphicsCommandList6 * This,
+            _In_  UINT StencilRef);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetPipelineState)
+        void ( STDMETHODCALLTYPE *SetPipelineState )( 
+            ID3D12GraphicsCommandList6 * This,
+            _In_  ID3D12PipelineState *pPipelineState);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, ResourceBarrier)
+        void ( STDMETHODCALLTYPE *ResourceBarrier )( 
+            ID3D12GraphicsCommandList6 * This,
+            _In_  UINT NumBarriers,
+            _In_reads_(NumBarriers)  const D3D12_RESOURCE_BARRIER *pBarriers);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, ExecuteBundle)
+        void ( STDMETHODCALLTYPE *ExecuteBundle )( 
+            ID3D12GraphicsCommandList6 * This,
+            _In_  ID3D12GraphicsCommandList *pCommandList);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetDescriptorHeaps)
+        void ( STDMETHODCALLTYPE *SetDescriptorHeaps )( 
+            ID3D12GraphicsCommandList6 * This,
+            _In_  UINT NumDescriptorHeaps,
+            _In_reads_(NumDescriptorHeaps)  ID3D12DescriptorHeap *const *ppDescriptorHeaps);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetComputeRootSignature)
+        void ( STDMETHODCALLTYPE *SetComputeRootSignature )( 
+            ID3D12GraphicsCommandList6 * This,
+            _In_opt_  ID3D12RootSignature *pRootSignature);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetGraphicsRootSignature)
+        void ( STDMETHODCALLTYPE *SetGraphicsRootSignature )( 
+            ID3D12GraphicsCommandList6 * This,
+            _In_opt_  ID3D12RootSignature *pRootSignature);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetComputeRootDescriptorTable)
+        void ( STDMETHODCALLTYPE *SetComputeRootDescriptorTable )( 
+            ID3D12GraphicsCommandList6 * This,
+            _In_  UINT RootParameterIndex,
+            _In_  D3D12_GPU_DESCRIPTOR_HANDLE BaseDescriptor);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetGraphicsRootDescriptorTable)
+        void ( STDMETHODCALLTYPE *SetGraphicsRootDescriptorTable )( 
+            ID3D12GraphicsCommandList6 * This,
+            _In_  UINT RootParameterIndex,
+            _In_  D3D12_GPU_DESCRIPTOR_HANDLE BaseDescriptor);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetComputeRoot32BitConstant)
+        void ( STDMETHODCALLTYPE *SetComputeRoot32BitConstant )( 
+            ID3D12GraphicsCommandList6 * This,
+            _In_  UINT RootParameterIndex,
+            _In_  UINT SrcData,
+            _In_  UINT DestOffsetIn32BitValues);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetGraphicsRoot32BitConstant)
+        void ( STDMETHODCALLTYPE *SetGraphicsRoot32BitConstant )( 
+            ID3D12GraphicsCommandList6 * This,
+            _In_  UINT RootParameterIndex,
+            _In_  UINT SrcData,
+            _In_  UINT DestOffsetIn32BitValues);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetComputeRoot32BitConstants)
+        void ( STDMETHODCALLTYPE *SetComputeRoot32BitConstants )( 
+            ID3D12GraphicsCommandList6 * This,
+            _In_  UINT RootParameterIndex,
+            _In_  UINT Num32BitValuesToSet,
+            _In_reads_(Num32BitValuesToSet*sizeof(UINT))  const void *pSrcData,
+            _In_  UINT DestOffsetIn32BitValues);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetGraphicsRoot32BitConstants)
+        void ( STDMETHODCALLTYPE *SetGraphicsRoot32BitConstants )( 
+            ID3D12GraphicsCommandList6 * This,
+            _In_  UINT RootParameterIndex,
+            _In_  UINT Num32BitValuesToSet,
+            _In_reads_(Num32BitValuesToSet*sizeof(UINT))  const void *pSrcData,
+            _In_  UINT DestOffsetIn32BitValues);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetComputeRootConstantBufferView)
+        void ( STDMETHODCALLTYPE *SetComputeRootConstantBufferView )( 
+            ID3D12GraphicsCommandList6 * This,
+            _In_  UINT RootParameterIndex,
+            _In_  D3D12_GPU_VIRTUAL_ADDRESS BufferLocation);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetGraphicsRootConstantBufferView)
+        void ( STDMETHODCALLTYPE *SetGraphicsRootConstantBufferView )( 
+            ID3D12GraphicsCommandList6 * This,
+            _In_  UINT RootParameterIndex,
+            _In_  D3D12_GPU_VIRTUAL_ADDRESS BufferLocation);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetComputeRootShaderResourceView)
+        void ( STDMETHODCALLTYPE *SetComputeRootShaderResourceView )( 
+            ID3D12GraphicsCommandList6 * This,
+            _In_  UINT RootParameterIndex,
+            _In_  D3D12_GPU_VIRTUAL_ADDRESS BufferLocation);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetGraphicsRootShaderResourceView)
+        void ( STDMETHODCALLTYPE *SetGraphicsRootShaderResourceView )( 
+            ID3D12GraphicsCommandList6 * This,
+            _In_  UINT RootParameterIndex,
+            _In_  D3D12_GPU_VIRTUAL_ADDRESS BufferLocation);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetComputeRootUnorderedAccessView)
+        void ( STDMETHODCALLTYPE *SetComputeRootUnorderedAccessView )( 
+            ID3D12GraphicsCommandList6 * This,
+            _In_  UINT RootParameterIndex,
+            _In_  D3D12_GPU_VIRTUAL_ADDRESS BufferLocation);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetGraphicsRootUnorderedAccessView)
+        void ( STDMETHODCALLTYPE *SetGraphicsRootUnorderedAccessView )( 
+            ID3D12GraphicsCommandList6 * This,
+            _In_  UINT RootParameterIndex,
+            _In_  D3D12_GPU_VIRTUAL_ADDRESS BufferLocation);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, IASetIndexBuffer)
+        void ( STDMETHODCALLTYPE *IASetIndexBuffer )( 
+            ID3D12GraphicsCommandList6 * This,
+            _In_opt_  const D3D12_INDEX_BUFFER_VIEW *pView);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, IASetVertexBuffers)
+        void ( STDMETHODCALLTYPE *IASetVertexBuffers )( 
+            ID3D12GraphicsCommandList6 * This,
+            _In_  UINT StartSlot,
+            _In_  UINT NumViews,
+            _In_reads_opt_(NumViews)  const D3D12_VERTEX_BUFFER_VIEW *pViews);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SOSetTargets)
+        void ( STDMETHODCALLTYPE *SOSetTargets )( 
+            ID3D12GraphicsCommandList6 * This,
+            _In_  UINT StartSlot,
+            _In_  UINT NumViews,
+            _In_reads_opt_(NumViews)  const D3D12_STREAM_OUTPUT_BUFFER_VIEW *pViews);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, OMSetRenderTargets)
+        void ( STDMETHODCALLTYPE *OMSetRenderTargets )( 
+            ID3D12GraphicsCommandList6 * This,
+            _In_  UINT NumRenderTargetDescriptors,
+            _In_opt_  const D3D12_CPU_DESCRIPTOR_HANDLE *pRenderTargetDescriptors,
+            _In_  BOOL RTsSingleHandleToDescriptorRange,
+            _In_opt_  const D3D12_CPU_DESCRIPTOR_HANDLE *pDepthStencilDescriptor);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, ClearDepthStencilView)
+        void ( STDMETHODCALLTYPE *ClearDepthStencilView )( 
+            ID3D12GraphicsCommandList6 * This,
+            _In_  D3D12_CPU_DESCRIPTOR_HANDLE DepthStencilView,
+            _In_  D3D12_CLEAR_FLAGS ClearFlags,
+            _In_  FLOAT Depth,
+            _In_  UINT8 Stencil,
+            _In_  UINT NumRects,
+            _In_reads_(NumRects)  const D3D12_RECT *pRects);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, ClearRenderTargetView)
+        void ( STDMETHODCALLTYPE *ClearRenderTargetView )( 
+            ID3D12GraphicsCommandList6 * This,
+            _In_  D3D12_CPU_DESCRIPTOR_HANDLE RenderTargetView,
+            _In_  const FLOAT ColorRGBA[ 4 ],
+            _In_  UINT NumRects,
+            _In_reads_(NumRects)  const D3D12_RECT *pRects);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, ClearUnorderedAccessViewUint)
+        void ( STDMETHODCALLTYPE *ClearUnorderedAccessViewUint )( 
+            ID3D12GraphicsCommandList6 * This,
+            _In_  D3D12_GPU_DESCRIPTOR_HANDLE ViewGPUHandleInCurrentHeap,
+            _In_  D3D12_CPU_DESCRIPTOR_HANDLE ViewCPUHandle,
+            _In_  ID3D12Resource *pResource,
+            _In_  const UINT Values[ 4 ],
+            _In_  UINT NumRects,
+            _In_reads_(NumRects)  const D3D12_RECT *pRects);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, ClearUnorderedAccessViewFloat)
+        void ( STDMETHODCALLTYPE *ClearUnorderedAccessViewFloat )( 
+            ID3D12GraphicsCommandList6 * This,
+            _In_  D3D12_GPU_DESCRIPTOR_HANDLE ViewGPUHandleInCurrentHeap,
+            _In_  D3D12_CPU_DESCRIPTOR_HANDLE ViewCPUHandle,
+            _In_  ID3D12Resource *pResource,
+            _In_  const FLOAT Values[ 4 ],
+            _In_  UINT NumRects,
+            _In_reads_(NumRects)  const D3D12_RECT *pRects);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, DiscardResource)
+        void ( STDMETHODCALLTYPE *DiscardResource )( 
+            ID3D12GraphicsCommandList6 * This,
+            _In_  ID3D12Resource *pResource,
+            _In_opt_  const D3D12_DISCARD_REGION *pRegion);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, BeginQuery)
+        void ( STDMETHODCALLTYPE *BeginQuery )( 
+            ID3D12GraphicsCommandList6 * This,
+            _In_  ID3D12QueryHeap *pQueryHeap,
+            _In_  D3D12_QUERY_TYPE Type,
+            _In_  UINT Index);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, EndQuery)
+        void ( STDMETHODCALLTYPE *EndQuery )( 
+            ID3D12GraphicsCommandList6 * This,
+            _In_  ID3D12QueryHeap *pQueryHeap,
+            _In_  D3D12_QUERY_TYPE Type,
+            _In_  UINT Index);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, ResolveQueryData)
+        void ( STDMETHODCALLTYPE *ResolveQueryData )( 
+            ID3D12GraphicsCommandList6 * This,
+            _In_  ID3D12QueryHeap *pQueryHeap,
+            _In_  D3D12_QUERY_TYPE Type,
+            _In_  UINT StartIndex,
+            _In_  UINT NumQueries,
+            _In_  ID3D12Resource *pDestinationBuffer,
+            _In_  UINT64 AlignedDestinationBufferOffset);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetPredication)
+        void ( STDMETHODCALLTYPE *SetPredication )( 
+            ID3D12GraphicsCommandList6 * This,
+            _In_opt_  ID3D12Resource *pBuffer,
+            _In_  UINT64 AlignedBufferOffset,
+            _In_  D3D12_PREDICATION_OP Operation);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetMarker)
+        void ( STDMETHODCALLTYPE *SetMarker )( 
+            ID3D12GraphicsCommandList6 * This,
+            UINT Metadata,
+            _In_reads_bytes_opt_(Size)  const void *pData,
+            UINT Size);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, BeginEvent)
+        void ( STDMETHODCALLTYPE *BeginEvent )( 
+            ID3D12GraphicsCommandList6 * This,
+            UINT Metadata,
+            _In_reads_bytes_opt_(Size)  const void *pData,
+            UINT Size);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, EndEvent)
+        void ( STDMETHODCALLTYPE *EndEvent )( 
+            ID3D12GraphicsCommandList6 * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, ExecuteIndirect)
+        void ( STDMETHODCALLTYPE *ExecuteIndirect )( 
+            ID3D12GraphicsCommandList6 * This,
+            _In_  ID3D12CommandSignature *pCommandSignature,
+            _In_  UINT MaxCommandCount,
+            _In_  ID3D12Resource *pArgumentBuffer,
+            _In_  UINT64 ArgumentBufferOffset,
+            _In_opt_  ID3D12Resource *pCountBuffer,
+            _In_  UINT64 CountBufferOffset);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList1, AtomicCopyBufferUINT)
+        void ( STDMETHODCALLTYPE *AtomicCopyBufferUINT )( 
+            ID3D12GraphicsCommandList6 * This,
+            _In_  ID3D12Resource *pDstBuffer,
+            UINT64 DstOffset,
+            _In_  ID3D12Resource *pSrcBuffer,
+            UINT64 SrcOffset,
+            UINT Dependencies,
+            _In_reads_(Dependencies)  ID3D12Resource *const *ppDependentResources,
+            _In_reads_(Dependencies)  const D3D12_SUBRESOURCE_RANGE_UINT64 *pDependentSubresourceRanges);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList1, AtomicCopyBufferUINT64)
+        void ( STDMETHODCALLTYPE *AtomicCopyBufferUINT64 )( 
+            ID3D12GraphicsCommandList6 * This,
+            _In_  ID3D12Resource *pDstBuffer,
+            UINT64 DstOffset,
+            _In_  ID3D12Resource *pSrcBuffer,
+            UINT64 SrcOffset,
+            UINT Dependencies,
+            _In_reads_(Dependencies)  ID3D12Resource *const *ppDependentResources,
+            _In_reads_(Dependencies)  const D3D12_SUBRESOURCE_RANGE_UINT64 *pDependentSubresourceRanges);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList1, OMSetDepthBounds)
+        void ( STDMETHODCALLTYPE *OMSetDepthBounds )( 
+            ID3D12GraphicsCommandList6 * This,
+            _In_  FLOAT Min,
+            _In_  FLOAT Max);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList1, SetSamplePositions)
+        void ( STDMETHODCALLTYPE *SetSamplePositions )( 
+            ID3D12GraphicsCommandList6 * This,
+            _In_  UINT NumSamplesPerPixel,
+            _In_  UINT NumPixels,
+            _In_reads_(NumSamplesPerPixel*NumPixels)  D3D12_SAMPLE_POSITION *pSamplePositions);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList1, ResolveSubresourceRegion)
+        void ( STDMETHODCALLTYPE *ResolveSubresourceRegion )( 
+            ID3D12GraphicsCommandList6 * This,
+            _In_  ID3D12Resource *pDstResource,
+            _In_  UINT DstSubresource,
+            _In_  UINT DstX,
+            _In_  UINT DstY,
+            _In_  ID3D12Resource *pSrcResource,
+            _In_  UINT SrcSubresource,
+            _In_opt_  D3D12_RECT *pSrcRect,
+            _In_  DXGI_FORMAT Format,
+            _In_  D3D12_RESOLVE_MODE ResolveMode);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList1, SetViewInstanceMask)
+        void ( STDMETHODCALLTYPE *SetViewInstanceMask )( 
+            ID3D12GraphicsCommandList6 * This,
+            _In_  UINT Mask);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList2, WriteBufferImmediate)
+        void ( STDMETHODCALLTYPE *WriteBufferImmediate )( 
+            ID3D12GraphicsCommandList6 * This,
+            UINT Count,
+            _In_reads_(Count)  const D3D12_WRITEBUFFERIMMEDIATE_PARAMETER *pParams,
+            _In_reads_opt_(Count)  const D3D12_WRITEBUFFERIMMEDIATE_MODE *pModes);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList3, SetProtectedResourceSession)
+        void ( STDMETHODCALLTYPE *SetProtectedResourceSession )( 
+            ID3D12GraphicsCommandList6 * This,
+            _In_opt_  ID3D12ProtectedResourceSession *pProtectedResourceSession);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList4, BeginRenderPass)
+        void ( STDMETHODCALLTYPE *BeginRenderPass )( 
+            ID3D12GraphicsCommandList6 * This,
+            _In_  UINT NumRenderTargets,
+            _In_reads_opt_(NumRenderTargets)  const D3D12_RENDER_PASS_RENDER_TARGET_DESC *pRenderTargets,
+            _In_opt_  const D3D12_RENDER_PASS_DEPTH_STENCIL_DESC *pDepthStencil,
+            D3D12_RENDER_PASS_FLAGS Flags);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList4, EndRenderPass)
+        void ( STDMETHODCALLTYPE *EndRenderPass )( 
+            ID3D12GraphicsCommandList6 * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList4, InitializeMetaCommand)
+        void ( STDMETHODCALLTYPE *InitializeMetaCommand )( 
+            ID3D12GraphicsCommandList6 * This,
+            _In_  ID3D12MetaCommand *pMetaCommand,
+            _In_reads_bytes_opt_(InitializationParametersDataSizeInBytes)  const void *pInitializationParametersData,
+            _In_  SIZE_T InitializationParametersDataSizeInBytes);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList4, ExecuteMetaCommand)
+        void ( STDMETHODCALLTYPE *ExecuteMetaCommand )( 
+            ID3D12GraphicsCommandList6 * This,
+            _In_  ID3D12MetaCommand *pMetaCommand,
+            _In_reads_bytes_opt_(ExecutionParametersDataSizeInBytes)  const void *pExecutionParametersData,
+            _In_  SIZE_T ExecutionParametersDataSizeInBytes);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList4, BuildRaytracingAccelerationStructure)
+        void ( STDMETHODCALLTYPE *BuildRaytracingAccelerationStructure )( 
+            ID3D12GraphicsCommandList6 * This,
+            _In_  const D3D12_BUILD_RAYTRACING_ACCELERATION_STRUCTURE_DESC *pDesc,
+            _In_  UINT NumPostbuildInfoDescs,
+            _In_reads_opt_(NumPostbuildInfoDescs)  const D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_DESC *pPostbuildInfoDescs);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList4, EmitRaytracingAccelerationStructurePostbuildInfo)
+        void ( STDMETHODCALLTYPE *EmitRaytracingAccelerationStructurePostbuildInfo )( 
+            ID3D12GraphicsCommandList6 * This,
+            _In_  const D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_DESC *pDesc,
+            _In_  UINT NumSourceAccelerationStructures,
+            _In_reads_( NumSourceAccelerationStructures )  const D3D12_GPU_VIRTUAL_ADDRESS *pSourceAccelerationStructureData);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList4, CopyRaytracingAccelerationStructure)
+        void ( STDMETHODCALLTYPE *CopyRaytracingAccelerationStructure )( 
+            ID3D12GraphicsCommandList6 * This,
+            _In_  D3D12_GPU_VIRTUAL_ADDRESS DestAccelerationStructureData,
+            _In_  D3D12_GPU_VIRTUAL_ADDRESS SourceAccelerationStructureData,
+            _In_  D3D12_RAYTRACING_ACCELERATION_STRUCTURE_COPY_MODE Mode);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList4, SetPipelineState1)
+        void ( STDMETHODCALLTYPE *SetPipelineState1 )( 
+            ID3D12GraphicsCommandList6 * This,
+            _In_  ID3D12StateObject *pStateObject);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList4, DispatchRays)
+        void ( STDMETHODCALLTYPE *DispatchRays )( 
+            ID3D12GraphicsCommandList6 * This,
+            _In_  const D3D12_DISPATCH_RAYS_DESC *pDesc);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList5, RSSetShadingRate)
+        void ( STDMETHODCALLTYPE *RSSetShadingRate )( 
+            ID3D12GraphicsCommandList6 * This,
+            _In_  D3D12_SHADING_RATE baseShadingRate,
+            _In_reads_opt_(D3D12_RS_SET_SHADING_RATE_COMBINER_COUNT)  const D3D12_SHADING_RATE_COMBINER *combiners);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList5, RSSetShadingRateImage)
+        void ( STDMETHODCALLTYPE *RSSetShadingRateImage )( 
+            ID3D12GraphicsCommandList6 * This,
+            _In_opt_  ID3D12Resource *shadingRateImage);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList6, DispatchMesh)
+        void ( STDMETHODCALLTYPE *DispatchMesh )( 
+            ID3D12GraphicsCommandList6 * This,
+            _In_  UINT ThreadGroupCountX,
+            _In_  UINT ThreadGroupCountY,
+            _In_  UINT ThreadGroupCountZ);
+        
+        END_INTERFACE
+    } ID3D12GraphicsCommandList6Vtbl;
+
+    interface ID3D12GraphicsCommandList6
+    {
+        CONST_VTBL struct ID3D12GraphicsCommandList6Vtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define ID3D12GraphicsCommandList6_QueryInterface(This,riid,ppvObject)	\
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define ID3D12GraphicsCommandList6_AddRef(This)	\
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define ID3D12GraphicsCommandList6_Release(This)	\
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#define ID3D12GraphicsCommandList6_GetPrivateData(This,guid,pDataSize,pData)	\
+    ( (This)->lpVtbl -> GetPrivateData(This,guid,pDataSize,pData) ) 
+
+#define ID3D12GraphicsCommandList6_SetPrivateData(This,guid,DataSize,pData)	\
+    ( (This)->lpVtbl -> SetPrivateData(This,guid,DataSize,pData) ) 
+
+#define ID3D12GraphicsCommandList6_SetPrivateDataInterface(This,guid,pData)	\
+    ( (This)->lpVtbl -> SetPrivateDataInterface(This,guid,pData) ) 
+
+#define ID3D12GraphicsCommandList6_SetName(This,Name)	\
+    ( (This)->lpVtbl -> SetName(This,Name) ) 
+
+
+#define ID3D12GraphicsCommandList6_GetDevice(This,riid,ppvDevice)	\
+    ( (This)->lpVtbl -> GetDevice(This,riid,ppvDevice) ) 
+
+
+#define ID3D12GraphicsCommandList6_GetType(This)	\
+    ( (This)->lpVtbl -> GetType(This) ) 
+
+
+#define ID3D12GraphicsCommandList6_Close(This)	\
+    ( (This)->lpVtbl -> Close(This) ) 
+
+#define ID3D12GraphicsCommandList6_Reset(This,pAllocator,pInitialState)	\
+    ( (This)->lpVtbl -> Reset(This,pAllocator,pInitialState) ) 
+
+#define ID3D12GraphicsCommandList6_ClearState(This,pPipelineState)	\
+    ( (This)->lpVtbl -> ClearState(This,pPipelineState) ) 
+
+#define ID3D12GraphicsCommandList6_DrawInstanced(This,VertexCountPerInstance,InstanceCount,StartVertexLocation,StartInstanceLocation)	\
+    ( (This)->lpVtbl -> DrawInstanced(This,VertexCountPerInstance,InstanceCount,StartVertexLocation,StartInstanceLocation) ) 
+
+#define ID3D12GraphicsCommandList6_DrawIndexedInstanced(This,IndexCountPerInstance,InstanceCount,StartIndexLocation,BaseVertexLocation,StartInstanceLocation)	\
+    ( (This)->lpVtbl -> DrawIndexedInstanced(This,IndexCountPerInstance,InstanceCount,StartIndexLocation,BaseVertexLocation,StartInstanceLocation) ) 
+
+#define ID3D12GraphicsCommandList6_Dispatch(This,ThreadGroupCountX,ThreadGroupCountY,ThreadGroupCountZ)	\
+    ( (This)->lpVtbl -> Dispatch(This,ThreadGroupCountX,ThreadGroupCountY,ThreadGroupCountZ) ) 
+
+#define ID3D12GraphicsCommandList6_CopyBufferRegion(This,pDstBuffer,DstOffset,pSrcBuffer,SrcOffset,NumBytes)	\
+    ( (This)->lpVtbl -> CopyBufferRegion(This,pDstBuffer,DstOffset,pSrcBuffer,SrcOffset,NumBytes) ) 
+
+#define ID3D12GraphicsCommandList6_CopyTextureRegion(This,pDst,DstX,DstY,DstZ,pSrc,pSrcBox)	\
+    ( (This)->lpVtbl -> CopyTextureRegion(This,pDst,DstX,DstY,DstZ,pSrc,pSrcBox) ) 
+
+#define ID3D12GraphicsCommandList6_CopyResource(This,pDstResource,pSrcResource)	\
+    ( (This)->lpVtbl -> CopyResource(This,pDstResource,pSrcResource) ) 
+
+#define ID3D12GraphicsCommandList6_CopyTiles(This,pTiledResource,pTileRegionStartCoordinate,pTileRegionSize,pBuffer,BufferStartOffsetInBytes,Flags)	\
+    ( (This)->lpVtbl -> CopyTiles(This,pTiledResource,pTileRegionStartCoordinate,pTileRegionSize,pBuffer,BufferStartOffsetInBytes,Flags) ) 
+
+#define ID3D12GraphicsCommandList6_ResolveSubresource(This,pDstResource,DstSubresource,pSrcResource,SrcSubresource,Format)	\
+    ( (This)->lpVtbl -> ResolveSubresource(This,pDstResource,DstSubresource,pSrcResource,SrcSubresource,Format) ) 
+
+#define ID3D12GraphicsCommandList6_IASetPrimitiveTopology(This,PrimitiveTopology)	\
+    ( (This)->lpVtbl -> IASetPrimitiveTopology(This,PrimitiveTopology) ) 
+
+#define ID3D12GraphicsCommandList6_RSSetViewports(This,NumViewports,pViewports)	\
+    ( (This)->lpVtbl -> RSSetViewports(This,NumViewports,pViewports) ) 
+
+#define ID3D12GraphicsCommandList6_RSSetScissorRects(This,NumRects,pRects)	\
+    ( (This)->lpVtbl -> RSSetScissorRects(This,NumRects,pRects) ) 
+
+#define ID3D12GraphicsCommandList6_OMSetBlendFactor(This,BlendFactor)	\
+    ( (This)->lpVtbl -> OMSetBlendFactor(This,BlendFactor) ) 
+
+#define ID3D12GraphicsCommandList6_OMSetStencilRef(This,StencilRef)	\
+    ( (This)->lpVtbl -> OMSetStencilRef(This,StencilRef) ) 
+
+#define ID3D12GraphicsCommandList6_SetPipelineState(This,pPipelineState)	\
+    ( (This)->lpVtbl -> SetPipelineState(This,pPipelineState) ) 
+
+#define ID3D12GraphicsCommandList6_ResourceBarrier(This,NumBarriers,pBarriers)	\
+    ( (This)->lpVtbl -> ResourceBarrier(This,NumBarriers,pBarriers) ) 
+
+#define ID3D12GraphicsCommandList6_ExecuteBundle(This,pCommandList)	\
+    ( (This)->lpVtbl -> ExecuteBundle(This,pCommandList) ) 
+
+#define ID3D12GraphicsCommandList6_SetDescriptorHeaps(This,NumDescriptorHeaps,ppDescriptorHeaps)	\
+    ( (This)->lpVtbl -> SetDescriptorHeaps(This,NumDescriptorHeaps,ppDescriptorHeaps) ) 
+
+#define ID3D12GraphicsCommandList6_SetComputeRootSignature(This,pRootSignature)	\
+    ( (This)->lpVtbl -> SetComputeRootSignature(This,pRootSignature) ) 
+
+#define ID3D12GraphicsCommandList6_SetGraphicsRootSignature(This,pRootSignature)	\
+    ( (This)->lpVtbl -> SetGraphicsRootSignature(This,pRootSignature) ) 
+
+#define ID3D12GraphicsCommandList6_SetComputeRootDescriptorTable(This,RootParameterIndex,BaseDescriptor)	\
+    ( (This)->lpVtbl -> SetComputeRootDescriptorTable(This,RootParameterIndex,BaseDescriptor) ) 
+
+#define ID3D12GraphicsCommandList6_SetGraphicsRootDescriptorTable(This,RootParameterIndex,BaseDescriptor)	\
+    ( (This)->lpVtbl -> SetGraphicsRootDescriptorTable(This,RootParameterIndex,BaseDescriptor) ) 
+
+#define ID3D12GraphicsCommandList6_SetComputeRoot32BitConstant(This,RootParameterIndex,SrcData,DestOffsetIn32BitValues)	\
+    ( (This)->lpVtbl -> SetComputeRoot32BitConstant(This,RootParameterIndex,SrcData,DestOffsetIn32BitValues) ) 
+
+#define ID3D12GraphicsCommandList6_SetGraphicsRoot32BitConstant(This,RootParameterIndex,SrcData,DestOffsetIn32BitValues)	\
+    ( (This)->lpVtbl -> SetGraphicsRoot32BitConstant(This,RootParameterIndex,SrcData,DestOffsetIn32BitValues) ) 
+
+#define ID3D12GraphicsCommandList6_SetComputeRoot32BitConstants(This,RootParameterIndex,Num32BitValuesToSet,pSrcData,DestOffsetIn32BitValues)	\
+    ( (This)->lpVtbl -> SetComputeRoot32BitConstants(This,RootParameterIndex,Num32BitValuesToSet,pSrcData,DestOffsetIn32BitValues) ) 
+
+#define ID3D12GraphicsCommandList6_SetGraphicsRoot32BitConstants(This,RootParameterIndex,Num32BitValuesToSet,pSrcData,DestOffsetIn32BitValues)	\
+    ( (This)->lpVtbl -> SetGraphicsRoot32BitConstants(This,RootParameterIndex,Num32BitValuesToSet,pSrcData,DestOffsetIn32BitValues) ) 
+
+#define ID3D12GraphicsCommandList6_SetComputeRootConstantBufferView(This,RootParameterIndex,BufferLocation)	\
+    ( (This)->lpVtbl -> SetComputeRootConstantBufferView(This,RootParameterIndex,BufferLocation) ) 
+
+#define ID3D12GraphicsCommandList6_SetGraphicsRootConstantBufferView(This,RootParameterIndex,BufferLocation)	\
+    ( (This)->lpVtbl -> SetGraphicsRootConstantBufferView(This,RootParameterIndex,BufferLocation) ) 
+
+#define ID3D12GraphicsCommandList6_SetComputeRootShaderResourceView(This,RootParameterIndex,BufferLocation)	\
+    ( (This)->lpVtbl -> SetComputeRootShaderResourceView(This,RootParameterIndex,BufferLocation) ) 
+
+#define ID3D12GraphicsCommandList6_SetGraphicsRootShaderResourceView(This,RootParameterIndex,BufferLocation)	\
+    ( (This)->lpVtbl -> SetGraphicsRootShaderResourceView(This,RootParameterIndex,BufferLocation) ) 
+
+#define ID3D12GraphicsCommandList6_SetComputeRootUnorderedAccessView(This,RootParameterIndex,BufferLocation)	\
+    ( (This)->lpVtbl -> SetComputeRootUnorderedAccessView(This,RootParameterIndex,BufferLocation) ) 
+
+#define ID3D12GraphicsCommandList6_SetGraphicsRootUnorderedAccessView(This,RootParameterIndex,BufferLocation)	\
+    ( (This)->lpVtbl -> SetGraphicsRootUnorderedAccessView(This,RootParameterIndex,BufferLocation) ) 
+
+#define ID3D12GraphicsCommandList6_IASetIndexBuffer(This,pView)	\
+    ( (This)->lpVtbl -> IASetIndexBuffer(This,pView) ) 
+
+#define ID3D12GraphicsCommandList6_IASetVertexBuffers(This,StartSlot,NumViews,pViews)	\
+    ( (This)->lpVtbl -> IASetVertexBuffers(This,StartSlot,NumViews,pViews) ) 
+
+#define ID3D12GraphicsCommandList6_SOSetTargets(This,StartSlot,NumViews,pViews)	\
+    ( (This)->lpVtbl -> SOSetTargets(This,StartSlot,NumViews,pViews) ) 
+
+#define ID3D12GraphicsCommandList6_OMSetRenderTargets(This,NumRenderTargetDescriptors,pRenderTargetDescriptors,RTsSingleHandleToDescriptorRange,pDepthStencilDescriptor)	\
+    ( (This)->lpVtbl -> OMSetRenderTargets(This,NumRenderTargetDescriptors,pRenderTargetDescriptors,RTsSingleHandleToDescriptorRange,pDepthStencilDescriptor) ) 
+
+#define ID3D12GraphicsCommandList6_ClearDepthStencilView(This,DepthStencilView,ClearFlags,Depth,Stencil,NumRects,pRects)	\
+    ( (This)->lpVtbl -> ClearDepthStencilView(This,DepthStencilView,ClearFlags,Depth,Stencil,NumRects,pRects) ) 
+
+#define ID3D12GraphicsCommandList6_ClearRenderTargetView(This,RenderTargetView,ColorRGBA,NumRects,pRects)	\
+    ( (This)->lpVtbl -> ClearRenderTargetView(This,RenderTargetView,ColorRGBA,NumRects,pRects) ) 
+
+#define ID3D12GraphicsCommandList6_ClearUnorderedAccessViewUint(This,ViewGPUHandleInCurrentHeap,ViewCPUHandle,pResource,Values,NumRects,pRects)	\
+    ( (This)->lpVtbl -> ClearUnorderedAccessViewUint(This,ViewGPUHandleInCurrentHeap,ViewCPUHandle,pResource,Values,NumRects,pRects) ) 
+
+#define ID3D12GraphicsCommandList6_ClearUnorderedAccessViewFloat(This,ViewGPUHandleInCurrentHeap,ViewCPUHandle,pResource,Values,NumRects,pRects)	\
+    ( (This)->lpVtbl -> ClearUnorderedAccessViewFloat(This,ViewGPUHandleInCurrentHeap,ViewCPUHandle,pResource,Values,NumRects,pRects) ) 
+
+#define ID3D12GraphicsCommandList6_DiscardResource(This,pResource,pRegion)	\
+    ( (This)->lpVtbl -> DiscardResource(This,pResource,pRegion) ) 
+
+#define ID3D12GraphicsCommandList6_BeginQuery(This,pQueryHeap,Type,Index)	\
+    ( (This)->lpVtbl -> BeginQuery(This,pQueryHeap,Type,Index) ) 
+
+#define ID3D12GraphicsCommandList6_EndQuery(This,pQueryHeap,Type,Index)	\
+    ( (This)->lpVtbl -> EndQuery(This,pQueryHeap,Type,Index) ) 
+
+#define ID3D12GraphicsCommandList6_ResolveQueryData(This,pQueryHeap,Type,StartIndex,NumQueries,pDestinationBuffer,AlignedDestinationBufferOffset)	\
+    ( (This)->lpVtbl -> ResolveQueryData(This,pQueryHeap,Type,StartIndex,NumQueries,pDestinationBuffer,AlignedDestinationBufferOffset) ) 
+
+#define ID3D12GraphicsCommandList6_SetPredication(This,pBuffer,AlignedBufferOffset,Operation)	\
+    ( (This)->lpVtbl -> SetPredication(This,pBuffer,AlignedBufferOffset,Operation) ) 
+
+#define ID3D12GraphicsCommandList6_SetMarker(This,Metadata,pData,Size)	\
+    ( (This)->lpVtbl -> SetMarker(This,Metadata,pData,Size) ) 
+
+#define ID3D12GraphicsCommandList6_BeginEvent(This,Metadata,pData,Size)	\
+    ( (This)->lpVtbl -> BeginEvent(This,Metadata,pData,Size) ) 
+
+#define ID3D12GraphicsCommandList6_EndEvent(This)	\
+    ( (This)->lpVtbl -> EndEvent(This) ) 
+
+#define ID3D12GraphicsCommandList6_ExecuteIndirect(This,pCommandSignature,MaxCommandCount,pArgumentBuffer,ArgumentBufferOffset,pCountBuffer,CountBufferOffset)	\
+    ( (This)->lpVtbl -> ExecuteIndirect(This,pCommandSignature,MaxCommandCount,pArgumentBuffer,ArgumentBufferOffset,pCountBuffer,CountBufferOffset) ) 
+
+
+#define ID3D12GraphicsCommandList6_AtomicCopyBufferUINT(This,pDstBuffer,DstOffset,pSrcBuffer,SrcOffset,Dependencies,ppDependentResources,pDependentSubresourceRanges)	\
+    ( (This)->lpVtbl -> AtomicCopyBufferUINT(This,pDstBuffer,DstOffset,pSrcBuffer,SrcOffset,Dependencies,ppDependentResources,pDependentSubresourceRanges) ) 
+
+#define ID3D12GraphicsCommandList6_AtomicCopyBufferUINT64(This,pDstBuffer,DstOffset,pSrcBuffer,SrcOffset,Dependencies,ppDependentResources,pDependentSubresourceRanges)	\
+    ( (This)->lpVtbl -> AtomicCopyBufferUINT64(This,pDstBuffer,DstOffset,pSrcBuffer,SrcOffset,Dependencies,ppDependentResources,pDependentSubresourceRanges) ) 
+
+#define ID3D12GraphicsCommandList6_OMSetDepthBounds(This,Min,Max)	\
+    ( (This)->lpVtbl -> OMSetDepthBounds(This,Min,Max) ) 
+
+#define ID3D12GraphicsCommandList6_SetSamplePositions(This,NumSamplesPerPixel,NumPixels,pSamplePositions)	\
+    ( (This)->lpVtbl -> SetSamplePositions(This,NumSamplesPerPixel,NumPixels,pSamplePositions) ) 
+
+#define ID3D12GraphicsCommandList6_ResolveSubresourceRegion(This,pDstResource,DstSubresource,DstX,DstY,pSrcResource,SrcSubresource,pSrcRect,Format,ResolveMode)	\
+    ( (This)->lpVtbl -> ResolveSubresourceRegion(This,pDstResource,DstSubresource,DstX,DstY,pSrcResource,SrcSubresource,pSrcRect,Format,ResolveMode) ) 
+
+#define ID3D12GraphicsCommandList6_SetViewInstanceMask(This,Mask)	\
+    ( (This)->lpVtbl -> SetViewInstanceMask(This,Mask) ) 
+
+
+#define ID3D12GraphicsCommandList6_WriteBufferImmediate(This,Count,pParams,pModes)	\
+    ( (This)->lpVtbl -> WriteBufferImmediate(This,Count,pParams,pModes) ) 
+
+
+#define ID3D12GraphicsCommandList6_SetProtectedResourceSession(This,pProtectedResourceSession)	\
+    ( (This)->lpVtbl -> SetProtectedResourceSession(This,pProtectedResourceSession) ) 
+
+
+#define ID3D12GraphicsCommandList6_BeginRenderPass(This,NumRenderTargets,pRenderTargets,pDepthStencil,Flags)	\
+    ( (This)->lpVtbl -> BeginRenderPass(This,NumRenderTargets,pRenderTargets,pDepthStencil,Flags) ) 
+
+#define ID3D12GraphicsCommandList6_EndRenderPass(This)	\
+    ( (This)->lpVtbl -> EndRenderPass(This) ) 
+
+#define ID3D12GraphicsCommandList6_InitializeMetaCommand(This,pMetaCommand,pInitializationParametersData,InitializationParametersDataSizeInBytes)	\
+    ( (This)->lpVtbl -> InitializeMetaCommand(This,pMetaCommand,pInitializationParametersData,InitializationParametersDataSizeInBytes) ) 
+
+#define ID3D12GraphicsCommandList6_ExecuteMetaCommand(This,pMetaCommand,pExecutionParametersData,ExecutionParametersDataSizeInBytes)	\
+    ( (This)->lpVtbl -> ExecuteMetaCommand(This,pMetaCommand,pExecutionParametersData,ExecutionParametersDataSizeInBytes) ) 
+
+#define ID3D12GraphicsCommandList6_BuildRaytracingAccelerationStructure(This,pDesc,NumPostbuildInfoDescs,pPostbuildInfoDescs)	\
+    ( (This)->lpVtbl -> BuildRaytracingAccelerationStructure(This,pDesc,NumPostbuildInfoDescs,pPostbuildInfoDescs) ) 
+
+#define ID3D12GraphicsCommandList6_EmitRaytracingAccelerationStructurePostbuildInfo(This,pDesc,NumSourceAccelerationStructures,pSourceAccelerationStructureData)	\
+    ( (This)->lpVtbl -> EmitRaytracingAccelerationStructurePostbuildInfo(This,pDesc,NumSourceAccelerationStructures,pSourceAccelerationStructureData) ) 
+
+#define ID3D12GraphicsCommandList6_CopyRaytracingAccelerationStructure(This,DestAccelerationStructureData,SourceAccelerationStructureData,Mode)	\
+    ( (This)->lpVtbl -> CopyRaytracingAccelerationStructure(This,DestAccelerationStructureData,SourceAccelerationStructureData,Mode) ) 
+
+#define ID3D12GraphicsCommandList6_SetPipelineState1(This,pStateObject)	\
+    ( (This)->lpVtbl -> SetPipelineState1(This,pStateObject) ) 
+
+#define ID3D12GraphicsCommandList6_DispatchRays(This,pDesc)	\
+    ( (This)->lpVtbl -> DispatchRays(This,pDesc) ) 
+
+
+#define ID3D12GraphicsCommandList6_RSSetShadingRate(This,baseShadingRate,combiners)	\
+    ( (This)->lpVtbl -> RSSetShadingRate(This,baseShadingRate,combiners) ) 
+
+#define ID3D12GraphicsCommandList6_RSSetShadingRateImage(This,shadingRateImage)	\
+    ( (This)->lpVtbl -> RSSetShadingRateImage(This,shadingRateImage) ) 
+
+
+#define ID3D12GraphicsCommandList6_DispatchMesh(This,ThreadGroupCountX,ThreadGroupCountY,ThreadGroupCountZ)	\
+    ( (This)->lpVtbl -> DispatchMesh(This,ThreadGroupCountX,ThreadGroupCountY,ThreadGroupCountZ) ) 
+
+#endif /* COBJMACROS */
+
+
+#endif 	/* C style interface */
+
+
+
+
+#endif 	/* __ID3D12GraphicsCommandList6_INTERFACE_DEFINED__ */
+
+
+#ifndef __ID3D12GraphicsCommandList7_INTERFACE_DEFINED__
+#define __ID3D12GraphicsCommandList7_INTERFACE_DEFINED__
+
+/* interface ID3D12GraphicsCommandList7 */
+/* [unique][local][object][uuid] */ 
+
+
+EXTERN_C const IID IID_ID3D12GraphicsCommandList7;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("dd171223-8b61-4769-90e3-160ccde4e2c1")
+    ID3D12GraphicsCommandList7 : public ID3D12GraphicsCommandList6
+    {
+    public:
+        virtual void STDMETHODCALLTYPE Barrier( 
+            UINT32 NumBarrierGroups,
+            _In_reads_(NumBarrierGroups)  const D3D12_BARRIER_GROUP *pBarrierGroups) = 0;
+        
+    };
+    
+    
+#else 	/* C style interface */
+
+    typedef struct ID3D12GraphicsCommandList7Vtbl
+    {
+        BEGIN_INTERFACE
+        
+        DECLSPEC_XFGVIRT(IUnknown, QueryInterface)
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            ID3D12GraphicsCommandList7 * This,
+            REFIID riid,
+            _COM_Outptr_  void **ppvObject);
+        
+        DECLSPEC_XFGVIRT(IUnknown, AddRef)
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            ID3D12GraphicsCommandList7 * This);
+        
+        DECLSPEC_XFGVIRT(IUnknown, Release)
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            ID3D12GraphicsCommandList7 * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, GetPrivateData)
+        HRESULT ( STDMETHODCALLTYPE *GetPrivateData )( 
+            ID3D12GraphicsCommandList7 * This,
+            _In_  REFGUID guid,
+            _Inout_  UINT *pDataSize,
+            _Out_writes_bytes_opt_( *pDataSize )  void *pData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, SetPrivateData)
+        HRESULT ( STDMETHODCALLTYPE *SetPrivateData )( 
+            ID3D12GraphicsCommandList7 * This,
+            _In_  REFGUID guid,
+            _In_  UINT DataSize,
+            _In_reads_bytes_opt_( DataSize )  const void *pData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, SetPrivateDataInterface)
+        HRESULT ( STDMETHODCALLTYPE *SetPrivateDataInterface )( 
+            ID3D12GraphicsCommandList7 * This,
+            _In_  REFGUID guid,
+            _In_opt_  const IUnknown *pData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, SetName)
+        HRESULT ( STDMETHODCALLTYPE *SetName )( 
+            ID3D12GraphicsCommandList7 * This,
+            _In_z_  LPCWSTR Name);
+        
+        DECLSPEC_XFGVIRT(ID3D12DeviceChild, GetDevice)
+        HRESULT ( STDMETHODCALLTYPE *GetDevice )( 
+            ID3D12GraphicsCommandList7 * This,
+            REFIID riid,
+            _COM_Outptr_opt_  void **ppvDevice);
+        
+        DECLSPEC_XFGVIRT(ID3D12CommandList, GetType)
+        D3D12_COMMAND_LIST_TYPE ( STDMETHODCALLTYPE *GetType )( 
+            ID3D12GraphicsCommandList7 * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, Close)
+        HRESULT ( STDMETHODCALLTYPE *Close )( 
+            ID3D12GraphicsCommandList7 * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, Reset)
+        HRESULT ( STDMETHODCALLTYPE *Reset )( 
+            ID3D12GraphicsCommandList7 * This,
+            _In_  ID3D12CommandAllocator *pAllocator,
+            _In_opt_  ID3D12PipelineState *pInitialState);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, ClearState)
+        void ( STDMETHODCALLTYPE *ClearState )( 
+            ID3D12GraphicsCommandList7 * This,
+            _In_opt_  ID3D12PipelineState *pPipelineState);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, DrawInstanced)
+        void ( STDMETHODCALLTYPE *DrawInstanced )( 
+            ID3D12GraphicsCommandList7 * This,
+            _In_  UINT VertexCountPerInstance,
+            _In_  UINT InstanceCount,
+            _In_  UINT StartVertexLocation,
+            _In_  UINT StartInstanceLocation);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, DrawIndexedInstanced)
+        void ( STDMETHODCALLTYPE *DrawIndexedInstanced )( 
+            ID3D12GraphicsCommandList7 * This,
+            _In_  UINT IndexCountPerInstance,
+            _In_  UINT InstanceCount,
+            _In_  UINT StartIndexLocation,
+            _In_  INT BaseVertexLocation,
+            _In_  UINT StartInstanceLocation);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, Dispatch)
+        void ( STDMETHODCALLTYPE *Dispatch )( 
+            ID3D12GraphicsCommandList7 * This,
+            _In_  UINT ThreadGroupCountX,
+            _In_  UINT ThreadGroupCountY,
+            _In_  UINT ThreadGroupCountZ);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, CopyBufferRegion)
+        void ( STDMETHODCALLTYPE *CopyBufferRegion )( 
+            ID3D12GraphicsCommandList7 * This,
+            _In_  ID3D12Resource *pDstBuffer,
+            UINT64 DstOffset,
+            _In_  ID3D12Resource *pSrcBuffer,
+            UINT64 SrcOffset,
+            UINT64 NumBytes);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, CopyTextureRegion)
+        void ( STDMETHODCALLTYPE *CopyTextureRegion )( 
+            ID3D12GraphicsCommandList7 * This,
+            _In_  const D3D12_TEXTURE_COPY_LOCATION *pDst,
+            UINT DstX,
+            UINT DstY,
+            UINT DstZ,
+            _In_  const D3D12_TEXTURE_COPY_LOCATION *pSrc,
+            _In_opt_  const D3D12_BOX *pSrcBox);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, CopyResource)
+        void ( STDMETHODCALLTYPE *CopyResource )( 
+            ID3D12GraphicsCommandList7 * This,
+            _In_  ID3D12Resource *pDstResource,
+            _In_  ID3D12Resource *pSrcResource);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, CopyTiles)
+        void ( STDMETHODCALLTYPE *CopyTiles )( 
+            ID3D12GraphicsCommandList7 * This,
+            _In_  ID3D12Resource *pTiledResource,
+            _In_  const D3D12_TILED_RESOURCE_COORDINATE *pTileRegionStartCoordinate,
+            _In_  const D3D12_TILE_REGION_SIZE *pTileRegionSize,
+            _In_  ID3D12Resource *pBuffer,
+            UINT64 BufferStartOffsetInBytes,
+            D3D12_TILE_COPY_FLAGS Flags);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, ResolveSubresource)
+        void ( STDMETHODCALLTYPE *ResolveSubresource )( 
+            ID3D12GraphicsCommandList7 * This,
+            _In_  ID3D12Resource *pDstResource,
+            _In_  UINT DstSubresource,
+            _In_  ID3D12Resource *pSrcResource,
+            _In_  UINT SrcSubresource,
+            _In_  DXGI_FORMAT Format);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, IASetPrimitiveTopology)
+        void ( STDMETHODCALLTYPE *IASetPrimitiveTopology )( 
+            ID3D12GraphicsCommandList7 * This,
+            _In_  D3D12_PRIMITIVE_TOPOLOGY PrimitiveTopology);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, RSSetViewports)
+        void ( STDMETHODCALLTYPE *RSSetViewports )( 
+            ID3D12GraphicsCommandList7 * This,
+            _In_range_(0, D3D12_VIEWPORT_AND_SCISSORRECT_OBJECT_COUNT_PER_PIPELINE)  UINT NumViewports,
+            _In_reads_( NumViewports)  const D3D12_VIEWPORT *pViewports);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, RSSetScissorRects)
+        void ( STDMETHODCALLTYPE *RSSetScissorRects )( 
+            ID3D12GraphicsCommandList7 * This,
+            _In_range_(0, D3D12_VIEWPORT_AND_SCISSORRECT_OBJECT_COUNT_PER_PIPELINE)  UINT NumRects,
+            _In_reads_( NumRects)  const D3D12_RECT *pRects);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, OMSetBlendFactor)
+        void ( STDMETHODCALLTYPE *OMSetBlendFactor )( 
+            ID3D12GraphicsCommandList7 * This,
+            _In_reads_opt_(4)  const FLOAT BlendFactor[ 4 ]);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, OMSetStencilRef)
+        void ( STDMETHODCALLTYPE *OMSetStencilRef )( 
+            ID3D12GraphicsCommandList7 * This,
+            _In_  UINT StencilRef);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetPipelineState)
+        void ( STDMETHODCALLTYPE *SetPipelineState )( 
+            ID3D12GraphicsCommandList7 * This,
+            _In_  ID3D12PipelineState *pPipelineState);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, ResourceBarrier)
+        void ( STDMETHODCALLTYPE *ResourceBarrier )( 
+            ID3D12GraphicsCommandList7 * This,
+            _In_  UINT NumBarriers,
+            _In_reads_(NumBarriers)  const D3D12_RESOURCE_BARRIER *pBarriers);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, ExecuteBundle)
+        void ( STDMETHODCALLTYPE *ExecuteBundle )( 
+            ID3D12GraphicsCommandList7 * This,
+            _In_  ID3D12GraphicsCommandList *pCommandList);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetDescriptorHeaps)
+        void ( STDMETHODCALLTYPE *SetDescriptorHeaps )( 
+            ID3D12GraphicsCommandList7 * This,
+            _In_  UINT NumDescriptorHeaps,
+            _In_reads_(NumDescriptorHeaps)  ID3D12DescriptorHeap *const *ppDescriptorHeaps);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetComputeRootSignature)
+        void ( STDMETHODCALLTYPE *SetComputeRootSignature )( 
+            ID3D12GraphicsCommandList7 * This,
+            _In_opt_  ID3D12RootSignature *pRootSignature);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetGraphicsRootSignature)
+        void ( STDMETHODCALLTYPE *SetGraphicsRootSignature )( 
+            ID3D12GraphicsCommandList7 * This,
+            _In_opt_  ID3D12RootSignature *pRootSignature);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetComputeRootDescriptorTable)
+        void ( STDMETHODCALLTYPE *SetComputeRootDescriptorTable )( 
+            ID3D12GraphicsCommandList7 * This,
+            _In_  UINT RootParameterIndex,
+            _In_  D3D12_GPU_DESCRIPTOR_HANDLE BaseDescriptor);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetGraphicsRootDescriptorTable)
+        void ( STDMETHODCALLTYPE *SetGraphicsRootDescriptorTable )( 
+            ID3D12GraphicsCommandList7 * This,
+            _In_  UINT RootParameterIndex,
+            _In_  D3D12_GPU_DESCRIPTOR_HANDLE BaseDescriptor);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetComputeRoot32BitConstant)
+        void ( STDMETHODCALLTYPE *SetComputeRoot32BitConstant )( 
+            ID3D12GraphicsCommandList7 * This,
+            _In_  UINT RootParameterIndex,
+            _In_  UINT SrcData,
+            _In_  UINT DestOffsetIn32BitValues);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetGraphicsRoot32BitConstant)
+        void ( STDMETHODCALLTYPE *SetGraphicsRoot32BitConstant )( 
+            ID3D12GraphicsCommandList7 * This,
+            _In_  UINT RootParameterIndex,
+            _In_  UINT SrcData,
+            _In_  UINT DestOffsetIn32BitValues);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetComputeRoot32BitConstants)
+        void ( STDMETHODCALLTYPE *SetComputeRoot32BitConstants )( 
+            ID3D12GraphicsCommandList7 * This,
+            _In_  UINT RootParameterIndex,
+            _In_  UINT Num32BitValuesToSet,
+            _In_reads_(Num32BitValuesToSet*sizeof(UINT))  const void *pSrcData,
+            _In_  UINT DestOffsetIn32BitValues);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetGraphicsRoot32BitConstants)
+        void ( STDMETHODCALLTYPE *SetGraphicsRoot32BitConstants )( 
+            ID3D12GraphicsCommandList7 * This,
+            _In_  UINT RootParameterIndex,
+            _In_  UINT Num32BitValuesToSet,
+            _In_reads_(Num32BitValuesToSet*sizeof(UINT))  const void *pSrcData,
+            _In_  UINT DestOffsetIn32BitValues);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetComputeRootConstantBufferView)
+        void ( STDMETHODCALLTYPE *SetComputeRootConstantBufferView )( 
+            ID3D12GraphicsCommandList7 * This,
+            _In_  UINT RootParameterIndex,
+            _In_  D3D12_GPU_VIRTUAL_ADDRESS BufferLocation);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetGraphicsRootConstantBufferView)
+        void ( STDMETHODCALLTYPE *SetGraphicsRootConstantBufferView )( 
+            ID3D12GraphicsCommandList7 * This,
+            _In_  UINT RootParameterIndex,
+            _In_  D3D12_GPU_VIRTUAL_ADDRESS BufferLocation);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetComputeRootShaderResourceView)
+        void ( STDMETHODCALLTYPE *SetComputeRootShaderResourceView )( 
+            ID3D12GraphicsCommandList7 * This,
+            _In_  UINT RootParameterIndex,
+            _In_  D3D12_GPU_VIRTUAL_ADDRESS BufferLocation);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetGraphicsRootShaderResourceView)
+        void ( STDMETHODCALLTYPE *SetGraphicsRootShaderResourceView )( 
+            ID3D12GraphicsCommandList7 * This,
+            _In_  UINT RootParameterIndex,
+            _In_  D3D12_GPU_VIRTUAL_ADDRESS BufferLocation);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetComputeRootUnorderedAccessView)
+        void ( STDMETHODCALLTYPE *SetComputeRootUnorderedAccessView )( 
+            ID3D12GraphicsCommandList7 * This,
+            _In_  UINT RootParameterIndex,
+            _In_  D3D12_GPU_VIRTUAL_ADDRESS BufferLocation);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetGraphicsRootUnorderedAccessView)
+        void ( STDMETHODCALLTYPE *SetGraphicsRootUnorderedAccessView )( 
+            ID3D12GraphicsCommandList7 * This,
+            _In_  UINT RootParameterIndex,
+            _In_  D3D12_GPU_VIRTUAL_ADDRESS BufferLocation);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, IASetIndexBuffer)
+        void ( STDMETHODCALLTYPE *IASetIndexBuffer )( 
+            ID3D12GraphicsCommandList7 * This,
+            _In_opt_  const D3D12_INDEX_BUFFER_VIEW *pView);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, IASetVertexBuffers)
+        void ( STDMETHODCALLTYPE *IASetVertexBuffers )( 
+            ID3D12GraphicsCommandList7 * This,
+            _In_  UINT StartSlot,
+            _In_  UINT NumViews,
+            _In_reads_opt_(NumViews)  const D3D12_VERTEX_BUFFER_VIEW *pViews);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SOSetTargets)
+        void ( STDMETHODCALLTYPE *SOSetTargets )( 
+            ID3D12GraphicsCommandList7 * This,
+            _In_  UINT StartSlot,
+            _In_  UINT NumViews,
+            _In_reads_opt_(NumViews)  const D3D12_STREAM_OUTPUT_BUFFER_VIEW *pViews);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, OMSetRenderTargets)
+        void ( STDMETHODCALLTYPE *OMSetRenderTargets )( 
+            ID3D12GraphicsCommandList7 * This,
+            _In_  UINT NumRenderTargetDescriptors,
+            _In_opt_  const D3D12_CPU_DESCRIPTOR_HANDLE *pRenderTargetDescriptors,
+            _In_  BOOL RTsSingleHandleToDescriptorRange,
+            _In_opt_  const D3D12_CPU_DESCRIPTOR_HANDLE *pDepthStencilDescriptor);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, ClearDepthStencilView)
+        void ( STDMETHODCALLTYPE *ClearDepthStencilView )( 
+            ID3D12GraphicsCommandList7 * This,
+            _In_  D3D12_CPU_DESCRIPTOR_HANDLE DepthStencilView,
+            _In_  D3D12_CLEAR_FLAGS ClearFlags,
+            _In_  FLOAT Depth,
+            _In_  UINT8 Stencil,
+            _In_  UINT NumRects,
+            _In_reads_(NumRects)  const D3D12_RECT *pRects);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, ClearRenderTargetView)
+        void ( STDMETHODCALLTYPE *ClearRenderTargetView )( 
+            ID3D12GraphicsCommandList7 * This,
+            _In_  D3D12_CPU_DESCRIPTOR_HANDLE RenderTargetView,
+            _In_  const FLOAT ColorRGBA[ 4 ],
+            _In_  UINT NumRects,
+            _In_reads_(NumRects)  const D3D12_RECT *pRects);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, ClearUnorderedAccessViewUint)
+        void ( STDMETHODCALLTYPE *ClearUnorderedAccessViewUint )( 
+            ID3D12GraphicsCommandList7 * This,
+            _In_  D3D12_GPU_DESCRIPTOR_HANDLE ViewGPUHandleInCurrentHeap,
+            _In_  D3D12_CPU_DESCRIPTOR_HANDLE ViewCPUHandle,
+            _In_  ID3D12Resource *pResource,
+            _In_  const UINT Values[ 4 ],
+            _In_  UINT NumRects,
+            _In_reads_(NumRects)  const D3D12_RECT *pRects);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, ClearUnorderedAccessViewFloat)
+        void ( STDMETHODCALLTYPE *ClearUnorderedAccessViewFloat )( 
+            ID3D12GraphicsCommandList7 * This,
+            _In_  D3D12_GPU_DESCRIPTOR_HANDLE ViewGPUHandleInCurrentHeap,
+            _In_  D3D12_CPU_DESCRIPTOR_HANDLE ViewCPUHandle,
+            _In_  ID3D12Resource *pResource,
+            _In_  const FLOAT Values[ 4 ],
+            _In_  UINT NumRects,
+            _In_reads_(NumRects)  const D3D12_RECT *pRects);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, DiscardResource)
+        void ( STDMETHODCALLTYPE *DiscardResource )( 
+            ID3D12GraphicsCommandList7 * This,
+            _In_  ID3D12Resource *pResource,
+            _In_opt_  const D3D12_DISCARD_REGION *pRegion);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, BeginQuery)
+        void ( STDMETHODCALLTYPE *BeginQuery )( 
+            ID3D12GraphicsCommandList7 * This,
+            _In_  ID3D12QueryHeap *pQueryHeap,
+            _In_  D3D12_QUERY_TYPE Type,
+            _In_  UINT Index);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, EndQuery)
+        void ( STDMETHODCALLTYPE *EndQuery )( 
+            ID3D12GraphicsCommandList7 * This,
+            _In_  ID3D12QueryHeap *pQueryHeap,
+            _In_  D3D12_QUERY_TYPE Type,
+            _In_  UINT Index);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, ResolveQueryData)
+        void ( STDMETHODCALLTYPE *ResolveQueryData )( 
+            ID3D12GraphicsCommandList7 * This,
+            _In_  ID3D12QueryHeap *pQueryHeap,
+            _In_  D3D12_QUERY_TYPE Type,
+            _In_  UINT StartIndex,
+            _In_  UINT NumQueries,
+            _In_  ID3D12Resource *pDestinationBuffer,
+            _In_  UINT64 AlignedDestinationBufferOffset);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetPredication)
+        void ( STDMETHODCALLTYPE *SetPredication )( 
+            ID3D12GraphicsCommandList7 * This,
+            _In_opt_  ID3D12Resource *pBuffer,
+            _In_  UINT64 AlignedBufferOffset,
+            _In_  D3D12_PREDICATION_OP Operation);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetMarker)
+        void ( STDMETHODCALLTYPE *SetMarker )( 
+            ID3D12GraphicsCommandList7 * This,
+            UINT Metadata,
+            _In_reads_bytes_opt_(Size)  const void *pData,
+            UINT Size);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, BeginEvent)
+        void ( STDMETHODCALLTYPE *BeginEvent )( 
+            ID3D12GraphicsCommandList7 * This,
+            UINT Metadata,
+            _In_reads_bytes_opt_(Size)  const void *pData,
+            UINT Size);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, EndEvent)
+        void ( STDMETHODCALLTYPE *EndEvent )( 
+            ID3D12GraphicsCommandList7 * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, ExecuteIndirect)
+        void ( STDMETHODCALLTYPE *ExecuteIndirect )( 
+            ID3D12GraphicsCommandList7 * This,
+            _In_  ID3D12CommandSignature *pCommandSignature,
+            _In_  UINT MaxCommandCount,
+            _In_  ID3D12Resource *pArgumentBuffer,
+            _In_  UINT64 ArgumentBufferOffset,
+            _In_opt_  ID3D12Resource *pCountBuffer,
+            _In_  UINT64 CountBufferOffset);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList1, AtomicCopyBufferUINT)
+        void ( STDMETHODCALLTYPE *AtomicCopyBufferUINT )( 
+            ID3D12GraphicsCommandList7 * This,
+            _In_  ID3D12Resource *pDstBuffer,
+            UINT64 DstOffset,
+            _In_  ID3D12Resource *pSrcBuffer,
+            UINT64 SrcOffset,
+            UINT Dependencies,
+            _In_reads_(Dependencies)  ID3D12Resource *const *ppDependentResources,
+            _In_reads_(Dependencies)  const D3D12_SUBRESOURCE_RANGE_UINT64 *pDependentSubresourceRanges);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList1, AtomicCopyBufferUINT64)
+        void ( STDMETHODCALLTYPE *AtomicCopyBufferUINT64 )( 
+            ID3D12GraphicsCommandList7 * This,
+            _In_  ID3D12Resource *pDstBuffer,
+            UINT64 DstOffset,
+            _In_  ID3D12Resource *pSrcBuffer,
+            UINT64 SrcOffset,
+            UINT Dependencies,
+            _In_reads_(Dependencies)  ID3D12Resource *const *ppDependentResources,
+            _In_reads_(Dependencies)  const D3D12_SUBRESOURCE_RANGE_UINT64 *pDependentSubresourceRanges);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList1, OMSetDepthBounds)
+        void ( STDMETHODCALLTYPE *OMSetDepthBounds )( 
+            ID3D12GraphicsCommandList7 * This,
+            _In_  FLOAT Min,
+            _In_  FLOAT Max);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList1, SetSamplePositions)
+        void ( STDMETHODCALLTYPE *SetSamplePositions )( 
+            ID3D12GraphicsCommandList7 * This,
+            _In_  UINT NumSamplesPerPixel,
+            _In_  UINT NumPixels,
+            _In_reads_(NumSamplesPerPixel*NumPixels)  D3D12_SAMPLE_POSITION *pSamplePositions);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList1, ResolveSubresourceRegion)
+        void ( STDMETHODCALLTYPE *ResolveSubresourceRegion )( 
+            ID3D12GraphicsCommandList7 * This,
+            _In_  ID3D12Resource *pDstResource,
+            _In_  UINT DstSubresource,
+            _In_  UINT DstX,
+            _In_  UINT DstY,
+            _In_  ID3D12Resource *pSrcResource,
+            _In_  UINT SrcSubresource,
+            _In_opt_  D3D12_RECT *pSrcRect,
+            _In_  DXGI_FORMAT Format,
+            _In_  D3D12_RESOLVE_MODE ResolveMode);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList1, SetViewInstanceMask)
+        void ( STDMETHODCALLTYPE *SetViewInstanceMask )( 
+            ID3D12GraphicsCommandList7 * This,
+            _In_  UINT Mask);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList2, WriteBufferImmediate)
+        void ( STDMETHODCALLTYPE *WriteBufferImmediate )( 
+            ID3D12GraphicsCommandList7 * This,
+            UINT Count,
+            _In_reads_(Count)  const D3D12_WRITEBUFFERIMMEDIATE_PARAMETER *pParams,
+            _In_reads_opt_(Count)  const D3D12_WRITEBUFFERIMMEDIATE_MODE *pModes);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList3, SetProtectedResourceSession)
+        void ( STDMETHODCALLTYPE *SetProtectedResourceSession )( 
+            ID3D12GraphicsCommandList7 * This,
+            _In_opt_  ID3D12ProtectedResourceSession *pProtectedResourceSession);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList4, BeginRenderPass)
+        void ( STDMETHODCALLTYPE *BeginRenderPass )( 
+            ID3D12GraphicsCommandList7 * This,
+            _In_  UINT NumRenderTargets,
+            _In_reads_opt_(NumRenderTargets)  const D3D12_RENDER_PASS_RENDER_TARGET_DESC *pRenderTargets,
+            _In_opt_  const D3D12_RENDER_PASS_DEPTH_STENCIL_DESC *pDepthStencil,
+            D3D12_RENDER_PASS_FLAGS Flags);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList4, EndRenderPass)
+        void ( STDMETHODCALLTYPE *EndRenderPass )( 
+            ID3D12GraphicsCommandList7 * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList4, InitializeMetaCommand)
+        void ( STDMETHODCALLTYPE *InitializeMetaCommand )( 
+            ID3D12GraphicsCommandList7 * This,
+            _In_  ID3D12MetaCommand *pMetaCommand,
+            _In_reads_bytes_opt_(InitializationParametersDataSizeInBytes)  const void *pInitializationParametersData,
+            _In_  SIZE_T InitializationParametersDataSizeInBytes);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList4, ExecuteMetaCommand)
+        void ( STDMETHODCALLTYPE *ExecuteMetaCommand )( 
+            ID3D12GraphicsCommandList7 * This,
+            _In_  ID3D12MetaCommand *pMetaCommand,
+            _In_reads_bytes_opt_(ExecutionParametersDataSizeInBytes)  const void *pExecutionParametersData,
+            _In_  SIZE_T ExecutionParametersDataSizeInBytes);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList4, BuildRaytracingAccelerationStructure)
+        void ( STDMETHODCALLTYPE *BuildRaytracingAccelerationStructure )( 
+            ID3D12GraphicsCommandList7 * This,
+            _In_  const D3D12_BUILD_RAYTRACING_ACCELERATION_STRUCTURE_DESC *pDesc,
+            _In_  UINT NumPostbuildInfoDescs,
+            _In_reads_opt_(NumPostbuildInfoDescs)  const D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_DESC *pPostbuildInfoDescs);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList4, EmitRaytracingAccelerationStructurePostbuildInfo)
+        void ( STDMETHODCALLTYPE *EmitRaytracingAccelerationStructurePostbuildInfo )( 
+            ID3D12GraphicsCommandList7 * This,
+            _In_  const D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_DESC *pDesc,
+            _In_  UINT NumSourceAccelerationStructures,
+            _In_reads_( NumSourceAccelerationStructures )  const D3D12_GPU_VIRTUAL_ADDRESS *pSourceAccelerationStructureData);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList4, CopyRaytracingAccelerationStructure)
+        void ( STDMETHODCALLTYPE *CopyRaytracingAccelerationStructure )( 
+            ID3D12GraphicsCommandList7 * This,
+            _In_  D3D12_GPU_VIRTUAL_ADDRESS DestAccelerationStructureData,
+            _In_  D3D12_GPU_VIRTUAL_ADDRESS SourceAccelerationStructureData,
+            _In_  D3D12_RAYTRACING_ACCELERATION_STRUCTURE_COPY_MODE Mode);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList4, SetPipelineState1)
+        void ( STDMETHODCALLTYPE *SetPipelineState1 )( 
+            ID3D12GraphicsCommandList7 * This,
+            _In_  ID3D12StateObject *pStateObject);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList4, DispatchRays)
+        void ( STDMETHODCALLTYPE *DispatchRays )( 
+            ID3D12GraphicsCommandList7 * This,
+            _In_  const D3D12_DISPATCH_RAYS_DESC *pDesc);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList5, RSSetShadingRate)
+        void ( STDMETHODCALLTYPE *RSSetShadingRate )( 
+            ID3D12GraphicsCommandList7 * This,
+            _In_  D3D12_SHADING_RATE baseShadingRate,
+            _In_reads_opt_(D3D12_RS_SET_SHADING_RATE_COMBINER_COUNT)  const D3D12_SHADING_RATE_COMBINER *combiners);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList5, RSSetShadingRateImage)
+        void ( STDMETHODCALLTYPE *RSSetShadingRateImage )( 
+            ID3D12GraphicsCommandList7 * This,
+            _In_opt_  ID3D12Resource *shadingRateImage);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList6, DispatchMesh)
+        void ( STDMETHODCALLTYPE *DispatchMesh )( 
+            ID3D12GraphicsCommandList7 * This,
+            _In_  UINT ThreadGroupCountX,
+            _In_  UINT ThreadGroupCountY,
+            _In_  UINT ThreadGroupCountZ);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList7, Barrier)
+        void ( STDMETHODCALLTYPE *Barrier )( 
+            ID3D12GraphicsCommandList7 * This,
+            UINT32 NumBarrierGroups,
+            _In_reads_(NumBarrierGroups)  const D3D12_BARRIER_GROUP *pBarrierGroups);
+        
+        END_INTERFACE
+    } ID3D12GraphicsCommandList7Vtbl;
+
+    interface ID3D12GraphicsCommandList7
+    {
+        CONST_VTBL struct ID3D12GraphicsCommandList7Vtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define ID3D12GraphicsCommandList7_QueryInterface(This,riid,ppvObject)	\
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define ID3D12GraphicsCommandList7_AddRef(This)	\
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define ID3D12GraphicsCommandList7_Release(This)	\
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#define ID3D12GraphicsCommandList7_GetPrivateData(This,guid,pDataSize,pData)	\
+    ( (This)->lpVtbl -> GetPrivateData(This,guid,pDataSize,pData) ) 
+
+#define ID3D12GraphicsCommandList7_SetPrivateData(This,guid,DataSize,pData)	\
+    ( (This)->lpVtbl -> SetPrivateData(This,guid,DataSize,pData) ) 
+
+#define ID3D12GraphicsCommandList7_SetPrivateDataInterface(This,guid,pData)	\
+    ( (This)->lpVtbl -> SetPrivateDataInterface(This,guid,pData) ) 
+
+#define ID3D12GraphicsCommandList7_SetName(This,Name)	\
+    ( (This)->lpVtbl -> SetName(This,Name) ) 
+
+
+#define ID3D12GraphicsCommandList7_GetDevice(This,riid,ppvDevice)	\
+    ( (This)->lpVtbl -> GetDevice(This,riid,ppvDevice) ) 
+
+
+#define ID3D12GraphicsCommandList7_GetType(This)	\
+    ( (This)->lpVtbl -> GetType(This) ) 
+
+
+#define ID3D12GraphicsCommandList7_Close(This)	\
+    ( (This)->lpVtbl -> Close(This) ) 
+
+#define ID3D12GraphicsCommandList7_Reset(This,pAllocator,pInitialState)	\
+    ( (This)->lpVtbl -> Reset(This,pAllocator,pInitialState) ) 
+
+#define ID3D12GraphicsCommandList7_ClearState(This,pPipelineState)	\
+    ( (This)->lpVtbl -> ClearState(This,pPipelineState) ) 
+
+#define ID3D12GraphicsCommandList7_DrawInstanced(This,VertexCountPerInstance,InstanceCount,StartVertexLocation,StartInstanceLocation)	\
+    ( (This)->lpVtbl -> DrawInstanced(This,VertexCountPerInstance,InstanceCount,StartVertexLocation,StartInstanceLocation) ) 
+
+#define ID3D12GraphicsCommandList7_DrawIndexedInstanced(This,IndexCountPerInstance,InstanceCount,StartIndexLocation,BaseVertexLocation,StartInstanceLocation)	\
+    ( (This)->lpVtbl -> DrawIndexedInstanced(This,IndexCountPerInstance,InstanceCount,StartIndexLocation,BaseVertexLocation,StartInstanceLocation) ) 
+
+#define ID3D12GraphicsCommandList7_Dispatch(This,ThreadGroupCountX,ThreadGroupCountY,ThreadGroupCountZ)	\
+    ( (This)->lpVtbl -> Dispatch(This,ThreadGroupCountX,ThreadGroupCountY,ThreadGroupCountZ) ) 
+
+#define ID3D12GraphicsCommandList7_CopyBufferRegion(This,pDstBuffer,DstOffset,pSrcBuffer,SrcOffset,NumBytes)	\
+    ( (This)->lpVtbl -> CopyBufferRegion(This,pDstBuffer,DstOffset,pSrcBuffer,SrcOffset,NumBytes) ) 
+
+#define ID3D12GraphicsCommandList7_CopyTextureRegion(This,pDst,DstX,DstY,DstZ,pSrc,pSrcBox)	\
+    ( (This)->lpVtbl -> CopyTextureRegion(This,pDst,DstX,DstY,DstZ,pSrc,pSrcBox) ) 
+
+#define ID3D12GraphicsCommandList7_CopyResource(This,pDstResource,pSrcResource)	\
+    ( (This)->lpVtbl -> CopyResource(This,pDstResource,pSrcResource) ) 
+
+#define ID3D12GraphicsCommandList7_CopyTiles(This,pTiledResource,pTileRegionStartCoordinate,pTileRegionSize,pBuffer,BufferStartOffsetInBytes,Flags)	\
+    ( (This)->lpVtbl -> CopyTiles(This,pTiledResource,pTileRegionStartCoordinate,pTileRegionSize,pBuffer,BufferStartOffsetInBytes,Flags) ) 
+
+#define ID3D12GraphicsCommandList7_ResolveSubresource(This,pDstResource,DstSubresource,pSrcResource,SrcSubresource,Format)	\
+    ( (This)->lpVtbl -> ResolveSubresource(This,pDstResource,DstSubresource,pSrcResource,SrcSubresource,Format) ) 
+
+#define ID3D12GraphicsCommandList7_IASetPrimitiveTopology(This,PrimitiveTopology)	\
+    ( (This)->lpVtbl -> IASetPrimitiveTopology(This,PrimitiveTopology) ) 
+
+#define ID3D12GraphicsCommandList7_RSSetViewports(This,NumViewports,pViewports)	\
+    ( (This)->lpVtbl -> RSSetViewports(This,NumViewports,pViewports) ) 
+
+#define ID3D12GraphicsCommandList7_RSSetScissorRects(This,NumRects,pRects)	\
+    ( (This)->lpVtbl -> RSSetScissorRects(This,NumRects,pRects) ) 
+
+#define ID3D12GraphicsCommandList7_OMSetBlendFactor(This,BlendFactor)	\
+    ( (This)->lpVtbl -> OMSetBlendFactor(This,BlendFactor) ) 
+
+#define ID3D12GraphicsCommandList7_OMSetStencilRef(This,StencilRef)	\
+    ( (This)->lpVtbl -> OMSetStencilRef(This,StencilRef) ) 
+
+#define ID3D12GraphicsCommandList7_SetPipelineState(This,pPipelineState)	\
+    ( (This)->lpVtbl -> SetPipelineState(This,pPipelineState) ) 
+
+#define ID3D12GraphicsCommandList7_ResourceBarrier(This,NumBarriers,pBarriers)	\
+    ( (This)->lpVtbl -> ResourceBarrier(This,NumBarriers,pBarriers) ) 
+
+#define ID3D12GraphicsCommandList7_ExecuteBundle(This,pCommandList)	\
+    ( (This)->lpVtbl -> ExecuteBundle(This,pCommandList) ) 
+
+#define ID3D12GraphicsCommandList7_SetDescriptorHeaps(This,NumDescriptorHeaps,ppDescriptorHeaps)	\
+    ( (This)->lpVtbl -> SetDescriptorHeaps(This,NumDescriptorHeaps,ppDescriptorHeaps) ) 
+
+#define ID3D12GraphicsCommandList7_SetComputeRootSignature(This,pRootSignature)	\
+    ( (This)->lpVtbl -> SetComputeRootSignature(This,pRootSignature) ) 
+
+#define ID3D12GraphicsCommandList7_SetGraphicsRootSignature(This,pRootSignature)	\
+    ( (This)->lpVtbl -> SetGraphicsRootSignature(This,pRootSignature) ) 
+
+#define ID3D12GraphicsCommandList7_SetComputeRootDescriptorTable(This,RootParameterIndex,BaseDescriptor)	\
+    ( (This)->lpVtbl -> SetComputeRootDescriptorTable(This,RootParameterIndex,BaseDescriptor) ) 
+
+#define ID3D12GraphicsCommandList7_SetGraphicsRootDescriptorTable(This,RootParameterIndex,BaseDescriptor)	\
+    ( (This)->lpVtbl -> SetGraphicsRootDescriptorTable(This,RootParameterIndex,BaseDescriptor) ) 
+
+#define ID3D12GraphicsCommandList7_SetComputeRoot32BitConstant(This,RootParameterIndex,SrcData,DestOffsetIn32BitValues)	\
+    ( (This)->lpVtbl -> SetComputeRoot32BitConstant(This,RootParameterIndex,SrcData,DestOffsetIn32BitValues) ) 
+
+#define ID3D12GraphicsCommandList7_SetGraphicsRoot32BitConstant(This,RootParameterIndex,SrcData,DestOffsetIn32BitValues)	\
+    ( (This)->lpVtbl -> SetGraphicsRoot32BitConstant(This,RootParameterIndex,SrcData,DestOffsetIn32BitValues) ) 
+
+#define ID3D12GraphicsCommandList7_SetComputeRoot32BitConstants(This,RootParameterIndex,Num32BitValuesToSet,pSrcData,DestOffsetIn32BitValues)	\
+    ( (This)->lpVtbl -> SetComputeRoot32BitConstants(This,RootParameterIndex,Num32BitValuesToSet,pSrcData,DestOffsetIn32BitValues) ) 
+
+#define ID3D12GraphicsCommandList7_SetGraphicsRoot32BitConstants(This,RootParameterIndex,Num32BitValuesToSet,pSrcData,DestOffsetIn32BitValues)	\
+    ( (This)->lpVtbl -> SetGraphicsRoot32BitConstants(This,RootParameterIndex,Num32BitValuesToSet,pSrcData,DestOffsetIn32BitValues) ) 
+
+#define ID3D12GraphicsCommandList7_SetComputeRootConstantBufferView(This,RootParameterIndex,BufferLocation)	\
+    ( (This)->lpVtbl -> SetComputeRootConstantBufferView(This,RootParameterIndex,BufferLocation) ) 
+
+#define ID3D12GraphicsCommandList7_SetGraphicsRootConstantBufferView(This,RootParameterIndex,BufferLocation)	\
+    ( (This)->lpVtbl -> SetGraphicsRootConstantBufferView(This,RootParameterIndex,BufferLocation) ) 
+
+#define ID3D12GraphicsCommandList7_SetComputeRootShaderResourceView(This,RootParameterIndex,BufferLocation)	\
+    ( (This)->lpVtbl -> SetComputeRootShaderResourceView(This,RootParameterIndex,BufferLocation) ) 
+
+#define ID3D12GraphicsCommandList7_SetGraphicsRootShaderResourceView(This,RootParameterIndex,BufferLocation)	\
+    ( (This)->lpVtbl -> SetGraphicsRootShaderResourceView(This,RootParameterIndex,BufferLocation) ) 
+
+#define ID3D12GraphicsCommandList7_SetComputeRootUnorderedAccessView(This,RootParameterIndex,BufferLocation)	\
+    ( (This)->lpVtbl -> SetComputeRootUnorderedAccessView(This,RootParameterIndex,BufferLocation) ) 
+
+#define ID3D12GraphicsCommandList7_SetGraphicsRootUnorderedAccessView(This,RootParameterIndex,BufferLocation)	\
+    ( (This)->lpVtbl -> SetGraphicsRootUnorderedAccessView(This,RootParameterIndex,BufferLocation) ) 
+
+#define ID3D12GraphicsCommandList7_IASetIndexBuffer(This,pView)	\
+    ( (This)->lpVtbl -> IASetIndexBuffer(This,pView) ) 
+
+#define ID3D12GraphicsCommandList7_IASetVertexBuffers(This,StartSlot,NumViews,pViews)	\
+    ( (This)->lpVtbl -> IASetVertexBuffers(This,StartSlot,NumViews,pViews) ) 
+
+#define ID3D12GraphicsCommandList7_SOSetTargets(This,StartSlot,NumViews,pViews)	\
+    ( (This)->lpVtbl -> SOSetTargets(This,StartSlot,NumViews,pViews) ) 
+
+#define ID3D12GraphicsCommandList7_OMSetRenderTargets(This,NumRenderTargetDescriptors,pRenderTargetDescriptors,RTsSingleHandleToDescriptorRange,pDepthStencilDescriptor)	\
+    ( (This)->lpVtbl -> OMSetRenderTargets(This,NumRenderTargetDescriptors,pRenderTargetDescriptors,RTsSingleHandleToDescriptorRange,pDepthStencilDescriptor) ) 
+
+#define ID3D12GraphicsCommandList7_ClearDepthStencilView(This,DepthStencilView,ClearFlags,Depth,Stencil,NumRects,pRects)	\
+    ( (This)->lpVtbl -> ClearDepthStencilView(This,DepthStencilView,ClearFlags,Depth,Stencil,NumRects,pRects) ) 
+
+#define ID3D12GraphicsCommandList7_ClearRenderTargetView(This,RenderTargetView,ColorRGBA,NumRects,pRects)	\
+    ( (This)->lpVtbl -> ClearRenderTargetView(This,RenderTargetView,ColorRGBA,NumRects,pRects) ) 
+
+#define ID3D12GraphicsCommandList7_ClearUnorderedAccessViewUint(This,ViewGPUHandleInCurrentHeap,ViewCPUHandle,pResource,Values,NumRects,pRects)	\
+    ( (This)->lpVtbl -> ClearUnorderedAccessViewUint(This,ViewGPUHandleInCurrentHeap,ViewCPUHandle,pResource,Values,NumRects,pRects) ) 
+
+#define ID3D12GraphicsCommandList7_ClearUnorderedAccessViewFloat(This,ViewGPUHandleInCurrentHeap,ViewCPUHandle,pResource,Values,NumRects,pRects)	\
+    ( (This)->lpVtbl -> ClearUnorderedAccessViewFloat(This,ViewGPUHandleInCurrentHeap,ViewCPUHandle,pResource,Values,NumRects,pRects) ) 
+
+#define ID3D12GraphicsCommandList7_DiscardResource(This,pResource,pRegion)	\
+    ( (This)->lpVtbl -> DiscardResource(This,pResource,pRegion) ) 
+
+#define ID3D12GraphicsCommandList7_BeginQuery(This,pQueryHeap,Type,Index)	\
+    ( (This)->lpVtbl -> BeginQuery(This,pQueryHeap,Type,Index) ) 
+
+#define ID3D12GraphicsCommandList7_EndQuery(This,pQueryHeap,Type,Index)	\
+    ( (This)->lpVtbl -> EndQuery(This,pQueryHeap,Type,Index) ) 
+
+#define ID3D12GraphicsCommandList7_ResolveQueryData(This,pQueryHeap,Type,StartIndex,NumQueries,pDestinationBuffer,AlignedDestinationBufferOffset)	\
+    ( (This)->lpVtbl -> ResolveQueryData(This,pQueryHeap,Type,StartIndex,NumQueries,pDestinationBuffer,AlignedDestinationBufferOffset) ) 
+
+#define ID3D12GraphicsCommandList7_SetPredication(This,pBuffer,AlignedBufferOffset,Operation)	\
+    ( (This)->lpVtbl -> SetPredication(This,pBuffer,AlignedBufferOffset,Operation) ) 
+
+#define ID3D12GraphicsCommandList7_SetMarker(This,Metadata,pData,Size)	\
+    ( (This)->lpVtbl -> SetMarker(This,Metadata,pData,Size) ) 
+
+#define ID3D12GraphicsCommandList7_BeginEvent(This,Metadata,pData,Size)	\
+    ( (This)->lpVtbl -> BeginEvent(This,Metadata,pData,Size) ) 
+
+#define ID3D12GraphicsCommandList7_EndEvent(This)	\
+    ( (This)->lpVtbl -> EndEvent(This) ) 
+
+#define ID3D12GraphicsCommandList7_ExecuteIndirect(This,pCommandSignature,MaxCommandCount,pArgumentBuffer,ArgumentBufferOffset,pCountBuffer,CountBufferOffset)	\
+    ( (This)->lpVtbl -> ExecuteIndirect(This,pCommandSignature,MaxCommandCount,pArgumentBuffer,ArgumentBufferOffset,pCountBuffer,CountBufferOffset) ) 
+
+
+#define ID3D12GraphicsCommandList7_AtomicCopyBufferUINT(This,pDstBuffer,DstOffset,pSrcBuffer,SrcOffset,Dependencies,ppDependentResources,pDependentSubresourceRanges)	\
+    ( (This)->lpVtbl -> AtomicCopyBufferUINT(This,pDstBuffer,DstOffset,pSrcBuffer,SrcOffset,Dependencies,ppDependentResources,pDependentSubresourceRanges) ) 
+
+#define ID3D12GraphicsCommandList7_AtomicCopyBufferUINT64(This,pDstBuffer,DstOffset,pSrcBuffer,SrcOffset,Dependencies,ppDependentResources,pDependentSubresourceRanges)	\
+    ( (This)->lpVtbl -> AtomicCopyBufferUINT64(This,pDstBuffer,DstOffset,pSrcBuffer,SrcOffset,Dependencies,ppDependentResources,pDependentSubresourceRanges) ) 
+
+#define ID3D12GraphicsCommandList7_OMSetDepthBounds(This,Min,Max)	\
+    ( (This)->lpVtbl -> OMSetDepthBounds(This,Min,Max) ) 
+
+#define ID3D12GraphicsCommandList7_SetSamplePositions(This,NumSamplesPerPixel,NumPixels,pSamplePositions)	\
+    ( (This)->lpVtbl -> SetSamplePositions(This,NumSamplesPerPixel,NumPixels,pSamplePositions) ) 
+
+#define ID3D12GraphicsCommandList7_ResolveSubresourceRegion(This,pDstResource,DstSubresource,DstX,DstY,pSrcResource,SrcSubresource,pSrcRect,Format,ResolveMode)	\
+    ( (This)->lpVtbl -> ResolveSubresourceRegion(This,pDstResource,DstSubresource,DstX,DstY,pSrcResource,SrcSubresource,pSrcRect,Format,ResolveMode) ) 
+
+#define ID3D12GraphicsCommandList7_SetViewInstanceMask(This,Mask)	\
+    ( (This)->lpVtbl -> SetViewInstanceMask(This,Mask) ) 
+
+
+#define ID3D12GraphicsCommandList7_WriteBufferImmediate(This,Count,pParams,pModes)	\
+    ( (This)->lpVtbl -> WriteBufferImmediate(This,Count,pParams,pModes) ) 
+
+
+#define ID3D12GraphicsCommandList7_SetProtectedResourceSession(This,pProtectedResourceSession)	\
+    ( (This)->lpVtbl -> SetProtectedResourceSession(This,pProtectedResourceSession) ) 
+
+
+#define ID3D12GraphicsCommandList7_BeginRenderPass(This,NumRenderTargets,pRenderTargets,pDepthStencil,Flags)	\
+    ( (This)->lpVtbl -> BeginRenderPass(This,NumRenderTargets,pRenderTargets,pDepthStencil,Flags) ) 
+
+#define ID3D12GraphicsCommandList7_EndRenderPass(This)	\
+    ( (This)->lpVtbl -> EndRenderPass(This) ) 
+
+#define ID3D12GraphicsCommandList7_InitializeMetaCommand(This,pMetaCommand,pInitializationParametersData,InitializationParametersDataSizeInBytes)	\
+    ( (This)->lpVtbl -> InitializeMetaCommand(This,pMetaCommand,pInitializationParametersData,InitializationParametersDataSizeInBytes) ) 
+
+#define ID3D12GraphicsCommandList7_ExecuteMetaCommand(This,pMetaCommand,pExecutionParametersData,ExecutionParametersDataSizeInBytes)	\
+    ( (This)->lpVtbl -> ExecuteMetaCommand(This,pMetaCommand,pExecutionParametersData,ExecutionParametersDataSizeInBytes) ) 
+
+#define ID3D12GraphicsCommandList7_BuildRaytracingAccelerationStructure(This,pDesc,NumPostbuildInfoDescs,pPostbuildInfoDescs)	\
+    ( (This)->lpVtbl -> BuildRaytracingAccelerationStructure(This,pDesc,NumPostbuildInfoDescs,pPostbuildInfoDescs) ) 
+
+#define ID3D12GraphicsCommandList7_EmitRaytracingAccelerationStructurePostbuildInfo(This,pDesc,NumSourceAccelerationStructures,pSourceAccelerationStructureData)	\
+    ( (This)->lpVtbl -> EmitRaytracingAccelerationStructurePostbuildInfo(This,pDesc,NumSourceAccelerationStructures,pSourceAccelerationStructureData) ) 
+
+#define ID3D12GraphicsCommandList7_CopyRaytracingAccelerationStructure(This,DestAccelerationStructureData,SourceAccelerationStructureData,Mode)	\
+    ( (This)->lpVtbl -> CopyRaytracingAccelerationStructure(This,DestAccelerationStructureData,SourceAccelerationStructureData,Mode) ) 
+
+#define ID3D12GraphicsCommandList7_SetPipelineState1(This,pStateObject)	\
+    ( (This)->lpVtbl -> SetPipelineState1(This,pStateObject) ) 
+
+#define ID3D12GraphicsCommandList7_DispatchRays(This,pDesc)	\
+    ( (This)->lpVtbl -> DispatchRays(This,pDesc) ) 
+
+
+#define ID3D12GraphicsCommandList7_RSSetShadingRate(This,baseShadingRate,combiners)	\
+    ( (This)->lpVtbl -> RSSetShadingRate(This,baseShadingRate,combiners) ) 
+
+#define ID3D12GraphicsCommandList7_RSSetShadingRateImage(This,shadingRateImage)	\
+    ( (This)->lpVtbl -> RSSetShadingRateImage(This,shadingRateImage) ) 
+
+
+#define ID3D12GraphicsCommandList7_DispatchMesh(This,ThreadGroupCountX,ThreadGroupCountY,ThreadGroupCountZ)	\
+    ( (This)->lpVtbl -> DispatchMesh(This,ThreadGroupCountX,ThreadGroupCountY,ThreadGroupCountZ) ) 
+
+
+#define ID3D12GraphicsCommandList7_Barrier(This,NumBarrierGroups,pBarrierGroups)	\
+    ( (This)->lpVtbl -> Barrier(This,NumBarrierGroups,pBarrierGroups) ) 
+
+#endif /* COBJMACROS */
+
+
+#endif 	/* C style interface */
+
+
+
+
+#endif 	/* __ID3D12GraphicsCommandList7_INTERFACE_DEFINED__ */
+
+
+#ifndef __ID3D12GraphicsCommandList8_INTERFACE_DEFINED__
+#define __ID3D12GraphicsCommandList8_INTERFACE_DEFINED__
+
+/* interface ID3D12GraphicsCommandList8 */
+/* [unique][local][object][uuid] */ 
+
+
+EXTERN_C const IID IID_ID3D12GraphicsCommandList8;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("ee936ef9-599d-4d28-938e-23c4ad05ce51")
+    ID3D12GraphicsCommandList8 : public ID3D12GraphicsCommandList7
+    {
+    public:
+        virtual void STDMETHODCALLTYPE OMSetFrontAndBackStencilRef( 
+            _In_  UINT FrontStencilRef,
+            _In_  UINT BackStencilRef) = 0;
+        
+    };
+    
+    
+#else 	/* C style interface */
+
+    typedef struct ID3D12GraphicsCommandList8Vtbl
+    {
+        BEGIN_INTERFACE
+        
+        DECLSPEC_XFGVIRT(IUnknown, QueryInterface)
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            ID3D12GraphicsCommandList8 * This,
+            REFIID riid,
+            _COM_Outptr_  void **ppvObject);
+        
+        DECLSPEC_XFGVIRT(IUnknown, AddRef)
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            ID3D12GraphicsCommandList8 * This);
+        
+        DECLSPEC_XFGVIRT(IUnknown, Release)
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            ID3D12GraphicsCommandList8 * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, GetPrivateData)
+        HRESULT ( STDMETHODCALLTYPE *GetPrivateData )( 
+            ID3D12GraphicsCommandList8 * This,
+            _In_  REFGUID guid,
+            _Inout_  UINT *pDataSize,
+            _Out_writes_bytes_opt_( *pDataSize )  void *pData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, SetPrivateData)
+        HRESULT ( STDMETHODCALLTYPE *SetPrivateData )( 
+            ID3D12GraphicsCommandList8 * This,
+            _In_  REFGUID guid,
+            _In_  UINT DataSize,
+            _In_reads_bytes_opt_( DataSize )  const void *pData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, SetPrivateDataInterface)
+        HRESULT ( STDMETHODCALLTYPE *SetPrivateDataInterface )( 
+            ID3D12GraphicsCommandList8 * This,
+            _In_  REFGUID guid,
+            _In_opt_  const IUnknown *pData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, SetName)
+        HRESULT ( STDMETHODCALLTYPE *SetName )( 
+            ID3D12GraphicsCommandList8 * This,
+            _In_z_  LPCWSTR Name);
+        
+        DECLSPEC_XFGVIRT(ID3D12DeviceChild, GetDevice)
+        HRESULT ( STDMETHODCALLTYPE *GetDevice )( 
+            ID3D12GraphicsCommandList8 * This,
+            REFIID riid,
+            _COM_Outptr_opt_  void **ppvDevice);
+        
+        DECLSPEC_XFGVIRT(ID3D12CommandList, GetType)
+        D3D12_COMMAND_LIST_TYPE ( STDMETHODCALLTYPE *GetType )( 
+            ID3D12GraphicsCommandList8 * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, Close)
+        HRESULT ( STDMETHODCALLTYPE *Close )( 
+            ID3D12GraphicsCommandList8 * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, Reset)
+        HRESULT ( STDMETHODCALLTYPE *Reset )( 
+            ID3D12GraphicsCommandList8 * This,
+            _In_  ID3D12CommandAllocator *pAllocator,
+            _In_opt_  ID3D12PipelineState *pInitialState);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, ClearState)
+        void ( STDMETHODCALLTYPE *ClearState )( 
+            ID3D12GraphicsCommandList8 * This,
+            _In_opt_  ID3D12PipelineState *pPipelineState);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, DrawInstanced)
+        void ( STDMETHODCALLTYPE *DrawInstanced )( 
+            ID3D12GraphicsCommandList8 * This,
+            _In_  UINT VertexCountPerInstance,
+            _In_  UINT InstanceCount,
+            _In_  UINT StartVertexLocation,
+            _In_  UINT StartInstanceLocation);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, DrawIndexedInstanced)
+        void ( STDMETHODCALLTYPE *DrawIndexedInstanced )( 
+            ID3D12GraphicsCommandList8 * This,
+            _In_  UINT IndexCountPerInstance,
+            _In_  UINT InstanceCount,
+            _In_  UINT StartIndexLocation,
+            _In_  INT BaseVertexLocation,
+            _In_  UINT StartInstanceLocation);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, Dispatch)
+        void ( STDMETHODCALLTYPE *Dispatch )( 
+            ID3D12GraphicsCommandList8 * This,
+            _In_  UINT ThreadGroupCountX,
+            _In_  UINT ThreadGroupCountY,
+            _In_  UINT ThreadGroupCountZ);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, CopyBufferRegion)
+        void ( STDMETHODCALLTYPE *CopyBufferRegion )( 
+            ID3D12GraphicsCommandList8 * This,
+            _In_  ID3D12Resource *pDstBuffer,
+            UINT64 DstOffset,
+            _In_  ID3D12Resource *pSrcBuffer,
+            UINT64 SrcOffset,
+            UINT64 NumBytes);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, CopyTextureRegion)
+        void ( STDMETHODCALLTYPE *CopyTextureRegion )( 
+            ID3D12GraphicsCommandList8 * This,
+            _In_  const D3D12_TEXTURE_COPY_LOCATION *pDst,
+            UINT DstX,
+            UINT DstY,
+            UINT DstZ,
+            _In_  const D3D12_TEXTURE_COPY_LOCATION *pSrc,
+            _In_opt_  const D3D12_BOX *pSrcBox);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, CopyResource)
+        void ( STDMETHODCALLTYPE *CopyResource )( 
+            ID3D12GraphicsCommandList8 * This,
+            _In_  ID3D12Resource *pDstResource,
+            _In_  ID3D12Resource *pSrcResource);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, CopyTiles)
+        void ( STDMETHODCALLTYPE *CopyTiles )( 
+            ID3D12GraphicsCommandList8 * This,
+            _In_  ID3D12Resource *pTiledResource,
+            _In_  const D3D12_TILED_RESOURCE_COORDINATE *pTileRegionStartCoordinate,
+            _In_  const D3D12_TILE_REGION_SIZE *pTileRegionSize,
+            _In_  ID3D12Resource *pBuffer,
+            UINT64 BufferStartOffsetInBytes,
+            D3D12_TILE_COPY_FLAGS Flags);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, ResolveSubresource)
+        void ( STDMETHODCALLTYPE *ResolveSubresource )( 
+            ID3D12GraphicsCommandList8 * This,
+            _In_  ID3D12Resource *pDstResource,
+            _In_  UINT DstSubresource,
+            _In_  ID3D12Resource *pSrcResource,
+            _In_  UINT SrcSubresource,
+            _In_  DXGI_FORMAT Format);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, IASetPrimitiveTopology)
+        void ( STDMETHODCALLTYPE *IASetPrimitiveTopology )( 
+            ID3D12GraphicsCommandList8 * This,
+            _In_  D3D12_PRIMITIVE_TOPOLOGY PrimitiveTopology);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, RSSetViewports)
+        void ( STDMETHODCALLTYPE *RSSetViewports )( 
+            ID3D12GraphicsCommandList8 * This,
+            _In_range_(0, D3D12_VIEWPORT_AND_SCISSORRECT_OBJECT_COUNT_PER_PIPELINE)  UINT NumViewports,
+            _In_reads_( NumViewports)  const D3D12_VIEWPORT *pViewports);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, RSSetScissorRects)
+        void ( STDMETHODCALLTYPE *RSSetScissorRects )( 
+            ID3D12GraphicsCommandList8 * This,
+            _In_range_(0, D3D12_VIEWPORT_AND_SCISSORRECT_OBJECT_COUNT_PER_PIPELINE)  UINT NumRects,
+            _In_reads_( NumRects)  const D3D12_RECT *pRects);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, OMSetBlendFactor)
+        void ( STDMETHODCALLTYPE *OMSetBlendFactor )( 
+            ID3D12GraphicsCommandList8 * This,
+            _In_reads_opt_(4)  const FLOAT BlendFactor[ 4 ]);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, OMSetStencilRef)
+        void ( STDMETHODCALLTYPE *OMSetStencilRef )( 
+            ID3D12GraphicsCommandList8 * This,
+            _In_  UINT StencilRef);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetPipelineState)
+        void ( STDMETHODCALLTYPE *SetPipelineState )( 
+            ID3D12GraphicsCommandList8 * This,
+            _In_  ID3D12PipelineState *pPipelineState);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, ResourceBarrier)
+        void ( STDMETHODCALLTYPE *ResourceBarrier )( 
+            ID3D12GraphicsCommandList8 * This,
+            _In_  UINT NumBarriers,
+            _In_reads_(NumBarriers)  const D3D12_RESOURCE_BARRIER *pBarriers);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, ExecuteBundle)
+        void ( STDMETHODCALLTYPE *ExecuteBundle )( 
+            ID3D12GraphicsCommandList8 * This,
+            _In_  ID3D12GraphicsCommandList *pCommandList);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetDescriptorHeaps)
+        void ( STDMETHODCALLTYPE *SetDescriptorHeaps )( 
+            ID3D12GraphicsCommandList8 * This,
+            _In_  UINT NumDescriptorHeaps,
+            _In_reads_(NumDescriptorHeaps)  ID3D12DescriptorHeap *const *ppDescriptorHeaps);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetComputeRootSignature)
+        void ( STDMETHODCALLTYPE *SetComputeRootSignature )( 
+            ID3D12GraphicsCommandList8 * This,
+            _In_opt_  ID3D12RootSignature *pRootSignature);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetGraphicsRootSignature)
+        void ( STDMETHODCALLTYPE *SetGraphicsRootSignature )( 
+            ID3D12GraphicsCommandList8 * This,
+            _In_opt_  ID3D12RootSignature *pRootSignature);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetComputeRootDescriptorTable)
+        void ( STDMETHODCALLTYPE *SetComputeRootDescriptorTable )( 
+            ID3D12GraphicsCommandList8 * This,
+            _In_  UINT RootParameterIndex,
+            _In_  D3D12_GPU_DESCRIPTOR_HANDLE BaseDescriptor);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetGraphicsRootDescriptorTable)
+        void ( STDMETHODCALLTYPE *SetGraphicsRootDescriptorTable )( 
+            ID3D12GraphicsCommandList8 * This,
+            _In_  UINT RootParameterIndex,
+            _In_  D3D12_GPU_DESCRIPTOR_HANDLE BaseDescriptor);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetComputeRoot32BitConstant)
+        void ( STDMETHODCALLTYPE *SetComputeRoot32BitConstant )( 
+            ID3D12GraphicsCommandList8 * This,
+            _In_  UINT RootParameterIndex,
+            _In_  UINT SrcData,
+            _In_  UINT DestOffsetIn32BitValues);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetGraphicsRoot32BitConstant)
+        void ( STDMETHODCALLTYPE *SetGraphicsRoot32BitConstant )( 
+            ID3D12GraphicsCommandList8 * This,
+            _In_  UINT RootParameterIndex,
+            _In_  UINT SrcData,
+            _In_  UINT DestOffsetIn32BitValues);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetComputeRoot32BitConstants)
+        void ( STDMETHODCALLTYPE *SetComputeRoot32BitConstants )( 
+            ID3D12GraphicsCommandList8 * This,
+            _In_  UINT RootParameterIndex,
+            _In_  UINT Num32BitValuesToSet,
+            _In_reads_(Num32BitValuesToSet*sizeof(UINT))  const void *pSrcData,
+            _In_  UINT DestOffsetIn32BitValues);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetGraphicsRoot32BitConstants)
+        void ( STDMETHODCALLTYPE *SetGraphicsRoot32BitConstants )( 
+            ID3D12GraphicsCommandList8 * This,
+            _In_  UINT RootParameterIndex,
+            _In_  UINT Num32BitValuesToSet,
+            _In_reads_(Num32BitValuesToSet*sizeof(UINT))  const void *pSrcData,
+            _In_  UINT DestOffsetIn32BitValues);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetComputeRootConstantBufferView)
+        void ( STDMETHODCALLTYPE *SetComputeRootConstantBufferView )( 
+            ID3D12GraphicsCommandList8 * This,
+            _In_  UINT RootParameterIndex,
+            _In_  D3D12_GPU_VIRTUAL_ADDRESS BufferLocation);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetGraphicsRootConstantBufferView)
+        void ( STDMETHODCALLTYPE *SetGraphicsRootConstantBufferView )( 
+            ID3D12GraphicsCommandList8 * This,
+            _In_  UINT RootParameterIndex,
+            _In_  D3D12_GPU_VIRTUAL_ADDRESS BufferLocation);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetComputeRootShaderResourceView)
+        void ( STDMETHODCALLTYPE *SetComputeRootShaderResourceView )( 
+            ID3D12GraphicsCommandList8 * This,
+            _In_  UINT RootParameterIndex,
+            _In_  D3D12_GPU_VIRTUAL_ADDRESS BufferLocation);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetGraphicsRootShaderResourceView)
+        void ( STDMETHODCALLTYPE *SetGraphicsRootShaderResourceView )( 
+            ID3D12GraphicsCommandList8 * This,
+            _In_  UINT RootParameterIndex,
+            _In_  D3D12_GPU_VIRTUAL_ADDRESS BufferLocation);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetComputeRootUnorderedAccessView)
+        void ( STDMETHODCALLTYPE *SetComputeRootUnorderedAccessView )( 
+            ID3D12GraphicsCommandList8 * This,
+            _In_  UINT RootParameterIndex,
+            _In_  D3D12_GPU_VIRTUAL_ADDRESS BufferLocation);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetGraphicsRootUnorderedAccessView)
+        void ( STDMETHODCALLTYPE *SetGraphicsRootUnorderedAccessView )( 
+            ID3D12GraphicsCommandList8 * This,
+            _In_  UINT RootParameterIndex,
+            _In_  D3D12_GPU_VIRTUAL_ADDRESS BufferLocation);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, IASetIndexBuffer)
+        void ( STDMETHODCALLTYPE *IASetIndexBuffer )( 
+            ID3D12GraphicsCommandList8 * This,
+            _In_opt_  const D3D12_INDEX_BUFFER_VIEW *pView);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, IASetVertexBuffers)
+        void ( STDMETHODCALLTYPE *IASetVertexBuffers )( 
+            ID3D12GraphicsCommandList8 * This,
+            _In_  UINT StartSlot,
+            _In_  UINT NumViews,
+            _In_reads_opt_(NumViews)  const D3D12_VERTEX_BUFFER_VIEW *pViews);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SOSetTargets)
+        void ( STDMETHODCALLTYPE *SOSetTargets )( 
+            ID3D12GraphicsCommandList8 * This,
+            _In_  UINT StartSlot,
+            _In_  UINT NumViews,
+            _In_reads_opt_(NumViews)  const D3D12_STREAM_OUTPUT_BUFFER_VIEW *pViews);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, OMSetRenderTargets)
+        void ( STDMETHODCALLTYPE *OMSetRenderTargets )( 
+            ID3D12GraphicsCommandList8 * This,
+            _In_  UINT NumRenderTargetDescriptors,
+            _In_opt_  const D3D12_CPU_DESCRIPTOR_HANDLE *pRenderTargetDescriptors,
+            _In_  BOOL RTsSingleHandleToDescriptorRange,
+            _In_opt_  const D3D12_CPU_DESCRIPTOR_HANDLE *pDepthStencilDescriptor);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, ClearDepthStencilView)
+        void ( STDMETHODCALLTYPE *ClearDepthStencilView )( 
+            ID3D12GraphicsCommandList8 * This,
+            _In_  D3D12_CPU_DESCRIPTOR_HANDLE DepthStencilView,
+            _In_  D3D12_CLEAR_FLAGS ClearFlags,
+            _In_  FLOAT Depth,
+            _In_  UINT8 Stencil,
+            _In_  UINT NumRects,
+            _In_reads_(NumRects)  const D3D12_RECT *pRects);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, ClearRenderTargetView)
+        void ( STDMETHODCALLTYPE *ClearRenderTargetView )( 
+            ID3D12GraphicsCommandList8 * This,
+            _In_  D3D12_CPU_DESCRIPTOR_HANDLE RenderTargetView,
+            _In_  const FLOAT ColorRGBA[ 4 ],
+            _In_  UINT NumRects,
+            _In_reads_(NumRects)  const D3D12_RECT *pRects);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, ClearUnorderedAccessViewUint)
+        void ( STDMETHODCALLTYPE *ClearUnorderedAccessViewUint )( 
+            ID3D12GraphicsCommandList8 * This,
+            _In_  D3D12_GPU_DESCRIPTOR_HANDLE ViewGPUHandleInCurrentHeap,
+            _In_  D3D12_CPU_DESCRIPTOR_HANDLE ViewCPUHandle,
+            _In_  ID3D12Resource *pResource,
+            _In_  const UINT Values[ 4 ],
+            _In_  UINT NumRects,
+            _In_reads_(NumRects)  const D3D12_RECT *pRects);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, ClearUnorderedAccessViewFloat)
+        void ( STDMETHODCALLTYPE *ClearUnorderedAccessViewFloat )( 
+            ID3D12GraphicsCommandList8 * This,
+            _In_  D3D12_GPU_DESCRIPTOR_HANDLE ViewGPUHandleInCurrentHeap,
+            _In_  D3D12_CPU_DESCRIPTOR_HANDLE ViewCPUHandle,
+            _In_  ID3D12Resource *pResource,
+            _In_  const FLOAT Values[ 4 ],
+            _In_  UINT NumRects,
+            _In_reads_(NumRects)  const D3D12_RECT *pRects);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, DiscardResource)
+        void ( STDMETHODCALLTYPE *DiscardResource )( 
+            ID3D12GraphicsCommandList8 * This,
+            _In_  ID3D12Resource *pResource,
+            _In_opt_  const D3D12_DISCARD_REGION *pRegion);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, BeginQuery)
+        void ( STDMETHODCALLTYPE *BeginQuery )( 
+            ID3D12GraphicsCommandList8 * This,
+            _In_  ID3D12QueryHeap *pQueryHeap,
+            _In_  D3D12_QUERY_TYPE Type,
+            _In_  UINT Index);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, EndQuery)
+        void ( STDMETHODCALLTYPE *EndQuery )( 
+            ID3D12GraphicsCommandList8 * This,
+            _In_  ID3D12QueryHeap *pQueryHeap,
+            _In_  D3D12_QUERY_TYPE Type,
+            _In_  UINT Index);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, ResolveQueryData)
+        void ( STDMETHODCALLTYPE *ResolveQueryData )( 
+            ID3D12GraphicsCommandList8 * This,
+            _In_  ID3D12QueryHeap *pQueryHeap,
+            _In_  D3D12_QUERY_TYPE Type,
+            _In_  UINT StartIndex,
+            _In_  UINT NumQueries,
+            _In_  ID3D12Resource *pDestinationBuffer,
+            _In_  UINT64 AlignedDestinationBufferOffset);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetPredication)
+        void ( STDMETHODCALLTYPE *SetPredication )( 
+            ID3D12GraphicsCommandList8 * This,
+            _In_opt_  ID3D12Resource *pBuffer,
+            _In_  UINT64 AlignedBufferOffset,
+            _In_  D3D12_PREDICATION_OP Operation);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetMarker)
+        void ( STDMETHODCALLTYPE *SetMarker )( 
+            ID3D12GraphicsCommandList8 * This,
+            UINT Metadata,
+            _In_reads_bytes_opt_(Size)  const void *pData,
+            UINT Size);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, BeginEvent)
+        void ( STDMETHODCALLTYPE *BeginEvent )( 
+            ID3D12GraphicsCommandList8 * This,
+            UINT Metadata,
+            _In_reads_bytes_opt_(Size)  const void *pData,
+            UINT Size);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, EndEvent)
+        void ( STDMETHODCALLTYPE *EndEvent )( 
+            ID3D12GraphicsCommandList8 * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, ExecuteIndirect)
+        void ( STDMETHODCALLTYPE *ExecuteIndirect )( 
+            ID3D12GraphicsCommandList8 * This,
+            _In_  ID3D12CommandSignature *pCommandSignature,
+            _In_  UINT MaxCommandCount,
+            _In_  ID3D12Resource *pArgumentBuffer,
+            _In_  UINT64 ArgumentBufferOffset,
+            _In_opt_  ID3D12Resource *pCountBuffer,
+            _In_  UINT64 CountBufferOffset);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList1, AtomicCopyBufferUINT)
+        void ( STDMETHODCALLTYPE *AtomicCopyBufferUINT )( 
+            ID3D12GraphicsCommandList8 * This,
+            _In_  ID3D12Resource *pDstBuffer,
+            UINT64 DstOffset,
+            _In_  ID3D12Resource *pSrcBuffer,
+            UINT64 SrcOffset,
+            UINT Dependencies,
+            _In_reads_(Dependencies)  ID3D12Resource *const *ppDependentResources,
+            _In_reads_(Dependencies)  const D3D12_SUBRESOURCE_RANGE_UINT64 *pDependentSubresourceRanges);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList1, AtomicCopyBufferUINT64)
+        void ( STDMETHODCALLTYPE *AtomicCopyBufferUINT64 )( 
+            ID3D12GraphicsCommandList8 * This,
+            _In_  ID3D12Resource *pDstBuffer,
+            UINT64 DstOffset,
+            _In_  ID3D12Resource *pSrcBuffer,
+            UINT64 SrcOffset,
+            UINT Dependencies,
+            _In_reads_(Dependencies)  ID3D12Resource *const *ppDependentResources,
+            _In_reads_(Dependencies)  const D3D12_SUBRESOURCE_RANGE_UINT64 *pDependentSubresourceRanges);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList1, OMSetDepthBounds)
+        void ( STDMETHODCALLTYPE *OMSetDepthBounds )( 
+            ID3D12GraphicsCommandList8 * This,
+            _In_  FLOAT Min,
+            _In_  FLOAT Max);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList1, SetSamplePositions)
+        void ( STDMETHODCALLTYPE *SetSamplePositions )( 
+            ID3D12GraphicsCommandList8 * This,
+            _In_  UINT NumSamplesPerPixel,
+            _In_  UINT NumPixels,
+            _In_reads_(NumSamplesPerPixel*NumPixels)  D3D12_SAMPLE_POSITION *pSamplePositions);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList1, ResolveSubresourceRegion)
+        void ( STDMETHODCALLTYPE *ResolveSubresourceRegion )( 
+            ID3D12GraphicsCommandList8 * This,
+            _In_  ID3D12Resource *pDstResource,
+            _In_  UINT DstSubresource,
+            _In_  UINT DstX,
+            _In_  UINT DstY,
+            _In_  ID3D12Resource *pSrcResource,
+            _In_  UINT SrcSubresource,
+            _In_opt_  D3D12_RECT *pSrcRect,
+            _In_  DXGI_FORMAT Format,
+            _In_  D3D12_RESOLVE_MODE ResolveMode);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList1, SetViewInstanceMask)
+        void ( STDMETHODCALLTYPE *SetViewInstanceMask )( 
+            ID3D12GraphicsCommandList8 * This,
+            _In_  UINT Mask);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList2, WriteBufferImmediate)
+        void ( STDMETHODCALLTYPE *WriteBufferImmediate )( 
+            ID3D12GraphicsCommandList8 * This,
+            UINT Count,
+            _In_reads_(Count)  const D3D12_WRITEBUFFERIMMEDIATE_PARAMETER *pParams,
+            _In_reads_opt_(Count)  const D3D12_WRITEBUFFERIMMEDIATE_MODE *pModes);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList3, SetProtectedResourceSession)
+        void ( STDMETHODCALLTYPE *SetProtectedResourceSession )( 
+            ID3D12GraphicsCommandList8 * This,
+            _In_opt_  ID3D12ProtectedResourceSession *pProtectedResourceSession);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList4, BeginRenderPass)
+        void ( STDMETHODCALLTYPE *BeginRenderPass )( 
+            ID3D12GraphicsCommandList8 * This,
+            _In_  UINT NumRenderTargets,
+            _In_reads_opt_(NumRenderTargets)  const D3D12_RENDER_PASS_RENDER_TARGET_DESC *pRenderTargets,
+            _In_opt_  const D3D12_RENDER_PASS_DEPTH_STENCIL_DESC *pDepthStencil,
+            D3D12_RENDER_PASS_FLAGS Flags);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList4, EndRenderPass)
+        void ( STDMETHODCALLTYPE *EndRenderPass )( 
+            ID3D12GraphicsCommandList8 * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList4, InitializeMetaCommand)
+        void ( STDMETHODCALLTYPE *InitializeMetaCommand )( 
+            ID3D12GraphicsCommandList8 * This,
+            _In_  ID3D12MetaCommand *pMetaCommand,
+            _In_reads_bytes_opt_(InitializationParametersDataSizeInBytes)  const void *pInitializationParametersData,
+            _In_  SIZE_T InitializationParametersDataSizeInBytes);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList4, ExecuteMetaCommand)
+        void ( STDMETHODCALLTYPE *ExecuteMetaCommand )( 
+            ID3D12GraphicsCommandList8 * This,
+            _In_  ID3D12MetaCommand *pMetaCommand,
+            _In_reads_bytes_opt_(ExecutionParametersDataSizeInBytes)  const void *pExecutionParametersData,
+            _In_  SIZE_T ExecutionParametersDataSizeInBytes);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList4, BuildRaytracingAccelerationStructure)
+        void ( STDMETHODCALLTYPE *BuildRaytracingAccelerationStructure )( 
+            ID3D12GraphicsCommandList8 * This,
+            _In_  const D3D12_BUILD_RAYTRACING_ACCELERATION_STRUCTURE_DESC *pDesc,
+            _In_  UINT NumPostbuildInfoDescs,
+            _In_reads_opt_(NumPostbuildInfoDescs)  const D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_DESC *pPostbuildInfoDescs);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList4, EmitRaytracingAccelerationStructurePostbuildInfo)
+        void ( STDMETHODCALLTYPE *EmitRaytracingAccelerationStructurePostbuildInfo )( 
+            ID3D12GraphicsCommandList8 * This,
+            _In_  const D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_DESC *pDesc,
+            _In_  UINT NumSourceAccelerationStructures,
+            _In_reads_( NumSourceAccelerationStructures )  const D3D12_GPU_VIRTUAL_ADDRESS *pSourceAccelerationStructureData);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList4, CopyRaytracingAccelerationStructure)
+        void ( STDMETHODCALLTYPE *CopyRaytracingAccelerationStructure )( 
+            ID3D12GraphicsCommandList8 * This,
+            _In_  D3D12_GPU_VIRTUAL_ADDRESS DestAccelerationStructureData,
+            _In_  D3D12_GPU_VIRTUAL_ADDRESS SourceAccelerationStructureData,
+            _In_  D3D12_RAYTRACING_ACCELERATION_STRUCTURE_COPY_MODE Mode);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList4, SetPipelineState1)
+        void ( STDMETHODCALLTYPE *SetPipelineState1 )( 
+            ID3D12GraphicsCommandList8 * This,
+            _In_  ID3D12StateObject *pStateObject);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList4, DispatchRays)
+        void ( STDMETHODCALLTYPE *DispatchRays )( 
+            ID3D12GraphicsCommandList8 * This,
+            _In_  const D3D12_DISPATCH_RAYS_DESC *pDesc);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList5, RSSetShadingRate)
+        void ( STDMETHODCALLTYPE *RSSetShadingRate )( 
+            ID3D12GraphicsCommandList8 * This,
+            _In_  D3D12_SHADING_RATE baseShadingRate,
+            _In_reads_opt_(D3D12_RS_SET_SHADING_RATE_COMBINER_COUNT)  const D3D12_SHADING_RATE_COMBINER *combiners);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList5, RSSetShadingRateImage)
+        void ( STDMETHODCALLTYPE *RSSetShadingRateImage )( 
+            ID3D12GraphicsCommandList8 * This,
+            _In_opt_  ID3D12Resource *shadingRateImage);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList6, DispatchMesh)
+        void ( STDMETHODCALLTYPE *DispatchMesh )( 
+            ID3D12GraphicsCommandList8 * This,
+            _In_  UINT ThreadGroupCountX,
+            _In_  UINT ThreadGroupCountY,
+            _In_  UINT ThreadGroupCountZ);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList7, Barrier)
+        void ( STDMETHODCALLTYPE *Barrier )( 
+            ID3D12GraphicsCommandList8 * This,
+            UINT32 NumBarrierGroups,
+            _In_reads_(NumBarrierGroups)  const D3D12_BARRIER_GROUP *pBarrierGroups);
+        
+        DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList8, OMSetFrontAndBackStencilRef)
+        void ( STDMETHODCALLTYPE *OMSetFrontAndBackStencilRef )( 
+            ID3D12GraphicsCommandList8 * This,
+            _In_  UINT FrontStencilRef,
+            _In_  UINT BackStencilRef);
+        
+        END_INTERFACE
+    } ID3D12GraphicsCommandList8Vtbl;
+
+    interface ID3D12GraphicsCommandList8
+    {
+        CONST_VTBL struct ID3D12GraphicsCommandList8Vtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define ID3D12GraphicsCommandList8_QueryInterface(This,riid,ppvObject)	\
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define ID3D12GraphicsCommandList8_AddRef(This)	\
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define ID3D12GraphicsCommandList8_Release(This)	\
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#define ID3D12GraphicsCommandList8_GetPrivateData(This,guid,pDataSize,pData)	\
+    ( (This)->lpVtbl -> GetPrivateData(This,guid,pDataSize,pData) ) 
+
+#define ID3D12GraphicsCommandList8_SetPrivateData(This,guid,DataSize,pData)	\
+    ( (This)->lpVtbl -> SetPrivateData(This,guid,DataSize,pData) ) 
+
+#define ID3D12GraphicsCommandList8_SetPrivateDataInterface(This,guid,pData)	\
+    ( (This)->lpVtbl -> SetPrivateDataInterface(This,guid,pData) ) 
+
+#define ID3D12GraphicsCommandList8_SetName(This,Name)	\
+    ( (This)->lpVtbl -> SetName(This,Name) ) 
+
+
+#define ID3D12GraphicsCommandList8_GetDevice(This,riid,ppvDevice)	\
+    ( (This)->lpVtbl -> GetDevice(This,riid,ppvDevice) ) 
+
+
+#define ID3D12GraphicsCommandList8_GetType(This)	\
+    ( (This)->lpVtbl -> GetType(This) ) 
+
+
+#define ID3D12GraphicsCommandList8_Close(This)	\
+    ( (This)->lpVtbl -> Close(This) ) 
+
+#define ID3D12GraphicsCommandList8_Reset(This,pAllocator,pInitialState)	\
+    ( (This)->lpVtbl -> Reset(This,pAllocator,pInitialState) ) 
+
+#define ID3D12GraphicsCommandList8_ClearState(This,pPipelineState)	\
+    ( (This)->lpVtbl -> ClearState(This,pPipelineState) ) 
+
+#define ID3D12GraphicsCommandList8_DrawInstanced(This,VertexCountPerInstance,InstanceCount,StartVertexLocation,StartInstanceLocation)	\
+    ( (This)->lpVtbl -> DrawInstanced(This,VertexCountPerInstance,InstanceCount,StartVertexLocation,StartInstanceLocation) ) 
+
+#define ID3D12GraphicsCommandList8_DrawIndexedInstanced(This,IndexCountPerInstance,InstanceCount,StartIndexLocation,BaseVertexLocation,StartInstanceLocation)	\
+    ( (This)->lpVtbl -> DrawIndexedInstanced(This,IndexCountPerInstance,InstanceCount,StartIndexLocation,BaseVertexLocation,StartInstanceLocation) ) 
+
+#define ID3D12GraphicsCommandList8_Dispatch(This,ThreadGroupCountX,ThreadGroupCountY,ThreadGroupCountZ)	\
+    ( (This)->lpVtbl -> Dispatch(This,ThreadGroupCountX,ThreadGroupCountY,ThreadGroupCountZ) ) 
+
+#define ID3D12GraphicsCommandList8_CopyBufferRegion(This,pDstBuffer,DstOffset,pSrcBuffer,SrcOffset,NumBytes)	\
+    ( (This)->lpVtbl -> CopyBufferRegion(This,pDstBuffer,DstOffset,pSrcBuffer,SrcOffset,NumBytes) ) 
+
+#define ID3D12GraphicsCommandList8_CopyTextureRegion(This,pDst,DstX,DstY,DstZ,pSrc,pSrcBox)	\
+    ( (This)->lpVtbl -> CopyTextureRegion(This,pDst,DstX,DstY,DstZ,pSrc,pSrcBox) ) 
+
+#define ID3D12GraphicsCommandList8_CopyResource(This,pDstResource,pSrcResource)	\
+    ( (This)->lpVtbl -> CopyResource(This,pDstResource,pSrcResource) ) 
+
+#define ID3D12GraphicsCommandList8_CopyTiles(This,pTiledResource,pTileRegionStartCoordinate,pTileRegionSize,pBuffer,BufferStartOffsetInBytes,Flags)	\
+    ( (This)->lpVtbl -> CopyTiles(This,pTiledResource,pTileRegionStartCoordinate,pTileRegionSize,pBuffer,BufferStartOffsetInBytes,Flags) ) 
+
+#define ID3D12GraphicsCommandList8_ResolveSubresource(This,pDstResource,DstSubresource,pSrcResource,SrcSubresource,Format)	\
+    ( (This)->lpVtbl -> ResolveSubresource(This,pDstResource,DstSubresource,pSrcResource,SrcSubresource,Format) ) 
+
+#define ID3D12GraphicsCommandList8_IASetPrimitiveTopology(This,PrimitiveTopology)	\
+    ( (This)->lpVtbl -> IASetPrimitiveTopology(This,PrimitiveTopology) ) 
+
+#define ID3D12GraphicsCommandList8_RSSetViewports(This,NumViewports,pViewports)	\
+    ( (This)->lpVtbl -> RSSetViewports(This,NumViewports,pViewports) ) 
+
+#define ID3D12GraphicsCommandList8_RSSetScissorRects(This,NumRects,pRects)	\
+    ( (This)->lpVtbl -> RSSetScissorRects(This,NumRects,pRects) ) 
+
+#define ID3D12GraphicsCommandList8_OMSetBlendFactor(This,BlendFactor)	\
+    ( (This)->lpVtbl -> OMSetBlendFactor(This,BlendFactor) ) 
+
+#define ID3D12GraphicsCommandList8_OMSetStencilRef(This,StencilRef)	\
+    ( (This)->lpVtbl -> OMSetStencilRef(This,StencilRef) ) 
+
+#define ID3D12GraphicsCommandList8_SetPipelineState(This,pPipelineState)	\
+    ( (This)->lpVtbl -> SetPipelineState(This,pPipelineState) ) 
+
+#define ID3D12GraphicsCommandList8_ResourceBarrier(This,NumBarriers,pBarriers)	\
+    ( (This)->lpVtbl -> ResourceBarrier(This,NumBarriers,pBarriers) ) 
+
+#define ID3D12GraphicsCommandList8_ExecuteBundle(This,pCommandList)	\
+    ( (This)->lpVtbl -> ExecuteBundle(This,pCommandList) ) 
+
+#define ID3D12GraphicsCommandList8_SetDescriptorHeaps(This,NumDescriptorHeaps,ppDescriptorHeaps)	\
+    ( (This)->lpVtbl -> SetDescriptorHeaps(This,NumDescriptorHeaps,ppDescriptorHeaps) ) 
+
+#define ID3D12GraphicsCommandList8_SetComputeRootSignature(This,pRootSignature)	\
+    ( (This)->lpVtbl -> SetComputeRootSignature(This,pRootSignature) ) 
+
+#define ID3D12GraphicsCommandList8_SetGraphicsRootSignature(This,pRootSignature)	\
+    ( (This)->lpVtbl -> SetGraphicsRootSignature(This,pRootSignature) ) 
+
+#define ID3D12GraphicsCommandList8_SetComputeRootDescriptorTable(This,RootParameterIndex,BaseDescriptor)	\
+    ( (This)->lpVtbl -> SetComputeRootDescriptorTable(This,RootParameterIndex,BaseDescriptor) ) 
+
+#define ID3D12GraphicsCommandList8_SetGraphicsRootDescriptorTable(This,RootParameterIndex,BaseDescriptor)	\
+    ( (This)->lpVtbl -> SetGraphicsRootDescriptorTable(This,RootParameterIndex,BaseDescriptor) ) 
+
+#define ID3D12GraphicsCommandList8_SetComputeRoot32BitConstant(This,RootParameterIndex,SrcData,DestOffsetIn32BitValues)	\
+    ( (This)->lpVtbl -> SetComputeRoot32BitConstant(This,RootParameterIndex,SrcData,DestOffsetIn32BitValues) ) 
+
+#define ID3D12GraphicsCommandList8_SetGraphicsRoot32BitConstant(This,RootParameterIndex,SrcData,DestOffsetIn32BitValues)	\
+    ( (This)->lpVtbl -> SetGraphicsRoot32BitConstant(This,RootParameterIndex,SrcData,DestOffsetIn32BitValues) ) 
+
+#define ID3D12GraphicsCommandList8_SetComputeRoot32BitConstants(This,RootParameterIndex,Num32BitValuesToSet,pSrcData,DestOffsetIn32BitValues)	\
+    ( (This)->lpVtbl -> SetComputeRoot32BitConstants(This,RootParameterIndex,Num32BitValuesToSet,pSrcData,DestOffsetIn32BitValues) ) 
+
+#define ID3D12GraphicsCommandList8_SetGraphicsRoot32BitConstants(This,RootParameterIndex,Num32BitValuesToSet,pSrcData,DestOffsetIn32BitValues)	\
+    ( (This)->lpVtbl -> SetGraphicsRoot32BitConstants(This,RootParameterIndex,Num32BitValuesToSet,pSrcData,DestOffsetIn32BitValues) ) 
+
+#define ID3D12GraphicsCommandList8_SetComputeRootConstantBufferView(This,RootParameterIndex,BufferLocation)	\
+    ( (This)->lpVtbl -> SetComputeRootConstantBufferView(This,RootParameterIndex,BufferLocation) ) 
+
+#define ID3D12GraphicsCommandList8_SetGraphicsRootConstantBufferView(This,RootParameterIndex,BufferLocation)	\
+    ( (This)->lpVtbl -> SetGraphicsRootConstantBufferView(This,RootParameterIndex,BufferLocation) ) 
+
+#define ID3D12GraphicsCommandList8_SetComputeRootShaderResourceView(This,RootParameterIndex,BufferLocation)	\
+    ( (This)->lpVtbl -> SetComputeRootShaderResourceView(This,RootParameterIndex,BufferLocation) ) 
+
+#define ID3D12GraphicsCommandList8_SetGraphicsRootShaderResourceView(This,RootParameterIndex,BufferLocation)	\
+    ( (This)->lpVtbl -> SetGraphicsRootShaderResourceView(This,RootParameterIndex,BufferLocation) ) 
+
+#define ID3D12GraphicsCommandList8_SetComputeRootUnorderedAccessView(This,RootParameterIndex,BufferLocation)	\
+    ( (This)->lpVtbl -> SetComputeRootUnorderedAccessView(This,RootParameterIndex,BufferLocation) ) 
+
+#define ID3D12GraphicsCommandList8_SetGraphicsRootUnorderedAccessView(This,RootParameterIndex,BufferLocation)	\
+    ( (This)->lpVtbl -> SetGraphicsRootUnorderedAccessView(This,RootParameterIndex,BufferLocation) ) 
+
+#define ID3D12GraphicsCommandList8_IASetIndexBuffer(This,pView)	\
+    ( (This)->lpVtbl -> IASetIndexBuffer(This,pView) ) 
+
+#define ID3D12GraphicsCommandList8_IASetVertexBuffers(This,StartSlot,NumViews,pViews)	\
+    ( (This)->lpVtbl -> IASetVertexBuffers(This,StartSlot,NumViews,pViews) ) 
+
+#define ID3D12GraphicsCommandList8_SOSetTargets(This,StartSlot,NumViews,pViews)	\
+    ( (This)->lpVtbl -> SOSetTargets(This,StartSlot,NumViews,pViews) ) 
+
+#define ID3D12GraphicsCommandList8_OMSetRenderTargets(This,NumRenderTargetDescriptors,pRenderTargetDescriptors,RTsSingleHandleToDescriptorRange,pDepthStencilDescriptor)	\
+    ( (This)->lpVtbl -> OMSetRenderTargets(This,NumRenderTargetDescriptors,pRenderTargetDescriptors,RTsSingleHandleToDescriptorRange,pDepthStencilDescriptor) ) 
+
+#define ID3D12GraphicsCommandList8_ClearDepthStencilView(This,DepthStencilView,ClearFlags,Depth,Stencil,NumRects,pRects)	\
+    ( (This)->lpVtbl -> ClearDepthStencilView(This,DepthStencilView,ClearFlags,Depth,Stencil,NumRects,pRects) ) 
+
+#define ID3D12GraphicsCommandList8_ClearRenderTargetView(This,RenderTargetView,ColorRGBA,NumRects,pRects)	\
+    ( (This)->lpVtbl -> ClearRenderTargetView(This,RenderTargetView,ColorRGBA,NumRects,pRects) ) 
+
+#define ID3D12GraphicsCommandList8_ClearUnorderedAccessViewUint(This,ViewGPUHandleInCurrentHeap,ViewCPUHandle,pResource,Values,NumRects,pRects)	\
+    ( (This)->lpVtbl -> ClearUnorderedAccessViewUint(This,ViewGPUHandleInCurrentHeap,ViewCPUHandle,pResource,Values,NumRects,pRects) ) 
+
+#define ID3D12GraphicsCommandList8_ClearUnorderedAccessViewFloat(This,ViewGPUHandleInCurrentHeap,ViewCPUHandle,pResource,Values,NumRects,pRects)	\
+    ( (This)->lpVtbl -> ClearUnorderedAccessViewFloat(This,ViewGPUHandleInCurrentHeap,ViewCPUHandle,pResource,Values,NumRects,pRects) ) 
+
+#define ID3D12GraphicsCommandList8_DiscardResource(This,pResource,pRegion)	\
+    ( (This)->lpVtbl -> DiscardResource(This,pResource,pRegion) ) 
+
+#define ID3D12GraphicsCommandList8_BeginQuery(This,pQueryHeap,Type,Index)	\
+    ( (This)->lpVtbl -> BeginQuery(This,pQueryHeap,Type,Index) ) 
+
+#define ID3D12GraphicsCommandList8_EndQuery(This,pQueryHeap,Type,Index)	\
+    ( (This)->lpVtbl -> EndQuery(This,pQueryHeap,Type,Index) ) 
+
+#define ID3D12GraphicsCommandList8_ResolveQueryData(This,pQueryHeap,Type,StartIndex,NumQueries,pDestinationBuffer,AlignedDestinationBufferOffset)	\
+    ( (This)->lpVtbl -> ResolveQueryData(This,pQueryHeap,Type,StartIndex,NumQueries,pDestinationBuffer,AlignedDestinationBufferOffset) ) 
+
+#define ID3D12GraphicsCommandList8_SetPredication(This,pBuffer,AlignedBufferOffset,Operation)	\
+    ( (This)->lpVtbl -> SetPredication(This,pBuffer,AlignedBufferOffset,Operation) ) 
+
+#define ID3D12GraphicsCommandList8_SetMarker(This,Metadata,pData,Size)	\
+    ( (This)->lpVtbl -> SetMarker(This,Metadata,pData,Size) ) 
+
+#define ID3D12GraphicsCommandList8_BeginEvent(This,Metadata,pData,Size)	\
+    ( (This)->lpVtbl -> BeginEvent(This,Metadata,pData,Size) ) 
+
+#define ID3D12GraphicsCommandList8_EndEvent(This)	\
+    ( (This)->lpVtbl -> EndEvent(This) ) 
+
+#define ID3D12GraphicsCommandList8_ExecuteIndirect(This,pCommandSignature,MaxCommandCount,pArgumentBuffer,ArgumentBufferOffset,pCountBuffer,CountBufferOffset)	\
+    ( (This)->lpVtbl -> ExecuteIndirect(This,pCommandSignature,MaxCommandCount,pArgumentBuffer,ArgumentBufferOffset,pCountBuffer,CountBufferOffset) ) 
+
+
+#define ID3D12GraphicsCommandList8_AtomicCopyBufferUINT(This,pDstBuffer,DstOffset,pSrcBuffer,SrcOffset,Dependencies,ppDependentResources,pDependentSubresourceRanges)	\
+    ( (This)->lpVtbl -> AtomicCopyBufferUINT(This,pDstBuffer,DstOffset,pSrcBuffer,SrcOffset,Dependencies,ppDependentResources,pDependentSubresourceRanges) ) 
+
+#define ID3D12GraphicsCommandList8_AtomicCopyBufferUINT64(This,pDstBuffer,DstOffset,pSrcBuffer,SrcOffset,Dependencies,ppDependentResources,pDependentSubresourceRanges)	\
+    ( (This)->lpVtbl -> AtomicCopyBufferUINT64(This,pDstBuffer,DstOffset,pSrcBuffer,SrcOffset,Dependencies,ppDependentResources,pDependentSubresourceRanges) ) 
+
+#define ID3D12GraphicsCommandList8_OMSetDepthBounds(This,Min,Max)	\
+    ( (This)->lpVtbl -> OMSetDepthBounds(This,Min,Max) ) 
+
+#define ID3D12GraphicsCommandList8_SetSamplePositions(This,NumSamplesPerPixel,NumPixels,pSamplePositions)	\
+    ( (This)->lpVtbl -> SetSamplePositions(This,NumSamplesPerPixel,NumPixels,pSamplePositions) ) 
+
+#define ID3D12GraphicsCommandList8_ResolveSubresourceRegion(This,pDstResource,DstSubresource,DstX,DstY,pSrcResource,SrcSubresource,pSrcRect,Format,ResolveMode)	\
+    ( (This)->lpVtbl -> ResolveSubresourceRegion(This,pDstResource,DstSubresource,DstX,DstY,pSrcResource,SrcSubresource,pSrcRect,Format,ResolveMode) ) 
+
+#define ID3D12GraphicsCommandList8_SetViewInstanceMask(This,Mask)	\
+    ( (This)->lpVtbl -> SetViewInstanceMask(This,Mask) ) 
+
+
+#define ID3D12GraphicsCommandList8_WriteBufferImmediate(This,Count,pParams,pModes)	\
+    ( (This)->lpVtbl -> WriteBufferImmediate(This,Count,pParams,pModes) ) 
+
+
+#define ID3D12GraphicsCommandList8_SetProtectedResourceSession(This,pProtectedResourceSession)	\
+    ( (This)->lpVtbl -> SetProtectedResourceSession(This,pProtectedResourceSession) ) 
+
+
+#define ID3D12GraphicsCommandList8_BeginRenderPass(This,NumRenderTargets,pRenderTargets,pDepthStencil,Flags)	\
+    ( (This)->lpVtbl -> BeginRenderPass(This,NumRenderTargets,pRenderTargets,pDepthStencil,Flags) ) 
+
+#define ID3D12GraphicsCommandList8_EndRenderPass(This)	\
+    ( (This)->lpVtbl -> EndRenderPass(This) ) 
+
+#define ID3D12GraphicsCommandList8_InitializeMetaCommand(This,pMetaCommand,pInitializationParametersData,InitializationParametersDataSizeInBytes)	\
+    ( (This)->lpVtbl -> InitializeMetaCommand(This,pMetaCommand,pInitializationParametersData,InitializationParametersDataSizeInBytes) ) 
+
+#define ID3D12GraphicsCommandList8_ExecuteMetaCommand(This,pMetaCommand,pExecutionParametersData,ExecutionParametersDataSizeInBytes)	\
+    ( (This)->lpVtbl -> ExecuteMetaCommand(This,pMetaCommand,pExecutionParametersData,ExecutionParametersDataSizeInBytes) ) 
+
+#define ID3D12GraphicsCommandList8_BuildRaytracingAccelerationStructure(This,pDesc,NumPostbuildInfoDescs,pPostbuildInfoDescs)	\
+    ( (This)->lpVtbl -> BuildRaytracingAccelerationStructure(This,pDesc,NumPostbuildInfoDescs,pPostbuildInfoDescs) ) 
+
+#define ID3D12GraphicsCommandList8_EmitRaytracingAccelerationStructurePostbuildInfo(This,pDesc,NumSourceAccelerationStructures,pSourceAccelerationStructureData)	\
+    ( (This)->lpVtbl -> EmitRaytracingAccelerationStructurePostbuildInfo(This,pDesc,NumSourceAccelerationStructures,pSourceAccelerationStructureData) ) 
+
+#define ID3D12GraphicsCommandList8_CopyRaytracingAccelerationStructure(This,DestAccelerationStructureData,SourceAccelerationStructureData,Mode)	\
+    ( (This)->lpVtbl -> CopyRaytracingAccelerationStructure(This,DestAccelerationStructureData,SourceAccelerationStructureData,Mode) ) 
+
+#define ID3D12GraphicsCommandList8_SetPipelineState1(This,pStateObject)	\
+    ( (This)->lpVtbl -> SetPipelineState1(This,pStateObject) ) 
+
+#define ID3D12GraphicsCommandList8_DispatchRays(This,pDesc)	\
+    ( (This)->lpVtbl -> DispatchRays(This,pDesc) ) 
+
+
+#define ID3D12GraphicsCommandList8_RSSetShadingRate(This,baseShadingRate,combiners)	\
+    ( (This)->lpVtbl -> RSSetShadingRate(This,baseShadingRate,combiners) ) 
+
+#define ID3D12GraphicsCommandList8_RSSetShadingRateImage(This,shadingRateImage)	\
+    ( (This)->lpVtbl -> RSSetShadingRateImage(This,shadingRateImage) ) 
+
+
+#define ID3D12GraphicsCommandList8_DispatchMesh(This,ThreadGroupCountX,ThreadGroupCountY,ThreadGroupCountZ)	\
+    ( (This)->lpVtbl -> DispatchMesh(This,ThreadGroupCountX,ThreadGroupCountY,ThreadGroupCountZ) ) 
+
+
+#define ID3D12GraphicsCommandList8_Barrier(This,NumBarrierGroups,pBarrierGroups)	\
+    ( (This)->lpVtbl -> Barrier(This,NumBarrierGroups,pBarrierGroups) ) 
+
+
+#define ID3D12GraphicsCommandList8_OMSetFrontAndBackStencilRef(This,FrontStencilRef,BackStencilRef)	\
+    ( (This)->lpVtbl -> OMSetFrontAndBackStencilRef(This,FrontStencilRef,BackStencilRef) ) 
+
+#endif /* COBJMACROS */
+
+
+#endif 	/* C style interface */
+
+
+
+
+#endif 	/* __ID3D12GraphicsCommandList8_INTERFACE_DEFINED__ */
+
+
+/* interface __MIDL_itf_d3d12_0000_0065 */
+/* [local] */ 
+
+#endif /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP | WINAPI_PARTITION_GAMES) */
+#pragma endregion
+DEFINE_GUID(IID_ID3D12Object,0xc4fec28f,0x7966,0x4e95,0x9f,0x94,0xf4,0x31,0xcb,0x56,0xc3,0xb8);
+DEFINE_GUID(IID_ID3D12DeviceChild,0x905db94b,0xa00c,0x4140,0x9d,0xf5,0x2b,0x64,0xca,0x9e,0xa3,0x57);
+DEFINE_GUID(IID_ID3D12RootSignature,0xc54a6b66,0x72df,0x4ee8,0x8b,0xe5,0xa9,0x46,0xa1,0x42,0x92,0x14);
+DEFINE_GUID(IID_ID3D12RootSignatureDeserializer,0x34AB647B,0x3CC8,0x46AC,0x84,0x1B,0xC0,0x96,0x56,0x45,0xC0,0x46);
+DEFINE_GUID(IID_ID3D12VersionedRootSignatureDeserializer,0x7F91CE67,0x090C,0x4BB7,0xB7,0x8E,0xED,0x8F,0xF2,0xE3,0x1D,0xA0);
+DEFINE_GUID(IID_ID3D12Pageable,0x63ee58fb,0x1268,0x4835,0x86,0xda,0xf0,0x08,0xce,0x62,0xf0,0xd6);
+DEFINE_GUID(IID_ID3D12Heap,0x6b3b2502,0x6e51,0x45b3,0x90,0xee,0x98,0x84,0x26,0x5e,0x8d,0xf3);
+DEFINE_GUID(IID_ID3D12Resource,0x696442be,0xa72e,0x4059,0xbc,0x79,0x5b,0x5c,0x98,0x04,0x0f,0xad);
+DEFINE_GUID(IID_ID3D12CommandAllocator,0x6102dee4,0xaf59,0x4b09,0xb9,0x99,0xb4,0x4d,0x73,0xf0,0x9b,0x24);
+DEFINE_GUID(IID_ID3D12Fence,0x0a753dcf,0xc4d8,0x4b91,0xad,0xf6,0xbe,0x5a,0x60,0xd9,0x5a,0x76);
+DEFINE_GUID(IID_ID3D12Fence1,0x433685fe,0xe22b,0x4ca0,0xa8,0xdb,0xb5,0xb4,0xf4,0xdd,0x0e,0x4a);
+DEFINE_GUID(IID_ID3D12PipelineState,0x765a30f3,0xf624,0x4c6f,0xa8,0x28,0xac,0xe9,0x48,0x62,0x24,0x45);
+DEFINE_GUID(IID_ID3D12DescriptorHeap,0x8efb471d,0x616c,0x4f49,0x90,0xf7,0x12,0x7b,0xb7,0x63,0xfa,0x51);
+DEFINE_GUID(IID_ID3D12QueryHeap,0x0d9658ae,0xed45,0x469e,0xa6,0x1d,0x97,0x0e,0xc5,0x83,0xca,0xb4);
+DEFINE_GUID(IID_ID3D12CommandSignature,0xc36a797c,0xec80,0x4f0a,0x89,0x85,0xa7,0xb2,0x47,0x50,0x82,0xd1);
+DEFINE_GUID(IID_ID3D12CommandList,0x7116d91c,0xe7e4,0x47ce,0xb8,0xc6,0xec,0x81,0x68,0xf4,0x37,0xe5);
+DEFINE_GUID(IID_ID3D12GraphicsCommandList,0x5b160d0f,0xac1b,0x4185,0x8b,0xa8,0xb3,0xae,0x42,0xa5,0xa4,0x55);
+DEFINE_GUID(IID_ID3D12GraphicsCommandList1,0x553103fb,0x1fe7,0x4557,0xbb,0x38,0x94,0x6d,0x7d,0x0e,0x7c,0xa7);
+DEFINE_GUID(IID_ID3D12GraphicsCommandList2,0x38C3E585,0xFF17,0x412C,0x91,0x50,0x4F,0xC6,0xF9,0xD7,0x2A,0x28);
+DEFINE_GUID(IID_ID3D12CommandQueue,0x0ec870a6,0x5d7e,0x4c22,0x8c,0xfc,0x5b,0xaa,0xe0,0x76,0x16,0xed);
+DEFINE_GUID(IID_ID3D12Device,0x189819f1,0x1db6,0x4b57,0xbe,0x54,0x18,0x21,0x33,0x9b,0x85,0xf7);
+DEFINE_GUID(IID_ID3D12PipelineLibrary,0xc64226a8,0x9201,0x46af,0xb4,0xcc,0x53,0xfb,0x9f,0xf7,0x41,0x4f);
+DEFINE_GUID(IID_ID3D12PipelineLibrary1,0x80eabf42,0x2568,0x4e5e,0xbd,0x82,0xc3,0x7f,0x86,0x96,0x1d,0xc3);
+DEFINE_GUID(IID_ID3D12Device1,0x77acce80,0x638e,0x4e65,0x88,0x95,0xc1,0xf2,0x33,0x86,0x86,0x3e);
+DEFINE_GUID(IID_ID3D12Device2,0x30baa41e,0xb15b,0x475c,0xa0,0xbb,0x1a,0xf5,0xc5,0xb6,0x43,0x28);
+DEFINE_GUID(IID_ID3D12Device3,0x81dadc15,0x2bad,0x4392,0x93,0xc5,0x10,0x13,0x45,0xc4,0xaa,0x98);
+DEFINE_GUID(IID_ID3D12ProtectedSession,0xA1533D18,0x0AC1,0x4084,0x85,0xB9,0x89,0xA9,0x61,0x16,0x80,0x6B);
+DEFINE_GUID(IID_ID3D12ProtectedResourceSession,0x6CD696F4,0xF289,0x40CC,0x80,0x91,0x5A,0x6C,0x0A,0x09,0x9C,0x3D);
+DEFINE_GUID(IID_ID3D12Device4,0xe865df17,0xa9ee,0x46f9,0xa4,0x63,0x30,0x98,0x31,0x5a,0xa2,0xe5);
+DEFINE_GUID(IID_ID3D12LifetimeOwner,0xe667af9f,0xcd56,0x4f46,0x83,0xce,0x03,0x2e,0x59,0x5d,0x70,0xa8);
+DEFINE_GUID(IID_ID3D12SwapChainAssistant,0xf1df64b6,0x57fd,0x49cd,0x88,0x07,0xc0,0xeb,0x88,0xb4,0x5c,0x8f);
+DEFINE_GUID(IID_ID3D12LifetimeTracker,0x3fd03d36,0x4eb1,0x424a,0xa5,0x82,0x49,0x4e,0xcb,0x8b,0xa8,0x13);
+DEFINE_GUID(IID_ID3D12StateObject,0x47016943,0xfca8,0x4594,0x93,0xea,0xaf,0x25,0x8b,0x55,0x34,0x6d);
+DEFINE_GUID(IID_ID3D12StateObjectProperties,0xde5fa827,0x9bf9,0x4f26,0x89,0xff,0xd7,0xf5,0x6f,0xde,0x38,0x60);
+DEFINE_GUID(IID_ID3D12Device5,0x8b4f173b,0x2fea,0x4b80,0x8f,0x58,0x43,0x07,0x19,0x1a,0xb9,0x5d);
+DEFINE_GUID(IID_ID3D12DeviceRemovedExtendedDataSettings,0x82BC481C,0x6B9B,0x4030,0xAE,0xDB,0x7E,0xE3,0xD1,0xDF,0x1E,0x63);
+DEFINE_GUID(IID_ID3D12DeviceRemovedExtendedDataSettings1,0xDBD5AE51,0x3317,0x4F0A,0xAD,0xF9,0x1D,0x7C,0xED,0xCA,0xAE,0x0B);
+DEFINE_GUID(IID_ID3D12DeviceRemovedExtendedDataSettings2,0x61552388,0x01ab,0x4008,0xa4,0x36,0x83,0xdb,0x18,0x95,0x66,0xea);
+DEFINE_GUID(IID_ID3D12DeviceRemovedExtendedData,0x98931D33,0x5AE8,0x4791,0xAA,0x3C,0x1A,0x73,0xA2,0x93,0x4E,0x71);
+DEFINE_GUID(IID_ID3D12DeviceRemovedExtendedData1,0x9727A022,0xCF1D,0x4DDA,0x9E,0xBA,0xEF,0xFA,0x65,0x3F,0xC5,0x06);
+DEFINE_GUID(IID_ID3D12DeviceRemovedExtendedData2,0x67FC5816,0xE4CA,0x4915,0xBF,0x18,0x42,0x54,0x12,0x72,0xDA,0x54);
+DEFINE_GUID(IID_ID3D12Device6,0xc70b221b,0x40e4,0x4a17,0x89,0xaf,0x02,0x5a,0x07,0x27,0xa6,0xdc);
+DEFINE_GUID(IID_ID3D12ProtectedResourceSession1,0xD6F12DD6,0x76FB,0x406E,0x89,0x61,0x42,0x96,0xEE,0xFC,0x04,0x09);
+DEFINE_GUID(IID_ID3D12Device7,0x5c014b53,0x68a1,0x4b9b,0x8b,0xd1,0xdd,0x60,0x46,0xb9,0x35,0x8b);
+DEFINE_GUID(IID_ID3D12Device8,0x9218E6BB,0xF944,0x4F7E,0xA7,0x5C,0xB1,0xB2,0xC7,0xB7,0x01,0xF3);
+DEFINE_GUID(IID_ID3D12Resource1,0x9D5E227A,0x4430,0x4161,0x88,0xB3,0x3E,0xCA,0x6B,0xB1,0x6E,0x19);
+DEFINE_GUID(IID_ID3D12Resource2,0xBE36EC3B,0xEA85,0x4AEB,0xA4,0x5A,0xE9,0xD7,0x64,0x04,0xA4,0x95);
+DEFINE_GUID(IID_ID3D12Heap1,0x572F7389,0x2168,0x49E3,0x96,0x93,0xD6,0xDF,0x58,0x71,0xBF,0x6D);
+DEFINE_GUID(IID_ID3D12GraphicsCommandList3,0x6FDA83A7,0xB84C,0x4E38,0x9A,0xC8,0xC7,0xBD,0x22,0x01,0x6B,0x3D);
+DEFINE_GUID(IID_ID3D12MetaCommand,0xDBB84C27,0x36CE,0x4FC9,0xB8,0x01,0xF0,0x48,0xC4,0x6A,0xC5,0x70);
+DEFINE_GUID(IID_ID3D12GraphicsCommandList4,0x8754318e,0xd3a9,0x4541,0x98,0xcf,0x64,0x5b,0x50,0xdc,0x48,0x74);
+DEFINE_GUID(IID_ID3D12ShaderCacheSession,0x28e2495d,0x0f64,0x4ae4,0xa6,0xec,0x12,0x92,0x55,0xdc,0x49,0xa8);
+DEFINE_GUID(IID_ID3D12Device9,0x4c80e962,0xf032,0x4f60,0xbc,0x9e,0xeb,0xc2,0xcf,0xa1,0xd8,0x3c);
+DEFINE_GUID(IID_ID3D12Device10,0x517f8718,0xaa66,0x49f9,0xb0,0x2b,0xa7,0xab,0x89,0xc0,0x60,0x31);
+DEFINE_GUID(IID_ID3D12Device11,0x5405c344,0xd457,0x444e,0xb4,0xdd,0x23,0x66,0xe4,0x5a,0xee,0x39);
+DEFINE_GUID(IID_ID3D12VirtualizationGuestDevice,0xbc66d368,0x7373,0x4943,0x87,0x57,0xfc,0x87,0xdc,0x79,0xe4,0x76);
+DEFINE_GUID(IID_ID3D12Tools,0x7071e1f0,0xe84b,0x4b33,0x97,0x4f,0x12,0xfa,0x49,0xde,0x65,0xc5);
+DEFINE_GUID(IID_ID3D12SDKConfiguration,0xe9eb5314,0x33aa,0x42b2,0xa7,0x18,0xd7,0x7f,0x58,0xb1,0xf1,0xc7);
+DEFINE_GUID(IID_ID3D12SDKConfiguration1,0x8aaf9303,0xad25,0x48b9,0x9a,0x57,0xd9,0xc3,0x7e,0x00,0x9d,0x9f);
+DEFINE_GUID(IID_ID3D12DeviceFactory,0x61f307d3,0xd34e,0x4e7c,0x83,0x74,0x3b,0xa4,0xde,0x23,0xcc,0xcb);
+DEFINE_GUID(IID_ID3D12DeviceConfiguration,0x78dbf87b,0xf766,0x422b,0xa6,0x1c,0xc8,0xc4,0x46,0xbd,0xb9,0xad);
+DEFINE_GUID(IID_ID3D12GraphicsCommandList5,0x55050859,0x4024,0x474c,0x87,0xf5,0x64,0x72,0xea,0xee,0x44,0xea);
+DEFINE_GUID(IID_ID3D12GraphicsCommandList6,0xc3827890,0xe548,0x4cfa,0x96,0xcf,0x56,0x89,0xa9,0x37,0x0f,0x80);
+DEFINE_GUID(IID_ID3D12GraphicsCommandList7,0xdd171223,0x8b61,0x4769,0x90,0xe3,0x16,0x0c,0xcd,0xe4,0xe2,0xc1);
+DEFINE_GUID(IID_ID3D12GraphicsCommandList8,0xee936ef9,0x599d,0x4d28,0x93,0x8e,0x23,0xc4,0xad,0x05,0xce,0x51);
+
+
+extern RPC_IF_HANDLE __MIDL_itf_d3d12_0000_0065_v0_0_c_ifspec;
+extern RPC_IF_HANDLE __MIDL_itf_d3d12_0000_0065_v0_0_s_ifspec;
+
+/* Additional Prototypes for ALL interfaces */
+
+/* end of Additional Prototypes */
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+
+
diff --git a/thirdparty/directx_headers/d3d12compatibility.h b/thirdparty/directx_headers/d3d12compatibility.h
new file mode 100644
index 0000000000..1a9430e5c9
--- /dev/null
+++ b/thirdparty/directx_headers/d3d12compatibility.h
@@ -0,0 +1,739 @@
+/*-------------------------------------------------------------------------------------
+ *
+ * Copyright (c) Microsoft Corporation
+ * Licensed under the MIT license
+ *
+ *-------------------------------------------------------------------------------------*/
+
+
+/* this ALWAYS GENERATED file contains the definitions for the interfaces */
+
+
+ /* File created by MIDL compiler version 8.01.0628 */
+
+
+
+/* verify that the <rpcndr.h> version is high enough to compile this file*/
+#ifndef __REQUIRED_RPCNDR_H_VERSION__
+#define __REQUIRED_RPCNDR_H_VERSION__ 500
+#endif
+
+/* verify that the <rpcsal.h> version is high enough to compile this file*/
+#ifndef __REQUIRED_RPCSAL_H_VERSION__
+#define __REQUIRED_RPCSAL_H_VERSION__ 100
+#endif
+
+#include "rpc.h"
+#include "rpcndr.h"
+
+#ifndef __RPCNDR_H_VERSION__
+#error this stub requires an updated version of <rpcndr.h>
+#endif /* __RPCNDR_H_VERSION__ */
+
+#ifndef COM_NO_WINDOWS_H
+#include "windows.h"
+#include "ole2.h"
+#endif /*COM_NO_WINDOWS_H*/
+
+#ifndef __d3d12compatibility_h__
+#define __d3d12compatibility_h__
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+#pragma once
+#endif
+
+#ifndef DECLSPEC_XFGVIRT
+#if defined(_CONTROL_FLOW_GUARD_XFG)
+#define DECLSPEC_XFGVIRT(base, func) __declspec(xfg_virtual(base, func))
+#else
+#define DECLSPEC_XFGVIRT(base, func)
+#endif
+#endif
+
+/* Forward Declarations */ 
+
+#ifndef __ID3D12CompatibilityDevice_FWD_DEFINED__
+#define __ID3D12CompatibilityDevice_FWD_DEFINED__
+typedef interface ID3D12CompatibilityDevice ID3D12CompatibilityDevice;
+
+#endif 	/* __ID3D12CompatibilityDevice_FWD_DEFINED__ */
+
+
+#ifndef __D3D11On12CreatorID_FWD_DEFINED__
+#define __D3D11On12CreatorID_FWD_DEFINED__
+typedef interface D3D11On12CreatorID D3D11On12CreatorID;
+
+#endif 	/* __D3D11On12CreatorID_FWD_DEFINED__ */
+
+
+#ifndef __D3D9On12CreatorID_FWD_DEFINED__
+#define __D3D9On12CreatorID_FWD_DEFINED__
+typedef interface D3D9On12CreatorID D3D9On12CreatorID;
+
+#endif 	/* __D3D9On12CreatorID_FWD_DEFINED__ */
+
+
+#ifndef __OpenGLOn12CreatorID_FWD_DEFINED__
+#define __OpenGLOn12CreatorID_FWD_DEFINED__
+typedef interface OpenGLOn12CreatorID OpenGLOn12CreatorID;
+
+#endif 	/* __OpenGLOn12CreatorID_FWD_DEFINED__ */
+
+
+#ifndef __OpenCLOn12CreatorID_FWD_DEFINED__
+#define __OpenCLOn12CreatorID_FWD_DEFINED__
+typedef interface OpenCLOn12CreatorID OpenCLOn12CreatorID;
+
+#endif 	/* __OpenCLOn12CreatorID_FWD_DEFINED__ */
+
+
+#ifndef __DirectMLTensorFlowCreatorID_FWD_DEFINED__
+#define __DirectMLTensorFlowCreatorID_FWD_DEFINED__
+typedef interface DirectMLTensorFlowCreatorID DirectMLTensorFlowCreatorID;
+
+#endif 	/* __DirectMLTensorFlowCreatorID_FWD_DEFINED__ */
+
+
+#ifndef __DirectMLPyTorchCreatorID_FWD_DEFINED__
+#define __DirectMLPyTorchCreatorID_FWD_DEFINED__
+typedef interface DirectMLPyTorchCreatorID DirectMLPyTorchCreatorID;
+
+#endif 	/* __DirectMLPyTorchCreatorID_FWD_DEFINED__ */
+
+
+/* header files for imported files */
+#include "oaidl.h"
+#include "ocidl.h"
+#include "d3d11on12.h"
+
+#ifdef __cplusplus
+extern "C"{
+#endif 
+
+
+/* interface __MIDL_itf_d3d12compatibility_0000_0000 */
+/* [local] */ 
+
+#include <winapifamily.h>
+#pragma region Desktop Family
+#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP | WINAPI_PARTITION_GAMES)
+typedef 
+enum D3D12_COMPATIBILITY_SHARED_FLAGS
+    {
+        D3D12_COMPATIBILITY_SHARED_FLAG_NONE	= 0,
+        D3D12_COMPATIBILITY_SHARED_FLAG_NON_NT_HANDLE	= 0x1,
+        D3D12_COMPATIBILITY_SHARED_FLAG_KEYED_MUTEX	= 0x2,
+        D3D12_COMPATIBILITY_SHARED_FLAG_9_ON_12	= 0x4
+    } 	D3D12_COMPATIBILITY_SHARED_FLAGS;
+
+DEFINE_ENUM_FLAG_OPERATORS( D3D12_COMPATIBILITY_SHARED_FLAGS );
+typedef 
+enum D3D12_REFLECT_SHARED_PROPERTY
+    {
+        D3D12_REFLECT_SHARED_PROPERTY_D3D11_RESOURCE_FLAGS	= 0,
+        D3D12_REFELCT_SHARED_PROPERTY_COMPATIBILITY_SHARED_FLAGS	= ( D3D12_REFLECT_SHARED_PROPERTY_D3D11_RESOURCE_FLAGS + 1 ) ,
+        D3D12_REFLECT_SHARED_PROPERTY_NON_NT_SHARED_HANDLE	= ( D3D12_REFELCT_SHARED_PROPERTY_COMPATIBILITY_SHARED_FLAGS + 1 ) 
+    } 	D3D12_REFLECT_SHARED_PROPERTY;
+
+
+
+extern RPC_IF_HANDLE __MIDL_itf_d3d12compatibility_0000_0000_v0_0_c_ifspec;
+extern RPC_IF_HANDLE __MIDL_itf_d3d12compatibility_0000_0000_v0_0_s_ifspec;
+
+#ifndef __ID3D12CompatibilityDevice_INTERFACE_DEFINED__
+#define __ID3D12CompatibilityDevice_INTERFACE_DEFINED__
+
+/* interface ID3D12CompatibilityDevice */
+/* [unique][local][object][uuid] */ 
+
+
+EXTERN_C const IID IID_ID3D12CompatibilityDevice;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("8f1c0e3c-fae3-4a82-b098-bfe1708207ff")
+    ID3D12CompatibilityDevice : public IUnknown
+    {
+    public:
+        virtual HRESULT STDMETHODCALLTYPE CreateSharedResource( 
+            _In_  const D3D12_HEAP_PROPERTIES *pHeapProperties,
+            D3D12_HEAP_FLAGS HeapFlags,
+            _In_  const D3D12_RESOURCE_DESC *pDesc,
+            D3D12_RESOURCE_STATES InitialResourceState,
+            _In_opt_  const D3D12_CLEAR_VALUE *pOptimizedClearValue,
+            _In_opt_  const D3D11_RESOURCE_FLAGS *pFlags11,
+            D3D12_COMPATIBILITY_SHARED_FLAGS CompatibilityFlags,
+            _In_opt_  ID3D12LifetimeTracker *pLifetimeTracker,
+            _In_opt_  ID3D12SwapChainAssistant *pOwningSwapchain,
+            REFIID riid,
+            _COM_Outptr_opt_  void **ppResource) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE CreateSharedHeap( 
+            _In_  const D3D12_HEAP_DESC *pHeapDesc,
+            D3D12_COMPATIBILITY_SHARED_FLAGS CompatibilityFlags,
+            REFIID riid,
+            _COM_Outptr_opt_  void **ppHeap) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE ReflectSharedProperties( 
+            _In_  ID3D12Object *pHeapOrResource,
+            D3D12_REFLECT_SHARED_PROPERTY ReflectType,
+            _Out_writes_bytes_(DataSize)  void *pData,
+            UINT DataSize) = 0;
+        
+    };
+    
+    
+#else 	/* C style interface */
+
+    typedef struct ID3D12CompatibilityDeviceVtbl
+    {
+        BEGIN_INTERFACE
+        
+        DECLSPEC_XFGVIRT(IUnknown, QueryInterface)
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            ID3D12CompatibilityDevice * This,
+            REFIID riid,
+            _COM_Outptr_  void **ppvObject);
+        
+        DECLSPEC_XFGVIRT(IUnknown, AddRef)
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            ID3D12CompatibilityDevice * This);
+        
+        DECLSPEC_XFGVIRT(IUnknown, Release)
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            ID3D12CompatibilityDevice * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12CompatibilityDevice, CreateSharedResource)
+        HRESULT ( STDMETHODCALLTYPE *CreateSharedResource )( 
+            ID3D12CompatibilityDevice * This,
+            _In_  const D3D12_HEAP_PROPERTIES *pHeapProperties,
+            D3D12_HEAP_FLAGS HeapFlags,
+            _In_  const D3D12_RESOURCE_DESC *pDesc,
+            D3D12_RESOURCE_STATES InitialResourceState,
+            _In_opt_  const D3D12_CLEAR_VALUE *pOptimizedClearValue,
+            _In_opt_  const D3D11_RESOURCE_FLAGS *pFlags11,
+            D3D12_COMPATIBILITY_SHARED_FLAGS CompatibilityFlags,
+            _In_opt_  ID3D12LifetimeTracker *pLifetimeTracker,
+            _In_opt_  ID3D12SwapChainAssistant *pOwningSwapchain,
+            REFIID riid,
+            _COM_Outptr_opt_  void **ppResource);
+        
+        DECLSPEC_XFGVIRT(ID3D12CompatibilityDevice, CreateSharedHeap)
+        HRESULT ( STDMETHODCALLTYPE *CreateSharedHeap )( 
+            ID3D12CompatibilityDevice * This,
+            _In_  const D3D12_HEAP_DESC *pHeapDesc,
+            D3D12_COMPATIBILITY_SHARED_FLAGS CompatibilityFlags,
+            REFIID riid,
+            _COM_Outptr_opt_  void **ppHeap);
+        
+        DECLSPEC_XFGVIRT(ID3D12CompatibilityDevice, ReflectSharedProperties)
+        HRESULT ( STDMETHODCALLTYPE *ReflectSharedProperties )( 
+            ID3D12CompatibilityDevice * This,
+            _In_  ID3D12Object *pHeapOrResource,
+            D3D12_REFLECT_SHARED_PROPERTY ReflectType,
+            _Out_writes_bytes_(DataSize)  void *pData,
+            UINT DataSize);
+        
+        END_INTERFACE
+    } ID3D12CompatibilityDeviceVtbl;
+
+    interface ID3D12CompatibilityDevice
+    {
+        CONST_VTBL struct ID3D12CompatibilityDeviceVtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define ID3D12CompatibilityDevice_QueryInterface(This,riid,ppvObject)	\
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define ID3D12CompatibilityDevice_AddRef(This)	\
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define ID3D12CompatibilityDevice_Release(This)	\
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#define ID3D12CompatibilityDevice_CreateSharedResource(This,pHeapProperties,HeapFlags,pDesc,InitialResourceState,pOptimizedClearValue,pFlags11,CompatibilityFlags,pLifetimeTracker,pOwningSwapchain,riid,ppResource)	\
+    ( (This)->lpVtbl -> CreateSharedResource(This,pHeapProperties,HeapFlags,pDesc,InitialResourceState,pOptimizedClearValue,pFlags11,CompatibilityFlags,pLifetimeTracker,pOwningSwapchain,riid,ppResource) ) 
+
+#define ID3D12CompatibilityDevice_CreateSharedHeap(This,pHeapDesc,CompatibilityFlags,riid,ppHeap)	\
+    ( (This)->lpVtbl -> CreateSharedHeap(This,pHeapDesc,CompatibilityFlags,riid,ppHeap) ) 
+
+#define ID3D12CompatibilityDevice_ReflectSharedProperties(This,pHeapOrResource,ReflectType,pData,DataSize)	\
+    ( (This)->lpVtbl -> ReflectSharedProperties(This,pHeapOrResource,ReflectType,pData,DataSize) ) 
+
+#endif /* COBJMACROS */
+
+
+#endif 	/* C style interface */
+
+
+
+
+#endif 	/* __ID3D12CompatibilityDevice_INTERFACE_DEFINED__ */
+
+
+#ifndef __D3D11On12CreatorID_INTERFACE_DEFINED__
+#define __D3D11On12CreatorID_INTERFACE_DEFINED__
+
+/* interface D3D11On12CreatorID */
+/* [unique][local][object][uuid] */ 
+
+
+EXTERN_C const IID IID_D3D11On12CreatorID;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("edbf5678-2960-4e81-8429-99d4b2630c4e")
+    D3D11On12CreatorID : public IUnknown
+    {
+    public:
+    };
+    
+    
+#else 	/* C style interface */
+
+    typedef struct D3D11On12CreatorIDVtbl
+    {
+        BEGIN_INTERFACE
+        
+        DECLSPEC_XFGVIRT(IUnknown, QueryInterface)
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            D3D11On12CreatorID * This,
+            REFIID riid,
+            _COM_Outptr_  void **ppvObject);
+        
+        DECLSPEC_XFGVIRT(IUnknown, AddRef)
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            D3D11On12CreatorID * This);
+        
+        DECLSPEC_XFGVIRT(IUnknown, Release)
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            D3D11On12CreatorID * This);
+        
+        END_INTERFACE
+    } D3D11On12CreatorIDVtbl;
+
+    interface D3D11On12CreatorID
+    {
+        CONST_VTBL struct D3D11On12CreatorIDVtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define D3D11On12CreatorID_QueryInterface(This,riid,ppvObject)	\
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define D3D11On12CreatorID_AddRef(This)	\
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define D3D11On12CreatorID_Release(This)	\
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#endif /* COBJMACROS */
+
+
+#endif 	/* C style interface */
+
+
+
+
+#endif 	/* __D3D11On12CreatorID_INTERFACE_DEFINED__ */
+
+
+#ifndef __D3D9On12CreatorID_INTERFACE_DEFINED__
+#define __D3D9On12CreatorID_INTERFACE_DEFINED__
+
+/* interface D3D9On12CreatorID */
+/* [unique][local][object][uuid] */ 
+
+
+EXTERN_C const IID IID_D3D9On12CreatorID;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("fffcbb7f-15d3-42a2-841e-9d8d32f37ddd")
+    D3D9On12CreatorID : public IUnknown
+    {
+    public:
+    };
+    
+    
+#else 	/* C style interface */
+
+    typedef struct D3D9On12CreatorIDVtbl
+    {
+        BEGIN_INTERFACE
+        
+        DECLSPEC_XFGVIRT(IUnknown, QueryInterface)
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            D3D9On12CreatorID * This,
+            REFIID riid,
+            _COM_Outptr_  void **ppvObject);
+        
+        DECLSPEC_XFGVIRT(IUnknown, AddRef)
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            D3D9On12CreatorID * This);
+        
+        DECLSPEC_XFGVIRT(IUnknown, Release)
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            D3D9On12CreatorID * This);
+        
+        END_INTERFACE
+    } D3D9On12CreatorIDVtbl;
+
+    interface D3D9On12CreatorID
+    {
+        CONST_VTBL struct D3D9On12CreatorIDVtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define D3D9On12CreatorID_QueryInterface(This,riid,ppvObject)	\
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define D3D9On12CreatorID_AddRef(This)	\
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define D3D9On12CreatorID_Release(This)	\
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#endif /* COBJMACROS */
+
+
+#endif 	/* C style interface */
+
+
+
+
+#endif 	/* __D3D9On12CreatorID_INTERFACE_DEFINED__ */
+
+
+#ifndef __OpenGLOn12CreatorID_INTERFACE_DEFINED__
+#define __OpenGLOn12CreatorID_INTERFACE_DEFINED__
+
+/* interface OpenGLOn12CreatorID */
+/* [unique][local][object][uuid] */ 
+
+
+EXTERN_C const IID IID_OpenGLOn12CreatorID;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("6bb3cd34-0d19-45ab-97ed-d720ba3dfc80")
+    OpenGLOn12CreatorID : public IUnknown
+    {
+    public:
+    };
+    
+    
+#else 	/* C style interface */
+
+    typedef struct OpenGLOn12CreatorIDVtbl
+    {
+        BEGIN_INTERFACE
+        
+        DECLSPEC_XFGVIRT(IUnknown, QueryInterface)
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            OpenGLOn12CreatorID * This,
+            REFIID riid,
+            _COM_Outptr_  void **ppvObject);
+        
+        DECLSPEC_XFGVIRT(IUnknown, AddRef)
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            OpenGLOn12CreatorID * This);
+        
+        DECLSPEC_XFGVIRT(IUnknown, Release)
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            OpenGLOn12CreatorID * This);
+        
+        END_INTERFACE
+    } OpenGLOn12CreatorIDVtbl;
+
+    interface OpenGLOn12CreatorID
+    {
+        CONST_VTBL struct OpenGLOn12CreatorIDVtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define OpenGLOn12CreatorID_QueryInterface(This,riid,ppvObject)	\
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define OpenGLOn12CreatorID_AddRef(This)	\
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define OpenGLOn12CreatorID_Release(This)	\
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#endif /* COBJMACROS */
+
+
+#endif 	/* C style interface */
+
+
+
+
+#endif 	/* __OpenGLOn12CreatorID_INTERFACE_DEFINED__ */
+
+
+#ifndef __OpenCLOn12CreatorID_INTERFACE_DEFINED__
+#define __OpenCLOn12CreatorID_INTERFACE_DEFINED__
+
+/* interface OpenCLOn12CreatorID */
+/* [unique][local][object][uuid] */ 
+
+
+EXTERN_C const IID IID_OpenCLOn12CreatorID;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("3f76bb74-91b5-4a88-b126-20ca0331cd60")
+    OpenCLOn12CreatorID : public IUnknown
+    {
+    public:
+    };
+    
+    
+#else 	/* C style interface */
+
+    typedef struct OpenCLOn12CreatorIDVtbl
+    {
+        BEGIN_INTERFACE
+        
+        DECLSPEC_XFGVIRT(IUnknown, QueryInterface)
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            OpenCLOn12CreatorID * This,
+            REFIID riid,
+            _COM_Outptr_  void **ppvObject);
+        
+        DECLSPEC_XFGVIRT(IUnknown, AddRef)
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            OpenCLOn12CreatorID * This);
+        
+        DECLSPEC_XFGVIRT(IUnknown, Release)
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            OpenCLOn12CreatorID * This);
+        
+        END_INTERFACE
+    } OpenCLOn12CreatorIDVtbl;
+
+    interface OpenCLOn12CreatorID
+    {
+        CONST_VTBL struct OpenCLOn12CreatorIDVtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define OpenCLOn12CreatorID_QueryInterface(This,riid,ppvObject)	\
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define OpenCLOn12CreatorID_AddRef(This)	\
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define OpenCLOn12CreatorID_Release(This)	\
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#endif /* COBJMACROS */
+
+
+#endif 	/* C style interface */
+
+
+
+
+#endif 	/* __OpenCLOn12CreatorID_INTERFACE_DEFINED__ */
+
+
+#ifndef __DirectMLTensorFlowCreatorID_INTERFACE_DEFINED__
+#define __DirectMLTensorFlowCreatorID_INTERFACE_DEFINED__
+
+/* interface DirectMLTensorFlowCreatorID */
+/* [unique][local][object][uuid] */ 
+
+
+EXTERN_C const IID IID_DirectMLTensorFlowCreatorID;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("cb7490ac-8a0f-44ec-9b7b-6f4cafe8e9ab")
+    DirectMLTensorFlowCreatorID : public IUnknown
+    {
+    public:
+    };
+    
+    
+#else 	/* C style interface */
+
+    typedef struct DirectMLTensorFlowCreatorIDVtbl
+    {
+        BEGIN_INTERFACE
+        
+        DECLSPEC_XFGVIRT(IUnknown, QueryInterface)
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            DirectMLTensorFlowCreatorID * This,
+            REFIID riid,
+            _COM_Outptr_  void **ppvObject);
+        
+        DECLSPEC_XFGVIRT(IUnknown, AddRef)
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            DirectMLTensorFlowCreatorID * This);
+        
+        DECLSPEC_XFGVIRT(IUnknown, Release)
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            DirectMLTensorFlowCreatorID * This);
+        
+        END_INTERFACE
+    } DirectMLTensorFlowCreatorIDVtbl;
+
+    interface DirectMLTensorFlowCreatorID
+    {
+        CONST_VTBL struct DirectMLTensorFlowCreatorIDVtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define DirectMLTensorFlowCreatorID_QueryInterface(This,riid,ppvObject)	\
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define DirectMLTensorFlowCreatorID_AddRef(This)	\
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define DirectMLTensorFlowCreatorID_Release(This)	\
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#endif /* COBJMACROS */
+
+
+#endif 	/* C style interface */
+
+
+
+
+#endif 	/* __DirectMLTensorFlowCreatorID_INTERFACE_DEFINED__ */
+
+
+#ifndef __DirectMLPyTorchCreatorID_INTERFACE_DEFINED__
+#define __DirectMLPyTorchCreatorID_INTERFACE_DEFINED__
+
+/* interface DirectMLPyTorchCreatorID */
+/* [unique][local][object][uuid] */ 
+
+
+EXTERN_C const IID IID_DirectMLPyTorchCreatorID;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("af029192-fba1-4b05-9116-235e06560354")
+    DirectMLPyTorchCreatorID : public IUnknown
+    {
+    public:
+    };
+    
+    
+#else 	/* C style interface */
+
+    typedef struct DirectMLPyTorchCreatorIDVtbl
+    {
+        BEGIN_INTERFACE
+        
+        DECLSPEC_XFGVIRT(IUnknown, QueryInterface)
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            DirectMLPyTorchCreatorID * This,
+            REFIID riid,
+            _COM_Outptr_  void **ppvObject);
+        
+        DECLSPEC_XFGVIRT(IUnknown, AddRef)
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            DirectMLPyTorchCreatorID * This);
+        
+        DECLSPEC_XFGVIRT(IUnknown, Release)
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            DirectMLPyTorchCreatorID * This);
+        
+        END_INTERFACE
+    } DirectMLPyTorchCreatorIDVtbl;
+
+    interface DirectMLPyTorchCreatorID
+    {
+        CONST_VTBL struct DirectMLPyTorchCreatorIDVtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define DirectMLPyTorchCreatorID_QueryInterface(This,riid,ppvObject)	\
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define DirectMLPyTorchCreatorID_AddRef(This)	\
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define DirectMLPyTorchCreatorID_Release(This)	\
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#endif /* COBJMACROS */
+
+
+#endif 	/* C style interface */
+
+
+
+
+#endif 	/* __DirectMLPyTorchCreatorID_INTERFACE_DEFINED__ */
+
+
+/* interface __MIDL_itf_d3d12compatibility_0000_0007 */
+/* [local] */ 
+
+#endif /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP | WINAPI_PARTITION_GAMES) */
+#pragma endregion
+DEFINE_GUID(IID_ID3D12CompatibilityDevice,0x8f1c0e3c,0xfae3,0x4a82,0xb0,0x98,0xbf,0xe1,0x70,0x82,0x07,0xff);
+DEFINE_GUID(IID_D3D11On12CreatorID,0xedbf5678,0x2960,0x4e81,0x84,0x29,0x99,0xd4,0xb2,0x63,0x0c,0x4e);
+DEFINE_GUID(IID_D3D9On12CreatorID,0xfffcbb7f,0x15d3,0x42a2,0x84,0x1e,0x9d,0x8d,0x32,0xf3,0x7d,0xdd);
+DEFINE_GUID(IID_OpenGLOn12CreatorID,0x6bb3cd34,0x0d19,0x45ab,0x97,0xed,0xd7,0x20,0xba,0x3d,0xfc,0x80);
+DEFINE_GUID(IID_OpenCLOn12CreatorID,0x3f76bb74,0x91b5,0x4a88,0xb1,0x26,0x20,0xca,0x03,0x31,0xcd,0x60);
+DEFINE_GUID(IID_DirectMLTensorFlowCreatorID,0xcb7490ac,0x8a0f,0x44ec,0x9b,0x7b,0x6f,0x4c,0xaf,0xe8,0xe9,0xab);
+DEFINE_GUID(IID_DirectMLPyTorchCreatorID,0xaf029192,0xfba1,0x4b05,0x91,0x16,0x23,0x5e,0x06,0x56,0x03,0x54);
+
+
+extern RPC_IF_HANDLE __MIDL_itf_d3d12compatibility_0000_0007_v0_0_c_ifspec;
+extern RPC_IF_HANDLE __MIDL_itf_d3d12compatibility_0000_0007_v0_0_s_ifspec;
+
+/* Additional Prototypes for ALL interfaces */
+
+/* end of Additional Prototypes */
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+
+
diff --git a/thirdparty/directx_headers/d3d12sdklayers.h b/thirdparty/directx_headers/d3d12sdklayers.h
new file mode 100644
index 0000000000..b25a8f6e5d
--- /dev/null
+++ b/thirdparty/directx_headers/d3d12sdklayers.h
@@ -0,0 +1,4110 @@
+/*-------------------------------------------------------------------------------------
+ *
+ * Copyright (c) Microsoft Corporation
+ * Licensed under the MIT license
+ *
+ *-------------------------------------------------------------------------------------*/
+
+
+/* this ALWAYS GENERATED file contains the definitions for the interfaces */
+
+
+ /* File created by MIDL compiler version 8.01.0628 */
+
+
+
+/* verify that the <rpcndr.h> version is high enough to compile this file*/
+#ifndef __REQUIRED_RPCNDR_H_VERSION__
+#define __REQUIRED_RPCNDR_H_VERSION__ 500
+#endif
+
+/* verify that the <rpcsal.h> version is high enough to compile this file*/
+#ifndef __REQUIRED_RPCSAL_H_VERSION__
+#define __REQUIRED_RPCSAL_H_VERSION__ 100
+#endif
+
+#include "rpc.h"
+#include "rpcndr.h"
+
+#ifndef __RPCNDR_H_VERSION__
+#error this stub requires an updated version of <rpcndr.h>
+#endif /* __RPCNDR_H_VERSION__ */
+
+#ifndef COM_NO_WINDOWS_H
+#include "windows.h"
+#include "ole2.h"
+#endif /*COM_NO_WINDOWS_H*/
+
+#ifndef __d3d12sdklayers_h__
+#define __d3d12sdklayers_h__
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+#pragma once
+#endif
+
+#ifndef DECLSPEC_XFGVIRT
+#if defined(_CONTROL_FLOW_GUARD_XFG)
+#define DECLSPEC_XFGVIRT(base, func) __declspec(xfg_virtual(base, func))
+#else
+#define DECLSPEC_XFGVIRT(base, func)
+#endif
+#endif
+
+/* Forward Declarations */ 
+
+#ifndef __ID3D12Debug_FWD_DEFINED__
+#define __ID3D12Debug_FWD_DEFINED__
+typedef interface ID3D12Debug ID3D12Debug;
+
+#endif 	/* __ID3D12Debug_FWD_DEFINED__ */
+
+
+#ifndef __ID3D12Debug1_FWD_DEFINED__
+#define __ID3D12Debug1_FWD_DEFINED__
+typedef interface ID3D12Debug1 ID3D12Debug1;
+
+#endif 	/* __ID3D12Debug1_FWD_DEFINED__ */
+
+
+#ifndef __ID3D12Debug2_FWD_DEFINED__
+#define __ID3D12Debug2_FWD_DEFINED__
+typedef interface ID3D12Debug2 ID3D12Debug2;
+
+#endif 	/* __ID3D12Debug2_FWD_DEFINED__ */
+
+
+#ifndef __ID3D12Debug3_FWD_DEFINED__
+#define __ID3D12Debug3_FWD_DEFINED__
+typedef interface ID3D12Debug3 ID3D12Debug3;
+
+#endif 	/* __ID3D12Debug3_FWD_DEFINED__ */
+
+
+#ifndef __ID3D12Debug4_FWD_DEFINED__
+#define __ID3D12Debug4_FWD_DEFINED__
+typedef interface ID3D12Debug4 ID3D12Debug4;
+
+#endif 	/* __ID3D12Debug4_FWD_DEFINED__ */
+
+
+#ifndef __ID3D12Debug5_FWD_DEFINED__
+#define __ID3D12Debug5_FWD_DEFINED__
+typedef interface ID3D12Debug5 ID3D12Debug5;
+
+#endif 	/* __ID3D12Debug5_FWD_DEFINED__ */
+
+
+#ifndef __ID3D12Debug6_FWD_DEFINED__
+#define __ID3D12Debug6_FWD_DEFINED__
+typedef interface ID3D12Debug6 ID3D12Debug6;
+
+#endif 	/* __ID3D12Debug6_FWD_DEFINED__ */
+
+
+#ifndef __ID3D12DebugDevice1_FWD_DEFINED__
+#define __ID3D12DebugDevice1_FWD_DEFINED__
+typedef interface ID3D12DebugDevice1 ID3D12DebugDevice1;
+
+#endif 	/* __ID3D12DebugDevice1_FWD_DEFINED__ */
+
+
+#ifndef __ID3D12DebugDevice_FWD_DEFINED__
+#define __ID3D12DebugDevice_FWD_DEFINED__
+typedef interface ID3D12DebugDevice ID3D12DebugDevice;
+
+#endif 	/* __ID3D12DebugDevice_FWD_DEFINED__ */
+
+
+#ifndef __ID3D12DebugDevice2_FWD_DEFINED__
+#define __ID3D12DebugDevice2_FWD_DEFINED__
+typedef interface ID3D12DebugDevice2 ID3D12DebugDevice2;
+
+#endif 	/* __ID3D12DebugDevice2_FWD_DEFINED__ */
+
+
+#ifndef __ID3D12DebugCommandQueue_FWD_DEFINED__
+#define __ID3D12DebugCommandQueue_FWD_DEFINED__
+typedef interface ID3D12DebugCommandQueue ID3D12DebugCommandQueue;
+
+#endif 	/* __ID3D12DebugCommandQueue_FWD_DEFINED__ */
+
+
+#ifndef __ID3D12DebugCommandQueue1_FWD_DEFINED__
+#define __ID3D12DebugCommandQueue1_FWD_DEFINED__
+typedef interface ID3D12DebugCommandQueue1 ID3D12DebugCommandQueue1;
+
+#endif 	/* __ID3D12DebugCommandQueue1_FWD_DEFINED__ */
+
+
+#ifndef __ID3D12DebugCommandList1_FWD_DEFINED__
+#define __ID3D12DebugCommandList1_FWD_DEFINED__
+typedef interface ID3D12DebugCommandList1 ID3D12DebugCommandList1;
+
+#endif 	/* __ID3D12DebugCommandList1_FWD_DEFINED__ */
+
+
+#ifndef __ID3D12DebugCommandList_FWD_DEFINED__
+#define __ID3D12DebugCommandList_FWD_DEFINED__
+typedef interface ID3D12DebugCommandList ID3D12DebugCommandList;
+
+#endif 	/* __ID3D12DebugCommandList_FWD_DEFINED__ */
+
+
+#ifndef __ID3D12DebugCommandList2_FWD_DEFINED__
+#define __ID3D12DebugCommandList2_FWD_DEFINED__
+typedef interface ID3D12DebugCommandList2 ID3D12DebugCommandList2;
+
+#endif 	/* __ID3D12DebugCommandList2_FWD_DEFINED__ */
+
+
+#ifndef __ID3D12DebugCommandList3_FWD_DEFINED__
+#define __ID3D12DebugCommandList3_FWD_DEFINED__
+typedef interface ID3D12DebugCommandList3 ID3D12DebugCommandList3;
+
+#endif 	/* __ID3D12DebugCommandList3_FWD_DEFINED__ */
+
+
+#ifndef __ID3D12SharingContract_FWD_DEFINED__
+#define __ID3D12SharingContract_FWD_DEFINED__
+typedef interface ID3D12SharingContract ID3D12SharingContract;
+
+#endif 	/* __ID3D12SharingContract_FWD_DEFINED__ */
+
+
+#ifndef __ID3D12InfoQueue_FWD_DEFINED__
+#define __ID3D12InfoQueue_FWD_DEFINED__
+typedef interface ID3D12InfoQueue ID3D12InfoQueue;
+
+#endif 	/* __ID3D12InfoQueue_FWD_DEFINED__ */
+
+
+#ifndef __ID3D12InfoQueue1_FWD_DEFINED__
+#define __ID3D12InfoQueue1_FWD_DEFINED__
+typedef interface ID3D12InfoQueue1 ID3D12InfoQueue1;
+
+#endif 	/* __ID3D12InfoQueue1_FWD_DEFINED__ */
+
+
+/* header files for imported files */
+#include "oaidl.h"
+#include "ocidl.h"
+#include "d3d12.h"
+
+#ifdef __cplusplus
+extern "C"{
+#endif 
+
+
+/* interface __MIDL_itf_d3d12sdklayers_0000_0000 */
+/* [local] */ 
+
+#include <winapifamily.h>
+#pragma region App Family
+#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP | WINAPI_PARTITION_GAMES)
+
+
+extern RPC_IF_HANDLE __MIDL_itf_d3d12sdklayers_0000_0000_v0_0_c_ifspec;
+extern RPC_IF_HANDLE __MIDL_itf_d3d12sdklayers_0000_0000_v0_0_s_ifspec;
+
+#ifndef __ID3D12Debug_INTERFACE_DEFINED__
+#define __ID3D12Debug_INTERFACE_DEFINED__
+
+/* interface ID3D12Debug */
+/* [unique][local][object][uuid] */ 
+
+
+EXTERN_C const IID IID_ID3D12Debug;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("344488b7-6846-474b-b989-f027448245e0")
+    ID3D12Debug : public IUnknown
+    {
+    public:
+        virtual void STDMETHODCALLTYPE EnableDebugLayer( void) = 0;
+        
+    };
+    
+    
+#else 	/* C style interface */
+
+    typedef struct ID3D12DebugVtbl
+    {
+        BEGIN_INTERFACE
+        
+        DECLSPEC_XFGVIRT(IUnknown, QueryInterface)
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            ID3D12Debug * This,
+            REFIID riid,
+            _COM_Outptr_  void **ppvObject);
+        
+        DECLSPEC_XFGVIRT(IUnknown, AddRef)
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            ID3D12Debug * This);
+        
+        DECLSPEC_XFGVIRT(IUnknown, Release)
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            ID3D12Debug * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12Debug, EnableDebugLayer)
+        void ( STDMETHODCALLTYPE *EnableDebugLayer )( 
+            ID3D12Debug * This);
+        
+        END_INTERFACE
+    } ID3D12DebugVtbl;
+
+    interface ID3D12Debug
+    {
+        CONST_VTBL struct ID3D12DebugVtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define ID3D12Debug_QueryInterface(This,riid,ppvObject)	\
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define ID3D12Debug_AddRef(This)	\
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define ID3D12Debug_Release(This)	\
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#define ID3D12Debug_EnableDebugLayer(This)	\
+    ( (This)->lpVtbl -> EnableDebugLayer(This) ) 
+
+#endif /* COBJMACROS */
+
+
+#endif 	/* C style interface */
+
+
+
+
+#endif 	/* __ID3D12Debug_INTERFACE_DEFINED__ */
+
+
+/* interface __MIDL_itf_d3d12sdklayers_0000_0001 */
+/* [local] */ 
+
+typedef 
+enum D3D12_GPU_BASED_VALIDATION_FLAGS
+    {
+        D3D12_GPU_BASED_VALIDATION_FLAGS_NONE	= 0,
+        D3D12_GPU_BASED_VALIDATION_FLAGS_DISABLE_STATE_TRACKING	= 0x1
+    } 	D3D12_GPU_BASED_VALIDATION_FLAGS;
+
+DEFINE_ENUM_FLAG_OPERATORS(D3D12_GPU_BASED_VALIDATION_FLAGS)
+
+
+extern RPC_IF_HANDLE __MIDL_itf_d3d12sdklayers_0000_0001_v0_0_c_ifspec;
+extern RPC_IF_HANDLE __MIDL_itf_d3d12sdklayers_0000_0001_v0_0_s_ifspec;
+
+#ifndef __ID3D12Debug1_INTERFACE_DEFINED__
+#define __ID3D12Debug1_INTERFACE_DEFINED__
+
+/* interface ID3D12Debug1 */
+/* [unique][local][object][uuid] */ 
+
+
+EXTERN_C const IID IID_ID3D12Debug1;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("affaa4ca-63fe-4d8e-b8ad-159000af4304")
+    ID3D12Debug1 : public IUnknown
+    {
+    public:
+        virtual void STDMETHODCALLTYPE EnableDebugLayer( void) = 0;
+        
+        virtual void STDMETHODCALLTYPE SetEnableGPUBasedValidation( 
+            BOOL Enable) = 0;
+        
+        virtual void STDMETHODCALLTYPE SetEnableSynchronizedCommandQueueValidation( 
+            BOOL Enable) = 0;
+        
+    };
+    
+    
+#else 	/* C style interface */
+
+    typedef struct ID3D12Debug1Vtbl
+    {
+        BEGIN_INTERFACE
+        
+        DECLSPEC_XFGVIRT(IUnknown, QueryInterface)
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            ID3D12Debug1 * This,
+            REFIID riid,
+            _COM_Outptr_  void **ppvObject);
+        
+        DECLSPEC_XFGVIRT(IUnknown, AddRef)
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            ID3D12Debug1 * This);
+        
+        DECLSPEC_XFGVIRT(IUnknown, Release)
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            ID3D12Debug1 * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12Debug1, EnableDebugLayer)
+        void ( STDMETHODCALLTYPE *EnableDebugLayer )( 
+            ID3D12Debug1 * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12Debug1, SetEnableGPUBasedValidation)
+        void ( STDMETHODCALLTYPE *SetEnableGPUBasedValidation )( 
+            ID3D12Debug1 * This,
+            BOOL Enable);
+        
+        DECLSPEC_XFGVIRT(ID3D12Debug1, SetEnableSynchronizedCommandQueueValidation)
+        void ( STDMETHODCALLTYPE *SetEnableSynchronizedCommandQueueValidation )( 
+            ID3D12Debug1 * This,
+            BOOL Enable);
+        
+        END_INTERFACE
+    } ID3D12Debug1Vtbl;
+
+    interface ID3D12Debug1
+    {
+        CONST_VTBL struct ID3D12Debug1Vtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define ID3D12Debug1_QueryInterface(This,riid,ppvObject)	\
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define ID3D12Debug1_AddRef(This)	\
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define ID3D12Debug1_Release(This)	\
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#define ID3D12Debug1_EnableDebugLayer(This)	\
+    ( (This)->lpVtbl -> EnableDebugLayer(This) ) 
+
+#define ID3D12Debug1_SetEnableGPUBasedValidation(This,Enable)	\
+    ( (This)->lpVtbl -> SetEnableGPUBasedValidation(This,Enable) ) 
+
+#define ID3D12Debug1_SetEnableSynchronizedCommandQueueValidation(This,Enable)	\
+    ( (This)->lpVtbl -> SetEnableSynchronizedCommandQueueValidation(This,Enable) ) 
+
+#endif /* COBJMACROS */
+
+
+#endif 	/* C style interface */
+
+
+
+
+#endif 	/* __ID3D12Debug1_INTERFACE_DEFINED__ */
+
+
+#ifndef __ID3D12Debug2_INTERFACE_DEFINED__
+#define __ID3D12Debug2_INTERFACE_DEFINED__
+
+/* interface ID3D12Debug2 */
+/* [unique][local][object][uuid] */ 
+
+
+EXTERN_C const IID IID_ID3D12Debug2;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("93a665c4-a3b2-4e5d-b692-a26ae14e3374")
+    ID3D12Debug2 : public IUnknown
+    {
+    public:
+        virtual void STDMETHODCALLTYPE SetGPUBasedValidationFlags( 
+            D3D12_GPU_BASED_VALIDATION_FLAGS Flags) = 0;
+        
+    };
+    
+    
+#else 	/* C style interface */
+
+    typedef struct ID3D12Debug2Vtbl
+    {
+        BEGIN_INTERFACE
+        
+        DECLSPEC_XFGVIRT(IUnknown, QueryInterface)
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            ID3D12Debug2 * This,
+            REFIID riid,
+            _COM_Outptr_  void **ppvObject);
+        
+        DECLSPEC_XFGVIRT(IUnknown, AddRef)
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            ID3D12Debug2 * This);
+        
+        DECLSPEC_XFGVIRT(IUnknown, Release)
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            ID3D12Debug2 * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12Debug2, SetGPUBasedValidationFlags)
+        void ( STDMETHODCALLTYPE *SetGPUBasedValidationFlags )( 
+            ID3D12Debug2 * This,
+            D3D12_GPU_BASED_VALIDATION_FLAGS Flags);
+        
+        END_INTERFACE
+    } ID3D12Debug2Vtbl;
+
+    interface ID3D12Debug2
+    {
+        CONST_VTBL struct ID3D12Debug2Vtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define ID3D12Debug2_QueryInterface(This,riid,ppvObject)	\
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define ID3D12Debug2_AddRef(This)	\
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define ID3D12Debug2_Release(This)	\
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#define ID3D12Debug2_SetGPUBasedValidationFlags(This,Flags)	\
+    ( (This)->lpVtbl -> SetGPUBasedValidationFlags(This,Flags) ) 
+
+#endif /* COBJMACROS */
+
+
+#endif 	/* C style interface */
+
+
+
+
+#endif 	/* __ID3D12Debug2_INTERFACE_DEFINED__ */
+
+
+#ifndef __ID3D12Debug3_INTERFACE_DEFINED__
+#define __ID3D12Debug3_INTERFACE_DEFINED__
+
+/* interface ID3D12Debug3 */
+/* [unique][local][object][uuid] */ 
+
+
+EXTERN_C const IID IID_ID3D12Debug3;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("5cf4e58f-f671-4ff1-a542-3686e3d153d1")
+    ID3D12Debug3 : public ID3D12Debug
+    {
+    public:
+        virtual void STDMETHODCALLTYPE SetEnableGPUBasedValidation( 
+            BOOL Enable) = 0;
+        
+        virtual void STDMETHODCALLTYPE SetEnableSynchronizedCommandQueueValidation( 
+            BOOL Enable) = 0;
+        
+        virtual void STDMETHODCALLTYPE SetGPUBasedValidationFlags( 
+            D3D12_GPU_BASED_VALIDATION_FLAGS Flags) = 0;
+        
+    };
+    
+    
+#else 	/* C style interface */
+
+    typedef struct ID3D12Debug3Vtbl
+    {
+        BEGIN_INTERFACE
+        
+        DECLSPEC_XFGVIRT(IUnknown, QueryInterface)
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            ID3D12Debug3 * This,
+            REFIID riid,
+            _COM_Outptr_  void **ppvObject);
+        
+        DECLSPEC_XFGVIRT(IUnknown, AddRef)
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            ID3D12Debug3 * This);
+        
+        DECLSPEC_XFGVIRT(IUnknown, Release)
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            ID3D12Debug3 * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12Debug, EnableDebugLayer)
+        void ( STDMETHODCALLTYPE *EnableDebugLayer )( 
+            ID3D12Debug3 * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12Debug3, SetEnableGPUBasedValidation)
+        void ( STDMETHODCALLTYPE *SetEnableGPUBasedValidation )( 
+            ID3D12Debug3 * This,
+            BOOL Enable);
+        
+        DECLSPEC_XFGVIRT(ID3D12Debug3, SetEnableSynchronizedCommandQueueValidation)
+        void ( STDMETHODCALLTYPE *SetEnableSynchronizedCommandQueueValidation )( 
+            ID3D12Debug3 * This,
+            BOOL Enable);
+        
+        DECLSPEC_XFGVIRT(ID3D12Debug3, SetGPUBasedValidationFlags)
+        void ( STDMETHODCALLTYPE *SetGPUBasedValidationFlags )( 
+            ID3D12Debug3 * This,
+            D3D12_GPU_BASED_VALIDATION_FLAGS Flags);
+        
+        END_INTERFACE
+    } ID3D12Debug3Vtbl;
+
+    interface ID3D12Debug3
+    {
+        CONST_VTBL struct ID3D12Debug3Vtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define ID3D12Debug3_QueryInterface(This,riid,ppvObject)	\
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define ID3D12Debug3_AddRef(This)	\
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define ID3D12Debug3_Release(This)	\
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#define ID3D12Debug3_EnableDebugLayer(This)	\
+    ( (This)->lpVtbl -> EnableDebugLayer(This) ) 
+
+
+#define ID3D12Debug3_SetEnableGPUBasedValidation(This,Enable)	\
+    ( (This)->lpVtbl -> SetEnableGPUBasedValidation(This,Enable) ) 
+
+#define ID3D12Debug3_SetEnableSynchronizedCommandQueueValidation(This,Enable)	\
+    ( (This)->lpVtbl -> SetEnableSynchronizedCommandQueueValidation(This,Enable) ) 
+
+#define ID3D12Debug3_SetGPUBasedValidationFlags(This,Flags)	\
+    ( (This)->lpVtbl -> SetGPUBasedValidationFlags(This,Flags) ) 
+
+#endif /* COBJMACROS */
+
+
+#endif 	/* C style interface */
+
+
+
+
+#endif 	/* __ID3D12Debug3_INTERFACE_DEFINED__ */
+
+
+#ifndef __ID3D12Debug4_INTERFACE_DEFINED__
+#define __ID3D12Debug4_INTERFACE_DEFINED__
+
+/* interface ID3D12Debug4 */
+/* [unique][local][object][uuid] */ 
+
+
+EXTERN_C const IID IID_ID3D12Debug4;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("014b816e-9ec5-4a2f-a845-ffbe441ce13a")
+    ID3D12Debug4 : public ID3D12Debug3
+    {
+    public:
+        virtual void STDMETHODCALLTYPE DisableDebugLayer( void) = 0;
+        
+    };
+    
+    
+#else 	/* C style interface */
+
+    typedef struct ID3D12Debug4Vtbl
+    {
+        BEGIN_INTERFACE
+        
+        DECLSPEC_XFGVIRT(IUnknown, QueryInterface)
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            ID3D12Debug4 * This,
+            REFIID riid,
+            _COM_Outptr_  void **ppvObject);
+        
+        DECLSPEC_XFGVIRT(IUnknown, AddRef)
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            ID3D12Debug4 * This);
+        
+        DECLSPEC_XFGVIRT(IUnknown, Release)
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            ID3D12Debug4 * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12Debug, EnableDebugLayer)
+        void ( STDMETHODCALLTYPE *EnableDebugLayer )( 
+            ID3D12Debug4 * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12Debug3, SetEnableGPUBasedValidation)
+        void ( STDMETHODCALLTYPE *SetEnableGPUBasedValidation )( 
+            ID3D12Debug4 * This,
+            BOOL Enable);
+        
+        DECLSPEC_XFGVIRT(ID3D12Debug3, SetEnableSynchronizedCommandQueueValidation)
+        void ( STDMETHODCALLTYPE *SetEnableSynchronizedCommandQueueValidation )( 
+            ID3D12Debug4 * This,
+            BOOL Enable);
+        
+        DECLSPEC_XFGVIRT(ID3D12Debug3, SetGPUBasedValidationFlags)
+        void ( STDMETHODCALLTYPE *SetGPUBasedValidationFlags )( 
+            ID3D12Debug4 * This,
+            D3D12_GPU_BASED_VALIDATION_FLAGS Flags);
+        
+        DECLSPEC_XFGVIRT(ID3D12Debug4, DisableDebugLayer)
+        void ( STDMETHODCALLTYPE *DisableDebugLayer )( 
+            ID3D12Debug4 * This);
+        
+        END_INTERFACE
+    } ID3D12Debug4Vtbl;
+
+    interface ID3D12Debug4
+    {
+        CONST_VTBL struct ID3D12Debug4Vtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define ID3D12Debug4_QueryInterface(This,riid,ppvObject)	\
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define ID3D12Debug4_AddRef(This)	\
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define ID3D12Debug4_Release(This)	\
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#define ID3D12Debug4_EnableDebugLayer(This)	\
+    ( (This)->lpVtbl -> EnableDebugLayer(This) ) 
+
+
+#define ID3D12Debug4_SetEnableGPUBasedValidation(This,Enable)	\
+    ( (This)->lpVtbl -> SetEnableGPUBasedValidation(This,Enable) ) 
+
+#define ID3D12Debug4_SetEnableSynchronizedCommandQueueValidation(This,Enable)	\
+    ( (This)->lpVtbl -> SetEnableSynchronizedCommandQueueValidation(This,Enable) ) 
+
+#define ID3D12Debug4_SetGPUBasedValidationFlags(This,Flags)	\
+    ( (This)->lpVtbl -> SetGPUBasedValidationFlags(This,Flags) ) 
+
+
+#define ID3D12Debug4_DisableDebugLayer(This)	\
+    ( (This)->lpVtbl -> DisableDebugLayer(This) ) 
+
+#endif /* COBJMACROS */
+
+
+#endif 	/* C style interface */
+
+
+
+
+#endif 	/* __ID3D12Debug4_INTERFACE_DEFINED__ */
+
+
+#ifndef __ID3D12Debug5_INTERFACE_DEFINED__
+#define __ID3D12Debug5_INTERFACE_DEFINED__
+
+/* interface ID3D12Debug5 */
+/* [unique][local][object][uuid] */ 
+
+
+EXTERN_C const IID IID_ID3D12Debug5;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("548d6b12-09fa-40e0-9069-5dcd589a52c9")
+    ID3D12Debug5 : public ID3D12Debug4
+    {
+    public:
+        virtual void STDMETHODCALLTYPE SetEnableAutoName( 
+            BOOL Enable) = 0;
+        
+    };
+    
+    
+#else 	/* C style interface */
+
+    typedef struct ID3D12Debug5Vtbl
+    {
+        BEGIN_INTERFACE
+        
+        DECLSPEC_XFGVIRT(IUnknown, QueryInterface)
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            ID3D12Debug5 * This,
+            REFIID riid,
+            _COM_Outptr_  void **ppvObject);
+        
+        DECLSPEC_XFGVIRT(IUnknown, AddRef)
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            ID3D12Debug5 * This);
+        
+        DECLSPEC_XFGVIRT(IUnknown, Release)
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            ID3D12Debug5 * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12Debug, EnableDebugLayer)
+        void ( STDMETHODCALLTYPE *EnableDebugLayer )( 
+            ID3D12Debug5 * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12Debug3, SetEnableGPUBasedValidation)
+        void ( STDMETHODCALLTYPE *SetEnableGPUBasedValidation )( 
+            ID3D12Debug5 * This,
+            BOOL Enable);
+        
+        DECLSPEC_XFGVIRT(ID3D12Debug3, SetEnableSynchronizedCommandQueueValidation)
+        void ( STDMETHODCALLTYPE *SetEnableSynchronizedCommandQueueValidation )( 
+            ID3D12Debug5 * This,
+            BOOL Enable);
+        
+        DECLSPEC_XFGVIRT(ID3D12Debug3, SetGPUBasedValidationFlags)
+        void ( STDMETHODCALLTYPE *SetGPUBasedValidationFlags )( 
+            ID3D12Debug5 * This,
+            D3D12_GPU_BASED_VALIDATION_FLAGS Flags);
+        
+        DECLSPEC_XFGVIRT(ID3D12Debug4, DisableDebugLayer)
+        void ( STDMETHODCALLTYPE *DisableDebugLayer )( 
+            ID3D12Debug5 * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12Debug5, SetEnableAutoName)
+        void ( STDMETHODCALLTYPE *SetEnableAutoName )( 
+            ID3D12Debug5 * This,
+            BOOL Enable);
+        
+        END_INTERFACE
+    } ID3D12Debug5Vtbl;
+
+    interface ID3D12Debug5
+    {
+        CONST_VTBL struct ID3D12Debug5Vtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define ID3D12Debug5_QueryInterface(This,riid,ppvObject)	\
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define ID3D12Debug5_AddRef(This)	\
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define ID3D12Debug5_Release(This)	\
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#define ID3D12Debug5_EnableDebugLayer(This)	\
+    ( (This)->lpVtbl -> EnableDebugLayer(This) ) 
+
+
+#define ID3D12Debug5_SetEnableGPUBasedValidation(This,Enable)	\
+    ( (This)->lpVtbl -> SetEnableGPUBasedValidation(This,Enable) ) 
+
+#define ID3D12Debug5_SetEnableSynchronizedCommandQueueValidation(This,Enable)	\
+    ( (This)->lpVtbl -> SetEnableSynchronizedCommandQueueValidation(This,Enable) ) 
+
+#define ID3D12Debug5_SetGPUBasedValidationFlags(This,Flags)	\
+    ( (This)->lpVtbl -> SetGPUBasedValidationFlags(This,Flags) ) 
+
+
+#define ID3D12Debug5_DisableDebugLayer(This)	\
+    ( (This)->lpVtbl -> DisableDebugLayer(This) ) 
+
+
+#define ID3D12Debug5_SetEnableAutoName(This,Enable)	\
+    ( (This)->lpVtbl -> SetEnableAutoName(This,Enable) ) 
+
+#endif /* COBJMACROS */
+
+
+#endif 	/* C style interface */
+
+
+
+
+#endif 	/* __ID3D12Debug5_INTERFACE_DEFINED__ */
+
+
+#ifndef __ID3D12Debug6_INTERFACE_DEFINED__
+#define __ID3D12Debug6_INTERFACE_DEFINED__
+
+/* interface ID3D12Debug6 */
+/* [unique][local][object][uuid] */ 
+
+
+EXTERN_C const IID IID_ID3D12Debug6;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("82a816d6-5d01-4157-97d0-4975463fd1ed")
+    ID3D12Debug6 : public ID3D12Debug5
+    {
+    public:
+        virtual void STDMETHODCALLTYPE SetForceLegacyBarrierValidation( 
+            BOOL Enable) = 0;
+        
+    };
+    
+    
+#else 	/* C style interface */
+
+    typedef struct ID3D12Debug6Vtbl
+    {
+        BEGIN_INTERFACE
+        
+        DECLSPEC_XFGVIRT(IUnknown, QueryInterface)
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            ID3D12Debug6 * This,
+            REFIID riid,
+            _COM_Outptr_  void **ppvObject);
+        
+        DECLSPEC_XFGVIRT(IUnknown, AddRef)
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            ID3D12Debug6 * This);
+        
+        DECLSPEC_XFGVIRT(IUnknown, Release)
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            ID3D12Debug6 * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12Debug, EnableDebugLayer)
+        void ( STDMETHODCALLTYPE *EnableDebugLayer )( 
+            ID3D12Debug6 * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12Debug3, SetEnableGPUBasedValidation)
+        void ( STDMETHODCALLTYPE *SetEnableGPUBasedValidation )( 
+            ID3D12Debug6 * This,
+            BOOL Enable);
+        
+        DECLSPEC_XFGVIRT(ID3D12Debug3, SetEnableSynchronizedCommandQueueValidation)
+        void ( STDMETHODCALLTYPE *SetEnableSynchronizedCommandQueueValidation )( 
+            ID3D12Debug6 * This,
+            BOOL Enable);
+        
+        DECLSPEC_XFGVIRT(ID3D12Debug3, SetGPUBasedValidationFlags)
+        void ( STDMETHODCALLTYPE *SetGPUBasedValidationFlags )( 
+            ID3D12Debug6 * This,
+            D3D12_GPU_BASED_VALIDATION_FLAGS Flags);
+        
+        DECLSPEC_XFGVIRT(ID3D12Debug4, DisableDebugLayer)
+        void ( STDMETHODCALLTYPE *DisableDebugLayer )( 
+            ID3D12Debug6 * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12Debug5, SetEnableAutoName)
+        void ( STDMETHODCALLTYPE *SetEnableAutoName )( 
+            ID3D12Debug6 * This,
+            BOOL Enable);
+        
+        DECLSPEC_XFGVIRT(ID3D12Debug6, SetForceLegacyBarrierValidation)
+        void ( STDMETHODCALLTYPE *SetForceLegacyBarrierValidation )( 
+            ID3D12Debug6 * This,
+            BOOL Enable);
+        
+        END_INTERFACE
+    } ID3D12Debug6Vtbl;
+
+    interface ID3D12Debug6
+    {
+        CONST_VTBL struct ID3D12Debug6Vtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define ID3D12Debug6_QueryInterface(This,riid,ppvObject)	\
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define ID3D12Debug6_AddRef(This)	\
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define ID3D12Debug6_Release(This)	\
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#define ID3D12Debug6_EnableDebugLayer(This)	\
+    ( (This)->lpVtbl -> EnableDebugLayer(This) ) 
+
+
+#define ID3D12Debug6_SetEnableGPUBasedValidation(This,Enable)	\
+    ( (This)->lpVtbl -> SetEnableGPUBasedValidation(This,Enable) ) 
+
+#define ID3D12Debug6_SetEnableSynchronizedCommandQueueValidation(This,Enable)	\
+    ( (This)->lpVtbl -> SetEnableSynchronizedCommandQueueValidation(This,Enable) ) 
+
+#define ID3D12Debug6_SetGPUBasedValidationFlags(This,Flags)	\
+    ( (This)->lpVtbl -> SetGPUBasedValidationFlags(This,Flags) ) 
+
+
+#define ID3D12Debug6_DisableDebugLayer(This)	\
+    ( (This)->lpVtbl -> DisableDebugLayer(This) ) 
+
+
+#define ID3D12Debug6_SetEnableAutoName(This,Enable)	\
+    ( (This)->lpVtbl -> SetEnableAutoName(This,Enable) ) 
+
+
+#define ID3D12Debug6_SetForceLegacyBarrierValidation(This,Enable)	\
+    ( (This)->lpVtbl -> SetForceLegacyBarrierValidation(This,Enable) ) 
+
+#endif /* COBJMACROS */
+
+
+#endif 	/* C style interface */
+
+
+
+
+#endif 	/* __ID3D12Debug6_INTERFACE_DEFINED__ */
+
+
+/* interface __MIDL_itf_d3d12sdklayers_0000_0007 */
+/* [local] */ 
+
+DEFINE_GUID(WKPDID_D3DAutoDebugObjectNameW, 0xd4902e36, 0x757a, 0x4942, 0x95, 0x94, 0xb6, 0x76, 0x9a, 0xfa, 0x43, 0xcd);
+typedef 
+enum D3D12_RLDO_FLAGS
+    {
+        D3D12_RLDO_NONE	= 0,
+        D3D12_RLDO_SUMMARY	= 0x1,
+        D3D12_RLDO_DETAIL	= 0x2,
+        D3D12_RLDO_IGNORE_INTERNAL	= 0x4
+    } 	D3D12_RLDO_FLAGS;
+
+DEFINE_ENUM_FLAG_OPERATORS(D3D12_RLDO_FLAGS)
+typedef 
+enum D3D12_DEBUG_DEVICE_PARAMETER_TYPE
+    {
+        D3D12_DEBUG_DEVICE_PARAMETER_FEATURE_FLAGS	= 0,
+        D3D12_DEBUG_DEVICE_PARAMETER_GPU_BASED_VALIDATION_SETTINGS	= ( D3D12_DEBUG_DEVICE_PARAMETER_FEATURE_FLAGS + 1 ) ,
+        D3D12_DEBUG_DEVICE_PARAMETER_GPU_SLOWDOWN_PERFORMANCE_FACTOR	= ( D3D12_DEBUG_DEVICE_PARAMETER_GPU_BASED_VALIDATION_SETTINGS + 1 ) 
+    } 	D3D12_DEBUG_DEVICE_PARAMETER_TYPE;
+
+typedef 
+enum D3D12_DEBUG_FEATURE
+    {
+        D3D12_DEBUG_FEATURE_NONE	= 0,
+        D3D12_DEBUG_FEATURE_ALLOW_BEHAVIOR_CHANGING_DEBUG_AIDS	= 0x1,
+        D3D12_DEBUG_FEATURE_CONSERVATIVE_RESOURCE_STATE_TRACKING	= 0x2,
+        D3D12_DEBUG_FEATURE_DISABLE_VIRTUALIZED_BUNDLES_VALIDATION	= 0x4,
+        D3D12_DEBUG_FEATURE_EMULATE_WINDOWS7	= 0x8
+    } 	D3D12_DEBUG_FEATURE;
+
+DEFINE_ENUM_FLAG_OPERATORS(D3D12_DEBUG_FEATURE)
+typedef 
+enum D3D12_GPU_BASED_VALIDATION_SHADER_PATCH_MODE
+    {
+        D3D12_GPU_BASED_VALIDATION_SHADER_PATCH_MODE_NONE	= 0,
+        D3D12_GPU_BASED_VALIDATION_SHADER_PATCH_MODE_STATE_TRACKING_ONLY	= ( D3D12_GPU_BASED_VALIDATION_SHADER_PATCH_MODE_NONE + 1 ) ,
+        D3D12_GPU_BASED_VALIDATION_SHADER_PATCH_MODE_UNGUARDED_VALIDATION	= ( D3D12_GPU_BASED_VALIDATION_SHADER_PATCH_MODE_STATE_TRACKING_ONLY + 1 ) ,
+        D3D12_GPU_BASED_VALIDATION_SHADER_PATCH_MODE_GUARDED_VALIDATION	= ( D3D12_GPU_BASED_VALIDATION_SHADER_PATCH_MODE_UNGUARDED_VALIDATION + 1 ) ,
+        NUM_D3D12_GPU_BASED_VALIDATION_SHADER_PATCH_MODES	= ( D3D12_GPU_BASED_VALIDATION_SHADER_PATCH_MODE_GUARDED_VALIDATION + 1 ) 
+    } 	D3D12_GPU_BASED_VALIDATION_SHADER_PATCH_MODE;
+
+typedef 
+enum D3D12_GPU_BASED_VALIDATION_PIPELINE_STATE_CREATE_FLAGS
+    {
+        D3D12_GPU_BASED_VALIDATION_PIPELINE_STATE_CREATE_FLAG_NONE	= 0,
+        D3D12_GPU_BASED_VALIDATION_PIPELINE_STATE_CREATE_FLAG_FRONT_LOAD_CREATE_TRACKING_ONLY_SHADERS	= 0x1,
+        D3D12_GPU_BASED_VALIDATION_PIPELINE_STATE_CREATE_FLAG_FRONT_LOAD_CREATE_UNGUARDED_VALIDATION_SHADERS	= 0x2,
+        D3D12_GPU_BASED_VALIDATION_PIPELINE_STATE_CREATE_FLAG_FRONT_LOAD_CREATE_GUARDED_VALIDATION_SHADERS	= 0x4,
+        D3D12_GPU_BASED_VALIDATION_PIPELINE_STATE_CREATE_FLAGS_VALID_MASK	= 0x7
+    } 	D3D12_GPU_BASED_VALIDATION_PIPELINE_STATE_CREATE_FLAGS;
+
+DEFINE_ENUM_FLAG_OPERATORS(D3D12_GPU_BASED_VALIDATION_PIPELINE_STATE_CREATE_FLAGS)
+typedef struct D3D12_DEBUG_DEVICE_GPU_BASED_VALIDATION_SETTINGS
+    {
+    UINT MaxMessagesPerCommandList;
+    D3D12_GPU_BASED_VALIDATION_SHADER_PATCH_MODE DefaultShaderPatchMode;
+    D3D12_GPU_BASED_VALIDATION_PIPELINE_STATE_CREATE_FLAGS PipelineStateCreateFlags;
+    } 	D3D12_DEBUG_DEVICE_GPU_BASED_VALIDATION_SETTINGS;
+
+typedef struct D3D12_DEBUG_DEVICE_GPU_SLOWDOWN_PERFORMANCE_FACTOR
+    {
+    FLOAT SlowdownFactor;
+    } 	D3D12_DEBUG_DEVICE_GPU_SLOWDOWN_PERFORMANCE_FACTOR;
+
+
+
+extern RPC_IF_HANDLE __MIDL_itf_d3d12sdklayers_0000_0007_v0_0_c_ifspec;
+extern RPC_IF_HANDLE __MIDL_itf_d3d12sdklayers_0000_0007_v0_0_s_ifspec;
+
+#ifndef __ID3D12DebugDevice1_INTERFACE_DEFINED__
+#define __ID3D12DebugDevice1_INTERFACE_DEFINED__
+
+/* interface ID3D12DebugDevice1 */
+/* [unique][local][object][uuid] */ 
+
+
+EXTERN_C const IID IID_ID3D12DebugDevice1;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("a9b71770-d099-4a65-a698-3dee10020f88")
+    ID3D12DebugDevice1 : public IUnknown
+    {
+    public:
+        virtual HRESULT STDMETHODCALLTYPE SetDebugParameter( 
+            D3D12_DEBUG_DEVICE_PARAMETER_TYPE Type,
+            _In_reads_bytes_(DataSize)  const void *pData,
+            UINT DataSize) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE GetDebugParameter( 
+            D3D12_DEBUG_DEVICE_PARAMETER_TYPE Type,
+            _Out_writes_bytes_(DataSize)  void *pData,
+            UINT DataSize) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE ReportLiveDeviceObjects( 
+            D3D12_RLDO_FLAGS Flags) = 0;
+        
+    };
+    
+    
+#else 	/* C style interface */
+
+    typedef struct ID3D12DebugDevice1Vtbl
+    {
+        BEGIN_INTERFACE
+        
+        DECLSPEC_XFGVIRT(IUnknown, QueryInterface)
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            ID3D12DebugDevice1 * This,
+            REFIID riid,
+            _COM_Outptr_  void **ppvObject);
+        
+        DECLSPEC_XFGVIRT(IUnknown, AddRef)
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            ID3D12DebugDevice1 * This);
+        
+        DECLSPEC_XFGVIRT(IUnknown, Release)
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            ID3D12DebugDevice1 * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12DebugDevice1, SetDebugParameter)
+        HRESULT ( STDMETHODCALLTYPE *SetDebugParameter )( 
+            ID3D12DebugDevice1 * This,
+            D3D12_DEBUG_DEVICE_PARAMETER_TYPE Type,
+            _In_reads_bytes_(DataSize)  const void *pData,
+            UINT DataSize);
+        
+        DECLSPEC_XFGVIRT(ID3D12DebugDevice1, GetDebugParameter)
+        HRESULT ( STDMETHODCALLTYPE *GetDebugParameter )( 
+            ID3D12DebugDevice1 * This,
+            D3D12_DEBUG_DEVICE_PARAMETER_TYPE Type,
+            _Out_writes_bytes_(DataSize)  void *pData,
+            UINT DataSize);
+        
+        DECLSPEC_XFGVIRT(ID3D12DebugDevice1, ReportLiveDeviceObjects)
+        HRESULT ( STDMETHODCALLTYPE *ReportLiveDeviceObjects )( 
+            ID3D12DebugDevice1 * This,
+            D3D12_RLDO_FLAGS Flags);
+        
+        END_INTERFACE
+    } ID3D12DebugDevice1Vtbl;
+
+    interface ID3D12DebugDevice1
+    {
+        CONST_VTBL struct ID3D12DebugDevice1Vtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define ID3D12DebugDevice1_QueryInterface(This,riid,ppvObject)	\
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define ID3D12DebugDevice1_AddRef(This)	\
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define ID3D12DebugDevice1_Release(This)	\
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#define ID3D12DebugDevice1_SetDebugParameter(This,Type,pData,DataSize)	\
+    ( (This)->lpVtbl -> SetDebugParameter(This,Type,pData,DataSize) ) 
+
+#define ID3D12DebugDevice1_GetDebugParameter(This,Type,pData,DataSize)	\
+    ( (This)->lpVtbl -> GetDebugParameter(This,Type,pData,DataSize) ) 
+
+#define ID3D12DebugDevice1_ReportLiveDeviceObjects(This,Flags)	\
+    ( (This)->lpVtbl -> ReportLiveDeviceObjects(This,Flags) ) 
+
+#endif /* COBJMACROS */
+
+
+#endif 	/* C style interface */
+
+
+
+
+#endif 	/* __ID3D12DebugDevice1_INTERFACE_DEFINED__ */
+
+
+#ifndef __ID3D12DebugDevice_INTERFACE_DEFINED__
+#define __ID3D12DebugDevice_INTERFACE_DEFINED__
+
+/* interface ID3D12DebugDevice */
+/* [unique][local][object][uuid] */ 
+
+
+EXTERN_C const IID IID_ID3D12DebugDevice;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("3febd6dd-4973-4787-8194-e45f9e28923e")
+    ID3D12DebugDevice : public IUnknown
+    {
+    public:
+        virtual HRESULT STDMETHODCALLTYPE SetFeatureMask( 
+            D3D12_DEBUG_FEATURE Mask) = 0;
+        
+        virtual D3D12_DEBUG_FEATURE STDMETHODCALLTYPE GetFeatureMask( void) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE ReportLiveDeviceObjects( 
+            D3D12_RLDO_FLAGS Flags) = 0;
+        
+    };
+    
+    
+#else 	/* C style interface */
+
+    typedef struct ID3D12DebugDeviceVtbl
+    {
+        BEGIN_INTERFACE
+        
+        DECLSPEC_XFGVIRT(IUnknown, QueryInterface)
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            ID3D12DebugDevice * This,
+            REFIID riid,
+            _COM_Outptr_  void **ppvObject);
+        
+        DECLSPEC_XFGVIRT(IUnknown, AddRef)
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            ID3D12DebugDevice * This);
+        
+        DECLSPEC_XFGVIRT(IUnknown, Release)
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            ID3D12DebugDevice * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12DebugDevice, SetFeatureMask)
+        HRESULT ( STDMETHODCALLTYPE *SetFeatureMask )( 
+            ID3D12DebugDevice * This,
+            D3D12_DEBUG_FEATURE Mask);
+        
+        DECLSPEC_XFGVIRT(ID3D12DebugDevice, GetFeatureMask)
+        D3D12_DEBUG_FEATURE ( STDMETHODCALLTYPE *GetFeatureMask )( 
+            ID3D12DebugDevice * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12DebugDevice, ReportLiveDeviceObjects)
+        HRESULT ( STDMETHODCALLTYPE *ReportLiveDeviceObjects )( 
+            ID3D12DebugDevice * This,
+            D3D12_RLDO_FLAGS Flags);
+        
+        END_INTERFACE
+    } ID3D12DebugDeviceVtbl;
+
+    interface ID3D12DebugDevice
+    {
+        CONST_VTBL struct ID3D12DebugDeviceVtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define ID3D12DebugDevice_QueryInterface(This,riid,ppvObject)	\
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define ID3D12DebugDevice_AddRef(This)	\
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define ID3D12DebugDevice_Release(This)	\
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#define ID3D12DebugDevice_SetFeatureMask(This,Mask)	\
+    ( (This)->lpVtbl -> SetFeatureMask(This,Mask) ) 
+
+#define ID3D12DebugDevice_GetFeatureMask(This)	\
+    ( (This)->lpVtbl -> GetFeatureMask(This) ) 
+
+#define ID3D12DebugDevice_ReportLiveDeviceObjects(This,Flags)	\
+    ( (This)->lpVtbl -> ReportLiveDeviceObjects(This,Flags) ) 
+
+#endif /* COBJMACROS */
+
+
+#endif 	/* C style interface */
+
+
+
+
+#endif 	/* __ID3D12DebugDevice_INTERFACE_DEFINED__ */
+
+
+#ifndef __ID3D12DebugDevice2_INTERFACE_DEFINED__
+#define __ID3D12DebugDevice2_INTERFACE_DEFINED__
+
+/* interface ID3D12DebugDevice2 */
+/* [unique][local][object][uuid] */ 
+
+
+EXTERN_C const IID IID_ID3D12DebugDevice2;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("60eccbc1-378d-4df1-894c-f8ac5ce4d7dd")
+    ID3D12DebugDevice2 : public ID3D12DebugDevice
+    {
+    public:
+        virtual HRESULT STDMETHODCALLTYPE SetDebugParameter( 
+            D3D12_DEBUG_DEVICE_PARAMETER_TYPE Type,
+            _In_reads_bytes_(DataSize)  const void *pData,
+            UINT DataSize) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE GetDebugParameter( 
+            D3D12_DEBUG_DEVICE_PARAMETER_TYPE Type,
+            _Out_writes_bytes_(DataSize)  void *pData,
+            UINT DataSize) = 0;
+        
+    };
+    
+    
+#else 	/* C style interface */
+
+    typedef struct ID3D12DebugDevice2Vtbl
+    {
+        BEGIN_INTERFACE
+        
+        DECLSPEC_XFGVIRT(IUnknown, QueryInterface)
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            ID3D12DebugDevice2 * This,
+            REFIID riid,
+            _COM_Outptr_  void **ppvObject);
+        
+        DECLSPEC_XFGVIRT(IUnknown, AddRef)
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            ID3D12DebugDevice2 * This);
+        
+        DECLSPEC_XFGVIRT(IUnknown, Release)
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            ID3D12DebugDevice2 * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12DebugDevice, SetFeatureMask)
+        HRESULT ( STDMETHODCALLTYPE *SetFeatureMask )( 
+            ID3D12DebugDevice2 * This,
+            D3D12_DEBUG_FEATURE Mask);
+        
+        DECLSPEC_XFGVIRT(ID3D12DebugDevice, GetFeatureMask)
+        D3D12_DEBUG_FEATURE ( STDMETHODCALLTYPE *GetFeatureMask )( 
+            ID3D12DebugDevice2 * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12DebugDevice, ReportLiveDeviceObjects)
+        HRESULT ( STDMETHODCALLTYPE *ReportLiveDeviceObjects )( 
+            ID3D12DebugDevice2 * This,
+            D3D12_RLDO_FLAGS Flags);
+        
+        DECLSPEC_XFGVIRT(ID3D12DebugDevice2, SetDebugParameter)
+        HRESULT ( STDMETHODCALLTYPE *SetDebugParameter )( 
+            ID3D12DebugDevice2 * This,
+            D3D12_DEBUG_DEVICE_PARAMETER_TYPE Type,
+            _In_reads_bytes_(DataSize)  const void *pData,
+            UINT DataSize);
+        
+        DECLSPEC_XFGVIRT(ID3D12DebugDevice2, GetDebugParameter)
+        HRESULT ( STDMETHODCALLTYPE *GetDebugParameter )( 
+            ID3D12DebugDevice2 * This,
+            D3D12_DEBUG_DEVICE_PARAMETER_TYPE Type,
+            _Out_writes_bytes_(DataSize)  void *pData,
+            UINT DataSize);
+        
+        END_INTERFACE
+    } ID3D12DebugDevice2Vtbl;
+
+    interface ID3D12DebugDevice2
+    {
+        CONST_VTBL struct ID3D12DebugDevice2Vtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define ID3D12DebugDevice2_QueryInterface(This,riid,ppvObject)	\
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define ID3D12DebugDevice2_AddRef(This)	\
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define ID3D12DebugDevice2_Release(This)	\
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#define ID3D12DebugDevice2_SetFeatureMask(This,Mask)	\
+    ( (This)->lpVtbl -> SetFeatureMask(This,Mask) ) 
+
+#define ID3D12DebugDevice2_GetFeatureMask(This)	\
+    ( (This)->lpVtbl -> GetFeatureMask(This) ) 
+
+#define ID3D12DebugDevice2_ReportLiveDeviceObjects(This,Flags)	\
+    ( (This)->lpVtbl -> ReportLiveDeviceObjects(This,Flags) ) 
+
+
+#define ID3D12DebugDevice2_SetDebugParameter(This,Type,pData,DataSize)	\
+    ( (This)->lpVtbl -> SetDebugParameter(This,Type,pData,DataSize) ) 
+
+#define ID3D12DebugDevice2_GetDebugParameter(This,Type,pData,DataSize)	\
+    ( (This)->lpVtbl -> GetDebugParameter(This,Type,pData,DataSize) ) 
+
+#endif /* COBJMACROS */
+
+
+#endif 	/* C style interface */
+
+
+
+
+#endif 	/* __ID3D12DebugDevice2_INTERFACE_DEFINED__ */
+
+
+/* interface __MIDL_itf_d3d12sdklayers_0000_0010 */
+/* [local] */ 
+
+DEFINE_GUID(DXGI_DEBUG_D3D12, 0xcf59a98c, 0xa950, 0x4326, 0x91, 0xef, 0x9b, 0xba, 0xa1, 0x7b, 0xfd, 0x95);
+
+
+extern RPC_IF_HANDLE __MIDL_itf_d3d12sdklayers_0000_0010_v0_0_c_ifspec;
+extern RPC_IF_HANDLE __MIDL_itf_d3d12sdklayers_0000_0010_v0_0_s_ifspec;
+
+#ifndef __ID3D12DebugCommandQueue_INTERFACE_DEFINED__
+#define __ID3D12DebugCommandQueue_INTERFACE_DEFINED__
+
+/* interface ID3D12DebugCommandQueue */
+/* [unique][local][object][uuid] */ 
+
+
+EXTERN_C const IID IID_ID3D12DebugCommandQueue;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("09e0bf36-54ac-484f-8847-4baeeab6053a")
+    ID3D12DebugCommandQueue : public IUnknown
+    {
+    public:
+        virtual BOOL STDMETHODCALLTYPE AssertResourceState( 
+            _In_  ID3D12Resource *pResource,
+            UINT Subresource,
+            UINT State) = 0;
+        
+    };
+    
+    
+#else 	/* C style interface */
+
+    typedef struct ID3D12DebugCommandQueueVtbl
+    {
+        BEGIN_INTERFACE
+        
+        DECLSPEC_XFGVIRT(IUnknown, QueryInterface)
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            ID3D12DebugCommandQueue * This,
+            REFIID riid,
+            _COM_Outptr_  void **ppvObject);
+        
+        DECLSPEC_XFGVIRT(IUnknown, AddRef)
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            ID3D12DebugCommandQueue * This);
+        
+        DECLSPEC_XFGVIRT(IUnknown, Release)
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            ID3D12DebugCommandQueue * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12DebugCommandQueue, AssertResourceState)
+        BOOL ( STDMETHODCALLTYPE *AssertResourceState )( 
+            ID3D12DebugCommandQueue * This,
+            _In_  ID3D12Resource *pResource,
+            UINT Subresource,
+            UINT State);
+        
+        END_INTERFACE
+    } ID3D12DebugCommandQueueVtbl;
+
+    interface ID3D12DebugCommandQueue
+    {
+        CONST_VTBL struct ID3D12DebugCommandQueueVtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define ID3D12DebugCommandQueue_QueryInterface(This,riid,ppvObject)	\
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define ID3D12DebugCommandQueue_AddRef(This)	\
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define ID3D12DebugCommandQueue_Release(This)	\
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#define ID3D12DebugCommandQueue_AssertResourceState(This,pResource,Subresource,State)	\
+    ( (This)->lpVtbl -> AssertResourceState(This,pResource,Subresource,State) ) 
+
+#endif /* COBJMACROS */
+
+
+#endif 	/* C style interface */
+
+
+
+
+#endif 	/* __ID3D12DebugCommandQueue_INTERFACE_DEFINED__ */
+
+
+#ifndef __ID3D12DebugCommandQueue1_INTERFACE_DEFINED__
+#define __ID3D12DebugCommandQueue1_INTERFACE_DEFINED__
+
+/* interface ID3D12DebugCommandQueue1 */
+/* [unique][local][object][uuid] */ 
+
+
+EXTERN_C const IID IID_ID3D12DebugCommandQueue1;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("16be35a2-bfd6-49f2-bcae-eaae4aff862d")
+    ID3D12DebugCommandQueue1 : public ID3D12DebugCommandQueue
+    {
+    public:
+        virtual void STDMETHODCALLTYPE AssertResourceAccess( 
+            _In_  ID3D12Resource *pResource,
+            UINT Subresource,
+            D3D12_BARRIER_ACCESS Access) = 0;
+        
+        virtual void STDMETHODCALLTYPE AssertTextureLayout( 
+            _In_  ID3D12Resource *pResource,
+            UINT Subresource,
+            D3D12_BARRIER_LAYOUT Layout) = 0;
+        
+    };
+    
+    
+#else 	/* C style interface */
+
+    typedef struct ID3D12DebugCommandQueue1Vtbl
+    {
+        BEGIN_INTERFACE
+        
+        DECLSPEC_XFGVIRT(IUnknown, QueryInterface)
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            ID3D12DebugCommandQueue1 * This,
+            REFIID riid,
+            _COM_Outptr_  void **ppvObject);
+        
+        DECLSPEC_XFGVIRT(IUnknown, AddRef)
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            ID3D12DebugCommandQueue1 * This);
+        
+        DECLSPEC_XFGVIRT(IUnknown, Release)
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            ID3D12DebugCommandQueue1 * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12DebugCommandQueue, AssertResourceState)
+        BOOL ( STDMETHODCALLTYPE *AssertResourceState )( 
+            ID3D12DebugCommandQueue1 * This,
+            _In_  ID3D12Resource *pResource,
+            UINT Subresource,
+            UINT State);
+        
+        DECLSPEC_XFGVIRT(ID3D12DebugCommandQueue1, AssertResourceAccess)
+        void ( STDMETHODCALLTYPE *AssertResourceAccess )( 
+            ID3D12DebugCommandQueue1 * This,
+            _In_  ID3D12Resource *pResource,
+            UINT Subresource,
+            D3D12_BARRIER_ACCESS Access);
+        
+        DECLSPEC_XFGVIRT(ID3D12DebugCommandQueue1, AssertTextureLayout)
+        void ( STDMETHODCALLTYPE *AssertTextureLayout )( 
+            ID3D12DebugCommandQueue1 * This,
+            _In_  ID3D12Resource *pResource,
+            UINT Subresource,
+            D3D12_BARRIER_LAYOUT Layout);
+        
+        END_INTERFACE
+    } ID3D12DebugCommandQueue1Vtbl;
+
+    interface ID3D12DebugCommandQueue1
+    {
+        CONST_VTBL struct ID3D12DebugCommandQueue1Vtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define ID3D12DebugCommandQueue1_QueryInterface(This,riid,ppvObject)	\
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define ID3D12DebugCommandQueue1_AddRef(This)	\
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define ID3D12DebugCommandQueue1_Release(This)	\
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#define ID3D12DebugCommandQueue1_AssertResourceState(This,pResource,Subresource,State)	\
+    ( (This)->lpVtbl -> AssertResourceState(This,pResource,Subresource,State) ) 
+
+
+#define ID3D12DebugCommandQueue1_AssertResourceAccess(This,pResource,Subresource,Access)	\
+    ( (This)->lpVtbl -> AssertResourceAccess(This,pResource,Subresource,Access) ) 
+
+#define ID3D12DebugCommandQueue1_AssertTextureLayout(This,pResource,Subresource,Layout)	\
+    ( (This)->lpVtbl -> AssertTextureLayout(This,pResource,Subresource,Layout) ) 
+
+#endif /* COBJMACROS */
+
+
+#endif 	/* C style interface */
+
+
+
+
+#endif 	/* __ID3D12DebugCommandQueue1_INTERFACE_DEFINED__ */
+
+
+/* interface __MIDL_itf_d3d12sdklayers_0000_0012 */
+/* [local] */ 
+
+typedef 
+enum D3D12_DEBUG_COMMAND_LIST_PARAMETER_TYPE
+    {
+        D3D12_DEBUG_COMMAND_LIST_PARAMETER_GPU_BASED_VALIDATION_SETTINGS	= 0
+    } 	D3D12_DEBUG_COMMAND_LIST_PARAMETER_TYPE;
+
+typedef struct D3D12_DEBUG_COMMAND_LIST_GPU_BASED_VALIDATION_SETTINGS
+    {
+    D3D12_GPU_BASED_VALIDATION_SHADER_PATCH_MODE ShaderPatchMode;
+    } 	D3D12_DEBUG_COMMAND_LIST_GPU_BASED_VALIDATION_SETTINGS;
+
+
+
+extern RPC_IF_HANDLE __MIDL_itf_d3d12sdklayers_0000_0012_v0_0_c_ifspec;
+extern RPC_IF_HANDLE __MIDL_itf_d3d12sdklayers_0000_0012_v0_0_s_ifspec;
+
+#ifndef __ID3D12DebugCommandList1_INTERFACE_DEFINED__
+#define __ID3D12DebugCommandList1_INTERFACE_DEFINED__
+
+/* interface ID3D12DebugCommandList1 */
+/* [unique][local][object][uuid] */ 
+
+
+EXTERN_C const IID IID_ID3D12DebugCommandList1;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("102ca951-311b-4b01-b11f-ecb83e061b37")
+    ID3D12DebugCommandList1 : public IUnknown
+    {
+    public:
+        virtual BOOL STDMETHODCALLTYPE AssertResourceState( 
+            _In_  ID3D12Resource *pResource,
+            UINT Subresource,
+            UINT State) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE SetDebugParameter( 
+            D3D12_DEBUG_COMMAND_LIST_PARAMETER_TYPE Type,
+            _In_reads_bytes_(DataSize)  const void *pData,
+            UINT DataSize) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE GetDebugParameter( 
+            D3D12_DEBUG_COMMAND_LIST_PARAMETER_TYPE Type,
+            _Out_writes_bytes_(DataSize)  void *pData,
+            UINT DataSize) = 0;
+        
+    };
+    
+    
+#else 	/* C style interface */
+
+    typedef struct ID3D12DebugCommandList1Vtbl
+    {
+        BEGIN_INTERFACE
+        
+        DECLSPEC_XFGVIRT(IUnknown, QueryInterface)
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            ID3D12DebugCommandList1 * This,
+            REFIID riid,
+            _COM_Outptr_  void **ppvObject);
+        
+        DECLSPEC_XFGVIRT(IUnknown, AddRef)
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            ID3D12DebugCommandList1 * This);
+        
+        DECLSPEC_XFGVIRT(IUnknown, Release)
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            ID3D12DebugCommandList1 * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12DebugCommandList1, AssertResourceState)
+        BOOL ( STDMETHODCALLTYPE *AssertResourceState )( 
+            ID3D12DebugCommandList1 * This,
+            _In_  ID3D12Resource *pResource,
+            UINT Subresource,
+            UINT State);
+        
+        DECLSPEC_XFGVIRT(ID3D12DebugCommandList1, SetDebugParameter)
+        HRESULT ( STDMETHODCALLTYPE *SetDebugParameter )( 
+            ID3D12DebugCommandList1 * This,
+            D3D12_DEBUG_COMMAND_LIST_PARAMETER_TYPE Type,
+            _In_reads_bytes_(DataSize)  const void *pData,
+            UINT DataSize);
+        
+        DECLSPEC_XFGVIRT(ID3D12DebugCommandList1, GetDebugParameter)
+        HRESULT ( STDMETHODCALLTYPE *GetDebugParameter )( 
+            ID3D12DebugCommandList1 * This,
+            D3D12_DEBUG_COMMAND_LIST_PARAMETER_TYPE Type,
+            _Out_writes_bytes_(DataSize)  void *pData,
+            UINT DataSize);
+        
+        END_INTERFACE
+    } ID3D12DebugCommandList1Vtbl;
+
+    interface ID3D12DebugCommandList1
+    {
+        CONST_VTBL struct ID3D12DebugCommandList1Vtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define ID3D12DebugCommandList1_QueryInterface(This,riid,ppvObject)	\
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define ID3D12DebugCommandList1_AddRef(This)	\
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define ID3D12DebugCommandList1_Release(This)	\
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#define ID3D12DebugCommandList1_AssertResourceState(This,pResource,Subresource,State)	\
+    ( (This)->lpVtbl -> AssertResourceState(This,pResource,Subresource,State) ) 
+
+#define ID3D12DebugCommandList1_SetDebugParameter(This,Type,pData,DataSize)	\
+    ( (This)->lpVtbl -> SetDebugParameter(This,Type,pData,DataSize) ) 
+
+#define ID3D12DebugCommandList1_GetDebugParameter(This,Type,pData,DataSize)	\
+    ( (This)->lpVtbl -> GetDebugParameter(This,Type,pData,DataSize) ) 
+
+#endif /* COBJMACROS */
+
+
+#endif 	/* C style interface */
+
+
+
+
+#endif 	/* __ID3D12DebugCommandList1_INTERFACE_DEFINED__ */
+
+
+#ifndef __ID3D12DebugCommandList_INTERFACE_DEFINED__
+#define __ID3D12DebugCommandList_INTERFACE_DEFINED__
+
+/* interface ID3D12DebugCommandList */
+/* [unique][local][object][uuid] */ 
+
+
+EXTERN_C const IID IID_ID3D12DebugCommandList;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("09e0bf36-54ac-484f-8847-4baeeab6053f")
+    ID3D12DebugCommandList : public IUnknown
+    {
+    public:
+        virtual BOOL STDMETHODCALLTYPE AssertResourceState( 
+            _In_  ID3D12Resource *pResource,
+            UINT Subresource,
+            UINT State) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE SetFeatureMask( 
+            D3D12_DEBUG_FEATURE Mask) = 0;
+        
+        virtual D3D12_DEBUG_FEATURE STDMETHODCALLTYPE GetFeatureMask( void) = 0;
+        
+    };
+    
+    
+#else 	/* C style interface */
+
+    typedef struct ID3D12DebugCommandListVtbl
+    {
+        BEGIN_INTERFACE
+        
+        DECLSPEC_XFGVIRT(IUnknown, QueryInterface)
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            ID3D12DebugCommandList * This,
+            REFIID riid,
+            _COM_Outptr_  void **ppvObject);
+        
+        DECLSPEC_XFGVIRT(IUnknown, AddRef)
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            ID3D12DebugCommandList * This);
+        
+        DECLSPEC_XFGVIRT(IUnknown, Release)
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            ID3D12DebugCommandList * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12DebugCommandList, AssertResourceState)
+        BOOL ( STDMETHODCALLTYPE *AssertResourceState )( 
+            ID3D12DebugCommandList * This,
+            _In_  ID3D12Resource *pResource,
+            UINT Subresource,
+            UINT State);
+        
+        DECLSPEC_XFGVIRT(ID3D12DebugCommandList, SetFeatureMask)
+        HRESULT ( STDMETHODCALLTYPE *SetFeatureMask )( 
+            ID3D12DebugCommandList * This,
+            D3D12_DEBUG_FEATURE Mask);
+        
+        DECLSPEC_XFGVIRT(ID3D12DebugCommandList, GetFeatureMask)
+        D3D12_DEBUG_FEATURE ( STDMETHODCALLTYPE *GetFeatureMask )( 
+            ID3D12DebugCommandList * This);
+        
+        END_INTERFACE
+    } ID3D12DebugCommandListVtbl;
+
+    interface ID3D12DebugCommandList
+    {
+        CONST_VTBL struct ID3D12DebugCommandListVtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define ID3D12DebugCommandList_QueryInterface(This,riid,ppvObject)	\
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define ID3D12DebugCommandList_AddRef(This)	\
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define ID3D12DebugCommandList_Release(This)	\
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#define ID3D12DebugCommandList_AssertResourceState(This,pResource,Subresource,State)	\
+    ( (This)->lpVtbl -> AssertResourceState(This,pResource,Subresource,State) ) 
+
+#define ID3D12DebugCommandList_SetFeatureMask(This,Mask)	\
+    ( (This)->lpVtbl -> SetFeatureMask(This,Mask) ) 
+
+#define ID3D12DebugCommandList_GetFeatureMask(This)	\
+    ( (This)->lpVtbl -> GetFeatureMask(This) ) 
+
+#endif /* COBJMACROS */
+
+
+#endif 	/* C style interface */
+
+
+
+
+#endif 	/* __ID3D12DebugCommandList_INTERFACE_DEFINED__ */
+
+
+#ifndef __ID3D12DebugCommandList2_INTERFACE_DEFINED__
+#define __ID3D12DebugCommandList2_INTERFACE_DEFINED__
+
+/* interface ID3D12DebugCommandList2 */
+/* [unique][local][object][uuid] */ 
+
+
+EXTERN_C const IID IID_ID3D12DebugCommandList2;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("aeb575cf-4e06-48be-ba3b-c450fc96652e")
+    ID3D12DebugCommandList2 : public ID3D12DebugCommandList
+    {
+    public:
+        virtual HRESULT STDMETHODCALLTYPE SetDebugParameter( 
+            D3D12_DEBUG_COMMAND_LIST_PARAMETER_TYPE Type,
+            _In_reads_bytes_(DataSize)  const void *pData,
+            UINT DataSize) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE GetDebugParameter( 
+            D3D12_DEBUG_COMMAND_LIST_PARAMETER_TYPE Type,
+            _Out_writes_bytes_(DataSize)  void *pData,
+            UINT DataSize) = 0;
+        
+    };
+    
+    
+#else 	/* C style interface */
+
+    typedef struct ID3D12DebugCommandList2Vtbl
+    {
+        BEGIN_INTERFACE
+        
+        DECLSPEC_XFGVIRT(IUnknown, QueryInterface)
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            ID3D12DebugCommandList2 * This,
+            REFIID riid,
+            _COM_Outptr_  void **ppvObject);
+        
+        DECLSPEC_XFGVIRT(IUnknown, AddRef)
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            ID3D12DebugCommandList2 * This);
+        
+        DECLSPEC_XFGVIRT(IUnknown, Release)
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            ID3D12DebugCommandList2 * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12DebugCommandList, AssertResourceState)
+        BOOL ( STDMETHODCALLTYPE *AssertResourceState )( 
+            ID3D12DebugCommandList2 * This,
+            _In_  ID3D12Resource *pResource,
+            UINT Subresource,
+            UINT State);
+        
+        DECLSPEC_XFGVIRT(ID3D12DebugCommandList, SetFeatureMask)
+        HRESULT ( STDMETHODCALLTYPE *SetFeatureMask )( 
+            ID3D12DebugCommandList2 * This,
+            D3D12_DEBUG_FEATURE Mask);
+        
+        DECLSPEC_XFGVIRT(ID3D12DebugCommandList, GetFeatureMask)
+        D3D12_DEBUG_FEATURE ( STDMETHODCALLTYPE *GetFeatureMask )( 
+            ID3D12DebugCommandList2 * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12DebugCommandList2, SetDebugParameter)
+        HRESULT ( STDMETHODCALLTYPE *SetDebugParameter )( 
+            ID3D12DebugCommandList2 * This,
+            D3D12_DEBUG_COMMAND_LIST_PARAMETER_TYPE Type,
+            _In_reads_bytes_(DataSize)  const void *pData,
+            UINT DataSize);
+        
+        DECLSPEC_XFGVIRT(ID3D12DebugCommandList2, GetDebugParameter)
+        HRESULT ( STDMETHODCALLTYPE *GetDebugParameter )( 
+            ID3D12DebugCommandList2 * This,
+            D3D12_DEBUG_COMMAND_LIST_PARAMETER_TYPE Type,
+            _Out_writes_bytes_(DataSize)  void *pData,
+            UINT DataSize);
+        
+        END_INTERFACE
+    } ID3D12DebugCommandList2Vtbl;
+
+    interface ID3D12DebugCommandList2
+    {
+        CONST_VTBL struct ID3D12DebugCommandList2Vtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define ID3D12DebugCommandList2_QueryInterface(This,riid,ppvObject)	\
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define ID3D12DebugCommandList2_AddRef(This)	\
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define ID3D12DebugCommandList2_Release(This)	\
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#define ID3D12DebugCommandList2_AssertResourceState(This,pResource,Subresource,State)	\
+    ( (This)->lpVtbl -> AssertResourceState(This,pResource,Subresource,State) ) 
+
+#define ID3D12DebugCommandList2_SetFeatureMask(This,Mask)	\
+    ( (This)->lpVtbl -> SetFeatureMask(This,Mask) ) 
+
+#define ID3D12DebugCommandList2_GetFeatureMask(This)	\
+    ( (This)->lpVtbl -> GetFeatureMask(This) ) 
+
+
+#define ID3D12DebugCommandList2_SetDebugParameter(This,Type,pData,DataSize)	\
+    ( (This)->lpVtbl -> SetDebugParameter(This,Type,pData,DataSize) ) 
+
+#define ID3D12DebugCommandList2_GetDebugParameter(This,Type,pData,DataSize)	\
+    ( (This)->lpVtbl -> GetDebugParameter(This,Type,pData,DataSize) ) 
+
+#endif /* COBJMACROS */
+
+
+#endif 	/* C style interface */
+
+
+
+
+#endif 	/* __ID3D12DebugCommandList2_INTERFACE_DEFINED__ */
+
+
+#ifndef __ID3D12DebugCommandList3_INTERFACE_DEFINED__
+#define __ID3D12DebugCommandList3_INTERFACE_DEFINED__
+
+/* interface ID3D12DebugCommandList3 */
+/* [unique][local][object][uuid] */ 
+
+
+EXTERN_C const IID IID_ID3D12DebugCommandList3;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("197d5e15-4d37-4d34-af78-724cd70fdb1f")
+    ID3D12DebugCommandList3 : public ID3D12DebugCommandList2
+    {
+    public:
+        virtual void STDMETHODCALLTYPE AssertResourceAccess( 
+            _In_  ID3D12Resource *pResource,
+            UINT Subresource,
+            D3D12_BARRIER_ACCESS Access) = 0;
+        
+        virtual void STDMETHODCALLTYPE AssertTextureLayout( 
+            _In_  ID3D12Resource *pResource,
+            UINT Subresource,
+            D3D12_BARRIER_LAYOUT Layout) = 0;
+        
+    };
+    
+    
+#else 	/* C style interface */
+
+    typedef struct ID3D12DebugCommandList3Vtbl
+    {
+        BEGIN_INTERFACE
+        
+        DECLSPEC_XFGVIRT(IUnknown, QueryInterface)
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            ID3D12DebugCommandList3 * This,
+            REFIID riid,
+            _COM_Outptr_  void **ppvObject);
+        
+        DECLSPEC_XFGVIRT(IUnknown, AddRef)
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            ID3D12DebugCommandList3 * This);
+        
+        DECLSPEC_XFGVIRT(IUnknown, Release)
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            ID3D12DebugCommandList3 * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12DebugCommandList, AssertResourceState)
+        BOOL ( STDMETHODCALLTYPE *AssertResourceState )( 
+            ID3D12DebugCommandList3 * This,
+            _In_  ID3D12Resource *pResource,
+            UINT Subresource,
+            UINT State);
+        
+        DECLSPEC_XFGVIRT(ID3D12DebugCommandList, SetFeatureMask)
+        HRESULT ( STDMETHODCALLTYPE *SetFeatureMask )( 
+            ID3D12DebugCommandList3 * This,
+            D3D12_DEBUG_FEATURE Mask);
+        
+        DECLSPEC_XFGVIRT(ID3D12DebugCommandList, GetFeatureMask)
+        D3D12_DEBUG_FEATURE ( STDMETHODCALLTYPE *GetFeatureMask )( 
+            ID3D12DebugCommandList3 * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12DebugCommandList2, SetDebugParameter)
+        HRESULT ( STDMETHODCALLTYPE *SetDebugParameter )( 
+            ID3D12DebugCommandList3 * This,
+            D3D12_DEBUG_COMMAND_LIST_PARAMETER_TYPE Type,
+            _In_reads_bytes_(DataSize)  const void *pData,
+            UINT DataSize);
+        
+        DECLSPEC_XFGVIRT(ID3D12DebugCommandList2, GetDebugParameter)
+        HRESULT ( STDMETHODCALLTYPE *GetDebugParameter )( 
+            ID3D12DebugCommandList3 * This,
+            D3D12_DEBUG_COMMAND_LIST_PARAMETER_TYPE Type,
+            _Out_writes_bytes_(DataSize)  void *pData,
+            UINT DataSize);
+        
+        DECLSPEC_XFGVIRT(ID3D12DebugCommandList3, AssertResourceAccess)
+        void ( STDMETHODCALLTYPE *AssertResourceAccess )( 
+            ID3D12DebugCommandList3 * This,
+            _In_  ID3D12Resource *pResource,
+            UINT Subresource,
+            D3D12_BARRIER_ACCESS Access);
+        
+        DECLSPEC_XFGVIRT(ID3D12DebugCommandList3, AssertTextureLayout)
+        void ( STDMETHODCALLTYPE *AssertTextureLayout )( 
+            ID3D12DebugCommandList3 * This,
+            _In_  ID3D12Resource *pResource,
+            UINT Subresource,
+            D3D12_BARRIER_LAYOUT Layout);
+        
+        END_INTERFACE
+    } ID3D12DebugCommandList3Vtbl;
+
+    interface ID3D12DebugCommandList3
+    {
+        CONST_VTBL struct ID3D12DebugCommandList3Vtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define ID3D12DebugCommandList3_QueryInterface(This,riid,ppvObject)	\
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define ID3D12DebugCommandList3_AddRef(This)	\
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define ID3D12DebugCommandList3_Release(This)	\
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#define ID3D12DebugCommandList3_AssertResourceState(This,pResource,Subresource,State)	\
+    ( (This)->lpVtbl -> AssertResourceState(This,pResource,Subresource,State) ) 
+
+#define ID3D12DebugCommandList3_SetFeatureMask(This,Mask)	\
+    ( (This)->lpVtbl -> SetFeatureMask(This,Mask) ) 
+
+#define ID3D12DebugCommandList3_GetFeatureMask(This)	\
+    ( (This)->lpVtbl -> GetFeatureMask(This) ) 
+
+
+#define ID3D12DebugCommandList3_SetDebugParameter(This,Type,pData,DataSize)	\
+    ( (This)->lpVtbl -> SetDebugParameter(This,Type,pData,DataSize) ) 
+
+#define ID3D12DebugCommandList3_GetDebugParameter(This,Type,pData,DataSize)	\
+    ( (This)->lpVtbl -> GetDebugParameter(This,Type,pData,DataSize) ) 
+
+
+#define ID3D12DebugCommandList3_AssertResourceAccess(This,pResource,Subresource,Access)	\
+    ( (This)->lpVtbl -> AssertResourceAccess(This,pResource,Subresource,Access) ) 
+
+#define ID3D12DebugCommandList3_AssertTextureLayout(This,pResource,Subresource,Layout)	\
+    ( (This)->lpVtbl -> AssertTextureLayout(This,pResource,Subresource,Layout) ) 
+
+#endif /* COBJMACROS */
+
+
+#endif 	/* C style interface */
+
+
+
+
+#endif 	/* __ID3D12DebugCommandList3_INTERFACE_DEFINED__ */
+
+
+#ifndef __ID3D12SharingContract_INTERFACE_DEFINED__
+#define __ID3D12SharingContract_INTERFACE_DEFINED__
+
+/* interface ID3D12SharingContract */
+/* [unique][local][object][uuid] */ 
+
+
+EXTERN_C const IID IID_ID3D12SharingContract;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("0adf7d52-929c-4e61-addb-ffed30de66ef")
+    ID3D12SharingContract : public IUnknown
+    {
+    public:
+        virtual void STDMETHODCALLTYPE Present( 
+            _In_  ID3D12Resource *pResource,
+            UINT Subresource,
+            _In_  HWND window) = 0;
+        
+        virtual void STDMETHODCALLTYPE SharedFenceSignal( 
+            _In_  ID3D12Fence *pFence,
+            UINT64 FenceValue) = 0;
+        
+        virtual void STDMETHODCALLTYPE BeginCapturableWork( 
+            _In_  REFGUID guid) = 0;
+        
+        virtual void STDMETHODCALLTYPE EndCapturableWork( 
+            _In_  REFGUID guid) = 0;
+        
+    };
+    
+    
+#else 	/* C style interface */
+
+    typedef struct ID3D12SharingContractVtbl
+    {
+        BEGIN_INTERFACE
+        
+        DECLSPEC_XFGVIRT(IUnknown, QueryInterface)
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            ID3D12SharingContract * This,
+            REFIID riid,
+            _COM_Outptr_  void **ppvObject);
+        
+        DECLSPEC_XFGVIRT(IUnknown, AddRef)
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            ID3D12SharingContract * This);
+        
+        DECLSPEC_XFGVIRT(IUnknown, Release)
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            ID3D12SharingContract * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12SharingContract, Present)
+        void ( STDMETHODCALLTYPE *Present )( 
+            ID3D12SharingContract * This,
+            _In_  ID3D12Resource *pResource,
+            UINT Subresource,
+            _In_  HWND window);
+        
+        DECLSPEC_XFGVIRT(ID3D12SharingContract, SharedFenceSignal)
+        void ( STDMETHODCALLTYPE *SharedFenceSignal )( 
+            ID3D12SharingContract * This,
+            _In_  ID3D12Fence *pFence,
+            UINT64 FenceValue);
+        
+        DECLSPEC_XFGVIRT(ID3D12SharingContract, BeginCapturableWork)
+        void ( STDMETHODCALLTYPE *BeginCapturableWork )( 
+            ID3D12SharingContract * This,
+            _In_  REFGUID guid);
+        
+        DECLSPEC_XFGVIRT(ID3D12SharingContract, EndCapturableWork)
+        void ( STDMETHODCALLTYPE *EndCapturableWork )( 
+            ID3D12SharingContract * This,
+            _In_  REFGUID guid);
+        
+        END_INTERFACE
+    } ID3D12SharingContractVtbl;
+
+    interface ID3D12SharingContract
+    {
+        CONST_VTBL struct ID3D12SharingContractVtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define ID3D12SharingContract_QueryInterface(This,riid,ppvObject)	\
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define ID3D12SharingContract_AddRef(This)	\
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define ID3D12SharingContract_Release(This)	\
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#define ID3D12SharingContract_Present(This,pResource,Subresource,window)	\
+    ( (This)->lpVtbl -> Present(This,pResource,Subresource,window) ) 
+
+#define ID3D12SharingContract_SharedFenceSignal(This,pFence,FenceValue)	\
+    ( (This)->lpVtbl -> SharedFenceSignal(This,pFence,FenceValue) ) 
+
+#define ID3D12SharingContract_BeginCapturableWork(This,guid)	\
+    ( (This)->lpVtbl -> BeginCapturableWork(This,guid) ) 
+
+#define ID3D12SharingContract_EndCapturableWork(This,guid)	\
+    ( (This)->lpVtbl -> EndCapturableWork(This,guid) ) 
+
+#endif /* COBJMACROS */
+
+
+#endif 	/* C style interface */
+
+
+
+
+#endif 	/* __ID3D12SharingContract_INTERFACE_DEFINED__ */
+
+
+/* interface __MIDL_itf_d3d12sdklayers_0000_0017 */
+/* [local] */ 
+
+typedef 
+enum D3D12_MESSAGE_CATEGORY
+    {
+        D3D12_MESSAGE_CATEGORY_APPLICATION_DEFINED	= 0,
+        D3D12_MESSAGE_CATEGORY_MISCELLANEOUS	= ( D3D12_MESSAGE_CATEGORY_APPLICATION_DEFINED + 1 ) ,
+        D3D12_MESSAGE_CATEGORY_INITIALIZATION	= ( D3D12_MESSAGE_CATEGORY_MISCELLANEOUS + 1 ) ,
+        D3D12_MESSAGE_CATEGORY_CLEANUP	= ( D3D12_MESSAGE_CATEGORY_INITIALIZATION + 1 ) ,
+        D3D12_MESSAGE_CATEGORY_COMPILATION	= ( D3D12_MESSAGE_CATEGORY_CLEANUP + 1 ) ,
+        D3D12_MESSAGE_CATEGORY_STATE_CREATION	= ( D3D12_MESSAGE_CATEGORY_COMPILATION + 1 ) ,
+        D3D12_MESSAGE_CATEGORY_STATE_SETTING	= ( D3D12_MESSAGE_CATEGORY_STATE_CREATION + 1 ) ,
+        D3D12_MESSAGE_CATEGORY_STATE_GETTING	= ( D3D12_MESSAGE_CATEGORY_STATE_SETTING + 1 ) ,
+        D3D12_MESSAGE_CATEGORY_RESOURCE_MANIPULATION	= ( D3D12_MESSAGE_CATEGORY_STATE_GETTING + 1 ) ,
+        D3D12_MESSAGE_CATEGORY_EXECUTION	= ( D3D12_MESSAGE_CATEGORY_RESOURCE_MANIPULATION + 1 ) ,
+        D3D12_MESSAGE_CATEGORY_SHADER	= ( D3D12_MESSAGE_CATEGORY_EXECUTION + 1 ) 
+    } 	D3D12_MESSAGE_CATEGORY;
+
+typedef 
+enum D3D12_MESSAGE_SEVERITY
+    {
+        D3D12_MESSAGE_SEVERITY_CORRUPTION	= 0,
+        D3D12_MESSAGE_SEVERITY_ERROR	= ( D3D12_MESSAGE_SEVERITY_CORRUPTION + 1 ) ,
+        D3D12_MESSAGE_SEVERITY_WARNING	= ( D3D12_MESSAGE_SEVERITY_ERROR + 1 ) ,
+        D3D12_MESSAGE_SEVERITY_INFO	= ( D3D12_MESSAGE_SEVERITY_WARNING + 1 ) ,
+        D3D12_MESSAGE_SEVERITY_MESSAGE	= ( D3D12_MESSAGE_SEVERITY_INFO + 1 ) 
+    } 	D3D12_MESSAGE_SEVERITY;
+
+typedef 
+enum D3D12_MESSAGE_ID
+    {
+        D3D12_MESSAGE_ID_UNKNOWN	= 0,
+        D3D12_MESSAGE_ID_STRING_FROM_APPLICATION	= 1,
+        D3D12_MESSAGE_ID_CORRUPTED_THIS	= 2,
+        D3D12_MESSAGE_ID_CORRUPTED_PARAMETER1	= 3,
+        D3D12_MESSAGE_ID_CORRUPTED_PARAMETER2	= 4,
+        D3D12_MESSAGE_ID_CORRUPTED_PARAMETER3	= 5,
+        D3D12_MESSAGE_ID_CORRUPTED_PARAMETER4	= 6,
+        D3D12_MESSAGE_ID_CORRUPTED_PARAMETER5	= 7,
+        D3D12_MESSAGE_ID_CORRUPTED_PARAMETER6	= 8,
+        D3D12_MESSAGE_ID_CORRUPTED_PARAMETER7	= 9,
+        D3D12_MESSAGE_ID_CORRUPTED_PARAMETER8	= 10,
+        D3D12_MESSAGE_ID_CORRUPTED_PARAMETER9	= 11,
+        D3D12_MESSAGE_ID_CORRUPTED_PARAMETER10	= 12,
+        D3D12_MESSAGE_ID_CORRUPTED_PARAMETER11	= 13,
+        D3D12_MESSAGE_ID_CORRUPTED_PARAMETER12	= 14,
+        D3D12_MESSAGE_ID_CORRUPTED_PARAMETER13	= 15,
+        D3D12_MESSAGE_ID_CORRUPTED_PARAMETER14	= 16,
+        D3D12_MESSAGE_ID_CORRUPTED_PARAMETER15	= 17,
+        D3D12_MESSAGE_ID_CORRUPTED_MULTITHREADING	= 18,
+        D3D12_MESSAGE_ID_MESSAGE_REPORTING_OUTOFMEMORY	= 19,
+        D3D12_MESSAGE_ID_GETPRIVATEDATA_MOREDATA	= 20,
+        D3D12_MESSAGE_ID_SETPRIVATEDATA_INVALIDFREEDATA	= 21,
+        D3D12_MESSAGE_ID_SETPRIVATEDATA_CHANGINGPARAMS	= 24,
+        D3D12_MESSAGE_ID_SETPRIVATEDATA_OUTOFMEMORY	= 25,
+        D3D12_MESSAGE_ID_CREATESHADERRESOURCEVIEW_UNRECOGNIZEDFORMAT	= 26,
+        D3D12_MESSAGE_ID_CREATESHADERRESOURCEVIEW_INVALIDDESC	= 27,
+        D3D12_MESSAGE_ID_CREATESHADERRESOURCEVIEW_INVALIDFORMAT	= 28,
+        D3D12_MESSAGE_ID_CREATESHADERRESOURCEVIEW_INVALIDVIDEOPLANESLICE	= 29,
+        D3D12_MESSAGE_ID_CREATESHADERRESOURCEVIEW_INVALIDPLANESLICE	= 30,
+        D3D12_MESSAGE_ID_CREATESHADERRESOURCEVIEW_INVALIDDIMENSIONS	= 31,
+        D3D12_MESSAGE_ID_CREATESHADERRESOURCEVIEW_INVALIDRESOURCE	= 32,
+        D3D12_MESSAGE_ID_CREATERENDERTARGETVIEW_UNRECOGNIZEDFORMAT	= 35,
+        D3D12_MESSAGE_ID_CREATERENDERTARGETVIEW_UNSUPPORTEDFORMAT	= 36,
+        D3D12_MESSAGE_ID_CREATERENDERTARGETVIEW_INVALIDDESC	= 37,
+        D3D12_MESSAGE_ID_CREATERENDERTARGETVIEW_INVALIDFORMAT	= 38,
+        D3D12_MESSAGE_ID_CREATERENDERTARGETVIEW_INVALIDVIDEOPLANESLICE	= 39,
+        D3D12_MESSAGE_ID_CREATERENDERTARGETVIEW_INVALIDPLANESLICE	= 40,
+        D3D12_MESSAGE_ID_CREATERENDERTARGETVIEW_INVALIDDIMENSIONS	= 41,
+        D3D12_MESSAGE_ID_CREATERENDERTARGETVIEW_INVALIDRESOURCE	= 42,
+        D3D12_MESSAGE_ID_CREATEDEPTHSTENCILVIEW_UNRECOGNIZEDFORMAT	= 45,
+        D3D12_MESSAGE_ID_CREATEDEPTHSTENCILVIEW_INVALIDDESC	= 46,
+        D3D12_MESSAGE_ID_CREATEDEPTHSTENCILVIEW_INVALIDFORMAT	= 47,
+        D3D12_MESSAGE_ID_CREATEDEPTHSTENCILVIEW_INVALIDDIMENSIONS	= 48,
+        D3D12_MESSAGE_ID_CREATEDEPTHSTENCILVIEW_INVALIDRESOURCE	= 49,
+        D3D12_MESSAGE_ID_CREATEINPUTLAYOUT_OUTOFMEMORY	= 52,
+        D3D12_MESSAGE_ID_CREATEINPUTLAYOUT_TOOMANYELEMENTS	= 53,
+        D3D12_MESSAGE_ID_CREATEINPUTLAYOUT_INVALIDFORMAT	= 54,
+        D3D12_MESSAGE_ID_CREATEINPUTLAYOUT_INCOMPATIBLEFORMAT	= 55,
+        D3D12_MESSAGE_ID_CREATEINPUTLAYOUT_INVALIDSLOT	= 56,
+        D3D12_MESSAGE_ID_CREATEINPUTLAYOUT_INVALIDINPUTSLOTCLASS	= 57,
+        D3D12_MESSAGE_ID_CREATEINPUTLAYOUT_STEPRATESLOTCLASSMISMATCH	= 58,
+        D3D12_MESSAGE_ID_CREATEINPUTLAYOUT_INVALIDSLOTCLASSCHANGE	= 59,
+        D3D12_MESSAGE_ID_CREATEINPUTLAYOUT_INVALIDSTEPRATECHANGE	= 60,
+        D3D12_MESSAGE_ID_CREATEINPUTLAYOUT_INVALIDALIGNMENT	= 61,
+        D3D12_MESSAGE_ID_CREATEINPUTLAYOUT_DUPLICATESEMANTIC	= 62,
+        D3D12_MESSAGE_ID_CREATEINPUTLAYOUT_UNPARSEABLEINPUTSIGNATURE	= 63,
+        D3D12_MESSAGE_ID_CREATEINPUTLAYOUT_NULLSEMANTIC	= 64,
+        D3D12_MESSAGE_ID_CREATEINPUTLAYOUT_MISSINGELEMENT	= 65,
+        D3D12_MESSAGE_ID_CREATEVERTEXSHADER_OUTOFMEMORY	= 66,
+        D3D12_MESSAGE_ID_CREATEVERTEXSHADER_INVALIDSHADERBYTECODE	= 67,
+        D3D12_MESSAGE_ID_CREATEVERTEXSHADER_INVALIDSHADERTYPE	= 68,
+        D3D12_MESSAGE_ID_CREATEGEOMETRYSHADER_OUTOFMEMORY	= 69,
+        D3D12_MESSAGE_ID_CREATEGEOMETRYSHADER_INVALIDSHADERBYTECODE	= 70,
+        D3D12_MESSAGE_ID_CREATEGEOMETRYSHADER_INVALIDSHADERTYPE	= 71,
+        D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_OUTOFMEMORY	= 72,
+        D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_INVALIDSHADERBYTECODE	= 73,
+        D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_INVALIDSHADERTYPE	= 74,
+        D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_INVALIDNUMENTRIES	= 75,
+        D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_OUTPUTSTREAMSTRIDEUNUSED	= 76,
+        D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_OUTPUTSLOT0EXPECTED	= 79,
+        D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_INVALIDOUTPUTSLOT	= 80,
+        D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_ONLYONEELEMENTPERSLOT	= 81,
+        D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_INVALIDCOMPONENTCOUNT	= 82,
+        D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_INVALIDSTARTCOMPONENTANDCOMPONENTCOUNT	= 83,
+        D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_INVALIDGAPDEFINITION	= 84,
+        D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_REPEATEDOUTPUT	= 85,
+        D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_INVALIDOUTPUTSTREAMSTRIDE	= 86,
+        D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_MISSINGSEMANTIC	= 87,
+        D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_MASKMISMATCH	= 88,
+        D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_CANTHAVEONLYGAPS	= 89,
+        D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_DECLTOOCOMPLEX	= 90,
+        D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_MISSINGOUTPUTSIGNATURE	= 91,
+        D3D12_MESSAGE_ID_CREATEPIXELSHADER_OUTOFMEMORY	= 92,
+        D3D12_MESSAGE_ID_CREATEPIXELSHADER_INVALIDSHADERBYTECODE	= 93,
+        D3D12_MESSAGE_ID_CREATEPIXELSHADER_INVALIDSHADERTYPE	= 94,
+        D3D12_MESSAGE_ID_CREATERASTERIZERSTATE_INVALIDFILLMODE	= 95,
+        D3D12_MESSAGE_ID_CREATERASTERIZERSTATE_INVALIDCULLMODE	= 96,
+        D3D12_MESSAGE_ID_CREATERASTERIZERSTATE_INVALIDDEPTHBIASCLAMP	= 97,
+        D3D12_MESSAGE_ID_CREATERASTERIZERSTATE_INVALIDSLOPESCALEDDEPTHBIAS	= 98,
+        D3D12_MESSAGE_ID_CREATEDEPTHSTENCILSTATE_INVALIDDEPTHWRITEMASK	= 100,
+        D3D12_MESSAGE_ID_CREATEDEPTHSTENCILSTATE_INVALIDDEPTHFUNC	= 101,
+        D3D12_MESSAGE_ID_CREATEDEPTHSTENCILSTATE_INVALIDFRONTFACESTENCILFAILOP	= 102,
+        D3D12_MESSAGE_ID_CREATEDEPTHSTENCILSTATE_INVALIDFRONTFACESTENCILZFAILOP	= 103,
+        D3D12_MESSAGE_ID_CREATEDEPTHSTENCILSTATE_INVALIDFRONTFACESTENCILPASSOP	= 104,
+        D3D12_MESSAGE_ID_CREATEDEPTHSTENCILSTATE_INVALIDFRONTFACESTENCILFUNC	= 105,
+        D3D12_MESSAGE_ID_CREATEDEPTHSTENCILSTATE_INVALIDBACKFACESTENCILFAILOP	= 106,
+        D3D12_MESSAGE_ID_CREATEDEPTHSTENCILSTATE_INVALIDBACKFACESTENCILZFAILOP	= 107,
+        D3D12_MESSAGE_ID_CREATEDEPTHSTENCILSTATE_INVALIDBACKFACESTENCILPASSOP	= 108,
+        D3D12_MESSAGE_ID_CREATEDEPTHSTENCILSTATE_INVALIDBACKFACESTENCILFUNC	= 109,
+        D3D12_MESSAGE_ID_CREATEBLENDSTATE_INVALIDSRCBLEND	= 111,
+        D3D12_MESSAGE_ID_CREATEBLENDSTATE_INVALIDDESTBLEND	= 112,
+        D3D12_MESSAGE_ID_CREATEBLENDSTATE_INVALIDBLENDOP	= 113,
+        D3D12_MESSAGE_ID_CREATEBLENDSTATE_INVALIDSRCBLENDALPHA	= 114,
+        D3D12_MESSAGE_ID_CREATEBLENDSTATE_INVALIDDESTBLENDALPHA	= 115,
+        D3D12_MESSAGE_ID_CREATEBLENDSTATE_INVALIDBLENDOPALPHA	= 116,
+        D3D12_MESSAGE_ID_CREATEBLENDSTATE_INVALIDRENDERTARGETWRITEMASK	= 117,
+        D3D12_MESSAGE_ID_CLEARDEPTHSTENCILVIEW_INVALID	= 135,
+        D3D12_MESSAGE_ID_COMMAND_LIST_DRAW_ROOT_SIGNATURE_NOT_SET	= 200,
+        D3D12_MESSAGE_ID_COMMAND_LIST_DRAW_ROOT_SIGNATURE_MISMATCH	= 201,
+        D3D12_MESSAGE_ID_COMMAND_LIST_DRAW_VERTEX_BUFFER_NOT_SET	= 202,
+        D3D12_MESSAGE_ID_COMMAND_LIST_DRAW_VERTEX_BUFFER_STRIDE_TOO_SMALL	= 209,
+        D3D12_MESSAGE_ID_COMMAND_LIST_DRAW_VERTEX_BUFFER_TOO_SMALL	= 210,
+        D3D12_MESSAGE_ID_COMMAND_LIST_DRAW_INDEX_BUFFER_NOT_SET	= 211,
+        D3D12_MESSAGE_ID_COMMAND_LIST_DRAW_INDEX_BUFFER_FORMAT_INVALID	= 212,
+        D3D12_MESSAGE_ID_COMMAND_LIST_DRAW_INDEX_BUFFER_TOO_SMALL	= 213,
+        D3D12_MESSAGE_ID_COMMAND_LIST_DRAW_INVALID_PRIMITIVETOPOLOGY	= 219,
+        D3D12_MESSAGE_ID_COMMAND_LIST_DRAW_VERTEX_STRIDE_UNALIGNED	= 221,
+        D3D12_MESSAGE_ID_COMMAND_LIST_DRAW_INDEX_OFFSET_UNALIGNED	= 222,
+        D3D12_MESSAGE_ID_DEVICE_REMOVAL_PROCESS_AT_FAULT	= 232,
+        D3D12_MESSAGE_ID_DEVICE_REMOVAL_PROCESS_POSSIBLY_AT_FAULT	= 233,
+        D3D12_MESSAGE_ID_DEVICE_REMOVAL_PROCESS_NOT_AT_FAULT	= 234,
+        D3D12_MESSAGE_ID_CREATEINPUTLAYOUT_TRAILING_DIGIT_IN_SEMANTIC	= 239,
+        D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_TRAILING_DIGIT_IN_SEMANTIC	= 240,
+        D3D12_MESSAGE_ID_CREATEINPUTLAYOUT_TYPE_MISMATCH	= 245,
+        D3D12_MESSAGE_ID_CREATEINPUTLAYOUT_EMPTY_LAYOUT	= 253,
+        D3D12_MESSAGE_ID_LIVE_OBJECT_SUMMARY	= 255,
+        D3D12_MESSAGE_ID_LIVE_DEVICE	= 274,
+        D3D12_MESSAGE_ID_LIVE_SWAPCHAIN	= 275,
+        D3D12_MESSAGE_ID_CREATEDEPTHSTENCILVIEW_INVALIDFLAGS	= 276,
+        D3D12_MESSAGE_ID_CREATEVERTEXSHADER_INVALIDCLASSLINKAGE	= 277,
+        D3D12_MESSAGE_ID_CREATEGEOMETRYSHADER_INVALIDCLASSLINKAGE	= 278,
+        D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_INVALIDSTREAMTORASTERIZER	= 280,
+        D3D12_MESSAGE_ID_CREATEPIXELSHADER_INVALIDCLASSLINKAGE	= 283,
+        D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_INVALIDSTREAM	= 284,
+        D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_UNEXPECTEDENTRIES	= 285,
+        D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_UNEXPECTEDSTRIDES	= 286,
+        D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_INVALIDNUMSTRIDES	= 287,
+        D3D12_MESSAGE_ID_CREATEHULLSHADER_OUTOFMEMORY	= 289,
+        D3D12_MESSAGE_ID_CREATEHULLSHADER_INVALIDSHADERBYTECODE	= 290,
+        D3D12_MESSAGE_ID_CREATEHULLSHADER_INVALIDSHADERTYPE	= 291,
+        D3D12_MESSAGE_ID_CREATEHULLSHADER_INVALIDCLASSLINKAGE	= 292,
+        D3D12_MESSAGE_ID_CREATEDOMAINSHADER_OUTOFMEMORY	= 294,
+        D3D12_MESSAGE_ID_CREATEDOMAINSHADER_INVALIDSHADERBYTECODE	= 295,
+        D3D12_MESSAGE_ID_CREATEDOMAINSHADER_INVALIDSHADERTYPE	= 296,
+        D3D12_MESSAGE_ID_CREATEDOMAINSHADER_INVALIDCLASSLINKAGE	= 297,
+        D3D12_MESSAGE_ID_RESOURCE_UNMAP_NOTMAPPED	= 310,
+        D3D12_MESSAGE_ID_DEVICE_CHECKFEATURESUPPORT_MISMATCHED_DATA_SIZE	= 318,
+        D3D12_MESSAGE_ID_CREATECOMPUTESHADER_OUTOFMEMORY	= 321,
+        D3D12_MESSAGE_ID_CREATECOMPUTESHADER_INVALIDSHADERBYTECODE	= 322,
+        D3D12_MESSAGE_ID_CREATECOMPUTESHADER_INVALIDCLASSLINKAGE	= 323,
+        D3D12_MESSAGE_ID_DEVICE_CREATEVERTEXSHADER_DOUBLEFLOATOPSNOTSUPPORTED	= 331,
+        D3D12_MESSAGE_ID_DEVICE_CREATEHULLSHADER_DOUBLEFLOATOPSNOTSUPPORTED	= 332,
+        D3D12_MESSAGE_ID_DEVICE_CREATEDOMAINSHADER_DOUBLEFLOATOPSNOTSUPPORTED	= 333,
+        D3D12_MESSAGE_ID_DEVICE_CREATEGEOMETRYSHADER_DOUBLEFLOATOPSNOTSUPPORTED	= 334,
+        D3D12_MESSAGE_ID_DEVICE_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_DOUBLEFLOATOPSNOTSUPPORTED	= 335,
+        D3D12_MESSAGE_ID_DEVICE_CREATEPIXELSHADER_DOUBLEFLOATOPSNOTSUPPORTED	= 336,
+        D3D12_MESSAGE_ID_DEVICE_CREATECOMPUTESHADER_DOUBLEFLOATOPSNOTSUPPORTED	= 337,
+        D3D12_MESSAGE_ID_CREATEUNORDEREDACCESSVIEW_INVALIDRESOURCE	= 340,
+        D3D12_MESSAGE_ID_CREATEUNORDEREDACCESSVIEW_INVALIDDESC	= 341,
+        D3D12_MESSAGE_ID_CREATEUNORDEREDACCESSVIEW_INVALIDFORMAT	= 342,
+        D3D12_MESSAGE_ID_CREATEUNORDEREDACCESSVIEW_INVALIDVIDEOPLANESLICE	= 343,
+        D3D12_MESSAGE_ID_CREATEUNORDEREDACCESSVIEW_INVALIDPLANESLICE	= 344,
+        D3D12_MESSAGE_ID_CREATEUNORDEREDACCESSVIEW_INVALIDDIMENSIONS	= 345,
+        D3D12_MESSAGE_ID_CREATEUNORDEREDACCESSVIEW_UNRECOGNIZEDFORMAT	= 346,
+        D3D12_MESSAGE_ID_CREATEUNORDEREDACCESSVIEW_INVALIDFLAGS	= 354,
+        D3D12_MESSAGE_ID_CREATERASTERIZERSTATE_INVALIDFORCEDSAMPLECOUNT	= 401,
+        D3D12_MESSAGE_ID_CREATEBLENDSTATE_INVALIDLOGICOPS	= 403,
+        D3D12_MESSAGE_ID_DEVICE_CREATEVERTEXSHADER_DOUBLEEXTENSIONSNOTSUPPORTED	= 410,
+        D3D12_MESSAGE_ID_DEVICE_CREATEHULLSHADER_DOUBLEEXTENSIONSNOTSUPPORTED	= 412,
+        D3D12_MESSAGE_ID_DEVICE_CREATEDOMAINSHADER_DOUBLEEXTENSIONSNOTSUPPORTED	= 414,
+        D3D12_MESSAGE_ID_DEVICE_CREATEGEOMETRYSHADER_DOUBLEEXTENSIONSNOTSUPPORTED	= 416,
+        D3D12_MESSAGE_ID_DEVICE_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_DOUBLEEXTENSIONSNOTSUPPORTED	= 418,
+        D3D12_MESSAGE_ID_DEVICE_CREATEPIXELSHADER_DOUBLEEXTENSIONSNOTSUPPORTED	= 420,
+        D3D12_MESSAGE_ID_DEVICE_CREATECOMPUTESHADER_DOUBLEEXTENSIONSNOTSUPPORTED	= 422,
+        D3D12_MESSAGE_ID_DEVICE_CREATEVERTEXSHADER_UAVSNOTSUPPORTED	= 425,
+        D3D12_MESSAGE_ID_DEVICE_CREATEHULLSHADER_UAVSNOTSUPPORTED	= 426,
+        D3D12_MESSAGE_ID_DEVICE_CREATEDOMAINSHADER_UAVSNOTSUPPORTED	= 427,
+        D3D12_MESSAGE_ID_DEVICE_CREATEGEOMETRYSHADER_UAVSNOTSUPPORTED	= 428,
+        D3D12_MESSAGE_ID_DEVICE_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_UAVSNOTSUPPORTED	= 429,
+        D3D12_MESSAGE_ID_DEVICE_CREATEPIXELSHADER_UAVSNOTSUPPORTED	= 430,
+        D3D12_MESSAGE_ID_DEVICE_CREATECOMPUTESHADER_UAVSNOTSUPPORTED	= 431,
+        D3D12_MESSAGE_ID_DEVICE_CLEARVIEW_INVALIDSOURCERECT	= 447,
+        D3D12_MESSAGE_ID_DEVICE_CLEARVIEW_EMPTYRECT	= 448,
+        D3D12_MESSAGE_ID_UPDATETILEMAPPINGS_INVALID_PARAMETER	= 493,
+        D3D12_MESSAGE_ID_COPYTILEMAPPINGS_INVALID_PARAMETER	= 494,
+        D3D12_MESSAGE_ID_CREATEDEVICE_INVALIDARGS	= 506,
+        D3D12_MESSAGE_ID_CREATEDEVICE_WARNING	= 507,
+        D3D12_MESSAGE_ID_RESOURCE_BARRIER_INVALID_TYPE	= 519,
+        D3D12_MESSAGE_ID_RESOURCE_BARRIER_NULL_POINTER	= 520,
+        D3D12_MESSAGE_ID_RESOURCE_BARRIER_INVALID_SUBRESOURCE	= 521,
+        D3D12_MESSAGE_ID_RESOURCE_BARRIER_RESERVED_BITS	= 522,
+        D3D12_MESSAGE_ID_RESOURCE_BARRIER_MISSING_BIND_FLAGS	= 523,
+        D3D12_MESSAGE_ID_RESOURCE_BARRIER_MISMATCHING_MISC_FLAGS	= 524,
+        D3D12_MESSAGE_ID_RESOURCE_BARRIER_MATCHING_STATES	= 525,
+        D3D12_MESSAGE_ID_RESOURCE_BARRIER_INVALID_COMBINATION	= 526,
+        D3D12_MESSAGE_ID_RESOURCE_BARRIER_BEFORE_AFTER_MISMATCH	= 527,
+        D3D12_MESSAGE_ID_RESOURCE_BARRIER_INVALID_RESOURCE	= 528,
+        D3D12_MESSAGE_ID_RESOURCE_BARRIER_SAMPLE_COUNT	= 529,
+        D3D12_MESSAGE_ID_RESOURCE_BARRIER_INVALID_FLAGS	= 530,
+        D3D12_MESSAGE_ID_RESOURCE_BARRIER_INVALID_COMBINED_FLAGS	= 531,
+        D3D12_MESSAGE_ID_RESOURCE_BARRIER_INVALID_FLAGS_FOR_FORMAT	= 532,
+        D3D12_MESSAGE_ID_RESOURCE_BARRIER_INVALID_SPLIT_BARRIER	= 533,
+        D3D12_MESSAGE_ID_RESOURCE_BARRIER_UNMATCHED_END	= 534,
+        D3D12_MESSAGE_ID_RESOURCE_BARRIER_UNMATCHED_BEGIN	= 535,
+        D3D12_MESSAGE_ID_RESOURCE_BARRIER_INVALID_FLAG	= 536,
+        D3D12_MESSAGE_ID_RESOURCE_BARRIER_INVALID_COMMAND_LIST_TYPE	= 537,
+        D3D12_MESSAGE_ID_INVALID_SUBRESOURCE_STATE	= 538,
+        D3D12_MESSAGE_ID_COMMAND_ALLOCATOR_CONTENTION	= 540,
+        D3D12_MESSAGE_ID_COMMAND_ALLOCATOR_RESET	= 541,
+        D3D12_MESSAGE_ID_COMMAND_ALLOCATOR_RESET_BUNDLE	= 542,
+        D3D12_MESSAGE_ID_COMMAND_ALLOCATOR_CANNOT_RESET	= 543,
+        D3D12_MESSAGE_ID_COMMAND_LIST_OPEN	= 544,
+        D3D12_MESSAGE_ID_INVALID_BUNDLE_API	= 546,
+        D3D12_MESSAGE_ID_COMMAND_LIST_CLOSED	= 547,
+        D3D12_MESSAGE_ID_WRONG_COMMAND_ALLOCATOR_TYPE	= 549,
+        D3D12_MESSAGE_ID_COMMAND_ALLOCATOR_SYNC	= 552,
+        D3D12_MESSAGE_ID_COMMAND_LIST_SYNC	= 553,
+        D3D12_MESSAGE_ID_SET_DESCRIPTOR_HEAP_INVALID	= 554,
+        D3D12_MESSAGE_ID_CREATE_COMMANDQUEUE	= 557,
+        D3D12_MESSAGE_ID_CREATE_COMMANDALLOCATOR	= 558,
+        D3D12_MESSAGE_ID_CREATE_PIPELINESTATE	= 559,
+        D3D12_MESSAGE_ID_CREATE_COMMANDLIST12	= 560,
+        D3D12_MESSAGE_ID_CREATE_RESOURCE	= 562,
+        D3D12_MESSAGE_ID_CREATE_DESCRIPTORHEAP	= 563,
+        D3D12_MESSAGE_ID_CREATE_ROOTSIGNATURE	= 564,
+        D3D12_MESSAGE_ID_CREATE_LIBRARY	= 565,
+        D3D12_MESSAGE_ID_CREATE_HEAP	= 566,
+        D3D12_MESSAGE_ID_CREATE_MONITOREDFENCE	= 567,
+        D3D12_MESSAGE_ID_CREATE_QUERYHEAP	= 568,
+        D3D12_MESSAGE_ID_CREATE_COMMANDSIGNATURE	= 569,
+        D3D12_MESSAGE_ID_LIVE_COMMANDQUEUE	= 570,
+        D3D12_MESSAGE_ID_LIVE_COMMANDALLOCATOR	= 571,
+        D3D12_MESSAGE_ID_LIVE_PIPELINESTATE	= 572,
+        D3D12_MESSAGE_ID_LIVE_COMMANDLIST12	= 573,
+        D3D12_MESSAGE_ID_LIVE_RESOURCE	= 575,
+        D3D12_MESSAGE_ID_LIVE_DESCRIPTORHEAP	= 576,
+        D3D12_MESSAGE_ID_LIVE_ROOTSIGNATURE	= 577,
+        D3D12_MESSAGE_ID_LIVE_LIBRARY	= 578,
+        D3D12_MESSAGE_ID_LIVE_HEAP	= 579,
+        D3D12_MESSAGE_ID_LIVE_MONITOREDFENCE	= 580,
+        D3D12_MESSAGE_ID_LIVE_QUERYHEAP	= 581,
+        D3D12_MESSAGE_ID_LIVE_COMMANDSIGNATURE	= 582,
+        D3D12_MESSAGE_ID_DESTROY_COMMANDQUEUE	= 583,
+        D3D12_MESSAGE_ID_DESTROY_COMMANDALLOCATOR	= 584,
+        D3D12_MESSAGE_ID_DESTROY_PIPELINESTATE	= 585,
+        D3D12_MESSAGE_ID_DESTROY_COMMANDLIST12	= 586,
+        D3D12_MESSAGE_ID_DESTROY_RESOURCE	= 588,
+        D3D12_MESSAGE_ID_DESTROY_DESCRIPTORHEAP	= 589,
+        D3D12_MESSAGE_ID_DESTROY_ROOTSIGNATURE	= 590,
+        D3D12_MESSAGE_ID_DESTROY_LIBRARY	= 591,
+        D3D12_MESSAGE_ID_DESTROY_HEAP	= 592,
+        D3D12_MESSAGE_ID_DESTROY_MONITOREDFENCE	= 593,
+        D3D12_MESSAGE_ID_DESTROY_QUERYHEAP	= 594,
+        D3D12_MESSAGE_ID_DESTROY_COMMANDSIGNATURE	= 595,
+        D3D12_MESSAGE_ID_CREATERESOURCE_INVALIDDIMENSIONS	= 597,
+        D3D12_MESSAGE_ID_CREATERESOURCE_INVALIDMISCFLAGS	= 599,
+        D3D12_MESSAGE_ID_CREATERESOURCE_INVALIDARG_RETURN	= 602,
+        D3D12_MESSAGE_ID_CREATERESOURCE_OUTOFMEMORY_RETURN	= 603,
+        D3D12_MESSAGE_ID_CREATERESOURCE_INVALIDDESC	= 604,
+        D3D12_MESSAGE_ID_POSSIBLY_INVALID_SUBRESOURCE_STATE	= 607,
+        D3D12_MESSAGE_ID_INVALID_USE_OF_NON_RESIDENT_RESOURCE	= 608,
+        D3D12_MESSAGE_ID_POSSIBLE_INVALID_USE_OF_NON_RESIDENT_RESOURCE	= 609,
+        D3D12_MESSAGE_ID_BUNDLE_PIPELINE_STATE_MISMATCH	= 610,
+        D3D12_MESSAGE_ID_PRIMITIVE_TOPOLOGY_MISMATCH_PIPELINE_STATE	= 611,
+        D3D12_MESSAGE_ID_RENDER_TARGET_FORMAT_MISMATCH_PIPELINE_STATE	= 613,
+        D3D12_MESSAGE_ID_RENDER_TARGET_SAMPLE_DESC_MISMATCH_PIPELINE_STATE	= 614,
+        D3D12_MESSAGE_ID_DEPTH_STENCIL_FORMAT_MISMATCH_PIPELINE_STATE	= 615,
+        D3D12_MESSAGE_ID_DEPTH_STENCIL_SAMPLE_DESC_MISMATCH_PIPELINE_STATE	= 616,
+        D3D12_MESSAGE_ID_CREATESHADER_INVALIDBYTECODE	= 622,
+        D3D12_MESSAGE_ID_CREATEHEAP_NULLDESC	= 623,
+        D3D12_MESSAGE_ID_CREATEHEAP_INVALIDSIZE	= 624,
+        D3D12_MESSAGE_ID_CREATEHEAP_UNRECOGNIZEDHEAPTYPE	= 625,
+        D3D12_MESSAGE_ID_CREATEHEAP_UNRECOGNIZEDCPUPAGEPROPERTIES	= 626,
+        D3D12_MESSAGE_ID_CREATEHEAP_UNRECOGNIZEDMEMORYPOOL	= 627,
+        D3D12_MESSAGE_ID_CREATEHEAP_INVALIDPROPERTIES	= 628,
+        D3D12_MESSAGE_ID_CREATEHEAP_INVALIDALIGNMENT	= 629,
+        D3D12_MESSAGE_ID_CREATEHEAP_UNRECOGNIZEDMISCFLAGS	= 630,
+        D3D12_MESSAGE_ID_CREATEHEAP_INVALIDMISCFLAGS	= 631,
+        D3D12_MESSAGE_ID_CREATEHEAP_INVALIDARG_RETURN	= 632,
+        D3D12_MESSAGE_ID_CREATEHEAP_OUTOFMEMORY_RETURN	= 633,
+        D3D12_MESSAGE_ID_CREATERESOURCEANDHEAP_NULLHEAPPROPERTIES	= 634,
+        D3D12_MESSAGE_ID_CREATERESOURCEANDHEAP_UNRECOGNIZEDHEAPTYPE	= 635,
+        D3D12_MESSAGE_ID_CREATERESOURCEANDHEAP_UNRECOGNIZEDCPUPAGEPROPERTIES	= 636,
+        D3D12_MESSAGE_ID_CREATERESOURCEANDHEAP_UNRECOGNIZEDMEMORYPOOL	= 637,
+        D3D12_MESSAGE_ID_CREATERESOURCEANDHEAP_INVALIDHEAPPROPERTIES	= 638,
+        D3D12_MESSAGE_ID_CREATERESOURCEANDHEAP_UNRECOGNIZEDHEAPMISCFLAGS	= 639,
+        D3D12_MESSAGE_ID_CREATERESOURCEANDHEAP_INVALIDHEAPMISCFLAGS	= 640,
+        D3D12_MESSAGE_ID_CREATERESOURCEANDHEAP_INVALIDARG_RETURN	= 641,
+        D3D12_MESSAGE_ID_CREATERESOURCEANDHEAP_OUTOFMEMORY_RETURN	= 642,
+        D3D12_MESSAGE_ID_GETCUSTOMHEAPPROPERTIES_UNRECOGNIZEDHEAPTYPE	= 643,
+        D3D12_MESSAGE_ID_GETCUSTOMHEAPPROPERTIES_INVALIDHEAPTYPE	= 644,
+        D3D12_MESSAGE_ID_CREATE_DESCRIPTOR_HEAP_INVALID_DESC	= 645,
+        D3D12_MESSAGE_ID_INVALID_DESCRIPTOR_HANDLE	= 646,
+        D3D12_MESSAGE_ID_CREATERASTERIZERSTATE_INVALID_CONSERVATIVERASTERMODE	= 647,
+        D3D12_MESSAGE_ID_CREATE_CONSTANT_BUFFER_VIEW_INVALID_RESOURCE	= 649,
+        D3D12_MESSAGE_ID_CREATE_CONSTANT_BUFFER_VIEW_INVALID_DESC	= 650,
+        D3D12_MESSAGE_ID_CREATE_UNORDEREDACCESS_VIEW_INVALID_COUNTER_USAGE	= 652,
+        D3D12_MESSAGE_ID_COPY_DESCRIPTORS_INVALID_RANGES	= 653,
+        D3D12_MESSAGE_ID_COPY_DESCRIPTORS_WRITE_ONLY_DESCRIPTOR	= 654,
+        D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_RTV_FORMAT_NOT_UNKNOWN	= 655,
+        D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_INVALID_RENDER_TARGET_COUNT	= 656,
+        D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_VERTEX_SHADER_NOT_SET	= 657,
+        D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_INPUTLAYOUT_NOT_SET	= 658,
+        D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_SHADER_LINKAGE_HS_DS_SIGNATURE_MISMATCH	= 659,
+        D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_SHADER_LINKAGE_REGISTERINDEX	= 660,
+        D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_SHADER_LINKAGE_COMPONENTTYPE	= 661,
+        D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_SHADER_LINKAGE_REGISTERMASK	= 662,
+        D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_SHADER_LINKAGE_SYSTEMVALUE	= 663,
+        D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_SHADER_LINKAGE_NEVERWRITTEN_ALWAYSREADS	= 664,
+        D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_SHADER_LINKAGE_MINPRECISION	= 665,
+        D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_SHADER_LINKAGE_SEMANTICNAME_NOT_FOUND	= 666,
+        D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_HS_XOR_DS_MISMATCH	= 667,
+        D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_HULL_SHADER_INPUT_TOPOLOGY_MISMATCH	= 668,
+        D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_HS_DS_CONTROL_POINT_COUNT_MISMATCH	= 669,
+        D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_HS_DS_TESSELLATOR_DOMAIN_MISMATCH	= 670,
+        D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_INVALID_USE_OF_CENTER_MULTISAMPLE_PATTERN	= 671,
+        D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_INVALID_USE_OF_FORCED_SAMPLE_COUNT	= 672,
+        D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_INVALID_PRIMITIVETOPOLOGY	= 673,
+        D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_INVALID_SYSTEMVALUE	= 674,
+        D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_OM_DUAL_SOURCE_BLENDING_CAN_ONLY_HAVE_RENDER_TARGET_0	= 675,
+        D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_OM_RENDER_TARGET_DOES_NOT_SUPPORT_BLENDING	= 676,
+        D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_PS_OUTPUT_TYPE_MISMATCH	= 677,
+        D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_OM_RENDER_TARGET_DOES_NOT_SUPPORT_LOGIC_OPS	= 678,
+        D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_RENDERTARGETVIEW_NOT_SET	= 679,
+        D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_DEPTHSTENCILVIEW_NOT_SET	= 680,
+        D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_GS_INPUT_PRIMITIVE_MISMATCH	= 681,
+        D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_POSITION_NOT_PRESENT	= 682,
+        D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_MISSING_ROOT_SIGNATURE_FLAGS	= 683,
+        D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_INVALID_INDEX_BUFFER_PROPERTIES	= 684,
+        D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_INVALID_SAMPLE_DESC	= 685,
+        D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_HS_ROOT_SIGNATURE_MISMATCH	= 686,
+        D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_DS_ROOT_SIGNATURE_MISMATCH	= 687,
+        D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_VS_ROOT_SIGNATURE_MISMATCH	= 688,
+        D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_GS_ROOT_SIGNATURE_MISMATCH	= 689,
+        D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_PS_ROOT_SIGNATURE_MISMATCH	= 690,
+        D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_MISSING_ROOT_SIGNATURE	= 691,
+        D3D12_MESSAGE_ID_EXECUTE_BUNDLE_OPEN_BUNDLE	= 692,
+        D3D12_MESSAGE_ID_EXECUTE_BUNDLE_DESCRIPTOR_HEAP_MISMATCH	= 693,
+        D3D12_MESSAGE_ID_EXECUTE_BUNDLE_TYPE	= 694,
+        D3D12_MESSAGE_ID_DRAW_EMPTY_SCISSOR_RECTANGLE	= 695,
+        D3D12_MESSAGE_ID_CREATE_ROOT_SIGNATURE_BLOB_NOT_FOUND	= 696,
+        D3D12_MESSAGE_ID_CREATE_ROOT_SIGNATURE_DESERIALIZE_FAILED	= 697,
+        D3D12_MESSAGE_ID_CREATE_ROOT_SIGNATURE_INVALID_CONFIGURATION	= 698,
+        D3D12_MESSAGE_ID_CREATE_ROOT_SIGNATURE_NOT_SUPPORTED_ON_DEVICE	= 699,
+        D3D12_MESSAGE_ID_CREATERESOURCEANDHEAP_NULLRESOURCEPROPERTIES	= 700,
+        D3D12_MESSAGE_ID_CREATERESOURCEANDHEAP_NULLHEAP	= 701,
+        D3D12_MESSAGE_ID_GETRESOURCEALLOCATIONINFO_INVALIDRDESCS	= 702,
+        D3D12_MESSAGE_ID_MAKERESIDENT_NULLOBJECTARRAY	= 703,
+        D3D12_MESSAGE_ID_EVICT_NULLOBJECTARRAY	= 705,
+        D3D12_MESSAGE_ID_SET_DESCRIPTOR_TABLE_INVALID	= 708,
+        D3D12_MESSAGE_ID_SET_ROOT_CONSTANT_INVALID	= 709,
+        D3D12_MESSAGE_ID_SET_ROOT_CONSTANT_BUFFER_VIEW_INVALID	= 710,
+        D3D12_MESSAGE_ID_SET_ROOT_SHADER_RESOURCE_VIEW_INVALID	= 711,
+        D3D12_MESSAGE_ID_SET_ROOT_UNORDERED_ACCESS_VIEW_INVALID	= 712,
+        D3D12_MESSAGE_ID_SET_VERTEX_BUFFERS_INVALID_DESC	= 713,
+        D3D12_MESSAGE_ID_SET_INDEX_BUFFER_INVALID_DESC	= 715,
+        D3D12_MESSAGE_ID_SET_STREAM_OUTPUT_BUFFERS_INVALID_DESC	= 717,
+        D3D12_MESSAGE_ID_CREATERESOURCE_UNRECOGNIZEDDIMENSIONALITY	= 718,
+        D3D12_MESSAGE_ID_CREATERESOURCE_UNRECOGNIZEDLAYOUT	= 719,
+        D3D12_MESSAGE_ID_CREATERESOURCE_INVALIDDIMENSIONALITY	= 720,
+        D3D12_MESSAGE_ID_CREATERESOURCE_INVALIDALIGNMENT	= 721,
+        D3D12_MESSAGE_ID_CREATERESOURCE_INVALIDMIPLEVELS	= 722,
+        D3D12_MESSAGE_ID_CREATERESOURCE_INVALIDSAMPLEDESC	= 723,
+        D3D12_MESSAGE_ID_CREATERESOURCE_INVALIDLAYOUT	= 724,
+        D3D12_MESSAGE_ID_SET_INDEX_BUFFER_INVALID	= 725,
+        D3D12_MESSAGE_ID_SET_VERTEX_BUFFERS_INVALID	= 726,
+        D3D12_MESSAGE_ID_SET_STREAM_OUTPUT_BUFFERS_INVALID	= 727,
+        D3D12_MESSAGE_ID_SET_RENDER_TARGETS_INVALID	= 728,
+        D3D12_MESSAGE_ID_CREATEQUERY_HEAP_INVALID_PARAMETERS	= 729,
+        D3D12_MESSAGE_ID_BEGIN_END_QUERY_INVALID_PARAMETERS	= 731,
+        D3D12_MESSAGE_ID_CLOSE_COMMAND_LIST_OPEN_QUERY	= 732,
+        D3D12_MESSAGE_ID_RESOLVE_QUERY_DATA_INVALID_PARAMETERS	= 733,
+        D3D12_MESSAGE_ID_SET_PREDICATION_INVALID_PARAMETERS	= 734,
+        D3D12_MESSAGE_ID_TIMESTAMPS_NOT_SUPPORTED	= 735,
+        D3D12_MESSAGE_ID_CREATERESOURCE_UNRECOGNIZEDFORMAT	= 737,
+        D3D12_MESSAGE_ID_CREATERESOURCE_INVALIDFORMAT	= 738,
+        D3D12_MESSAGE_ID_GETCOPYABLEFOOTPRINTS_INVALIDSUBRESOURCERANGE	= 739,
+        D3D12_MESSAGE_ID_GETCOPYABLEFOOTPRINTS_INVALIDBASEOFFSET	= 740,
+        D3D12_MESSAGE_ID_GETCOPYABLELAYOUT_INVALIDSUBRESOURCERANGE	= 739,
+        D3D12_MESSAGE_ID_GETCOPYABLELAYOUT_INVALIDBASEOFFSET	= 740,
+        D3D12_MESSAGE_ID_RESOURCE_BARRIER_INVALID_HEAP	= 741,
+        D3D12_MESSAGE_ID_CREATE_SAMPLER_INVALID	= 742,
+        D3D12_MESSAGE_ID_CREATECOMMANDSIGNATURE_INVALID	= 743,
+        D3D12_MESSAGE_ID_EXECUTE_INDIRECT_INVALID_PARAMETERS	= 744,
+        D3D12_MESSAGE_ID_GETGPUVIRTUALADDRESS_INVALID_RESOURCE_DIMENSION	= 745,
+        D3D12_MESSAGE_ID_CREATERESOURCE_INVALIDCLEARVALUE	= 815,
+        D3D12_MESSAGE_ID_CREATERESOURCE_UNRECOGNIZEDCLEARVALUEFORMAT	= 816,
+        D3D12_MESSAGE_ID_CREATERESOURCE_INVALIDCLEARVALUEFORMAT	= 817,
+        D3D12_MESSAGE_ID_CREATERESOURCE_CLEARVALUEDENORMFLUSH	= 818,
+        D3D12_MESSAGE_ID_CLEARRENDERTARGETVIEW_MISMATCHINGCLEARVALUE	= 820,
+        D3D12_MESSAGE_ID_CLEARDEPTHSTENCILVIEW_MISMATCHINGCLEARVALUE	= 821,
+        D3D12_MESSAGE_ID_MAP_INVALIDHEAP	= 822,
+        D3D12_MESSAGE_ID_UNMAP_INVALIDHEAP	= 823,
+        D3D12_MESSAGE_ID_MAP_INVALIDRESOURCE	= 824,
+        D3D12_MESSAGE_ID_UNMAP_INVALIDRESOURCE	= 825,
+        D3D12_MESSAGE_ID_MAP_INVALIDSUBRESOURCE	= 826,
+        D3D12_MESSAGE_ID_UNMAP_INVALIDSUBRESOURCE	= 827,
+        D3D12_MESSAGE_ID_MAP_INVALIDRANGE	= 828,
+        D3D12_MESSAGE_ID_UNMAP_INVALIDRANGE	= 829,
+        D3D12_MESSAGE_ID_MAP_INVALIDDATAPOINTER	= 832,
+        D3D12_MESSAGE_ID_MAP_INVALIDARG_RETURN	= 833,
+        D3D12_MESSAGE_ID_MAP_OUTOFMEMORY_RETURN	= 834,
+        D3D12_MESSAGE_ID_EXECUTECOMMANDLISTS_BUNDLENOTSUPPORTED	= 835,
+        D3D12_MESSAGE_ID_EXECUTECOMMANDLISTS_COMMANDLISTMISMATCH	= 836,
+        D3D12_MESSAGE_ID_EXECUTECOMMANDLISTS_OPENCOMMANDLIST	= 837,
+        D3D12_MESSAGE_ID_EXECUTECOMMANDLISTS_FAILEDCOMMANDLIST	= 838,
+        D3D12_MESSAGE_ID_COPYBUFFERREGION_NULLDST	= 839,
+        D3D12_MESSAGE_ID_COPYBUFFERREGION_INVALIDDSTRESOURCEDIMENSION	= 840,
+        D3D12_MESSAGE_ID_COPYBUFFERREGION_DSTRANGEOUTOFBOUNDS	= 841,
+        D3D12_MESSAGE_ID_COPYBUFFERREGION_NULLSRC	= 842,
+        D3D12_MESSAGE_ID_COPYBUFFERREGION_INVALIDSRCRESOURCEDIMENSION	= 843,
+        D3D12_MESSAGE_ID_COPYBUFFERREGION_SRCRANGEOUTOFBOUNDS	= 844,
+        D3D12_MESSAGE_ID_COPYBUFFERREGION_INVALIDCOPYFLAGS	= 845,
+        D3D12_MESSAGE_ID_COPYTEXTUREREGION_NULLDST	= 846,
+        D3D12_MESSAGE_ID_COPYTEXTUREREGION_UNRECOGNIZEDDSTTYPE	= 847,
+        D3D12_MESSAGE_ID_COPYTEXTUREREGION_INVALIDDSTRESOURCEDIMENSION	= 848,
+        D3D12_MESSAGE_ID_COPYTEXTUREREGION_INVALIDDSTRESOURCE	= 849,
+        D3D12_MESSAGE_ID_COPYTEXTUREREGION_INVALIDDSTSUBRESOURCE	= 850,
+        D3D12_MESSAGE_ID_COPYTEXTUREREGION_INVALIDDSTOFFSET	= 851,
+        D3D12_MESSAGE_ID_COPYTEXTUREREGION_UNRECOGNIZEDDSTFORMAT	= 852,
+        D3D12_MESSAGE_ID_COPYTEXTUREREGION_INVALIDDSTFORMAT	= 853,
+        D3D12_MESSAGE_ID_COPYTEXTUREREGION_INVALIDDSTDIMENSIONS	= 854,
+        D3D12_MESSAGE_ID_COPYTEXTUREREGION_INVALIDDSTROWPITCH	= 855,
+        D3D12_MESSAGE_ID_COPYTEXTUREREGION_INVALIDDSTPLACEMENT	= 856,
+        D3D12_MESSAGE_ID_COPYTEXTUREREGION_INVALIDDSTDSPLACEDFOOTPRINTFORMAT	= 857,
+        D3D12_MESSAGE_ID_COPYTEXTUREREGION_DSTREGIONOUTOFBOUNDS	= 858,
+        D3D12_MESSAGE_ID_COPYTEXTUREREGION_NULLSRC	= 859,
+        D3D12_MESSAGE_ID_COPYTEXTUREREGION_UNRECOGNIZEDSRCTYPE	= 860,
+        D3D12_MESSAGE_ID_COPYTEXTUREREGION_INVALIDSRCRESOURCEDIMENSION	= 861,
+        D3D12_MESSAGE_ID_COPYTEXTUREREGION_INVALIDSRCRESOURCE	= 862,
+        D3D12_MESSAGE_ID_COPYTEXTUREREGION_INVALIDSRCSUBRESOURCE	= 863,
+        D3D12_MESSAGE_ID_COPYTEXTUREREGION_INVALIDSRCOFFSET	= 864,
+        D3D12_MESSAGE_ID_COPYTEXTUREREGION_UNRECOGNIZEDSRCFORMAT	= 865,
+        D3D12_MESSAGE_ID_COPYTEXTUREREGION_INVALIDSRCFORMAT	= 866,
+        D3D12_MESSAGE_ID_COPYTEXTUREREGION_INVALIDSRCDIMENSIONS	= 867,
+        D3D12_MESSAGE_ID_COPYTEXTUREREGION_INVALIDSRCROWPITCH	= 868,
+        D3D12_MESSAGE_ID_COPYTEXTUREREGION_INVALIDSRCPLACEMENT	= 869,
+        D3D12_MESSAGE_ID_COPYTEXTUREREGION_INVALIDSRCDSPLACEDFOOTPRINTFORMAT	= 870,
+        D3D12_MESSAGE_ID_COPYTEXTUREREGION_SRCREGIONOUTOFBOUNDS	= 871,
+        D3D12_MESSAGE_ID_COPYTEXTUREREGION_INVALIDDSTCOORDINATES	= 872,
+        D3D12_MESSAGE_ID_COPYTEXTUREREGION_INVALIDSRCBOX	= 873,
+        D3D12_MESSAGE_ID_COPYTEXTUREREGION_FORMATMISMATCH	= 874,
+        D3D12_MESSAGE_ID_COPYTEXTUREREGION_EMPTYBOX	= 875,
+        D3D12_MESSAGE_ID_COPYTEXTUREREGION_INVALIDCOPYFLAGS	= 876,
+        D3D12_MESSAGE_ID_RESOLVESUBRESOURCE_INVALID_SUBRESOURCE_INDEX	= 877,
+        D3D12_MESSAGE_ID_RESOLVESUBRESOURCE_INVALID_FORMAT	= 878,
+        D3D12_MESSAGE_ID_RESOLVESUBRESOURCE_RESOURCE_MISMATCH	= 879,
+        D3D12_MESSAGE_ID_RESOLVESUBRESOURCE_INVALID_SAMPLE_COUNT	= 880,
+        D3D12_MESSAGE_ID_CREATECOMPUTEPIPELINESTATE_INVALID_SHADER	= 881,
+        D3D12_MESSAGE_ID_CREATECOMPUTEPIPELINESTATE_CS_ROOT_SIGNATURE_MISMATCH	= 882,
+        D3D12_MESSAGE_ID_CREATECOMPUTEPIPELINESTATE_MISSING_ROOT_SIGNATURE	= 883,
+        D3D12_MESSAGE_ID_CREATEPIPELINESTATE_INVALIDCACHEDBLOB	= 884,
+        D3D12_MESSAGE_ID_CREATEPIPELINESTATE_CACHEDBLOBADAPTERMISMATCH	= 885,
+        D3D12_MESSAGE_ID_CREATEPIPELINESTATE_CACHEDBLOBDRIVERVERSIONMISMATCH	= 886,
+        D3D12_MESSAGE_ID_CREATEPIPELINESTATE_CACHEDBLOBDESCMISMATCH	= 887,
+        D3D12_MESSAGE_ID_CREATEPIPELINESTATE_CACHEDBLOBIGNORED	= 888,
+        D3D12_MESSAGE_ID_WRITETOSUBRESOURCE_INVALIDHEAP	= 889,
+        D3D12_MESSAGE_ID_WRITETOSUBRESOURCE_INVALIDRESOURCE	= 890,
+        D3D12_MESSAGE_ID_WRITETOSUBRESOURCE_INVALIDBOX	= 891,
+        D3D12_MESSAGE_ID_WRITETOSUBRESOURCE_INVALIDSUBRESOURCE	= 892,
+        D3D12_MESSAGE_ID_WRITETOSUBRESOURCE_EMPTYBOX	= 893,
+        D3D12_MESSAGE_ID_READFROMSUBRESOURCE_INVALIDHEAP	= 894,
+        D3D12_MESSAGE_ID_READFROMSUBRESOURCE_INVALIDRESOURCE	= 895,
+        D3D12_MESSAGE_ID_READFROMSUBRESOURCE_INVALIDBOX	= 896,
+        D3D12_MESSAGE_ID_READFROMSUBRESOURCE_INVALIDSUBRESOURCE	= 897,
+        D3D12_MESSAGE_ID_READFROMSUBRESOURCE_EMPTYBOX	= 898,
+        D3D12_MESSAGE_ID_TOO_MANY_NODES_SPECIFIED	= 899,
+        D3D12_MESSAGE_ID_INVALID_NODE_INDEX	= 900,
+        D3D12_MESSAGE_ID_GETHEAPPROPERTIES_INVALIDRESOURCE	= 901,
+        D3D12_MESSAGE_ID_NODE_MASK_MISMATCH	= 902,
+        D3D12_MESSAGE_ID_COMMAND_LIST_OUTOFMEMORY	= 903,
+        D3D12_MESSAGE_ID_COMMAND_LIST_MULTIPLE_SWAPCHAIN_BUFFER_REFERENCES	= 904,
+        D3D12_MESSAGE_ID_COMMAND_LIST_TOO_MANY_SWAPCHAIN_REFERENCES	= 905,
+        D3D12_MESSAGE_ID_COMMAND_QUEUE_TOO_MANY_SWAPCHAIN_REFERENCES	= 906,
+        D3D12_MESSAGE_ID_EXECUTECOMMANDLISTS_WRONGSWAPCHAINBUFFERREFERENCE	= 907,
+        D3D12_MESSAGE_ID_COMMAND_LIST_SETRENDERTARGETS_INVALIDNUMRENDERTARGETS	= 908,
+        D3D12_MESSAGE_ID_CREATE_QUEUE_INVALID_TYPE	= 909,
+        D3D12_MESSAGE_ID_CREATE_QUEUE_INVALID_FLAGS	= 910,
+        D3D12_MESSAGE_ID_CREATESHAREDRESOURCE_INVALIDFLAGS	= 911,
+        D3D12_MESSAGE_ID_CREATESHAREDRESOURCE_INVALIDFORMAT	= 912,
+        D3D12_MESSAGE_ID_CREATESHAREDHEAP_INVALIDFLAGS	= 913,
+        D3D12_MESSAGE_ID_REFLECTSHAREDPROPERTIES_UNRECOGNIZEDPROPERTIES	= 914,
+        D3D12_MESSAGE_ID_REFLECTSHAREDPROPERTIES_INVALIDSIZE	= 915,
+        D3D12_MESSAGE_ID_REFLECTSHAREDPROPERTIES_INVALIDOBJECT	= 916,
+        D3D12_MESSAGE_ID_KEYEDMUTEX_INVALIDOBJECT	= 917,
+        D3D12_MESSAGE_ID_KEYEDMUTEX_INVALIDKEY	= 918,
+        D3D12_MESSAGE_ID_KEYEDMUTEX_WRONGSTATE	= 919,
+        D3D12_MESSAGE_ID_CREATE_QUEUE_INVALID_PRIORITY	= 920,
+        D3D12_MESSAGE_ID_OBJECT_DELETED_WHILE_STILL_IN_USE	= 921,
+        D3D12_MESSAGE_ID_CREATEPIPELINESTATE_INVALID_FLAGS	= 922,
+        D3D12_MESSAGE_ID_HEAP_ADDRESS_RANGE_HAS_NO_RESOURCE	= 923,
+        D3D12_MESSAGE_ID_COMMAND_LIST_DRAW_RENDER_TARGET_DELETED	= 924,
+        D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_ALL_RENDER_TARGETS_HAVE_UNKNOWN_FORMAT	= 925,
+        D3D12_MESSAGE_ID_HEAP_ADDRESS_RANGE_INTERSECTS_MULTIPLE_BUFFERS	= 926,
+        D3D12_MESSAGE_ID_EXECUTECOMMANDLISTS_GPU_WRITTEN_READBACK_RESOURCE_MAPPED	= 927,
+        D3D12_MESSAGE_ID_UNMAP_RANGE_NOT_EMPTY	= 929,
+        D3D12_MESSAGE_ID_MAP_INVALID_NULLRANGE	= 930,
+        D3D12_MESSAGE_ID_UNMAP_INVALID_NULLRANGE	= 931,
+        D3D12_MESSAGE_ID_NO_GRAPHICS_API_SUPPORT	= 932,
+        D3D12_MESSAGE_ID_NO_COMPUTE_API_SUPPORT	= 933,
+        D3D12_MESSAGE_ID_RESOLVESUBRESOURCE_RESOURCE_FLAGS_NOT_SUPPORTED	= 934,
+        D3D12_MESSAGE_ID_GPU_BASED_VALIDATION_ROOT_ARGUMENT_UNINITIALIZED	= 935,
+        D3D12_MESSAGE_ID_GPU_BASED_VALIDATION_DESCRIPTOR_HEAP_INDEX_OUT_OF_BOUNDS	= 936,
+        D3D12_MESSAGE_ID_GPU_BASED_VALIDATION_DESCRIPTOR_TABLE_REGISTER_INDEX_OUT_OF_BOUNDS	= 937,
+        D3D12_MESSAGE_ID_GPU_BASED_VALIDATION_DESCRIPTOR_UNINITIALIZED	= 938,
+        D3D12_MESSAGE_ID_GPU_BASED_VALIDATION_DESCRIPTOR_TYPE_MISMATCH	= 939,
+        D3D12_MESSAGE_ID_GPU_BASED_VALIDATION_SRV_RESOURCE_DIMENSION_MISMATCH	= 940,
+        D3D12_MESSAGE_ID_GPU_BASED_VALIDATION_UAV_RESOURCE_DIMENSION_MISMATCH	= 941,
+        D3D12_MESSAGE_ID_GPU_BASED_VALIDATION_INCOMPATIBLE_RESOURCE_STATE	= 942,
+        D3D12_MESSAGE_ID_COPYRESOURCE_NULLDST	= 943,
+        D3D12_MESSAGE_ID_COPYRESOURCE_INVALIDDSTRESOURCE	= 944,
+        D3D12_MESSAGE_ID_COPYRESOURCE_NULLSRC	= 945,
+        D3D12_MESSAGE_ID_COPYRESOURCE_INVALIDSRCRESOURCE	= 946,
+        D3D12_MESSAGE_ID_RESOLVESUBRESOURCE_NULLDST	= 947,
+        D3D12_MESSAGE_ID_RESOLVESUBRESOURCE_INVALIDDSTRESOURCE	= 948,
+        D3D12_MESSAGE_ID_RESOLVESUBRESOURCE_NULLSRC	= 949,
+        D3D12_MESSAGE_ID_RESOLVESUBRESOURCE_INVALIDSRCRESOURCE	= 950,
+        D3D12_MESSAGE_ID_PIPELINE_STATE_TYPE_MISMATCH	= 951,
+        D3D12_MESSAGE_ID_COMMAND_LIST_DISPATCH_ROOT_SIGNATURE_NOT_SET	= 952,
+        D3D12_MESSAGE_ID_COMMAND_LIST_DISPATCH_ROOT_SIGNATURE_MISMATCH	= 953,
+        D3D12_MESSAGE_ID_RESOURCE_BARRIER_ZERO_BARRIERS	= 954,
+        D3D12_MESSAGE_ID_BEGIN_END_EVENT_MISMATCH	= 955,
+        D3D12_MESSAGE_ID_RESOURCE_BARRIER_POSSIBLE_BEFORE_AFTER_MISMATCH	= 956,
+        D3D12_MESSAGE_ID_RESOURCE_BARRIER_MISMATCHING_BEGIN_END	= 957,
+        D3D12_MESSAGE_ID_GPU_BASED_VALIDATION_INVALID_RESOURCE	= 958,
+        D3D12_MESSAGE_ID_USE_OF_ZERO_REFCOUNT_OBJECT	= 959,
+        D3D12_MESSAGE_ID_OBJECT_EVICTED_WHILE_STILL_IN_USE	= 960,
+        D3D12_MESSAGE_ID_GPU_BASED_VALIDATION_ROOT_DESCRIPTOR_ACCESS_OUT_OF_BOUNDS	= 961,
+        D3D12_MESSAGE_ID_CREATEPIPELINELIBRARY_INVALIDLIBRARYBLOB	= 962,
+        D3D12_MESSAGE_ID_CREATEPIPELINELIBRARY_DRIVERVERSIONMISMATCH	= 963,
+        D3D12_MESSAGE_ID_CREATEPIPELINELIBRARY_ADAPTERVERSIONMISMATCH	= 964,
+        D3D12_MESSAGE_ID_CREATEPIPELINELIBRARY_UNSUPPORTED	= 965,
+        D3D12_MESSAGE_ID_CREATE_PIPELINELIBRARY	= 966,
+        D3D12_MESSAGE_ID_LIVE_PIPELINELIBRARY	= 967,
+        D3D12_MESSAGE_ID_DESTROY_PIPELINELIBRARY	= 968,
+        D3D12_MESSAGE_ID_STOREPIPELINE_NONAME	= 969,
+        D3D12_MESSAGE_ID_STOREPIPELINE_DUPLICATENAME	= 970,
+        D3D12_MESSAGE_ID_LOADPIPELINE_NAMENOTFOUND	= 971,
+        D3D12_MESSAGE_ID_LOADPIPELINE_INVALIDDESC	= 972,
+        D3D12_MESSAGE_ID_PIPELINELIBRARY_SERIALIZE_NOTENOUGHMEMORY	= 973,
+        D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_PS_OUTPUT_RT_OUTPUT_MISMATCH	= 974,
+        D3D12_MESSAGE_ID_SETEVENTONMULTIPLEFENCECOMPLETION_INVALIDFLAGS	= 975,
+        D3D12_MESSAGE_ID_CREATE_QUEUE_VIDEO_NOT_SUPPORTED	= 976,
+        D3D12_MESSAGE_ID_CREATE_COMMAND_ALLOCATOR_VIDEO_NOT_SUPPORTED	= 977,
+        D3D12_MESSAGE_ID_CREATEQUERY_HEAP_VIDEO_DECODE_STATISTICS_NOT_SUPPORTED	= 978,
+        D3D12_MESSAGE_ID_CREATE_VIDEODECODECOMMANDLIST	= 979,
+        D3D12_MESSAGE_ID_CREATE_VIDEODECODER	= 980,
+        D3D12_MESSAGE_ID_CREATE_VIDEODECODESTREAM	= 981,
+        D3D12_MESSAGE_ID_LIVE_VIDEODECODECOMMANDLIST	= 982,
+        D3D12_MESSAGE_ID_LIVE_VIDEODECODER	= 983,
+        D3D12_MESSAGE_ID_LIVE_VIDEODECODESTREAM	= 984,
+        D3D12_MESSAGE_ID_DESTROY_VIDEODECODECOMMANDLIST	= 985,
+        D3D12_MESSAGE_ID_DESTROY_VIDEODECODER	= 986,
+        D3D12_MESSAGE_ID_DESTROY_VIDEODECODESTREAM	= 987,
+        D3D12_MESSAGE_ID_DECODE_FRAME_INVALID_PARAMETERS	= 988,
+        D3D12_MESSAGE_ID_DEPRECATED_API	= 989,
+        D3D12_MESSAGE_ID_RESOURCE_BARRIER_MISMATCHING_COMMAND_LIST_TYPE	= 990,
+        D3D12_MESSAGE_ID_COMMAND_LIST_DESCRIPTOR_TABLE_NOT_SET	= 991,
+        D3D12_MESSAGE_ID_COMMAND_LIST_ROOT_CONSTANT_BUFFER_VIEW_NOT_SET	= 992,
+        D3D12_MESSAGE_ID_COMMAND_LIST_ROOT_SHADER_RESOURCE_VIEW_NOT_SET	= 993,
+        D3D12_MESSAGE_ID_COMMAND_LIST_ROOT_UNORDERED_ACCESS_VIEW_NOT_SET	= 994,
+        D3D12_MESSAGE_ID_DISCARD_INVALID_SUBRESOURCE_RANGE	= 995,
+        D3D12_MESSAGE_ID_DISCARD_ONE_SUBRESOURCE_FOR_MIPS_WITH_RECTS	= 996,
+        D3D12_MESSAGE_ID_DISCARD_NO_RECTS_FOR_NON_TEXTURE2D	= 997,
+        D3D12_MESSAGE_ID_COPY_ON_SAME_SUBRESOURCE	= 998,
+        D3D12_MESSAGE_ID_SETRESIDENCYPRIORITY_INVALID_PAGEABLE	= 999,
+        D3D12_MESSAGE_ID_GPU_BASED_VALIDATION_UNSUPPORTED	= 1000,
+        D3D12_MESSAGE_ID_STATIC_DESCRIPTOR_INVALID_DESCRIPTOR_CHANGE	= 1001,
+        D3D12_MESSAGE_ID_DATA_STATIC_DESCRIPTOR_INVALID_DATA_CHANGE	= 1002,
+        D3D12_MESSAGE_ID_DATA_STATIC_WHILE_SET_AT_EXECUTE_DESCRIPTOR_INVALID_DATA_CHANGE	= 1003,
+        D3D12_MESSAGE_ID_EXECUTE_BUNDLE_STATIC_DESCRIPTOR_DATA_STATIC_NOT_SET	= 1004,
+        D3D12_MESSAGE_ID_GPU_BASED_VALIDATION_RESOURCE_ACCESS_OUT_OF_BOUNDS	= 1005,
+        D3D12_MESSAGE_ID_GPU_BASED_VALIDATION_SAMPLER_MODE_MISMATCH	= 1006,
+        D3D12_MESSAGE_ID_CREATE_FENCE_INVALID_FLAGS	= 1007,
+        D3D12_MESSAGE_ID_RESOURCE_BARRIER_DUPLICATE_SUBRESOURCE_TRANSITIONS	= 1008,
+        D3D12_MESSAGE_ID_SETRESIDENCYPRIORITY_INVALID_PRIORITY	= 1009,
+        D3D12_MESSAGE_ID_CREATE_DESCRIPTOR_HEAP_LARGE_NUM_DESCRIPTORS	= 1013,
+        D3D12_MESSAGE_ID_BEGIN_EVENT	= 1014,
+        D3D12_MESSAGE_ID_END_EVENT	= 1015,
+        D3D12_MESSAGE_ID_CREATEDEVICE_DEBUG_LAYER_STARTUP_OPTIONS	= 1016,
+        D3D12_MESSAGE_ID_CREATEDEPTHSTENCILSTATE_DEPTHBOUNDSTEST_UNSUPPORTED	= 1017,
+        D3D12_MESSAGE_ID_CREATEPIPELINESTATE_DUPLICATE_SUBOBJECT	= 1018,
+        D3D12_MESSAGE_ID_CREATEPIPELINESTATE_UNKNOWN_SUBOBJECT	= 1019,
+        D3D12_MESSAGE_ID_CREATEPIPELINESTATE_ZERO_SIZE_STREAM	= 1020,
+        D3D12_MESSAGE_ID_CREATEPIPELINESTATE_INVALID_STREAM	= 1021,
+        D3D12_MESSAGE_ID_CREATEPIPELINESTATE_CANNOT_DEDUCE_TYPE	= 1022,
+        D3D12_MESSAGE_ID_COMMAND_LIST_STATIC_DESCRIPTOR_RESOURCE_DIMENSION_MISMATCH	= 1023,
+        D3D12_MESSAGE_ID_CREATE_COMMAND_QUEUE_INSUFFICIENT_PRIVILEGE_FOR_GLOBAL_REALTIME	= 1024,
+        D3D12_MESSAGE_ID_CREATE_COMMAND_QUEUE_INSUFFICIENT_HARDWARE_SUPPORT_FOR_GLOBAL_REALTIME	= 1025,
+        D3D12_MESSAGE_ID_ATOMICCOPYBUFFER_INVALID_ARCHITECTURE	= 1026,
+        D3D12_MESSAGE_ID_ATOMICCOPYBUFFER_NULL_DST	= 1027,
+        D3D12_MESSAGE_ID_ATOMICCOPYBUFFER_INVALID_DST_RESOURCE_DIMENSION	= 1028,
+        D3D12_MESSAGE_ID_ATOMICCOPYBUFFER_DST_RANGE_OUT_OF_BOUNDS	= 1029,
+        D3D12_MESSAGE_ID_ATOMICCOPYBUFFER_NULL_SRC	= 1030,
+        D3D12_MESSAGE_ID_ATOMICCOPYBUFFER_INVALID_SRC_RESOURCE_DIMENSION	= 1031,
+        D3D12_MESSAGE_ID_ATOMICCOPYBUFFER_SRC_RANGE_OUT_OF_BOUNDS	= 1032,
+        D3D12_MESSAGE_ID_ATOMICCOPYBUFFER_INVALID_OFFSET_ALIGNMENT	= 1033,
+        D3D12_MESSAGE_ID_ATOMICCOPYBUFFER_NULL_DEPENDENT_RESOURCES	= 1034,
+        D3D12_MESSAGE_ID_ATOMICCOPYBUFFER_NULL_DEPENDENT_SUBRESOURCE_RANGES	= 1035,
+        D3D12_MESSAGE_ID_ATOMICCOPYBUFFER_INVALID_DEPENDENT_RESOURCE	= 1036,
+        D3D12_MESSAGE_ID_ATOMICCOPYBUFFER_INVALID_DEPENDENT_SUBRESOURCE_RANGE	= 1037,
+        D3D12_MESSAGE_ID_ATOMICCOPYBUFFER_DEPENDENT_SUBRESOURCE_OUT_OF_BOUNDS	= 1038,
+        D3D12_MESSAGE_ID_ATOMICCOPYBUFFER_DEPENDENT_RANGE_OUT_OF_BOUNDS	= 1039,
+        D3D12_MESSAGE_ID_ATOMICCOPYBUFFER_ZERO_DEPENDENCIES	= 1040,
+        D3D12_MESSAGE_ID_DEVICE_CREATE_SHARED_HANDLE_INVALIDARG	= 1041,
+        D3D12_MESSAGE_ID_DESCRIPTOR_HANDLE_WITH_INVALID_RESOURCE	= 1042,
+        D3D12_MESSAGE_ID_SETDEPTHBOUNDS_INVALIDARGS	= 1043,
+        D3D12_MESSAGE_ID_GPU_BASED_VALIDATION_RESOURCE_STATE_IMPRECISE	= 1044,
+        D3D12_MESSAGE_ID_COMMAND_LIST_PIPELINE_STATE_NOT_SET	= 1045,
+        D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_SHADER_MODEL_MISMATCH	= 1046,
+        D3D12_MESSAGE_ID_OBJECT_ACCESSED_WHILE_STILL_IN_USE	= 1047,
+        D3D12_MESSAGE_ID_PROGRAMMABLE_MSAA_UNSUPPORTED	= 1048,
+        D3D12_MESSAGE_ID_SETSAMPLEPOSITIONS_INVALIDARGS	= 1049,
+        D3D12_MESSAGE_ID_RESOLVESUBRESOURCEREGION_INVALID_RECT	= 1050,
+        D3D12_MESSAGE_ID_CREATE_VIDEODECODECOMMANDQUEUE	= 1051,
+        D3D12_MESSAGE_ID_CREATE_VIDEOPROCESSCOMMANDLIST	= 1052,
+        D3D12_MESSAGE_ID_CREATE_VIDEOPROCESSCOMMANDQUEUE	= 1053,
+        D3D12_MESSAGE_ID_LIVE_VIDEODECODECOMMANDQUEUE	= 1054,
+        D3D12_MESSAGE_ID_LIVE_VIDEOPROCESSCOMMANDLIST	= 1055,
+        D3D12_MESSAGE_ID_LIVE_VIDEOPROCESSCOMMANDQUEUE	= 1056,
+        D3D12_MESSAGE_ID_DESTROY_VIDEODECODECOMMANDQUEUE	= 1057,
+        D3D12_MESSAGE_ID_DESTROY_VIDEOPROCESSCOMMANDLIST	= 1058,
+        D3D12_MESSAGE_ID_DESTROY_VIDEOPROCESSCOMMANDQUEUE	= 1059,
+        D3D12_MESSAGE_ID_CREATE_VIDEOPROCESSOR	= 1060,
+        D3D12_MESSAGE_ID_CREATE_VIDEOPROCESSSTREAM	= 1061,
+        D3D12_MESSAGE_ID_LIVE_VIDEOPROCESSOR	= 1062,
+        D3D12_MESSAGE_ID_LIVE_VIDEOPROCESSSTREAM	= 1063,
+        D3D12_MESSAGE_ID_DESTROY_VIDEOPROCESSOR	= 1064,
+        D3D12_MESSAGE_ID_DESTROY_VIDEOPROCESSSTREAM	= 1065,
+        D3D12_MESSAGE_ID_PROCESS_FRAME_INVALID_PARAMETERS	= 1066,
+        D3D12_MESSAGE_ID_COPY_INVALIDLAYOUT	= 1067,
+        D3D12_MESSAGE_ID_CREATE_CRYPTO_SESSION	= 1068,
+        D3D12_MESSAGE_ID_CREATE_CRYPTO_SESSION_POLICY	= 1069,
+        D3D12_MESSAGE_ID_CREATE_PROTECTED_RESOURCE_SESSION	= 1070,
+        D3D12_MESSAGE_ID_LIVE_CRYPTO_SESSION	= 1071,
+        D3D12_MESSAGE_ID_LIVE_CRYPTO_SESSION_POLICY	= 1072,
+        D3D12_MESSAGE_ID_LIVE_PROTECTED_RESOURCE_SESSION	= 1073,
+        D3D12_MESSAGE_ID_DESTROY_CRYPTO_SESSION	= 1074,
+        D3D12_MESSAGE_ID_DESTROY_CRYPTO_SESSION_POLICY	= 1075,
+        D3D12_MESSAGE_ID_DESTROY_PROTECTED_RESOURCE_SESSION	= 1076,
+        D3D12_MESSAGE_ID_PROTECTED_RESOURCE_SESSION_UNSUPPORTED	= 1077,
+        D3D12_MESSAGE_ID_FENCE_INVALIDOPERATION	= 1078,
+        D3D12_MESSAGE_ID_CREATEQUERY_HEAP_COPY_QUEUE_TIMESTAMPS_NOT_SUPPORTED	= 1079,
+        D3D12_MESSAGE_ID_SAMPLEPOSITIONS_MISMATCH_DEFERRED	= 1080,
+        D3D12_MESSAGE_ID_SAMPLEPOSITIONS_MISMATCH_RECORDTIME_ASSUMEDFROMFIRSTUSE	= 1081,
+        D3D12_MESSAGE_ID_SAMPLEPOSITIONS_MISMATCH_RECORDTIME_ASSUMEDFROMCLEAR	= 1082,
+        D3D12_MESSAGE_ID_CREATE_VIDEODECODERHEAP	= 1083,
+        D3D12_MESSAGE_ID_LIVE_VIDEODECODERHEAP	= 1084,
+        D3D12_MESSAGE_ID_DESTROY_VIDEODECODERHEAP	= 1085,
+        D3D12_MESSAGE_ID_OPENEXISTINGHEAP_INVALIDARG_RETURN	= 1086,
+        D3D12_MESSAGE_ID_OPENEXISTINGHEAP_OUTOFMEMORY_RETURN	= 1087,
+        D3D12_MESSAGE_ID_OPENEXISTINGHEAP_INVALIDADDRESS	= 1088,
+        D3D12_MESSAGE_ID_OPENEXISTINGHEAP_INVALIDHANDLE	= 1089,
+        D3D12_MESSAGE_ID_WRITEBUFFERIMMEDIATE_INVALID_DEST	= 1090,
+        D3D12_MESSAGE_ID_WRITEBUFFERIMMEDIATE_INVALID_MODE	= 1091,
+        D3D12_MESSAGE_ID_WRITEBUFFERIMMEDIATE_INVALID_ALIGNMENT	= 1092,
+        D3D12_MESSAGE_ID_WRITEBUFFERIMMEDIATE_NOT_SUPPORTED	= 1093,
+        D3D12_MESSAGE_ID_SETVIEWINSTANCEMASK_INVALIDARGS	= 1094,
+        D3D12_MESSAGE_ID_VIEW_INSTANCING_UNSUPPORTED	= 1095,
+        D3D12_MESSAGE_ID_VIEW_INSTANCING_INVALIDARGS	= 1096,
+        D3D12_MESSAGE_ID_COPYTEXTUREREGION_MISMATCH_DECODE_REFERENCE_ONLY_FLAG	= 1097,
+        D3D12_MESSAGE_ID_COPYRESOURCE_MISMATCH_DECODE_REFERENCE_ONLY_FLAG	= 1098,
+        D3D12_MESSAGE_ID_CREATE_VIDEO_DECODE_HEAP_CAPS_FAILURE	= 1099,
+        D3D12_MESSAGE_ID_CREATE_VIDEO_DECODE_HEAP_CAPS_UNSUPPORTED	= 1100,
+        D3D12_MESSAGE_ID_VIDEO_DECODE_SUPPORT_INVALID_INPUT	= 1101,
+        D3D12_MESSAGE_ID_CREATE_VIDEO_DECODER_UNSUPPORTED	= 1102,
+        D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_METADATA_ERROR	= 1103,
+        D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_VIEW_INSTANCING_VERTEX_SIZE_EXCEEDED	= 1104,
+        D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_RUNTIME_INTERNAL_ERROR	= 1105,
+        D3D12_MESSAGE_ID_NO_VIDEO_API_SUPPORT	= 1106,
+        D3D12_MESSAGE_ID_VIDEO_PROCESS_SUPPORT_INVALID_INPUT	= 1107,
+        D3D12_MESSAGE_ID_CREATE_VIDEO_PROCESSOR_CAPS_FAILURE	= 1108,
+        D3D12_MESSAGE_ID_VIDEO_PROCESS_SUPPORT_UNSUPPORTED_FORMAT	= 1109,
+        D3D12_MESSAGE_ID_VIDEO_DECODE_FRAME_INVALID_ARGUMENT	= 1110,
+        D3D12_MESSAGE_ID_ENQUEUE_MAKE_RESIDENT_INVALID_FLAGS	= 1111,
+        D3D12_MESSAGE_ID_OPENEXISTINGHEAP_UNSUPPORTED	= 1112,
+        D3D12_MESSAGE_ID_VIDEO_PROCESS_FRAMES_INVALID_ARGUMENT	= 1113,
+        D3D12_MESSAGE_ID_VIDEO_DECODE_SUPPORT_UNSUPPORTED	= 1114,
+        D3D12_MESSAGE_ID_CREATE_COMMANDRECORDER	= 1115,
+        D3D12_MESSAGE_ID_LIVE_COMMANDRECORDER	= 1116,
+        D3D12_MESSAGE_ID_DESTROY_COMMANDRECORDER	= 1117,
+        D3D12_MESSAGE_ID_CREATE_COMMAND_RECORDER_VIDEO_NOT_SUPPORTED	= 1118,
+        D3D12_MESSAGE_ID_CREATE_COMMAND_RECORDER_INVALID_SUPPORT_FLAGS	= 1119,
+        D3D12_MESSAGE_ID_CREATE_COMMAND_RECORDER_INVALID_FLAGS	= 1120,
+        D3D12_MESSAGE_ID_CREATE_COMMAND_RECORDER_MORE_RECORDERS_THAN_LOGICAL_PROCESSORS	= 1121,
+        D3D12_MESSAGE_ID_CREATE_COMMANDPOOL	= 1122,
+        D3D12_MESSAGE_ID_LIVE_COMMANDPOOL	= 1123,
+        D3D12_MESSAGE_ID_DESTROY_COMMANDPOOL	= 1124,
+        D3D12_MESSAGE_ID_CREATE_COMMAND_POOL_INVALID_FLAGS	= 1125,
+        D3D12_MESSAGE_ID_CREATE_COMMAND_LIST_VIDEO_NOT_SUPPORTED	= 1126,
+        D3D12_MESSAGE_ID_COMMAND_RECORDER_SUPPORT_FLAGS_MISMATCH	= 1127,
+        D3D12_MESSAGE_ID_COMMAND_RECORDER_CONTENTION	= 1128,
+        D3D12_MESSAGE_ID_COMMAND_RECORDER_USAGE_WITH_CREATECOMMANDLIST_COMMAND_LIST	= 1129,
+        D3D12_MESSAGE_ID_COMMAND_ALLOCATOR_USAGE_WITH_CREATECOMMANDLIST1_COMMAND_LIST	= 1130,
+        D3D12_MESSAGE_ID_CANNOT_EXECUTE_EMPTY_COMMAND_LIST	= 1131,
+        D3D12_MESSAGE_ID_CANNOT_RESET_COMMAND_POOL_WITH_OPEN_COMMAND_LISTS	= 1132,
+        D3D12_MESSAGE_ID_CANNOT_USE_COMMAND_RECORDER_WITHOUT_CURRENT_TARGET	= 1133,
+        D3D12_MESSAGE_ID_CANNOT_CHANGE_COMMAND_RECORDER_TARGET_WHILE_RECORDING	= 1134,
+        D3D12_MESSAGE_ID_COMMAND_POOL_SYNC	= 1135,
+        D3D12_MESSAGE_ID_EVICT_UNDERFLOW	= 1136,
+        D3D12_MESSAGE_ID_CREATE_META_COMMAND	= 1137,
+        D3D12_MESSAGE_ID_LIVE_META_COMMAND	= 1138,
+        D3D12_MESSAGE_ID_DESTROY_META_COMMAND	= 1139,
+        D3D12_MESSAGE_ID_COPYBUFFERREGION_INVALID_DST_RESOURCE	= 1140,
+        D3D12_MESSAGE_ID_COPYBUFFERREGION_INVALID_SRC_RESOURCE	= 1141,
+        D3D12_MESSAGE_ID_ATOMICCOPYBUFFER_INVALID_DST_RESOURCE	= 1142,
+        D3D12_MESSAGE_ID_ATOMICCOPYBUFFER_INVALID_SRC_RESOURCE	= 1143,
+        D3D12_MESSAGE_ID_CREATEPLACEDRESOURCEONBUFFER_NULL_BUFFER	= 1144,
+        D3D12_MESSAGE_ID_CREATEPLACEDRESOURCEONBUFFER_NULL_RESOURCE_DESC	= 1145,
+        D3D12_MESSAGE_ID_CREATEPLACEDRESOURCEONBUFFER_UNSUPPORTED	= 1146,
+        D3D12_MESSAGE_ID_CREATEPLACEDRESOURCEONBUFFER_INVALID_BUFFER_DIMENSION	= 1147,
+        D3D12_MESSAGE_ID_CREATEPLACEDRESOURCEONBUFFER_INVALID_BUFFER_FLAGS	= 1148,
+        D3D12_MESSAGE_ID_CREATEPLACEDRESOURCEONBUFFER_INVALID_BUFFER_OFFSET	= 1149,
+        D3D12_MESSAGE_ID_CREATEPLACEDRESOURCEONBUFFER_INVALID_RESOURCE_DIMENSION	= 1150,
+        D3D12_MESSAGE_ID_CREATEPLACEDRESOURCEONBUFFER_INVALID_RESOURCE_FLAGS	= 1151,
+        D3D12_MESSAGE_ID_CREATEPLACEDRESOURCEONBUFFER_OUTOFMEMORY_RETURN	= 1152,
+        D3D12_MESSAGE_ID_CANNOT_CREATE_GRAPHICS_AND_VIDEO_COMMAND_RECORDER	= 1153,
+        D3D12_MESSAGE_ID_UPDATETILEMAPPINGS_POSSIBLY_MISMATCHING_PROPERTIES	= 1154,
+        D3D12_MESSAGE_ID_CREATE_COMMAND_LIST_INVALID_COMMAND_LIST_TYPE	= 1155,
+        D3D12_MESSAGE_ID_CLEARUNORDEREDACCESSVIEW_INCOMPATIBLE_WITH_STRUCTURED_BUFFERS	= 1156,
+        D3D12_MESSAGE_ID_COMPUTE_ONLY_DEVICE_OPERATION_UNSUPPORTED	= 1157,
+        D3D12_MESSAGE_ID_BUILD_RAYTRACING_ACCELERATION_STRUCTURE_INVALID	= 1158,
+        D3D12_MESSAGE_ID_EMIT_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_INVALID	= 1159,
+        D3D12_MESSAGE_ID_COPY_RAYTRACING_ACCELERATION_STRUCTURE_INVALID	= 1160,
+        D3D12_MESSAGE_ID_DISPATCH_RAYS_INVALID	= 1161,
+        D3D12_MESSAGE_ID_GET_RAYTRACING_ACCELERATION_STRUCTURE_PREBUILD_INFO_INVALID	= 1162,
+        D3D12_MESSAGE_ID_CREATE_LIFETIMETRACKER	= 1163,
+        D3D12_MESSAGE_ID_LIVE_LIFETIMETRACKER	= 1164,
+        D3D12_MESSAGE_ID_DESTROY_LIFETIMETRACKER	= 1165,
+        D3D12_MESSAGE_ID_DESTROYOWNEDOBJECT_OBJECTNOTOWNED	= 1166,
+        D3D12_MESSAGE_ID_CREATE_TRACKEDWORKLOAD	= 1167,
+        D3D12_MESSAGE_ID_LIVE_TRACKEDWORKLOAD	= 1168,
+        D3D12_MESSAGE_ID_DESTROY_TRACKEDWORKLOAD	= 1169,
+        D3D12_MESSAGE_ID_RENDER_PASS_ERROR	= 1170,
+        D3D12_MESSAGE_ID_META_COMMAND_ID_INVALID	= 1171,
+        D3D12_MESSAGE_ID_META_COMMAND_UNSUPPORTED_PARAMS	= 1172,
+        D3D12_MESSAGE_ID_META_COMMAND_FAILED_ENUMERATION	= 1173,
+        D3D12_MESSAGE_ID_META_COMMAND_PARAMETER_SIZE_MISMATCH	= 1174,
+        D3D12_MESSAGE_ID_UNINITIALIZED_META_COMMAND	= 1175,
+        D3D12_MESSAGE_ID_META_COMMAND_INVALID_GPU_VIRTUAL_ADDRESS	= 1176,
+        D3D12_MESSAGE_ID_CREATE_VIDEOENCODECOMMANDLIST	= 1177,
+        D3D12_MESSAGE_ID_LIVE_VIDEOENCODECOMMANDLIST	= 1178,
+        D3D12_MESSAGE_ID_DESTROY_VIDEOENCODECOMMANDLIST	= 1179,
+        D3D12_MESSAGE_ID_CREATE_VIDEOENCODECOMMANDQUEUE	= 1180,
+        D3D12_MESSAGE_ID_LIVE_VIDEOENCODECOMMANDQUEUE	= 1181,
+        D3D12_MESSAGE_ID_DESTROY_VIDEOENCODECOMMANDQUEUE	= 1182,
+        D3D12_MESSAGE_ID_CREATE_VIDEOMOTIONESTIMATOR	= 1183,
+        D3D12_MESSAGE_ID_LIVE_VIDEOMOTIONESTIMATOR	= 1184,
+        D3D12_MESSAGE_ID_DESTROY_VIDEOMOTIONESTIMATOR	= 1185,
+        D3D12_MESSAGE_ID_CREATE_VIDEOMOTIONVECTORHEAP	= 1186,
+        D3D12_MESSAGE_ID_LIVE_VIDEOMOTIONVECTORHEAP	= 1187,
+        D3D12_MESSAGE_ID_DESTROY_VIDEOMOTIONVECTORHEAP	= 1188,
+        D3D12_MESSAGE_ID_MULTIPLE_TRACKED_WORKLOADS	= 1189,
+        D3D12_MESSAGE_ID_MULTIPLE_TRACKED_WORKLOAD_PAIRS	= 1190,
+        D3D12_MESSAGE_ID_OUT_OF_ORDER_TRACKED_WORKLOAD_PAIR	= 1191,
+        D3D12_MESSAGE_ID_CANNOT_ADD_TRACKED_WORKLOAD	= 1192,
+        D3D12_MESSAGE_ID_INCOMPLETE_TRACKED_WORKLOAD_PAIR	= 1193,
+        D3D12_MESSAGE_ID_CREATE_STATE_OBJECT_ERROR	= 1194,
+        D3D12_MESSAGE_ID_GET_SHADER_IDENTIFIER_ERROR	= 1195,
+        D3D12_MESSAGE_ID_GET_SHADER_STACK_SIZE_ERROR	= 1196,
+        D3D12_MESSAGE_ID_GET_PIPELINE_STACK_SIZE_ERROR	= 1197,
+        D3D12_MESSAGE_ID_SET_PIPELINE_STACK_SIZE_ERROR	= 1198,
+        D3D12_MESSAGE_ID_GET_SHADER_IDENTIFIER_SIZE_INVALID	= 1199,
+        D3D12_MESSAGE_ID_CHECK_DRIVER_MATCHING_IDENTIFIER_INVALID	= 1200,
+        D3D12_MESSAGE_ID_CHECK_DRIVER_MATCHING_IDENTIFIER_DRIVER_REPORTED_ISSUE	= 1201,
+        D3D12_MESSAGE_ID_RENDER_PASS_INVALID_RESOURCE_BARRIER	= 1202,
+        D3D12_MESSAGE_ID_RENDER_PASS_DISALLOWED_API_CALLED	= 1203,
+        D3D12_MESSAGE_ID_RENDER_PASS_CANNOT_NEST_RENDER_PASSES	= 1204,
+        D3D12_MESSAGE_ID_RENDER_PASS_CANNOT_END_WITHOUT_BEGIN	= 1205,
+        D3D12_MESSAGE_ID_RENDER_PASS_CANNOT_CLOSE_COMMAND_LIST	= 1206,
+        D3D12_MESSAGE_ID_RENDER_PASS_GPU_WORK_WHILE_SUSPENDED	= 1207,
+        D3D12_MESSAGE_ID_RENDER_PASS_MISMATCHING_SUSPEND_RESUME	= 1208,
+        D3D12_MESSAGE_ID_RENDER_PASS_NO_PRIOR_SUSPEND_WITHIN_EXECUTECOMMANDLISTS	= 1209,
+        D3D12_MESSAGE_ID_RENDER_PASS_NO_SUBSEQUENT_RESUME_WITHIN_EXECUTECOMMANDLISTS	= 1210,
+        D3D12_MESSAGE_ID_TRACKED_WORKLOAD_COMMAND_QUEUE_MISMATCH	= 1211,
+        D3D12_MESSAGE_ID_TRACKED_WORKLOAD_NOT_SUPPORTED	= 1212,
+        D3D12_MESSAGE_ID_RENDER_PASS_MISMATCHING_NO_ACCESS	= 1213,
+        D3D12_MESSAGE_ID_RENDER_PASS_UNSUPPORTED_RESOLVE	= 1214,
+        D3D12_MESSAGE_ID_CLEARUNORDEREDACCESSVIEW_INVALID_RESOURCE_PTR	= 1215,
+        D3D12_MESSAGE_ID_WINDOWS7_FENCE_OUTOFORDER_SIGNAL	= 1216,
+        D3D12_MESSAGE_ID_WINDOWS7_FENCE_OUTOFORDER_WAIT	= 1217,
+        D3D12_MESSAGE_ID_VIDEO_CREATE_MOTION_ESTIMATOR_INVALID_ARGUMENT	= 1218,
+        D3D12_MESSAGE_ID_VIDEO_CREATE_MOTION_VECTOR_HEAP_INVALID_ARGUMENT	= 1219,
+        D3D12_MESSAGE_ID_ESTIMATE_MOTION_INVALID_ARGUMENT	= 1220,
+        D3D12_MESSAGE_ID_RESOLVE_MOTION_VECTOR_HEAP_INVALID_ARGUMENT	= 1221,
+        D3D12_MESSAGE_ID_GETGPUVIRTUALADDRESS_INVALID_HEAP_TYPE	= 1222,
+        D3D12_MESSAGE_ID_SET_BACKGROUND_PROCESSING_MODE_INVALID_ARGUMENT	= 1223,
+        D3D12_MESSAGE_ID_CREATE_COMMAND_LIST_INVALID_COMMAND_LIST_TYPE_FOR_FEATURE_LEVEL	= 1224,
+        D3D12_MESSAGE_ID_CREATE_VIDEOEXTENSIONCOMMAND	= 1225,
+        D3D12_MESSAGE_ID_LIVE_VIDEOEXTENSIONCOMMAND	= 1226,
+        D3D12_MESSAGE_ID_DESTROY_VIDEOEXTENSIONCOMMAND	= 1227,
+        D3D12_MESSAGE_ID_INVALID_VIDEO_EXTENSION_COMMAND_ID	= 1228,
+        D3D12_MESSAGE_ID_VIDEO_EXTENSION_COMMAND_INVALID_ARGUMENT	= 1229,
+        D3D12_MESSAGE_ID_CREATE_ROOT_SIGNATURE_NOT_UNIQUE_IN_DXIL_LIBRARY	= 1230,
+        D3D12_MESSAGE_ID_VARIABLE_SHADING_RATE_NOT_ALLOWED_WITH_TIR	= 1231,
+        D3D12_MESSAGE_ID_GEOMETRY_SHADER_OUTPUTTING_BOTH_VIEWPORT_ARRAY_INDEX_AND_SHADING_RATE_NOT_SUPPORTED_ON_DEVICE	= 1232,
+        D3D12_MESSAGE_ID_RSSETSHADING_RATE_INVALID_SHADING_RATE	= 1233,
+        D3D12_MESSAGE_ID_RSSETSHADING_RATE_SHADING_RATE_NOT_PERMITTED_BY_CAP	= 1234,
+        D3D12_MESSAGE_ID_RSSETSHADING_RATE_INVALID_COMBINER	= 1235,
+        D3D12_MESSAGE_ID_RSSETSHADINGRATEIMAGE_REQUIRES_TIER_2	= 1236,
+        D3D12_MESSAGE_ID_RSSETSHADINGRATE_REQUIRES_TIER_1	= 1237,
+        D3D12_MESSAGE_ID_SHADING_RATE_IMAGE_INCORRECT_FORMAT	= 1238,
+        D3D12_MESSAGE_ID_SHADING_RATE_IMAGE_INCORRECT_ARRAY_SIZE	= 1239,
+        D3D12_MESSAGE_ID_SHADING_RATE_IMAGE_INCORRECT_MIP_LEVEL	= 1240,
+        D3D12_MESSAGE_ID_SHADING_RATE_IMAGE_INCORRECT_SAMPLE_COUNT	= 1241,
+        D3D12_MESSAGE_ID_SHADING_RATE_IMAGE_INCORRECT_SAMPLE_QUALITY	= 1242,
+        D3D12_MESSAGE_ID_NON_RETAIL_SHADER_MODEL_WONT_VALIDATE	= 1243,
+        D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_AS_ROOT_SIGNATURE_MISMATCH	= 1244,
+        D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_MS_ROOT_SIGNATURE_MISMATCH	= 1245,
+        D3D12_MESSAGE_ID_ADD_TO_STATE_OBJECT_ERROR	= 1246,
+        D3D12_MESSAGE_ID_CREATE_PROTECTED_RESOURCE_SESSION_INVALID_ARGUMENT	= 1247,
+        D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_MS_PSO_DESC_MISMATCH	= 1248,
+        D3D12_MESSAGE_ID_CREATEPIPELINESTATE_MS_INCOMPLETE_TYPE	= 1249,
+        D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_AS_NOT_MS_MISMATCH	= 1250,
+        D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_MS_NOT_PS_MISMATCH	= 1251,
+        D3D12_MESSAGE_ID_NONZERO_SAMPLER_FEEDBACK_MIP_REGION_WITH_INCOMPATIBLE_FORMAT	= 1252,
+        D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_INPUTLAYOUT_SHADER_MISMATCH	= 1253,
+        D3D12_MESSAGE_ID_EMPTY_DISPATCH	= 1254,
+        D3D12_MESSAGE_ID_RESOURCE_FORMAT_REQUIRES_SAMPLER_FEEDBACK_CAPABILITY	= 1255,
+        D3D12_MESSAGE_ID_SAMPLER_FEEDBACK_MAP_INVALID_MIP_REGION	= 1256,
+        D3D12_MESSAGE_ID_SAMPLER_FEEDBACK_MAP_INVALID_DIMENSION	= 1257,
+        D3D12_MESSAGE_ID_SAMPLER_FEEDBACK_MAP_INVALID_SAMPLE_COUNT	= 1258,
+        D3D12_MESSAGE_ID_SAMPLER_FEEDBACK_MAP_INVALID_SAMPLE_QUALITY	= 1259,
+        D3D12_MESSAGE_ID_SAMPLER_FEEDBACK_MAP_INVALID_LAYOUT	= 1260,
+        D3D12_MESSAGE_ID_SAMPLER_FEEDBACK_MAP_REQUIRES_UNORDERED_ACCESS_FLAG	= 1261,
+        D3D12_MESSAGE_ID_SAMPLER_FEEDBACK_CREATE_UAV_NULL_ARGUMENTS	= 1262,
+        D3D12_MESSAGE_ID_SAMPLER_FEEDBACK_UAV_REQUIRES_SAMPLER_FEEDBACK_CAPABILITY	= 1263,
+        D3D12_MESSAGE_ID_SAMPLER_FEEDBACK_CREATE_UAV_REQUIRES_FEEDBACK_MAP_FORMAT	= 1264,
+        D3D12_MESSAGE_ID_CREATEMESHSHADER_INVALIDSHADERBYTECODE	= 1265,
+        D3D12_MESSAGE_ID_CREATEMESHSHADER_OUTOFMEMORY	= 1266,
+        D3D12_MESSAGE_ID_CREATEMESHSHADERWITHSTREAMOUTPUT_INVALIDSHADERTYPE	= 1267,
+        D3D12_MESSAGE_ID_RESOLVESUBRESOURCE_SAMPLER_FEEDBACK_TRANSCODE_INVALID_FORMAT	= 1268,
+        D3D12_MESSAGE_ID_RESOLVESUBRESOURCE_SAMPLER_FEEDBACK_INVALID_MIP_LEVEL_COUNT	= 1269,
+        D3D12_MESSAGE_ID_RESOLVESUBRESOURCE_SAMPLER_FEEDBACK_TRANSCODE_ARRAY_SIZE_MISMATCH	= 1270,
+        D3D12_MESSAGE_ID_SAMPLER_FEEDBACK_CREATE_UAV_MISMATCHING_TARGETED_RESOURCE	= 1271,
+        D3D12_MESSAGE_ID_CREATEMESHSHADER_OUTPUTEXCEEDSMAXSIZE	= 1272,
+        D3D12_MESSAGE_ID_CREATEMESHSHADER_GROUPSHAREDEXCEEDSMAXSIZE	= 1273,
+        D3D12_MESSAGE_ID_VERTEX_SHADER_OUTPUTTING_BOTH_VIEWPORT_ARRAY_INDEX_AND_SHADING_RATE_NOT_SUPPORTED_ON_DEVICE	= 1274,
+        D3D12_MESSAGE_ID_MESH_SHADER_OUTPUTTING_BOTH_VIEWPORT_ARRAY_INDEX_AND_SHADING_RATE_NOT_SUPPORTED_ON_DEVICE	= 1275,
+        D3D12_MESSAGE_ID_CREATEMESHSHADER_MISMATCHEDASMSPAYLOADSIZE	= 1276,
+        D3D12_MESSAGE_ID_CREATE_ROOT_SIGNATURE_UNBOUNDED_STATIC_DESCRIPTORS	= 1277,
+        D3D12_MESSAGE_ID_CREATEAMPLIFICATIONSHADER_INVALIDSHADERBYTECODE	= 1278,
+        D3D12_MESSAGE_ID_CREATEAMPLIFICATIONSHADER_OUTOFMEMORY	= 1279,
+        D3D12_MESSAGE_ID_CREATE_SHADERCACHESESSION	= 1280,
+        D3D12_MESSAGE_ID_LIVE_SHADERCACHESESSION	= 1281,
+        D3D12_MESSAGE_ID_DESTROY_SHADERCACHESESSION	= 1282,
+        D3D12_MESSAGE_ID_CREATESHADERCACHESESSION_INVALIDARGS	= 1283,
+        D3D12_MESSAGE_ID_CREATESHADERCACHESESSION_DISABLED	= 1284,
+        D3D12_MESSAGE_ID_CREATESHADERCACHESESSION_ALREADYOPEN	= 1285,
+        D3D12_MESSAGE_ID_SHADERCACHECONTROL_DEVELOPERMODE	= 1286,
+        D3D12_MESSAGE_ID_SHADERCACHECONTROL_INVALIDFLAGS	= 1287,
+        D3D12_MESSAGE_ID_SHADERCACHECONTROL_STATEALREADYSET	= 1288,
+        D3D12_MESSAGE_ID_SHADERCACHECONTROL_IGNOREDFLAG	= 1289,
+        D3D12_MESSAGE_ID_SHADERCACHESESSION_STOREVALUE_ALREADYPRESENT	= 1290,
+        D3D12_MESSAGE_ID_SHADERCACHESESSION_STOREVALUE_HASHCOLLISION	= 1291,
+        D3D12_MESSAGE_ID_SHADERCACHESESSION_STOREVALUE_CACHEFULL	= 1292,
+        D3D12_MESSAGE_ID_SHADERCACHESESSION_FINDVALUE_NOTFOUND	= 1293,
+        D3D12_MESSAGE_ID_SHADERCACHESESSION_CORRUPT	= 1294,
+        D3D12_MESSAGE_ID_SHADERCACHESESSION_DISABLED	= 1295,
+        D3D12_MESSAGE_ID_OVERSIZED_DISPATCH	= 1296,
+        D3D12_MESSAGE_ID_CREATE_VIDEOENCODER	= 1297,
+        D3D12_MESSAGE_ID_LIVE_VIDEOENCODER	= 1298,
+        D3D12_MESSAGE_ID_DESTROY_VIDEOENCODER	= 1299,
+        D3D12_MESSAGE_ID_CREATE_VIDEOENCODERHEAP	= 1300,
+        D3D12_MESSAGE_ID_LIVE_VIDEOENCODERHEAP	= 1301,
+        D3D12_MESSAGE_ID_DESTROY_VIDEOENCODERHEAP	= 1302,
+        D3D12_MESSAGE_ID_COPYTEXTUREREGION_MISMATCH_ENCODE_REFERENCE_ONLY_FLAG	= 1303,
+        D3D12_MESSAGE_ID_COPYRESOURCE_MISMATCH_ENCODE_REFERENCE_ONLY_FLAG	= 1304,
+        D3D12_MESSAGE_ID_ENCODE_FRAME_INVALID_PARAMETERS	= 1305,
+        D3D12_MESSAGE_ID_ENCODE_FRAME_UNSUPPORTED_PARAMETERS	= 1306,
+        D3D12_MESSAGE_ID_RESOLVE_ENCODER_OUTPUT_METADATA_INVALID_PARAMETERS	= 1307,
+        D3D12_MESSAGE_ID_RESOLVE_ENCODER_OUTPUT_METADATA_UNSUPPORTED_PARAMETERS	= 1308,
+        D3D12_MESSAGE_ID_CREATE_VIDEO_ENCODER_INVALID_PARAMETERS	= 1309,
+        D3D12_MESSAGE_ID_CREATE_VIDEO_ENCODER_UNSUPPORTED_PARAMETERS	= 1310,
+        D3D12_MESSAGE_ID_CREATE_VIDEO_ENCODER_HEAP_INVALID_PARAMETERS	= 1311,
+        D3D12_MESSAGE_ID_CREATE_VIDEO_ENCODER_HEAP_UNSUPPORTED_PARAMETERS	= 1312,
+        D3D12_MESSAGE_ID_CREATECOMMANDLIST_NULL_COMMANDALLOCATOR	= 1313,
+        D3D12_MESSAGE_ID_CLEAR_UNORDERED_ACCESS_VIEW_INVALID_DESCRIPTOR_HANDLE	= 1314,
+        D3D12_MESSAGE_ID_DESCRIPTOR_HEAP_NOT_SHADER_VISIBLE	= 1315,
+        D3D12_MESSAGE_ID_CREATEBLENDSTATE_BLENDOP_WARNING	= 1316,
+        D3D12_MESSAGE_ID_CREATEBLENDSTATE_BLENDOPALPHA_WARNING	= 1317,
+        D3D12_MESSAGE_ID_WRITE_COMBINE_PERFORMANCE_WARNING	= 1318,
+        D3D12_MESSAGE_ID_RESOLVE_QUERY_INVALID_QUERY_STATE	= 1319,
+        D3D12_MESSAGE_ID_SETPRIVATEDATA_NO_ACCESS	= 1320,
+        D3D12_MESSAGE_ID_COMMAND_LIST_STATIC_DESCRIPTOR_SAMPLER_MODE_MISMATCH	= 1321,
+        D3D12_MESSAGE_ID_GETCOPYABLEFOOTPRINTS_UNSUPPORTED_BUFFER_WIDTH	= 1322,
+        D3D12_MESSAGE_ID_CREATEMESHSHADER_TOPOLOGY_MISMATCH	= 1323,
+        D3D12_MESSAGE_ID_VRS_SUM_COMBINER_REQUIRES_CAPABILITY	= 1324,
+        D3D12_MESSAGE_ID_SETTING_SHADING_RATE_FROM_MS_REQUIRES_CAPABILITY	= 1325,
+        D3D12_MESSAGE_ID_SHADERCACHESESSION_SHADERCACHEDELETE_NOTSUPPORTED	= 1326,
+        D3D12_MESSAGE_ID_SHADERCACHECONTROL_SHADERCACHECLEAR_NOTSUPPORTED	= 1327,
+        D3D12_MESSAGE_ID_CREATERESOURCE_STATE_IGNORED	= 1328,
+        D3D12_MESSAGE_ID_UNUSED_CROSS_EXECUTE_SPLIT_BARRIER	= 1329,
+        D3D12_MESSAGE_ID_DEVICE_OPEN_SHARED_HANDLE_ACCESS_DENIED	= 1330,
+        D3D12_MESSAGE_ID_INCOMPATIBLE_BARRIER_VALUES	= 1331,
+        D3D12_MESSAGE_ID_INCOMPATIBLE_BARRIER_ACCESS	= 1332,
+        D3D12_MESSAGE_ID_INCOMPATIBLE_BARRIER_SYNC	= 1333,
+        D3D12_MESSAGE_ID_INCOMPATIBLE_BARRIER_LAYOUT	= 1334,
+        D3D12_MESSAGE_ID_INCOMPATIBLE_BARRIER_TYPE	= 1335,
+        D3D12_MESSAGE_ID_OUT_OF_BOUNDS_BARRIER_SUBRESOURCE_RANGE	= 1336,
+        D3D12_MESSAGE_ID_INCOMPATIBLE_BARRIER_RESOURCE_DIMENSION	= 1337,
+        D3D12_MESSAGE_ID_SET_SCISSOR_RECTS_INVALID_RECT	= 1338,
+        D3D12_MESSAGE_ID_SHADING_RATE_SOURCE_REQUIRES_DIMENSION_TEXTURE2D	= 1339,
+        D3D12_MESSAGE_ID_BUFFER_BARRIER_SUBREGION_OUT_OF_BOUNDS	= 1340,
+        D3D12_MESSAGE_ID_UNSUPPORTED_BARRIER_LAYOUT	= 1341,
+        D3D12_MESSAGE_ID_CREATERESOURCEANDHEAP_INVALID_PARAMETERS	= 1342,
+        D3D12_MESSAGE_ID_ENHANCED_BARRIERS_NOT_SUPPORTED	= 1343,
+        D3D12_MESSAGE_ID_CAST_TARGET_TEXEL_SIZE_MISMATCH	= 1344,
+        D3D12_MESSAGE_ID_CAST_TO_PLANAR_NOT_SUPORTED	= 1345,
+        D3D12_MESSAGE_ID_LEGACY_BARRIER_VALIDATION_FORCED_ON	= 1346,
+        D3D12_MESSAGE_ID_EMPTY_ROOT_DESCRIPTOR_TABLE	= 1347,
+        D3D12_MESSAGE_ID_COMMAND_LIST_DRAW_ELEMENT_OFFSET_UNALIGNED	= 1348,
+        D3D12_MESSAGE_ID_ALPHA_BLEND_FACTOR_NOT_SUPPORTED	= 1349,
+        D3D12_MESSAGE_ID_BARRIER_INTEROP_INVALID_LAYOUT	= 1350,
+        D3D12_MESSAGE_ID_BARRIER_INTEROP_INVALID_STATE	= 1351,
+        D3D12_MESSAGE_ID_GRAPHICS_PIPELINE_STATE_DESC_ZERO_SAMPLE_MASK	= 1352,
+        D3D12_MESSAGE_ID_INDEPENDENT_STENCIL_REF_NOT_SUPPORTED	= 1353,
+        D3D12_MESSAGE_ID_CREATEDEPTHSTENCILSTATE_INDEPENDENT_MASKS_UNSUPPORTED	= 1354,
+        D3D12_MESSAGE_ID_TEXTURE_BARRIER_SUBRESOURCES_OUT_OF_BOUNDS	= 1355,
+        D3D12_MESSAGE_ID_NON_OPTIMAL_BARRIER_ONLY_EXECUTE_COMMAND_LISTS	= 1356,
+        D3D12_MESSAGE_ID_EXECUTE_INDIRECT_ZERO_COMMAND_COUNT	= 1357,
+        D3D12_MESSAGE_ID_GPU_BASED_VALIDATION_INCOMPATIBLE_TEXTURE_LAYOUT	= 1358,
+        D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_DYNAMIC_INDEX_BUFFER_STRIP_CUT_NOT_SUPPORTED	= 1359,
+        D3D12_MESSAGE_ID_PRIMITIVE_TOPOLOGY_TRIANGLE_FANS_NOT_SUPPORTED	= 1360,
+        D3D12_MESSAGE_ID_CREATE_SAMPLER_COMPARISON_FUNC_IGNORED	= 1361,
+        D3D12_MESSAGE_ID_D3D12_MESSAGES_END	= ( D3D12_MESSAGE_ID_CREATE_SAMPLER_COMPARISON_FUNC_IGNORED + 1 ) 
+    } 	D3D12_MESSAGE_ID;
+
+typedef struct D3D12_MESSAGE
+    {
+    D3D12_MESSAGE_CATEGORY Category;
+    D3D12_MESSAGE_SEVERITY Severity;
+    D3D12_MESSAGE_ID ID;
+    _Field_size_(DescriptionByteLength)  const char *pDescription;
+    SIZE_T DescriptionByteLength;
+    } 	D3D12_MESSAGE;
+
+typedef struct D3D12_INFO_QUEUE_FILTER_DESC
+    {
+    UINT NumCategories;
+    _Field_size_(NumCategories)  D3D12_MESSAGE_CATEGORY *pCategoryList;
+    UINT NumSeverities;
+    _Field_size_(NumSeverities)  D3D12_MESSAGE_SEVERITY *pSeverityList;
+    UINT NumIDs;
+    _Field_size_(NumIDs)  D3D12_MESSAGE_ID *pIDList;
+    } 	D3D12_INFO_QUEUE_FILTER_DESC;
+
+typedef struct D3D12_INFO_QUEUE_FILTER
+    {
+    D3D12_INFO_QUEUE_FILTER_DESC AllowList;
+    D3D12_INFO_QUEUE_FILTER_DESC DenyList;
+    } 	D3D12_INFO_QUEUE_FILTER;
+
+#define D3D12_INFO_QUEUE_DEFAULT_MESSAGE_COUNT_LIMIT 1024
+
+
+extern RPC_IF_HANDLE __MIDL_itf_d3d12sdklayers_0000_0017_v0_0_c_ifspec;
+extern RPC_IF_HANDLE __MIDL_itf_d3d12sdklayers_0000_0017_v0_0_s_ifspec;
+
+#ifndef __ID3D12InfoQueue_INTERFACE_DEFINED__
+#define __ID3D12InfoQueue_INTERFACE_DEFINED__
+
+/* interface ID3D12InfoQueue */
+/* [unique][local][object][uuid] */ 
+
+
+EXTERN_C const IID IID_ID3D12InfoQueue;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("0742a90b-c387-483f-b946-30a7e4e61458")
+    ID3D12InfoQueue : public IUnknown
+    {
+    public:
+        virtual HRESULT STDMETHODCALLTYPE SetMessageCountLimit( 
+            _In_  UINT64 MessageCountLimit) = 0;
+        
+        virtual void STDMETHODCALLTYPE ClearStoredMessages( void) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE GetMessage( 
+            _In_  UINT64 MessageIndex,
+            _Out_writes_bytes_opt_(*pMessageByteLength)  D3D12_MESSAGE *pMessage,
+            _Inout_  SIZE_T *pMessageByteLength) = 0;
+        
+        virtual UINT64 STDMETHODCALLTYPE GetNumMessagesAllowedByStorageFilter( void) = 0;
+        
+        virtual UINT64 STDMETHODCALLTYPE GetNumMessagesDeniedByStorageFilter( void) = 0;
+        
+        virtual UINT64 STDMETHODCALLTYPE GetNumStoredMessages( void) = 0;
+        
+        virtual UINT64 STDMETHODCALLTYPE GetNumStoredMessagesAllowedByRetrievalFilter( void) = 0;
+        
+        virtual UINT64 STDMETHODCALLTYPE GetNumMessagesDiscardedByMessageCountLimit( void) = 0;
+        
+        virtual UINT64 STDMETHODCALLTYPE GetMessageCountLimit( void) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE AddStorageFilterEntries( 
+            _In_  D3D12_INFO_QUEUE_FILTER *pFilter) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE GetStorageFilter( 
+            _Out_writes_bytes_opt_(*pFilterByteLength)  D3D12_INFO_QUEUE_FILTER *pFilter,
+            _Inout_  SIZE_T *pFilterByteLength) = 0;
+        
+        virtual void STDMETHODCALLTYPE ClearStorageFilter( void) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE PushEmptyStorageFilter( void) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE PushCopyOfStorageFilter( void) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE PushStorageFilter( 
+            _In_  D3D12_INFO_QUEUE_FILTER *pFilter) = 0;
+        
+        virtual void STDMETHODCALLTYPE PopStorageFilter( void) = 0;
+        
+        virtual UINT STDMETHODCALLTYPE GetStorageFilterStackSize( void) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE AddRetrievalFilterEntries( 
+            _In_  D3D12_INFO_QUEUE_FILTER *pFilter) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE GetRetrievalFilter( 
+            _Out_writes_bytes_opt_(*pFilterByteLength)  D3D12_INFO_QUEUE_FILTER *pFilter,
+            _Inout_  SIZE_T *pFilterByteLength) = 0;
+        
+        virtual void STDMETHODCALLTYPE ClearRetrievalFilter( void) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE PushEmptyRetrievalFilter( void) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE PushCopyOfRetrievalFilter( void) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE PushRetrievalFilter( 
+            _In_  D3D12_INFO_QUEUE_FILTER *pFilter) = 0;
+        
+        virtual void STDMETHODCALLTYPE PopRetrievalFilter( void) = 0;
+        
+        virtual UINT STDMETHODCALLTYPE GetRetrievalFilterStackSize( void) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE AddMessage( 
+            _In_  D3D12_MESSAGE_CATEGORY Category,
+            _In_  D3D12_MESSAGE_SEVERITY Severity,
+            _In_  D3D12_MESSAGE_ID ID,
+            _In_  LPCSTR pDescription) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE AddApplicationMessage( 
+            _In_  D3D12_MESSAGE_SEVERITY Severity,
+            _In_  LPCSTR pDescription) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE SetBreakOnCategory( 
+            _In_  D3D12_MESSAGE_CATEGORY Category,
+            _In_  BOOL bEnable) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE SetBreakOnSeverity( 
+            _In_  D3D12_MESSAGE_SEVERITY Severity,
+            _In_  BOOL bEnable) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE SetBreakOnID( 
+            _In_  D3D12_MESSAGE_ID ID,
+            _In_  BOOL bEnable) = 0;
+        
+        virtual BOOL STDMETHODCALLTYPE GetBreakOnCategory( 
+            _In_  D3D12_MESSAGE_CATEGORY Category) = 0;
+        
+        virtual BOOL STDMETHODCALLTYPE GetBreakOnSeverity( 
+            _In_  D3D12_MESSAGE_SEVERITY Severity) = 0;
+        
+        virtual BOOL STDMETHODCALLTYPE GetBreakOnID( 
+            _In_  D3D12_MESSAGE_ID ID) = 0;
+        
+        virtual void STDMETHODCALLTYPE SetMuteDebugOutput( 
+            _In_  BOOL bMute) = 0;
+        
+        virtual BOOL STDMETHODCALLTYPE GetMuteDebugOutput( void) = 0;
+        
+    };
+    
+    
+#else 	/* C style interface */
+
+    typedef struct ID3D12InfoQueueVtbl
+    {
+        BEGIN_INTERFACE
+        
+        DECLSPEC_XFGVIRT(IUnknown, QueryInterface)
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            ID3D12InfoQueue * This,
+            REFIID riid,
+            _COM_Outptr_  void **ppvObject);
+        
+        DECLSPEC_XFGVIRT(IUnknown, AddRef)
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            ID3D12InfoQueue * This);
+        
+        DECLSPEC_XFGVIRT(IUnknown, Release)
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            ID3D12InfoQueue * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12InfoQueue, SetMessageCountLimit)
+        HRESULT ( STDMETHODCALLTYPE *SetMessageCountLimit )( 
+            ID3D12InfoQueue * This,
+            _In_  UINT64 MessageCountLimit);
+        
+        DECLSPEC_XFGVIRT(ID3D12InfoQueue, ClearStoredMessages)
+        void ( STDMETHODCALLTYPE *ClearStoredMessages )( 
+            ID3D12InfoQueue * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12InfoQueue, GetMessage)
+        HRESULT ( STDMETHODCALLTYPE *GetMessage )( 
+            ID3D12InfoQueue * This,
+            _In_  UINT64 MessageIndex,
+            _Out_writes_bytes_opt_(*pMessageByteLength)  D3D12_MESSAGE *pMessage,
+            _Inout_  SIZE_T *pMessageByteLength);
+        
+        DECLSPEC_XFGVIRT(ID3D12InfoQueue, GetNumMessagesAllowedByStorageFilter)
+        UINT64 ( STDMETHODCALLTYPE *GetNumMessagesAllowedByStorageFilter )( 
+            ID3D12InfoQueue * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12InfoQueue, GetNumMessagesDeniedByStorageFilter)
+        UINT64 ( STDMETHODCALLTYPE *GetNumMessagesDeniedByStorageFilter )( 
+            ID3D12InfoQueue * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12InfoQueue, GetNumStoredMessages)
+        UINT64 ( STDMETHODCALLTYPE *GetNumStoredMessages )( 
+            ID3D12InfoQueue * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12InfoQueue, GetNumStoredMessagesAllowedByRetrievalFilter)
+        UINT64 ( STDMETHODCALLTYPE *GetNumStoredMessagesAllowedByRetrievalFilter )( 
+            ID3D12InfoQueue * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12InfoQueue, GetNumMessagesDiscardedByMessageCountLimit)
+        UINT64 ( STDMETHODCALLTYPE *GetNumMessagesDiscardedByMessageCountLimit )( 
+            ID3D12InfoQueue * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12InfoQueue, GetMessageCountLimit)
+        UINT64 ( STDMETHODCALLTYPE *GetMessageCountLimit )( 
+            ID3D12InfoQueue * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12InfoQueue, AddStorageFilterEntries)
+        HRESULT ( STDMETHODCALLTYPE *AddStorageFilterEntries )( 
+            ID3D12InfoQueue * This,
+            _In_  D3D12_INFO_QUEUE_FILTER *pFilter);
+        
+        DECLSPEC_XFGVIRT(ID3D12InfoQueue, GetStorageFilter)
+        HRESULT ( STDMETHODCALLTYPE *GetStorageFilter )( 
+            ID3D12InfoQueue * This,
+            _Out_writes_bytes_opt_(*pFilterByteLength)  D3D12_INFO_QUEUE_FILTER *pFilter,
+            _Inout_  SIZE_T *pFilterByteLength);
+        
+        DECLSPEC_XFGVIRT(ID3D12InfoQueue, ClearStorageFilter)
+        void ( STDMETHODCALLTYPE *ClearStorageFilter )( 
+            ID3D12InfoQueue * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12InfoQueue, PushEmptyStorageFilter)
+        HRESULT ( STDMETHODCALLTYPE *PushEmptyStorageFilter )( 
+            ID3D12InfoQueue * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12InfoQueue, PushCopyOfStorageFilter)
+        HRESULT ( STDMETHODCALLTYPE *PushCopyOfStorageFilter )( 
+            ID3D12InfoQueue * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12InfoQueue, PushStorageFilter)
+        HRESULT ( STDMETHODCALLTYPE *PushStorageFilter )( 
+            ID3D12InfoQueue * This,
+            _In_  D3D12_INFO_QUEUE_FILTER *pFilter);
+        
+        DECLSPEC_XFGVIRT(ID3D12InfoQueue, PopStorageFilter)
+        void ( STDMETHODCALLTYPE *PopStorageFilter )( 
+            ID3D12InfoQueue * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12InfoQueue, GetStorageFilterStackSize)
+        UINT ( STDMETHODCALLTYPE *GetStorageFilterStackSize )( 
+            ID3D12InfoQueue * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12InfoQueue, AddRetrievalFilterEntries)
+        HRESULT ( STDMETHODCALLTYPE *AddRetrievalFilterEntries )( 
+            ID3D12InfoQueue * This,
+            _In_  D3D12_INFO_QUEUE_FILTER *pFilter);
+        
+        DECLSPEC_XFGVIRT(ID3D12InfoQueue, GetRetrievalFilter)
+        HRESULT ( STDMETHODCALLTYPE *GetRetrievalFilter )( 
+            ID3D12InfoQueue * This,
+            _Out_writes_bytes_opt_(*pFilterByteLength)  D3D12_INFO_QUEUE_FILTER *pFilter,
+            _Inout_  SIZE_T *pFilterByteLength);
+        
+        DECLSPEC_XFGVIRT(ID3D12InfoQueue, ClearRetrievalFilter)
+        void ( STDMETHODCALLTYPE *ClearRetrievalFilter )( 
+            ID3D12InfoQueue * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12InfoQueue, PushEmptyRetrievalFilter)
+        HRESULT ( STDMETHODCALLTYPE *PushEmptyRetrievalFilter )( 
+            ID3D12InfoQueue * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12InfoQueue, PushCopyOfRetrievalFilter)
+        HRESULT ( STDMETHODCALLTYPE *PushCopyOfRetrievalFilter )( 
+            ID3D12InfoQueue * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12InfoQueue, PushRetrievalFilter)
+        HRESULT ( STDMETHODCALLTYPE *PushRetrievalFilter )( 
+            ID3D12InfoQueue * This,
+            _In_  D3D12_INFO_QUEUE_FILTER *pFilter);
+        
+        DECLSPEC_XFGVIRT(ID3D12InfoQueue, PopRetrievalFilter)
+        void ( STDMETHODCALLTYPE *PopRetrievalFilter )( 
+            ID3D12InfoQueue * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12InfoQueue, GetRetrievalFilterStackSize)
+        UINT ( STDMETHODCALLTYPE *GetRetrievalFilterStackSize )( 
+            ID3D12InfoQueue * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12InfoQueue, AddMessage)
+        HRESULT ( STDMETHODCALLTYPE *AddMessage )( 
+            ID3D12InfoQueue * This,
+            _In_  D3D12_MESSAGE_CATEGORY Category,
+            _In_  D3D12_MESSAGE_SEVERITY Severity,
+            _In_  D3D12_MESSAGE_ID ID,
+            _In_  LPCSTR pDescription);
+        
+        DECLSPEC_XFGVIRT(ID3D12InfoQueue, AddApplicationMessage)
+        HRESULT ( STDMETHODCALLTYPE *AddApplicationMessage )( 
+            ID3D12InfoQueue * This,
+            _In_  D3D12_MESSAGE_SEVERITY Severity,
+            _In_  LPCSTR pDescription);
+        
+        DECLSPEC_XFGVIRT(ID3D12InfoQueue, SetBreakOnCategory)
+        HRESULT ( STDMETHODCALLTYPE *SetBreakOnCategory )( 
+            ID3D12InfoQueue * This,
+            _In_  D3D12_MESSAGE_CATEGORY Category,
+            _In_  BOOL bEnable);
+        
+        DECLSPEC_XFGVIRT(ID3D12InfoQueue, SetBreakOnSeverity)
+        HRESULT ( STDMETHODCALLTYPE *SetBreakOnSeverity )( 
+            ID3D12InfoQueue * This,
+            _In_  D3D12_MESSAGE_SEVERITY Severity,
+            _In_  BOOL bEnable);
+        
+        DECLSPEC_XFGVIRT(ID3D12InfoQueue, SetBreakOnID)
+        HRESULT ( STDMETHODCALLTYPE *SetBreakOnID )( 
+            ID3D12InfoQueue * This,
+            _In_  D3D12_MESSAGE_ID ID,
+            _In_  BOOL bEnable);
+        
+        DECLSPEC_XFGVIRT(ID3D12InfoQueue, GetBreakOnCategory)
+        BOOL ( STDMETHODCALLTYPE *GetBreakOnCategory )( 
+            ID3D12InfoQueue * This,
+            _In_  D3D12_MESSAGE_CATEGORY Category);
+        
+        DECLSPEC_XFGVIRT(ID3D12InfoQueue, GetBreakOnSeverity)
+        BOOL ( STDMETHODCALLTYPE *GetBreakOnSeverity )( 
+            ID3D12InfoQueue * This,
+            _In_  D3D12_MESSAGE_SEVERITY Severity);
+        
+        DECLSPEC_XFGVIRT(ID3D12InfoQueue, GetBreakOnID)
+        BOOL ( STDMETHODCALLTYPE *GetBreakOnID )( 
+            ID3D12InfoQueue * This,
+            _In_  D3D12_MESSAGE_ID ID);
+        
+        DECLSPEC_XFGVIRT(ID3D12InfoQueue, SetMuteDebugOutput)
+        void ( STDMETHODCALLTYPE *SetMuteDebugOutput )( 
+            ID3D12InfoQueue * This,
+            _In_  BOOL bMute);
+        
+        DECLSPEC_XFGVIRT(ID3D12InfoQueue, GetMuteDebugOutput)
+        BOOL ( STDMETHODCALLTYPE *GetMuteDebugOutput )( 
+            ID3D12InfoQueue * This);
+        
+        END_INTERFACE
+    } ID3D12InfoQueueVtbl;
+
+    interface ID3D12InfoQueue
+    {
+        CONST_VTBL struct ID3D12InfoQueueVtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define ID3D12InfoQueue_QueryInterface(This,riid,ppvObject)	\
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define ID3D12InfoQueue_AddRef(This)	\
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define ID3D12InfoQueue_Release(This)	\
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#define ID3D12InfoQueue_SetMessageCountLimit(This,MessageCountLimit)	\
+    ( (This)->lpVtbl -> SetMessageCountLimit(This,MessageCountLimit) ) 
+
+#define ID3D12InfoQueue_ClearStoredMessages(This)	\
+    ( (This)->lpVtbl -> ClearStoredMessages(This) ) 
+
+#define ID3D12InfoQueue_GetMessage(This,MessageIndex,pMessage,pMessageByteLength)	\
+    ( (This)->lpVtbl -> GetMessage(This,MessageIndex,pMessage,pMessageByteLength) ) 
+
+#define ID3D12InfoQueue_GetNumMessagesAllowedByStorageFilter(This)	\
+    ( (This)->lpVtbl -> GetNumMessagesAllowedByStorageFilter(This) ) 
+
+#define ID3D12InfoQueue_GetNumMessagesDeniedByStorageFilter(This)	\
+    ( (This)->lpVtbl -> GetNumMessagesDeniedByStorageFilter(This) ) 
+
+#define ID3D12InfoQueue_GetNumStoredMessages(This)	\
+    ( (This)->lpVtbl -> GetNumStoredMessages(This) ) 
+
+#define ID3D12InfoQueue_GetNumStoredMessagesAllowedByRetrievalFilter(This)	\
+    ( (This)->lpVtbl -> GetNumStoredMessagesAllowedByRetrievalFilter(This) ) 
+
+#define ID3D12InfoQueue_GetNumMessagesDiscardedByMessageCountLimit(This)	\
+    ( (This)->lpVtbl -> GetNumMessagesDiscardedByMessageCountLimit(This) ) 
+
+#define ID3D12InfoQueue_GetMessageCountLimit(This)	\
+    ( (This)->lpVtbl -> GetMessageCountLimit(This) ) 
+
+#define ID3D12InfoQueue_AddStorageFilterEntries(This,pFilter)	\
+    ( (This)->lpVtbl -> AddStorageFilterEntries(This,pFilter) ) 
+
+#define ID3D12InfoQueue_GetStorageFilter(This,pFilter,pFilterByteLength)	\
+    ( (This)->lpVtbl -> GetStorageFilter(This,pFilter,pFilterByteLength) ) 
+
+#define ID3D12InfoQueue_ClearStorageFilter(This)	\
+    ( (This)->lpVtbl -> ClearStorageFilter(This) ) 
+
+#define ID3D12InfoQueue_PushEmptyStorageFilter(This)	\
+    ( (This)->lpVtbl -> PushEmptyStorageFilter(This) ) 
+
+#define ID3D12InfoQueue_PushCopyOfStorageFilter(This)	\
+    ( (This)->lpVtbl -> PushCopyOfStorageFilter(This) ) 
+
+#define ID3D12InfoQueue_PushStorageFilter(This,pFilter)	\
+    ( (This)->lpVtbl -> PushStorageFilter(This,pFilter) ) 
+
+#define ID3D12InfoQueue_PopStorageFilter(This)	\
+    ( (This)->lpVtbl -> PopStorageFilter(This) ) 
+
+#define ID3D12InfoQueue_GetStorageFilterStackSize(This)	\
+    ( (This)->lpVtbl -> GetStorageFilterStackSize(This) ) 
+
+#define ID3D12InfoQueue_AddRetrievalFilterEntries(This,pFilter)	\
+    ( (This)->lpVtbl -> AddRetrievalFilterEntries(This,pFilter) ) 
+
+#define ID3D12InfoQueue_GetRetrievalFilter(This,pFilter,pFilterByteLength)	\
+    ( (This)->lpVtbl -> GetRetrievalFilter(This,pFilter,pFilterByteLength) ) 
+
+#define ID3D12InfoQueue_ClearRetrievalFilter(This)	\
+    ( (This)->lpVtbl -> ClearRetrievalFilter(This) ) 
+
+#define ID3D12InfoQueue_PushEmptyRetrievalFilter(This)	\
+    ( (This)->lpVtbl -> PushEmptyRetrievalFilter(This) ) 
+
+#define ID3D12InfoQueue_PushCopyOfRetrievalFilter(This)	\
+    ( (This)->lpVtbl -> PushCopyOfRetrievalFilter(This) ) 
+
+#define ID3D12InfoQueue_PushRetrievalFilter(This,pFilter)	\
+    ( (This)->lpVtbl -> PushRetrievalFilter(This,pFilter) ) 
+
+#define ID3D12InfoQueue_PopRetrievalFilter(This)	\
+    ( (This)->lpVtbl -> PopRetrievalFilter(This) ) 
+
+#define ID3D12InfoQueue_GetRetrievalFilterStackSize(This)	\
+    ( (This)->lpVtbl -> GetRetrievalFilterStackSize(This) ) 
+
+#define ID3D12InfoQueue_AddMessage(This,Category,Severity,ID,pDescription)	\
+    ( (This)->lpVtbl -> AddMessage(This,Category,Severity,ID,pDescription) ) 
+
+#define ID3D12InfoQueue_AddApplicationMessage(This,Severity,pDescription)	\
+    ( (This)->lpVtbl -> AddApplicationMessage(This,Severity,pDescription) ) 
+
+#define ID3D12InfoQueue_SetBreakOnCategory(This,Category,bEnable)	\
+    ( (This)->lpVtbl -> SetBreakOnCategory(This,Category,bEnable) ) 
+
+#define ID3D12InfoQueue_SetBreakOnSeverity(This,Severity,bEnable)	\
+    ( (This)->lpVtbl -> SetBreakOnSeverity(This,Severity,bEnable) ) 
+
+#define ID3D12InfoQueue_SetBreakOnID(This,ID,bEnable)	\
+    ( (This)->lpVtbl -> SetBreakOnID(This,ID,bEnable) ) 
+
+#define ID3D12InfoQueue_GetBreakOnCategory(This,Category)	\
+    ( (This)->lpVtbl -> GetBreakOnCategory(This,Category) ) 
+
+#define ID3D12InfoQueue_GetBreakOnSeverity(This,Severity)	\
+    ( (This)->lpVtbl -> GetBreakOnSeverity(This,Severity) ) 
+
+#define ID3D12InfoQueue_GetBreakOnID(This,ID)	\
+    ( (This)->lpVtbl -> GetBreakOnID(This,ID) ) 
+
+#define ID3D12InfoQueue_SetMuteDebugOutput(This,bMute)	\
+    ( (This)->lpVtbl -> SetMuteDebugOutput(This,bMute) ) 
+
+#define ID3D12InfoQueue_GetMuteDebugOutput(This)	\
+    ( (This)->lpVtbl -> GetMuteDebugOutput(This) ) 
+
+#endif /* COBJMACROS */
+
+
+#endif 	/* C style interface */
+
+
+
+
+#endif 	/* __ID3D12InfoQueue_INTERFACE_DEFINED__ */
+
+
+/* interface __MIDL_itf_d3d12sdklayers_0000_0018 */
+/* [local] */ 
+
+typedef 
+enum D3D12_MESSAGE_CALLBACK_FLAGS
+    {
+        D3D12_MESSAGE_CALLBACK_FLAG_NONE	= 0,
+        D3D12_MESSAGE_CALLBACK_IGNORE_FILTERS	= 0x1
+    } 	D3D12_MESSAGE_CALLBACK_FLAGS;
+
+DEFINE_ENUM_FLAG_OPERATORS(D3D12_MESSAGE_CALLBACK_FLAGS)
+typedef void ( __stdcall *D3D12MessageFunc )( 
+    D3D12_MESSAGE_CATEGORY Category,
+    D3D12_MESSAGE_SEVERITY Severity,
+    D3D12_MESSAGE_ID ID,
+    LPCSTR pDescription,
+    void *pContext);
+
+
+
+extern RPC_IF_HANDLE __MIDL_itf_d3d12sdklayers_0000_0018_v0_0_c_ifspec;
+extern RPC_IF_HANDLE __MIDL_itf_d3d12sdklayers_0000_0018_v0_0_s_ifspec;
+
+#ifndef __ID3D12InfoQueue1_INTERFACE_DEFINED__
+#define __ID3D12InfoQueue1_INTERFACE_DEFINED__
+
+/* interface ID3D12InfoQueue1 */
+/* [unique][local][object][uuid] */ 
+
+
+EXTERN_C const IID IID_ID3D12InfoQueue1;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("2852dd88-b484-4c0c-b6b1-67168500e600")
+    ID3D12InfoQueue1 : public ID3D12InfoQueue
+    {
+    public:
+        virtual HRESULT STDMETHODCALLTYPE RegisterMessageCallback( 
+            _In_  D3D12MessageFunc CallbackFunc,
+            _In_  D3D12_MESSAGE_CALLBACK_FLAGS CallbackFilterFlags,
+            _In_  void *pContext,
+            _Inout_  DWORD *pCallbackCookie) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE UnregisterMessageCallback( 
+            _In_  DWORD CallbackCookie) = 0;
+        
+    };
+    
+    
+#else 	/* C style interface */
+
+    typedef struct ID3D12InfoQueue1Vtbl
+    {
+        BEGIN_INTERFACE
+        
+        DECLSPEC_XFGVIRT(IUnknown, QueryInterface)
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            ID3D12InfoQueue1 * This,
+            REFIID riid,
+            _COM_Outptr_  void **ppvObject);
+        
+        DECLSPEC_XFGVIRT(IUnknown, AddRef)
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            ID3D12InfoQueue1 * This);
+        
+        DECLSPEC_XFGVIRT(IUnknown, Release)
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            ID3D12InfoQueue1 * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12InfoQueue, SetMessageCountLimit)
+        HRESULT ( STDMETHODCALLTYPE *SetMessageCountLimit )( 
+            ID3D12InfoQueue1 * This,
+            _In_  UINT64 MessageCountLimit);
+        
+        DECLSPEC_XFGVIRT(ID3D12InfoQueue, ClearStoredMessages)
+        void ( STDMETHODCALLTYPE *ClearStoredMessages )( 
+            ID3D12InfoQueue1 * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12InfoQueue, GetMessage)
+        HRESULT ( STDMETHODCALLTYPE *GetMessage )( 
+            ID3D12InfoQueue1 * This,
+            _In_  UINT64 MessageIndex,
+            _Out_writes_bytes_opt_(*pMessageByteLength)  D3D12_MESSAGE *pMessage,
+            _Inout_  SIZE_T *pMessageByteLength);
+        
+        DECLSPEC_XFGVIRT(ID3D12InfoQueue, GetNumMessagesAllowedByStorageFilter)
+        UINT64 ( STDMETHODCALLTYPE *GetNumMessagesAllowedByStorageFilter )( 
+            ID3D12InfoQueue1 * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12InfoQueue, GetNumMessagesDeniedByStorageFilter)
+        UINT64 ( STDMETHODCALLTYPE *GetNumMessagesDeniedByStorageFilter )( 
+            ID3D12InfoQueue1 * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12InfoQueue, GetNumStoredMessages)
+        UINT64 ( STDMETHODCALLTYPE *GetNumStoredMessages )( 
+            ID3D12InfoQueue1 * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12InfoQueue, GetNumStoredMessagesAllowedByRetrievalFilter)
+        UINT64 ( STDMETHODCALLTYPE *GetNumStoredMessagesAllowedByRetrievalFilter )( 
+            ID3D12InfoQueue1 * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12InfoQueue, GetNumMessagesDiscardedByMessageCountLimit)
+        UINT64 ( STDMETHODCALLTYPE *GetNumMessagesDiscardedByMessageCountLimit )( 
+            ID3D12InfoQueue1 * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12InfoQueue, GetMessageCountLimit)
+        UINT64 ( STDMETHODCALLTYPE *GetMessageCountLimit )( 
+            ID3D12InfoQueue1 * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12InfoQueue, AddStorageFilterEntries)
+        HRESULT ( STDMETHODCALLTYPE *AddStorageFilterEntries )( 
+            ID3D12InfoQueue1 * This,
+            _In_  D3D12_INFO_QUEUE_FILTER *pFilter);
+        
+        DECLSPEC_XFGVIRT(ID3D12InfoQueue, GetStorageFilter)
+        HRESULT ( STDMETHODCALLTYPE *GetStorageFilter )( 
+            ID3D12InfoQueue1 * This,
+            _Out_writes_bytes_opt_(*pFilterByteLength)  D3D12_INFO_QUEUE_FILTER *pFilter,
+            _Inout_  SIZE_T *pFilterByteLength);
+        
+        DECLSPEC_XFGVIRT(ID3D12InfoQueue, ClearStorageFilter)
+        void ( STDMETHODCALLTYPE *ClearStorageFilter )( 
+            ID3D12InfoQueue1 * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12InfoQueue, PushEmptyStorageFilter)
+        HRESULT ( STDMETHODCALLTYPE *PushEmptyStorageFilter )( 
+            ID3D12InfoQueue1 * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12InfoQueue, PushCopyOfStorageFilter)
+        HRESULT ( STDMETHODCALLTYPE *PushCopyOfStorageFilter )( 
+            ID3D12InfoQueue1 * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12InfoQueue, PushStorageFilter)
+        HRESULT ( STDMETHODCALLTYPE *PushStorageFilter )( 
+            ID3D12InfoQueue1 * This,
+            _In_  D3D12_INFO_QUEUE_FILTER *pFilter);
+        
+        DECLSPEC_XFGVIRT(ID3D12InfoQueue, PopStorageFilter)
+        void ( STDMETHODCALLTYPE *PopStorageFilter )( 
+            ID3D12InfoQueue1 * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12InfoQueue, GetStorageFilterStackSize)
+        UINT ( STDMETHODCALLTYPE *GetStorageFilterStackSize )( 
+            ID3D12InfoQueue1 * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12InfoQueue, AddRetrievalFilterEntries)
+        HRESULT ( STDMETHODCALLTYPE *AddRetrievalFilterEntries )( 
+            ID3D12InfoQueue1 * This,
+            _In_  D3D12_INFO_QUEUE_FILTER *pFilter);
+        
+        DECLSPEC_XFGVIRT(ID3D12InfoQueue, GetRetrievalFilter)
+        HRESULT ( STDMETHODCALLTYPE *GetRetrievalFilter )( 
+            ID3D12InfoQueue1 * This,
+            _Out_writes_bytes_opt_(*pFilterByteLength)  D3D12_INFO_QUEUE_FILTER *pFilter,
+            _Inout_  SIZE_T *pFilterByteLength);
+        
+        DECLSPEC_XFGVIRT(ID3D12InfoQueue, ClearRetrievalFilter)
+        void ( STDMETHODCALLTYPE *ClearRetrievalFilter )( 
+            ID3D12InfoQueue1 * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12InfoQueue, PushEmptyRetrievalFilter)
+        HRESULT ( STDMETHODCALLTYPE *PushEmptyRetrievalFilter )( 
+            ID3D12InfoQueue1 * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12InfoQueue, PushCopyOfRetrievalFilter)
+        HRESULT ( STDMETHODCALLTYPE *PushCopyOfRetrievalFilter )( 
+            ID3D12InfoQueue1 * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12InfoQueue, PushRetrievalFilter)
+        HRESULT ( STDMETHODCALLTYPE *PushRetrievalFilter )( 
+            ID3D12InfoQueue1 * This,
+            _In_  D3D12_INFO_QUEUE_FILTER *pFilter);
+        
+        DECLSPEC_XFGVIRT(ID3D12InfoQueue, PopRetrievalFilter)
+        void ( STDMETHODCALLTYPE *PopRetrievalFilter )( 
+            ID3D12InfoQueue1 * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12InfoQueue, GetRetrievalFilterStackSize)
+        UINT ( STDMETHODCALLTYPE *GetRetrievalFilterStackSize )( 
+            ID3D12InfoQueue1 * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12InfoQueue, AddMessage)
+        HRESULT ( STDMETHODCALLTYPE *AddMessage )( 
+            ID3D12InfoQueue1 * This,
+            _In_  D3D12_MESSAGE_CATEGORY Category,
+            _In_  D3D12_MESSAGE_SEVERITY Severity,
+            _In_  D3D12_MESSAGE_ID ID,
+            _In_  LPCSTR pDescription);
+        
+        DECLSPEC_XFGVIRT(ID3D12InfoQueue, AddApplicationMessage)
+        HRESULT ( STDMETHODCALLTYPE *AddApplicationMessage )( 
+            ID3D12InfoQueue1 * This,
+            _In_  D3D12_MESSAGE_SEVERITY Severity,
+            _In_  LPCSTR pDescription);
+        
+        DECLSPEC_XFGVIRT(ID3D12InfoQueue, SetBreakOnCategory)
+        HRESULT ( STDMETHODCALLTYPE *SetBreakOnCategory )( 
+            ID3D12InfoQueue1 * This,
+            _In_  D3D12_MESSAGE_CATEGORY Category,
+            _In_  BOOL bEnable);
+        
+        DECLSPEC_XFGVIRT(ID3D12InfoQueue, SetBreakOnSeverity)
+        HRESULT ( STDMETHODCALLTYPE *SetBreakOnSeverity )( 
+            ID3D12InfoQueue1 * This,
+            _In_  D3D12_MESSAGE_SEVERITY Severity,
+            _In_  BOOL bEnable);
+        
+        DECLSPEC_XFGVIRT(ID3D12InfoQueue, SetBreakOnID)
+        HRESULT ( STDMETHODCALLTYPE *SetBreakOnID )( 
+            ID3D12InfoQueue1 * This,
+            _In_  D3D12_MESSAGE_ID ID,
+            _In_  BOOL bEnable);
+        
+        DECLSPEC_XFGVIRT(ID3D12InfoQueue, GetBreakOnCategory)
+        BOOL ( STDMETHODCALLTYPE *GetBreakOnCategory )( 
+            ID3D12InfoQueue1 * This,
+            _In_  D3D12_MESSAGE_CATEGORY Category);
+        
+        DECLSPEC_XFGVIRT(ID3D12InfoQueue, GetBreakOnSeverity)
+        BOOL ( STDMETHODCALLTYPE *GetBreakOnSeverity )( 
+            ID3D12InfoQueue1 * This,
+            _In_  D3D12_MESSAGE_SEVERITY Severity);
+        
+        DECLSPEC_XFGVIRT(ID3D12InfoQueue, GetBreakOnID)
+        BOOL ( STDMETHODCALLTYPE *GetBreakOnID )( 
+            ID3D12InfoQueue1 * This,
+            _In_  D3D12_MESSAGE_ID ID);
+        
+        DECLSPEC_XFGVIRT(ID3D12InfoQueue, SetMuteDebugOutput)
+        void ( STDMETHODCALLTYPE *SetMuteDebugOutput )( 
+            ID3D12InfoQueue1 * This,
+            _In_  BOOL bMute);
+        
+        DECLSPEC_XFGVIRT(ID3D12InfoQueue, GetMuteDebugOutput)
+        BOOL ( STDMETHODCALLTYPE *GetMuteDebugOutput )( 
+            ID3D12InfoQueue1 * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12InfoQueue1, RegisterMessageCallback)
+        HRESULT ( STDMETHODCALLTYPE *RegisterMessageCallback )( 
+            ID3D12InfoQueue1 * This,
+            _In_  D3D12MessageFunc CallbackFunc,
+            _In_  D3D12_MESSAGE_CALLBACK_FLAGS CallbackFilterFlags,
+            _In_  void *pContext,
+            _Inout_  DWORD *pCallbackCookie);
+        
+        DECLSPEC_XFGVIRT(ID3D12InfoQueue1, UnregisterMessageCallback)
+        HRESULT ( STDMETHODCALLTYPE *UnregisterMessageCallback )( 
+            ID3D12InfoQueue1 * This,
+            _In_  DWORD CallbackCookie);
+        
+        END_INTERFACE
+    } ID3D12InfoQueue1Vtbl;
+
+    interface ID3D12InfoQueue1
+    {
+        CONST_VTBL struct ID3D12InfoQueue1Vtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define ID3D12InfoQueue1_QueryInterface(This,riid,ppvObject)	\
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define ID3D12InfoQueue1_AddRef(This)	\
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define ID3D12InfoQueue1_Release(This)	\
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#define ID3D12InfoQueue1_SetMessageCountLimit(This,MessageCountLimit)	\
+    ( (This)->lpVtbl -> SetMessageCountLimit(This,MessageCountLimit) ) 
+
+#define ID3D12InfoQueue1_ClearStoredMessages(This)	\
+    ( (This)->lpVtbl -> ClearStoredMessages(This) ) 
+
+#define ID3D12InfoQueue1_GetMessage(This,MessageIndex,pMessage,pMessageByteLength)	\
+    ( (This)->lpVtbl -> GetMessage(This,MessageIndex,pMessage,pMessageByteLength) ) 
+
+#define ID3D12InfoQueue1_GetNumMessagesAllowedByStorageFilter(This)	\
+    ( (This)->lpVtbl -> GetNumMessagesAllowedByStorageFilter(This) ) 
+
+#define ID3D12InfoQueue1_GetNumMessagesDeniedByStorageFilter(This)	\
+    ( (This)->lpVtbl -> GetNumMessagesDeniedByStorageFilter(This) ) 
+
+#define ID3D12InfoQueue1_GetNumStoredMessages(This)	\
+    ( (This)->lpVtbl -> GetNumStoredMessages(This) ) 
+
+#define ID3D12InfoQueue1_GetNumStoredMessagesAllowedByRetrievalFilter(This)	\
+    ( (This)->lpVtbl -> GetNumStoredMessagesAllowedByRetrievalFilter(This) ) 
+
+#define ID3D12InfoQueue1_GetNumMessagesDiscardedByMessageCountLimit(This)	\
+    ( (This)->lpVtbl -> GetNumMessagesDiscardedByMessageCountLimit(This) ) 
+
+#define ID3D12InfoQueue1_GetMessageCountLimit(This)	\
+    ( (This)->lpVtbl -> GetMessageCountLimit(This) ) 
+
+#define ID3D12InfoQueue1_AddStorageFilterEntries(This,pFilter)	\
+    ( (This)->lpVtbl -> AddStorageFilterEntries(This,pFilter) ) 
+
+#define ID3D12InfoQueue1_GetStorageFilter(This,pFilter,pFilterByteLength)	\
+    ( (This)->lpVtbl -> GetStorageFilter(This,pFilter,pFilterByteLength) ) 
+
+#define ID3D12InfoQueue1_ClearStorageFilter(This)	\
+    ( (This)->lpVtbl -> ClearStorageFilter(This) ) 
+
+#define ID3D12InfoQueue1_PushEmptyStorageFilter(This)	\
+    ( (This)->lpVtbl -> PushEmptyStorageFilter(This) ) 
+
+#define ID3D12InfoQueue1_PushCopyOfStorageFilter(This)	\
+    ( (This)->lpVtbl -> PushCopyOfStorageFilter(This) ) 
+
+#define ID3D12InfoQueue1_PushStorageFilter(This,pFilter)	\
+    ( (This)->lpVtbl -> PushStorageFilter(This,pFilter) ) 
+
+#define ID3D12InfoQueue1_PopStorageFilter(This)	\
+    ( (This)->lpVtbl -> PopStorageFilter(This) ) 
+
+#define ID3D12InfoQueue1_GetStorageFilterStackSize(This)	\
+    ( (This)->lpVtbl -> GetStorageFilterStackSize(This) ) 
+
+#define ID3D12InfoQueue1_AddRetrievalFilterEntries(This,pFilter)	\
+    ( (This)->lpVtbl -> AddRetrievalFilterEntries(This,pFilter) ) 
+
+#define ID3D12InfoQueue1_GetRetrievalFilter(This,pFilter,pFilterByteLength)	\
+    ( (This)->lpVtbl -> GetRetrievalFilter(This,pFilter,pFilterByteLength) ) 
+
+#define ID3D12InfoQueue1_ClearRetrievalFilter(This)	\
+    ( (This)->lpVtbl -> ClearRetrievalFilter(This) ) 
+
+#define ID3D12InfoQueue1_PushEmptyRetrievalFilter(This)	\
+    ( (This)->lpVtbl -> PushEmptyRetrievalFilter(This) ) 
+
+#define ID3D12InfoQueue1_PushCopyOfRetrievalFilter(This)	\
+    ( (This)->lpVtbl -> PushCopyOfRetrievalFilter(This) ) 
+
+#define ID3D12InfoQueue1_PushRetrievalFilter(This,pFilter)	\
+    ( (This)->lpVtbl -> PushRetrievalFilter(This,pFilter) ) 
+
+#define ID3D12InfoQueue1_PopRetrievalFilter(This)	\
+    ( (This)->lpVtbl -> PopRetrievalFilter(This) ) 
+
+#define ID3D12InfoQueue1_GetRetrievalFilterStackSize(This)	\
+    ( (This)->lpVtbl -> GetRetrievalFilterStackSize(This) ) 
+
+#define ID3D12InfoQueue1_AddMessage(This,Category,Severity,ID,pDescription)	\
+    ( (This)->lpVtbl -> AddMessage(This,Category,Severity,ID,pDescription) ) 
+
+#define ID3D12InfoQueue1_AddApplicationMessage(This,Severity,pDescription)	\
+    ( (This)->lpVtbl -> AddApplicationMessage(This,Severity,pDescription) ) 
+
+#define ID3D12InfoQueue1_SetBreakOnCategory(This,Category,bEnable)	\
+    ( (This)->lpVtbl -> SetBreakOnCategory(This,Category,bEnable) ) 
+
+#define ID3D12InfoQueue1_SetBreakOnSeverity(This,Severity,bEnable)	\
+    ( (This)->lpVtbl -> SetBreakOnSeverity(This,Severity,bEnable) ) 
+
+#define ID3D12InfoQueue1_SetBreakOnID(This,ID,bEnable)	\
+    ( (This)->lpVtbl -> SetBreakOnID(This,ID,bEnable) ) 
+
+#define ID3D12InfoQueue1_GetBreakOnCategory(This,Category)	\
+    ( (This)->lpVtbl -> GetBreakOnCategory(This,Category) ) 
+
+#define ID3D12InfoQueue1_GetBreakOnSeverity(This,Severity)	\
+    ( (This)->lpVtbl -> GetBreakOnSeverity(This,Severity) ) 
+
+#define ID3D12InfoQueue1_GetBreakOnID(This,ID)	\
+    ( (This)->lpVtbl -> GetBreakOnID(This,ID) ) 
+
+#define ID3D12InfoQueue1_SetMuteDebugOutput(This,bMute)	\
+    ( (This)->lpVtbl -> SetMuteDebugOutput(This,bMute) ) 
+
+#define ID3D12InfoQueue1_GetMuteDebugOutput(This)	\
+    ( (This)->lpVtbl -> GetMuteDebugOutput(This) ) 
+
+
+#define ID3D12InfoQueue1_RegisterMessageCallback(This,CallbackFunc,CallbackFilterFlags,pContext,pCallbackCookie)	\
+    ( (This)->lpVtbl -> RegisterMessageCallback(This,CallbackFunc,CallbackFilterFlags,pContext,pCallbackCookie) ) 
+
+#define ID3D12InfoQueue1_UnregisterMessageCallback(This,CallbackCookie)	\
+    ( (This)->lpVtbl -> UnregisterMessageCallback(This,CallbackCookie) ) 
+
+#endif /* COBJMACROS */
+
+
+#endif 	/* C style interface */
+
+
+
+
+#endif 	/* __ID3D12InfoQueue1_INTERFACE_DEFINED__ */
+
+
+/* interface __MIDL_itf_d3d12sdklayers_0000_0019 */
+/* [local] */ 
+
+#endif /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP | WINAPI_PARTITION_GAMES) */
+#pragma endregion
+DEFINE_GUID(IID_ID3D12Debug,0x344488b7,0x6846,0x474b,0xb9,0x89,0xf0,0x27,0x44,0x82,0x45,0xe0);
+DEFINE_GUID(IID_ID3D12Debug1,0xaffaa4ca,0x63fe,0x4d8e,0xb8,0xad,0x15,0x90,0x00,0xaf,0x43,0x04);
+DEFINE_GUID(IID_ID3D12Debug2,0x93a665c4,0xa3b2,0x4e5d,0xb6,0x92,0xa2,0x6a,0xe1,0x4e,0x33,0x74);
+DEFINE_GUID(IID_ID3D12Debug3,0x5cf4e58f,0xf671,0x4ff1,0xa5,0x42,0x36,0x86,0xe3,0xd1,0x53,0xd1);
+DEFINE_GUID(IID_ID3D12Debug4,0x014b816e,0x9ec5,0x4a2f,0xa8,0x45,0xff,0xbe,0x44,0x1c,0xe1,0x3a);
+DEFINE_GUID(IID_ID3D12Debug5,0x548d6b12,0x09fa,0x40e0,0x90,0x69,0x5d,0xcd,0x58,0x9a,0x52,0xc9);
+DEFINE_GUID(IID_ID3D12Debug6,0x82a816d6,0x5d01,0x4157,0x97,0xd0,0x49,0x75,0x46,0x3f,0xd1,0xed);
+DEFINE_GUID(IID_ID3D12DebugDevice1,0xa9b71770,0xd099,0x4a65,0xa6,0x98,0x3d,0xee,0x10,0x02,0x0f,0x88);
+DEFINE_GUID(IID_ID3D12DebugDevice,0x3febd6dd,0x4973,0x4787,0x81,0x94,0xe4,0x5f,0x9e,0x28,0x92,0x3e);
+DEFINE_GUID(IID_ID3D12DebugDevice2,0x60eccbc1,0x378d,0x4df1,0x89,0x4c,0xf8,0xac,0x5c,0xe4,0xd7,0xdd);
+DEFINE_GUID(IID_ID3D12DebugCommandQueue,0x09e0bf36,0x54ac,0x484f,0x88,0x47,0x4b,0xae,0xea,0xb6,0x05,0x3a);
+DEFINE_GUID(IID_ID3D12DebugCommandQueue1,0x16be35a2,0xbfd6,0x49f2,0xbc,0xae,0xea,0xae,0x4a,0xff,0x86,0x2d);
+DEFINE_GUID(IID_ID3D12DebugCommandList1,0x102ca951,0x311b,0x4b01,0xb1,0x1f,0xec,0xb8,0x3e,0x06,0x1b,0x37);
+DEFINE_GUID(IID_ID3D12DebugCommandList,0x09e0bf36,0x54ac,0x484f,0x88,0x47,0x4b,0xae,0xea,0xb6,0x05,0x3f);
+DEFINE_GUID(IID_ID3D12DebugCommandList2,0xaeb575cf,0x4e06,0x48be,0xba,0x3b,0xc4,0x50,0xfc,0x96,0x65,0x2e);
+DEFINE_GUID(IID_ID3D12DebugCommandList3,0x197d5e15,0x4d37,0x4d34,0xaf,0x78,0x72,0x4c,0xd7,0x0f,0xdb,0x1f);
+DEFINE_GUID(IID_ID3D12SharingContract,0x0adf7d52,0x929c,0x4e61,0xad,0xdb,0xff,0xed,0x30,0xde,0x66,0xef);
+DEFINE_GUID(IID_ID3D12InfoQueue,0x0742a90b,0xc387,0x483f,0xb9,0x46,0x30,0xa7,0xe4,0xe6,0x14,0x58);
+DEFINE_GUID(IID_ID3D12InfoQueue1,0x2852dd88,0xb484,0x4c0c,0xb6,0xb1,0x67,0x16,0x85,0x00,0xe6,0x00);
+
+
+extern RPC_IF_HANDLE __MIDL_itf_d3d12sdklayers_0000_0019_v0_0_c_ifspec;
+extern RPC_IF_HANDLE __MIDL_itf_d3d12sdklayers_0000_0019_v0_0_s_ifspec;
+
+/* Additional Prototypes for ALL interfaces */
+
+/* end of Additional Prototypes */
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+
+
diff --git a/thirdparty/directx_headers/d3d12shader.h b/thirdparty/directx_headers/d3d12shader.h
new file mode 100644
index 0000000000..0acf584e32
--- /dev/null
+++ b/thirdparty/directx_headers/d3d12shader.h
@@ -0,0 +1,490 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+//  Copyright (c) Microsoft Corporation.
+//  Licensed under the MIT license.
+//
+//  File:       D3D12Shader.h
+//  Content:    D3D12 Shader Types and APIs
+//
+//////////////////////////////////////////////////////////////////////////////
+
+#ifndef __D3D12SHADER_H__
+#define __D3D12SHADER_H__
+
+#include "d3dcommon.h"
+
+typedef enum D3D12_SHADER_VERSION_TYPE
+{
+    D3D12_SHVER_PIXEL_SHADER          = 0,
+    D3D12_SHVER_VERTEX_SHADER         = 1,
+    D3D12_SHVER_GEOMETRY_SHADER       = 2,
+    
+    // D3D11 Shaders
+    D3D12_SHVER_HULL_SHADER           = 3,
+    D3D12_SHVER_DOMAIN_SHADER         = 4,
+    D3D12_SHVER_COMPUTE_SHADER        = 5,
+
+    // D3D12 Shaders
+    D3D12_SHVER_LIBRARY               = 6,
+
+    D3D12_SHVER_RAY_GENERATION_SHADER = 7,
+    D3D12_SHVER_INTERSECTION_SHADER   = 8,
+    D3D12_SHVER_ANY_HIT_SHADER        = 9,
+    D3D12_SHVER_CLOSEST_HIT_SHADER    = 10,
+    D3D12_SHVER_MISS_SHADER           = 11,
+    D3D12_SHVER_CALLABLE_SHADER       = 12,
+
+    D3D12_SHVER_MESH_SHADER           = 13,
+    D3D12_SHVER_AMPLIFICATION_SHADER  = 14,
+
+    D3D12_SHVER_RESERVED0             = 0xFFF0,
+} D3D12_SHADER_VERSION_TYPE;
+
+#define D3D12_SHVER_GET_TYPE(_Version) \
+    (((_Version) >> 16) & 0xffff)
+#define D3D12_SHVER_GET_MAJOR(_Version) \
+    (((_Version) >> 4) & 0xf)
+#define D3D12_SHVER_GET_MINOR(_Version) \
+    (((_Version) >> 0) & 0xf)
+
+// Slot ID for library function return
+#define D3D_RETURN_PARAMETER_INDEX (-1)
+
+typedef D3D_RESOURCE_RETURN_TYPE D3D12_RESOURCE_RETURN_TYPE;
+
+typedef D3D_CBUFFER_TYPE D3D12_CBUFFER_TYPE;
+
+
+typedef struct _D3D12_SIGNATURE_PARAMETER_DESC
+{
+    LPCSTR                      SemanticName;   // Name of the semantic
+    UINT                        SemanticIndex;  // Index of the semantic
+    UINT                        Register;       // Number of member variables
+    D3D_NAME                    SystemValueType;// A predefined system value, or D3D_NAME_UNDEFINED if not applicable
+    D3D_REGISTER_COMPONENT_TYPE ComponentType;  // Scalar type (e.g. uint, float, etc.)
+    BYTE                        Mask;           // Mask to indicate which components of the register
+                                                // are used (combination of D3D10_COMPONENT_MASK values)
+    BYTE                        ReadWriteMask;  // Mask to indicate whether a given component is 
+                                                // never written (if this is an output signature) or
+                                                // always read (if this is an input signature).
+                                                // (combination of D3D_MASK_* values)
+    UINT                        Stream;         // Stream index
+    D3D_MIN_PRECISION           MinPrecision;   // Minimum desired interpolation precision
+} D3D12_SIGNATURE_PARAMETER_DESC;
+
+typedef struct _D3D12_SHADER_BUFFER_DESC
+{
+    LPCSTR                  Name;           // Name of the constant buffer
+    D3D_CBUFFER_TYPE        Type;           // Indicates type of buffer content
+    UINT                    Variables;      // Number of member variables
+    UINT                    Size;           // Size of CB (in bytes)
+    UINT                    uFlags;         // Buffer description flags
+} D3D12_SHADER_BUFFER_DESC;
+
+typedef struct _D3D12_SHADER_VARIABLE_DESC
+{
+    LPCSTR                  Name;           // Name of the variable
+    UINT                    StartOffset;    // Offset in constant buffer's backing store
+    UINT                    Size;           // Size of variable (in bytes)
+    UINT                    uFlags;         // Variable flags
+    LPVOID                  DefaultValue;   // Raw pointer to default value
+    UINT                    StartTexture;   // First texture index (or -1 if no textures used)
+    UINT                    TextureSize;    // Number of texture slots possibly used.
+    UINT                    StartSampler;   // First sampler index (or -1 if no textures used)
+    UINT                    SamplerSize;    // Number of sampler slots possibly used.
+} D3D12_SHADER_VARIABLE_DESC;
+
+typedef struct _D3D12_SHADER_TYPE_DESC
+{
+    D3D_SHADER_VARIABLE_CLASS   Class;          // Variable class (e.g. object, matrix, etc.)
+    D3D_SHADER_VARIABLE_TYPE    Type;           // Variable type (e.g. float, sampler, etc.)
+    UINT                        Rows;           // Number of rows (for matrices, 1 for other numeric, 0 if not applicable)
+    UINT                        Columns;        // Number of columns (for vectors & matrices, 1 for other numeric, 0 if not applicable)
+    UINT                        Elements;       // Number of elements (0 if not an array)
+    UINT                        Members;        // Number of members (0 if not a structure)
+    UINT                        Offset;         // Offset from the start of structure (0 if not a structure member)
+    LPCSTR                      Name;           // Name of type, can be NULL
+} D3D12_SHADER_TYPE_DESC;
+
+typedef D3D_TESSELLATOR_DOMAIN D3D12_TESSELLATOR_DOMAIN;
+
+typedef D3D_TESSELLATOR_PARTITIONING D3D12_TESSELLATOR_PARTITIONING;
+
+typedef D3D_TESSELLATOR_OUTPUT_PRIMITIVE D3D12_TESSELLATOR_OUTPUT_PRIMITIVE;
+
+typedef struct _D3D12_SHADER_DESC
+{
+    UINT                    Version;                     // Shader version
+    LPCSTR                  Creator;                     // Creator string
+    UINT                    Flags;                       // Shader compilation/parse flags
+    
+    UINT                    ConstantBuffers;             // Number of constant buffers
+    UINT                    BoundResources;              // Number of bound resources
+    UINT                    InputParameters;             // Number of parameters in the input signature
+    UINT                    OutputParameters;            // Number of parameters in the output signature
+
+    UINT                    InstructionCount;            // Number of emitted instructions
+    UINT                    TempRegisterCount;           // Number of temporary registers used 
+    UINT                    TempArrayCount;              // Number of temporary arrays used
+    UINT                    DefCount;                    // Number of constant defines 
+    UINT                    DclCount;                    // Number of declarations (input + output)
+    UINT                    TextureNormalInstructions;   // Number of non-categorized texture instructions
+    UINT                    TextureLoadInstructions;     // Number of texture load instructions
+    UINT                    TextureCompInstructions;     // Number of texture comparison instructions
+    UINT                    TextureBiasInstructions;     // Number of texture bias instructions
+    UINT                    TextureGradientInstructions; // Number of texture gradient instructions
+    UINT                    FloatInstructionCount;       // Number of floating point arithmetic instructions used
+    UINT                    IntInstructionCount;         // Number of signed integer arithmetic instructions used
+    UINT                    UintInstructionCount;        // Number of unsigned integer arithmetic instructions used
+    UINT                    StaticFlowControlCount;      // Number of static flow control instructions used
+    UINT                    DynamicFlowControlCount;     // Number of dynamic flow control instructions used
+    UINT                    MacroInstructionCount;       // Number of macro instructions used
+    UINT                    ArrayInstructionCount;       // Number of array instructions used
+    UINT                    CutInstructionCount;         // Number of cut instructions used
+    UINT                    EmitInstructionCount;        // Number of emit instructions used
+    D3D_PRIMITIVE_TOPOLOGY  GSOutputTopology;            // Geometry shader output topology
+    UINT                    GSMaxOutputVertexCount;      // Geometry shader maximum output vertex count
+    D3D_PRIMITIVE           InputPrimitive;              // GS/HS input primitive
+    UINT                    PatchConstantParameters;     // Number of parameters in the patch constant signature
+    UINT                    cGSInstanceCount;            // Number of Geometry shader instances
+    UINT                    cControlPoints;              // Number of control points in the HS->DS stage
+    D3D_TESSELLATOR_OUTPUT_PRIMITIVE HSOutputPrimitive;  // Primitive output by the tessellator
+    D3D_TESSELLATOR_PARTITIONING HSPartitioning;         // Partitioning mode of the tessellator
+    D3D_TESSELLATOR_DOMAIN  TessellatorDomain;           // Domain of the tessellator (quad, tri, isoline)
+    // instruction counts
+    UINT cBarrierInstructions;                           // Number of barrier instructions in a compute shader
+    UINT cInterlockedInstructions;                       // Number of interlocked instructions
+    UINT cTextureStoreInstructions;                      // Number of texture writes
+} D3D12_SHADER_DESC;
+
+typedef struct _D3D12_SHADER_INPUT_BIND_DESC
+{
+    LPCSTR                      Name;           // Name of the resource
+    D3D_SHADER_INPUT_TYPE       Type;           // Type of resource (e.g. texture, cbuffer, etc.)
+    UINT                        BindPoint;      // Starting bind point
+    UINT                        BindCount;      // Number of contiguous bind points (for arrays)
+
+    UINT                        uFlags;         // Input binding flags
+    D3D_RESOURCE_RETURN_TYPE    ReturnType;     // Return type (if texture)
+    D3D_SRV_DIMENSION           Dimension;      // Dimension (if texture)
+    UINT                        NumSamples;     // Number of samples (0 if not MS texture)
+    UINT                        Space;          // Register space
+    UINT uID;                                   // Range ID in the bytecode
+} D3D12_SHADER_INPUT_BIND_DESC;
+
+#define D3D_SHADER_REQUIRES_DOUBLES                                                         0x00000001
+#define D3D_SHADER_REQUIRES_EARLY_DEPTH_STENCIL                                             0x00000002
+#define D3D_SHADER_REQUIRES_UAVS_AT_EVERY_STAGE                                             0x00000004
+#define D3D_SHADER_REQUIRES_64_UAVS                                                         0x00000008
+#define D3D_SHADER_REQUIRES_MINIMUM_PRECISION                                               0x00000010
+#define D3D_SHADER_REQUIRES_11_1_DOUBLE_EXTENSIONS                                          0x00000020
+#define D3D_SHADER_REQUIRES_11_1_SHADER_EXTENSIONS                                          0x00000040
+#define D3D_SHADER_REQUIRES_LEVEL_9_COMPARISON_FILTERING                                    0x00000080
+#define D3D_SHADER_REQUIRES_TILED_RESOURCES                                                 0x00000100
+#define D3D_SHADER_REQUIRES_STENCIL_REF                                                     0x00000200
+#define D3D_SHADER_REQUIRES_INNER_COVERAGE                                                  0x00000400
+#define D3D_SHADER_REQUIRES_TYPED_UAV_LOAD_ADDITIONAL_FORMATS                               0x00000800
+#define D3D_SHADER_REQUIRES_ROVS                                                            0x00001000
+#define D3D_SHADER_REQUIRES_VIEWPORT_AND_RT_ARRAY_INDEX_FROM_ANY_SHADER_FEEDING_RASTERIZER  0x00002000
+#define D3D_SHADER_REQUIRES_WAVE_OPS                                                        0x00004000
+#define D3D_SHADER_REQUIRES_INT64_OPS                                                       0x00008000
+#define D3D_SHADER_REQUIRES_VIEW_ID                                                         0x00010000
+#define D3D_SHADER_REQUIRES_BARYCENTRICS                                                    0x00020000
+#define D3D_SHADER_REQUIRES_NATIVE_16BIT_OPS                                                0x00040000
+#define D3D_SHADER_REQUIRES_SHADING_RATE                                                    0x00080000
+#define D3D_SHADER_REQUIRES_RAYTRACING_TIER_1_1                                             0x00100000
+#define D3D_SHADER_REQUIRES_SAMPLER_FEEDBACK                                                0x00200000
+#define D3D_SHADER_REQUIRES_ATOMIC_INT64_ON_TYPED_RESOURCE                                  0x00400000
+#define D3D_SHADER_REQUIRES_ATOMIC_INT64_ON_GROUP_SHARED                                    0x00800000
+#define D3D_SHADER_REQUIRES_DERIVATIVES_IN_MESH_AND_AMPLIFICATION_SHADERS                   0x01000000
+#define D3D_SHADER_REQUIRES_RESOURCE_DESCRIPTOR_HEAP_INDEXING                               0x02000000
+#define D3D_SHADER_REQUIRES_SAMPLER_DESCRIPTOR_HEAP_INDEXING                                0x04000000
+#define D3D_SHADER_REQUIRES_WAVE_MMA                                                        0x08000000
+#define D3D_SHADER_REQUIRES_ATOMIC_INT64_ON_DESCRIPTOR_HEAP_RESOURCE                        0x10000000
+#define D3D_SHADER_FEATURE_ADVANCED_TEXTURE_OPS                                             0x20000000
+#define D3D_SHADER_FEATURE_WRITEABLE_MSAA_TEXTURES                                          0x40000000
+
+
+typedef struct _D3D12_LIBRARY_DESC
+{
+    LPCSTR    Creator;           // The name of the originator of the library.
+    UINT      Flags;             // Compilation flags.
+    UINT      FunctionCount;     // Number of functions exported from the library.
+} D3D12_LIBRARY_DESC;
+
+typedef struct _D3D12_FUNCTION_DESC
+{
+    UINT                    Version;                     // Shader version
+    LPCSTR                  Creator;                     // Creator string
+    UINT                    Flags;                       // Shader compilation/parse flags
+    
+    UINT                    ConstantBuffers;             // Number of constant buffers
+    UINT                    BoundResources;              // Number of bound resources
+
+    UINT                    InstructionCount;            // Number of emitted instructions
+    UINT                    TempRegisterCount;           // Number of temporary registers used 
+    UINT                    TempArrayCount;              // Number of temporary arrays used
+    UINT                    DefCount;                    // Number of constant defines 
+    UINT                    DclCount;                    // Number of declarations (input + output)
+    UINT                    TextureNormalInstructions;   // Number of non-categorized texture instructions
+    UINT                    TextureLoadInstructions;     // Number of texture load instructions
+    UINT                    TextureCompInstructions;     // Number of texture comparison instructions
+    UINT                    TextureBiasInstructions;     // Number of texture bias instructions
+    UINT                    TextureGradientInstructions; // Number of texture gradient instructions
+    UINT                    FloatInstructionCount;       // Number of floating point arithmetic instructions used
+    UINT                    IntInstructionCount;         // Number of signed integer arithmetic instructions used
+    UINT                    UintInstructionCount;        // Number of unsigned integer arithmetic instructions used
+    UINT                    StaticFlowControlCount;      // Number of static flow control instructions used
+    UINT                    DynamicFlowControlCount;     // Number of dynamic flow control instructions used
+    UINT                    MacroInstructionCount;       // Number of macro instructions used
+    UINT                    ArrayInstructionCount;       // Number of array instructions used
+    UINT                    MovInstructionCount;         // Number of mov instructions used
+    UINT                    MovcInstructionCount;        // Number of movc instructions used
+    UINT                    ConversionInstructionCount;  // Number of type conversion instructions used
+    UINT                    BitwiseInstructionCount;     // Number of bitwise arithmetic instructions used
+    D3D_FEATURE_LEVEL       MinFeatureLevel;             // Min target of the function byte code
+    UINT64                  RequiredFeatureFlags;        // Required feature flags
+
+    LPCSTR                  Name;                        // Function name
+    INT                     FunctionParameterCount;      // Number of logical parameters in the function signature (not including return)
+    BOOL                    HasReturn;                   // TRUE, if function returns a value, false - it is a subroutine
+    BOOL                    Has10Level9VertexShader;     // TRUE, if there is a 10L9 VS blob
+    BOOL                    Has10Level9PixelShader;      // TRUE, if there is a 10L9 PS blob
+} D3D12_FUNCTION_DESC;
+
+typedef struct _D3D12_PARAMETER_DESC
+{
+    LPCSTR                      Name;               // Parameter name.
+    LPCSTR                      SemanticName;       // Parameter semantic name (+index).
+    D3D_SHADER_VARIABLE_TYPE    Type;               // Element type.
+    D3D_SHADER_VARIABLE_CLASS   Class;              // Scalar/Vector/Matrix.
+    UINT                        Rows;               // Rows are for matrix parameters.
+    UINT                        Columns;            // Components or Columns in matrix.
+    D3D_INTERPOLATION_MODE      InterpolationMode;  // Interpolation mode.
+    D3D_PARAMETER_FLAGS         Flags;              // Parameter modifiers.
+
+    UINT                        FirstInRegister;    // The first input register for this parameter.
+    UINT                        FirstInComponent;   // The first input register component for this parameter.
+    UINT                        FirstOutRegister;   // The first output register for this parameter.
+    UINT                        FirstOutComponent;  // The first output register component for this parameter.
+} D3D12_PARAMETER_DESC;
+
+
+//////////////////////////////////////////////////////////////////////////////
+// Interfaces ////////////////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////////////////
+
+typedef interface ID3D12ShaderReflectionType ID3D12ShaderReflectionType;
+typedef interface ID3D12ShaderReflectionType *LPD3D12SHADERREFLECTIONTYPE;
+
+typedef interface ID3D12ShaderReflectionVariable ID3D12ShaderReflectionVariable;
+typedef interface ID3D12ShaderReflectionVariable *LPD3D12SHADERREFLECTIONVARIABLE;
+
+typedef interface ID3D12ShaderReflectionConstantBuffer ID3D12ShaderReflectionConstantBuffer;
+typedef interface ID3D12ShaderReflectionConstantBuffer *LPD3D12SHADERREFLECTIONCONSTANTBUFFER;
+
+typedef interface ID3D12ShaderReflection ID3D12ShaderReflection;
+typedef interface ID3D12ShaderReflection *LPD3D12SHADERREFLECTION;
+
+typedef interface ID3D12LibraryReflection ID3D12LibraryReflection;
+typedef interface ID3D12LibraryReflection *LPD3D12LIBRARYREFLECTION;
+
+typedef interface ID3D12FunctionReflection ID3D12FunctionReflection;
+typedef interface ID3D12FunctionReflection *LPD3D12FUNCTIONREFLECTION;
+
+typedef interface ID3D12FunctionParameterReflection ID3D12FunctionParameterReflection;
+typedef interface ID3D12FunctionParameterReflection *LPD3D12FUNCTIONPARAMETERREFLECTION;
+
+
+// {E913C351-783D-48CA-A1D1-4F306284AD56}
+interface DECLSPEC_UUID("E913C351-783D-48CA-A1D1-4F306284AD56") ID3D12ShaderReflectionType;
+DEFINE_GUID(IID_ID3D12ShaderReflectionType, 
+0xe913c351, 0x783d, 0x48ca, 0xa1, 0xd1, 0x4f, 0x30, 0x62, 0x84, 0xad, 0x56);
+
+#undef INTERFACE
+#define INTERFACE ID3D12ShaderReflectionType
+
+DECLARE_INTERFACE(ID3D12ShaderReflectionType)
+{
+    STDMETHOD(GetDesc)(THIS_ _Out_ D3D12_SHADER_TYPE_DESC *pDesc) PURE;
+    
+    STDMETHOD_(ID3D12ShaderReflectionType*, GetMemberTypeByIndex)(THIS_ _In_ UINT Index) PURE;
+    STDMETHOD_(ID3D12ShaderReflectionType*, GetMemberTypeByName)(THIS_ _In_ LPCSTR Name) PURE;
+    STDMETHOD_(LPCSTR, GetMemberTypeName)(THIS_ _In_ UINT Index) PURE;
+
+    STDMETHOD(IsEqual)(THIS_ _In_ ID3D12ShaderReflectionType* pType) PURE;
+    STDMETHOD_(ID3D12ShaderReflectionType*, GetSubType)(THIS) PURE;
+    STDMETHOD_(ID3D12ShaderReflectionType*, GetBaseClass)(THIS) PURE;
+    STDMETHOD_(UINT, GetNumInterfaces)(THIS) PURE;
+    STDMETHOD_(ID3D12ShaderReflectionType*, GetInterfaceByIndex)(THIS_ _In_ UINT uIndex) PURE;
+    STDMETHOD(IsOfType)(THIS_ _In_ ID3D12ShaderReflectionType* pType) PURE;
+    STDMETHOD(ImplementsInterface)(THIS_ _In_ ID3D12ShaderReflectionType* pBase) PURE;
+};
+
+// {8337A8A6-A216-444A-B2F4-314733A73AEA}
+interface DECLSPEC_UUID("8337A8A6-A216-444A-B2F4-314733A73AEA") ID3D12ShaderReflectionVariable;
+DEFINE_GUID(IID_ID3D12ShaderReflectionVariable, 
+0x8337a8a6, 0xa216, 0x444a, 0xb2, 0xf4, 0x31, 0x47, 0x33, 0xa7, 0x3a, 0xea);
+
+#undef INTERFACE
+#define INTERFACE ID3D12ShaderReflectionVariable
+
+DECLARE_INTERFACE(ID3D12ShaderReflectionVariable)
+{
+    STDMETHOD(GetDesc)(THIS_ _Out_ D3D12_SHADER_VARIABLE_DESC *pDesc) PURE;
+    
+    STDMETHOD_(ID3D12ShaderReflectionType*, GetType)(THIS) PURE;
+    STDMETHOD_(ID3D12ShaderReflectionConstantBuffer*, GetBuffer)(THIS) PURE;
+
+    STDMETHOD_(UINT, GetInterfaceSlot)(THIS_ _In_ UINT uArrayIndex) PURE;
+};
+
+// {C59598B4-48B3-4869-B9B1-B1618B14A8B7}
+interface DECLSPEC_UUID("C59598B4-48B3-4869-B9B1-B1618B14A8B7") ID3D12ShaderReflectionConstantBuffer;
+DEFINE_GUID(IID_ID3D12ShaderReflectionConstantBuffer, 
+0xc59598b4, 0x48b3, 0x4869, 0xb9, 0xb1, 0xb1, 0x61, 0x8b, 0x14, 0xa8, 0xb7);
+
+#undef INTERFACE
+#define INTERFACE ID3D12ShaderReflectionConstantBuffer
+
+DECLARE_INTERFACE(ID3D12ShaderReflectionConstantBuffer)
+{
+    STDMETHOD(GetDesc)(THIS_ D3D12_SHADER_BUFFER_DESC *pDesc) PURE;
+    
+    STDMETHOD_(ID3D12ShaderReflectionVariable*, GetVariableByIndex)(THIS_ _In_ UINT Index) PURE;
+    STDMETHOD_(ID3D12ShaderReflectionVariable*, GetVariableByName)(THIS_ _In_ LPCSTR Name) PURE;
+};
+
+// The ID3D12ShaderReflection IID may change from SDK version to SDK version
+// if the reflection API changes.  This prevents new code with the new API
+// from working with an old binary.  Recompiling with the new header
+// will pick up the new IID.
+
+// {5A58797D-A72C-478D-8BA2-EFC6B0EFE88E}
+interface DECLSPEC_UUID("5A58797D-A72C-478D-8BA2-EFC6B0EFE88E") ID3D12ShaderReflection;
+DEFINE_GUID(IID_ID3D12ShaderReflection, 
+0x5a58797d, 0xa72c, 0x478d, 0x8b, 0xa2, 0xef, 0xc6, 0xb0, 0xef, 0xe8, 0x8e);
+
+#undef INTERFACE
+#define INTERFACE ID3D12ShaderReflection
+
+DECLARE_INTERFACE_(ID3D12ShaderReflection, IUnknown)
+{
+    STDMETHOD(QueryInterface)(THIS_ _In_ REFIID iid,
+                              _Out_ LPVOID *ppv) PURE;
+    STDMETHOD_(ULONG, AddRef)(THIS) PURE;
+    STDMETHOD_(ULONG, Release)(THIS) PURE;
+
+    STDMETHOD(GetDesc)(THIS_ _Out_ D3D12_SHADER_DESC *pDesc) PURE;
+    
+    STDMETHOD_(ID3D12ShaderReflectionConstantBuffer*, GetConstantBufferByIndex)(THIS_ _In_ UINT Index) PURE;
+    STDMETHOD_(ID3D12ShaderReflectionConstantBuffer*, GetConstantBufferByName)(THIS_ _In_ LPCSTR Name) PURE;
+    
+    STDMETHOD(GetResourceBindingDesc)(THIS_ _In_ UINT ResourceIndex,
+                                      _Out_ D3D12_SHADER_INPUT_BIND_DESC *pDesc) PURE;
+    
+    STDMETHOD(GetInputParameterDesc)(THIS_ _In_ UINT ParameterIndex,
+                                     _Out_ D3D12_SIGNATURE_PARAMETER_DESC *pDesc) PURE;
+    STDMETHOD(GetOutputParameterDesc)(THIS_ _In_ UINT ParameterIndex,
+                                      _Out_ D3D12_SIGNATURE_PARAMETER_DESC *pDesc) PURE;
+    STDMETHOD(GetPatchConstantParameterDesc)(THIS_ _In_ UINT ParameterIndex,
+                                             _Out_ D3D12_SIGNATURE_PARAMETER_DESC *pDesc) PURE;
+
+    STDMETHOD_(ID3D12ShaderReflectionVariable*, GetVariableByName)(THIS_ _In_ LPCSTR Name) PURE;
+
+    STDMETHOD(GetResourceBindingDescByName)(THIS_ _In_ LPCSTR Name,
+                                            _Out_ D3D12_SHADER_INPUT_BIND_DESC *pDesc) PURE;
+
+    STDMETHOD_(UINT, GetMovInstructionCount)(THIS) PURE;
+    STDMETHOD_(UINT, GetMovcInstructionCount)(THIS) PURE;
+    STDMETHOD_(UINT, GetConversionInstructionCount)(THIS) PURE;
+    STDMETHOD_(UINT, GetBitwiseInstructionCount)(THIS) PURE;
+    
+    STDMETHOD_(D3D_PRIMITIVE, GetGSInputPrimitive)(THIS) PURE;
+    STDMETHOD_(BOOL, IsSampleFrequencyShader)(THIS) PURE;
+
+    STDMETHOD_(UINT, GetNumInterfaceSlots)(THIS) PURE;
+    STDMETHOD(GetMinFeatureLevel)(THIS_ _Out_ enum D3D_FEATURE_LEVEL* pLevel) PURE;
+
+    STDMETHOD_(UINT, GetThreadGroupSize)(THIS_
+                                         _Out_opt_ UINT* pSizeX,
+                                         _Out_opt_ UINT* pSizeY,
+                                         _Out_opt_ UINT* pSizeZ) PURE;
+
+    STDMETHOD_(UINT64, GetRequiresFlags)(THIS) PURE;
+};
+
+// {8E349D19-54DB-4A56-9DC9-119D87BDB804}
+interface DECLSPEC_UUID("8E349D19-54DB-4A56-9DC9-119D87BDB804") ID3D12LibraryReflection;
+DEFINE_GUID(IID_ID3D12LibraryReflection, 
+0x8e349d19, 0x54db, 0x4a56, 0x9d, 0xc9, 0x11, 0x9d, 0x87, 0xbd, 0xb8, 0x4);
+
+#undef INTERFACE
+#define INTERFACE ID3D12LibraryReflection
+
+DECLARE_INTERFACE_(ID3D12LibraryReflection, IUnknown)
+{
+    STDMETHOD(QueryInterface)(THIS_ _In_ REFIID iid, _Out_ LPVOID * ppv) PURE;
+    STDMETHOD_(ULONG, AddRef)(THIS) PURE;
+    STDMETHOD_(ULONG, Release)(THIS) PURE;
+
+    STDMETHOD(GetDesc)(THIS_ _Out_ D3D12_LIBRARY_DESC * pDesc) PURE;
+    
+    STDMETHOD_(ID3D12FunctionReflection *, GetFunctionByIndex)(THIS_ _In_ INT FunctionIndex) PURE;
+};
+
+// {1108795C-2772-4BA9-B2A8-D464DC7E2799}
+interface DECLSPEC_UUID("1108795C-2772-4BA9-B2A8-D464DC7E2799") ID3D12FunctionReflection;
+DEFINE_GUID(IID_ID3D12FunctionReflection, 
+0x1108795c, 0x2772, 0x4ba9, 0xb2, 0xa8, 0xd4, 0x64, 0xdc, 0x7e, 0x27, 0x99);
+
+#undef INTERFACE
+#define INTERFACE ID3D12FunctionReflection
+
+DECLARE_INTERFACE(ID3D12FunctionReflection)
+{
+    STDMETHOD(GetDesc)(THIS_ _Out_ D3D12_FUNCTION_DESC * pDesc) PURE;
+    
+    STDMETHOD_(ID3D12ShaderReflectionConstantBuffer *, GetConstantBufferByIndex)(THIS_ _In_ UINT BufferIndex) PURE;
+    STDMETHOD_(ID3D12ShaderReflectionConstantBuffer *, GetConstantBufferByName)(THIS_ _In_ LPCSTR Name) PURE;
+    
+    STDMETHOD(GetResourceBindingDesc)(THIS_ _In_ UINT ResourceIndex,
+                                      _Out_ D3D12_SHADER_INPUT_BIND_DESC * pDesc) PURE;
+    
+    STDMETHOD_(ID3D12ShaderReflectionVariable *, GetVariableByName)(THIS_ _In_ LPCSTR Name) PURE;
+
+    STDMETHOD(GetResourceBindingDescByName)(THIS_ _In_ LPCSTR Name,
+                                            _Out_ D3D12_SHADER_INPUT_BIND_DESC * pDesc) PURE;
+
+    // Use D3D_RETURN_PARAMETER_INDEX to get description of the return value.
+    STDMETHOD_(ID3D12FunctionParameterReflection *, GetFunctionParameter)(THIS_ _In_ INT ParameterIndex) PURE;
+};
+
+// {EC25F42D-7006-4F2B-B33E-02CC3375733F}
+interface DECLSPEC_UUID("EC25F42D-7006-4F2B-B33E-02CC3375733F") ID3D12FunctionParameterReflection;
+DEFINE_GUID(IID_ID3D12FunctionParameterReflection, 
+0xec25f42d, 0x7006, 0x4f2b, 0xb3, 0x3e, 0x2, 0xcc, 0x33, 0x75, 0x73, 0x3f);
+
+#undef INTERFACE
+#define INTERFACE ID3D12FunctionParameterReflection
+
+DECLARE_INTERFACE(ID3D12FunctionParameterReflection)
+{
+    STDMETHOD(GetDesc)(THIS_ _Out_ D3D12_PARAMETER_DESC * pDesc) PURE;
+};
+
+
+//////////////////////////////////////////////////////////////////////////////
+// APIs //////////////////////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////////////////
+
+#ifdef __cplusplus
+extern "C" {
+#endif //__cplusplus
+
+#ifdef __cplusplus
+}
+#endif //__cplusplus
+    
+#endif //__D3D12SHADER_H__
+
diff --git a/thirdparty/directx_headers/d3d12video.h b/thirdparty/directx_headers/d3d12video.h
new file mode 100644
index 0000000000..add372e381
--- /dev/null
+++ b/thirdparty/directx_headers/d3d12video.h
@@ -0,0 +1,8584 @@
+/*-------------------------------------------------------------------------------------
+ *
+ * Copyright (c) Microsoft Corporation
+ * Licensed under the MIT license
+ *
+ *-------------------------------------------------------------------------------------*/
+
+
+/* this ALWAYS GENERATED file contains the definitions for the interfaces */
+
+
+ /* File created by MIDL compiler version 8.01.0628 */
+
+
+
+/* verify that the <rpcndr.h> version is high enough to compile this file*/
+#ifndef __REQUIRED_RPCNDR_H_VERSION__
+#define __REQUIRED_RPCNDR_H_VERSION__ 500
+#endif
+
+/* verify that the <rpcsal.h> version is high enough to compile this file*/
+#ifndef __REQUIRED_RPCSAL_H_VERSION__
+#define __REQUIRED_RPCSAL_H_VERSION__ 100
+#endif
+
+#include "rpc.h"
+#include "rpcndr.h"
+
+#ifndef __RPCNDR_H_VERSION__
+#error this stub requires an updated version of <rpcndr.h>
+#endif /* __RPCNDR_H_VERSION__ */
+
+#ifndef COM_NO_WINDOWS_H
+#include "windows.h"
+#include "ole2.h"
+#endif /*COM_NO_WINDOWS_H*/
+
+#ifndef __d3d12video_h__
+#define __d3d12video_h__
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+#pragma once
+#endif
+
+#ifndef DECLSPEC_XFGVIRT
+#if defined(_CONTROL_FLOW_GUARD_XFG)
+#define DECLSPEC_XFGVIRT(base, func) __declspec(xfg_virtual(base, func))
+#else
+#define DECLSPEC_XFGVIRT(base, func)
+#endif
+#endif
+
+/* Forward Declarations */ 
+
+#ifndef __ID3D12VideoDecoderHeap_FWD_DEFINED__
+#define __ID3D12VideoDecoderHeap_FWD_DEFINED__
+typedef interface ID3D12VideoDecoderHeap ID3D12VideoDecoderHeap;
+
+#endif 	/* __ID3D12VideoDecoderHeap_FWD_DEFINED__ */
+
+
+#ifndef __ID3D12VideoDevice_FWD_DEFINED__
+#define __ID3D12VideoDevice_FWD_DEFINED__
+typedef interface ID3D12VideoDevice ID3D12VideoDevice;
+
+#endif 	/* __ID3D12VideoDevice_FWD_DEFINED__ */
+
+
+#ifndef __ID3D12VideoDecoder_FWD_DEFINED__
+#define __ID3D12VideoDecoder_FWD_DEFINED__
+typedef interface ID3D12VideoDecoder ID3D12VideoDecoder;
+
+#endif 	/* __ID3D12VideoDecoder_FWD_DEFINED__ */
+
+
+#ifndef __ID3D12VideoProcessor_FWD_DEFINED__
+#define __ID3D12VideoProcessor_FWD_DEFINED__
+typedef interface ID3D12VideoProcessor ID3D12VideoProcessor;
+
+#endif 	/* __ID3D12VideoProcessor_FWD_DEFINED__ */
+
+
+#ifndef __ID3D12VideoDecodeCommandList_FWD_DEFINED__
+#define __ID3D12VideoDecodeCommandList_FWD_DEFINED__
+typedef interface ID3D12VideoDecodeCommandList ID3D12VideoDecodeCommandList;
+
+#endif 	/* __ID3D12VideoDecodeCommandList_FWD_DEFINED__ */
+
+
+#ifndef __ID3D12VideoProcessCommandList_FWD_DEFINED__
+#define __ID3D12VideoProcessCommandList_FWD_DEFINED__
+typedef interface ID3D12VideoProcessCommandList ID3D12VideoProcessCommandList;
+
+#endif 	/* __ID3D12VideoProcessCommandList_FWD_DEFINED__ */
+
+
+#ifndef __ID3D12VideoDecodeCommandList1_FWD_DEFINED__
+#define __ID3D12VideoDecodeCommandList1_FWD_DEFINED__
+typedef interface ID3D12VideoDecodeCommandList1 ID3D12VideoDecodeCommandList1;
+
+#endif 	/* __ID3D12VideoDecodeCommandList1_FWD_DEFINED__ */
+
+
+#ifndef __ID3D12VideoProcessCommandList1_FWD_DEFINED__
+#define __ID3D12VideoProcessCommandList1_FWD_DEFINED__
+typedef interface ID3D12VideoProcessCommandList1 ID3D12VideoProcessCommandList1;
+
+#endif 	/* __ID3D12VideoProcessCommandList1_FWD_DEFINED__ */
+
+
+#ifndef __ID3D12VideoMotionEstimator_FWD_DEFINED__
+#define __ID3D12VideoMotionEstimator_FWD_DEFINED__
+typedef interface ID3D12VideoMotionEstimator ID3D12VideoMotionEstimator;
+
+#endif 	/* __ID3D12VideoMotionEstimator_FWD_DEFINED__ */
+
+
+#ifndef __ID3D12VideoMotionVectorHeap_FWD_DEFINED__
+#define __ID3D12VideoMotionVectorHeap_FWD_DEFINED__
+typedef interface ID3D12VideoMotionVectorHeap ID3D12VideoMotionVectorHeap;
+
+#endif 	/* __ID3D12VideoMotionVectorHeap_FWD_DEFINED__ */
+
+
+#ifndef __ID3D12VideoDevice1_FWD_DEFINED__
+#define __ID3D12VideoDevice1_FWD_DEFINED__
+typedef interface ID3D12VideoDevice1 ID3D12VideoDevice1;
+
+#endif 	/* __ID3D12VideoDevice1_FWD_DEFINED__ */
+
+
+#ifndef __ID3D12VideoEncodeCommandList_FWD_DEFINED__
+#define __ID3D12VideoEncodeCommandList_FWD_DEFINED__
+typedef interface ID3D12VideoEncodeCommandList ID3D12VideoEncodeCommandList;
+
+#endif 	/* __ID3D12VideoEncodeCommandList_FWD_DEFINED__ */
+
+
+#ifndef __ID3D12VideoDecoder1_FWD_DEFINED__
+#define __ID3D12VideoDecoder1_FWD_DEFINED__
+typedef interface ID3D12VideoDecoder1 ID3D12VideoDecoder1;
+
+#endif 	/* __ID3D12VideoDecoder1_FWD_DEFINED__ */
+
+
+#ifndef __ID3D12VideoDecoderHeap1_FWD_DEFINED__
+#define __ID3D12VideoDecoderHeap1_FWD_DEFINED__
+typedef interface ID3D12VideoDecoderHeap1 ID3D12VideoDecoderHeap1;
+
+#endif 	/* __ID3D12VideoDecoderHeap1_FWD_DEFINED__ */
+
+
+#ifndef __ID3D12VideoProcessor1_FWD_DEFINED__
+#define __ID3D12VideoProcessor1_FWD_DEFINED__
+typedef interface ID3D12VideoProcessor1 ID3D12VideoProcessor1;
+
+#endif 	/* __ID3D12VideoProcessor1_FWD_DEFINED__ */
+
+
+#ifndef __ID3D12VideoExtensionCommand_FWD_DEFINED__
+#define __ID3D12VideoExtensionCommand_FWD_DEFINED__
+typedef interface ID3D12VideoExtensionCommand ID3D12VideoExtensionCommand;
+
+#endif 	/* __ID3D12VideoExtensionCommand_FWD_DEFINED__ */
+
+
+#ifndef __ID3D12VideoDevice2_FWD_DEFINED__
+#define __ID3D12VideoDevice2_FWD_DEFINED__
+typedef interface ID3D12VideoDevice2 ID3D12VideoDevice2;
+
+#endif 	/* __ID3D12VideoDevice2_FWD_DEFINED__ */
+
+
+#ifndef __ID3D12VideoDecodeCommandList2_FWD_DEFINED__
+#define __ID3D12VideoDecodeCommandList2_FWD_DEFINED__
+typedef interface ID3D12VideoDecodeCommandList2 ID3D12VideoDecodeCommandList2;
+
+#endif 	/* __ID3D12VideoDecodeCommandList2_FWD_DEFINED__ */
+
+
+#ifndef __ID3D12VideoDecodeCommandList3_FWD_DEFINED__
+#define __ID3D12VideoDecodeCommandList3_FWD_DEFINED__
+typedef interface ID3D12VideoDecodeCommandList3 ID3D12VideoDecodeCommandList3;
+
+#endif 	/* __ID3D12VideoDecodeCommandList3_FWD_DEFINED__ */
+
+
+#ifndef __ID3D12VideoProcessCommandList2_FWD_DEFINED__
+#define __ID3D12VideoProcessCommandList2_FWD_DEFINED__
+typedef interface ID3D12VideoProcessCommandList2 ID3D12VideoProcessCommandList2;
+
+#endif 	/* __ID3D12VideoProcessCommandList2_FWD_DEFINED__ */
+
+
+#ifndef __ID3D12VideoProcessCommandList3_FWD_DEFINED__
+#define __ID3D12VideoProcessCommandList3_FWD_DEFINED__
+typedef interface ID3D12VideoProcessCommandList3 ID3D12VideoProcessCommandList3;
+
+#endif 	/* __ID3D12VideoProcessCommandList3_FWD_DEFINED__ */
+
+
+#ifndef __ID3D12VideoEncodeCommandList1_FWD_DEFINED__
+#define __ID3D12VideoEncodeCommandList1_FWD_DEFINED__
+typedef interface ID3D12VideoEncodeCommandList1 ID3D12VideoEncodeCommandList1;
+
+#endif 	/* __ID3D12VideoEncodeCommandList1_FWD_DEFINED__ */
+
+
+#ifndef __ID3D12VideoEncoder_FWD_DEFINED__
+#define __ID3D12VideoEncoder_FWD_DEFINED__
+typedef interface ID3D12VideoEncoder ID3D12VideoEncoder;
+
+#endif 	/* __ID3D12VideoEncoder_FWD_DEFINED__ */
+
+
+#ifndef __ID3D12VideoEncoderHeap_FWD_DEFINED__
+#define __ID3D12VideoEncoderHeap_FWD_DEFINED__
+typedef interface ID3D12VideoEncoderHeap ID3D12VideoEncoderHeap;
+
+#endif 	/* __ID3D12VideoEncoderHeap_FWD_DEFINED__ */
+
+
+#ifndef __ID3D12VideoDevice3_FWD_DEFINED__
+#define __ID3D12VideoDevice3_FWD_DEFINED__
+typedef interface ID3D12VideoDevice3 ID3D12VideoDevice3;
+
+#endif 	/* __ID3D12VideoDevice3_FWD_DEFINED__ */
+
+
+#ifndef __ID3D12VideoEncodeCommandList2_FWD_DEFINED__
+#define __ID3D12VideoEncodeCommandList2_FWD_DEFINED__
+typedef interface ID3D12VideoEncodeCommandList2 ID3D12VideoEncodeCommandList2;
+
+#endif 	/* __ID3D12VideoEncodeCommandList2_FWD_DEFINED__ */
+
+
+#ifndef __ID3D12VideoEncodeCommandList3_FWD_DEFINED__
+#define __ID3D12VideoEncodeCommandList3_FWD_DEFINED__
+typedef interface ID3D12VideoEncodeCommandList3 ID3D12VideoEncodeCommandList3;
+
+#endif 	/* __ID3D12VideoEncodeCommandList3_FWD_DEFINED__ */
+
+
+/* header files for imported files */
+#include "oaidl.h"
+#include "ocidl.h"
+#include "dxgicommon.h"
+#include "d3d12.h"
+
+#ifdef __cplusplus
+extern "C"{
+#endif 
+
+
+/* interface __MIDL_itf_d3d12video_0000_0000 */
+/* [local] */ 
+
+#include <winapifamily.h>
+#pragma region App Family
+#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP | WINAPI_PARTITION_GAMES)
+typedef 
+enum D3D12_VIDEO_FIELD_TYPE
+    {
+        D3D12_VIDEO_FIELD_TYPE_NONE	= 0,
+        D3D12_VIDEO_FIELD_TYPE_INTERLACED_TOP_FIELD_FIRST	= 1,
+        D3D12_VIDEO_FIELD_TYPE_INTERLACED_BOTTOM_FIELD_FIRST	= 2
+    } 	D3D12_VIDEO_FIELD_TYPE;
+
+typedef 
+enum D3D12_VIDEO_FRAME_STEREO_FORMAT
+    {
+        D3D12_VIDEO_FRAME_STEREO_FORMAT_NONE	= 0,
+        D3D12_VIDEO_FRAME_STEREO_FORMAT_MONO	= 1,
+        D3D12_VIDEO_FRAME_STEREO_FORMAT_HORIZONTAL	= 2,
+        D3D12_VIDEO_FRAME_STEREO_FORMAT_VERTICAL	= 3,
+        D3D12_VIDEO_FRAME_STEREO_FORMAT_SEPARATE	= 4
+    } 	D3D12_VIDEO_FRAME_STEREO_FORMAT;
+
+typedef struct D3D12_VIDEO_FORMAT
+    {
+    DXGI_FORMAT Format;
+    DXGI_COLOR_SPACE_TYPE ColorSpace;
+    } 	D3D12_VIDEO_FORMAT;
+
+typedef struct D3D12_VIDEO_SAMPLE
+    {
+    UINT Width;
+    UINT Height;
+    D3D12_VIDEO_FORMAT Format;
+    } 	D3D12_VIDEO_SAMPLE;
+
+typedef 
+enum D3D12_VIDEO_FRAME_CODED_INTERLACE_TYPE
+    {
+        D3D12_VIDEO_FRAME_CODED_INTERLACE_TYPE_NONE	= 0,
+        D3D12_VIDEO_FRAME_CODED_INTERLACE_TYPE_FIELD_BASED	= 1
+    } 	D3D12_VIDEO_FRAME_CODED_INTERLACE_TYPE;
+
+typedef 
+enum D3D12_FEATURE_VIDEO
+    {
+        D3D12_FEATURE_VIDEO_DECODE_SUPPORT	= 0,
+        D3D12_FEATURE_VIDEO_DECODE_PROFILES	= 1,
+        D3D12_FEATURE_VIDEO_DECODE_FORMATS	= 2,
+        D3D12_FEATURE_VIDEO_DECODE_CONVERSION_SUPPORT	= 3,
+        D3D12_FEATURE_VIDEO_PROCESS_SUPPORT	= 5,
+        D3D12_FEATURE_VIDEO_PROCESS_MAX_INPUT_STREAMS	= 6,
+        D3D12_FEATURE_VIDEO_PROCESS_REFERENCE_INFO	= 7,
+        D3D12_FEATURE_VIDEO_DECODER_HEAP_SIZE	= 8,
+        D3D12_FEATURE_VIDEO_PROCESSOR_SIZE	= 9,
+        D3D12_FEATURE_VIDEO_DECODE_PROFILE_COUNT	= 10,
+        D3D12_FEATURE_VIDEO_DECODE_FORMAT_COUNT	= 11,
+        D3D12_FEATURE_VIDEO_ARCHITECTURE	= 17,
+        D3D12_FEATURE_VIDEO_DECODE_HISTOGRAM	= 18,
+        D3D12_FEATURE_VIDEO_FEATURE_AREA_SUPPORT	= 19,
+        D3D12_FEATURE_VIDEO_MOTION_ESTIMATOR	= 20,
+        D3D12_FEATURE_VIDEO_MOTION_ESTIMATOR_SIZE	= 21,
+        D3D12_FEATURE_VIDEO_EXTENSION_COMMAND_COUNT	= 22,
+        D3D12_FEATURE_VIDEO_EXTENSION_COMMANDS	= 23,
+        D3D12_FEATURE_VIDEO_EXTENSION_COMMAND_PARAMETER_COUNT	= 24,
+        D3D12_FEATURE_VIDEO_EXTENSION_COMMAND_PARAMETERS	= 25,
+        D3D12_FEATURE_VIDEO_EXTENSION_COMMAND_SUPPORT	= 26,
+        D3D12_FEATURE_VIDEO_EXTENSION_COMMAND_SIZE	= 27,
+        D3D12_FEATURE_VIDEO_DECODE_PROTECTED_RESOURCES	= 28,
+        D3D12_FEATURE_VIDEO_PROCESS_PROTECTED_RESOURCES	= 29,
+        D3D12_FEATURE_VIDEO_MOTION_ESTIMATOR_PROTECTED_RESOURCES	= 30,
+        D3D12_FEATURE_VIDEO_DECODER_HEAP_SIZE1	= 31,
+        D3D12_FEATURE_VIDEO_PROCESSOR_SIZE1	= 32,
+        D3D12_FEATURE_VIDEO_ENCODER_CODEC	= 33,
+        D3D12_FEATURE_VIDEO_ENCODER_PROFILE_LEVEL	= 34,
+        D3D12_FEATURE_VIDEO_ENCODER_OUTPUT_RESOLUTION_RATIOS_COUNT	= 35,
+        D3D12_FEATURE_VIDEO_ENCODER_OUTPUT_RESOLUTION	= 36,
+        D3D12_FEATURE_VIDEO_ENCODER_INPUT_FORMAT	= 37,
+        D3D12_FEATURE_VIDEO_ENCODER_RATE_CONTROL_MODE	= 38,
+        D3D12_FEATURE_VIDEO_ENCODER_INTRA_REFRESH_MODE	= 39,
+        D3D12_FEATURE_VIDEO_ENCODER_FRAME_SUBREGION_LAYOUT_MODE	= 40,
+        D3D12_FEATURE_VIDEO_ENCODER_HEAP_SIZE	= 41,
+        D3D12_FEATURE_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT	= 42,
+        D3D12_FEATURE_VIDEO_ENCODER_SUPPORT	= 43,
+        D3D12_FEATURE_VIDEO_ENCODER_CODEC_PICTURE_CONTROL_SUPPORT	= 44,
+        D3D12_FEATURE_VIDEO_ENCODER_RESOURCE_REQUIREMENTS	= 45
+    } 	D3D12_FEATURE_VIDEO;
+
+typedef 
+enum D3D12_BITSTREAM_ENCRYPTION_TYPE
+    {
+        D3D12_BITSTREAM_ENCRYPTION_TYPE_NONE	= 0
+    } 	D3D12_BITSTREAM_ENCRYPTION_TYPE;
+
+typedef struct D3D12_VIDEO_DECODE_CONFIGURATION
+    {
+    GUID DecodeProfile;
+    D3D12_BITSTREAM_ENCRYPTION_TYPE BitstreamEncryption;
+    D3D12_VIDEO_FRAME_CODED_INTERLACE_TYPE InterlaceType;
+    } 	D3D12_VIDEO_DECODE_CONFIGURATION;
+
+typedef struct D3D12_VIDEO_DECODER_DESC
+    {
+    UINT NodeMask;
+    D3D12_VIDEO_DECODE_CONFIGURATION Configuration;
+    } 	D3D12_VIDEO_DECODER_DESC;
+
+typedef struct D3D12_VIDEO_DECODER_HEAP_DESC
+    {
+    UINT NodeMask;
+    D3D12_VIDEO_DECODE_CONFIGURATION Configuration;
+    UINT DecodeWidth;
+    UINT DecodeHeight;
+    DXGI_FORMAT Format;
+    DXGI_RATIONAL FrameRate;
+    UINT BitRate;
+    UINT MaxDecodePictureBufferCount;
+    } 	D3D12_VIDEO_DECODER_HEAP_DESC;
+
+typedef struct D3D12_VIDEO_SIZE_RANGE
+    {
+    UINT MaxWidth;
+    UINT MaxHeight;
+    UINT MinWidth;
+    UINT MinHeight;
+    } 	D3D12_VIDEO_SIZE_RANGE;
+
+typedef 
+enum D3D12_VIDEO_PROCESS_FILTER
+    {
+        D3D12_VIDEO_PROCESS_FILTER_BRIGHTNESS	= 0,
+        D3D12_VIDEO_PROCESS_FILTER_CONTRAST	= 1,
+        D3D12_VIDEO_PROCESS_FILTER_HUE	= 2,
+        D3D12_VIDEO_PROCESS_FILTER_SATURATION	= 3,
+        D3D12_VIDEO_PROCESS_FILTER_NOISE_REDUCTION	= 4,
+        D3D12_VIDEO_PROCESS_FILTER_EDGE_ENHANCEMENT	= 5,
+        D3D12_VIDEO_PROCESS_FILTER_ANAMORPHIC_SCALING	= 6,
+        D3D12_VIDEO_PROCESS_FILTER_STEREO_ADJUSTMENT	= 7
+    } 	D3D12_VIDEO_PROCESS_FILTER;
+
+typedef 
+enum D3D12_VIDEO_PROCESS_FILTER_FLAGS
+    {
+        D3D12_VIDEO_PROCESS_FILTER_FLAG_NONE	= 0,
+        D3D12_VIDEO_PROCESS_FILTER_FLAG_BRIGHTNESS	= ( 1 << D3D12_VIDEO_PROCESS_FILTER_BRIGHTNESS ) ,
+        D3D12_VIDEO_PROCESS_FILTER_FLAG_CONTRAST	= ( 1 << D3D12_VIDEO_PROCESS_FILTER_CONTRAST ) ,
+        D3D12_VIDEO_PROCESS_FILTER_FLAG_HUE	= ( 1 << D3D12_VIDEO_PROCESS_FILTER_HUE ) ,
+        D3D12_VIDEO_PROCESS_FILTER_FLAG_SATURATION	= ( 1 << D3D12_VIDEO_PROCESS_FILTER_SATURATION ) ,
+        D3D12_VIDEO_PROCESS_FILTER_FLAG_NOISE_REDUCTION	= ( 1 << D3D12_VIDEO_PROCESS_FILTER_NOISE_REDUCTION ) ,
+        D3D12_VIDEO_PROCESS_FILTER_FLAG_EDGE_ENHANCEMENT	= ( 1 << D3D12_VIDEO_PROCESS_FILTER_EDGE_ENHANCEMENT ) ,
+        D3D12_VIDEO_PROCESS_FILTER_FLAG_ANAMORPHIC_SCALING	= ( 1 << D3D12_VIDEO_PROCESS_FILTER_ANAMORPHIC_SCALING ) ,
+        D3D12_VIDEO_PROCESS_FILTER_FLAG_STEREO_ADJUSTMENT	= ( 1 << D3D12_VIDEO_PROCESS_FILTER_STEREO_ADJUSTMENT ) 
+    } 	D3D12_VIDEO_PROCESS_FILTER_FLAGS;
+
+DEFINE_ENUM_FLAG_OPERATORS(D3D12_VIDEO_PROCESS_FILTER_FLAGS );
+typedef 
+enum D3D12_VIDEO_PROCESS_DEINTERLACE_FLAGS
+    {
+        D3D12_VIDEO_PROCESS_DEINTERLACE_FLAG_NONE	= 0,
+        D3D12_VIDEO_PROCESS_DEINTERLACE_FLAG_BOB	= 0x1,
+        D3D12_VIDEO_PROCESS_DEINTERLACE_FLAG_CUSTOM	= 0x80000000
+    } 	D3D12_VIDEO_PROCESS_DEINTERLACE_FLAGS;
+
+DEFINE_ENUM_FLAG_OPERATORS(D3D12_VIDEO_PROCESS_DEINTERLACE_FLAGS );
+typedef struct D3D12_VIDEO_PROCESS_ALPHA_BLENDING
+    {
+    BOOL Enable;
+    FLOAT Alpha;
+    } 	D3D12_VIDEO_PROCESS_ALPHA_BLENDING;
+
+typedef struct D3D12_VIDEO_PROCESS_LUMA_KEY
+    {
+    BOOL Enable;
+    FLOAT Lower;
+    FLOAT Upper;
+    } 	D3D12_VIDEO_PROCESS_LUMA_KEY;
+
+typedef struct D3D12_VIDEO_PROCESS_INPUT_STREAM_DESC
+    {
+    DXGI_FORMAT Format;
+    DXGI_COLOR_SPACE_TYPE ColorSpace;
+    DXGI_RATIONAL SourceAspectRatio;
+    DXGI_RATIONAL DestinationAspectRatio;
+    DXGI_RATIONAL FrameRate;
+    D3D12_VIDEO_SIZE_RANGE SourceSizeRange;
+    D3D12_VIDEO_SIZE_RANGE DestinationSizeRange;
+    BOOL EnableOrientation;
+    D3D12_VIDEO_PROCESS_FILTER_FLAGS FilterFlags;
+    D3D12_VIDEO_FRAME_STEREO_FORMAT StereoFormat;
+    D3D12_VIDEO_FIELD_TYPE FieldType;
+    D3D12_VIDEO_PROCESS_DEINTERLACE_FLAGS DeinterlaceMode;
+    BOOL EnableAlphaBlending;
+    D3D12_VIDEO_PROCESS_LUMA_KEY LumaKey;
+    UINT NumPastFrames;
+    UINT NumFutureFrames;
+    BOOL EnableAutoProcessing;
+    } 	D3D12_VIDEO_PROCESS_INPUT_STREAM_DESC;
+
+typedef 
+enum D3D12_VIDEO_PROCESS_ALPHA_FILL_MODE
+    {
+        D3D12_VIDEO_PROCESS_ALPHA_FILL_MODE_OPAQUE	= 0,
+        D3D12_VIDEO_PROCESS_ALPHA_FILL_MODE_BACKGROUND	= 1,
+        D3D12_VIDEO_PROCESS_ALPHA_FILL_MODE_DESTINATION	= 2,
+        D3D12_VIDEO_PROCESS_ALPHA_FILL_MODE_SOURCE_STREAM	= 3
+    } 	D3D12_VIDEO_PROCESS_ALPHA_FILL_MODE;
+
+typedef struct D3D12_VIDEO_PROCESS_OUTPUT_STREAM_DESC
+    {
+    DXGI_FORMAT Format;
+    DXGI_COLOR_SPACE_TYPE ColorSpace;
+    D3D12_VIDEO_PROCESS_ALPHA_FILL_MODE AlphaFillMode;
+    UINT AlphaFillModeSourceStreamIndex;
+    FLOAT BackgroundColor[ 4 ];
+    DXGI_RATIONAL FrameRate;
+    BOOL EnableStereo;
+    } 	D3D12_VIDEO_PROCESS_OUTPUT_STREAM_DESC;
+
+
+
+extern RPC_IF_HANDLE __MIDL_itf_d3d12video_0000_0000_v0_0_c_ifspec;
+extern RPC_IF_HANDLE __MIDL_itf_d3d12video_0000_0000_v0_0_s_ifspec;
+
+#ifndef __ID3D12VideoDecoderHeap_INTERFACE_DEFINED__
+#define __ID3D12VideoDecoderHeap_INTERFACE_DEFINED__
+
+/* interface ID3D12VideoDecoderHeap */
+/* [unique][local][object][uuid] */ 
+
+
+EXTERN_C const IID IID_ID3D12VideoDecoderHeap;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("0946B7C9-EBF6-4047-BB73-8683E27DBB1F")
+    ID3D12VideoDecoderHeap : public ID3D12Pageable
+    {
+    public:
+#if defined(_MSC_VER) || !defined(_WIN32)
+        virtual D3D12_VIDEO_DECODER_HEAP_DESC STDMETHODCALLTYPE GetDesc( void) = 0;
+#else
+        virtual D3D12_VIDEO_DECODER_HEAP_DESC *STDMETHODCALLTYPE GetDesc( 
+            D3D12_VIDEO_DECODER_HEAP_DESC * RetVal) = 0;
+#endif
+        
+    };
+    
+    
+#else 	/* C style interface */
+
+    typedef struct ID3D12VideoDecoderHeapVtbl
+    {
+        BEGIN_INTERFACE
+        
+        DECLSPEC_XFGVIRT(IUnknown, QueryInterface)
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            ID3D12VideoDecoderHeap * This,
+            REFIID riid,
+            _COM_Outptr_  void **ppvObject);
+        
+        DECLSPEC_XFGVIRT(IUnknown, AddRef)
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            ID3D12VideoDecoderHeap * This);
+        
+        DECLSPEC_XFGVIRT(IUnknown, Release)
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            ID3D12VideoDecoderHeap * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, GetPrivateData)
+        HRESULT ( STDMETHODCALLTYPE *GetPrivateData )( 
+            ID3D12VideoDecoderHeap * This,
+            _In_  REFGUID guid,
+            _Inout_  UINT *pDataSize,
+            _Out_writes_bytes_opt_( *pDataSize )  void *pData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, SetPrivateData)
+        HRESULT ( STDMETHODCALLTYPE *SetPrivateData )( 
+            ID3D12VideoDecoderHeap * This,
+            _In_  REFGUID guid,
+            _In_  UINT DataSize,
+            _In_reads_bytes_opt_( DataSize )  const void *pData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, SetPrivateDataInterface)
+        HRESULT ( STDMETHODCALLTYPE *SetPrivateDataInterface )( 
+            ID3D12VideoDecoderHeap * This,
+            _In_  REFGUID guid,
+            _In_opt_  const IUnknown *pData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, SetName)
+        HRESULT ( STDMETHODCALLTYPE *SetName )( 
+            ID3D12VideoDecoderHeap * This,
+            _In_z_  LPCWSTR Name);
+        
+        DECLSPEC_XFGVIRT(ID3D12DeviceChild, GetDevice)
+        HRESULT ( STDMETHODCALLTYPE *GetDevice )( 
+            ID3D12VideoDecoderHeap * This,
+            REFIID riid,
+            _COM_Outptr_opt_  void **ppvDevice);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoDecoderHeap, GetDesc)
+#if !defined(_WIN32)
+        D3D12_VIDEO_DECODER_HEAP_DESC ( STDMETHODCALLTYPE *GetDesc )( 
+            ID3D12VideoDecoderHeap * This);
+        
+#else
+        D3D12_VIDEO_DECODER_HEAP_DESC *( STDMETHODCALLTYPE *GetDesc )( 
+            ID3D12VideoDecoderHeap * This,
+            D3D12_VIDEO_DECODER_HEAP_DESC * RetVal);
+        
+#endif
+        
+        END_INTERFACE
+    } ID3D12VideoDecoderHeapVtbl;
+
+    interface ID3D12VideoDecoderHeap
+    {
+        CONST_VTBL struct ID3D12VideoDecoderHeapVtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define ID3D12VideoDecoderHeap_QueryInterface(This,riid,ppvObject)	\
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define ID3D12VideoDecoderHeap_AddRef(This)	\
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define ID3D12VideoDecoderHeap_Release(This)	\
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#define ID3D12VideoDecoderHeap_GetPrivateData(This,guid,pDataSize,pData)	\
+    ( (This)->lpVtbl -> GetPrivateData(This,guid,pDataSize,pData) ) 
+
+#define ID3D12VideoDecoderHeap_SetPrivateData(This,guid,DataSize,pData)	\
+    ( (This)->lpVtbl -> SetPrivateData(This,guid,DataSize,pData) ) 
+
+#define ID3D12VideoDecoderHeap_SetPrivateDataInterface(This,guid,pData)	\
+    ( (This)->lpVtbl -> SetPrivateDataInterface(This,guid,pData) ) 
+
+#define ID3D12VideoDecoderHeap_SetName(This,Name)	\
+    ( (This)->lpVtbl -> SetName(This,Name) ) 
+
+
+#define ID3D12VideoDecoderHeap_GetDevice(This,riid,ppvDevice)	\
+    ( (This)->lpVtbl -> GetDevice(This,riid,ppvDevice) ) 
+
+
+#if !defined(_WIN32)
+
+#define ID3D12VideoDecoderHeap_GetDesc(This)	\
+    ( (This)->lpVtbl -> GetDesc(This) ) 
+#else
+#define ID3D12VideoDecoderHeap_GetDesc(This,RetVal)	\
+    ( (This)->lpVtbl -> GetDesc(This,RetVal) ) 
+#endif
+
+#endif /* COBJMACROS */
+
+
+#endif 	/* C style interface */
+
+
+
+
+#endif 	/* __ID3D12VideoDecoderHeap_INTERFACE_DEFINED__ */
+
+
+#ifndef __ID3D12VideoDevice_INTERFACE_DEFINED__
+#define __ID3D12VideoDevice_INTERFACE_DEFINED__
+
+/* interface ID3D12VideoDevice */
+/* [unique][local][object][uuid] */ 
+
+
+EXTERN_C const IID IID_ID3D12VideoDevice;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("1F052807-0B46-4ACC-8A89-364F793718A4")
+    ID3D12VideoDevice : public IUnknown
+    {
+    public:
+        virtual HRESULT STDMETHODCALLTYPE CheckFeatureSupport( 
+            D3D12_FEATURE_VIDEO FeatureVideo,
+            _Inout_updates_bytes_(FeatureSupportDataSize)  void *pFeatureSupportData,
+            UINT FeatureSupportDataSize) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE CreateVideoDecoder( 
+            _In_  const D3D12_VIDEO_DECODER_DESC *pDesc,
+            _In_  REFIID riid,
+            _COM_Outptr_  void **ppVideoDecoder) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE CreateVideoDecoderHeap( 
+            _In_  const D3D12_VIDEO_DECODER_HEAP_DESC *pVideoDecoderHeapDesc,
+            _In_  REFIID riid,
+            _COM_Outptr_  void **ppVideoDecoderHeap) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE CreateVideoProcessor( 
+            UINT NodeMask,
+            _In_  const D3D12_VIDEO_PROCESS_OUTPUT_STREAM_DESC *pOutputStreamDesc,
+            UINT NumInputStreamDescs,
+            _In_reads_(NumInputStreamDescs)  const D3D12_VIDEO_PROCESS_INPUT_STREAM_DESC *pInputStreamDescs,
+            _In_  REFIID riid,
+            _COM_Outptr_  void **ppVideoProcessor) = 0;
+        
+    };
+    
+    
+#else 	/* C style interface */
+
+    typedef struct ID3D12VideoDeviceVtbl
+    {
+        BEGIN_INTERFACE
+        
+        DECLSPEC_XFGVIRT(IUnknown, QueryInterface)
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            ID3D12VideoDevice * This,
+            REFIID riid,
+            _COM_Outptr_  void **ppvObject);
+        
+        DECLSPEC_XFGVIRT(IUnknown, AddRef)
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            ID3D12VideoDevice * This);
+        
+        DECLSPEC_XFGVIRT(IUnknown, Release)
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            ID3D12VideoDevice * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoDevice, CheckFeatureSupport)
+        HRESULT ( STDMETHODCALLTYPE *CheckFeatureSupport )( 
+            ID3D12VideoDevice * This,
+            D3D12_FEATURE_VIDEO FeatureVideo,
+            _Inout_updates_bytes_(FeatureSupportDataSize)  void *pFeatureSupportData,
+            UINT FeatureSupportDataSize);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoDevice, CreateVideoDecoder)
+        HRESULT ( STDMETHODCALLTYPE *CreateVideoDecoder )( 
+            ID3D12VideoDevice * This,
+            _In_  const D3D12_VIDEO_DECODER_DESC *pDesc,
+            _In_  REFIID riid,
+            _COM_Outptr_  void **ppVideoDecoder);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoDevice, CreateVideoDecoderHeap)
+        HRESULT ( STDMETHODCALLTYPE *CreateVideoDecoderHeap )( 
+            ID3D12VideoDevice * This,
+            _In_  const D3D12_VIDEO_DECODER_HEAP_DESC *pVideoDecoderHeapDesc,
+            _In_  REFIID riid,
+            _COM_Outptr_  void **ppVideoDecoderHeap);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoDevice, CreateVideoProcessor)
+        HRESULT ( STDMETHODCALLTYPE *CreateVideoProcessor )( 
+            ID3D12VideoDevice * This,
+            UINT NodeMask,
+            _In_  const D3D12_VIDEO_PROCESS_OUTPUT_STREAM_DESC *pOutputStreamDesc,
+            UINT NumInputStreamDescs,
+            _In_reads_(NumInputStreamDescs)  const D3D12_VIDEO_PROCESS_INPUT_STREAM_DESC *pInputStreamDescs,
+            _In_  REFIID riid,
+            _COM_Outptr_  void **ppVideoProcessor);
+        
+        END_INTERFACE
+    } ID3D12VideoDeviceVtbl;
+
+    interface ID3D12VideoDevice
+    {
+        CONST_VTBL struct ID3D12VideoDeviceVtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define ID3D12VideoDevice_QueryInterface(This,riid,ppvObject)	\
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define ID3D12VideoDevice_AddRef(This)	\
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define ID3D12VideoDevice_Release(This)	\
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#define ID3D12VideoDevice_CheckFeatureSupport(This,FeatureVideo,pFeatureSupportData,FeatureSupportDataSize)	\
+    ( (This)->lpVtbl -> CheckFeatureSupport(This,FeatureVideo,pFeatureSupportData,FeatureSupportDataSize) ) 
+
+#define ID3D12VideoDevice_CreateVideoDecoder(This,pDesc,riid,ppVideoDecoder)	\
+    ( (This)->lpVtbl -> CreateVideoDecoder(This,pDesc,riid,ppVideoDecoder) ) 
+
+#define ID3D12VideoDevice_CreateVideoDecoderHeap(This,pVideoDecoderHeapDesc,riid,ppVideoDecoderHeap)	\
+    ( (This)->lpVtbl -> CreateVideoDecoderHeap(This,pVideoDecoderHeapDesc,riid,ppVideoDecoderHeap) ) 
+
+#define ID3D12VideoDevice_CreateVideoProcessor(This,NodeMask,pOutputStreamDesc,NumInputStreamDescs,pInputStreamDescs,riid,ppVideoProcessor)	\
+    ( (This)->lpVtbl -> CreateVideoProcessor(This,NodeMask,pOutputStreamDesc,NumInputStreamDescs,pInputStreamDescs,riid,ppVideoProcessor) ) 
+
+#endif /* COBJMACROS */
+
+
+#endif 	/* C style interface */
+
+
+
+
+#endif 	/* __ID3D12VideoDevice_INTERFACE_DEFINED__ */
+
+
+#ifndef __ID3D12VideoDecoder_INTERFACE_DEFINED__
+#define __ID3D12VideoDecoder_INTERFACE_DEFINED__
+
+/* interface ID3D12VideoDecoder */
+/* [unique][local][object][uuid] */ 
+
+
+EXTERN_C const IID IID_ID3D12VideoDecoder;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("C59B6BDC-7720-4074-A136-17A156037470")
+    ID3D12VideoDecoder : public ID3D12Pageable
+    {
+    public:
+#if defined(_MSC_VER) || !defined(_WIN32)
+        virtual D3D12_VIDEO_DECODER_DESC STDMETHODCALLTYPE GetDesc( void) = 0;
+#else
+        virtual D3D12_VIDEO_DECODER_DESC *STDMETHODCALLTYPE GetDesc( 
+            D3D12_VIDEO_DECODER_DESC * RetVal) = 0;
+#endif
+        
+    };
+    
+    
+#else 	/* C style interface */
+
+    typedef struct ID3D12VideoDecoderVtbl
+    {
+        BEGIN_INTERFACE
+        
+        DECLSPEC_XFGVIRT(IUnknown, QueryInterface)
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            ID3D12VideoDecoder * This,
+            REFIID riid,
+            _COM_Outptr_  void **ppvObject);
+        
+        DECLSPEC_XFGVIRT(IUnknown, AddRef)
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            ID3D12VideoDecoder * This);
+        
+        DECLSPEC_XFGVIRT(IUnknown, Release)
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            ID3D12VideoDecoder * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, GetPrivateData)
+        HRESULT ( STDMETHODCALLTYPE *GetPrivateData )( 
+            ID3D12VideoDecoder * This,
+            _In_  REFGUID guid,
+            _Inout_  UINT *pDataSize,
+            _Out_writes_bytes_opt_( *pDataSize )  void *pData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, SetPrivateData)
+        HRESULT ( STDMETHODCALLTYPE *SetPrivateData )( 
+            ID3D12VideoDecoder * This,
+            _In_  REFGUID guid,
+            _In_  UINT DataSize,
+            _In_reads_bytes_opt_( DataSize )  const void *pData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, SetPrivateDataInterface)
+        HRESULT ( STDMETHODCALLTYPE *SetPrivateDataInterface )( 
+            ID3D12VideoDecoder * This,
+            _In_  REFGUID guid,
+            _In_opt_  const IUnknown *pData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, SetName)
+        HRESULT ( STDMETHODCALLTYPE *SetName )( 
+            ID3D12VideoDecoder * This,
+            _In_z_  LPCWSTR Name);
+        
+        DECLSPEC_XFGVIRT(ID3D12DeviceChild, GetDevice)
+        HRESULT ( STDMETHODCALLTYPE *GetDevice )( 
+            ID3D12VideoDecoder * This,
+            REFIID riid,
+            _COM_Outptr_opt_  void **ppvDevice);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoDecoder, GetDesc)
+#if !defined(_WIN32)
+        D3D12_VIDEO_DECODER_DESC ( STDMETHODCALLTYPE *GetDesc )( 
+            ID3D12VideoDecoder * This);
+        
+#else
+        D3D12_VIDEO_DECODER_DESC *( STDMETHODCALLTYPE *GetDesc )( 
+            ID3D12VideoDecoder * This,
+            D3D12_VIDEO_DECODER_DESC * RetVal);
+        
+#endif
+        
+        END_INTERFACE
+    } ID3D12VideoDecoderVtbl;
+
+    interface ID3D12VideoDecoder
+    {
+        CONST_VTBL struct ID3D12VideoDecoderVtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define ID3D12VideoDecoder_QueryInterface(This,riid,ppvObject)	\
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define ID3D12VideoDecoder_AddRef(This)	\
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define ID3D12VideoDecoder_Release(This)	\
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#define ID3D12VideoDecoder_GetPrivateData(This,guid,pDataSize,pData)	\
+    ( (This)->lpVtbl -> GetPrivateData(This,guid,pDataSize,pData) ) 
+
+#define ID3D12VideoDecoder_SetPrivateData(This,guid,DataSize,pData)	\
+    ( (This)->lpVtbl -> SetPrivateData(This,guid,DataSize,pData) ) 
+
+#define ID3D12VideoDecoder_SetPrivateDataInterface(This,guid,pData)	\
+    ( (This)->lpVtbl -> SetPrivateDataInterface(This,guid,pData) ) 
+
+#define ID3D12VideoDecoder_SetName(This,Name)	\
+    ( (This)->lpVtbl -> SetName(This,Name) ) 
+
+
+#define ID3D12VideoDecoder_GetDevice(This,riid,ppvDevice)	\
+    ( (This)->lpVtbl -> GetDevice(This,riid,ppvDevice) ) 
+
+
+#if !defined(_WIN32)
+
+#define ID3D12VideoDecoder_GetDesc(This)	\
+    ( (This)->lpVtbl -> GetDesc(This) ) 
+#else
+#define ID3D12VideoDecoder_GetDesc(This,RetVal)	\
+    ( (This)->lpVtbl -> GetDesc(This,RetVal) ) 
+#endif
+
+#endif /* COBJMACROS */
+
+
+#endif 	/* C style interface */
+
+
+
+
+#endif 	/* __ID3D12VideoDecoder_INTERFACE_DEFINED__ */
+
+
+/* interface __MIDL_itf_d3d12video_0000_0003 */
+/* [local] */ 
+
+typedef 
+enum D3D12_VIDEO_DECODE_TIER
+    {
+        D3D12_VIDEO_DECODE_TIER_NOT_SUPPORTED	= 0,
+        D3D12_VIDEO_DECODE_TIER_1	= 1,
+        D3D12_VIDEO_DECODE_TIER_2	= 2,
+        D3D12_VIDEO_DECODE_TIER_3	= 3
+    } 	D3D12_VIDEO_DECODE_TIER;
+
+typedef 
+enum D3D12_VIDEO_DECODE_SUPPORT_FLAGS
+    {
+        D3D12_VIDEO_DECODE_SUPPORT_FLAG_NONE	= 0,
+        D3D12_VIDEO_DECODE_SUPPORT_FLAG_SUPPORTED	= 0x1
+    } 	D3D12_VIDEO_DECODE_SUPPORT_FLAGS;
+
+DEFINE_ENUM_FLAG_OPERATORS(D3D12_VIDEO_DECODE_SUPPORT_FLAGS );
+typedef 
+enum D3D12_VIDEO_DECODE_CONFIGURATION_FLAGS
+    {
+        D3D12_VIDEO_DECODE_CONFIGURATION_FLAG_NONE	= 0,
+        D3D12_VIDEO_DECODE_CONFIGURATION_FLAG_HEIGHT_ALIGNMENT_MULTIPLE_32_REQUIRED	= 0x1,
+        D3D12_VIDEO_DECODE_CONFIGURATION_FLAG_POST_PROCESSING_SUPPORTED	= 0x2,
+        D3D12_VIDEO_DECODE_CONFIGURATION_FLAG_REFERENCE_ONLY_ALLOCATIONS_REQUIRED	= 0x4,
+        D3D12_VIDEO_DECODE_CONFIGURATION_FLAG_ALLOW_RESOLUTION_CHANGE_ON_NON_KEY_FRAME	= 0x8
+    } 	D3D12_VIDEO_DECODE_CONFIGURATION_FLAGS;
+
+DEFINE_ENUM_FLAG_OPERATORS(D3D12_VIDEO_DECODE_CONFIGURATION_FLAGS );
+typedef 
+enum D3D12_VIDEO_DECODE_STATUS
+    {
+        D3D12_VIDEO_DECODE_STATUS_OK	= 0,
+        D3D12_VIDEO_DECODE_STATUS_CONTINUE	= 1,
+        D3D12_VIDEO_DECODE_STATUS_CONTINUE_SKIP_DISPLAY	= 2,
+        D3D12_VIDEO_DECODE_STATUS_RESTART	= 3,
+        D3D12_VIDEO_DECODE_STATUS_RATE_EXCEEDED	= 4
+    } 	D3D12_VIDEO_DECODE_STATUS;
+
+typedef 
+enum D3D12_VIDEO_DECODE_ARGUMENT_TYPE
+    {
+        D3D12_VIDEO_DECODE_ARGUMENT_TYPE_PICTURE_PARAMETERS	= 0,
+        D3D12_VIDEO_DECODE_ARGUMENT_TYPE_INVERSE_QUANTIZATION_MATRIX	= 1,
+        D3D12_VIDEO_DECODE_ARGUMENT_TYPE_SLICE_CONTROL	= 2,
+        D3D12_VIDEO_DECODE_ARGUMENT_TYPE_MAX_VALID	= 3
+    } 	D3D12_VIDEO_DECODE_ARGUMENT_TYPE;
+
+typedef struct D3D12_FEATURE_DATA_VIDEO_DECODE_SUPPORT
+    {
+    UINT NodeIndex;
+    D3D12_VIDEO_DECODE_CONFIGURATION Configuration;
+    UINT Width;
+    UINT Height;
+    DXGI_FORMAT DecodeFormat;
+    DXGI_RATIONAL FrameRate;
+    UINT BitRate;
+    D3D12_VIDEO_DECODE_SUPPORT_FLAGS SupportFlags;
+    D3D12_VIDEO_DECODE_CONFIGURATION_FLAGS ConfigurationFlags;
+    D3D12_VIDEO_DECODE_TIER DecodeTier;
+    } 	D3D12_FEATURE_DATA_VIDEO_DECODE_SUPPORT;
+
+typedef struct D3D12_FEATURE_DATA_VIDEO_DECODE_PROFILE_COUNT
+    {
+    UINT NodeIndex;
+    UINT ProfileCount;
+    } 	D3D12_FEATURE_DATA_VIDEO_DECODE_PROFILE_COUNT;
+
+typedef struct D3D12_FEATURE_DATA_VIDEO_DECODE_PROFILES
+    {
+    UINT NodeIndex;
+    UINT ProfileCount;
+    _Field_size_full_(ProfileCount)  GUID *pProfiles;
+    } 	D3D12_FEATURE_DATA_VIDEO_DECODE_PROFILES;
+
+typedef struct D3D12_FEATURE_DATA_VIDEO_DECODE_FORMAT_COUNT
+    {
+    UINT NodeIndex;
+    D3D12_VIDEO_DECODE_CONFIGURATION Configuration;
+    UINT FormatCount;
+    } 	D3D12_FEATURE_DATA_VIDEO_DECODE_FORMAT_COUNT;
+
+typedef struct D3D12_FEATURE_DATA_VIDEO_DECODE_FORMATS
+    {
+    UINT NodeIndex;
+    D3D12_VIDEO_DECODE_CONFIGURATION Configuration;
+    UINT FormatCount;
+    _Field_size_full_(FormatCount)  DXGI_FORMAT *pOutputFormats;
+    } 	D3D12_FEATURE_DATA_VIDEO_DECODE_FORMATS;
+
+typedef struct D3D12_FEATURE_DATA_VIDEO_ARCHITECTURE
+    {
+    BOOL IOCoherent;
+    } 	D3D12_FEATURE_DATA_VIDEO_ARCHITECTURE;
+
+typedef 
+enum D3D12_VIDEO_DECODE_HISTOGRAM_COMPONENT
+    {
+        D3D12_VIDEO_DECODE_HISTOGRAM_COMPONENT_Y	= 0,
+        D3D12_VIDEO_DECODE_HISTOGRAM_COMPONENT_U	= 1,
+        D3D12_VIDEO_DECODE_HISTOGRAM_COMPONENT_V	= 2,
+        D3D12_VIDEO_DECODE_HISTOGRAM_COMPONENT_R	= 0,
+        D3D12_VIDEO_DECODE_HISTOGRAM_COMPONENT_G	= 1,
+        D3D12_VIDEO_DECODE_HISTOGRAM_COMPONENT_B	= 2,
+        D3D12_VIDEO_DECODE_HISTOGRAM_COMPONENT_A	= 3
+    } 	D3D12_VIDEO_DECODE_HISTOGRAM_COMPONENT;
+
+typedef 
+enum D3D12_VIDEO_DECODE_HISTOGRAM_COMPONENT_FLAGS
+    {
+        D3D12_VIDEO_DECODE_HISTOGRAM_COMPONENT_FLAG_NONE	= 0,
+        D3D12_VIDEO_DECODE_HISTOGRAM_COMPONENT_FLAG_Y	= ( 1 << D3D12_VIDEO_DECODE_HISTOGRAM_COMPONENT_Y ) ,
+        D3D12_VIDEO_DECODE_HISTOGRAM_COMPONENT_FLAG_U	= ( 1 << D3D12_VIDEO_DECODE_HISTOGRAM_COMPONENT_U ) ,
+        D3D12_VIDEO_DECODE_HISTOGRAM_COMPONENT_FLAG_V	= ( 1 << D3D12_VIDEO_DECODE_HISTOGRAM_COMPONENT_V ) ,
+        D3D12_VIDEO_DECODE_HISTOGRAM_COMPONENT_FLAG_R	= ( 1 << D3D12_VIDEO_DECODE_HISTOGRAM_COMPONENT_R ) ,
+        D3D12_VIDEO_DECODE_HISTOGRAM_COMPONENT_FLAG_G	= ( 1 << D3D12_VIDEO_DECODE_HISTOGRAM_COMPONENT_G ) ,
+        D3D12_VIDEO_DECODE_HISTOGRAM_COMPONENT_FLAG_B	= ( 1 << D3D12_VIDEO_DECODE_HISTOGRAM_COMPONENT_B ) ,
+        D3D12_VIDEO_DECODE_HISTOGRAM_COMPONENT_FLAG_A	= ( 1 << D3D12_VIDEO_DECODE_HISTOGRAM_COMPONENT_A ) 
+    } 	D3D12_VIDEO_DECODE_HISTOGRAM_COMPONENT_FLAGS;
+
+DEFINE_ENUM_FLAG_OPERATORS(D3D12_VIDEO_DECODE_HISTOGRAM_COMPONENT_FLAGS );
+typedef struct D3D12_FEATURE_DATA_VIDEO_DECODE_HISTOGRAM
+    {
+    UINT NodeIndex;
+    GUID DecodeProfile;
+    UINT Width;
+    UINT Height;
+    DXGI_FORMAT DecodeFormat;
+    D3D12_VIDEO_DECODE_HISTOGRAM_COMPONENT_FLAGS Components;
+    UINT BinCount;
+    UINT CounterBitDepth;
+    } 	D3D12_FEATURE_DATA_VIDEO_DECODE_HISTOGRAM;
+
+typedef 
+enum D3D12_VIDEO_DECODE_CONVERSION_SUPPORT_FLAGS
+    {
+        D3D12_VIDEO_DECODE_CONVERSION_SUPPORT_FLAG_NONE	= 0,
+        D3D12_VIDEO_DECODE_CONVERSION_SUPPORT_FLAG_SUPPORTED	= 0x1
+    } 	D3D12_VIDEO_DECODE_CONVERSION_SUPPORT_FLAGS;
+
+DEFINE_ENUM_FLAG_OPERATORS(D3D12_VIDEO_DECODE_CONVERSION_SUPPORT_FLAGS );
+typedef 
+enum D3D12_VIDEO_SCALE_SUPPORT_FLAGS
+    {
+        D3D12_VIDEO_SCALE_SUPPORT_FLAG_NONE	= 0,
+        D3D12_VIDEO_SCALE_SUPPORT_FLAG_POW2_ONLY	= 0x1,
+        D3D12_VIDEO_SCALE_SUPPORT_FLAG_EVEN_DIMENSIONS_ONLY	= 0x2
+    } 	D3D12_VIDEO_SCALE_SUPPORT_FLAGS;
+
+DEFINE_ENUM_FLAG_OPERATORS(D3D12_VIDEO_SCALE_SUPPORT_FLAGS );
+typedef struct D3D12_VIDEO_SCALE_SUPPORT
+    {
+    D3D12_VIDEO_SIZE_RANGE OutputSizeRange;
+    D3D12_VIDEO_SCALE_SUPPORT_FLAGS Flags;
+    } 	D3D12_VIDEO_SCALE_SUPPORT;
+
+typedef struct D3D12_FEATURE_DATA_VIDEO_DECODE_CONVERSION_SUPPORT
+    {
+    UINT NodeIndex;
+    D3D12_VIDEO_DECODE_CONFIGURATION Configuration;
+    D3D12_VIDEO_SAMPLE DecodeSample;
+    D3D12_VIDEO_FORMAT OutputFormat;
+    DXGI_RATIONAL FrameRate;
+    UINT BitRate;
+    D3D12_VIDEO_DECODE_CONVERSION_SUPPORT_FLAGS SupportFlags;
+    D3D12_VIDEO_SCALE_SUPPORT ScaleSupport;
+    } 	D3D12_FEATURE_DATA_VIDEO_DECODE_CONVERSION_SUPPORT;
+
+typedef struct D3D12_FEATURE_DATA_VIDEO_DECODER_HEAP_SIZE
+    {
+    D3D12_VIDEO_DECODER_HEAP_DESC VideoDecoderHeapDesc;
+    UINT64 MemoryPoolL0Size;
+    UINT64 MemoryPoolL1Size;
+    } 	D3D12_FEATURE_DATA_VIDEO_DECODER_HEAP_SIZE;
+
+typedef struct D3D12_FEATURE_DATA_VIDEO_PROCESSOR_SIZE
+    {
+    UINT NodeMask;
+    const D3D12_VIDEO_PROCESS_OUTPUT_STREAM_DESC *pOutputStreamDesc;
+    UINT NumInputStreamDescs;
+    const D3D12_VIDEO_PROCESS_INPUT_STREAM_DESC *pInputStreamDescs;
+    UINT64 MemoryPoolL0Size;
+    UINT64 MemoryPoolL1Size;
+    } 	D3D12_FEATURE_DATA_VIDEO_PROCESSOR_SIZE;
+
+typedef struct D3D12_QUERY_DATA_VIDEO_DECODE_STATISTICS
+    {
+    UINT64 Status;
+    UINT64 NumMacroblocksAffected;
+    DXGI_RATIONAL FrameRate;
+    UINT BitRate;
+    } 	D3D12_QUERY_DATA_VIDEO_DECODE_STATISTICS;
+
+typedef struct D3D12_VIDEO_DECODE_FRAME_ARGUMENT
+    {
+    D3D12_VIDEO_DECODE_ARGUMENT_TYPE Type;
+    UINT Size;
+    _Field_size_bytes_full_(Size)  void *pData;
+    } 	D3D12_VIDEO_DECODE_FRAME_ARGUMENT;
+
+typedef struct D3D12_VIDEO_DECODE_REFERENCE_FRAMES
+    {
+    UINT NumTexture2Ds;
+    _Field_size_full_(NumTexture2Ds)  ID3D12Resource **ppTexture2Ds;
+    _Field_size_full_(NumTexture2Ds)  UINT *pSubresources;
+    _Field_size_full_opt_(NumTexture2Ds)  ID3D12VideoDecoderHeap **ppHeaps;
+    } 	D3D12_VIDEO_DECODE_REFERENCE_FRAMES;
+
+typedef struct D3D12_VIDEO_DECODE_COMPRESSED_BITSTREAM
+    {
+    ID3D12Resource *pBuffer;
+    UINT64 Offset;
+    UINT64 Size;
+    } 	D3D12_VIDEO_DECODE_COMPRESSED_BITSTREAM;
+
+typedef struct D3D12_VIDEO_DECODE_CONVERSION_ARGUMENTS
+    {
+    BOOL Enable;
+    ID3D12Resource *pReferenceTexture2D;
+    UINT ReferenceSubresource;
+    DXGI_COLOR_SPACE_TYPE OutputColorSpace;
+    DXGI_COLOR_SPACE_TYPE DecodeColorSpace;
+    } 	D3D12_VIDEO_DECODE_CONVERSION_ARGUMENTS;
+
+typedef struct D3D12_VIDEO_DECODE_INPUT_STREAM_ARGUMENTS
+    {
+    UINT NumFrameArguments;
+    D3D12_VIDEO_DECODE_FRAME_ARGUMENT FrameArguments[ 10 ];
+    D3D12_VIDEO_DECODE_REFERENCE_FRAMES ReferenceFrames;
+    D3D12_VIDEO_DECODE_COMPRESSED_BITSTREAM CompressedBitstream;
+    ID3D12VideoDecoderHeap *pHeap;
+    } 	D3D12_VIDEO_DECODE_INPUT_STREAM_ARGUMENTS;
+
+typedef struct D3D12_VIDEO_DECODE_OUTPUT_STREAM_ARGUMENTS
+    {
+    ID3D12Resource *pOutputTexture2D;
+    UINT OutputSubresource;
+    D3D12_VIDEO_DECODE_CONVERSION_ARGUMENTS ConversionArguments;
+    } 	D3D12_VIDEO_DECODE_OUTPUT_STREAM_ARGUMENTS;
+
+
+
+extern RPC_IF_HANDLE __MIDL_itf_d3d12video_0000_0003_v0_0_c_ifspec;
+extern RPC_IF_HANDLE __MIDL_itf_d3d12video_0000_0003_v0_0_s_ifspec;
+
+#ifndef __ID3D12VideoProcessor_INTERFACE_DEFINED__
+#define __ID3D12VideoProcessor_INTERFACE_DEFINED__
+
+/* interface ID3D12VideoProcessor */
+/* [unique][local][object][uuid] */ 
+
+
+EXTERN_C const IID IID_ID3D12VideoProcessor;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("304FDB32-BEDE-410A-8545-943AC6A46138")
+    ID3D12VideoProcessor : public ID3D12Pageable
+    {
+    public:
+        virtual UINT STDMETHODCALLTYPE GetNodeMask( void) = 0;
+        
+        virtual UINT STDMETHODCALLTYPE GetNumInputStreamDescs( void) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE GetInputStreamDescs( 
+            UINT NumInputStreamDescs,
+            _Out_writes_(NumInputStreamDescs)  D3D12_VIDEO_PROCESS_INPUT_STREAM_DESC *pInputStreamDescs) = 0;
+        
+#if defined(_MSC_VER) || !defined(_WIN32)
+        virtual D3D12_VIDEO_PROCESS_OUTPUT_STREAM_DESC STDMETHODCALLTYPE GetOutputStreamDesc( void) = 0;
+#else
+        virtual D3D12_VIDEO_PROCESS_OUTPUT_STREAM_DESC *STDMETHODCALLTYPE GetOutputStreamDesc( 
+            D3D12_VIDEO_PROCESS_OUTPUT_STREAM_DESC * RetVal) = 0;
+#endif
+        
+    };
+    
+    
+#else 	/* C style interface */
+
+    typedef struct ID3D12VideoProcessorVtbl
+    {
+        BEGIN_INTERFACE
+        
+        DECLSPEC_XFGVIRT(IUnknown, QueryInterface)
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            ID3D12VideoProcessor * This,
+            REFIID riid,
+            _COM_Outptr_  void **ppvObject);
+        
+        DECLSPEC_XFGVIRT(IUnknown, AddRef)
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            ID3D12VideoProcessor * This);
+        
+        DECLSPEC_XFGVIRT(IUnknown, Release)
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            ID3D12VideoProcessor * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, GetPrivateData)
+        HRESULT ( STDMETHODCALLTYPE *GetPrivateData )( 
+            ID3D12VideoProcessor * This,
+            _In_  REFGUID guid,
+            _Inout_  UINT *pDataSize,
+            _Out_writes_bytes_opt_( *pDataSize )  void *pData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, SetPrivateData)
+        HRESULT ( STDMETHODCALLTYPE *SetPrivateData )( 
+            ID3D12VideoProcessor * This,
+            _In_  REFGUID guid,
+            _In_  UINT DataSize,
+            _In_reads_bytes_opt_( DataSize )  const void *pData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, SetPrivateDataInterface)
+        HRESULT ( STDMETHODCALLTYPE *SetPrivateDataInterface )( 
+            ID3D12VideoProcessor * This,
+            _In_  REFGUID guid,
+            _In_opt_  const IUnknown *pData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, SetName)
+        HRESULT ( STDMETHODCALLTYPE *SetName )( 
+            ID3D12VideoProcessor * This,
+            _In_z_  LPCWSTR Name);
+        
+        DECLSPEC_XFGVIRT(ID3D12DeviceChild, GetDevice)
+        HRESULT ( STDMETHODCALLTYPE *GetDevice )( 
+            ID3D12VideoProcessor * This,
+            REFIID riid,
+            _COM_Outptr_opt_  void **ppvDevice);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoProcessor, GetNodeMask)
+        UINT ( STDMETHODCALLTYPE *GetNodeMask )( 
+            ID3D12VideoProcessor * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoProcessor, GetNumInputStreamDescs)
+        UINT ( STDMETHODCALLTYPE *GetNumInputStreamDescs )( 
+            ID3D12VideoProcessor * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoProcessor, GetInputStreamDescs)
+        HRESULT ( STDMETHODCALLTYPE *GetInputStreamDescs )( 
+            ID3D12VideoProcessor * This,
+            UINT NumInputStreamDescs,
+            _Out_writes_(NumInputStreamDescs)  D3D12_VIDEO_PROCESS_INPUT_STREAM_DESC *pInputStreamDescs);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoProcessor, GetOutputStreamDesc)
+#if !defined(_WIN32)
+        D3D12_VIDEO_PROCESS_OUTPUT_STREAM_DESC ( STDMETHODCALLTYPE *GetOutputStreamDesc )( 
+            ID3D12VideoProcessor * This);
+        
+#else
+        D3D12_VIDEO_PROCESS_OUTPUT_STREAM_DESC *( STDMETHODCALLTYPE *GetOutputStreamDesc )( 
+            ID3D12VideoProcessor * This,
+            D3D12_VIDEO_PROCESS_OUTPUT_STREAM_DESC * RetVal);
+        
+#endif
+        
+        END_INTERFACE
+    } ID3D12VideoProcessorVtbl;
+
+    interface ID3D12VideoProcessor
+    {
+        CONST_VTBL struct ID3D12VideoProcessorVtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define ID3D12VideoProcessor_QueryInterface(This,riid,ppvObject)	\
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define ID3D12VideoProcessor_AddRef(This)	\
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define ID3D12VideoProcessor_Release(This)	\
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#define ID3D12VideoProcessor_GetPrivateData(This,guid,pDataSize,pData)	\
+    ( (This)->lpVtbl -> GetPrivateData(This,guid,pDataSize,pData) ) 
+
+#define ID3D12VideoProcessor_SetPrivateData(This,guid,DataSize,pData)	\
+    ( (This)->lpVtbl -> SetPrivateData(This,guid,DataSize,pData) ) 
+
+#define ID3D12VideoProcessor_SetPrivateDataInterface(This,guid,pData)	\
+    ( (This)->lpVtbl -> SetPrivateDataInterface(This,guid,pData) ) 
+
+#define ID3D12VideoProcessor_SetName(This,Name)	\
+    ( (This)->lpVtbl -> SetName(This,Name) ) 
+
+
+#define ID3D12VideoProcessor_GetDevice(This,riid,ppvDevice)	\
+    ( (This)->lpVtbl -> GetDevice(This,riid,ppvDevice) ) 
+
+
+
+#define ID3D12VideoProcessor_GetNodeMask(This)	\
+    ( (This)->lpVtbl -> GetNodeMask(This) ) 
+
+#define ID3D12VideoProcessor_GetNumInputStreamDescs(This)	\
+    ( (This)->lpVtbl -> GetNumInputStreamDescs(This) ) 
+
+#define ID3D12VideoProcessor_GetInputStreamDescs(This,NumInputStreamDescs,pInputStreamDescs)	\
+    ( (This)->lpVtbl -> GetInputStreamDescs(This,NumInputStreamDescs,pInputStreamDescs) ) 
+#if !defined(_WIN32)
+
+#define ID3D12VideoProcessor_GetOutputStreamDesc(This)	\
+    ( (This)->lpVtbl -> GetOutputStreamDesc(This) ) 
+#else
+#define ID3D12VideoProcessor_GetOutputStreamDesc(This,RetVal)	\
+    ( (This)->lpVtbl -> GetOutputStreamDesc(This,RetVal) ) 
+#endif
+
+#endif /* COBJMACROS */
+
+
+#endif 	/* C style interface */
+
+
+
+
+#endif 	/* __ID3D12VideoProcessor_INTERFACE_DEFINED__ */
+
+
+/* interface __MIDL_itf_d3d12video_0000_0004 */
+/* [local] */ 
+
+typedef 
+enum D3D12_VIDEO_PROCESS_FEATURE_FLAGS
+    {
+        D3D12_VIDEO_PROCESS_FEATURE_FLAG_NONE	= 0,
+        D3D12_VIDEO_PROCESS_FEATURE_FLAG_ALPHA_FILL	= 0x1,
+        D3D12_VIDEO_PROCESS_FEATURE_FLAG_LUMA_KEY	= 0x2,
+        D3D12_VIDEO_PROCESS_FEATURE_FLAG_STEREO	= 0x4,
+        D3D12_VIDEO_PROCESS_FEATURE_FLAG_ROTATION	= 0x8,
+        D3D12_VIDEO_PROCESS_FEATURE_FLAG_FLIP	= 0x10,
+        D3D12_VIDEO_PROCESS_FEATURE_FLAG_ALPHA_BLENDING	= 0x20,
+        D3D12_VIDEO_PROCESS_FEATURE_FLAG_PIXEL_ASPECT_RATIO	= 0x40
+    } 	D3D12_VIDEO_PROCESS_FEATURE_FLAGS;
+
+DEFINE_ENUM_FLAG_OPERATORS(D3D12_VIDEO_PROCESS_FEATURE_FLAGS );
+typedef 
+enum D3D12_VIDEO_PROCESS_AUTO_PROCESSING_FLAGS
+    {
+        D3D12_VIDEO_PROCESS_AUTO_PROCESSING_FLAG_NONE	= 0,
+        D3D12_VIDEO_PROCESS_AUTO_PROCESSING_FLAG_DENOISE	= 0x1,
+        D3D12_VIDEO_PROCESS_AUTO_PROCESSING_FLAG_DERINGING	= 0x2,
+        D3D12_VIDEO_PROCESS_AUTO_PROCESSING_FLAG_EDGE_ENHANCEMENT	= 0x4,
+        D3D12_VIDEO_PROCESS_AUTO_PROCESSING_FLAG_COLOR_CORRECTION	= 0x8,
+        D3D12_VIDEO_PROCESS_AUTO_PROCESSING_FLAG_FLESH_TONE_MAPPING	= 0x10,
+        D3D12_VIDEO_PROCESS_AUTO_PROCESSING_FLAG_IMAGE_STABILIZATION	= 0x20,
+        D3D12_VIDEO_PROCESS_AUTO_PROCESSING_FLAG_SUPER_RESOLUTION	= 0x40,
+        D3D12_VIDEO_PROCESS_AUTO_PROCESSING_FLAG_ANAMORPHIC_SCALING	= 0x80,
+        D3D12_VIDEO_PROCESS_AUTO_PROCESSING_FLAG_CUSTOM	= 0x80000000
+    } 	D3D12_VIDEO_PROCESS_AUTO_PROCESSING_FLAGS;
+
+DEFINE_ENUM_FLAG_OPERATORS(D3D12_VIDEO_PROCESS_AUTO_PROCESSING_FLAGS );
+typedef 
+enum D3D12_VIDEO_PROCESS_ORIENTATION
+    {
+        D3D12_VIDEO_PROCESS_ORIENTATION_DEFAULT	= 0,
+        D3D12_VIDEO_PROCESS_ORIENTATION_FLIP_HORIZONTAL	= 1,
+        D3D12_VIDEO_PROCESS_ORIENTATION_CLOCKWISE_90	= 2,
+        D3D12_VIDEO_PROCESS_ORIENTATION_CLOCKWISE_90_FLIP_HORIZONTAL	= 3,
+        D3D12_VIDEO_PROCESS_ORIENTATION_CLOCKWISE_180	= 4,
+        D3D12_VIDEO_PROCESS_ORIENTATION_FLIP_VERTICAL	= 5,
+        D3D12_VIDEO_PROCESS_ORIENTATION_CLOCKWISE_270	= 6,
+        D3D12_VIDEO_PROCESS_ORIENTATION_CLOCKWISE_270_FLIP_HORIZONTAL	= 7
+    } 	D3D12_VIDEO_PROCESS_ORIENTATION;
+
+typedef 
+enum D3D12_VIDEO_PROCESS_INPUT_STREAM_FLAGS
+    {
+        D3D12_VIDEO_PROCESS_INPUT_STREAM_FLAG_NONE	= 0,
+        D3D12_VIDEO_PROCESS_INPUT_STREAM_FLAG_FRAME_DISCONTINUITY	= 0x1,
+        D3D12_VIDEO_PROCESS_INPUT_STREAM_FLAG_FRAME_REPEAT	= 0x2
+    } 	D3D12_VIDEO_PROCESS_INPUT_STREAM_FLAGS;
+
+DEFINE_ENUM_FLAG_OPERATORS(D3D12_VIDEO_PROCESS_INPUT_STREAM_FLAGS );
+typedef struct D3D12_VIDEO_PROCESS_FILTER_RANGE
+    {
+    INT Minimum;
+    INT Maximum;
+    INT Default;
+    FLOAT Multiplier;
+    } 	D3D12_VIDEO_PROCESS_FILTER_RANGE;
+
+typedef 
+enum D3D12_VIDEO_PROCESS_SUPPORT_FLAGS
+    {
+        D3D12_VIDEO_PROCESS_SUPPORT_FLAG_NONE	= 0,
+        D3D12_VIDEO_PROCESS_SUPPORT_FLAG_SUPPORTED	= 0x1
+    } 	D3D12_VIDEO_PROCESS_SUPPORT_FLAGS;
+
+DEFINE_ENUM_FLAG_OPERATORS(D3D12_VIDEO_PROCESS_SUPPORT_FLAGS );
+typedef struct D3D12_FEATURE_DATA_VIDEO_PROCESS_SUPPORT
+    {
+    UINT NodeIndex;
+    D3D12_VIDEO_SAMPLE InputSample;
+    D3D12_VIDEO_FIELD_TYPE InputFieldType;
+    D3D12_VIDEO_FRAME_STEREO_FORMAT InputStereoFormat;
+    DXGI_RATIONAL InputFrameRate;
+    D3D12_VIDEO_FORMAT OutputFormat;
+    D3D12_VIDEO_FRAME_STEREO_FORMAT OutputStereoFormat;
+    DXGI_RATIONAL OutputFrameRate;
+    D3D12_VIDEO_PROCESS_SUPPORT_FLAGS SupportFlags;
+    D3D12_VIDEO_SCALE_SUPPORT ScaleSupport;
+    D3D12_VIDEO_PROCESS_FEATURE_FLAGS FeatureSupport;
+    D3D12_VIDEO_PROCESS_DEINTERLACE_FLAGS DeinterlaceSupport;
+    D3D12_VIDEO_PROCESS_AUTO_PROCESSING_FLAGS AutoProcessingSupport;
+    D3D12_VIDEO_PROCESS_FILTER_FLAGS FilterSupport;
+    D3D12_VIDEO_PROCESS_FILTER_RANGE FilterRangeSupport[ 32 ];
+    } 	D3D12_FEATURE_DATA_VIDEO_PROCESS_SUPPORT;
+
+typedef struct D3D12_FEATURE_DATA_VIDEO_PROCESS_MAX_INPUT_STREAMS
+    {
+    UINT NodeIndex;
+    UINT MaxInputStreams;
+    } 	D3D12_FEATURE_DATA_VIDEO_PROCESS_MAX_INPUT_STREAMS;
+
+typedef struct D3D12_FEATURE_DATA_VIDEO_PROCESS_REFERENCE_INFO
+    {
+    UINT NodeIndex;
+    D3D12_VIDEO_PROCESS_DEINTERLACE_FLAGS DeinterlaceMode;
+    D3D12_VIDEO_PROCESS_FILTER_FLAGS Filters;
+    D3D12_VIDEO_PROCESS_FEATURE_FLAGS FeatureSupport;
+    DXGI_RATIONAL InputFrameRate;
+    DXGI_RATIONAL OutputFrameRate;
+    BOOL EnableAutoProcessing;
+    UINT PastFrames;
+    UINT FutureFrames;
+    } 	D3D12_FEATURE_DATA_VIDEO_PROCESS_REFERENCE_INFO;
+
+typedef struct D3D12_VIDEO_PROCESS_REFERENCE_SET
+    {
+    UINT NumPastFrames;
+    ID3D12Resource **ppPastFrames;
+    UINT *pPastSubresources;
+    UINT NumFutureFrames;
+    ID3D12Resource **ppFutureFrames;
+    UINT *pFutureSubresources;
+    } 	D3D12_VIDEO_PROCESS_REFERENCE_SET;
+
+typedef struct D3D12_VIDEO_PROCESS_TRANSFORM
+    {
+    D3D12_RECT SourceRectangle;
+    D3D12_RECT DestinationRectangle;
+    D3D12_VIDEO_PROCESS_ORIENTATION Orientation;
+    } 	D3D12_VIDEO_PROCESS_TRANSFORM;
+
+typedef struct D3D12_VIDEO_PROCESS_INPUT_STREAM_RATE
+    {
+    UINT OutputIndex;
+    UINT InputFrameOrField;
+    } 	D3D12_VIDEO_PROCESS_INPUT_STREAM_RATE;
+
+typedef struct D3D12_VIDEO_PROCESS_INPUT_STREAM
+    {
+    ID3D12Resource *pTexture2D;
+    UINT Subresource;
+    D3D12_VIDEO_PROCESS_REFERENCE_SET ReferenceSet;
+    } 	D3D12_VIDEO_PROCESS_INPUT_STREAM;
+
+typedef struct D3D12_VIDEO_PROCESS_INPUT_STREAM_ARGUMENTS
+    {
+    D3D12_VIDEO_PROCESS_INPUT_STREAM InputStream[ 2 ];
+    D3D12_VIDEO_PROCESS_TRANSFORM Transform;
+    D3D12_VIDEO_PROCESS_INPUT_STREAM_FLAGS Flags;
+    D3D12_VIDEO_PROCESS_INPUT_STREAM_RATE RateInfo;
+    INT FilterLevels[ 32 ];
+    D3D12_VIDEO_PROCESS_ALPHA_BLENDING AlphaBlending;
+    } 	D3D12_VIDEO_PROCESS_INPUT_STREAM_ARGUMENTS;
+
+typedef struct D3D12_VIDEO_PROCESS_OUTPUT_STREAM
+    {
+    ID3D12Resource *pTexture2D;
+    UINT Subresource;
+    } 	D3D12_VIDEO_PROCESS_OUTPUT_STREAM;
+
+typedef struct D3D12_VIDEO_PROCESS_OUTPUT_STREAM_ARGUMENTS
+    {
+    D3D12_VIDEO_PROCESS_OUTPUT_STREAM OutputStream[ 2 ];
+    D3D12_RECT TargetRectangle;
+    } 	D3D12_VIDEO_PROCESS_OUTPUT_STREAM_ARGUMENTS;
+
+
+
+extern RPC_IF_HANDLE __MIDL_itf_d3d12video_0000_0004_v0_0_c_ifspec;
+extern RPC_IF_HANDLE __MIDL_itf_d3d12video_0000_0004_v0_0_s_ifspec;
+
+#ifndef __ID3D12VideoDecodeCommandList_INTERFACE_DEFINED__
+#define __ID3D12VideoDecodeCommandList_INTERFACE_DEFINED__
+
+/* interface ID3D12VideoDecodeCommandList */
+/* [unique][local][object][uuid] */ 
+
+
+EXTERN_C const IID IID_ID3D12VideoDecodeCommandList;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("3B60536E-AD29-4E64-A269-F853837E5E53")
+    ID3D12VideoDecodeCommandList : public ID3D12CommandList
+    {
+    public:
+        virtual HRESULT STDMETHODCALLTYPE Close( void) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE Reset( 
+            _In_  ID3D12CommandAllocator *pAllocator) = 0;
+        
+        virtual void STDMETHODCALLTYPE ClearState( void) = 0;
+        
+        virtual void STDMETHODCALLTYPE ResourceBarrier( 
+            _In_  UINT NumBarriers,
+            _In_reads_(NumBarriers)  const D3D12_RESOURCE_BARRIER *pBarriers) = 0;
+        
+        virtual void STDMETHODCALLTYPE DiscardResource( 
+            _In_  ID3D12Resource *pResource,
+            _In_opt_  const D3D12_DISCARD_REGION *pRegion) = 0;
+        
+        virtual void STDMETHODCALLTYPE BeginQuery( 
+            _In_  ID3D12QueryHeap *pQueryHeap,
+            _In_  D3D12_QUERY_TYPE Type,
+            _In_  UINT Index) = 0;
+        
+        virtual void STDMETHODCALLTYPE EndQuery( 
+            _In_  ID3D12QueryHeap *pQueryHeap,
+            _In_  D3D12_QUERY_TYPE Type,
+            _In_  UINT Index) = 0;
+        
+        virtual void STDMETHODCALLTYPE ResolveQueryData( 
+            _In_  ID3D12QueryHeap *pQueryHeap,
+            _In_  D3D12_QUERY_TYPE Type,
+            _In_  UINT StartIndex,
+            _In_  UINT NumQueries,
+            _In_  ID3D12Resource *pDestinationBuffer,
+            _In_  UINT64 AlignedDestinationBufferOffset) = 0;
+        
+        virtual void STDMETHODCALLTYPE SetPredication( 
+            _In_opt_  ID3D12Resource *pBuffer,
+            _In_  UINT64 AlignedBufferOffset,
+            _In_  D3D12_PREDICATION_OP Operation) = 0;
+        
+        virtual void STDMETHODCALLTYPE SetMarker( 
+            UINT Metadata,
+            _In_reads_bytes_opt_(Size)  const void *pData,
+            UINT Size) = 0;
+        
+        virtual void STDMETHODCALLTYPE BeginEvent( 
+            UINT Metadata,
+            _In_reads_bytes_opt_(Size)  const void *pData,
+            UINT Size) = 0;
+        
+        virtual void STDMETHODCALLTYPE EndEvent( void) = 0;
+        
+        virtual void STDMETHODCALLTYPE DecodeFrame( 
+            _In_  ID3D12VideoDecoder *pDecoder,
+            _In_  const D3D12_VIDEO_DECODE_OUTPUT_STREAM_ARGUMENTS *pOutputArguments,
+            _In_  const D3D12_VIDEO_DECODE_INPUT_STREAM_ARGUMENTS *pInputArguments) = 0;
+        
+        virtual void STDMETHODCALLTYPE WriteBufferImmediate( 
+            UINT Count,
+            _In_reads_(Count)  const D3D12_WRITEBUFFERIMMEDIATE_PARAMETER *pParams,
+            _In_reads_opt_(Count)  const D3D12_WRITEBUFFERIMMEDIATE_MODE *pModes) = 0;
+        
+    };
+    
+    
+#else 	/* C style interface */
+
+    typedef struct ID3D12VideoDecodeCommandListVtbl
+    {
+        BEGIN_INTERFACE
+        
+        DECLSPEC_XFGVIRT(IUnknown, QueryInterface)
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            ID3D12VideoDecodeCommandList * This,
+            REFIID riid,
+            _COM_Outptr_  void **ppvObject);
+        
+        DECLSPEC_XFGVIRT(IUnknown, AddRef)
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            ID3D12VideoDecodeCommandList * This);
+        
+        DECLSPEC_XFGVIRT(IUnknown, Release)
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            ID3D12VideoDecodeCommandList * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, GetPrivateData)
+        HRESULT ( STDMETHODCALLTYPE *GetPrivateData )( 
+            ID3D12VideoDecodeCommandList * This,
+            _In_  REFGUID guid,
+            _Inout_  UINT *pDataSize,
+            _Out_writes_bytes_opt_( *pDataSize )  void *pData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, SetPrivateData)
+        HRESULT ( STDMETHODCALLTYPE *SetPrivateData )( 
+            ID3D12VideoDecodeCommandList * This,
+            _In_  REFGUID guid,
+            _In_  UINT DataSize,
+            _In_reads_bytes_opt_( DataSize )  const void *pData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, SetPrivateDataInterface)
+        HRESULT ( STDMETHODCALLTYPE *SetPrivateDataInterface )( 
+            ID3D12VideoDecodeCommandList * This,
+            _In_  REFGUID guid,
+            _In_opt_  const IUnknown *pData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, SetName)
+        HRESULT ( STDMETHODCALLTYPE *SetName )( 
+            ID3D12VideoDecodeCommandList * This,
+            _In_z_  LPCWSTR Name);
+        
+        DECLSPEC_XFGVIRT(ID3D12DeviceChild, GetDevice)
+        HRESULT ( STDMETHODCALLTYPE *GetDevice )( 
+            ID3D12VideoDecodeCommandList * This,
+            REFIID riid,
+            _COM_Outptr_opt_  void **ppvDevice);
+        
+        DECLSPEC_XFGVIRT(ID3D12CommandList, GetType)
+        D3D12_COMMAND_LIST_TYPE ( STDMETHODCALLTYPE *GetType )( 
+            ID3D12VideoDecodeCommandList * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoDecodeCommandList, Close)
+        HRESULT ( STDMETHODCALLTYPE *Close )( 
+            ID3D12VideoDecodeCommandList * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoDecodeCommandList, Reset)
+        HRESULT ( STDMETHODCALLTYPE *Reset )( 
+            ID3D12VideoDecodeCommandList * This,
+            _In_  ID3D12CommandAllocator *pAllocator);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoDecodeCommandList, ClearState)
+        void ( STDMETHODCALLTYPE *ClearState )( 
+            ID3D12VideoDecodeCommandList * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoDecodeCommandList, ResourceBarrier)
+        void ( STDMETHODCALLTYPE *ResourceBarrier )( 
+            ID3D12VideoDecodeCommandList * This,
+            _In_  UINT NumBarriers,
+            _In_reads_(NumBarriers)  const D3D12_RESOURCE_BARRIER *pBarriers);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoDecodeCommandList, DiscardResource)
+        void ( STDMETHODCALLTYPE *DiscardResource )( 
+            ID3D12VideoDecodeCommandList * This,
+            _In_  ID3D12Resource *pResource,
+            _In_opt_  const D3D12_DISCARD_REGION *pRegion);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoDecodeCommandList, BeginQuery)
+        void ( STDMETHODCALLTYPE *BeginQuery )( 
+            ID3D12VideoDecodeCommandList * This,
+            _In_  ID3D12QueryHeap *pQueryHeap,
+            _In_  D3D12_QUERY_TYPE Type,
+            _In_  UINT Index);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoDecodeCommandList, EndQuery)
+        void ( STDMETHODCALLTYPE *EndQuery )( 
+            ID3D12VideoDecodeCommandList * This,
+            _In_  ID3D12QueryHeap *pQueryHeap,
+            _In_  D3D12_QUERY_TYPE Type,
+            _In_  UINT Index);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoDecodeCommandList, ResolveQueryData)
+        void ( STDMETHODCALLTYPE *ResolveQueryData )( 
+            ID3D12VideoDecodeCommandList * This,
+            _In_  ID3D12QueryHeap *pQueryHeap,
+            _In_  D3D12_QUERY_TYPE Type,
+            _In_  UINT StartIndex,
+            _In_  UINT NumQueries,
+            _In_  ID3D12Resource *pDestinationBuffer,
+            _In_  UINT64 AlignedDestinationBufferOffset);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoDecodeCommandList, SetPredication)
+        void ( STDMETHODCALLTYPE *SetPredication )( 
+            ID3D12VideoDecodeCommandList * This,
+            _In_opt_  ID3D12Resource *pBuffer,
+            _In_  UINT64 AlignedBufferOffset,
+            _In_  D3D12_PREDICATION_OP Operation);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoDecodeCommandList, SetMarker)
+        void ( STDMETHODCALLTYPE *SetMarker )( 
+            ID3D12VideoDecodeCommandList * This,
+            UINT Metadata,
+            _In_reads_bytes_opt_(Size)  const void *pData,
+            UINT Size);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoDecodeCommandList, BeginEvent)
+        void ( STDMETHODCALLTYPE *BeginEvent )( 
+            ID3D12VideoDecodeCommandList * This,
+            UINT Metadata,
+            _In_reads_bytes_opt_(Size)  const void *pData,
+            UINT Size);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoDecodeCommandList, EndEvent)
+        void ( STDMETHODCALLTYPE *EndEvent )( 
+            ID3D12VideoDecodeCommandList * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoDecodeCommandList, DecodeFrame)
+        void ( STDMETHODCALLTYPE *DecodeFrame )( 
+            ID3D12VideoDecodeCommandList * This,
+            _In_  ID3D12VideoDecoder *pDecoder,
+            _In_  const D3D12_VIDEO_DECODE_OUTPUT_STREAM_ARGUMENTS *pOutputArguments,
+            _In_  const D3D12_VIDEO_DECODE_INPUT_STREAM_ARGUMENTS *pInputArguments);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoDecodeCommandList, WriteBufferImmediate)
+        void ( STDMETHODCALLTYPE *WriteBufferImmediate )( 
+            ID3D12VideoDecodeCommandList * This,
+            UINT Count,
+            _In_reads_(Count)  const D3D12_WRITEBUFFERIMMEDIATE_PARAMETER *pParams,
+            _In_reads_opt_(Count)  const D3D12_WRITEBUFFERIMMEDIATE_MODE *pModes);
+        
+        END_INTERFACE
+    } ID3D12VideoDecodeCommandListVtbl;
+
+    interface ID3D12VideoDecodeCommandList
+    {
+        CONST_VTBL struct ID3D12VideoDecodeCommandListVtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define ID3D12VideoDecodeCommandList_QueryInterface(This,riid,ppvObject)	\
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define ID3D12VideoDecodeCommandList_AddRef(This)	\
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define ID3D12VideoDecodeCommandList_Release(This)	\
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#define ID3D12VideoDecodeCommandList_GetPrivateData(This,guid,pDataSize,pData)	\
+    ( (This)->lpVtbl -> GetPrivateData(This,guid,pDataSize,pData) ) 
+
+#define ID3D12VideoDecodeCommandList_SetPrivateData(This,guid,DataSize,pData)	\
+    ( (This)->lpVtbl -> SetPrivateData(This,guid,DataSize,pData) ) 
+
+#define ID3D12VideoDecodeCommandList_SetPrivateDataInterface(This,guid,pData)	\
+    ( (This)->lpVtbl -> SetPrivateDataInterface(This,guid,pData) ) 
+
+#define ID3D12VideoDecodeCommandList_SetName(This,Name)	\
+    ( (This)->lpVtbl -> SetName(This,Name) ) 
+
+
+#define ID3D12VideoDecodeCommandList_GetDevice(This,riid,ppvDevice)	\
+    ( (This)->lpVtbl -> GetDevice(This,riid,ppvDevice) ) 
+
+
+#define ID3D12VideoDecodeCommandList_GetType(This)	\
+    ( (This)->lpVtbl -> GetType(This) ) 
+
+
+#define ID3D12VideoDecodeCommandList_Close(This)	\
+    ( (This)->lpVtbl -> Close(This) ) 
+
+#define ID3D12VideoDecodeCommandList_Reset(This,pAllocator)	\
+    ( (This)->lpVtbl -> Reset(This,pAllocator) ) 
+
+#define ID3D12VideoDecodeCommandList_ClearState(This)	\
+    ( (This)->lpVtbl -> ClearState(This) ) 
+
+#define ID3D12VideoDecodeCommandList_ResourceBarrier(This,NumBarriers,pBarriers)	\
+    ( (This)->lpVtbl -> ResourceBarrier(This,NumBarriers,pBarriers) ) 
+
+#define ID3D12VideoDecodeCommandList_DiscardResource(This,pResource,pRegion)	\
+    ( (This)->lpVtbl -> DiscardResource(This,pResource,pRegion) ) 
+
+#define ID3D12VideoDecodeCommandList_BeginQuery(This,pQueryHeap,Type,Index)	\
+    ( (This)->lpVtbl -> BeginQuery(This,pQueryHeap,Type,Index) ) 
+
+#define ID3D12VideoDecodeCommandList_EndQuery(This,pQueryHeap,Type,Index)	\
+    ( (This)->lpVtbl -> EndQuery(This,pQueryHeap,Type,Index) ) 
+
+#define ID3D12VideoDecodeCommandList_ResolveQueryData(This,pQueryHeap,Type,StartIndex,NumQueries,pDestinationBuffer,AlignedDestinationBufferOffset)	\
+    ( (This)->lpVtbl -> ResolveQueryData(This,pQueryHeap,Type,StartIndex,NumQueries,pDestinationBuffer,AlignedDestinationBufferOffset) ) 
+
+#define ID3D12VideoDecodeCommandList_SetPredication(This,pBuffer,AlignedBufferOffset,Operation)	\
+    ( (This)->lpVtbl -> SetPredication(This,pBuffer,AlignedBufferOffset,Operation) ) 
+
+#define ID3D12VideoDecodeCommandList_SetMarker(This,Metadata,pData,Size)	\
+    ( (This)->lpVtbl -> SetMarker(This,Metadata,pData,Size) ) 
+
+#define ID3D12VideoDecodeCommandList_BeginEvent(This,Metadata,pData,Size)	\
+    ( (This)->lpVtbl -> BeginEvent(This,Metadata,pData,Size) ) 
+
+#define ID3D12VideoDecodeCommandList_EndEvent(This)	\
+    ( (This)->lpVtbl -> EndEvent(This) ) 
+
+#define ID3D12VideoDecodeCommandList_DecodeFrame(This,pDecoder,pOutputArguments,pInputArguments)	\
+    ( (This)->lpVtbl -> DecodeFrame(This,pDecoder,pOutputArguments,pInputArguments) ) 
+
+#define ID3D12VideoDecodeCommandList_WriteBufferImmediate(This,Count,pParams,pModes)	\
+    ( (This)->lpVtbl -> WriteBufferImmediate(This,Count,pParams,pModes) ) 
+
+#endif /* COBJMACROS */
+
+
+#endif 	/* C style interface */
+
+
+
+
+#endif 	/* __ID3D12VideoDecodeCommandList_INTERFACE_DEFINED__ */
+
+
+#ifndef __ID3D12VideoProcessCommandList_INTERFACE_DEFINED__
+#define __ID3D12VideoProcessCommandList_INTERFACE_DEFINED__
+
+/* interface ID3D12VideoProcessCommandList */
+/* [unique][local][object][uuid] */ 
+
+
+EXTERN_C const IID IID_ID3D12VideoProcessCommandList;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("AEB2543A-167F-4682-ACC8-D159ED4A6209")
+    ID3D12VideoProcessCommandList : public ID3D12CommandList
+    {
+    public:
+        virtual HRESULT STDMETHODCALLTYPE Close( void) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE Reset( 
+            _In_  ID3D12CommandAllocator *pAllocator) = 0;
+        
+        virtual void STDMETHODCALLTYPE ClearState( void) = 0;
+        
+        virtual void STDMETHODCALLTYPE ResourceBarrier( 
+            _In_  UINT NumBarriers,
+            _In_reads_(NumBarriers)  const D3D12_RESOURCE_BARRIER *pBarriers) = 0;
+        
+        virtual void STDMETHODCALLTYPE DiscardResource( 
+            _In_  ID3D12Resource *pResource,
+            _In_opt_  const D3D12_DISCARD_REGION *pRegion) = 0;
+        
+        virtual void STDMETHODCALLTYPE BeginQuery( 
+            _In_  ID3D12QueryHeap *pQueryHeap,
+            _In_  D3D12_QUERY_TYPE Type,
+            _In_  UINT Index) = 0;
+        
+        virtual void STDMETHODCALLTYPE EndQuery( 
+            _In_  ID3D12QueryHeap *pQueryHeap,
+            _In_  D3D12_QUERY_TYPE Type,
+            _In_  UINT Index) = 0;
+        
+        virtual void STDMETHODCALLTYPE ResolveQueryData( 
+            _In_  ID3D12QueryHeap *pQueryHeap,
+            _In_  D3D12_QUERY_TYPE Type,
+            _In_  UINT StartIndex,
+            _In_  UINT NumQueries,
+            _In_  ID3D12Resource *pDestinationBuffer,
+            _In_  UINT64 AlignedDestinationBufferOffset) = 0;
+        
+        virtual void STDMETHODCALLTYPE SetPredication( 
+            _In_opt_  ID3D12Resource *pBuffer,
+            _In_  UINT64 AlignedBufferOffset,
+            _In_  D3D12_PREDICATION_OP Operation) = 0;
+        
+        virtual void STDMETHODCALLTYPE SetMarker( 
+            UINT Metadata,
+            _In_reads_bytes_opt_(Size)  const void *pData,
+            UINT Size) = 0;
+        
+        virtual void STDMETHODCALLTYPE BeginEvent( 
+            UINT Metadata,
+            _In_reads_bytes_opt_(Size)  const void *pData,
+            UINT Size) = 0;
+        
+        virtual void STDMETHODCALLTYPE EndEvent( void) = 0;
+        
+        virtual void STDMETHODCALLTYPE ProcessFrames( 
+            _In_  ID3D12VideoProcessor *pVideoProcessor,
+            _In_  const D3D12_VIDEO_PROCESS_OUTPUT_STREAM_ARGUMENTS *pOutputArguments,
+            UINT NumInputStreams,
+            _In_reads_(NumInputStreams)  const D3D12_VIDEO_PROCESS_INPUT_STREAM_ARGUMENTS *pInputArguments) = 0;
+        
+        virtual void STDMETHODCALLTYPE WriteBufferImmediate( 
+            UINT Count,
+            _In_reads_(Count)  const D3D12_WRITEBUFFERIMMEDIATE_PARAMETER *pParams,
+            _In_reads_opt_(Count)  const D3D12_WRITEBUFFERIMMEDIATE_MODE *pModes) = 0;
+        
+    };
+    
+    
+#else 	/* C style interface */
+
+    typedef struct ID3D12VideoProcessCommandListVtbl
+    {
+        BEGIN_INTERFACE
+        
+        DECLSPEC_XFGVIRT(IUnknown, QueryInterface)
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            ID3D12VideoProcessCommandList * This,
+            REFIID riid,
+            _COM_Outptr_  void **ppvObject);
+        
+        DECLSPEC_XFGVIRT(IUnknown, AddRef)
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            ID3D12VideoProcessCommandList * This);
+        
+        DECLSPEC_XFGVIRT(IUnknown, Release)
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            ID3D12VideoProcessCommandList * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, GetPrivateData)
+        HRESULT ( STDMETHODCALLTYPE *GetPrivateData )( 
+            ID3D12VideoProcessCommandList * This,
+            _In_  REFGUID guid,
+            _Inout_  UINT *pDataSize,
+            _Out_writes_bytes_opt_( *pDataSize )  void *pData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, SetPrivateData)
+        HRESULT ( STDMETHODCALLTYPE *SetPrivateData )( 
+            ID3D12VideoProcessCommandList * This,
+            _In_  REFGUID guid,
+            _In_  UINT DataSize,
+            _In_reads_bytes_opt_( DataSize )  const void *pData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, SetPrivateDataInterface)
+        HRESULT ( STDMETHODCALLTYPE *SetPrivateDataInterface )( 
+            ID3D12VideoProcessCommandList * This,
+            _In_  REFGUID guid,
+            _In_opt_  const IUnknown *pData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, SetName)
+        HRESULT ( STDMETHODCALLTYPE *SetName )( 
+            ID3D12VideoProcessCommandList * This,
+            _In_z_  LPCWSTR Name);
+        
+        DECLSPEC_XFGVIRT(ID3D12DeviceChild, GetDevice)
+        HRESULT ( STDMETHODCALLTYPE *GetDevice )( 
+            ID3D12VideoProcessCommandList * This,
+            REFIID riid,
+            _COM_Outptr_opt_  void **ppvDevice);
+        
+        DECLSPEC_XFGVIRT(ID3D12CommandList, GetType)
+        D3D12_COMMAND_LIST_TYPE ( STDMETHODCALLTYPE *GetType )( 
+            ID3D12VideoProcessCommandList * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoProcessCommandList, Close)
+        HRESULT ( STDMETHODCALLTYPE *Close )( 
+            ID3D12VideoProcessCommandList * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoProcessCommandList, Reset)
+        HRESULT ( STDMETHODCALLTYPE *Reset )( 
+            ID3D12VideoProcessCommandList * This,
+            _In_  ID3D12CommandAllocator *pAllocator);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoProcessCommandList, ClearState)
+        void ( STDMETHODCALLTYPE *ClearState )( 
+            ID3D12VideoProcessCommandList * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoProcessCommandList, ResourceBarrier)
+        void ( STDMETHODCALLTYPE *ResourceBarrier )( 
+            ID3D12VideoProcessCommandList * This,
+            _In_  UINT NumBarriers,
+            _In_reads_(NumBarriers)  const D3D12_RESOURCE_BARRIER *pBarriers);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoProcessCommandList, DiscardResource)
+        void ( STDMETHODCALLTYPE *DiscardResource )( 
+            ID3D12VideoProcessCommandList * This,
+            _In_  ID3D12Resource *pResource,
+            _In_opt_  const D3D12_DISCARD_REGION *pRegion);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoProcessCommandList, BeginQuery)
+        void ( STDMETHODCALLTYPE *BeginQuery )( 
+            ID3D12VideoProcessCommandList * This,
+            _In_  ID3D12QueryHeap *pQueryHeap,
+            _In_  D3D12_QUERY_TYPE Type,
+            _In_  UINT Index);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoProcessCommandList, EndQuery)
+        void ( STDMETHODCALLTYPE *EndQuery )( 
+            ID3D12VideoProcessCommandList * This,
+            _In_  ID3D12QueryHeap *pQueryHeap,
+            _In_  D3D12_QUERY_TYPE Type,
+            _In_  UINT Index);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoProcessCommandList, ResolveQueryData)
+        void ( STDMETHODCALLTYPE *ResolveQueryData )( 
+            ID3D12VideoProcessCommandList * This,
+            _In_  ID3D12QueryHeap *pQueryHeap,
+            _In_  D3D12_QUERY_TYPE Type,
+            _In_  UINT StartIndex,
+            _In_  UINT NumQueries,
+            _In_  ID3D12Resource *pDestinationBuffer,
+            _In_  UINT64 AlignedDestinationBufferOffset);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoProcessCommandList, SetPredication)
+        void ( STDMETHODCALLTYPE *SetPredication )( 
+            ID3D12VideoProcessCommandList * This,
+            _In_opt_  ID3D12Resource *pBuffer,
+            _In_  UINT64 AlignedBufferOffset,
+            _In_  D3D12_PREDICATION_OP Operation);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoProcessCommandList, SetMarker)
+        void ( STDMETHODCALLTYPE *SetMarker )( 
+            ID3D12VideoProcessCommandList * This,
+            UINT Metadata,
+            _In_reads_bytes_opt_(Size)  const void *pData,
+            UINT Size);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoProcessCommandList, BeginEvent)
+        void ( STDMETHODCALLTYPE *BeginEvent )( 
+            ID3D12VideoProcessCommandList * This,
+            UINT Metadata,
+            _In_reads_bytes_opt_(Size)  const void *pData,
+            UINT Size);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoProcessCommandList, EndEvent)
+        void ( STDMETHODCALLTYPE *EndEvent )( 
+            ID3D12VideoProcessCommandList * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoProcessCommandList, ProcessFrames)
+        void ( STDMETHODCALLTYPE *ProcessFrames )( 
+            ID3D12VideoProcessCommandList * This,
+            _In_  ID3D12VideoProcessor *pVideoProcessor,
+            _In_  const D3D12_VIDEO_PROCESS_OUTPUT_STREAM_ARGUMENTS *pOutputArguments,
+            UINT NumInputStreams,
+            _In_reads_(NumInputStreams)  const D3D12_VIDEO_PROCESS_INPUT_STREAM_ARGUMENTS *pInputArguments);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoProcessCommandList, WriteBufferImmediate)
+        void ( STDMETHODCALLTYPE *WriteBufferImmediate )( 
+            ID3D12VideoProcessCommandList * This,
+            UINT Count,
+            _In_reads_(Count)  const D3D12_WRITEBUFFERIMMEDIATE_PARAMETER *pParams,
+            _In_reads_opt_(Count)  const D3D12_WRITEBUFFERIMMEDIATE_MODE *pModes);
+        
+        END_INTERFACE
+    } ID3D12VideoProcessCommandListVtbl;
+
+    interface ID3D12VideoProcessCommandList
+    {
+        CONST_VTBL struct ID3D12VideoProcessCommandListVtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define ID3D12VideoProcessCommandList_QueryInterface(This,riid,ppvObject)	\
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define ID3D12VideoProcessCommandList_AddRef(This)	\
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define ID3D12VideoProcessCommandList_Release(This)	\
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#define ID3D12VideoProcessCommandList_GetPrivateData(This,guid,pDataSize,pData)	\
+    ( (This)->lpVtbl -> GetPrivateData(This,guid,pDataSize,pData) ) 
+
+#define ID3D12VideoProcessCommandList_SetPrivateData(This,guid,DataSize,pData)	\
+    ( (This)->lpVtbl -> SetPrivateData(This,guid,DataSize,pData) ) 
+
+#define ID3D12VideoProcessCommandList_SetPrivateDataInterface(This,guid,pData)	\
+    ( (This)->lpVtbl -> SetPrivateDataInterface(This,guid,pData) ) 
+
+#define ID3D12VideoProcessCommandList_SetName(This,Name)	\
+    ( (This)->lpVtbl -> SetName(This,Name) ) 
+
+
+#define ID3D12VideoProcessCommandList_GetDevice(This,riid,ppvDevice)	\
+    ( (This)->lpVtbl -> GetDevice(This,riid,ppvDevice) ) 
+
+
+#define ID3D12VideoProcessCommandList_GetType(This)	\
+    ( (This)->lpVtbl -> GetType(This) ) 
+
+
+#define ID3D12VideoProcessCommandList_Close(This)	\
+    ( (This)->lpVtbl -> Close(This) ) 
+
+#define ID3D12VideoProcessCommandList_Reset(This,pAllocator)	\
+    ( (This)->lpVtbl -> Reset(This,pAllocator) ) 
+
+#define ID3D12VideoProcessCommandList_ClearState(This)	\
+    ( (This)->lpVtbl -> ClearState(This) ) 
+
+#define ID3D12VideoProcessCommandList_ResourceBarrier(This,NumBarriers,pBarriers)	\
+    ( (This)->lpVtbl -> ResourceBarrier(This,NumBarriers,pBarriers) ) 
+
+#define ID3D12VideoProcessCommandList_DiscardResource(This,pResource,pRegion)	\
+    ( (This)->lpVtbl -> DiscardResource(This,pResource,pRegion) ) 
+
+#define ID3D12VideoProcessCommandList_BeginQuery(This,pQueryHeap,Type,Index)	\
+    ( (This)->lpVtbl -> BeginQuery(This,pQueryHeap,Type,Index) ) 
+
+#define ID3D12VideoProcessCommandList_EndQuery(This,pQueryHeap,Type,Index)	\
+    ( (This)->lpVtbl -> EndQuery(This,pQueryHeap,Type,Index) ) 
+
+#define ID3D12VideoProcessCommandList_ResolveQueryData(This,pQueryHeap,Type,StartIndex,NumQueries,pDestinationBuffer,AlignedDestinationBufferOffset)	\
+    ( (This)->lpVtbl -> ResolveQueryData(This,pQueryHeap,Type,StartIndex,NumQueries,pDestinationBuffer,AlignedDestinationBufferOffset) ) 
+
+#define ID3D12VideoProcessCommandList_SetPredication(This,pBuffer,AlignedBufferOffset,Operation)	\
+    ( (This)->lpVtbl -> SetPredication(This,pBuffer,AlignedBufferOffset,Operation) ) 
+
+#define ID3D12VideoProcessCommandList_SetMarker(This,Metadata,pData,Size)	\
+    ( (This)->lpVtbl -> SetMarker(This,Metadata,pData,Size) ) 
+
+#define ID3D12VideoProcessCommandList_BeginEvent(This,Metadata,pData,Size)	\
+    ( (This)->lpVtbl -> BeginEvent(This,Metadata,pData,Size) ) 
+
+#define ID3D12VideoProcessCommandList_EndEvent(This)	\
+    ( (This)->lpVtbl -> EndEvent(This) ) 
+
+#define ID3D12VideoProcessCommandList_ProcessFrames(This,pVideoProcessor,pOutputArguments,NumInputStreams,pInputArguments)	\
+    ( (This)->lpVtbl -> ProcessFrames(This,pVideoProcessor,pOutputArguments,NumInputStreams,pInputArguments) ) 
+
+#define ID3D12VideoProcessCommandList_WriteBufferImmediate(This,Count,pParams,pModes)	\
+    ( (This)->lpVtbl -> WriteBufferImmediate(This,Count,pParams,pModes) ) 
+
+#endif /* COBJMACROS */
+
+
+#endif 	/* C style interface */
+
+
+
+
+#endif 	/* __ID3D12VideoProcessCommandList_INTERFACE_DEFINED__ */
+
+
+/* interface __MIDL_itf_d3d12video_0000_0006 */
+/* [local] */ 
+
+typedef struct D3D12_VIDEO_DECODE_OUTPUT_HISTOGRAM
+    {
+    UINT64 Offset;
+    ID3D12Resource *pBuffer;
+    } 	D3D12_VIDEO_DECODE_OUTPUT_HISTOGRAM;
+
+typedef struct D3D12_VIDEO_DECODE_CONVERSION_ARGUMENTS1
+    {
+    BOOL Enable;
+    ID3D12Resource *pReferenceTexture2D;
+    UINT ReferenceSubresource;
+    DXGI_COLOR_SPACE_TYPE OutputColorSpace;
+    DXGI_COLOR_SPACE_TYPE DecodeColorSpace;
+    UINT OutputWidth;
+    UINT OutputHeight;
+    } 	D3D12_VIDEO_DECODE_CONVERSION_ARGUMENTS1;
+
+typedef struct D3D12_VIDEO_DECODE_OUTPUT_STREAM_ARGUMENTS1
+    {
+    ID3D12Resource *pOutputTexture2D;
+    UINT OutputSubresource;
+    D3D12_VIDEO_DECODE_CONVERSION_ARGUMENTS1 ConversionArguments;
+    D3D12_VIDEO_DECODE_OUTPUT_HISTOGRAM Histograms[ 4 ];
+    } 	D3D12_VIDEO_DECODE_OUTPUT_STREAM_ARGUMENTS1;
+
+
+
+extern RPC_IF_HANDLE __MIDL_itf_d3d12video_0000_0006_v0_0_c_ifspec;
+extern RPC_IF_HANDLE __MIDL_itf_d3d12video_0000_0006_v0_0_s_ifspec;
+
+#ifndef __ID3D12VideoDecodeCommandList1_INTERFACE_DEFINED__
+#define __ID3D12VideoDecodeCommandList1_INTERFACE_DEFINED__
+
+/* interface ID3D12VideoDecodeCommandList1 */
+/* [unique][local][object][uuid] */ 
+
+
+EXTERN_C const IID IID_ID3D12VideoDecodeCommandList1;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("D52F011B-B56E-453C-A05A-A7F311C8F472")
+    ID3D12VideoDecodeCommandList1 : public ID3D12VideoDecodeCommandList
+    {
+    public:
+        virtual void STDMETHODCALLTYPE DecodeFrame1( 
+            _In_  ID3D12VideoDecoder *pDecoder,
+            _In_  const D3D12_VIDEO_DECODE_OUTPUT_STREAM_ARGUMENTS1 *pOutputArguments,
+            _In_  const D3D12_VIDEO_DECODE_INPUT_STREAM_ARGUMENTS *pInputArguments) = 0;
+        
+    };
+    
+    
+#else 	/* C style interface */
+
+    typedef struct ID3D12VideoDecodeCommandList1Vtbl
+    {
+        BEGIN_INTERFACE
+        
+        DECLSPEC_XFGVIRT(IUnknown, QueryInterface)
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            ID3D12VideoDecodeCommandList1 * This,
+            REFIID riid,
+            _COM_Outptr_  void **ppvObject);
+        
+        DECLSPEC_XFGVIRT(IUnknown, AddRef)
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            ID3D12VideoDecodeCommandList1 * This);
+        
+        DECLSPEC_XFGVIRT(IUnknown, Release)
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            ID3D12VideoDecodeCommandList1 * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, GetPrivateData)
+        HRESULT ( STDMETHODCALLTYPE *GetPrivateData )( 
+            ID3D12VideoDecodeCommandList1 * This,
+            _In_  REFGUID guid,
+            _Inout_  UINT *pDataSize,
+            _Out_writes_bytes_opt_( *pDataSize )  void *pData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, SetPrivateData)
+        HRESULT ( STDMETHODCALLTYPE *SetPrivateData )( 
+            ID3D12VideoDecodeCommandList1 * This,
+            _In_  REFGUID guid,
+            _In_  UINT DataSize,
+            _In_reads_bytes_opt_( DataSize )  const void *pData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, SetPrivateDataInterface)
+        HRESULT ( STDMETHODCALLTYPE *SetPrivateDataInterface )( 
+            ID3D12VideoDecodeCommandList1 * This,
+            _In_  REFGUID guid,
+            _In_opt_  const IUnknown *pData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, SetName)
+        HRESULT ( STDMETHODCALLTYPE *SetName )( 
+            ID3D12VideoDecodeCommandList1 * This,
+            _In_z_  LPCWSTR Name);
+        
+        DECLSPEC_XFGVIRT(ID3D12DeviceChild, GetDevice)
+        HRESULT ( STDMETHODCALLTYPE *GetDevice )( 
+            ID3D12VideoDecodeCommandList1 * This,
+            REFIID riid,
+            _COM_Outptr_opt_  void **ppvDevice);
+        
+        DECLSPEC_XFGVIRT(ID3D12CommandList, GetType)
+        D3D12_COMMAND_LIST_TYPE ( STDMETHODCALLTYPE *GetType )( 
+            ID3D12VideoDecodeCommandList1 * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoDecodeCommandList, Close)
+        HRESULT ( STDMETHODCALLTYPE *Close )( 
+            ID3D12VideoDecodeCommandList1 * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoDecodeCommandList, Reset)
+        HRESULT ( STDMETHODCALLTYPE *Reset )( 
+            ID3D12VideoDecodeCommandList1 * This,
+            _In_  ID3D12CommandAllocator *pAllocator);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoDecodeCommandList, ClearState)
+        void ( STDMETHODCALLTYPE *ClearState )( 
+            ID3D12VideoDecodeCommandList1 * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoDecodeCommandList, ResourceBarrier)
+        void ( STDMETHODCALLTYPE *ResourceBarrier )( 
+            ID3D12VideoDecodeCommandList1 * This,
+            _In_  UINT NumBarriers,
+            _In_reads_(NumBarriers)  const D3D12_RESOURCE_BARRIER *pBarriers);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoDecodeCommandList, DiscardResource)
+        void ( STDMETHODCALLTYPE *DiscardResource )( 
+            ID3D12VideoDecodeCommandList1 * This,
+            _In_  ID3D12Resource *pResource,
+            _In_opt_  const D3D12_DISCARD_REGION *pRegion);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoDecodeCommandList, BeginQuery)
+        void ( STDMETHODCALLTYPE *BeginQuery )( 
+            ID3D12VideoDecodeCommandList1 * This,
+            _In_  ID3D12QueryHeap *pQueryHeap,
+            _In_  D3D12_QUERY_TYPE Type,
+            _In_  UINT Index);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoDecodeCommandList, EndQuery)
+        void ( STDMETHODCALLTYPE *EndQuery )( 
+            ID3D12VideoDecodeCommandList1 * This,
+            _In_  ID3D12QueryHeap *pQueryHeap,
+            _In_  D3D12_QUERY_TYPE Type,
+            _In_  UINT Index);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoDecodeCommandList, ResolveQueryData)
+        void ( STDMETHODCALLTYPE *ResolveQueryData )( 
+            ID3D12VideoDecodeCommandList1 * This,
+            _In_  ID3D12QueryHeap *pQueryHeap,
+            _In_  D3D12_QUERY_TYPE Type,
+            _In_  UINT StartIndex,
+            _In_  UINT NumQueries,
+            _In_  ID3D12Resource *pDestinationBuffer,
+            _In_  UINT64 AlignedDestinationBufferOffset);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoDecodeCommandList, SetPredication)
+        void ( STDMETHODCALLTYPE *SetPredication )( 
+            ID3D12VideoDecodeCommandList1 * This,
+            _In_opt_  ID3D12Resource *pBuffer,
+            _In_  UINT64 AlignedBufferOffset,
+            _In_  D3D12_PREDICATION_OP Operation);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoDecodeCommandList, SetMarker)
+        void ( STDMETHODCALLTYPE *SetMarker )( 
+            ID3D12VideoDecodeCommandList1 * This,
+            UINT Metadata,
+            _In_reads_bytes_opt_(Size)  const void *pData,
+            UINT Size);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoDecodeCommandList, BeginEvent)
+        void ( STDMETHODCALLTYPE *BeginEvent )( 
+            ID3D12VideoDecodeCommandList1 * This,
+            UINT Metadata,
+            _In_reads_bytes_opt_(Size)  const void *pData,
+            UINT Size);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoDecodeCommandList, EndEvent)
+        void ( STDMETHODCALLTYPE *EndEvent )( 
+            ID3D12VideoDecodeCommandList1 * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoDecodeCommandList, DecodeFrame)
+        void ( STDMETHODCALLTYPE *DecodeFrame )( 
+            ID3D12VideoDecodeCommandList1 * This,
+            _In_  ID3D12VideoDecoder *pDecoder,
+            _In_  const D3D12_VIDEO_DECODE_OUTPUT_STREAM_ARGUMENTS *pOutputArguments,
+            _In_  const D3D12_VIDEO_DECODE_INPUT_STREAM_ARGUMENTS *pInputArguments);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoDecodeCommandList, WriteBufferImmediate)
+        void ( STDMETHODCALLTYPE *WriteBufferImmediate )( 
+            ID3D12VideoDecodeCommandList1 * This,
+            UINT Count,
+            _In_reads_(Count)  const D3D12_WRITEBUFFERIMMEDIATE_PARAMETER *pParams,
+            _In_reads_opt_(Count)  const D3D12_WRITEBUFFERIMMEDIATE_MODE *pModes);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoDecodeCommandList1, DecodeFrame1)
+        void ( STDMETHODCALLTYPE *DecodeFrame1 )( 
+            ID3D12VideoDecodeCommandList1 * This,
+            _In_  ID3D12VideoDecoder *pDecoder,
+            _In_  const D3D12_VIDEO_DECODE_OUTPUT_STREAM_ARGUMENTS1 *pOutputArguments,
+            _In_  const D3D12_VIDEO_DECODE_INPUT_STREAM_ARGUMENTS *pInputArguments);
+        
+        END_INTERFACE
+    } ID3D12VideoDecodeCommandList1Vtbl;
+
+    interface ID3D12VideoDecodeCommandList1
+    {
+        CONST_VTBL struct ID3D12VideoDecodeCommandList1Vtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define ID3D12VideoDecodeCommandList1_QueryInterface(This,riid,ppvObject)	\
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define ID3D12VideoDecodeCommandList1_AddRef(This)	\
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define ID3D12VideoDecodeCommandList1_Release(This)	\
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#define ID3D12VideoDecodeCommandList1_GetPrivateData(This,guid,pDataSize,pData)	\
+    ( (This)->lpVtbl -> GetPrivateData(This,guid,pDataSize,pData) ) 
+
+#define ID3D12VideoDecodeCommandList1_SetPrivateData(This,guid,DataSize,pData)	\
+    ( (This)->lpVtbl -> SetPrivateData(This,guid,DataSize,pData) ) 
+
+#define ID3D12VideoDecodeCommandList1_SetPrivateDataInterface(This,guid,pData)	\
+    ( (This)->lpVtbl -> SetPrivateDataInterface(This,guid,pData) ) 
+
+#define ID3D12VideoDecodeCommandList1_SetName(This,Name)	\
+    ( (This)->lpVtbl -> SetName(This,Name) ) 
+
+
+#define ID3D12VideoDecodeCommandList1_GetDevice(This,riid,ppvDevice)	\
+    ( (This)->lpVtbl -> GetDevice(This,riid,ppvDevice) ) 
+
+
+#define ID3D12VideoDecodeCommandList1_GetType(This)	\
+    ( (This)->lpVtbl -> GetType(This) ) 
+
+
+#define ID3D12VideoDecodeCommandList1_Close(This)	\
+    ( (This)->lpVtbl -> Close(This) ) 
+
+#define ID3D12VideoDecodeCommandList1_Reset(This,pAllocator)	\
+    ( (This)->lpVtbl -> Reset(This,pAllocator) ) 
+
+#define ID3D12VideoDecodeCommandList1_ClearState(This)	\
+    ( (This)->lpVtbl -> ClearState(This) ) 
+
+#define ID3D12VideoDecodeCommandList1_ResourceBarrier(This,NumBarriers,pBarriers)	\
+    ( (This)->lpVtbl -> ResourceBarrier(This,NumBarriers,pBarriers) ) 
+
+#define ID3D12VideoDecodeCommandList1_DiscardResource(This,pResource,pRegion)	\
+    ( (This)->lpVtbl -> DiscardResource(This,pResource,pRegion) ) 
+
+#define ID3D12VideoDecodeCommandList1_BeginQuery(This,pQueryHeap,Type,Index)	\
+    ( (This)->lpVtbl -> BeginQuery(This,pQueryHeap,Type,Index) ) 
+
+#define ID3D12VideoDecodeCommandList1_EndQuery(This,pQueryHeap,Type,Index)	\
+    ( (This)->lpVtbl -> EndQuery(This,pQueryHeap,Type,Index) ) 
+
+#define ID3D12VideoDecodeCommandList1_ResolveQueryData(This,pQueryHeap,Type,StartIndex,NumQueries,pDestinationBuffer,AlignedDestinationBufferOffset)	\
+    ( (This)->lpVtbl -> ResolveQueryData(This,pQueryHeap,Type,StartIndex,NumQueries,pDestinationBuffer,AlignedDestinationBufferOffset) ) 
+
+#define ID3D12VideoDecodeCommandList1_SetPredication(This,pBuffer,AlignedBufferOffset,Operation)	\
+    ( (This)->lpVtbl -> SetPredication(This,pBuffer,AlignedBufferOffset,Operation) ) 
+
+#define ID3D12VideoDecodeCommandList1_SetMarker(This,Metadata,pData,Size)	\
+    ( (This)->lpVtbl -> SetMarker(This,Metadata,pData,Size) ) 
+
+#define ID3D12VideoDecodeCommandList1_BeginEvent(This,Metadata,pData,Size)	\
+    ( (This)->lpVtbl -> BeginEvent(This,Metadata,pData,Size) ) 
+
+#define ID3D12VideoDecodeCommandList1_EndEvent(This)	\
+    ( (This)->lpVtbl -> EndEvent(This) ) 
+
+#define ID3D12VideoDecodeCommandList1_DecodeFrame(This,pDecoder,pOutputArguments,pInputArguments)	\
+    ( (This)->lpVtbl -> DecodeFrame(This,pDecoder,pOutputArguments,pInputArguments) ) 
+
+#define ID3D12VideoDecodeCommandList1_WriteBufferImmediate(This,Count,pParams,pModes)	\
+    ( (This)->lpVtbl -> WriteBufferImmediate(This,Count,pParams,pModes) ) 
+
+
+#define ID3D12VideoDecodeCommandList1_DecodeFrame1(This,pDecoder,pOutputArguments,pInputArguments)	\
+    ( (This)->lpVtbl -> DecodeFrame1(This,pDecoder,pOutputArguments,pInputArguments) ) 
+
+#endif /* COBJMACROS */
+
+
+#endif 	/* C style interface */
+
+
+
+
+#endif 	/* __ID3D12VideoDecodeCommandList1_INTERFACE_DEFINED__ */
+
+
+/* interface __MIDL_itf_d3d12video_0000_0007 */
+/* [local] */ 
+
+typedef struct D3D12_VIDEO_PROCESS_INPUT_STREAM_ARGUMENTS1
+    {
+    D3D12_VIDEO_PROCESS_INPUT_STREAM InputStream[ 2 ];
+    D3D12_VIDEO_PROCESS_TRANSFORM Transform;
+    D3D12_VIDEO_PROCESS_INPUT_STREAM_FLAGS Flags;
+    D3D12_VIDEO_PROCESS_INPUT_STREAM_RATE RateInfo;
+    INT FilterLevels[ 32 ];
+    D3D12_VIDEO_PROCESS_ALPHA_BLENDING AlphaBlending;
+    D3D12_VIDEO_FIELD_TYPE FieldType;
+    } 	D3D12_VIDEO_PROCESS_INPUT_STREAM_ARGUMENTS1;
+
+
+
+extern RPC_IF_HANDLE __MIDL_itf_d3d12video_0000_0007_v0_0_c_ifspec;
+extern RPC_IF_HANDLE __MIDL_itf_d3d12video_0000_0007_v0_0_s_ifspec;
+
+#ifndef __ID3D12VideoProcessCommandList1_INTERFACE_DEFINED__
+#define __ID3D12VideoProcessCommandList1_INTERFACE_DEFINED__
+
+/* interface ID3D12VideoProcessCommandList1 */
+/* [unique][local][object][uuid] */ 
+
+
+EXTERN_C const IID IID_ID3D12VideoProcessCommandList1;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("542C5C4D-7596-434F-8C93-4EFA6766F267")
+    ID3D12VideoProcessCommandList1 : public ID3D12VideoProcessCommandList
+    {
+    public:
+        virtual void STDMETHODCALLTYPE ProcessFrames1( 
+            _In_  ID3D12VideoProcessor *pVideoProcessor,
+            _In_  const D3D12_VIDEO_PROCESS_OUTPUT_STREAM_ARGUMENTS *pOutputArguments,
+            UINT NumInputStreams,
+            _In_reads_(NumInputStreams)  const D3D12_VIDEO_PROCESS_INPUT_STREAM_ARGUMENTS1 *pInputArguments) = 0;
+        
+    };
+    
+    
+#else 	/* C style interface */
+
+    typedef struct ID3D12VideoProcessCommandList1Vtbl
+    {
+        BEGIN_INTERFACE
+        
+        DECLSPEC_XFGVIRT(IUnknown, QueryInterface)
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            ID3D12VideoProcessCommandList1 * This,
+            REFIID riid,
+            _COM_Outptr_  void **ppvObject);
+        
+        DECLSPEC_XFGVIRT(IUnknown, AddRef)
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            ID3D12VideoProcessCommandList1 * This);
+        
+        DECLSPEC_XFGVIRT(IUnknown, Release)
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            ID3D12VideoProcessCommandList1 * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, GetPrivateData)
+        HRESULT ( STDMETHODCALLTYPE *GetPrivateData )( 
+            ID3D12VideoProcessCommandList1 * This,
+            _In_  REFGUID guid,
+            _Inout_  UINT *pDataSize,
+            _Out_writes_bytes_opt_( *pDataSize )  void *pData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, SetPrivateData)
+        HRESULT ( STDMETHODCALLTYPE *SetPrivateData )( 
+            ID3D12VideoProcessCommandList1 * This,
+            _In_  REFGUID guid,
+            _In_  UINT DataSize,
+            _In_reads_bytes_opt_( DataSize )  const void *pData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, SetPrivateDataInterface)
+        HRESULT ( STDMETHODCALLTYPE *SetPrivateDataInterface )( 
+            ID3D12VideoProcessCommandList1 * This,
+            _In_  REFGUID guid,
+            _In_opt_  const IUnknown *pData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, SetName)
+        HRESULT ( STDMETHODCALLTYPE *SetName )( 
+            ID3D12VideoProcessCommandList1 * This,
+            _In_z_  LPCWSTR Name);
+        
+        DECLSPEC_XFGVIRT(ID3D12DeviceChild, GetDevice)
+        HRESULT ( STDMETHODCALLTYPE *GetDevice )( 
+            ID3D12VideoProcessCommandList1 * This,
+            REFIID riid,
+            _COM_Outptr_opt_  void **ppvDevice);
+        
+        DECLSPEC_XFGVIRT(ID3D12CommandList, GetType)
+        D3D12_COMMAND_LIST_TYPE ( STDMETHODCALLTYPE *GetType )( 
+            ID3D12VideoProcessCommandList1 * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoProcessCommandList, Close)
+        HRESULT ( STDMETHODCALLTYPE *Close )( 
+            ID3D12VideoProcessCommandList1 * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoProcessCommandList, Reset)
+        HRESULT ( STDMETHODCALLTYPE *Reset )( 
+            ID3D12VideoProcessCommandList1 * This,
+            _In_  ID3D12CommandAllocator *pAllocator);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoProcessCommandList, ClearState)
+        void ( STDMETHODCALLTYPE *ClearState )( 
+            ID3D12VideoProcessCommandList1 * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoProcessCommandList, ResourceBarrier)
+        void ( STDMETHODCALLTYPE *ResourceBarrier )( 
+            ID3D12VideoProcessCommandList1 * This,
+            _In_  UINT NumBarriers,
+            _In_reads_(NumBarriers)  const D3D12_RESOURCE_BARRIER *pBarriers);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoProcessCommandList, DiscardResource)
+        void ( STDMETHODCALLTYPE *DiscardResource )( 
+            ID3D12VideoProcessCommandList1 * This,
+            _In_  ID3D12Resource *pResource,
+            _In_opt_  const D3D12_DISCARD_REGION *pRegion);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoProcessCommandList, BeginQuery)
+        void ( STDMETHODCALLTYPE *BeginQuery )( 
+            ID3D12VideoProcessCommandList1 * This,
+            _In_  ID3D12QueryHeap *pQueryHeap,
+            _In_  D3D12_QUERY_TYPE Type,
+            _In_  UINT Index);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoProcessCommandList, EndQuery)
+        void ( STDMETHODCALLTYPE *EndQuery )( 
+            ID3D12VideoProcessCommandList1 * This,
+            _In_  ID3D12QueryHeap *pQueryHeap,
+            _In_  D3D12_QUERY_TYPE Type,
+            _In_  UINT Index);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoProcessCommandList, ResolveQueryData)
+        void ( STDMETHODCALLTYPE *ResolveQueryData )( 
+            ID3D12VideoProcessCommandList1 * This,
+            _In_  ID3D12QueryHeap *pQueryHeap,
+            _In_  D3D12_QUERY_TYPE Type,
+            _In_  UINT StartIndex,
+            _In_  UINT NumQueries,
+            _In_  ID3D12Resource *pDestinationBuffer,
+            _In_  UINT64 AlignedDestinationBufferOffset);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoProcessCommandList, SetPredication)
+        void ( STDMETHODCALLTYPE *SetPredication )( 
+            ID3D12VideoProcessCommandList1 * This,
+            _In_opt_  ID3D12Resource *pBuffer,
+            _In_  UINT64 AlignedBufferOffset,
+            _In_  D3D12_PREDICATION_OP Operation);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoProcessCommandList, SetMarker)
+        void ( STDMETHODCALLTYPE *SetMarker )( 
+            ID3D12VideoProcessCommandList1 * This,
+            UINT Metadata,
+            _In_reads_bytes_opt_(Size)  const void *pData,
+            UINT Size);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoProcessCommandList, BeginEvent)
+        void ( STDMETHODCALLTYPE *BeginEvent )( 
+            ID3D12VideoProcessCommandList1 * This,
+            UINT Metadata,
+            _In_reads_bytes_opt_(Size)  const void *pData,
+            UINT Size);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoProcessCommandList, EndEvent)
+        void ( STDMETHODCALLTYPE *EndEvent )( 
+            ID3D12VideoProcessCommandList1 * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoProcessCommandList, ProcessFrames)
+        void ( STDMETHODCALLTYPE *ProcessFrames )( 
+            ID3D12VideoProcessCommandList1 * This,
+            _In_  ID3D12VideoProcessor *pVideoProcessor,
+            _In_  const D3D12_VIDEO_PROCESS_OUTPUT_STREAM_ARGUMENTS *pOutputArguments,
+            UINT NumInputStreams,
+            _In_reads_(NumInputStreams)  const D3D12_VIDEO_PROCESS_INPUT_STREAM_ARGUMENTS *pInputArguments);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoProcessCommandList, WriteBufferImmediate)
+        void ( STDMETHODCALLTYPE *WriteBufferImmediate )( 
+            ID3D12VideoProcessCommandList1 * This,
+            UINT Count,
+            _In_reads_(Count)  const D3D12_WRITEBUFFERIMMEDIATE_PARAMETER *pParams,
+            _In_reads_opt_(Count)  const D3D12_WRITEBUFFERIMMEDIATE_MODE *pModes);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoProcessCommandList1, ProcessFrames1)
+        void ( STDMETHODCALLTYPE *ProcessFrames1 )( 
+            ID3D12VideoProcessCommandList1 * This,
+            _In_  ID3D12VideoProcessor *pVideoProcessor,
+            _In_  const D3D12_VIDEO_PROCESS_OUTPUT_STREAM_ARGUMENTS *pOutputArguments,
+            UINT NumInputStreams,
+            _In_reads_(NumInputStreams)  const D3D12_VIDEO_PROCESS_INPUT_STREAM_ARGUMENTS1 *pInputArguments);
+        
+        END_INTERFACE
+    } ID3D12VideoProcessCommandList1Vtbl;
+
+    interface ID3D12VideoProcessCommandList1
+    {
+        CONST_VTBL struct ID3D12VideoProcessCommandList1Vtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define ID3D12VideoProcessCommandList1_QueryInterface(This,riid,ppvObject)	\
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define ID3D12VideoProcessCommandList1_AddRef(This)	\
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define ID3D12VideoProcessCommandList1_Release(This)	\
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#define ID3D12VideoProcessCommandList1_GetPrivateData(This,guid,pDataSize,pData)	\
+    ( (This)->lpVtbl -> GetPrivateData(This,guid,pDataSize,pData) ) 
+
+#define ID3D12VideoProcessCommandList1_SetPrivateData(This,guid,DataSize,pData)	\
+    ( (This)->lpVtbl -> SetPrivateData(This,guid,DataSize,pData) ) 
+
+#define ID3D12VideoProcessCommandList1_SetPrivateDataInterface(This,guid,pData)	\
+    ( (This)->lpVtbl -> SetPrivateDataInterface(This,guid,pData) ) 
+
+#define ID3D12VideoProcessCommandList1_SetName(This,Name)	\
+    ( (This)->lpVtbl -> SetName(This,Name) ) 
+
+
+#define ID3D12VideoProcessCommandList1_GetDevice(This,riid,ppvDevice)	\
+    ( (This)->lpVtbl -> GetDevice(This,riid,ppvDevice) ) 
+
+
+#define ID3D12VideoProcessCommandList1_GetType(This)	\
+    ( (This)->lpVtbl -> GetType(This) ) 
+
+
+#define ID3D12VideoProcessCommandList1_Close(This)	\
+    ( (This)->lpVtbl -> Close(This) ) 
+
+#define ID3D12VideoProcessCommandList1_Reset(This,pAllocator)	\
+    ( (This)->lpVtbl -> Reset(This,pAllocator) ) 
+
+#define ID3D12VideoProcessCommandList1_ClearState(This)	\
+    ( (This)->lpVtbl -> ClearState(This) ) 
+
+#define ID3D12VideoProcessCommandList1_ResourceBarrier(This,NumBarriers,pBarriers)	\
+    ( (This)->lpVtbl -> ResourceBarrier(This,NumBarriers,pBarriers) ) 
+
+#define ID3D12VideoProcessCommandList1_DiscardResource(This,pResource,pRegion)	\
+    ( (This)->lpVtbl -> DiscardResource(This,pResource,pRegion) ) 
+
+#define ID3D12VideoProcessCommandList1_BeginQuery(This,pQueryHeap,Type,Index)	\
+    ( (This)->lpVtbl -> BeginQuery(This,pQueryHeap,Type,Index) ) 
+
+#define ID3D12VideoProcessCommandList1_EndQuery(This,pQueryHeap,Type,Index)	\
+    ( (This)->lpVtbl -> EndQuery(This,pQueryHeap,Type,Index) ) 
+
+#define ID3D12VideoProcessCommandList1_ResolveQueryData(This,pQueryHeap,Type,StartIndex,NumQueries,pDestinationBuffer,AlignedDestinationBufferOffset)	\
+    ( (This)->lpVtbl -> ResolveQueryData(This,pQueryHeap,Type,StartIndex,NumQueries,pDestinationBuffer,AlignedDestinationBufferOffset) ) 
+
+#define ID3D12VideoProcessCommandList1_SetPredication(This,pBuffer,AlignedBufferOffset,Operation)	\
+    ( (This)->lpVtbl -> SetPredication(This,pBuffer,AlignedBufferOffset,Operation) ) 
+
+#define ID3D12VideoProcessCommandList1_SetMarker(This,Metadata,pData,Size)	\
+    ( (This)->lpVtbl -> SetMarker(This,Metadata,pData,Size) ) 
+
+#define ID3D12VideoProcessCommandList1_BeginEvent(This,Metadata,pData,Size)	\
+    ( (This)->lpVtbl -> BeginEvent(This,Metadata,pData,Size) ) 
+
+#define ID3D12VideoProcessCommandList1_EndEvent(This)	\
+    ( (This)->lpVtbl -> EndEvent(This) ) 
+
+#define ID3D12VideoProcessCommandList1_ProcessFrames(This,pVideoProcessor,pOutputArguments,NumInputStreams,pInputArguments)	\
+    ( (This)->lpVtbl -> ProcessFrames(This,pVideoProcessor,pOutputArguments,NumInputStreams,pInputArguments) ) 
+
+#define ID3D12VideoProcessCommandList1_WriteBufferImmediate(This,Count,pParams,pModes)	\
+    ( (This)->lpVtbl -> WriteBufferImmediate(This,Count,pParams,pModes) ) 
+
+
+#define ID3D12VideoProcessCommandList1_ProcessFrames1(This,pVideoProcessor,pOutputArguments,NumInputStreams,pInputArguments)	\
+    ( (This)->lpVtbl -> ProcessFrames1(This,pVideoProcessor,pOutputArguments,NumInputStreams,pInputArguments) ) 
+
+#endif /* COBJMACROS */
+
+
+#endif 	/* C style interface */
+
+
+
+
+#endif 	/* __ID3D12VideoProcessCommandList1_INTERFACE_DEFINED__ */
+
+
+/* interface __MIDL_itf_d3d12video_0000_0008 */
+/* [local] */ 
+
+typedef 
+enum D3D12_VIDEO_MOTION_ESTIMATOR_SEARCH_BLOCK_SIZE
+    {
+        D3D12_VIDEO_MOTION_ESTIMATOR_SEARCH_BLOCK_SIZE_8X8	= 0,
+        D3D12_VIDEO_MOTION_ESTIMATOR_SEARCH_BLOCK_SIZE_16X16	= 1
+    } 	D3D12_VIDEO_MOTION_ESTIMATOR_SEARCH_BLOCK_SIZE;
+
+typedef 
+enum D3D12_VIDEO_MOTION_ESTIMATOR_SEARCH_BLOCK_SIZE_FLAGS
+    {
+        D3D12_VIDEO_MOTION_ESTIMATOR_SEARCH_BLOCK_SIZE_FLAG_NONE	= 0,
+        D3D12_VIDEO_MOTION_ESTIMATOR_SEARCH_BLOCK_SIZE_FLAG_8X8	= ( 1 << D3D12_VIDEO_MOTION_ESTIMATOR_SEARCH_BLOCK_SIZE_8X8 ) ,
+        D3D12_VIDEO_MOTION_ESTIMATOR_SEARCH_BLOCK_SIZE_FLAG_16X16	= ( 1 << D3D12_VIDEO_MOTION_ESTIMATOR_SEARCH_BLOCK_SIZE_16X16 ) 
+    } 	D3D12_VIDEO_MOTION_ESTIMATOR_SEARCH_BLOCK_SIZE_FLAGS;
+
+DEFINE_ENUM_FLAG_OPERATORS( D3D12_VIDEO_MOTION_ESTIMATOR_SEARCH_BLOCK_SIZE_FLAGS );
+typedef 
+enum D3D12_VIDEO_MOTION_ESTIMATOR_VECTOR_PRECISION
+    {
+        D3D12_VIDEO_MOTION_ESTIMATOR_VECTOR_PRECISION_QUARTER_PEL	= 0
+    } 	D3D12_VIDEO_MOTION_ESTIMATOR_VECTOR_PRECISION;
+
+typedef 
+enum D3D12_VIDEO_MOTION_ESTIMATOR_VECTOR_PRECISION_FLAGS
+    {
+        D3D12_VIDEO_MOTION_ESTIMATOR_VECTOR_PRECISION_FLAG_NONE	= 0,
+        D3D12_VIDEO_MOTION_ESTIMATOR_VECTOR_PRECISION_FLAG_QUARTER_PEL	= ( 1 << D3D12_VIDEO_MOTION_ESTIMATOR_VECTOR_PRECISION_QUARTER_PEL ) 
+    } 	D3D12_VIDEO_MOTION_ESTIMATOR_VECTOR_PRECISION_FLAGS;
+
+DEFINE_ENUM_FLAG_OPERATORS( D3D12_VIDEO_MOTION_ESTIMATOR_VECTOR_PRECISION_FLAGS );
+typedef struct D3D12_FEATURE_DATA_VIDEO_FEATURE_AREA_SUPPORT
+    {
+    UINT NodeIndex;
+    BOOL VideoDecodeSupport;
+    BOOL VideoProcessSupport;
+    BOOL VideoEncodeSupport;
+    } 	D3D12_FEATURE_DATA_VIDEO_FEATURE_AREA_SUPPORT;
+
+typedef struct D3D12_FEATURE_DATA_VIDEO_MOTION_ESTIMATOR
+    {
+    UINT NodeIndex;
+    DXGI_FORMAT InputFormat;
+    D3D12_VIDEO_MOTION_ESTIMATOR_SEARCH_BLOCK_SIZE_FLAGS BlockSizeFlags;
+    D3D12_VIDEO_MOTION_ESTIMATOR_VECTOR_PRECISION_FLAGS PrecisionFlags;
+    D3D12_VIDEO_SIZE_RANGE SizeRange;
+    } 	D3D12_FEATURE_DATA_VIDEO_MOTION_ESTIMATOR;
+
+typedef struct D3D12_FEATURE_DATA_VIDEO_MOTION_ESTIMATOR_SIZE
+    {
+    UINT NodeIndex;
+    DXGI_FORMAT InputFormat;
+    D3D12_VIDEO_MOTION_ESTIMATOR_SEARCH_BLOCK_SIZE BlockSize;
+    D3D12_VIDEO_MOTION_ESTIMATOR_VECTOR_PRECISION Precision;
+    D3D12_VIDEO_SIZE_RANGE SizeRange;
+    BOOL Protected;
+    UINT64 MotionVectorHeapMemoryPoolL0Size;
+    UINT64 MotionVectorHeapMemoryPoolL1Size;
+    UINT64 MotionEstimatorMemoryPoolL0Size;
+    UINT64 MotionEstimatorMemoryPoolL1Size;
+    } 	D3D12_FEATURE_DATA_VIDEO_MOTION_ESTIMATOR_SIZE;
+
+typedef struct D3D12_VIDEO_MOTION_ESTIMATOR_DESC
+    {
+    UINT NodeMask;
+    DXGI_FORMAT InputFormat;
+    D3D12_VIDEO_MOTION_ESTIMATOR_SEARCH_BLOCK_SIZE BlockSize;
+    D3D12_VIDEO_MOTION_ESTIMATOR_VECTOR_PRECISION Precision;
+    D3D12_VIDEO_SIZE_RANGE SizeRange;
+    } 	D3D12_VIDEO_MOTION_ESTIMATOR_DESC;
+
+
+
+extern RPC_IF_HANDLE __MIDL_itf_d3d12video_0000_0008_v0_0_c_ifspec;
+extern RPC_IF_HANDLE __MIDL_itf_d3d12video_0000_0008_v0_0_s_ifspec;
+
+#ifndef __ID3D12VideoMotionEstimator_INTERFACE_DEFINED__
+#define __ID3D12VideoMotionEstimator_INTERFACE_DEFINED__
+
+/* interface ID3D12VideoMotionEstimator */
+/* [unique][local][object][uuid] */ 
+
+
+EXTERN_C const IID IID_ID3D12VideoMotionEstimator;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("33FDAE0E-098B-428F-87BB-34B695DE08F8")
+    ID3D12VideoMotionEstimator : public ID3D12Pageable
+    {
+    public:
+#if defined(_MSC_VER) || !defined(_WIN32)
+        virtual D3D12_VIDEO_MOTION_ESTIMATOR_DESC STDMETHODCALLTYPE GetDesc( void) = 0;
+#else
+        virtual D3D12_VIDEO_MOTION_ESTIMATOR_DESC *STDMETHODCALLTYPE GetDesc( 
+            D3D12_VIDEO_MOTION_ESTIMATOR_DESC * RetVal) = 0;
+#endif
+        
+        virtual HRESULT STDMETHODCALLTYPE GetProtectedResourceSession( 
+            REFIID riid,
+            _COM_Outptr_opt_  void **ppProtectedSession) = 0;
+        
+    };
+    
+    
+#else 	/* C style interface */
+
+    typedef struct ID3D12VideoMotionEstimatorVtbl
+    {
+        BEGIN_INTERFACE
+        
+        DECLSPEC_XFGVIRT(IUnknown, QueryInterface)
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            ID3D12VideoMotionEstimator * This,
+            REFIID riid,
+            _COM_Outptr_  void **ppvObject);
+        
+        DECLSPEC_XFGVIRT(IUnknown, AddRef)
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            ID3D12VideoMotionEstimator * This);
+        
+        DECLSPEC_XFGVIRT(IUnknown, Release)
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            ID3D12VideoMotionEstimator * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, GetPrivateData)
+        HRESULT ( STDMETHODCALLTYPE *GetPrivateData )( 
+            ID3D12VideoMotionEstimator * This,
+            _In_  REFGUID guid,
+            _Inout_  UINT *pDataSize,
+            _Out_writes_bytes_opt_( *pDataSize )  void *pData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, SetPrivateData)
+        HRESULT ( STDMETHODCALLTYPE *SetPrivateData )( 
+            ID3D12VideoMotionEstimator * This,
+            _In_  REFGUID guid,
+            _In_  UINT DataSize,
+            _In_reads_bytes_opt_( DataSize )  const void *pData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, SetPrivateDataInterface)
+        HRESULT ( STDMETHODCALLTYPE *SetPrivateDataInterface )( 
+            ID3D12VideoMotionEstimator * This,
+            _In_  REFGUID guid,
+            _In_opt_  const IUnknown *pData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, SetName)
+        HRESULT ( STDMETHODCALLTYPE *SetName )( 
+            ID3D12VideoMotionEstimator * This,
+            _In_z_  LPCWSTR Name);
+        
+        DECLSPEC_XFGVIRT(ID3D12DeviceChild, GetDevice)
+        HRESULT ( STDMETHODCALLTYPE *GetDevice )( 
+            ID3D12VideoMotionEstimator * This,
+            REFIID riid,
+            _COM_Outptr_opt_  void **ppvDevice);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoMotionEstimator, GetDesc)
+#if !defined(_WIN32)
+        D3D12_VIDEO_MOTION_ESTIMATOR_DESC ( STDMETHODCALLTYPE *GetDesc )( 
+            ID3D12VideoMotionEstimator * This);
+        
+#else
+        D3D12_VIDEO_MOTION_ESTIMATOR_DESC *( STDMETHODCALLTYPE *GetDesc )( 
+            ID3D12VideoMotionEstimator * This,
+            D3D12_VIDEO_MOTION_ESTIMATOR_DESC * RetVal);
+        
+#endif
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoMotionEstimator, GetProtectedResourceSession)
+        HRESULT ( STDMETHODCALLTYPE *GetProtectedResourceSession )( 
+            ID3D12VideoMotionEstimator * This,
+            REFIID riid,
+            _COM_Outptr_opt_  void **ppProtectedSession);
+        
+        END_INTERFACE
+    } ID3D12VideoMotionEstimatorVtbl;
+
+    interface ID3D12VideoMotionEstimator
+    {
+        CONST_VTBL struct ID3D12VideoMotionEstimatorVtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define ID3D12VideoMotionEstimator_QueryInterface(This,riid,ppvObject)	\
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define ID3D12VideoMotionEstimator_AddRef(This)	\
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define ID3D12VideoMotionEstimator_Release(This)	\
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#define ID3D12VideoMotionEstimator_GetPrivateData(This,guid,pDataSize,pData)	\
+    ( (This)->lpVtbl -> GetPrivateData(This,guid,pDataSize,pData) ) 
+
+#define ID3D12VideoMotionEstimator_SetPrivateData(This,guid,DataSize,pData)	\
+    ( (This)->lpVtbl -> SetPrivateData(This,guid,DataSize,pData) ) 
+
+#define ID3D12VideoMotionEstimator_SetPrivateDataInterface(This,guid,pData)	\
+    ( (This)->lpVtbl -> SetPrivateDataInterface(This,guid,pData) ) 
+
+#define ID3D12VideoMotionEstimator_SetName(This,Name)	\
+    ( (This)->lpVtbl -> SetName(This,Name) ) 
+
+
+#define ID3D12VideoMotionEstimator_GetDevice(This,riid,ppvDevice)	\
+    ( (This)->lpVtbl -> GetDevice(This,riid,ppvDevice) ) 
+
+
+#if !defined(_WIN32)
+
+#define ID3D12VideoMotionEstimator_GetDesc(This)	\
+    ( (This)->lpVtbl -> GetDesc(This) ) 
+#else
+#define ID3D12VideoMotionEstimator_GetDesc(This,RetVal)	\
+    ( (This)->lpVtbl -> GetDesc(This,RetVal) ) 
+#endif
+
+#define ID3D12VideoMotionEstimator_GetProtectedResourceSession(This,riid,ppProtectedSession)	\
+    ( (This)->lpVtbl -> GetProtectedResourceSession(This,riid,ppProtectedSession) ) 
+
+#endif /* COBJMACROS */
+
+
+#endif 	/* C style interface */
+
+
+
+
+#endif 	/* __ID3D12VideoMotionEstimator_INTERFACE_DEFINED__ */
+
+
+/* interface __MIDL_itf_d3d12video_0000_0009 */
+/* [local] */ 
+
+typedef struct D3D12_VIDEO_MOTION_VECTOR_HEAP_DESC
+    {
+    UINT NodeMask;
+    DXGI_FORMAT InputFormat;
+    D3D12_VIDEO_MOTION_ESTIMATOR_SEARCH_BLOCK_SIZE BlockSize;
+    D3D12_VIDEO_MOTION_ESTIMATOR_VECTOR_PRECISION Precision;
+    D3D12_VIDEO_SIZE_RANGE SizeRange;
+    } 	D3D12_VIDEO_MOTION_VECTOR_HEAP_DESC;
+
+
+
+extern RPC_IF_HANDLE __MIDL_itf_d3d12video_0000_0009_v0_0_c_ifspec;
+extern RPC_IF_HANDLE __MIDL_itf_d3d12video_0000_0009_v0_0_s_ifspec;
+
+#ifndef __ID3D12VideoMotionVectorHeap_INTERFACE_DEFINED__
+#define __ID3D12VideoMotionVectorHeap_INTERFACE_DEFINED__
+
+/* interface ID3D12VideoMotionVectorHeap */
+/* [unique][local][object][uuid] */ 
+
+
+EXTERN_C const IID IID_ID3D12VideoMotionVectorHeap;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("5BE17987-743A-4061-834B-23D22DAEA505")
+    ID3D12VideoMotionVectorHeap : public ID3D12Pageable
+    {
+    public:
+#if defined(_MSC_VER) || !defined(_WIN32)
+        virtual D3D12_VIDEO_MOTION_VECTOR_HEAP_DESC STDMETHODCALLTYPE GetDesc( void) = 0;
+#else
+        virtual D3D12_VIDEO_MOTION_VECTOR_HEAP_DESC *STDMETHODCALLTYPE GetDesc( 
+            D3D12_VIDEO_MOTION_VECTOR_HEAP_DESC * RetVal) = 0;
+#endif
+        
+        virtual HRESULT STDMETHODCALLTYPE GetProtectedResourceSession( 
+            REFIID riid,
+            _COM_Outptr_opt_  void **ppProtectedSession) = 0;
+        
+    };
+    
+    
+#else 	/* C style interface */
+
+    typedef struct ID3D12VideoMotionVectorHeapVtbl
+    {
+        BEGIN_INTERFACE
+        
+        DECLSPEC_XFGVIRT(IUnknown, QueryInterface)
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            ID3D12VideoMotionVectorHeap * This,
+            REFIID riid,
+            _COM_Outptr_  void **ppvObject);
+        
+        DECLSPEC_XFGVIRT(IUnknown, AddRef)
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            ID3D12VideoMotionVectorHeap * This);
+        
+        DECLSPEC_XFGVIRT(IUnknown, Release)
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            ID3D12VideoMotionVectorHeap * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, GetPrivateData)
+        HRESULT ( STDMETHODCALLTYPE *GetPrivateData )( 
+            ID3D12VideoMotionVectorHeap * This,
+            _In_  REFGUID guid,
+            _Inout_  UINT *pDataSize,
+            _Out_writes_bytes_opt_( *pDataSize )  void *pData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, SetPrivateData)
+        HRESULT ( STDMETHODCALLTYPE *SetPrivateData )( 
+            ID3D12VideoMotionVectorHeap * This,
+            _In_  REFGUID guid,
+            _In_  UINT DataSize,
+            _In_reads_bytes_opt_( DataSize )  const void *pData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, SetPrivateDataInterface)
+        HRESULT ( STDMETHODCALLTYPE *SetPrivateDataInterface )( 
+            ID3D12VideoMotionVectorHeap * This,
+            _In_  REFGUID guid,
+            _In_opt_  const IUnknown *pData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, SetName)
+        HRESULT ( STDMETHODCALLTYPE *SetName )( 
+            ID3D12VideoMotionVectorHeap * This,
+            _In_z_  LPCWSTR Name);
+        
+        DECLSPEC_XFGVIRT(ID3D12DeviceChild, GetDevice)
+        HRESULT ( STDMETHODCALLTYPE *GetDevice )( 
+            ID3D12VideoMotionVectorHeap * This,
+            REFIID riid,
+            _COM_Outptr_opt_  void **ppvDevice);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoMotionVectorHeap, GetDesc)
+#if !defined(_WIN32)
+        D3D12_VIDEO_MOTION_VECTOR_HEAP_DESC ( STDMETHODCALLTYPE *GetDesc )( 
+            ID3D12VideoMotionVectorHeap * This);
+        
+#else
+        D3D12_VIDEO_MOTION_VECTOR_HEAP_DESC *( STDMETHODCALLTYPE *GetDesc )( 
+            ID3D12VideoMotionVectorHeap * This,
+            D3D12_VIDEO_MOTION_VECTOR_HEAP_DESC * RetVal);
+        
+#endif
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoMotionVectorHeap, GetProtectedResourceSession)
+        HRESULT ( STDMETHODCALLTYPE *GetProtectedResourceSession )( 
+            ID3D12VideoMotionVectorHeap * This,
+            REFIID riid,
+            _COM_Outptr_opt_  void **ppProtectedSession);
+        
+        END_INTERFACE
+    } ID3D12VideoMotionVectorHeapVtbl;
+
+    interface ID3D12VideoMotionVectorHeap
+    {
+        CONST_VTBL struct ID3D12VideoMotionVectorHeapVtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define ID3D12VideoMotionVectorHeap_QueryInterface(This,riid,ppvObject)	\
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define ID3D12VideoMotionVectorHeap_AddRef(This)	\
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define ID3D12VideoMotionVectorHeap_Release(This)	\
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#define ID3D12VideoMotionVectorHeap_GetPrivateData(This,guid,pDataSize,pData)	\
+    ( (This)->lpVtbl -> GetPrivateData(This,guid,pDataSize,pData) ) 
+
+#define ID3D12VideoMotionVectorHeap_SetPrivateData(This,guid,DataSize,pData)	\
+    ( (This)->lpVtbl -> SetPrivateData(This,guid,DataSize,pData) ) 
+
+#define ID3D12VideoMotionVectorHeap_SetPrivateDataInterface(This,guid,pData)	\
+    ( (This)->lpVtbl -> SetPrivateDataInterface(This,guid,pData) ) 
+
+#define ID3D12VideoMotionVectorHeap_SetName(This,Name)	\
+    ( (This)->lpVtbl -> SetName(This,Name) ) 
+
+
+#define ID3D12VideoMotionVectorHeap_GetDevice(This,riid,ppvDevice)	\
+    ( (This)->lpVtbl -> GetDevice(This,riid,ppvDevice) ) 
+
+
+#if !defined(_WIN32)
+
+#define ID3D12VideoMotionVectorHeap_GetDesc(This)	\
+    ( (This)->lpVtbl -> GetDesc(This) ) 
+#else
+#define ID3D12VideoMotionVectorHeap_GetDesc(This,RetVal)	\
+    ( (This)->lpVtbl -> GetDesc(This,RetVal) ) 
+#endif
+
+#define ID3D12VideoMotionVectorHeap_GetProtectedResourceSession(This,riid,ppProtectedSession)	\
+    ( (This)->lpVtbl -> GetProtectedResourceSession(This,riid,ppProtectedSession) ) 
+
+#endif /* COBJMACROS */
+
+
+#endif 	/* C style interface */
+
+
+
+
+#endif 	/* __ID3D12VideoMotionVectorHeap_INTERFACE_DEFINED__ */
+
+
+#ifndef __ID3D12VideoDevice1_INTERFACE_DEFINED__
+#define __ID3D12VideoDevice1_INTERFACE_DEFINED__
+
+/* interface ID3D12VideoDevice1 */
+/* [unique][local][object][uuid] */ 
+
+
+EXTERN_C const IID IID_ID3D12VideoDevice1;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("981611AD-A144-4C83-9890-F30E26D658AB")
+    ID3D12VideoDevice1 : public ID3D12VideoDevice
+    {
+    public:
+        virtual HRESULT STDMETHODCALLTYPE CreateVideoMotionEstimator( 
+            _In_  const D3D12_VIDEO_MOTION_ESTIMATOR_DESC *pDesc,
+            _In_opt_  ID3D12ProtectedResourceSession *pProtectedResourceSession,
+            _In_  REFIID riid,
+            _COM_Outptr_  void **ppVideoMotionEstimator) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE CreateVideoMotionVectorHeap( 
+            _In_  const D3D12_VIDEO_MOTION_VECTOR_HEAP_DESC *pDesc,
+            _In_opt_  ID3D12ProtectedResourceSession *pProtectedResourceSession,
+            _In_  REFIID riid,
+            _COM_Outptr_  void **ppVideoMotionVectorHeap) = 0;
+        
+    };
+    
+    
+#else 	/* C style interface */
+
+    typedef struct ID3D12VideoDevice1Vtbl
+    {
+        BEGIN_INTERFACE
+        
+        DECLSPEC_XFGVIRT(IUnknown, QueryInterface)
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            ID3D12VideoDevice1 * This,
+            REFIID riid,
+            _COM_Outptr_  void **ppvObject);
+        
+        DECLSPEC_XFGVIRT(IUnknown, AddRef)
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            ID3D12VideoDevice1 * This);
+        
+        DECLSPEC_XFGVIRT(IUnknown, Release)
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            ID3D12VideoDevice1 * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoDevice, CheckFeatureSupport)
+        HRESULT ( STDMETHODCALLTYPE *CheckFeatureSupport )( 
+            ID3D12VideoDevice1 * This,
+            D3D12_FEATURE_VIDEO FeatureVideo,
+            _Inout_updates_bytes_(FeatureSupportDataSize)  void *pFeatureSupportData,
+            UINT FeatureSupportDataSize);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoDevice, CreateVideoDecoder)
+        HRESULT ( STDMETHODCALLTYPE *CreateVideoDecoder )( 
+            ID3D12VideoDevice1 * This,
+            _In_  const D3D12_VIDEO_DECODER_DESC *pDesc,
+            _In_  REFIID riid,
+            _COM_Outptr_  void **ppVideoDecoder);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoDevice, CreateVideoDecoderHeap)
+        HRESULT ( STDMETHODCALLTYPE *CreateVideoDecoderHeap )( 
+            ID3D12VideoDevice1 * This,
+            _In_  const D3D12_VIDEO_DECODER_HEAP_DESC *pVideoDecoderHeapDesc,
+            _In_  REFIID riid,
+            _COM_Outptr_  void **ppVideoDecoderHeap);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoDevice, CreateVideoProcessor)
+        HRESULT ( STDMETHODCALLTYPE *CreateVideoProcessor )( 
+            ID3D12VideoDevice1 * This,
+            UINT NodeMask,
+            _In_  const D3D12_VIDEO_PROCESS_OUTPUT_STREAM_DESC *pOutputStreamDesc,
+            UINT NumInputStreamDescs,
+            _In_reads_(NumInputStreamDescs)  const D3D12_VIDEO_PROCESS_INPUT_STREAM_DESC *pInputStreamDescs,
+            _In_  REFIID riid,
+            _COM_Outptr_  void **ppVideoProcessor);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoDevice1, CreateVideoMotionEstimator)
+        HRESULT ( STDMETHODCALLTYPE *CreateVideoMotionEstimator )( 
+            ID3D12VideoDevice1 * This,
+            _In_  const D3D12_VIDEO_MOTION_ESTIMATOR_DESC *pDesc,
+            _In_opt_  ID3D12ProtectedResourceSession *pProtectedResourceSession,
+            _In_  REFIID riid,
+            _COM_Outptr_  void **ppVideoMotionEstimator);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoDevice1, CreateVideoMotionVectorHeap)
+        HRESULT ( STDMETHODCALLTYPE *CreateVideoMotionVectorHeap )( 
+            ID3D12VideoDevice1 * This,
+            _In_  const D3D12_VIDEO_MOTION_VECTOR_HEAP_DESC *pDesc,
+            _In_opt_  ID3D12ProtectedResourceSession *pProtectedResourceSession,
+            _In_  REFIID riid,
+            _COM_Outptr_  void **ppVideoMotionVectorHeap);
+        
+        END_INTERFACE
+    } ID3D12VideoDevice1Vtbl;
+
+    interface ID3D12VideoDevice1
+    {
+        CONST_VTBL struct ID3D12VideoDevice1Vtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define ID3D12VideoDevice1_QueryInterface(This,riid,ppvObject)	\
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define ID3D12VideoDevice1_AddRef(This)	\
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define ID3D12VideoDevice1_Release(This)	\
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#define ID3D12VideoDevice1_CheckFeatureSupport(This,FeatureVideo,pFeatureSupportData,FeatureSupportDataSize)	\
+    ( (This)->lpVtbl -> CheckFeatureSupport(This,FeatureVideo,pFeatureSupportData,FeatureSupportDataSize) ) 
+
+#define ID3D12VideoDevice1_CreateVideoDecoder(This,pDesc,riid,ppVideoDecoder)	\
+    ( (This)->lpVtbl -> CreateVideoDecoder(This,pDesc,riid,ppVideoDecoder) ) 
+
+#define ID3D12VideoDevice1_CreateVideoDecoderHeap(This,pVideoDecoderHeapDesc,riid,ppVideoDecoderHeap)	\
+    ( (This)->lpVtbl -> CreateVideoDecoderHeap(This,pVideoDecoderHeapDesc,riid,ppVideoDecoderHeap) ) 
+
+#define ID3D12VideoDevice1_CreateVideoProcessor(This,NodeMask,pOutputStreamDesc,NumInputStreamDescs,pInputStreamDescs,riid,ppVideoProcessor)	\
+    ( (This)->lpVtbl -> CreateVideoProcessor(This,NodeMask,pOutputStreamDesc,NumInputStreamDescs,pInputStreamDescs,riid,ppVideoProcessor) ) 
+
+
+#define ID3D12VideoDevice1_CreateVideoMotionEstimator(This,pDesc,pProtectedResourceSession,riid,ppVideoMotionEstimator)	\
+    ( (This)->lpVtbl -> CreateVideoMotionEstimator(This,pDesc,pProtectedResourceSession,riid,ppVideoMotionEstimator) ) 
+
+#define ID3D12VideoDevice1_CreateVideoMotionVectorHeap(This,pDesc,pProtectedResourceSession,riid,ppVideoMotionVectorHeap)	\
+    ( (This)->lpVtbl -> CreateVideoMotionVectorHeap(This,pDesc,pProtectedResourceSession,riid,ppVideoMotionVectorHeap) ) 
+
+#endif /* COBJMACROS */
+
+
+#endif 	/* C style interface */
+
+
+
+
+#endif 	/* __ID3D12VideoDevice1_INTERFACE_DEFINED__ */
+
+
+/* interface __MIDL_itf_d3d12video_0000_0011 */
+/* [local] */ 
+
+typedef struct D3D12_RESOURCE_COORDINATE
+    {
+    UINT64 X;
+    UINT Y;
+    UINT Z;
+    UINT SubresourceIndex;
+    } 	D3D12_RESOURCE_COORDINATE;
+
+typedef struct D3D12_VIDEO_MOTION_ESTIMATOR_OUTPUT
+    {
+    ID3D12VideoMotionVectorHeap *pMotionVectorHeap;
+    } 	D3D12_VIDEO_MOTION_ESTIMATOR_OUTPUT;
+
+typedef struct D3D12_VIDEO_MOTION_ESTIMATOR_INPUT
+    {
+    ID3D12Resource *pInputTexture2D;
+    UINT InputSubresourceIndex;
+    ID3D12Resource *pReferenceTexture2D;
+    UINT ReferenceSubresourceIndex;
+    ID3D12VideoMotionVectorHeap *pHintMotionVectorHeap;
+    } 	D3D12_VIDEO_MOTION_ESTIMATOR_INPUT;
+
+typedef struct D3D12_RESOLVE_VIDEO_MOTION_VECTOR_HEAP_OUTPUT
+    {
+    ID3D12Resource *pMotionVectorTexture2D;
+    D3D12_RESOURCE_COORDINATE MotionVectorCoordinate;
+    } 	D3D12_RESOLVE_VIDEO_MOTION_VECTOR_HEAP_OUTPUT;
+
+typedef struct D3D12_RESOLVE_VIDEO_MOTION_VECTOR_HEAP_INPUT
+    {
+    ID3D12VideoMotionVectorHeap *pMotionVectorHeap;
+    UINT PixelWidth;
+    UINT PixelHeight;
+    } 	D3D12_RESOLVE_VIDEO_MOTION_VECTOR_HEAP_INPUT;
+
+
+
+extern RPC_IF_HANDLE __MIDL_itf_d3d12video_0000_0011_v0_0_c_ifspec;
+extern RPC_IF_HANDLE __MIDL_itf_d3d12video_0000_0011_v0_0_s_ifspec;
+
+#ifndef __ID3D12VideoEncodeCommandList_INTERFACE_DEFINED__
+#define __ID3D12VideoEncodeCommandList_INTERFACE_DEFINED__
+
+/* interface ID3D12VideoEncodeCommandList */
+/* [unique][local][object][uuid] */ 
+
+
+EXTERN_C const IID IID_ID3D12VideoEncodeCommandList;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("8455293A-0CBD-4831-9B39-FBDBAB724723")
+    ID3D12VideoEncodeCommandList : public ID3D12CommandList
+    {
+    public:
+        virtual HRESULT STDMETHODCALLTYPE Close( void) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE Reset( 
+            _In_  ID3D12CommandAllocator *pAllocator) = 0;
+        
+        virtual void STDMETHODCALLTYPE ClearState( void) = 0;
+        
+        virtual void STDMETHODCALLTYPE ResourceBarrier( 
+            _In_  UINT NumBarriers,
+            _In_reads_(NumBarriers)  const D3D12_RESOURCE_BARRIER *pBarriers) = 0;
+        
+        virtual void STDMETHODCALLTYPE DiscardResource( 
+            _In_  ID3D12Resource *pResource,
+            _In_opt_  const D3D12_DISCARD_REGION *pRegion) = 0;
+        
+        virtual void STDMETHODCALLTYPE BeginQuery( 
+            _In_  ID3D12QueryHeap *pQueryHeap,
+            _In_  D3D12_QUERY_TYPE Type,
+            _In_  UINT Index) = 0;
+        
+        virtual void STDMETHODCALLTYPE EndQuery( 
+            _In_  ID3D12QueryHeap *pQueryHeap,
+            _In_  D3D12_QUERY_TYPE Type,
+            _In_  UINT Index) = 0;
+        
+        virtual void STDMETHODCALLTYPE ResolveQueryData( 
+            _In_  ID3D12QueryHeap *pQueryHeap,
+            _In_  D3D12_QUERY_TYPE Type,
+            _In_  UINT StartIndex,
+            _In_  UINT NumQueries,
+            _In_  ID3D12Resource *pDestinationBuffer,
+            _In_  UINT64 AlignedDestinationBufferOffset) = 0;
+        
+        virtual void STDMETHODCALLTYPE SetPredication( 
+            _In_opt_  ID3D12Resource *pBuffer,
+            _In_  UINT64 AlignedBufferOffset,
+            _In_  D3D12_PREDICATION_OP Operation) = 0;
+        
+        virtual void STDMETHODCALLTYPE SetMarker( 
+            UINT Metadata,
+            _In_reads_bytes_opt_(Size)  const void *pData,
+            UINT Size) = 0;
+        
+        virtual void STDMETHODCALLTYPE BeginEvent( 
+            UINT Metadata,
+            _In_reads_bytes_opt_(Size)  const void *pData,
+            UINT Size) = 0;
+        
+        virtual void STDMETHODCALLTYPE EndEvent( void) = 0;
+        
+        virtual void STDMETHODCALLTYPE EstimateMotion( 
+            _In_  ID3D12VideoMotionEstimator *pMotionEstimator,
+            _In_  const D3D12_VIDEO_MOTION_ESTIMATOR_OUTPUT *pOutputArguments,
+            _In_  const D3D12_VIDEO_MOTION_ESTIMATOR_INPUT *pInputArguments) = 0;
+        
+        virtual void STDMETHODCALLTYPE ResolveMotionVectorHeap( 
+            const D3D12_RESOLVE_VIDEO_MOTION_VECTOR_HEAP_OUTPUT *pOutputArguments,
+            const D3D12_RESOLVE_VIDEO_MOTION_VECTOR_HEAP_INPUT *pInputArguments) = 0;
+        
+        virtual void STDMETHODCALLTYPE WriteBufferImmediate( 
+            UINT Count,
+            _In_reads_(Count)  const D3D12_WRITEBUFFERIMMEDIATE_PARAMETER *pParams,
+            _In_reads_opt_(Count)  const D3D12_WRITEBUFFERIMMEDIATE_MODE *pModes) = 0;
+        
+        virtual void STDMETHODCALLTYPE SetProtectedResourceSession( 
+            _In_opt_  ID3D12ProtectedResourceSession *pProtectedResourceSession) = 0;
+        
+    };
+    
+    
+#else 	/* C style interface */
+
+    typedef struct ID3D12VideoEncodeCommandListVtbl
+    {
+        BEGIN_INTERFACE
+        
+        DECLSPEC_XFGVIRT(IUnknown, QueryInterface)
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            ID3D12VideoEncodeCommandList * This,
+            REFIID riid,
+            _COM_Outptr_  void **ppvObject);
+        
+        DECLSPEC_XFGVIRT(IUnknown, AddRef)
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            ID3D12VideoEncodeCommandList * This);
+        
+        DECLSPEC_XFGVIRT(IUnknown, Release)
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            ID3D12VideoEncodeCommandList * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, GetPrivateData)
+        HRESULT ( STDMETHODCALLTYPE *GetPrivateData )( 
+            ID3D12VideoEncodeCommandList * This,
+            _In_  REFGUID guid,
+            _Inout_  UINT *pDataSize,
+            _Out_writes_bytes_opt_( *pDataSize )  void *pData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, SetPrivateData)
+        HRESULT ( STDMETHODCALLTYPE *SetPrivateData )( 
+            ID3D12VideoEncodeCommandList * This,
+            _In_  REFGUID guid,
+            _In_  UINT DataSize,
+            _In_reads_bytes_opt_( DataSize )  const void *pData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, SetPrivateDataInterface)
+        HRESULT ( STDMETHODCALLTYPE *SetPrivateDataInterface )( 
+            ID3D12VideoEncodeCommandList * This,
+            _In_  REFGUID guid,
+            _In_opt_  const IUnknown *pData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, SetName)
+        HRESULT ( STDMETHODCALLTYPE *SetName )( 
+            ID3D12VideoEncodeCommandList * This,
+            _In_z_  LPCWSTR Name);
+        
+        DECLSPEC_XFGVIRT(ID3D12DeviceChild, GetDevice)
+        HRESULT ( STDMETHODCALLTYPE *GetDevice )( 
+            ID3D12VideoEncodeCommandList * This,
+            REFIID riid,
+            _COM_Outptr_opt_  void **ppvDevice);
+        
+        DECLSPEC_XFGVIRT(ID3D12CommandList, GetType)
+        D3D12_COMMAND_LIST_TYPE ( STDMETHODCALLTYPE *GetType )( 
+            ID3D12VideoEncodeCommandList * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoEncodeCommandList, Close)
+        HRESULT ( STDMETHODCALLTYPE *Close )( 
+            ID3D12VideoEncodeCommandList * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoEncodeCommandList, Reset)
+        HRESULT ( STDMETHODCALLTYPE *Reset )( 
+            ID3D12VideoEncodeCommandList * This,
+            _In_  ID3D12CommandAllocator *pAllocator);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoEncodeCommandList, ClearState)
+        void ( STDMETHODCALLTYPE *ClearState )( 
+            ID3D12VideoEncodeCommandList * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoEncodeCommandList, ResourceBarrier)
+        void ( STDMETHODCALLTYPE *ResourceBarrier )( 
+            ID3D12VideoEncodeCommandList * This,
+            _In_  UINT NumBarriers,
+            _In_reads_(NumBarriers)  const D3D12_RESOURCE_BARRIER *pBarriers);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoEncodeCommandList, DiscardResource)
+        void ( STDMETHODCALLTYPE *DiscardResource )( 
+            ID3D12VideoEncodeCommandList * This,
+            _In_  ID3D12Resource *pResource,
+            _In_opt_  const D3D12_DISCARD_REGION *pRegion);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoEncodeCommandList, BeginQuery)
+        void ( STDMETHODCALLTYPE *BeginQuery )( 
+            ID3D12VideoEncodeCommandList * This,
+            _In_  ID3D12QueryHeap *pQueryHeap,
+            _In_  D3D12_QUERY_TYPE Type,
+            _In_  UINT Index);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoEncodeCommandList, EndQuery)
+        void ( STDMETHODCALLTYPE *EndQuery )( 
+            ID3D12VideoEncodeCommandList * This,
+            _In_  ID3D12QueryHeap *pQueryHeap,
+            _In_  D3D12_QUERY_TYPE Type,
+            _In_  UINT Index);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoEncodeCommandList, ResolveQueryData)
+        void ( STDMETHODCALLTYPE *ResolveQueryData )( 
+            ID3D12VideoEncodeCommandList * This,
+            _In_  ID3D12QueryHeap *pQueryHeap,
+            _In_  D3D12_QUERY_TYPE Type,
+            _In_  UINT StartIndex,
+            _In_  UINT NumQueries,
+            _In_  ID3D12Resource *pDestinationBuffer,
+            _In_  UINT64 AlignedDestinationBufferOffset);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoEncodeCommandList, SetPredication)
+        void ( STDMETHODCALLTYPE *SetPredication )( 
+            ID3D12VideoEncodeCommandList * This,
+            _In_opt_  ID3D12Resource *pBuffer,
+            _In_  UINT64 AlignedBufferOffset,
+            _In_  D3D12_PREDICATION_OP Operation);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoEncodeCommandList, SetMarker)
+        void ( STDMETHODCALLTYPE *SetMarker )( 
+            ID3D12VideoEncodeCommandList * This,
+            UINT Metadata,
+            _In_reads_bytes_opt_(Size)  const void *pData,
+            UINT Size);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoEncodeCommandList, BeginEvent)
+        void ( STDMETHODCALLTYPE *BeginEvent )( 
+            ID3D12VideoEncodeCommandList * This,
+            UINT Metadata,
+            _In_reads_bytes_opt_(Size)  const void *pData,
+            UINT Size);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoEncodeCommandList, EndEvent)
+        void ( STDMETHODCALLTYPE *EndEvent )( 
+            ID3D12VideoEncodeCommandList * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoEncodeCommandList, EstimateMotion)
+        void ( STDMETHODCALLTYPE *EstimateMotion )( 
+            ID3D12VideoEncodeCommandList * This,
+            _In_  ID3D12VideoMotionEstimator *pMotionEstimator,
+            _In_  const D3D12_VIDEO_MOTION_ESTIMATOR_OUTPUT *pOutputArguments,
+            _In_  const D3D12_VIDEO_MOTION_ESTIMATOR_INPUT *pInputArguments);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoEncodeCommandList, ResolveMotionVectorHeap)
+        void ( STDMETHODCALLTYPE *ResolveMotionVectorHeap )( 
+            ID3D12VideoEncodeCommandList * This,
+            const D3D12_RESOLVE_VIDEO_MOTION_VECTOR_HEAP_OUTPUT *pOutputArguments,
+            const D3D12_RESOLVE_VIDEO_MOTION_VECTOR_HEAP_INPUT *pInputArguments);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoEncodeCommandList, WriteBufferImmediate)
+        void ( STDMETHODCALLTYPE *WriteBufferImmediate )( 
+            ID3D12VideoEncodeCommandList * This,
+            UINT Count,
+            _In_reads_(Count)  const D3D12_WRITEBUFFERIMMEDIATE_PARAMETER *pParams,
+            _In_reads_opt_(Count)  const D3D12_WRITEBUFFERIMMEDIATE_MODE *pModes);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoEncodeCommandList, SetProtectedResourceSession)
+        void ( STDMETHODCALLTYPE *SetProtectedResourceSession )( 
+            ID3D12VideoEncodeCommandList * This,
+            _In_opt_  ID3D12ProtectedResourceSession *pProtectedResourceSession);
+        
+        END_INTERFACE
+    } ID3D12VideoEncodeCommandListVtbl;
+
+    interface ID3D12VideoEncodeCommandList
+    {
+        CONST_VTBL struct ID3D12VideoEncodeCommandListVtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define ID3D12VideoEncodeCommandList_QueryInterface(This,riid,ppvObject)	\
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define ID3D12VideoEncodeCommandList_AddRef(This)	\
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define ID3D12VideoEncodeCommandList_Release(This)	\
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#define ID3D12VideoEncodeCommandList_GetPrivateData(This,guid,pDataSize,pData)	\
+    ( (This)->lpVtbl -> GetPrivateData(This,guid,pDataSize,pData) ) 
+
+#define ID3D12VideoEncodeCommandList_SetPrivateData(This,guid,DataSize,pData)	\
+    ( (This)->lpVtbl -> SetPrivateData(This,guid,DataSize,pData) ) 
+
+#define ID3D12VideoEncodeCommandList_SetPrivateDataInterface(This,guid,pData)	\
+    ( (This)->lpVtbl -> SetPrivateDataInterface(This,guid,pData) ) 
+
+#define ID3D12VideoEncodeCommandList_SetName(This,Name)	\
+    ( (This)->lpVtbl -> SetName(This,Name) ) 
+
+
+#define ID3D12VideoEncodeCommandList_GetDevice(This,riid,ppvDevice)	\
+    ( (This)->lpVtbl -> GetDevice(This,riid,ppvDevice) ) 
+
+
+#define ID3D12VideoEncodeCommandList_GetType(This)	\
+    ( (This)->lpVtbl -> GetType(This) ) 
+
+
+#define ID3D12VideoEncodeCommandList_Close(This)	\
+    ( (This)->lpVtbl -> Close(This) ) 
+
+#define ID3D12VideoEncodeCommandList_Reset(This,pAllocator)	\
+    ( (This)->lpVtbl -> Reset(This,pAllocator) ) 
+
+#define ID3D12VideoEncodeCommandList_ClearState(This)	\
+    ( (This)->lpVtbl -> ClearState(This) ) 
+
+#define ID3D12VideoEncodeCommandList_ResourceBarrier(This,NumBarriers,pBarriers)	\
+    ( (This)->lpVtbl -> ResourceBarrier(This,NumBarriers,pBarriers) ) 
+
+#define ID3D12VideoEncodeCommandList_DiscardResource(This,pResource,pRegion)	\
+    ( (This)->lpVtbl -> DiscardResource(This,pResource,pRegion) ) 
+
+#define ID3D12VideoEncodeCommandList_BeginQuery(This,pQueryHeap,Type,Index)	\
+    ( (This)->lpVtbl -> BeginQuery(This,pQueryHeap,Type,Index) ) 
+
+#define ID3D12VideoEncodeCommandList_EndQuery(This,pQueryHeap,Type,Index)	\
+    ( (This)->lpVtbl -> EndQuery(This,pQueryHeap,Type,Index) ) 
+
+#define ID3D12VideoEncodeCommandList_ResolveQueryData(This,pQueryHeap,Type,StartIndex,NumQueries,pDestinationBuffer,AlignedDestinationBufferOffset)	\
+    ( (This)->lpVtbl -> ResolveQueryData(This,pQueryHeap,Type,StartIndex,NumQueries,pDestinationBuffer,AlignedDestinationBufferOffset) ) 
+
+#define ID3D12VideoEncodeCommandList_SetPredication(This,pBuffer,AlignedBufferOffset,Operation)	\
+    ( (This)->lpVtbl -> SetPredication(This,pBuffer,AlignedBufferOffset,Operation) ) 
+
+#define ID3D12VideoEncodeCommandList_SetMarker(This,Metadata,pData,Size)	\
+    ( (This)->lpVtbl -> SetMarker(This,Metadata,pData,Size) ) 
+
+#define ID3D12VideoEncodeCommandList_BeginEvent(This,Metadata,pData,Size)	\
+    ( (This)->lpVtbl -> BeginEvent(This,Metadata,pData,Size) ) 
+
+#define ID3D12VideoEncodeCommandList_EndEvent(This)	\
+    ( (This)->lpVtbl -> EndEvent(This) ) 
+
+#define ID3D12VideoEncodeCommandList_EstimateMotion(This,pMotionEstimator,pOutputArguments,pInputArguments)	\
+    ( (This)->lpVtbl -> EstimateMotion(This,pMotionEstimator,pOutputArguments,pInputArguments) ) 
+
+#define ID3D12VideoEncodeCommandList_ResolveMotionVectorHeap(This,pOutputArguments,pInputArguments)	\
+    ( (This)->lpVtbl -> ResolveMotionVectorHeap(This,pOutputArguments,pInputArguments) ) 
+
+#define ID3D12VideoEncodeCommandList_WriteBufferImmediate(This,Count,pParams,pModes)	\
+    ( (This)->lpVtbl -> WriteBufferImmediate(This,Count,pParams,pModes) ) 
+
+#define ID3D12VideoEncodeCommandList_SetProtectedResourceSession(This,pProtectedResourceSession)	\
+    ( (This)->lpVtbl -> SetProtectedResourceSession(This,pProtectedResourceSession) ) 
+
+#endif /* COBJMACROS */
+
+
+#endif 	/* C style interface */
+
+
+
+
+#endif 	/* __ID3D12VideoEncodeCommandList_INTERFACE_DEFINED__ */
+
+
+/* interface __MIDL_itf_d3d12video_0000_0012 */
+/* [local] */ 
+
+typedef 
+enum D3D12_VIDEO_PROTECTED_RESOURCE_SUPPORT_FLAGS
+    {
+        D3D12_VIDEO_PROTECTED_RESOURCE_SUPPORT_FLAG_NONE	= 0,
+        D3D12_VIDEO_PROTECTED_RESOURCE_SUPPORT_FLAG_SUPPORTED	= 0x1
+    } 	D3D12_VIDEO_PROTECTED_RESOURCE_SUPPORT_FLAGS;
+
+DEFINE_ENUM_FLAG_OPERATORS(D3D12_VIDEO_PROTECTED_RESOURCE_SUPPORT_FLAGS );
+typedef struct D3D12_FEATURE_DATA_VIDEO_DECODE_PROTECTED_RESOURCES
+    {
+    UINT NodeIndex;
+    D3D12_VIDEO_DECODE_CONFIGURATION Configuration;
+    D3D12_VIDEO_PROTECTED_RESOURCE_SUPPORT_FLAGS SupportFlags;
+    } 	D3D12_FEATURE_DATA_VIDEO_DECODE_PROTECTED_RESOURCES;
+
+typedef struct D3D12_FEATURE_DATA_VIDEO_PROCESS_PROTECTED_RESOURCES
+    {
+    UINT NodeIndex;
+    D3D12_VIDEO_PROTECTED_RESOURCE_SUPPORT_FLAGS SupportFlags;
+    } 	D3D12_FEATURE_DATA_VIDEO_PROCESS_PROTECTED_RESOURCES;
+
+typedef struct D3D12_FEATURE_DATA_VIDEO_MOTION_ESTIMATOR_PROTECTED_RESOURCES
+    {
+    UINT NodeIndex;
+    D3D12_VIDEO_PROTECTED_RESOURCE_SUPPORT_FLAGS SupportFlags;
+    } 	D3D12_FEATURE_DATA_VIDEO_MOTION_ESTIMATOR_PROTECTED_RESOURCES;
+
+typedef struct D3D12_FEATURE_DATA_VIDEO_DECODER_HEAP_SIZE1
+    {
+    D3D12_VIDEO_DECODER_HEAP_DESC VideoDecoderHeapDesc;
+    BOOL Protected;
+    UINT64 MemoryPoolL0Size;
+    UINT64 MemoryPoolL1Size;
+    } 	D3D12_FEATURE_DATA_VIDEO_DECODER_HEAP_SIZE1;
+
+typedef struct D3D12_FEATURE_DATA_VIDEO_PROCESSOR_SIZE1
+    {
+    UINT NodeMask;
+    const D3D12_VIDEO_PROCESS_OUTPUT_STREAM_DESC *pOutputStreamDesc;
+    UINT NumInputStreamDescs;
+    const D3D12_VIDEO_PROCESS_INPUT_STREAM_DESC *pInputStreamDescs;
+    BOOL Protected;
+    UINT64 MemoryPoolL0Size;
+    UINT64 MemoryPoolL1Size;
+    } 	D3D12_FEATURE_DATA_VIDEO_PROCESSOR_SIZE1;
+
+typedef 
+enum D3D12_VIDEO_EXTENSION_COMMAND_PARAMETER_STAGE
+    {
+        D3D12_VIDEO_EXTENSION_COMMAND_PARAMETER_STAGE_CREATION	= 0,
+        D3D12_VIDEO_EXTENSION_COMMAND_PARAMETER_STAGE_INITIALIZATION	= 1,
+        D3D12_VIDEO_EXTENSION_COMMAND_PARAMETER_STAGE_EXECUTION	= 2,
+        D3D12_VIDEO_EXTENSION_COMMAND_PARAMETER_STAGE_CAPS_INPUT	= 3,
+        D3D12_VIDEO_EXTENSION_COMMAND_PARAMETER_STAGE_CAPS_OUTPUT	= 4,
+        D3D12_VIDEO_EXTENSION_COMMAND_PARAMETER_STAGE_DEVICE_EXECUTE_INPUT	= 5,
+        D3D12_VIDEO_EXTENSION_COMMAND_PARAMETER_STAGE_DEVICE_EXECUTE_OUTPUT	= 6
+    } 	D3D12_VIDEO_EXTENSION_COMMAND_PARAMETER_STAGE;
+
+typedef 
+enum D3D12_VIDEO_EXTENSION_COMMAND_PARAMETER_TYPE
+    {
+        D3D12_VIDEO_EXTENSION_COMMAND_PARAMETER_TYPE_UINT8	= 0,
+        D3D12_VIDEO_EXTENSION_COMMAND_PARAMETER_TYPE_UINT16	= 1,
+        D3D12_VIDEO_EXTENSION_COMMAND_PARAMETER_TYPE_UINT32	= 2,
+        D3D12_VIDEO_EXTENSION_COMMAND_PARAMETER_TYPE_UINT64	= 3,
+        D3D12_VIDEO_EXTENSION_COMMAND_PARAMETER_TYPE_SINT8	= 4,
+        D3D12_VIDEO_EXTENSION_COMMAND_PARAMETER_TYPE_SINT16	= 5,
+        D3D12_VIDEO_EXTENSION_COMMAND_PARAMETER_TYPE_SINT32	= 6,
+        D3D12_VIDEO_EXTENSION_COMMAND_PARAMETER_TYPE_SINT64	= 7,
+        D3D12_VIDEO_EXTENSION_COMMAND_PARAMETER_TYPE_FLOAT	= 8,
+        D3D12_VIDEO_EXTENSION_COMMAND_PARAMETER_TYPE_DOUBLE	= 9,
+        D3D12_VIDEO_EXTENSION_COMMAND_PARAMETER_TYPE_RESOURCE	= 10
+    } 	D3D12_VIDEO_EXTENSION_COMMAND_PARAMETER_TYPE;
+
+typedef 
+enum D3D12_VIDEO_EXTENSION_COMMAND_PARAMETER_FLAGS
+    {
+        D3D12_VIDEO_EXTENSION_COMMAND_PARAMETER_FLAG_NONE	= 0,
+        D3D12_VIDEO_EXTENSION_COMMAND_PARAMETER_FLAG_READ	= 0x1,
+        D3D12_VIDEO_EXTENSION_COMMAND_PARAMETER_FLAG_WRITE	= 0x2
+    } 	D3D12_VIDEO_EXTENSION_COMMAND_PARAMETER_FLAGS;
+
+DEFINE_ENUM_FLAG_OPERATORS(D3D12_VIDEO_EXTENSION_COMMAND_PARAMETER_FLAGS );
+typedef struct D3D12_FEATURE_DATA_VIDEO_EXTENSION_COMMAND_COUNT
+    {
+    UINT NodeIndex;
+    UINT CommandCount;
+    } 	D3D12_FEATURE_DATA_VIDEO_EXTENSION_COMMAND_COUNT;
+
+typedef struct D3D12_VIDEO_EXTENSION_COMMAND_INFO
+    {
+    GUID CommandId;
+    LPCWSTR Name;
+    D3D12_COMMAND_LIST_SUPPORT_FLAGS CommandListSupportFlags;
+    } 	D3D12_VIDEO_EXTENSION_COMMAND_INFO;
+
+typedef struct D3D12_FEATURE_DATA_VIDEO_EXTENSION_COMMANDS
+    {
+    UINT NodeIndex;
+    UINT CommandCount;
+    _Field_size_full_(CommandCount)  D3D12_VIDEO_EXTENSION_COMMAND_INFO *pCommandInfos;
+    } 	D3D12_FEATURE_DATA_VIDEO_EXTENSION_COMMANDS;
+
+typedef struct D3D12_FEATURE_DATA_VIDEO_EXTENSION_COMMAND_PARAMETER_COUNT
+    {
+    GUID CommandId;
+    D3D12_VIDEO_EXTENSION_COMMAND_PARAMETER_STAGE Stage;
+    UINT ParameterCount;
+    UINT ParameterPacking;
+    } 	D3D12_FEATURE_DATA_VIDEO_EXTENSION_COMMAND_PARAMETER_COUNT;
+
+typedef struct D3D12_VIDEO_EXTENSION_COMMAND_PARAMETER_INFO
+    {
+    LPCWSTR Name;
+    D3D12_VIDEO_EXTENSION_COMMAND_PARAMETER_TYPE Type;
+    D3D12_VIDEO_EXTENSION_COMMAND_PARAMETER_FLAGS Flags;
+    } 	D3D12_VIDEO_EXTENSION_COMMAND_PARAMETER_INFO;
+
+typedef struct D3D12_FEATURE_DATA_VIDEO_EXTENSION_COMMAND_PARAMETERS
+    {
+    GUID CommandId;
+    D3D12_VIDEO_EXTENSION_COMMAND_PARAMETER_STAGE Stage;
+    UINT ParameterCount;
+    _Field_size_full_(ParameterCount)  D3D12_VIDEO_EXTENSION_COMMAND_PARAMETER_INFO *pParameterInfos;
+    } 	D3D12_FEATURE_DATA_VIDEO_EXTENSION_COMMAND_PARAMETERS;
+
+typedef struct D3D12_FEATURE_DATA_VIDEO_EXTENSION_COMMAND_SUPPORT
+    {
+    UINT NodeIndex;
+    GUID CommandId;
+    _Field_size_bytes_full_opt_(InputDataSizeInBytes)  const void *pInputData;
+    SIZE_T InputDataSizeInBytes;
+    _Field_size_bytes_full_opt_(OutputDataSizeInBytes)  void *pOutputData;
+    SIZE_T OutputDataSizeInBytes;
+    } 	D3D12_FEATURE_DATA_VIDEO_EXTENSION_COMMAND_SUPPORT;
+
+typedef struct D3D12_FEATURE_DATA_VIDEO_EXTENSION_COMMAND_SIZE
+    {
+    UINT NodeIndex;
+    GUID CommandId;
+    _Field_size_bytes_full_(CreationParametersDataSizeInBytes)  const void *pCreationParameters;
+    SIZE_T CreationParametersSizeInBytes;
+    UINT64 MemoryPoolL0Size;
+    UINT64 MemoryPoolL1Size;
+    } 	D3D12_FEATURE_DATA_VIDEO_EXTENSION_COMMAND_SIZE;
+
+typedef struct D3D12_VIDEO_EXTENSION_COMMAND_DESC
+    {
+    UINT NodeMask;
+    GUID CommandId;
+    } 	D3D12_VIDEO_EXTENSION_COMMAND_DESC;
+
+
+
+extern RPC_IF_HANDLE __MIDL_itf_d3d12video_0000_0012_v0_0_c_ifspec;
+extern RPC_IF_HANDLE __MIDL_itf_d3d12video_0000_0012_v0_0_s_ifspec;
+
+#ifndef __ID3D12VideoDecoder1_INTERFACE_DEFINED__
+#define __ID3D12VideoDecoder1_INTERFACE_DEFINED__
+
+/* interface ID3D12VideoDecoder1 */
+/* [unique][local][object][uuid] */ 
+
+
+EXTERN_C const IID IID_ID3D12VideoDecoder1;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("79A2E5FB-CCD2-469A-9FDE-195D10951F7E")
+    ID3D12VideoDecoder1 : public ID3D12VideoDecoder
+    {
+    public:
+        virtual HRESULT STDMETHODCALLTYPE GetProtectedResourceSession( 
+            REFIID riid,
+            _COM_Outptr_opt_  void **ppProtectedSession) = 0;
+        
+    };
+    
+    
+#else 	/* C style interface */
+
+    typedef struct ID3D12VideoDecoder1Vtbl
+    {
+        BEGIN_INTERFACE
+        
+        DECLSPEC_XFGVIRT(IUnknown, QueryInterface)
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            ID3D12VideoDecoder1 * This,
+            REFIID riid,
+            _COM_Outptr_  void **ppvObject);
+        
+        DECLSPEC_XFGVIRT(IUnknown, AddRef)
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            ID3D12VideoDecoder1 * This);
+        
+        DECLSPEC_XFGVIRT(IUnknown, Release)
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            ID3D12VideoDecoder1 * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, GetPrivateData)
+        HRESULT ( STDMETHODCALLTYPE *GetPrivateData )( 
+            ID3D12VideoDecoder1 * This,
+            _In_  REFGUID guid,
+            _Inout_  UINT *pDataSize,
+            _Out_writes_bytes_opt_( *pDataSize )  void *pData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, SetPrivateData)
+        HRESULT ( STDMETHODCALLTYPE *SetPrivateData )( 
+            ID3D12VideoDecoder1 * This,
+            _In_  REFGUID guid,
+            _In_  UINT DataSize,
+            _In_reads_bytes_opt_( DataSize )  const void *pData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, SetPrivateDataInterface)
+        HRESULT ( STDMETHODCALLTYPE *SetPrivateDataInterface )( 
+            ID3D12VideoDecoder1 * This,
+            _In_  REFGUID guid,
+            _In_opt_  const IUnknown *pData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, SetName)
+        HRESULT ( STDMETHODCALLTYPE *SetName )( 
+            ID3D12VideoDecoder1 * This,
+            _In_z_  LPCWSTR Name);
+        
+        DECLSPEC_XFGVIRT(ID3D12DeviceChild, GetDevice)
+        HRESULT ( STDMETHODCALLTYPE *GetDevice )( 
+            ID3D12VideoDecoder1 * This,
+            REFIID riid,
+            _COM_Outptr_opt_  void **ppvDevice);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoDecoder, GetDesc)
+#if !defined(_WIN32)
+        D3D12_VIDEO_DECODER_DESC ( STDMETHODCALLTYPE *GetDesc )( 
+            ID3D12VideoDecoder1 * This);
+        
+#else
+        D3D12_VIDEO_DECODER_DESC *( STDMETHODCALLTYPE *GetDesc )( 
+            ID3D12VideoDecoder1 * This,
+            D3D12_VIDEO_DECODER_DESC * RetVal);
+        
+#endif
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoDecoder1, GetProtectedResourceSession)
+        HRESULT ( STDMETHODCALLTYPE *GetProtectedResourceSession )( 
+            ID3D12VideoDecoder1 * This,
+            REFIID riid,
+            _COM_Outptr_opt_  void **ppProtectedSession);
+        
+        END_INTERFACE
+    } ID3D12VideoDecoder1Vtbl;
+
+    interface ID3D12VideoDecoder1
+    {
+        CONST_VTBL struct ID3D12VideoDecoder1Vtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define ID3D12VideoDecoder1_QueryInterface(This,riid,ppvObject)	\
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define ID3D12VideoDecoder1_AddRef(This)	\
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define ID3D12VideoDecoder1_Release(This)	\
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#define ID3D12VideoDecoder1_GetPrivateData(This,guid,pDataSize,pData)	\
+    ( (This)->lpVtbl -> GetPrivateData(This,guid,pDataSize,pData) ) 
+
+#define ID3D12VideoDecoder1_SetPrivateData(This,guid,DataSize,pData)	\
+    ( (This)->lpVtbl -> SetPrivateData(This,guid,DataSize,pData) ) 
+
+#define ID3D12VideoDecoder1_SetPrivateDataInterface(This,guid,pData)	\
+    ( (This)->lpVtbl -> SetPrivateDataInterface(This,guid,pData) ) 
+
+#define ID3D12VideoDecoder1_SetName(This,Name)	\
+    ( (This)->lpVtbl -> SetName(This,Name) ) 
+
+
+#define ID3D12VideoDecoder1_GetDevice(This,riid,ppvDevice)	\
+    ( (This)->lpVtbl -> GetDevice(This,riid,ppvDevice) ) 
+
+
+#if !defined(_WIN32)
+
+#define ID3D12VideoDecoder1_GetDesc(This)	\
+    ( (This)->lpVtbl -> GetDesc(This) ) 
+#else
+#define ID3D12VideoDecoder1_GetDesc(This,RetVal)	\
+    ( (This)->lpVtbl -> GetDesc(This,RetVal) ) 
+#endif
+
+
+#define ID3D12VideoDecoder1_GetProtectedResourceSession(This,riid,ppProtectedSession)	\
+    ( (This)->lpVtbl -> GetProtectedResourceSession(This,riid,ppProtectedSession) ) 
+
+#endif /* COBJMACROS */
+
+
+#endif 	/* C style interface */
+
+
+
+
+#endif 	/* __ID3D12VideoDecoder1_INTERFACE_DEFINED__ */
+
+
+#ifndef __ID3D12VideoDecoderHeap1_INTERFACE_DEFINED__
+#define __ID3D12VideoDecoderHeap1_INTERFACE_DEFINED__
+
+/* interface ID3D12VideoDecoderHeap1 */
+/* [unique][local][object][uuid] */ 
+
+
+EXTERN_C const IID IID_ID3D12VideoDecoderHeap1;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("DA1D98C5-539F-41B2-BF6B-1198A03B6D26")
+    ID3D12VideoDecoderHeap1 : public ID3D12VideoDecoderHeap
+    {
+    public:
+        virtual HRESULT STDMETHODCALLTYPE GetProtectedResourceSession( 
+            REFIID riid,
+            _COM_Outptr_opt_  void **ppProtectedSession) = 0;
+        
+    };
+    
+    
+#else 	/* C style interface */
+
+    typedef struct ID3D12VideoDecoderHeap1Vtbl
+    {
+        BEGIN_INTERFACE
+        
+        DECLSPEC_XFGVIRT(IUnknown, QueryInterface)
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            ID3D12VideoDecoderHeap1 * This,
+            REFIID riid,
+            _COM_Outptr_  void **ppvObject);
+        
+        DECLSPEC_XFGVIRT(IUnknown, AddRef)
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            ID3D12VideoDecoderHeap1 * This);
+        
+        DECLSPEC_XFGVIRT(IUnknown, Release)
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            ID3D12VideoDecoderHeap1 * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, GetPrivateData)
+        HRESULT ( STDMETHODCALLTYPE *GetPrivateData )( 
+            ID3D12VideoDecoderHeap1 * This,
+            _In_  REFGUID guid,
+            _Inout_  UINT *pDataSize,
+            _Out_writes_bytes_opt_( *pDataSize )  void *pData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, SetPrivateData)
+        HRESULT ( STDMETHODCALLTYPE *SetPrivateData )( 
+            ID3D12VideoDecoderHeap1 * This,
+            _In_  REFGUID guid,
+            _In_  UINT DataSize,
+            _In_reads_bytes_opt_( DataSize )  const void *pData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, SetPrivateDataInterface)
+        HRESULT ( STDMETHODCALLTYPE *SetPrivateDataInterface )( 
+            ID3D12VideoDecoderHeap1 * This,
+            _In_  REFGUID guid,
+            _In_opt_  const IUnknown *pData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, SetName)
+        HRESULT ( STDMETHODCALLTYPE *SetName )( 
+            ID3D12VideoDecoderHeap1 * This,
+            _In_z_  LPCWSTR Name);
+        
+        DECLSPEC_XFGVIRT(ID3D12DeviceChild, GetDevice)
+        HRESULT ( STDMETHODCALLTYPE *GetDevice )( 
+            ID3D12VideoDecoderHeap1 * This,
+            REFIID riid,
+            _COM_Outptr_opt_  void **ppvDevice);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoDecoderHeap, GetDesc)
+#if !defined(_WIN32)
+        D3D12_VIDEO_DECODER_HEAP_DESC ( STDMETHODCALLTYPE *GetDesc )( 
+            ID3D12VideoDecoderHeap1 * This);
+        
+#else
+        D3D12_VIDEO_DECODER_HEAP_DESC *( STDMETHODCALLTYPE *GetDesc )( 
+            ID3D12VideoDecoderHeap1 * This,
+            D3D12_VIDEO_DECODER_HEAP_DESC * RetVal);
+        
+#endif
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoDecoderHeap1, GetProtectedResourceSession)
+        HRESULT ( STDMETHODCALLTYPE *GetProtectedResourceSession )( 
+            ID3D12VideoDecoderHeap1 * This,
+            REFIID riid,
+            _COM_Outptr_opt_  void **ppProtectedSession);
+        
+        END_INTERFACE
+    } ID3D12VideoDecoderHeap1Vtbl;
+
+    interface ID3D12VideoDecoderHeap1
+    {
+        CONST_VTBL struct ID3D12VideoDecoderHeap1Vtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define ID3D12VideoDecoderHeap1_QueryInterface(This,riid,ppvObject)	\
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define ID3D12VideoDecoderHeap1_AddRef(This)	\
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define ID3D12VideoDecoderHeap1_Release(This)	\
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#define ID3D12VideoDecoderHeap1_GetPrivateData(This,guid,pDataSize,pData)	\
+    ( (This)->lpVtbl -> GetPrivateData(This,guid,pDataSize,pData) ) 
+
+#define ID3D12VideoDecoderHeap1_SetPrivateData(This,guid,DataSize,pData)	\
+    ( (This)->lpVtbl -> SetPrivateData(This,guid,DataSize,pData) ) 
+
+#define ID3D12VideoDecoderHeap1_SetPrivateDataInterface(This,guid,pData)	\
+    ( (This)->lpVtbl -> SetPrivateDataInterface(This,guid,pData) ) 
+
+#define ID3D12VideoDecoderHeap1_SetName(This,Name)	\
+    ( (This)->lpVtbl -> SetName(This,Name) ) 
+
+
+#define ID3D12VideoDecoderHeap1_GetDevice(This,riid,ppvDevice)	\
+    ( (This)->lpVtbl -> GetDevice(This,riid,ppvDevice) ) 
+
+
+#if !defined(_WIN32)
+
+#define ID3D12VideoDecoderHeap1_GetDesc(This)	\
+    ( (This)->lpVtbl -> GetDesc(This) ) 
+#else
+#define ID3D12VideoDecoderHeap1_GetDesc(This,RetVal)	\
+    ( (This)->lpVtbl -> GetDesc(This,RetVal) ) 
+#endif
+
+
+#define ID3D12VideoDecoderHeap1_GetProtectedResourceSession(This,riid,ppProtectedSession)	\
+    ( (This)->lpVtbl -> GetProtectedResourceSession(This,riid,ppProtectedSession) ) 
+
+#endif /* COBJMACROS */
+
+
+#endif 	/* C style interface */
+
+
+
+
+#endif 	/* __ID3D12VideoDecoderHeap1_INTERFACE_DEFINED__ */
+
+
+#ifndef __ID3D12VideoProcessor1_INTERFACE_DEFINED__
+#define __ID3D12VideoProcessor1_INTERFACE_DEFINED__
+
+/* interface ID3D12VideoProcessor1 */
+/* [unique][local][object][uuid] */ 
+
+
+EXTERN_C const IID IID_ID3D12VideoProcessor1;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("F3CFE615-553F-425C-86D8-EE8C1B1FB01C")
+    ID3D12VideoProcessor1 : public ID3D12VideoProcessor
+    {
+    public:
+        virtual HRESULT STDMETHODCALLTYPE GetProtectedResourceSession( 
+            REFIID riid,
+            _COM_Outptr_opt_  void **ppProtectedSession) = 0;
+        
+    };
+    
+    
+#else 	/* C style interface */
+
+    typedef struct ID3D12VideoProcessor1Vtbl
+    {
+        BEGIN_INTERFACE
+        
+        DECLSPEC_XFGVIRT(IUnknown, QueryInterface)
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            ID3D12VideoProcessor1 * This,
+            REFIID riid,
+            _COM_Outptr_  void **ppvObject);
+        
+        DECLSPEC_XFGVIRT(IUnknown, AddRef)
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            ID3D12VideoProcessor1 * This);
+        
+        DECLSPEC_XFGVIRT(IUnknown, Release)
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            ID3D12VideoProcessor1 * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, GetPrivateData)
+        HRESULT ( STDMETHODCALLTYPE *GetPrivateData )( 
+            ID3D12VideoProcessor1 * This,
+            _In_  REFGUID guid,
+            _Inout_  UINT *pDataSize,
+            _Out_writes_bytes_opt_( *pDataSize )  void *pData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, SetPrivateData)
+        HRESULT ( STDMETHODCALLTYPE *SetPrivateData )( 
+            ID3D12VideoProcessor1 * This,
+            _In_  REFGUID guid,
+            _In_  UINT DataSize,
+            _In_reads_bytes_opt_( DataSize )  const void *pData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, SetPrivateDataInterface)
+        HRESULT ( STDMETHODCALLTYPE *SetPrivateDataInterface )( 
+            ID3D12VideoProcessor1 * This,
+            _In_  REFGUID guid,
+            _In_opt_  const IUnknown *pData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, SetName)
+        HRESULT ( STDMETHODCALLTYPE *SetName )( 
+            ID3D12VideoProcessor1 * This,
+            _In_z_  LPCWSTR Name);
+        
+        DECLSPEC_XFGVIRT(ID3D12DeviceChild, GetDevice)
+        HRESULT ( STDMETHODCALLTYPE *GetDevice )( 
+            ID3D12VideoProcessor1 * This,
+            REFIID riid,
+            _COM_Outptr_opt_  void **ppvDevice);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoProcessor, GetNodeMask)
+        UINT ( STDMETHODCALLTYPE *GetNodeMask )( 
+            ID3D12VideoProcessor1 * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoProcessor, GetNumInputStreamDescs)
+        UINT ( STDMETHODCALLTYPE *GetNumInputStreamDescs )( 
+            ID3D12VideoProcessor1 * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoProcessor, GetInputStreamDescs)
+        HRESULT ( STDMETHODCALLTYPE *GetInputStreamDescs )( 
+            ID3D12VideoProcessor1 * This,
+            UINT NumInputStreamDescs,
+            _Out_writes_(NumInputStreamDescs)  D3D12_VIDEO_PROCESS_INPUT_STREAM_DESC *pInputStreamDescs);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoProcessor, GetOutputStreamDesc)
+#if !defined(_WIN32)
+        D3D12_VIDEO_PROCESS_OUTPUT_STREAM_DESC ( STDMETHODCALLTYPE *GetOutputStreamDesc )( 
+            ID3D12VideoProcessor1 * This);
+        
+#else
+        D3D12_VIDEO_PROCESS_OUTPUT_STREAM_DESC *( STDMETHODCALLTYPE *GetOutputStreamDesc )( 
+            ID3D12VideoProcessor1 * This,
+            D3D12_VIDEO_PROCESS_OUTPUT_STREAM_DESC * RetVal);
+        
+#endif
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoProcessor1, GetProtectedResourceSession)
+        HRESULT ( STDMETHODCALLTYPE *GetProtectedResourceSession )( 
+            ID3D12VideoProcessor1 * This,
+            REFIID riid,
+            _COM_Outptr_opt_  void **ppProtectedSession);
+        
+        END_INTERFACE
+    } ID3D12VideoProcessor1Vtbl;
+
+    interface ID3D12VideoProcessor1
+    {
+        CONST_VTBL struct ID3D12VideoProcessor1Vtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define ID3D12VideoProcessor1_QueryInterface(This,riid,ppvObject)	\
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define ID3D12VideoProcessor1_AddRef(This)	\
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define ID3D12VideoProcessor1_Release(This)	\
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#define ID3D12VideoProcessor1_GetPrivateData(This,guid,pDataSize,pData)	\
+    ( (This)->lpVtbl -> GetPrivateData(This,guid,pDataSize,pData) ) 
+
+#define ID3D12VideoProcessor1_SetPrivateData(This,guid,DataSize,pData)	\
+    ( (This)->lpVtbl -> SetPrivateData(This,guid,DataSize,pData) ) 
+
+#define ID3D12VideoProcessor1_SetPrivateDataInterface(This,guid,pData)	\
+    ( (This)->lpVtbl -> SetPrivateDataInterface(This,guid,pData) ) 
+
+#define ID3D12VideoProcessor1_SetName(This,Name)	\
+    ( (This)->lpVtbl -> SetName(This,Name) ) 
+
+
+#define ID3D12VideoProcessor1_GetDevice(This,riid,ppvDevice)	\
+    ( (This)->lpVtbl -> GetDevice(This,riid,ppvDevice) ) 
+
+
+
+#define ID3D12VideoProcessor1_GetNodeMask(This)	\
+    ( (This)->lpVtbl -> GetNodeMask(This) ) 
+
+#define ID3D12VideoProcessor1_GetNumInputStreamDescs(This)	\
+    ( (This)->lpVtbl -> GetNumInputStreamDescs(This) ) 
+
+#define ID3D12VideoProcessor1_GetInputStreamDescs(This,NumInputStreamDescs,pInputStreamDescs)	\
+    ( (This)->lpVtbl -> GetInputStreamDescs(This,NumInputStreamDescs,pInputStreamDescs) ) 
+#if !defined(_WIN32)
+
+#define ID3D12VideoProcessor1_GetOutputStreamDesc(This)	\
+    ( (This)->lpVtbl -> GetOutputStreamDesc(This) ) 
+#else
+#define ID3D12VideoProcessor1_GetOutputStreamDesc(This,RetVal)	\
+    ( (This)->lpVtbl -> GetOutputStreamDesc(This,RetVal) ) 
+#endif
+
+
+#define ID3D12VideoProcessor1_GetProtectedResourceSession(This,riid,ppProtectedSession)	\
+    ( (This)->lpVtbl -> GetProtectedResourceSession(This,riid,ppProtectedSession) ) 
+
+#endif /* COBJMACROS */
+
+
+#endif 	/* C style interface */
+
+
+
+
+#endif 	/* __ID3D12VideoProcessor1_INTERFACE_DEFINED__ */
+
+
+#ifndef __ID3D12VideoExtensionCommand_INTERFACE_DEFINED__
+#define __ID3D12VideoExtensionCommand_INTERFACE_DEFINED__
+
+/* interface ID3D12VideoExtensionCommand */
+/* [unique][local][object][uuid] */ 
+
+
+EXTERN_C const IID IID_ID3D12VideoExtensionCommand;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("554E41E8-AE8E-4A8C-B7D2-5B4F274A30E4")
+    ID3D12VideoExtensionCommand : public ID3D12Pageable
+    {
+    public:
+#if defined(_MSC_VER) || !defined(_WIN32)
+        virtual D3D12_VIDEO_EXTENSION_COMMAND_DESC STDMETHODCALLTYPE GetDesc( void) = 0;
+#else
+        virtual D3D12_VIDEO_EXTENSION_COMMAND_DESC *STDMETHODCALLTYPE GetDesc( 
+            D3D12_VIDEO_EXTENSION_COMMAND_DESC * RetVal) = 0;
+#endif
+        
+        virtual HRESULT STDMETHODCALLTYPE GetProtectedResourceSession( 
+            REFIID riid,
+            _COM_Outptr_opt_  void **ppProtectedSession) = 0;
+        
+    };
+    
+    
+#else 	/* C style interface */
+
+    typedef struct ID3D12VideoExtensionCommandVtbl
+    {
+        BEGIN_INTERFACE
+        
+        DECLSPEC_XFGVIRT(IUnknown, QueryInterface)
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            ID3D12VideoExtensionCommand * This,
+            REFIID riid,
+            _COM_Outptr_  void **ppvObject);
+        
+        DECLSPEC_XFGVIRT(IUnknown, AddRef)
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            ID3D12VideoExtensionCommand * This);
+        
+        DECLSPEC_XFGVIRT(IUnknown, Release)
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            ID3D12VideoExtensionCommand * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, GetPrivateData)
+        HRESULT ( STDMETHODCALLTYPE *GetPrivateData )( 
+            ID3D12VideoExtensionCommand * This,
+            _In_  REFGUID guid,
+            _Inout_  UINT *pDataSize,
+            _Out_writes_bytes_opt_( *pDataSize )  void *pData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, SetPrivateData)
+        HRESULT ( STDMETHODCALLTYPE *SetPrivateData )( 
+            ID3D12VideoExtensionCommand * This,
+            _In_  REFGUID guid,
+            _In_  UINT DataSize,
+            _In_reads_bytes_opt_( DataSize )  const void *pData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, SetPrivateDataInterface)
+        HRESULT ( STDMETHODCALLTYPE *SetPrivateDataInterface )( 
+            ID3D12VideoExtensionCommand * This,
+            _In_  REFGUID guid,
+            _In_opt_  const IUnknown *pData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, SetName)
+        HRESULT ( STDMETHODCALLTYPE *SetName )( 
+            ID3D12VideoExtensionCommand * This,
+            _In_z_  LPCWSTR Name);
+        
+        DECLSPEC_XFGVIRT(ID3D12DeviceChild, GetDevice)
+        HRESULT ( STDMETHODCALLTYPE *GetDevice )( 
+            ID3D12VideoExtensionCommand * This,
+            REFIID riid,
+            _COM_Outptr_opt_  void **ppvDevice);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoExtensionCommand, GetDesc)
+#if !defined(_WIN32)
+        D3D12_VIDEO_EXTENSION_COMMAND_DESC ( STDMETHODCALLTYPE *GetDesc )( 
+            ID3D12VideoExtensionCommand * This);
+        
+#else
+        D3D12_VIDEO_EXTENSION_COMMAND_DESC *( STDMETHODCALLTYPE *GetDesc )( 
+            ID3D12VideoExtensionCommand * This,
+            D3D12_VIDEO_EXTENSION_COMMAND_DESC * RetVal);
+        
+#endif
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoExtensionCommand, GetProtectedResourceSession)
+        HRESULT ( STDMETHODCALLTYPE *GetProtectedResourceSession )( 
+            ID3D12VideoExtensionCommand * This,
+            REFIID riid,
+            _COM_Outptr_opt_  void **ppProtectedSession);
+        
+        END_INTERFACE
+    } ID3D12VideoExtensionCommandVtbl;
+
+    interface ID3D12VideoExtensionCommand
+    {
+        CONST_VTBL struct ID3D12VideoExtensionCommandVtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define ID3D12VideoExtensionCommand_QueryInterface(This,riid,ppvObject)	\
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define ID3D12VideoExtensionCommand_AddRef(This)	\
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define ID3D12VideoExtensionCommand_Release(This)	\
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#define ID3D12VideoExtensionCommand_GetPrivateData(This,guid,pDataSize,pData)	\
+    ( (This)->lpVtbl -> GetPrivateData(This,guid,pDataSize,pData) ) 
+
+#define ID3D12VideoExtensionCommand_SetPrivateData(This,guid,DataSize,pData)	\
+    ( (This)->lpVtbl -> SetPrivateData(This,guid,DataSize,pData) ) 
+
+#define ID3D12VideoExtensionCommand_SetPrivateDataInterface(This,guid,pData)	\
+    ( (This)->lpVtbl -> SetPrivateDataInterface(This,guid,pData) ) 
+
+#define ID3D12VideoExtensionCommand_SetName(This,Name)	\
+    ( (This)->lpVtbl -> SetName(This,Name) ) 
+
+
+#define ID3D12VideoExtensionCommand_GetDevice(This,riid,ppvDevice)	\
+    ( (This)->lpVtbl -> GetDevice(This,riid,ppvDevice) ) 
+
+
+#if !defined(_WIN32)
+
+#define ID3D12VideoExtensionCommand_GetDesc(This)	\
+    ( (This)->lpVtbl -> GetDesc(This) ) 
+#else
+#define ID3D12VideoExtensionCommand_GetDesc(This,RetVal)	\
+    ( (This)->lpVtbl -> GetDesc(This,RetVal) ) 
+#endif
+
+#define ID3D12VideoExtensionCommand_GetProtectedResourceSession(This,riid,ppProtectedSession)	\
+    ( (This)->lpVtbl -> GetProtectedResourceSession(This,riid,ppProtectedSession) ) 
+
+#endif /* COBJMACROS */
+
+
+#endif 	/* C style interface */
+
+
+
+
+#endif 	/* __ID3D12VideoExtensionCommand_INTERFACE_DEFINED__ */
+
+
+#ifndef __ID3D12VideoDevice2_INTERFACE_DEFINED__
+#define __ID3D12VideoDevice2_INTERFACE_DEFINED__
+
+/* interface ID3D12VideoDevice2 */
+/* [unique][local][object][uuid] */ 
+
+
+EXTERN_C const IID IID_ID3D12VideoDevice2;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("F019AC49-F838-4A95-9B17-579437C8F513")
+    ID3D12VideoDevice2 : public ID3D12VideoDevice1
+    {
+    public:
+        virtual HRESULT STDMETHODCALLTYPE CreateVideoDecoder1( 
+            _In_  const D3D12_VIDEO_DECODER_DESC *pDesc,
+            _In_opt_  ID3D12ProtectedResourceSession *pProtectedResourceSession,
+            _In_  REFIID riid,
+            _COM_Outptr_  void **ppVideoDecoder) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE CreateVideoDecoderHeap1( 
+            _In_  const D3D12_VIDEO_DECODER_HEAP_DESC *pVideoDecoderHeapDesc,
+            _In_opt_  ID3D12ProtectedResourceSession *pProtectedResourceSession,
+            _In_  REFIID riid,
+            _COM_Outptr_  void **ppVideoDecoderHeap) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE CreateVideoProcessor1( 
+            UINT NodeMask,
+            _In_  const D3D12_VIDEO_PROCESS_OUTPUT_STREAM_DESC *pOutputStreamDesc,
+            UINT NumInputStreamDescs,
+            _In_reads_(NumInputStreamDescs)  const D3D12_VIDEO_PROCESS_INPUT_STREAM_DESC *pInputStreamDescs,
+            _In_opt_  ID3D12ProtectedResourceSession *pProtectedResourceSession,
+            _In_  REFIID riid,
+            _COM_Outptr_  void **ppVideoProcessor) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE CreateVideoExtensionCommand( 
+            _In_  const D3D12_VIDEO_EXTENSION_COMMAND_DESC *pDesc,
+            _In_reads_bytes_(CreationParametersDataSizeInBytes)  const void *pCreationParameters,
+            SIZE_T CreationParametersDataSizeInBytes,
+            _In_opt_  ID3D12ProtectedResourceSession *pProtectedResourceSession,
+            _In_  REFIID riid,
+            _COM_Outptr_  void **ppVideoExtensionCommand) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE ExecuteExtensionCommand( 
+            _In_  ID3D12VideoExtensionCommand *pExtensionCommand,
+            _In_reads_bytes_(ExecutionParametersSizeInBytes)  const void *pExecutionParameters,
+            SIZE_T ExecutionParametersSizeInBytes,
+            _Out_writes_bytes_(OutputDataSizeInBytes)  void *pOutputData,
+            SIZE_T OutputDataSizeInBytes) = 0;
+        
+    };
+    
+    
+#else 	/* C style interface */
+
+    typedef struct ID3D12VideoDevice2Vtbl
+    {
+        BEGIN_INTERFACE
+        
+        DECLSPEC_XFGVIRT(IUnknown, QueryInterface)
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            ID3D12VideoDevice2 * This,
+            REFIID riid,
+            _COM_Outptr_  void **ppvObject);
+        
+        DECLSPEC_XFGVIRT(IUnknown, AddRef)
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            ID3D12VideoDevice2 * This);
+        
+        DECLSPEC_XFGVIRT(IUnknown, Release)
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            ID3D12VideoDevice2 * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoDevice, CheckFeatureSupport)
+        HRESULT ( STDMETHODCALLTYPE *CheckFeatureSupport )( 
+            ID3D12VideoDevice2 * This,
+            D3D12_FEATURE_VIDEO FeatureVideo,
+            _Inout_updates_bytes_(FeatureSupportDataSize)  void *pFeatureSupportData,
+            UINT FeatureSupportDataSize);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoDevice, CreateVideoDecoder)
+        HRESULT ( STDMETHODCALLTYPE *CreateVideoDecoder )( 
+            ID3D12VideoDevice2 * This,
+            _In_  const D3D12_VIDEO_DECODER_DESC *pDesc,
+            _In_  REFIID riid,
+            _COM_Outptr_  void **ppVideoDecoder);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoDevice, CreateVideoDecoderHeap)
+        HRESULT ( STDMETHODCALLTYPE *CreateVideoDecoderHeap )( 
+            ID3D12VideoDevice2 * This,
+            _In_  const D3D12_VIDEO_DECODER_HEAP_DESC *pVideoDecoderHeapDesc,
+            _In_  REFIID riid,
+            _COM_Outptr_  void **ppVideoDecoderHeap);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoDevice, CreateVideoProcessor)
+        HRESULT ( STDMETHODCALLTYPE *CreateVideoProcessor )( 
+            ID3D12VideoDevice2 * This,
+            UINT NodeMask,
+            _In_  const D3D12_VIDEO_PROCESS_OUTPUT_STREAM_DESC *pOutputStreamDesc,
+            UINT NumInputStreamDescs,
+            _In_reads_(NumInputStreamDescs)  const D3D12_VIDEO_PROCESS_INPUT_STREAM_DESC *pInputStreamDescs,
+            _In_  REFIID riid,
+            _COM_Outptr_  void **ppVideoProcessor);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoDevice1, CreateVideoMotionEstimator)
+        HRESULT ( STDMETHODCALLTYPE *CreateVideoMotionEstimator )( 
+            ID3D12VideoDevice2 * This,
+            _In_  const D3D12_VIDEO_MOTION_ESTIMATOR_DESC *pDesc,
+            _In_opt_  ID3D12ProtectedResourceSession *pProtectedResourceSession,
+            _In_  REFIID riid,
+            _COM_Outptr_  void **ppVideoMotionEstimator);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoDevice1, CreateVideoMotionVectorHeap)
+        HRESULT ( STDMETHODCALLTYPE *CreateVideoMotionVectorHeap )( 
+            ID3D12VideoDevice2 * This,
+            _In_  const D3D12_VIDEO_MOTION_VECTOR_HEAP_DESC *pDesc,
+            _In_opt_  ID3D12ProtectedResourceSession *pProtectedResourceSession,
+            _In_  REFIID riid,
+            _COM_Outptr_  void **ppVideoMotionVectorHeap);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoDevice2, CreateVideoDecoder1)
+        HRESULT ( STDMETHODCALLTYPE *CreateVideoDecoder1 )( 
+            ID3D12VideoDevice2 * This,
+            _In_  const D3D12_VIDEO_DECODER_DESC *pDesc,
+            _In_opt_  ID3D12ProtectedResourceSession *pProtectedResourceSession,
+            _In_  REFIID riid,
+            _COM_Outptr_  void **ppVideoDecoder);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoDevice2, CreateVideoDecoderHeap1)
+        HRESULT ( STDMETHODCALLTYPE *CreateVideoDecoderHeap1 )( 
+            ID3D12VideoDevice2 * This,
+            _In_  const D3D12_VIDEO_DECODER_HEAP_DESC *pVideoDecoderHeapDesc,
+            _In_opt_  ID3D12ProtectedResourceSession *pProtectedResourceSession,
+            _In_  REFIID riid,
+            _COM_Outptr_  void **ppVideoDecoderHeap);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoDevice2, CreateVideoProcessor1)
+        HRESULT ( STDMETHODCALLTYPE *CreateVideoProcessor1 )( 
+            ID3D12VideoDevice2 * This,
+            UINT NodeMask,
+            _In_  const D3D12_VIDEO_PROCESS_OUTPUT_STREAM_DESC *pOutputStreamDesc,
+            UINT NumInputStreamDescs,
+            _In_reads_(NumInputStreamDescs)  const D3D12_VIDEO_PROCESS_INPUT_STREAM_DESC *pInputStreamDescs,
+            _In_opt_  ID3D12ProtectedResourceSession *pProtectedResourceSession,
+            _In_  REFIID riid,
+            _COM_Outptr_  void **ppVideoProcessor);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoDevice2, CreateVideoExtensionCommand)
+        HRESULT ( STDMETHODCALLTYPE *CreateVideoExtensionCommand )( 
+            ID3D12VideoDevice2 * This,
+            _In_  const D3D12_VIDEO_EXTENSION_COMMAND_DESC *pDesc,
+            _In_reads_bytes_(CreationParametersDataSizeInBytes)  const void *pCreationParameters,
+            SIZE_T CreationParametersDataSizeInBytes,
+            _In_opt_  ID3D12ProtectedResourceSession *pProtectedResourceSession,
+            _In_  REFIID riid,
+            _COM_Outptr_  void **ppVideoExtensionCommand);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoDevice2, ExecuteExtensionCommand)
+        HRESULT ( STDMETHODCALLTYPE *ExecuteExtensionCommand )( 
+            ID3D12VideoDevice2 * This,
+            _In_  ID3D12VideoExtensionCommand *pExtensionCommand,
+            _In_reads_bytes_(ExecutionParametersSizeInBytes)  const void *pExecutionParameters,
+            SIZE_T ExecutionParametersSizeInBytes,
+            _Out_writes_bytes_(OutputDataSizeInBytes)  void *pOutputData,
+            SIZE_T OutputDataSizeInBytes);
+        
+        END_INTERFACE
+    } ID3D12VideoDevice2Vtbl;
+
+    interface ID3D12VideoDevice2
+    {
+        CONST_VTBL struct ID3D12VideoDevice2Vtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define ID3D12VideoDevice2_QueryInterface(This,riid,ppvObject)	\
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define ID3D12VideoDevice2_AddRef(This)	\
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define ID3D12VideoDevice2_Release(This)	\
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#define ID3D12VideoDevice2_CheckFeatureSupport(This,FeatureVideo,pFeatureSupportData,FeatureSupportDataSize)	\
+    ( (This)->lpVtbl -> CheckFeatureSupport(This,FeatureVideo,pFeatureSupportData,FeatureSupportDataSize) ) 
+
+#define ID3D12VideoDevice2_CreateVideoDecoder(This,pDesc,riid,ppVideoDecoder)	\
+    ( (This)->lpVtbl -> CreateVideoDecoder(This,pDesc,riid,ppVideoDecoder) ) 
+
+#define ID3D12VideoDevice2_CreateVideoDecoderHeap(This,pVideoDecoderHeapDesc,riid,ppVideoDecoderHeap)	\
+    ( (This)->lpVtbl -> CreateVideoDecoderHeap(This,pVideoDecoderHeapDesc,riid,ppVideoDecoderHeap) ) 
+
+#define ID3D12VideoDevice2_CreateVideoProcessor(This,NodeMask,pOutputStreamDesc,NumInputStreamDescs,pInputStreamDescs,riid,ppVideoProcessor)	\
+    ( (This)->lpVtbl -> CreateVideoProcessor(This,NodeMask,pOutputStreamDesc,NumInputStreamDescs,pInputStreamDescs,riid,ppVideoProcessor) ) 
+
+
+#define ID3D12VideoDevice2_CreateVideoMotionEstimator(This,pDesc,pProtectedResourceSession,riid,ppVideoMotionEstimator)	\
+    ( (This)->lpVtbl -> CreateVideoMotionEstimator(This,pDesc,pProtectedResourceSession,riid,ppVideoMotionEstimator) ) 
+
+#define ID3D12VideoDevice2_CreateVideoMotionVectorHeap(This,pDesc,pProtectedResourceSession,riid,ppVideoMotionVectorHeap)	\
+    ( (This)->lpVtbl -> CreateVideoMotionVectorHeap(This,pDesc,pProtectedResourceSession,riid,ppVideoMotionVectorHeap) ) 
+
+
+#define ID3D12VideoDevice2_CreateVideoDecoder1(This,pDesc,pProtectedResourceSession,riid,ppVideoDecoder)	\
+    ( (This)->lpVtbl -> CreateVideoDecoder1(This,pDesc,pProtectedResourceSession,riid,ppVideoDecoder) ) 
+
+#define ID3D12VideoDevice2_CreateVideoDecoderHeap1(This,pVideoDecoderHeapDesc,pProtectedResourceSession,riid,ppVideoDecoderHeap)	\
+    ( (This)->lpVtbl -> CreateVideoDecoderHeap1(This,pVideoDecoderHeapDesc,pProtectedResourceSession,riid,ppVideoDecoderHeap) ) 
+
+#define ID3D12VideoDevice2_CreateVideoProcessor1(This,NodeMask,pOutputStreamDesc,NumInputStreamDescs,pInputStreamDescs,pProtectedResourceSession,riid,ppVideoProcessor)	\
+    ( (This)->lpVtbl -> CreateVideoProcessor1(This,NodeMask,pOutputStreamDesc,NumInputStreamDescs,pInputStreamDescs,pProtectedResourceSession,riid,ppVideoProcessor) ) 
+
+#define ID3D12VideoDevice2_CreateVideoExtensionCommand(This,pDesc,pCreationParameters,CreationParametersDataSizeInBytes,pProtectedResourceSession,riid,ppVideoExtensionCommand)	\
+    ( (This)->lpVtbl -> CreateVideoExtensionCommand(This,pDesc,pCreationParameters,CreationParametersDataSizeInBytes,pProtectedResourceSession,riid,ppVideoExtensionCommand) ) 
+
+#define ID3D12VideoDevice2_ExecuteExtensionCommand(This,pExtensionCommand,pExecutionParameters,ExecutionParametersSizeInBytes,pOutputData,OutputDataSizeInBytes)	\
+    ( (This)->lpVtbl -> ExecuteExtensionCommand(This,pExtensionCommand,pExecutionParameters,ExecutionParametersSizeInBytes,pOutputData,OutputDataSizeInBytes) ) 
+
+#endif /* COBJMACROS */
+
+
+#endif 	/* C style interface */
+
+
+
+
+#endif 	/* __ID3D12VideoDevice2_INTERFACE_DEFINED__ */
+
+
+#ifndef __ID3D12VideoDecodeCommandList2_INTERFACE_DEFINED__
+#define __ID3D12VideoDecodeCommandList2_INTERFACE_DEFINED__
+
+/* interface ID3D12VideoDecodeCommandList2 */
+/* [unique][local][object][uuid] */ 
+
+
+EXTERN_C const IID IID_ID3D12VideoDecodeCommandList2;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("6e120880-c114-4153-8036-d247051e1729")
+    ID3D12VideoDecodeCommandList2 : public ID3D12VideoDecodeCommandList1
+    {
+    public:
+        virtual void STDMETHODCALLTYPE SetProtectedResourceSession( 
+            _In_opt_  ID3D12ProtectedResourceSession *pProtectedResourceSession) = 0;
+        
+        virtual void STDMETHODCALLTYPE InitializeExtensionCommand( 
+            _In_  ID3D12VideoExtensionCommand *pExtensionCommand,
+            _In_reads_bytes_(InitializationParametersSizeInBytes)  const void *pInitializationParameters,
+            SIZE_T InitializationParametersSizeInBytes) = 0;
+        
+        virtual void STDMETHODCALLTYPE ExecuteExtensionCommand( 
+            _In_  ID3D12VideoExtensionCommand *pExtensionCommand,
+            _In_reads_bytes_(ExecutionParametersSizeInBytes)  const void *pExecutionParameters,
+            SIZE_T ExecutionParametersSizeInBytes) = 0;
+        
+    };
+    
+    
+#else 	/* C style interface */
+
+    typedef struct ID3D12VideoDecodeCommandList2Vtbl
+    {
+        BEGIN_INTERFACE
+        
+        DECLSPEC_XFGVIRT(IUnknown, QueryInterface)
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            ID3D12VideoDecodeCommandList2 * This,
+            REFIID riid,
+            _COM_Outptr_  void **ppvObject);
+        
+        DECLSPEC_XFGVIRT(IUnknown, AddRef)
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            ID3D12VideoDecodeCommandList2 * This);
+        
+        DECLSPEC_XFGVIRT(IUnknown, Release)
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            ID3D12VideoDecodeCommandList2 * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, GetPrivateData)
+        HRESULT ( STDMETHODCALLTYPE *GetPrivateData )( 
+            ID3D12VideoDecodeCommandList2 * This,
+            _In_  REFGUID guid,
+            _Inout_  UINT *pDataSize,
+            _Out_writes_bytes_opt_( *pDataSize )  void *pData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, SetPrivateData)
+        HRESULT ( STDMETHODCALLTYPE *SetPrivateData )( 
+            ID3D12VideoDecodeCommandList2 * This,
+            _In_  REFGUID guid,
+            _In_  UINT DataSize,
+            _In_reads_bytes_opt_( DataSize )  const void *pData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, SetPrivateDataInterface)
+        HRESULT ( STDMETHODCALLTYPE *SetPrivateDataInterface )( 
+            ID3D12VideoDecodeCommandList2 * This,
+            _In_  REFGUID guid,
+            _In_opt_  const IUnknown *pData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, SetName)
+        HRESULT ( STDMETHODCALLTYPE *SetName )( 
+            ID3D12VideoDecodeCommandList2 * This,
+            _In_z_  LPCWSTR Name);
+        
+        DECLSPEC_XFGVIRT(ID3D12DeviceChild, GetDevice)
+        HRESULT ( STDMETHODCALLTYPE *GetDevice )( 
+            ID3D12VideoDecodeCommandList2 * This,
+            REFIID riid,
+            _COM_Outptr_opt_  void **ppvDevice);
+        
+        DECLSPEC_XFGVIRT(ID3D12CommandList, GetType)
+        D3D12_COMMAND_LIST_TYPE ( STDMETHODCALLTYPE *GetType )( 
+            ID3D12VideoDecodeCommandList2 * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoDecodeCommandList, Close)
+        HRESULT ( STDMETHODCALLTYPE *Close )( 
+            ID3D12VideoDecodeCommandList2 * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoDecodeCommandList, Reset)
+        HRESULT ( STDMETHODCALLTYPE *Reset )( 
+            ID3D12VideoDecodeCommandList2 * This,
+            _In_  ID3D12CommandAllocator *pAllocator);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoDecodeCommandList, ClearState)
+        void ( STDMETHODCALLTYPE *ClearState )( 
+            ID3D12VideoDecodeCommandList2 * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoDecodeCommandList, ResourceBarrier)
+        void ( STDMETHODCALLTYPE *ResourceBarrier )( 
+            ID3D12VideoDecodeCommandList2 * This,
+            _In_  UINT NumBarriers,
+            _In_reads_(NumBarriers)  const D3D12_RESOURCE_BARRIER *pBarriers);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoDecodeCommandList, DiscardResource)
+        void ( STDMETHODCALLTYPE *DiscardResource )( 
+            ID3D12VideoDecodeCommandList2 * This,
+            _In_  ID3D12Resource *pResource,
+            _In_opt_  const D3D12_DISCARD_REGION *pRegion);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoDecodeCommandList, BeginQuery)
+        void ( STDMETHODCALLTYPE *BeginQuery )( 
+            ID3D12VideoDecodeCommandList2 * This,
+            _In_  ID3D12QueryHeap *pQueryHeap,
+            _In_  D3D12_QUERY_TYPE Type,
+            _In_  UINT Index);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoDecodeCommandList, EndQuery)
+        void ( STDMETHODCALLTYPE *EndQuery )( 
+            ID3D12VideoDecodeCommandList2 * This,
+            _In_  ID3D12QueryHeap *pQueryHeap,
+            _In_  D3D12_QUERY_TYPE Type,
+            _In_  UINT Index);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoDecodeCommandList, ResolveQueryData)
+        void ( STDMETHODCALLTYPE *ResolveQueryData )( 
+            ID3D12VideoDecodeCommandList2 * This,
+            _In_  ID3D12QueryHeap *pQueryHeap,
+            _In_  D3D12_QUERY_TYPE Type,
+            _In_  UINT StartIndex,
+            _In_  UINT NumQueries,
+            _In_  ID3D12Resource *pDestinationBuffer,
+            _In_  UINT64 AlignedDestinationBufferOffset);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoDecodeCommandList, SetPredication)
+        void ( STDMETHODCALLTYPE *SetPredication )( 
+            ID3D12VideoDecodeCommandList2 * This,
+            _In_opt_  ID3D12Resource *pBuffer,
+            _In_  UINT64 AlignedBufferOffset,
+            _In_  D3D12_PREDICATION_OP Operation);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoDecodeCommandList, SetMarker)
+        void ( STDMETHODCALLTYPE *SetMarker )( 
+            ID3D12VideoDecodeCommandList2 * This,
+            UINT Metadata,
+            _In_reads_bytes_opt_(Size)  const void *pData,
+            UINT Size);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoDecodeCommandList, BeginEvent)
+        void ( STDMETHODCALLTYPE *BeginEvent )( 
+            ID3D12VideoDecodeCommandList2 * This,
+            UINT Metadata,
+            _In_reads_bytes_opt_(Size)  const void *pData,
+            UINT Size);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoDecodeCommandList, EndEvent)
+        void ( STDMETHODCALLTYPE *EndEvent )( 
+            ID3D12VideoDecodeCommandList2 * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoDecodeCommandList, DecodeFrame)
+        void ( STDMETHODCALLTYPE *DecodeFrame )( 
+            ID3D12VideoDecodeCommandList2 * This,
+            _In_  ID3D12VideoDecoder *pDecoder,
+            _In_  const D3D12_VIDEO_DECODE_OUTPUT_STREAM_ARGUMENTS *pOutputArguments,
+            _In_  const D3D12_VIDEO_DECODE_INPUT_STREAM_ARGUMENTS *pInputArguments);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoDecodeCommandList, WriteBufferImmediate)
+        void ( STDMETHODCALLTYPE *WriteBufferImmediate )( 
+            ID3D12VideoDecodeCommandList2 * This,
+            UINT Count,
+            _In_reads_(Count)  const D3D12_WRITEBUFFERIMMEDIATE_PARAMETER *pParams,
+            _In_reads_opt_(Count)  const D3D12_WRITEBUFFERIMMEDIATE_MODE *pModes);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoDecodeCommandList1, DecodeFrame1)
+        void ( STDMETHODCALLTYPE *DecodeFrame1 )( 
+            ID3D12VideoDecodeCommandList2 * This,
+            _In_  ID3D12VideoDecoder *pDecoder,
+            _In_  const D3D12_VIDEO_DECODE_OUTPUT_STREAM_ARGUMENTS1 *pOutputArguments,
+            _In_  const D3D12_VIDEO_DECODE_INPUT_STREAM_ARGUMENTS *pInputArguments);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoDecodeCommandList2, SetProtectedResourceSession)
+        void ( STDMETHODCALLTYPE *SetProtectedResourceSession )( 
+            ID3D12VideoDecodeCommandList2 * This,
+            _In_opt_  ID3D12ProtectedResourceSession *pProtectedResourceSession);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoDecodeCommandList2, InitializeExtensionCommand)
+        void ( STDMETHODCALLTYPE *InitializeExtensionCommand )( 
+            ID3D12VideoDecodeCommandList2 * This,
+            _In_  ID3D12VideoExtensionCommand *pExtensionCommand,
+            _In_reads_bytes_(InitializationParametersSizeInBytes)  const void *pInitializationParameters,
+            SIZE_T InitializationParametersSizeInBytes);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoDecodeCommandList2, ExecuteExtensionCommand)
+        void ( STDMETHODCALLTYPE *ExecuteExtensionCommand )( 
+            ID3D12VideoDecodeCommandList2 * This,
+            _In_  ID3D12VideoExtensionCommand *pExtensionCommand,
+            _In_reads_bytes_(ExecutionParametersSizeInBytes)  const void *pExecutionParameters,
+            SIZE_T ExecutionParametersSizeInBytes);
+        
+        END_INTERFACE
+    } ID3D12VideoDecodeCommandList2Vtbl;
+
+    interface ID3D12VideoDecodeCommandList2
+    {
+        CONST_VTBL struct ID3D12VideoDecodeCommandList2Vtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define ID3D12VideoDecodeCommandList2_QueryInterface(This,riid,ppvObject)	\
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define ID3D12VideoDecodeCommandList2_AddRef(This)	\
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define ID3D12VideoDecodeCommandList2_Release(This)	\
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#define ID3D12VideoDecodeCommandList2_GetPrivateData(This,guid,pDataSize,pData)	\
+    ( (This)->lpVtbl -> GetPrivateData(This,guid,pDataSize,pData) ) 
+
+#define ID3D12VideoDecodeCommandList2_SetPrivateData(This,guid,DataSize,pData)	\
+    ( (This)->lpVtbl -> SetPrivateData(This,guid,DataSize,pData) ) 
+
+#define ID3D12VideoDecodeCommandList2_SetPrivateDataInterface(This,guid,pData)	\
+    ( (This)->lpVtbl -> SetPrivateDataInterface(This,guid,pData) ) 
+
+#define ID3D12VideoDecodeCommandList2_SetName(This,Name)	\
+    ( (This)->lpVtbl -> SetName(This,Name) ) 
+
+
+#define ID3D12VideoDecodeCommandList2_GetDevice(This,riid,ppvDevice)	\
+    ( (This)->lpVtbl -> GetDevice(This,riid,ppvDevice) ) 
+
+
+#define ID3D12VideoDecodeCommandList2_GetType(This)	\
+    ( (This)->lpVtbl -> GetType(This) ) 
+
+
+#define ID3D12VideoDecodeCommandList2_Close(This)	\
+    ( (This)->lpVtbl -> Close(This) ) 
+
+#define ID3D12VideoDecodeCommandList2_Reset(This,pAllocator)	\
+    ( (This)->lpVtbl -> Reset(This,pAllocator) ) 
+
+#define ID3D12VideoDecodeCommandList2_ClearState(This)	\
+    ( (This)->lpVtbl -> ClearState(This) ) 
+
+#define ID3D12VideoDecodeCommandList2_ResourceBarrier(This,NumBarriers,pBarriers)	\
+    ( (This)->lpVtbl -> ResourceBarrier(This,NumBarriers,pBarriers) ) 
+
+#define ID3D12VideoDecodeCommandList2_DiscardResource(This,pResource,pRegion)	\
+    ( (This)->lpVtbl -> DiscardResource(This,pResource,pRegion) ) 
+
+#define ID3D12VideoDecodeCommandList2_BeginQuery(This,pQueryHeap,Type,Index)	\
+    ( (This)->lpVtbl -> BeginQuery(This,pQueryHeap,Type,Index) ) 
+
+#define ID3D12VideoDecodeCommandList2_EndQuery(This,pQueryHeap,Type,Index)	\
+    ( (This)->lpVtbl -> EndQuery(This,pQueryHeap,Type,Index) ) 
+
+#define ID3D12VideoDecodeCommandList2_ResolveQueryData(This,pQueryHeap,Type,StartIndex,NumQueries,pDestinationBuffer,AlignedDestinationBufferOffset)	\
+    ( (This)->lpVtbl -> ResolveQueryData(This,pQueryHeap,Type,StartIndex,NumQueries,pDestinationBuffer,AlignedDestinationBufferOffset) ) 
+
+#define ID3D12VideoDecodeCommandList2_SetPredication(This,pBuffer,AlignedBufferOffset,Operation)	\
+    ( (This)->lpVtbl -> SetPredication(This,pBuffer,AlignedBufferOffset,Operation) ) 
+
+#define ID3D12VideoDecodeCommandList2_SetMarker(This,Metadata,pData,Size)	\
+    ( (This)->lpVtbl -> SetMarker(This,Metadata,pData,Size) ) 
+
+#define ID3D12VideoDecodeCommandList2_BeginEvent(This,Metadata,pData,Size)	\
+    ( (This)->lpVtbl -> BeginEvent(This,Metadata,pData,Size) ) 
+
+#define ID3D12VideoDecodeCommandList2_EndEvent(This)	\
+    ( (This)->lpVtbl -> EndEvent(This) ) 
+
+#define ID3D12VideoDecodeCommandList2_DecodeFrame(This,pDecoder,pOutputArguments,pInputArguments)	\
+    ( (This)->lpVtbl -> DecodeFrame(This,pDecoder,pOutputArguments,pInputArguments) ) 
+
+#define ID3D12VideoDecodeCommandList2_WriteBufferImmediate(This,Count,pParams,pModes)	\
+    ( (This)->lpVtbl -> WriteBufferImmediate(This,Count,pParams,pModes) ) 
+
+
+#define ID3D12VideoDecodeCommandList2_DecodeFrame1(This,pDecoder,pOutputArguments,pInputArguments)	\
+    ( (This)->lpVtbl -> DecodeFrame1(This,pDecoder,pOutputArguments,pInputArguments) ) 
+
+
+#define ID3D12VideoDecodeCommandList2_SetProtectedResourceSession(This,pProtectedResourceSession)	\
+    ( (This)->lpVtbl -> SetProtectedResourceSession(This,pProtectedResourceSession) ) 
+
+#define ID3D12VideoDecodeCommandList2_InitializeExtensionCommand(This,pExtensionCommand,pInitializationParameters,InitializationParametersSizeInBytes)	\
+    ( (This)->lpVtbl -> InitializeExtensionCommand(This,pExtensionCommand,pInitializationParameters,InitializationParametersSizeInBytes) ) 
+
+#define ID3D12VideoDecodeCommandList2_ExecuteExtensionCommand(This,pExtensionCommand,pExecutionParameters,ExecutionParametersSizeInBytes)	\
+    ( (This)->lpVtbl -> ExecuteExtensionCommand(This,pExtensionCommand,pExecutionParameters,ExecutionParametersSizeInBytes) ) 
+
+#endif /* COBJMACROS */
+
+
+#endif 	/* C style interface */
+
+
+
+
+#endif 	/* __ID3D12VideoDecodeCommandList2_INTERFACE_DEFINED__ */
+
+
+#ifndef __ID3D12VideoDecodeCommandList3_INTERFACE_DEFINED__
+#define __ID3D12VideoDecodeCommandList3_INTERFACE_DEFINED__
+
+/* interface ID3D12VideoDecodeCommandList3 */
+/* [unique][local][object][uuid] */ 
+
+
+EXTERN_C const IID IID_ID3D12VideoDecodeCommandList3;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("2aee8c37-9562-42da-8abf-61efeb2e4513")
+    ID3D12VideoDecodeCommandList3 : public ID3D12VideoDecodeCommandList2
+    {
+    public:
+        virtual void STDMETHODCALLTYPE Barrier( 
+            UINT32 NumBarrierGroups,
+            _In_reads_(NumBarrierGroups)  const D3D12_BARRIER_GROUP *pBarrierGroups) = 0;
+        
+    };
+    
+    
+#else 	/* C style interface */
+
+    typedef struct ID3D12VideoDecodeCommandList3Vtbl
+    {
+        BEGIN_INTERFACE
+        
+        DECLSPEC_XFGVIRT(IUnknown, QueryInterface)
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            ID3D12VideoDecodeCommandList3 * This,
+            REFIID riid,
+            _COM_Outptr_  void **ppvObject);
+        
+        DECLSPEC_XFGVIRT(IUnknown, AddRef)
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            ID3D12VideoDecodeCommandList3 * This);
+        
+        DECLSPEC_XFGVIRT(IUnknown, Release)
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            ID3D12VideoDecodeCommandList3 * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, GetPrivateData)
+        HRESULT ( STDMETHODCALLTYPE *GetPrivateData )( 
+            ID3D12VideoDecodeCommandList3 * This,
+            _In_  REFGUID guid,
+            _Inout_  UINT *pDataSize,
+            _Out_writes_bytes_opt_( *pDataSize )  void *pData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, SetPrivateData)
+        HRESULT ( STDMETHODCALLTYPE *SetPrivateData )( 
+            ID3D12VideoDecodeCommandList3 * This,
+            _In_  REFGUID guid,
+            _In_  UINT DataSize,
+            _In_reads_bytes_opt_( DataSize )  const void *pData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, SetPrivateDataInterface)
+        HRESULT ( STDMETHODCALLTYPE *SetPrivateDataInterface )( 
+            ID3D12VideoDecodeCommandList3 * This,
+            _In_  REFGUID guid,
+            _In_opt_  const IUnknown *pData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, SetName)
+        HRESULT ( STDMETHODCALLTYPE *SetName )( 
+            ID3D12VideoDecodeCommandList3 * This,
+            _In_z_  LPCWSTR Name);
+        
+        DECLSPEC_XFGVIRT(ID3D12DeviceChild, GetDevice)
+        HRESULT ( STDMETHODCALLTYPE *GetDevice )( 
+            ID3D12VideoDecodeCommandList3 * This,
+            REFIID riid,
+            _COM_Outptr_opt_  void **ppvDevice);
+        
+        DECLSPEC_XFGVIRT(ID3D12CommandList, GetType)
+        D3D12_COMMAND_LIST_TYPE ( STDMETHODCALLTYPE *GetType )( 
+            ID3D12VideoDecodeCommandList3 * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoDecodeCommandList, Close)
+        HRESULT ( STDMETHODCALLTYPE *Close )( 
+            ID3D12VideoDecodeCommandList3 * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoDecodeCommandList, Reset)
+        HRESULT ( STDMETHODCALLTYPE *Reset )( 
+            ID3D12VideoDecodeCommandList3 * This,
+            _In_  ID3D12CommandAllocator *pAllocator);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoDecodeCommandList, ClearState)
+        void ( STDMETHODCALLTYPE *ClearState )( 
+            ID3D12VideoDecodeCommandList3 * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoDecodeCommandList, ResourceBarrier)
+        void ( STDMETHODCALLTYPE *ResourceBarrier )( 
+            ID3D12VideoDecodeCommandList3 * This,
+            _In_  UINT NumBarriers,
+            _In_reads_(NumBarriers)  const D3D12_RESOURCE_BARRIER *pBarriers);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoDecodeCommandList, DiscardResource)
+        void ( STDMETHODCALLTYPE *DiscardResource )( 
+            ID3D12VideoDecodeCommandList3 * This,
+            _In_  ID3D12Resource *pResource,
+            _In_opt_  const D3D12_DISCARD_REGION *pRegion);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoDecodeCommandList, BeginQuery)
+        void ( STDMETHODCALLTYPE *BeginQuery )( 
+            ID3D12VideoDecodeCommandList3 * This,
+            _In_  ID3D12QueryHeap *pQueryHeap,
+            _In_  D3D12_QUERY_TYPE Type,
+            _In_  UINT Index);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoDecodeCommandList, EndQuery)
+        void ( STDMETHODCALLTYPE *EndQuery )( 
+            ID3D12VideoDecodeCommandList3 * This,
+            _In_  ID3D12QueryHeap *pQueryHeap,
+            _In_  D3D12_QUERY_TYPE Type,
+            _In_  UINT Index);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoDecodeCommandList, ResolveQueryData)
+        void ( STDMETHODCALLTYPE *ResolveQueryData )( 
+            ID3D12VideoDecodeCommandList3 * This,
+            _In_  ID3D12QueryHeap *pQueryHeap,
+            _In_  D3D12_QUERY_TYPE Type,
+            _In_  UINT StartIndex,
+            _In_  UINT NumQueries,
+            _In_  ID3D12Resource *pDestinationBuffer,
+            _In_  UINT64 AlignedDestinationBufferOffset);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoDecodeCommandList, SetPredication)
+        void ( STDMETHODCALLTYPE *SetPredication )( 
+            ID3D12VideoDecodeCommandList3 * This,
+            _In_opt_  ID3D12Resource *pBuffer,
+            _In_  UINT64 AlignedBufferOffset,
+            _In_  D3D12_PREDICATION_OP Operation);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoDecodeCommandList, SetMarker)
+        void ( STDMETHODCALLTYPE *SetMarker )( 
+            ID3D12VideoDecodeCommandList3 * This,
+            UINT Metadata,
+            _In_reads_bytes_opt_(Size)  const void *pData,
+            UINT Size);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoDecodeCommandList, BeginEvent)
+        void ( STDMETHODCALLTYPE *BeginEvent )( 
+            ID3D12VideoDecodeCommandList3 * This,
+            UINT Metadata,
+            _In_reads_bytes_opt_(Size)  const void *pData,
+            UINT Size);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoDecodeCommandList, EndEvent)
+        void ( STDMETHODCALLTYPE *EndEvent )( 
+            ID3D12VideoDecodeCommandList3 * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoDecodeCommandList, DecodeFrame)
+        void ( STDMETHODCALLTYPE *DecodeFrame )( 
+            ID3D12VideoDecodeCommandList3 * This,
+            _In_  ID3D12VideoDecoder *pDecoder,
+            _In_  const D3D12_VIDEO_DECODE_OUTPUT_STREAM_ARGUMENTS *pOutputArguments,
+            _In_  const D3D12_VIDEO_DECODE_INPUT_STREAM_ARGUMENTS *pInputArguments);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoDecodeCommandList, WriteBufferImmediate)
+        void ( STDMETHODCALLTYPE *WriteBufferImmediate )( 
+            ID3D12VideoDecodeCommandList3 * This,
+            UINT Count,
+            _In_reads_(Count)  const D3D12_WRITEBUFFERIMMEDIATE_PARAMETER *pParams,
+            _In_reads_opt_(Count)  const D3D12_WRITEBUFFERIMMEDIATE_MODE *pModes);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoDecodeCommandList1, DecodeFrame1)
+        void ( STDMETHODCALLTYPE *DecodeFrame1 )( 
+            ID3D12VideoDecodeCommandList3 * This,
+            _In_  ID3D12VideoDecoder *pDecoder,
+            _In_  const D3D12_VIDEO_DECODE_OUTPUT_STREAM_ARGUMENTS1 *pOutputArguments,
+            _In_  const D3D12_VIDEO_DECODE_INPUT_STREAM_ARGUMENTS *pInputArguments);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoDecodeCommandList2, SetProtectedResourceSession)
+        void ( STDMETHODCALLTYPE *SetProtectedResourceSession )( 
+            ID3D12VideoDecodeCommandList3 * This,
+            _In_opt_  ID3D12ProtectedResourceSession *pProtectedResourceSession);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoDecodeCommandList2, InitializeExtensionCommand)
+        void ( STDMETHODCALLTYPE *InitializeExtensionCommand )( 
+            ID3D12VideoDecodeCommandList3 * This,
+            _In_  ID3D12VideoExtensionCommand *pExtensionCommand,
+            _In_reads_bytes_(InitializationParametersSizeInBytes)  const void *pInitializationParameters,
+            SIZE_T InitializationParametersSizeInBytes);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoDecodeCommandList2, ExecuteExtensionCommand)
+        void ( STDMETHODCALLTYPE *ExecuteExtensionCommand )( 
+            ID3D12VideoDecodeCommandList3 * This,
+            _In_  ID3D12VideoExtensionCommand *pExtensionCommand,
+            _In_reads_bytes_(ExecutionParametersSizeInBytes)  const void *pExecutionParameters,
+            SIZE_T ExecutionParametersSizeInBytes);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoDecodeCommandList3, Barrier)
+        void ( STDMETHODCALLTYPE *Barrier )( 
+            ID3D12VideoDecodeCommandList3 * This,
+            UINT32 NumBarrierGroups,
+            _In_reads_(NumBarrierGroups)  const D3D12_BARRIER_GROUP *pBarrierGroups);
+        
+        END_INTERFACE
+    } ID3D12VideoDecodeCommandList3Vtbl;
+
+    interface ID3D12VideoDecodeCommandList3
+    {
+        CONST_VTBL struct ID3D12VideoDecodeCommandList3Vtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define ID3D12VideoDecodeCommandList3_QueryInterface(This,riid,ppvObject)	\
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define ID3D12VideoDecodeCommandList3_AddRef(This)	\
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define ID3D12VideoDecodeCommandList3_Release(This)	\
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#define ID3D12VideoDecodeCommandList3_GetPrivateData(This,guid,pDataSize,pData)	\
+    ( (This)->lpVtbl -> GetPrivateData(This,guid,pDataSize,pData) ) 
+
+#define ID3D12VideoDecodeCommandList3_SetPrivateData(This,guid,DataSize,pData)	\
+    ( (This)->lpVtbl -> SetPrivateData(This,guid,DataSize,pData) ) 
+
+#define ID3D12VideoDecodeCommandList3_SetPrivateDataInterface(This,guid,pData)	\
+    ( (This)->lpVtbl -> SetPrivateDataInterface(This,guid,pData) ) 
+
+#define ID3D12VideoDecodeCommandList3_SetName(This,Name)	\
+    ( (This)->lpVtbl -> SetName(This,Name) ) 
+
+
+#define ID3D12VideoDecodeCommandList3_GetDevice(This,riid,ppvDevice)	\
+    ( (This)->lpVtbl -> GetDevice(This,riid,ppvDevice) ) 
+
+
+#define ID3D12VideoDecodeCommandList3_GetType(This)	\
+    ( (This)->lpVtbl -> GetType(This) ) 
+
+
+#define ID3D12VideoDecodeCommandList3_Close(This)	\
+    ( (This)->lpVtbl -> Close(This) ) 
+
+#define ID3D12VideoDecodeCommandList3_Reset(This,pAllocator)	\
+    ( (This)->lpVtbl -> Reset(This,pAllocator) ) 
+
+#define ID3D12VideoDecodeCommandList3_ClearState(This)	\
+    ( (This)->lpVtbl -> ClearState(This) ) 
+
+#define ID3D12VideoDecodeCommandList3_ResourceBarrier(This,NumBarriers,pBarriers)	\
+    ( (This)->lpVtbl -> ResourceBarrier(This,NumBarriers,pBarriers) ) 
+
+#define ID3D12VideoDecodeCommandList3_DiscardResource(This,pResource,pRegion)	\
+    ( (This)->lpVtbl -> DiscardResource(This,pResource,pRegion) ) 
+
+#define ID3D12VideoDecodeCommandList3_BeginQuery(This,pQueryHeap,Type,Index)	\
+    ( (This)->lpVtbl -> BeginQuery(This,pQueryHeap,Type,Index) ) 
+
+#define ID3D12VideoDecodeCommandList3_EndQuery(This,pQueryHeap,Type,Index)	\
+    ( (This)->lpVtbl -> EndQuery(This,pQueryHeap,Type,Index) ) 
+
+#define ID3D12VideoDecodeCommandList3_ResolveQueryData(This,pQueryHeap,Type,StartIndex,NumQueries,pDestinationBuffer,AlignedDestinationBufferOffset)	\
+    ( (This)->lpVtbl -> ResolveQueryData(This,pQueryHeap,Type,StartIndex,NumQueries,pDestinationBuffer,AlignedDestinationBufferOffset) ) 
+
+#define ID3D12VideoDecodeCommandList3_SetPredication(This,pBuffer,AlignedBufferOffset,Operation)	\
+    ( (This)->lpVtbl -> SetPredication(This,pBuffer,AlignedBufferOffset,Operation) ) 
+
+#define ID3D12VideoDecodeCommandList3_SetMarker(This,Metadata,pData,Size)	\
+    ( (This)->lpVtbl -> SetMarker(This,Metadata,pData,Size) ) 
+
+#define ID3D12VideoDecodeCommandList3_BeginEvent(This,Metadata,pData,Size)	\
+    ( (This)->lpVtbl -> BeginEvent(This,Metadata,pData,Size) ) 
+
+#define ID3D12VideoDecodeCommandList3_EndEvent(This)	\
+    ( (This)->lpVtbl -> EndEvent(This) ) 
+
+#define ID3D12VideoDecodeCommandList3_DecodeFrame(This,pDecoder,pOutputArguments,pInputArguments)	\
+    ( (This)->lpVtbl -> DecodeFrame(This,pDecoder,pOutputArguments,pInputArguments) ) 
+
+#define ID3D12VideoDecodeCommandList3_WriteBufferImmediate(This,Count,pParams,pModes)	\
+    ( (This)->lpVtbl -> WriteBufferImmediate(This,Count,pParams,pModes) ) 
+
+
+#define ID3D12VideoDecodeCommandList3_DecodeFrame1(This,pDecoder,pOutputArguments,pInputArguments)	\
+    ( (This)->lpVtbl -> DecodeFrame1(This,pDecoder,pOutputArguments,pInputArguments) ) 
+
+
+#define ID3D12VideoDecodeCommandList3_SetProtectedResourceSession(This,pProtectedResourceSession)	\
+    ( (This)->lpVtbl -> SetProtectedResourceSession(This,pProtectedResourceSession) ) 
+
+#define ID3D12VideoDecodeCommandList3_InitializeExtensionCommand(This,pExtensionCommand,pInitializationParameters,InitializationParametersSizeInBytes)	\
+    ( (This)->lpVtbl -> InitializeExtensionCommand(This,pExtensionCommand,pInitializationParameters,InitializationParametersSizeInBytes) ) 
+
+#define ID3D12VideoDecodeCommandList3_ExecuteExtensionCommand(This,pExtensionCommand,pExecutionParameters,ExecutionParametersSizeInBytes)	\
+    ( (This)->lpVtbl -> ExecuteExtensionCommand(This,pExtensionCommand,pExecutionParameters,ExecutionParametersSizeInBytes) ) 
+
+
+#define ID3D12VideoDecodeCommandList3_Barrier(This,NumBarrierGroups,pBarrierGroups)	\
+    ( (This)->lpVtbl -> Barrier(This,NumBarrierGroups,pBarrierGroups) ) 
+
+#endif /* COBJMACROS */
+
+
+#endif 	/* C style interface */
+
+
+
+
+#endif 	/* __ID3D12VideoDecodeCommandList3_INTERFACE_DEFINED__ */
+
+
+#ifndef __ID3D12VideoProcessCommandList2_INTERFACE_DEFINED__
+#define __ID3D12VideoProcessCommandList2_INTERFACE_DEFINED__
+
+/* interface ID3D12VideoProcessCommandList2 */
+/* [unique][local][object][uuid] */ 
+
+
+EXTERN_C const IID IID_ID3D12VideoProcessCommandList2;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("db525ae4-6ad6-473c-baa7-59b2e37082e4")
+    ID3D12VideoProcessCommandList2 : public ID3D12VideoProcessCommandList1
+    {
+    public:
+        virtual void STDMETHODCALLTYPE SetProtectedResourceSession( 
+            _In_opt_  ID3D12ProtectedResourceSession *pProtectedResourceSession) = 0;
+        
+        virtual void STDMETHODCALLTYPE InitializeExtensionCommand( 
+            _In_  ID3D12VideoExtensionCommand *pExtensionCommand,
+            _In_reads_bytes_(InitializationParametersSizeInBytes)  const void *pInitializationParameters,
+            SIZE_T InitializationParametersSizeInBytes) = 0;
+        
+        virtual void STDMETHODCALLTYPE ExecuteExtensionCommand( 
+            _In_  ID3D12VideoExtensionCommand *pExtensionCommand,
+            _In_reads_bytes_(ExecutionParametersSizeInBytes)  const void *pExecutionParameters,
+            SIZE_T ExecutionParametersSizeInBytes) = 0;
+        
+    };
+    
+    
+#else 	/* C style interface */
+
+    typedef struct ID3D12VideoProcessCommandList2Vtbl
+    {
+        BEGIN_INTERFACE
+        
+        DECLSPEC_XFGVIRT(IUnknown, QueryInterface)
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            ID3D12VideoProcessCommandList2 * This,
+            REFIID riid,
+            _COM_Outptr_  void **ppvObject);
+        
+        DECLSPEC_XFGVIRT(IUnknown, AddRef)
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            ID3D12VideoProcessCommandList2 * This);
+        
+        DECLSPEC_XFGVIRT(IUnknown, Release)
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            ID3D12VideoProcessCommandList2 * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, GetPrivateData)
+        HRESULT ( STDMETHODCALLTYPE *GetPrivateData )( 
+            ID3D12VideoProcessCommandList2 * This,
+            _In_  REFGUID guid,
+            _Inout_  UINT *pDataSize,
+            _Out_writes_bytes_opt_( *pDataSize )  void *pData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, SetPrivateData)
+        HRESULT ( STDMETHODCALLTYPE *SetPrivateData )( 
+            ID3D12VideoProcessCommandList2 * This,
+            _In_  REFGUID guid,
+            _In_  UINT DataSize,
+            _In_reads_bytes_opt_( DataSize )  const void *pData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, SetPrivateDataInterface)
+        HRESULT ( STDMETHODCALLTYPE *SetPrivateDataInterface )( 
+            ID3D12VideoProcessCommandList2 * This,
+            _In_  REFGUID guid,
+            _In_opt_  const IUnknown *pData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, SetName)
+        HRESULT ( STDMETHODCALLTYPE *SetName )( 
+            ID3D12VideoProcessCommandList2 * This,
+            _In_z_  LPCWSTR Name);
+        
+        DECLSPEC_XFGVIRT(ID3D12DeviceChild, GetDevice)
+        HRESULT ( STDMETHODCALLTYPE *GetDevice )( 
+            ID3D12VideoProcessCommandList2 * This,
+            REFIID riid,
+            _COM_Outptr_opt_  void **ppvDevice);
+        
+        DECLSPEC_XFGVIRT(ID3D12CommandList, GetType)
+        D3D12_COMMAND_LIST_TYPE ( STDMETHODCALLTYPE *GetType )( 
+            ID3D12VideoProcessCommandList2 * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoProcessCommandList, Close)
+        HRESULT ( STDMETHODCALLTYPE *Close )( 
+            ID3D12VideoProcessCommandList2 * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoProcessCommandList, Reset)
+        HRESULT ( STDMETHODCALLTYPE *Reset )( 
+            ID3D12VideoProcessCommandList2 * This,
+            _In_  ID3D12CommandAllocator *pAllocator);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoProcessCommandList, ClearState)
+        void ( STDMETHODCALLTYPE *ClearState )( 
+            ID3D12VideoProcessCommandList2 * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoProcessCommandList, ResourceBarrier)
+        void ( STDMETHODCALLTYPE *ResourceBarrier )( 
+            ID3D12VideoProcessCommandList2 * This,
+            _In_  UINT NumBarriers,
+            _In_reads_(NumBarriers)  const D3D12_RESOURCE_BARRIER *pBarriers);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoProcessCommandList, DiscardResource)
+        void ( STDMETHODCALLTYPE *DiscardResource )( 
+            ID3D12VideoProcessCommandList2 * This,
+            _In_  ID3D12Resource *pResource,
+            _In_opt_  const D3D12_DISCARD_REGION *pRegion);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoProcessCommandList, BeginQuery)
+        void ( STDMETHODCALLTYPE *BeginQuery )( 
+            ID3D12VideoProcessCommandList2 * This,
+            _In_  ID3D12QueryHeap *pQueryHeap,
+            _In_  D3D12_QUERY_TYPE Type,
+            _In_  UINT Index);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoProcessCommandList, EndQuery)
+        void ( STDMETHODCALLTYPE *EndQuery )( 
+            ID3D12VideoProcessCommandList2 * This,
+            _In_  ID3D12QueryHeap *pQueryHeap,
+            _In_  D3D12_QUERY_TYPE Type,
+            _In_  UINT Index);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoProcessCommandList, ResolveQueryData)
+        void ( STDMETHODCALLTYPE *ResolveQueryData )( 
+            ID3D12VideoProcessCommandList2 * This,
+            _In_  ID3D12QueryHeap *pQueryHeap,
+            _In_  D3D12_QUERY_TYPE Type,
+            _In_  UINT StartIndex,
+            _In_  UINT NumQueries,
+            _In_  ID3D12Resource *pDestinationBuffer,
+            _In_  UINT64 AlignedDestinationBufferOffset);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoProcessCommandList, SetPredication)
+        void ( STDMETHODCALLTYPE *SetPredication )( 
+            ID3D12VideoProcessCommandList2 * This,
+            _In_opt_  ID3D12Resource *pBuffer,
+            _In_  UINT64 AlignedBufferOffset,
+            _In_  D3D12_PREDICATION_OP Operation);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoProcessCommandList, SetMarker)
+        void ( STDMETHODCALLTYPE *SetMarker )( 
+            ID3D12VideoProcessCommandList2 * This,
+            UINT Metadata,
+            _In_reads_bytes_opt_(Size)  const void *pData,
+            UINT Size);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoProcessCommandList, BeginEvent)
+        void ( STDMETHODCALLTYPE *BeginEvent )( 
+            ID3D12VideoProcessCommandList2 * This,
+            UINT Metadata,
+            _In_reads_bytes_opt_(Size)  const void *pData,
+            UINT Size);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoProcessCommandList, EndEvent)
+        void ( STDMETHODCALLTYPE *EndEvent )( 
+            ID3D12VideoProcessCommandList2 * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoProcessCommandList, ProcessFrames)
+        void ( STDMETHODCALLTYPE *ProcessFrames )( 
+            ID3D12VideoProcessCommandList2 * This,
+            _In_  ID3D12VideoProcessor *pVideoProcessor,
+            _In_  const D3D12_VIDEO_PROCESS_OUTPUT_STREAM_ARGUMENTS *pOutputArguments,
+            UINT NumInputStreams,
+            _In_reads_(NumInputStreams)  const D3D12_VIDEO_PROCESS_INPUT_STREAM_ARGUMENTS *pInputArguments);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoProcessCommandList, WriteBufferImmediate)
+        void ( STDMETHODCALLTYPE *WriteBufferImmediate )( 
+            ID3D12VideoProcessCommandList2 * This,
+            UINT Count,
+            _In_reads_(Count)  const D3D12_WRITEBUFFERIMMEDIATE_PARAMETER *pParams,
+            _In_reads_opt_(Count)  const D3D12_WRITEBUFFERIMMEDIATE_MODE *pModes);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoProcessCommandList1, ProcessFrames1)
+        void ( STDMETHODCALLTYPE *ProcessFrames1 )( 
+            ID3D12VideoProcessCommandList2 * This,
+            _In_  ID3D12VideoProcessor *pVideoProcessor,
+            _In_  const D3D12_VIDEO_PROCESS_OUTPUT_STREAM_ARGUMENTS *pOutputArguments,
+            UINT NumInputStreams,
+            _In_reads_(NumInputStreams)  const D3D12_VIDEO_PROCESS_INPUT_STREAM_ARGUMENTS1 *pInputArguments);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoProcessCommandList2, SetProtectedResourceSession)
+        void ( STDMETHODCALLTYPE *SetProtectedResourceSession )( 
+            ID3D12VideoProcessCommandList2 * This,
+            _In_opt_  ID3D12ProtectedResourceSession *pProtectedResourceSession);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoProcessCommandList2, InitializeExtensionCommand)
+        void ( STDMETHODCALLTYPE *InitializeExtensionCommand )( 
+            ID3D12VideoProcessCommandList2 * This,
+            _In_  ID3D12VideoExtensionCommand *pExtensionCommand,
+            _In_reads_bytes_(InitializationParametersSizeInBytes)  const void *pInitializationParameters,
+            SIZE_T InitializationParametersSizeInBytes);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoProcessCommandList2, ExecuteExtensionCommand)
+        void ( STDMETHODCALLTYPE *ExecuteExtensionCommand )( 
+            ID3D12VideoProcessCommandList2 * This,
+            _In_  ID3D12VideoExtensionCommand *pExtensionCommand,
+            _In_reads_bytes_(ExecutionParametersSizeInBytes)  const void *pExecutionParameters,
+            SIZE_T ExecutionParametersSizeInBytes);
+        
+        END_INTERFACE
+    } ID3D12VideoProcessCommandList2Vtbl;
+
+    interface ID3D12VideoProcessCommandList2
+    {
+        CONST_VTBL struct ID3D12VideoProcessCommandList2Vtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define ID3D12VideoProcessCommandList2_QueryInterface(This,riid,ppvObject)	\
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define ID3D12VideoProcessCommandList2_AddRef(This)	\
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define ID3D12VideoProcessCommandList2_Release(This)	\
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#define ID3D12VideoProcessCommandList2_GetPrivateData(This,guid,pDataSize,pData)	\
+    ( (This)->lpVtbl -> GetPrivateData(This,guid,pDataSize,pData) ) 
+
+#define ID3D12VideoProcessCommandList2_SetPrivateData(This,guid,DataSize,pData)	\
+    ( (This)->lpVtbl -> SetPrivateData(This,guid,DataSize,pData) ) 
+
+#define ID3D12VideoProcessCommandList2_SetPrivateDataInterface(This,guid,pData)	\
+    ( (This)->lpVtbl -> SetPrivateDataInterface(This,guid,pData) ) 
+
+#define ID3D12VideoProcessCommandList2_SetName(This,Name)	\
+    ( (This)->lpVtbl -> SetName(This,Name) ) 
+
+
+#define ID3D12VideoProcessCommandList2_GetDevice(This,riid,ppvDevice)	\
+    ( (This)->lpVtbl -> GetDevice(This,riid,ppvDevice) ) 
+
+
+#define ID3D12VideoProcessCommandList2_GetType(This)	\
+    ( (This)->lpVtbl -> GetType(This) ) 
+
+
+#define ID3D12VideoProcessCommandList2_Close(This)	\
+    ( (This)->lpVtbl -> Close(This) ) 
+
+#define ID3D12VideoProcessCommandList2_Reset(This,pAllocator)	\
+    ( (This)->lpVtbl -> Reset(This,pAllocator) ) 
+
+#define ID3D12VideoProcessCommandList2_ClearState(This)	\
+    ( (This)->lpVtbl -> ClearState(This) ) 
+
+#define ID3D12VideoProcessCommandList2_ResourceBarrier(This,NumBarriers,pBarriers)	\
+    ( (This)->lpVtbl -> ResourceBarrier(This,NumBarriers,pBarriers) ) 
+
+#define ID3D12VideoProcessCommandList2_DiscardResource(This,pResource,pRegion)	\
+    ( (This)->lpVtbl -> DiscardResource(This,pResource,pRegion) ) 
+
+#define ID3D12VideoProcessCommandList2_BeginQuery(This,pQueryHeap,Type,Index)	\
+    ( (This)->lpVtbl -> BeginQuery(This,pQueryHeap,Type,Index) ) 
+
+#define ID3D12VideoProcessCommandList2_EndQuery(This,pQueryHeap,Type,Index)	\
+    ( (This)->lpVtbl -> EndQuery(This,pQueryHeap,Type,Index) ) 
+
+#define ID3D12VideoProcessCommandList2_ResolveQueryData(This,pQueryHeap,Type,StartIndex,NumQueries,pDestinationBuffer,AlignedDestinationBufferOffset)	\
+    ( (This)->lpVtbl -> ResolveQueryData(This,pQueryHeap,Type,StartIndex,NumQueries,pDestinationBuffer,AlignedDestinationBufferOffset) ) 
+
+#define ID3D12VideoProcessCommandList2_SetPredication(This,pBuffer,AlignedBufferOffset,Operation)	\
+    ( (This)->lpVtbl -> SetPredication(This,pBuffer,AlignedBufferOffset,Operation) ) 
+
+#define ID3D12VideoProcessCommandList2_SetMarker(This,Metadata,pData,Size)	\
+    ( (This)->lpVtbl -> SetMarker(This,Metadata,pData,Size) ) 
+
+#define ID3D12VideoProcessCommandList2_BeginEvent(This,Metadata,pData,Size)	\
+    ( (This)->lpVtbl -> BeginEvent(This,Metadata,pData,Size) ) 
+
+#define ID3D12VideoProcessCommandList2_EndEvent(This)	\
+    ( (This)->lpVtbl -> EndEvent(This) ) 
+
+#define ID3D12VideoProcessCommandList2_ProcessFrames(This,pVideoProcessor,pOutputArguments,NumInputStreams,pInputArguments)	\
+    ( (This)->lpVtbl -> ProcessFrames(This,pVideoProcessor,pOutputArguments,NumInputStreams,pInputArguments) ) 
+
+#define ID3D12VideoProcessCommandList2_WriteBufferImmediate(This,Count,pParams,pModes)	\
+    ( (This)->lpVtbl -> WriteBufferImmediate(This,Count,pParams,pModes) ) 
+
+
+#define ID3D12VideoProcessCommandList2_ProcessFrames1(This,pVideoProcessor,pOutputArguments,NumInputStreams,pInputArguments)	\
+    ( (This)->lpVtbl -> ProcessFrames1(This,pVideoProcessor,pOutputArguments,NumInputStreams,pInputArguments) ) 
+
+
+#define ID3D12VideoProcessCommandList2_SetProtectedResourceSession(This,pProtectedResourceSession)	\
+    ( (This)->lpVtbl -> SetProtectedResourceSession(This,pProtectedResourceSession) ) 
+
+#define ID3D12VideoProcessCommandList2_InitializeExtensionCommand(This,pExtensionCommand,pInitializationParameters,InitializationParametersSizeInBytes)	\
+    ( (This)->lpVtbl -> InitializeExtensionCommand(This,pExtensionCommand,pInitializationParameters,InitializationParametersSizeInBytes) ) 
+
+#define ID3D12VideoProcessCommandList2_ExecuteExtensionCommand(This,pExtensionCommand,pExecutionParameters,ExecutionParametersSizeInBytes)	\
+    ( (This)->lpVtbl -> ExecuteExtensionCommand(This,pExtensionCommand,pExecutionParameters,ExecutionParametersSizeInBytes) ) 
+
+#endif /* COBJMACROS */
+
+
+#endif 	/* C style interface */
+
+
+
+
+#endif 	/* __ID3D12VideoProcessCommandList2_INTERFACE_DEFINED__ */
+
+
+#ifndef __ID3D12VideoProcessCommandList3_INTERFACE_DEFINED__
+#define __ID3D12VideoProcessCommandList3_INTERFACE_DEFINED__
+
+/* interface ID3D12VideoProcessCommandList3 */
+/* [unique][local][object][uuid] */ 
+
+
+EXTERN_C const IID IID_ID3D12VideoProcessCommandList3;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("1a0a4ca4-9f08-40ce-9558-b411fd2666ff")
+    ID3D12VideoProcessCommandList3 : public ID3D12VideoProcessCommandList2
+    {
+    public:
+        virtual void STDMETHODCALLTYPE Barrier( 
+            UINT32 NumBarrierGroups,
+            _In_reads_(NumBarrierGroups)  const D3D12_BARRIER_GROUP *pBarrierGroups) = 0;
+        
+    };
+    
+    
+#else 	/* C style interface */
+
+    typedef struct ID3D12VideoProcessCommandList3Vtbl
+    {
+        BEGIN_INTERFACE
+        
+        DECLSPEC_XFGVIRT(IUnknown, QueryInterface)
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            ID3D12VideoProcessCommandList3 * This,
+            REFIID riid,
+            _COM_Outptr_  void **ppvObject);
+        
+        DECLSPEC_XFGVIRT(IUnknown, AddRef)
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            ID3D12VideoProcessCommandList3 * This);
+        
+        DECLSPEC_XFGVIRT(IUnknown, Release)
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            ID3D12VideoProcessCommandList3 * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, GetPrivateData)
+        HRESULT ( STDMETHODCALLTYPE *GetPrivateData )( 
+            ID3D12VideoProcessCommandList3 * This,
+            _In_  REFGUID guid,
+            _Inout_  UINT *pDataSize,
+            _Out_writes_bytes_opt_( *pDataSize )  void *pData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, SetPrivateData)
+        HRESULT ( STDMETHODCALLTYPE *SetPrivateData )( 
+            ID3D12VideoProcessCommandList3 * This,
+            _In_  REFGUID guid,
+            _In_  UINT DataSize,
+            _In_reads_bytes_opt_( DataSize )  const void *pData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, SetPrivateDataInterface)
+        HRESULT ( STDMETHODCALLTYPE *SetPrivateDataInterface )( 
+            ID3D12VideoProcessCommandList3 * This,
+            _In_  REFGUID guid,
+            _In_opt_  const IUnknown *pData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, SetName)
+        HRESULT ( STDMETHODCALLTYPE *SetName )( 
+            ID3D12VideoProcessCommandList3 * This,
+            _In_z_  LPCWSTR Name);
+        
+        DECLSPEC_XFGVIRT(ID3D12DeviceChild, GetDevice)
+        HRESULT ( STDMETHODCALLTYPE *GetDevice )( 
+            ID3D12VideoProcessCommandList3 * This,
+            REFIID riid,
+            _COM_Outptr_opt_  void **ppvDevice);
+        
+        DECLSPEC_XFGVIRT(ID3D12CommandList, GetType)
+        D3D12_COMMAND_LIST_TYPE ( STDMETHODCALLTYPE *GetType )( 
+            ID3D12VideoProcessCommandList3 * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoProcessCommandList, Close)
+        HRESULT ( STDMETHODCALLTYPE *Close )( 
+            ID3D12VideoProcessCommandList3 * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoProcessCommandList, Reset)
+        HRESULT ( STDMETHODCALLTYPE *Reset )( 
+            ID3D12VideoProcessCommandList3 * This,
+            _In_  ID3D12CommandAllocator *pAllocator);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoProcessCommandList, ClearState)
+        void ( STDMETHODCALLTYPE *ClearState )( 
+            ID3D12VideoProcessCommandList3 * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoProcessCommandList, ResourceBarrier)
+        void ( STDMETHODCALLTYPE *ResourceBarrier )( 
+            ID3D12VideoProcessCommandList3 * This,
+            _In_  UINT NumBarriers,
+            _In_reads_(NumBarriers)  const D3D12_RESOURCE_BARRIER *pBarriers);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoProcessCommandList, DiscardResource)
+        void ( STDMETHODCALLTYPE *DiscardResource )( 
+            ID3D12VideoProcessCommandList3 * This,
+            _In_  ID3D12Resource *pResource,
+            _In_opt_  const D3D12_DISCARD_REGION *pRegion);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoProcessCommandList, BeginQuery)
+        void ( STDMETHODCALLTYPE *BeginQuery )( 
+            ID3D12VideoProcessCommandList3 * This,
+            _In_  ID3D12QueryHeap *pQueryHeap,
+            _In_  D3D12_QUERY_TYPE Type,
+            _In_  UINT Index);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoProcessCommandList, EndQuery)
+        void ( STDMETHODCALLTYPE *EndQuery )( 
+            ID3D12VideoProcessCommandList3 * This,
+            _In_  ID3D12QueryHeap *pQueryHeap,
+            _In_  D3D12_QUERY_TYPE Type,
+            _In_  UINT Index);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoProcessCommandList, ResolveQueryData)
+        void ( STDMETHODCALLTYPE *ResolveQueryData )( 
+            ID3D12VideoProcessCommandList3 * This,
+            _In_  ID3D12QueryHeap *pQueryHeap,
+            _In_  D3D12_QUERY_TYPE Type,
+            _In_  UINT StartIndex,
+            _In_  UINT NumQueries,
+            _In_  ID3D12Resource *pDestinationBuffer,
+            _In_  UINT64 AlignedDestinationBufferOffset);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoProcessCommandList, SetPredication)
+        void ( STDMETHODCALLTYPE *SetPredication )( 
+            ID3D12VideoProcessCommandList3 * This,
+            _In_opt_  ID3D12Resource *pBuffer,
+            _In_  UINT64 AlignedBufferOffset,
+            _In_  D3D12_PREDICATION_OP Operation);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoProcessCommandList, SetMarker)
+        void ( STDMETHODCALLTYPE *SetMarker )( 
+            ID3D12VideoProcessCommandList3 * This,
+            UINT Metadata,
+            _In_reads_bytes_opt_(Size)  const void *pData,
+            UINT Size);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoProcessCommandList, BeginEvent)
+        void ( STDMETHODCALLTYPE *BeginEvent )( 
+            ID3D12VideoProcessCommandList3 * This,
+            UINT Metadata,
+            _In_reads_bytes_opt_(Size)  const void *pData,
+            UINT Size);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoProcessCommandList, EndEvent)
+        void ( STDMETHODCALLTYPE *EndEvent )( 
+            ID3D12VideoProcessCommandList3 * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoProcessCommandList, ProcessFrames)
+        void ( STDMETHODCALLTYPE *ProcessFrames )( 
+            ID3D12VideoProcessCommandList3 * This,
+            _In_  ID3D12VideoProcessor *pVideoProcessor,
+            _In_  const D3D12_VIDEO_PROCESS_OUTPUT_STREAM_ARGUMENTS *pOutputArguments,
+            UINT NumInputStreams,
+            _In_reads_(NumInputStreams)  const D3D12_VIDEO_PROCESS_INPUT_STREAM_ARGUMENTS *pInputArguments);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoProcessCommandList, WriteBufferImmediate)
+        void ( STDMETHODCALLTYPE *WriteBufferImmediate )( 
+            ID3D12VideoProcessCommandList3 * This,
+            UINT Count,
+            _In_reads_(Count)  const D3D12_WRITEBUFFERIMMEDIATE_PARAMETER *pParams,
+            _In_reads_opt_(Count)  const D3D12_WRITEBUFFERIMMEDIATE_MODE *pModes);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoProcessCommandList1, ProcessFrames1)
+        void ( STDMETHODCALLTYPE *ProcessFrames1 )( 
+            ID3D12VideoProcessCommandList3 * This,
+            _In_  ID3D12VideoProcessor *pVideoProcessor,
+            _In_  const D3D12_VIDEO_PROCESS_OUTPUT_STREAM_ARGUMENTS *pOutputArguments,
+            UINT NumInputStreams,
+            _In_reads_(NumInputStreams)  const D3D12_VIDEO_PROCESS_INPUT_STREAM_ARGUMENTS1 *pInputArguments);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoProcessCommandList2, SetProtectedResourceSession)
+        void ( STDMETHODCALLTYPE *SetProtectedResourceSession )( 
+            ID3D12VideoProcessCommandList3 * This,
+            _In_opt_  ID3D12ProtectedResourceSession *pProtectedResourceSession);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoProcessCommandList2, InitializeExtensionCommand)
+        void ( STDMETHODCALLTYPE *InitializeExtensionCommand )( 
+            ID3D12VideoProcessCommandList3 * This,
+            _In_  ID3D12VideoExtensionCommand *pExtensionCommand,
+            _In_reads_bytes_(InitializationParametersSizeInBytes)  const void *pInitializationParameters,
+            SIZE_T InitializationParametersSizeInBytes);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoProcessCommandList2, ExecuteExtensionCommand)
+        void ( STDMETHODCALLTYPE *ExecuteExtensionCommand )( 
+            ID3D12VideoProcessCommandList3 * This,
+            _In_  ID3D12VideoExtensionCommand *pExtensionCommand,
+            _In_reads_bytes_(ExecutionParametersSizeInBytes)  const void *pExecutionParameters,
+            SIZE_T ExecutionParametersSizeInBytes);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoProcessCommandList3, Barrier)
+        void ( STDMETHODCALLTYPE *Barrier )( 
+            ID3D12VideoProcessCommandList3 * This,
+            UINT32 NumBarrierGroups,
+            _In_reads_(NumBarrierGroups)  const D3D12_BARRIER_GROUP *pBarrierGroups);
+        
+        END_INTERFACE
+    } ID3D12VideoProcessCommandList3Vtbl;
+
+    interface ID3D12VideoProcessCommandList3
+    {
+        CONST_VTBL struct ID3D12VideoProcessCommandList3Vtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define ID3D12VideoProcessCommandList3_QueryInterface(This,riid,ppvObject)	\
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define ID3D12VideoProcessCommandList3_AddRef(This)	\
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define ID3D12VideoProcessCommandList3_Release(This)	\
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#define ID3D12VideoProcessCommandList3_GetPrivateData(This,guid,pDataSize,pData)	\
+    ( (This)->lpVtbl -> GetPrivateData(This,guid,pDataSize,pData) ) 
+
+#define ID3D12VideoProcessCommandList3_SetPrivateData(This,guid,DataSize,pData)	\
+    ( (This)->lpVtbl -> SetPrivateData(This,guid,DataSize,pData) ) 
+
+#define ID3D12VideoProcessCommandList3_SetPrivateDataInterface(This,guid,pData)	\
+    ( (This)->lpVtbl -> SetPrivateDataInterface(This,guid,pData) ) 
+
+#define ID3D12VideoProcessCommandList3_SetName(This,Name)	\
+    ( (This)->lpVtbl -> SetName(This,Name) ) 
+
+
+#define ID3D12VideoProcessCommandList3_GetDevice(This,riid,ppvDevice)	\
+    ( (This)->lpVtbl -> GetDevice(This,riid,ppvDevice) ) 
+
+
+#define ID3D12VideoProcessCommandList3_GetType(This)	\
+    ( (This)->lpVtbl -> GetType(This) ) 
+
+
+#define ID3D12VideoProcessCommandList3_Close(This)	\
+    ( (This)->lpVtbl -> Close(This) ) 
+
+#define ID3D12VideoProcessCommandList3_Reset(This,pAllocator)	\
+    ( (This)->lpVtbl -> Reset(This,pAllocator) ) 
+
+#define ID3D12VideoProcessCommandList3_ClearState(This)	\
+    ( (This)->lpVtbl -> ClearState(This) ) 
+
+#define ID3D12VideoProcessCommandList3_ResourceBarrier(This,NumBarriers,pBarriers)	\
+    ( (This)->lpVtbl -> ResourceBarrier(This,NumBarriers,pBarriers) ) 
+
+#define ID3D12VideoProcessCommandList3_DiscardResource(This,pResource,pRegion)	\
+    ( (This)->lpVtbl -> DiscardResource(This,pResource,pRegion) ) 
+
+#define ID3D12VideoProcessCommandList3_BeginQuery(This,pQueryHeap,Type,Index)	\
+    ( (This)->lpVtbl -> BeginQuery(This,pQueryHeap,Type,Index) ) 
+
+#define ID3D12VideoProcessCommandList3_EndQuery(This,pQueryHeap,Type,Index)	\
+    ( (This)->lpVtbl -> EndQuery(This,pQueryHeap,Type,Index) ) 
+
+#define ID3D12VideoProcessCommandList3_ResolveQueryData(This,pQueryHeap,Type,StartIndex,NumQueries,pDestinationBuffer,AlignedDestinationBufferOffset)	\
+    ( (This)->lpVtbl -> ResolveQueryData(This,pQueryHeap,Type,StartIndex,NumQueries,pDestinationBuffer,AlignedDestinationBufferOffset) ) 
+
+#define ID3D12VideoProcessCommandList3_SetPredication(This,pBuffer,AlignedBufferOffset,Operation)	\
+    ( (This)->lpVtbl -> SetPredication(This,pBuffer,AlignedBufferOffset,Operation) ) 
+
+#define ID3D12VideoProcessCommandList3_SetMarker(This,Metadata,pData,Size)	\
+    ( (This)->lpVtbl -> SetMarker(This,Metadata,pData,Size) ) 
+
+#define ID3D12VideoProcessCommandList3_BeginEvent(This,Metadata,pData,Size)	\
+    ( (This)->lpVtbl -> BeginEvent(This,Metadata,pData,Size) ) 
+
+#define ID3D12VideoProcessCommandList3_EndEvent(This)	\
+    ( (This)->lpVtbl -> EndEvent(This) ) 
+
+#define ID3D12VideoProcessCommandList3_ProcessFrames(This,pVideoProcessor,pOutputArguments,NumInputStreams,pInputArguments)	\
+    ( (This)->lpVtbl -> ProcessFrames(This,pVideoProcessor,pOutputArguments,NumInputStreams,pInputArguments) ) 
+
+#define ID3D12VideoProcessCommandList3_WriteBufferImmediate(This,Count,pParams,pModes)	\
+    ( (This)->lpVtbl -> WriteBufferImmediate(This,Count,pParams,pModes) ) 
+
+
+#define ID3D12VideoProcessCommandList3_ProcessFrames1(This,pVideoProcessor,pOutputArguments,NumInputStreams,pInputArguments)	\
+    ( (This)->lpVtbl -> ProcessFrames1(This,pVideoProcessor,pOutputArguments,NumInputStreams,pInputArguments) ) 
+
+
+#define ID3D12VideoProcessCommandList3_SetProtectedResourceSession(This,pProtectedResourceSession)	\
+    ( (This)->lpVtbl -> SetProtectedResourceSession(This,pProtectedResourceSession) ) 
+
+#define ID3D12VideoProcessCommandList3_InitializeExtensionCommand(This,pExtensionCommand,pInitializationParameters,InitializationParametersSizeInBytes)	\
+    ( (This)->lpVtbl -> InitializeExtensionCommand(This,pExtensionCommand,pInitializationParameters,InitializationParametersSizeInBytes) ) 
+
+#define ID3D12VideoProcessCommandList3_ExecuteExtensionCommand(This,pExtensionCommand,pExecutionParameters,ExecutionParametersSizeInBytes)	\
+    ( (This)->lpVtbl -> ExecuteExtensionCommand(This,pExtensionCommand,pExecutionParameters,ExecutionParametersSizeInBytes) ) 
+
+
+#define ID3D12VideoProcessCommandList3_Barrier(This,NumBarrierGroups,pBarrierGroups)	\
+    ( (This)->lpVtbl -> Barrier(This,NumBarrierGroups,pBarrierGroups) ) 
+
+#endif /* COBJMACROS */
+
+
+#endif 	/* C style interface */
+
+
+
+
+#endif 	/* __ID3D12VideoProcessCommandList3_INTERFACE_DEFINED__ */
+
+
+#ifndef __ID3D12VideoEncodeCommandList1_INTERFACE_DEFINED__
+#define __ID3D12VideoEncodeCommandList1_INTERFACE_DEFINED__
+
+/* interface ID3D12VideoEncodeCommandList1 */
+/* [unique][local][object][uuid] */ 
+
+
+EXTERN_C const IID IID_ID3D12VideoEncodeCommandList1;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("94971eca-2bdb-4769-88cf-3675ea757ebc")
+    ID3D12VideoEncodeCommandList1 : public ID3D12VideoEncodeCommandList
+    {
+    public:
+        virtual void STDMETHODCALLTYPE InitializeExtensionCommand( 
+            _In_  ID3D12VideoExtensionCommand *pExtensionCommand,
+            _In_reads_bytes_(InitializationParametersSizeInBytes)  const void *pInitializationParameters,
+            SIZE_T InitializationParametersSizeInBytes) = 0;
+        
+        virtual void STDMETHODCALLTYPE ExecuteExtensionCommand( 
+            _In_  ID3D12VideoExtensionCommand *pExtensionCommand,
+            _In_reads_bytes_(ExecutionParametersSizeInBytes)  const void *pExecutionParameters,
+            SIZE_T ExecutionParametersSizeInBytes) = 0;
+        
+    };
+    
+    
+#else 	/* C style interface */
+
+    typedef struct ID3D12VideoEncodeCommandList1Vtbl
+    {
+        BEGIN_INTERFACE
+        
+        DECLSPEC_XFGVIRT(IUnknown, QueryInterface)
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            ID3D12VideoEncodeCommandList1 * This,
+            REFIID riid,
+            _COM_Outptr_  void **ppvObject);
+        
+        DECLSPEC_XFGVIRT(IUnknown, AddRef)
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            ID3D12VideoEncodeCommandList1 * This);
+        
+        DECLSPEC_XFGVIRT(IUnknown, Release)
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            ID3D12VideoEncodeCommandList1 * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, GetPrivateData)
+        HRESULT ( STDMETHODCALLTYPE *GetPrivateData )( 
+            ID3D12VideoEncodeCommandList1 * This,
+            _In_  REFGUID guid,
+            _Inout_  UINT *pDataSize,
+            _Out_writes_bytes_opt_( *pDataSize )  void *pData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, SetPrivateData)
+        HRESULT ( STDMETHODCALLTYPE *SetPrivateData )( 
+            ID3D12VideoEncodeCommandList1 * This,
+            _In_  REFGUID guid,
+            _In_  UINT DataSize,
+            _In_reads_bytes_opt_( DataSize )  const void *pData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, SetPrivateDataInterface)
+        HRESULT ( STDMETHODCALLTYPE *SetPrivateDataInterface )( 
+            ID3D12VideoEncodeCommandList1 * This,
+            _In_  REFGUID guid,
+            _In_opt_  const IUnknown *pData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, SetName)
+        HRESULT ( STDMETHODCALLTYPE *SetName )( 
+            ID3D12VideoEncodeCommandList1 * This,
+            _In_z_  LPCWSTR Name);
+        
+        DECLSPEC_XFGVIRT(ID3D12DeviceChild, GetDevice)
+        HRESULT ( STDMETHODCALLTYPE *GetDevice )( 
+            ID3D12VideoEncodeCommandList1 * This,
+            REFIID riid,
+            _COM_Outptr_opt_  void **ppvDevice);
+        
+        DECLSPEC_XFGVIRT(ID3D12CommandList, GetType)
+        D3D12_COMMAND_LIST_TYPE ( STDMETHODCALLTYPE *GetType )( 
+            ID3D12VideoEncodeCommandList1 * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoEncodeCommandList, Close)
+        HRESULT ( STDMETHODCALLTYPE *Close )( 
+            ID3D12VideoEncodeCommandList1 * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoEncodeCommandList, Reset)
+        HRESULT ( STDMETHODCALLTYPE *Reset )( 
+            ID3D12VideoEncodeCommandList1 * This,
+            _In_  ID3D12CommandAllocator *pAllocator);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoEncodeCommandList, ClearState)
+        void ( STDMETHODCALLTYPE *ClearState )( 
+            ID3D12VideoEncodeCommandList1 * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoEncodeCommandList, ResourceBarrier)
+        void ( STDMETHODCALLTYPE *ResourceBarrier )( 
+            ID3D12VideoEncodeCommandList1 * This,
+            _In_  UINT NumBarriers,
+            _In_reads_(NumBarriers)  const D3D12_RESOURCE_BARRIER *pBarriers);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoEncodeCommandList, DiscardResource)
+        void ( STDMETHODCALLTYPE *DiscardResource )( 
+            ID3D12VideoEncodeCommandList1 * This,
+            _In_  ID3D12Resource *pResource,
+            _In_opt_  const D3D12_DISCARD_REGION *pRegion);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoEncodeCommandList, BeginQuery)
+        void ( STDMETHODCALLTYPE *BeginQuery )( 
+            ID3D12VideoEncodeCommandList1 * This,
+            _In_  ID3D12QueryHeap *pQueryHeap,
+            _In_  D3D12_QUERY_TYPE Type,
+            _In_  UINT Index);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoEncodeCommandList, EndQuery)
+        void ( STDMETHODCALLTYPE *EndQuery )( 
+            ID3D12VideoEncodeCommandList1 * This,
+            _In_  ID3D12QueryHeap *pQueryHeap,
+            _In_  D3D12_QUERY_TYPE Type,
+            _In_  UINT Index);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoEncodeCommandList, ResolveQueryData)
+        void ( STDMETHODCALLTYPE *ResolveQueryData )( 
+            ID3D12VideoEncodeCommandList1 * This,
+            _In_  ID3D12QueryHeap *pQueryHeap,
+            _In_  D3D12_QUERY_TYPE Type,
+            _In_  UINT StartIndex,
+            _In_  UINT NumQueries,
+            _In_  ID3D12Resource *pDestinationBuffer,
+            _In_  UINT64 AlignedDestinationBufferOffset);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoEncodeCommandList, SetPredication)
+        void ( STDMETHODCALLTYPE *SetPredication )( 
+            ID3D12VideoEncodeCommandList1 * This,
+            _In_opt_  ID3D12Resource *pBuffer,
+            _In_  UINT64 AlignedBufferOffset,
+            _In_  D3D12_PREDICATION_OP Operation);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoEncodeCommandList, SetMarker)
+        void ( STDMETHODCALLTYPE *SetMarker )( 
+            ID3D12VideoEncodeCommandList1 * This,
+            UINT Metadata,
+            _In_reads_bytes_opt_(Size)  const void *pData,
+            UINT Size);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoEncodeCommandList, BeginEvent)
+        void ( STDMETHODCALLTYPE *BeginEvent )( 
+            ID3D12VideoEncodeCommandList1 * This,
+            UINT Metadata,
+            _In_reads_bytes_opt_(Size)  const void *pData,
+            UINT Size);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoEncodeCommandList, EndEvent)
+        void ( STDMETHODCALLTYPE *EndEvent )( 
+            ID3D12VideoEncodeCommandList1 * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoEncodeCommandList, EstimateMotion)
+        void ( STDMETHODCALLTYPE *EstimateMotion )( 
+            ID3D12VideoEncodeCommandList1 * This,
+            _In_  ID3D12VideoMotionEstimator *pMotionEstimator,
+            _In_  const D3D12_VIDEO_MOTION_ESTIMATOR_OUTPUT *pOutputArguments,
+            _In_  const D3D12_VIDEO_MOTION_ESTIMATOR_INPUT *pInputArguments);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoEncodeCommandList, ResolveMotionVectorHeap)
+        void ( STDMETHODCALLTYPE *ResolveMotionVectorHeap )( 
+            ID3D12VideoEncodeCommandList1 * This,
+            const D3D12_RESOLVE_VIDEO_MOTION_VECTOR_HEAP_OUTPUT *pOutputArguments,
+            const D3D12_RESOLVE_VIDEO_MOTION_VECTOR_HEAP_INPUT *pInputArguments);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoEncodeCommandList, WriteBufferImmediate)
+        void ( STDMETHODCALLTYPE *WriteBufferImmediate )( 
+            ID3D12VideoEncodeCommandList1 * This,
+            UINT Count,
+            _In_reads_(Count)  const D3D12_WRITEBUFFERIMMEDIATE_PARAMETER *pParams,
+            _In_reads_opt_(Count)  const D3D12_WRITEBUFFERIMMEDIATE_MODE *pModes);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoEncodeCommandList, SetProtectedResourceSession)
+        void ( STDMETHODCALLTYPE *SetProtectedResourceSession )( 
+            ID3D12VideoEncodeCommandList1 * This,
+            _In_opt_  ID3D12ProtectedResourceSession *pProtectedResourceSession);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoEncodeCommandList1, InitializeExtensionCommand)
+        void ( STDMETHODCALLTYPE *InitializeExtensionCommand )( 
+            ID3D12VideoEncodeCommandList1 * This,
+            _In_  ID3D12VideoExtensionCommand *pExtensionCommand,
+            _In_reads_bytes_(InitializationParametersSizeInBytes)  const void *pInitializationParameters,
+            SIZE_T InitializationParametersSizeInBytes);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoEncodeCommandList1, ExecuteExtensionCommand)
+        void ( STDMETHODCALLTYPE *ExecuteExtensionCommand )( 
+            ID3D12VideoEncodeCommandList1 * This,
+            _In_  ID3D12VideoExtensionCommand *pExtensionCommand,
+            _In_reads_bytes_(ExecutionParametersSizeInBytes)  const void *pExecutionParameters,
+            SIZE_T ExecutionParametersSizeInBytes);
+        
+        END_INTERFACE
+    } ID3D12VideoEncodeCommandList1Vtbl;
+
+    interface ID3D12VideoEncodeCommandList1
+    {
+        CONST_VTBL struct ID3D12VideoEncodeCommandList1Vtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define ID3D12VideoEncodeCommandList1_QueryInterface(This,riid,ppvObject)	\
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define ID3D12VideoEncodeCommandList1_AddRef(This)	\
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define ID3D12VideoEncodeCommandList1_Release(This)	\
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#define ID3D12VideoEncodeCommandList1_GetPrivateData(This,guid,pDataSize,pData)	\
+    ( (This)->lpVtbl -> GetPrivateData(This,guid,pDataSize,pData) ) 
+
+#define ID3D12VideoEncodeCommandList1_SetPrivateData(This,guid,DataSize,pData)	\
+    ( (This)->lpVtbl -> SetPrivateData(This,guid,DataSize,pData) ) 
+
+#define ID3D12VideoEncodeCommandList1_SetPrivateDataInterface(This,guid,pData)	\
+    ( (This)->lpVtbl -> SetPrivateDataInterface(This,guid,pData) ) 
+
+#define ID3D12VideoEncodeCommandList1_SetName(This,Name)	\
+    ( (This)->lpVtbl -> SetName(This,Name) ) 
+
+
+#define ID3D12VideoEncodeCommandList1_GetDevice(This,riid,ppvDevice)	\
+    ( (This)->lpVtbl -> GetDevice(This,riid,ppvDevice) ) 
+
+
+#define ID3D12VideoEncodeCommandList1_GetType(This)	\
+    ( (This)->lpVtbl -> GetType(This) ) 
+
+
+#define ID3D12VideoEncodeCommandList1_Close(This)	\
+    ( (This)->lpVtbl -> Close(This) ) 
+
+#define ID3D12VideoEncodeCommandList1_Reset(This,pAllocator)	\
+    ( (This)->lpVtbl -> Reset(This,pAllocator) ) 
+
+#define ID3D12VideoEncodeCommandList1_ClearState(This)	\
+    ( (This)->lpVtbl -> ClearState(This) ) 
+
+#define ID3D12VideoEncodeCommandList1_ResourceBarrier(This,NumBarriers,pBarriers)	\
+    ( (This)->lpVtbl -> ResourceBarrier(This,NumBarriers,pBarriers) ) 
+
+#define ID3D12VideoEncodeCommandList1_DiscardResource(This,pResource,pRegion)	\
+    ( (This)->lpVtbl -> DiscardResource(This,pResource,pRegion) ) 
+
+#define ID3D12VideoEncodeCommandList1_BeginQuery(This,pQueryHeap,Type,Index)	\
+    ( (This)->lpVtbl -> BeginQuery(This,pQueryHeap,Type,Index) ) 
+
+#define ID3D12VideoEncodeCommandList1_EndQuery(This,pQueryHeap,Type,Index)	\
+    ( (This)->lpVtbl -> EndQuery(This,pQueryHeap,Type,Index) ) 
+
+#define ID3D12VideoEncodeCommandList1_ResolveQueryData(This,pQueryHeap,Type,StartIndex,NumQueries,pDestinationBuffer,AlignedDestinationBufferOffset)	\
+    ( (This)->lpVtbl -> ResolveQueryData(This,pQueryHeap,Type,StartIndex,NumQueries,pDestinationBuffer,AlignedDestinationBufferOffset) ) 
+
+#define ID3D12VideoEncodeCommandList1_SetPredication(This,pBuffer,AlignedBufferOffset,Operation)	\
+    ( (This)->lpVtbl -> SetPredication(This,pBuffer,AlignedBufferOffset,Operation) ) 
+
+#define ID3D12VideoEncodeCommandList1_SetMarker(This,Metadata,pData,Size)	\
+    ( (This)->lpVtbl -> SetMarker(This,Metadata,pData,Size) ) 
+
+#define ID3D12VideoEncodeCommandList1_BeginEvent(This,Metadata,pData,Size)	\
+    ( (This)->lpVtbl -> BeginEvent(This,Metadata,pData,Size) ) 
+
+#define ID3D12VideoEncodeCommandList1_EndEvent(This)	\
+    ( (This)->lpVtbl -> EndEvent(This) ) 
+
+#define ID3D12VideoEncodeCommandList1_EstimateMotion(This,pMotionEstimator,pOutputArguments,pInputArguments)	\
+    ( (This)->lpVtbl -> EstimateMotion(This,pMotionEstimator,pOutputArguments,pInputArguments) ) 
+
+#define ID3D12VideoEncodeCommandList1_ResolveMotionVectorHeap(This,pOutputArguments,pInputArguments)	\
+    ( (This)->lpVtbl -> ResolveMotionVectorHeap(This,pOutputArguments,pInputArguments) ) 
+
+#define ID3D12VideoEncodeCommandList1_WriteBufferImmediate(This,Count,pParams,pModes)	\
+    ( (This)->lpVtbl -> WriteBufferImmediate(This,Count,pParams,pModes) ) 
+
+#define ID3D12VideoEncodeCommandList1_SetProtectedResourceSession(This,pProtectedResourceSession)	\
+    ( (This)->lpVtbl -> SetProtectedResourceSession(This,pProtectedResourceSession) ) 
+
+
+#define ID3D12VideoEncodeCommandList1_InitializeExtensionCommand(This,pExtensionCommand,pInitializationParameters,InitializationParametersSizeInBytes)	\
+    ( (This)->lpVtbl -> InitializeExtensionCommand(This,pExtensionCommand,pInitializationParameters,InitializationParametersSizeInBytes) ) 
+
+#define ID3D12VideoEncodeCommandList1_ExecuteExtensionCommand(This,pExtensionCommand,pExecutionParameters,ExecutionParametersSizeInBytes)	\
+    ( (This)->lpVtbl -> ExecuteExtensionCommand(This,pExtensionCommand,pExecutionParameters,ExecutionParametersSizeInBytes) ) 
+
+#endif /* COBJMACROS */
+
+
+#endif 	/* C style interface */
+
+
+
+
+#endif 	/* __ID3D12VideoEncodeCommandList1_INTERFACE_DEFINED__ */
+
+
+/* interface __MIDL_itf_d3d12video_0000_0022 */
+/* [local] */ 
+
+DEFINE_GUID(D3D12_VIDEO_DECODE_PROFILE_MPEG2, 0xee27417f, 0x5e28, 0x4e65, 0xbe, 0xea, 0x1d, 0x26, 0xb5, 0x08, 0xad, 0xc9); 
+DEFINE_GUID(D3D12_VIDEO_DECODE_PROFILE_MPEG1_AND_MPEG2, 0x86695f12, 0x340e, 0x4f04, 0x9f, 0xd3, 0x92, 0x53, 0xdd, 0x32, 0x74, 0x60); 
+DEFINE_GUID(D3D12_VIDEO_DECODE_PROFILE_H264, 0x1b81be68, 0xa0c7, 0x11d3, 0xb9, 0x84, 0x00, 0xc0, 0x4f, 0x2e, 0x73, 0xc5);
+DEFINE_GUID(D3D12_VIDEO_DECODE_PROFILE_H264_STEREO_PROGRESSIVE, 0xd79be8da, 0x0cf1, 0x4c81, 0xb8, 0x2a, 0x69, 0xa4, 0xe2, 0x36, 0xf4, 0x3d);
+DEFINE_GUID(D3D12_VIDEO_DECODE_PROFILE_H264_STEREO, 0xf9aaccbb, 0xc2b6, 0x4cfc, 0x87, 0x79, 0x57, 0x07, 0xb1, 0x76, 0x05, 0x52);
+DEFINE_GUID(D3D12_VIDEO_DECODE_PROFILE_H264_MULTIVIEW, 0x705b9d82, 0x76cf, 0x49d6, 0xb7, 0xe6, 0xac, 0x88, 0x72, 0xdb, 0x01, 0x3c);
+DEFINE_GUID(D3D12_VIDEO_DECODE_PROFILE_VC1, 0x1b81beA3, 0xa0c7, 0x11d3, 0xb9, 0x84, 0x00, 0xc0, 0x4f, 0x2e, 0x73, 0xc5);
+DEFINE_GUID(D3D12_VIDEO_DECODE_PROFILE_VC1_D2010, 0x1b81beA4, 0xa0c7, 0x11d3, 0xb9, 0x84, 0x00, 0xc0, 0x4f, 0x2e, 0x73, 0xc5);
+DEFINE_GUID(D3D12_VIDEO_DECODE_PROFILE_MPEG4PT2_SIMPLE, 0xefd64d74, 0xc9e8,0x41d7,0xa5,0xe9,0xe9,0xb0,0xe3,0x9f,0xa3,0x19);
+DEFINE_GUID(D3D12_VIDEO_DECODE_PROFILE_MPEG4PT2_ADVSIMPLE_NOGMC, 0xed418a9f, 0x010d, 0x4eda, 0x9a, 0xe3, 0x9a, 0x65, 0x35, 0x8d, 0x8d, 0x2e);
+DEFINE_GUID(D3D12_VIDEO_DECODE_PROFILE_HEVC_MAIN, 0x5b11d51b, 0x2f4c, 0x4452, 0xbc, 0xc3, 0x09, 0xf2, 0xa1, 0x16, 0x0c, 0xc0);
+DEFINE_GUID(D3D12_VIDEO_DECODE_PROFILE_HEVC_MAIN10, 0x107af0e0, 0xef1a, 0x4d19, 0xab, 0xa8, 0x67, 0xa1, 0x63, 0x07, 0x3d, 0x13);
+DEFINE_GUID(D3D12_VIDEO_DECODE_PROFILE_VP9, 0x463707f8, 0xa1d0, 0x4585, 0x87, 0x6d, 0x83, 0xaa, 0x6d, 0x60, 0xb8, 0x9e);
+DEFINE_GUID(D3D12_VIDEO_DECODE_PROFILE_VP9_10BIT_PROFILE2, 0xa4c749ef, 0x6ecf, 0x48aa, 0x84, 0x48, 0x50, 0xa7, 0xa1, 0x16, 0x5f, 0xf7);
+DEFINE_GUID(D3D12_VIDEO_DECODE_PROFILE_VP8, 0x90b899ea, 0x3a62, 0x4705, 0x88, 0xb3, 0x8d, 0xf0, 0x4b, 0x27, 0x44, 0xe7);
+DEFINE_GUID(D3D12_VIDEO_DECODE_PROFILE_AV1_PROFILE0, 0xb8be4ccb, 0xcf53, 0x46ba, 0x8d, 0x59, 0xd6, 0xb8, 0xa6, 0xda, 0x5d, 0x2a);
+DEFINE_GUID(D3D12_VIDEO_DECODE_PROFILE_AV1_PROFILE1, 0x6936ff0f, 0x45b1, 0x4163, 0x9c, 0xc1, 0x64, 0x6e, 0xf6, 0x94, 0x61, 0x08);
+DEFINE_GUID(D3D12_VIDEO_DECODE_PROFILE_AV1_PROFILE2, 0x0c5f2aa1, 0xe541, 0x4089, 0xbb, 0x7b, 0x98, 0x11, 0x0a, 0x19, 0xd7, 0xc8);
+DEFINE_GUID(D3D12_VIDEO_DECODE_PROFILE_AV1_12BIT_PROFILE2, 0x17127009, 0xa00f, 0x4ce1, 0x99, 0x4e, 0xbf, 0x40, 0x81, 0xf6, 0xf3, 0xf0);
+DEFINE_GUID(D3D12_VIDEO_DECODE_PROFILE_AV1_12BIT_PROFILE2_420, 0x2d80bed6, 0x9cac, 0x4835, 0x9e, 0x91, 0x32, 0x7b, 0xbc, 0x4f, 0x9e, 0xe8);
+typedef 
+enum D3D12_VIDEO_ENCODER_RATE_CONTROL_MODE
+    {
+        D3D12_VIDEO_ENCODER_RATE_CONTROL_MODE_ABSOLUTE_QP_MAP	= 0,
+        D3D12_VIDEO_ENCODER_RATE_CONTROL_MODE_CQP	= 1,
+        D3D12_VIDEO_ENCODER_RATE_CONTROL_MODE_CBR	= 2,
+        D3D12_VIDEO_ENCODER_RATE_CONTROL_MODE_VBR	= 3,
+        D3D12_VIDEO_ENCODER_RATE_CONTROL_MODE_QVBR	= 4
+    } 	D3D12_VIDEO_ENCODER_RATE_CONTROL_MODE;
+
+typedef 
+enum D3D12_VIDEO_ENCODER_RATE_CONTROL_FLAGS
+    {
+        D3D12_VIDEO_ENCODER_RATE_CONTROL_FLAG_NONE	= 0,
+        D3D12_VIDEO_ENCODER_RATE_CONTROL_FLAG_ENABLE_DELTA_QP	= 0x1,
+        D3D12_VIDEO_ENCODER_RATE_CONTROL_FLAG_ENABLE_FRAME_ANALYSIS	= 0x2,
+        D3D12_VIDEO_ENCODER_RATE_CONTROL_FLAG_ENABLE_QP_RANGE	= 0x4,
+        D3D12_VIDEO_ENCODER_RATE_CONTROL_FLAG_ENABLE_INITIAL_QP	= 0x8,
+        D3D12_VIDEO_ENCODER_RATE_CONTROL_FLAG_ENABLE_MAX_FRAME_SIZE	= 0x10,
+        D3D12_VIDEO_ENCODER_RATE_CONTROL_FLAG_ENABLE_VBV_SIZES	= 0x20
+    } 	D3D12_VIDEO_ENCODER_RATE_CONTROL_FLAGS;
+
+DEFINE_ENUM_FLAG_OPERATORS(D3D12_VIDEO_ENCODER_RATE_CONTROL_FLAGS);
+typedef struct D3D12_VIDEO_ENCODER_RATE_CONTROL_CQP
+    {
+    UINT ConstantQP_FullIntracodedFrame;
+    UINT ConstantQP_InterPredictedFrame_PrevRefOnly;
+    UINT ConstantQP_InterPredictedFrame_BiDirectionalRef;
+    } 	D3D12_VIDEO_ENCODER_RATE_CONTROL_CQP;
+
+typedef struct D3D12_VIDEO_ENCODER_RATE_CONTROL_CBR
+    {
+    UINT InitialQP;
+    UINT MinQP;
+    UINT MaxQP;
+    UINT64 MaxFrameBitSize;
+    UINT64 TargetBitRate;
+    UINT64 VBVCapacity;
+    UINT64 InitialVBVFullness;
+    } 	D3D12_VIDEO_ENCODER_RATE_CONTROL_CBR;
+
+typedef struct D3D12_VIDEO_ENCODER_RATE_CONTROL_VBR
+    {
+    UINT InitialQP;
+    UINT MinQP;
+    UINT MaxQP;
+    UINT64 MaxFrameBitSize;
+    UINT64 TargetAvgBitRate;
+    UINT64 PeakBitRate;
+    UINT64 VBVCapacity;
+    UINT64 InitialVBVFullness;
+    } 	D3D12_VIDEO_ENCODER_RATE_CONTROL_VBR;
+
+typedef struct D3D12_VIDEO_ENCODER_RATE_CONTROL_QVBR
+    {
+    UINT InitialQP;
+    UINT MinQP;
+    UINT MaxQP;
+    UINT64 MaxFrameBitSize;
+    UINT64 TargetAvgBitRate;
+    UINT64 PeakBitRate;
+    UINT ConstantQualityTarget;
+    } 	D3D12_VIDEO_ENCODER_RATE_CONTROL_QVBR;
+
+typedef struct D3D12_VIDEO_ENCODER_RATE_CONTROL_CONFIGURATION_PARAMS
+    {
+    UINT DataSize;
+    union 
+        {
+        const D3D12_VIDEO_ENCODER_RATE_CONTROL_CQP *pConfiguration_CQP;
+        const D3D12_VIDEO_ENCODER_RATE_CONTROL_CBR *pConfiguration_CBR;
+        const D3D12_VIDEO_ENCODER_RATE_CONTROL_VBR *pConfiguration_VBR;
+        const D3D12_VIDEO_ENCODER_RATE_CONTROL_QVBR *pConfiguration_QVBR;
+        } 	;
+    } 	D3D12_VIDEO_ENCODER_RATE_CONTROL_CONFIGURATION_PARAMS;
+
+typedef struct D3D12_VIDEO_ENCODER_RATE_CONTROL
+    {
+    D3D12_VIDEO_ENCODER_RATE_CONTROL_MODE Mode;
+    D3D12_VIDEO_ENCODER_RATE_CONTROL_FLAGS Flags;
+    D3D12_VIDEO_ENCODER_RATE_CONTROL_CONFIGURATION_PARAMS ConfigParams;
+    DXGI_RATIONAL TargetFrameRate;
+    } 	D3D12_VIDEO_ENCODER_RATE_CONTROL;
+
+typedef 
+enum D3D12_VIDEO_ENCODER_CODEC
+    {
+        D3D12_VIDEO_ENCODER_CODEC_H264	= 0,
+        D3D12_VIDEO_ENCODER_CODEC_HEVC	= 1
+    } 	D3D12_VIDEO_ENCODER_CODEC;
+
+typedef struct D3D12_FEATURE_DATA_VIDEO_ENCODER_CODEC
+    {
+    UINT NodeIndex;
+    D3D12_VIDEO_ENCODER_CODEC Codec;
+    BOOL IsSupported;
+    } 	D3D12_FEATURE_DATA_VIDEO_ENCODER_CODEC;
+
+typedef 
+enum D3D12_VIDEO_ENCODER_PROFILE_H264
+    {
+        D3D12_VIDEO_ENCODER_PROFILE_H264_MAIN	= 0,
+        D3D12_VIDEO_ENCODER_PROFILE_H264_HIGH	= 1,
+        D3D12_VIDEO_ENCODER_PROFILE_H264_HIGH_10	= 2
+    } 	D3D12_VIDEO_ENCODER_PROFILE_H264;
+
+typedef 
+enum D3D12_VIDEO_ENCODER_PROFILE_HEVC
+    {
+        D3D12_VIDEO_ENCODER_PROFILE_HEVC_MAIN	= 0,
+        D3D12_VIDEO_ENCODER_PROFILE_HEVC_MAIN10	= 1
+    } 	D3D12_VIDEO_ENCODER_PROFILE_HEVC;
+
+typedef struct D3D12_VIDEO_ENCODER_PROFILE_DESC
+    {
+    UINT DataSize;
+    union 
+        {
+        D3D12_VIDEO_ENCODER_PROFILE_H264 *pH264Profile;
+        D3D12_VIDEO_ENCODER_PROFILE_HEVC *pHEVCProfile;
+        } 	;
+    } 	D3D12_VIDEO_ENCODER_PROFILE_DESC;
+
+typedef 
+enum D3D12_VIDEO_ENCODER_LEVELS_H264
+    {
+        D3D12_VIDEO_ENCODER_LEVELS_H264_1	= 0,
+        D3D12_VIDEO_ENCODER_LEVELS_H264_1b	= 1,
+        D3D12_VIDEO_ENCODER_LEVELS_H264_11	= 2,
+        D3D12_VIDEO_ENCODER_LEVELS_H264_12	= 3,
+        D3D12_VIDEO_ENCODER_LEVELS_H264_13	= 4,
+        D3D12_VIDEO_ENCODER_LEVELS_H264_2	= 5,
+        D3D12_VIDEO_ENCODER_LEVELS_H264_21	= 6,
+        D3D12_VIDEO_ENCODER_LEVELS_H264_22	= 7,
+        D3D12_VIDEO_ENCODER_LEVELS_H264_3	= 8,
+        D3D12_VIDEO_ENCODER_LEVELS_H264_31	= 9,
+        D3D12_VIDEO_ENCODER_LEVELS_H264_32	= 10,
+        D3D12_VIDEO_ENCODER_LEVELS_H264_4	= 11,
+        D3D12_VIDEO_ENCODER_LEVELS_H264_41	= 12,
+        D3D12_VIDEO_ENCODER_LEVELS_H264_42	= 13,
+        D3D12_VIDEO_ENCODER_LEVELS_H264_5	= 14,
+        D3D12_VIDEO_ENCODER_LEVELS_H264_51	= 15,
+        D3D12_VIDEO_ENCODER_LEVELS_H264_52	= 16,
+        D3D12_VIDEO_ENCODER_LEVELS_H264_6	= 17,
+        D3D12_VIDEO_ENCODER_LEVELS_H264_61	= 18,
+        D3D12_VIDEO_ENCODER_LEVELS_H264_62	= 19
+    } 	D3D12_VIDEO_ENCODER_LEVELS_H264;
+
+typedef 
+enum D3D12_VIDEO_ENCODER_TIER_HEVC
+    {
+        D3D12_VIDEO_ENCODER_TIER_HEVC_MAIN	= 0,
+        D3D12_VIDEO_ENCODER_TIER_HEVC_HIGH	= 1
+    } 	D3D12_VIDEO_ENCODER_TIER_HEVC;
+
+typedef 
+enum D3D12_VIDEO_ENCODER_LEVELS_HEVC
+    {
+        D3D12_VIDEO_ENCODER_LEVELS_HEVC_1	= 0,
+        D3D12_VIDEO_ENCODER_LEVELS_HEVC_2	= 1,
+        D3D12_VIDEO_ENCODER_LEVELS_HEVC_21	= 2,
+        D3D12_VIDEO_ENCODER_LEVELS_HEVC_3	= 3,
+        D3D12_VIDEO_ENCODER_LEVELS_HEVC_31	= 4,
+        D3D12_VIDEO_ENCODER_LEVELS_HEVC_4	= 5,
+        D3D12_VIDEO_ENCODER_LEVELS_HEVC_41	= 6,
+        D3D12_VIDEO_ENCODER_LEVELS_HEVC_5	= 7,
+        D3D12_VIDEO_ENCODER_LEVELS_HEVC_51	= 8,
+        D3D12_VIDEO_ENCODER_LEVELS_HEVC_52	= 9,
+        D3D12_VIDEO_ENCODER_LEVELS_HEVC_6	= 10,
+        D3D12_VIDEO_ENCODER_LEVELS_HEVC_61	= 11,
+        D3D12_VIDEO_ENCODER_LEVELS_HEVC_62	= 12
+    } 	D3D12_VIDEO_ENCODER_LEVELS_HEVC;
+
+typedef struct D3D12_VIDEO_ENCODER_LEVEL_TIER_CONSTRAINTS_HEVC
+    {
+    D3D12_VIDEO_ENCODER_LEVELS_HEVC Level;
+    D3D12_VIDEO_ENCODER_TIER_HEVC Tier;
+    } 	D3D12_VIDEO_ENCODER_LEVEL_TIER_CONSTRAINTS_HEVC;
+
+typedef struct D3D12_VIDEO_ENCODER_LEVEL_SETTING
+    {
+    UINT DataSize;
+    union 
+        {
+        D3D12_VIDEO_ENCODER_LEVELS_H264 *pH264LevelSetting;
+        D3D12_VIDEO_ENCODER_LEVEL_TIER_CONSTRAINTS_HEVC *pHEVCLevelSetting;
+        } 	;
+    } 	D3D12_VIDEO_ENCODER_LEVEL_SETTING;
+
+typedef struct D3D12_FEATURE_DATA_VIDEO_ENCODER_PROFILE_LEVEL
+    {
+    UINT NodeIndex;
+    D3D12_VIDEO_ENCODER_CODEC Codec;
+    D3D12_VIDEO_ENCODER_PROFILE_DESC Profile;
+    BOOL IsSupported;
+    D3D12_VIDEO_ENCODER_LEVEL_SETTING MinSupportedLevel;
+    D3D12_VIDEO_ENCODER_LEVEL_SETTING MaxSupportedLevel;
+    } 	D3D12_FEATURE_DATA_VIDEO_ENCODER_PROFILE_LEVEL;
+
+typedef struct D3D12_VIDEO_ENCODER_PICTURE_RESOLUTION_DESC
+    {
+    UINT Width;
+    UINT Height;
+    } 	D3D12_VIDEO_ENCODER_PICTURE_RESOLUTION_DESC;
+
+typedef struct D3D12_VIDEO_ENCODER_PICTURE_RESOLUTION_RATIO_DESC
+    {
+    UINT WidthRatio;
+    UINT HeightRatio;
+    } 	D3D12_VIDEO_ENCODER_PICTURE_RESOLUTION_RATIO_DESC;
+
+typedef struct D3D12_FEATURE_DATA_VIDEO_ENCODER_OUTPUT_RESOLUTION_RATIOS_COUNT
+    {
+    UINT NodeIndex;
+    D3D12_VIDEO_ENCODER_CODEC Codec;
+    UINT ResolutionRatiosCount;
+    } 	D3D12_FEATURE_DATA_VIDEO_ENCODER_OUTPUT_RESOLUTION_RATIOS_COUNT;
+
+typedef struct D3D12_FEATURE_DATA_VIDEO_ENCODER_OUTPUT_RESOLUTION
+    {
+    UINT NodeIndex;
+    D3D12_VIDEO_ENCODER_CODEC Codec;
+    UINT ResolutionRatiosCount;
+    BOOL IsSupported;
+    D3D12_VIDEO_ENCODER_PICTURE_RESOLUTION_DESC MinResolutionSupported;
+    D3D12_VIDEO_ENCODER_PICTURE_RESOLUTION_DESC MaxResolutionSupported;
+    UINT ResolutionWidthMultipleRequirement;
+    UINT ResolutionHeightMultipleRequirement;
+    _Field_size_full_(ResolutionRatiosCount)  D3D12_VIDEO_ENCODER_PICTURE_RESOLUTION_RATIO_DESC *pResolutionRatios;
+    } 	D3D12_FEATURE_DATA_VIDEO_ENCODER_OUTPUT_RESOLUTION;
+
+typedef struct D3D12_FEATURE_DATA_VIDEO_ENCODER_INPUT_FORMAT
+    {
+    UINT NodeIndex;
+    D3D12_VIDEO_ENCODER_CODEC Codec;
+    D3D12_VIDEO_ENCODER_PROFILE_DESC Profile;
+    DXGI_FORMAT Format;
+    BOOL IsSupported;
+    } 	D3D12_FEATURE_DATA_VIDEO_ENCODER_INPUT_FORMAT;
+
+typedef struct D3D12_FEATURE_DATA_VIDEO_ENCODER_RATE_CONTROL_MODE
+    {
+    UINT NodeIndex;
+    D3D12_VIDEO_ENCODER_CODEC Codec;
+    D3D12_VIDEO_ENCODER_RATE_CONTROL_MODE RateControlMode;
+    BOOL IsSupported;
+    } 	D3D12_FEATURE_DATA_VIDEO_ENCODER_RATE_CONTROL_MODE;
+
+typedef 
+enum D3D12_VIDEO_ENCODER_INTRA_REFRESH_MODE
+    {
+        D3D12_VIDEO_ENCODER_INTRA_REFRESH_MODE_NONE	= 0,
+        D3D12_VIDEO_ENCODER_INTRA_REFRESH_MODE_ROW_BASED	= 1
+    } 	D3D12_VIDEO_ENCODER_INTRA_REFRESH_MODE;
+
+typedef struct D3D12_FEATURE_DATA_VIDEO_ENCODER_INTRA_REFRESH_MODE
+    {
+    UINT NodeIndex;
+    D3D12_VIDEO_ENCODER_CODEC Codec;
+    D3D12_VIDEO_ENCODER_PROFILE_DESC Profile;
+    D3D12_VIDEO_ENCODER_LEVEL_SETTING Level;
+    D3D12_VIDEO_ENCODER_INTRA_REFRESH_MODE IntraRefreshMode;
+    BOOL IsSupported;
+    } 	D3D12_FEATURE_DATA_VIDEO_ENCODER_INTRA_REFRESH_MODE;
+
+typedef 
+enum D3D12_VIDEO_ENCODER_FRAME_SUBREGION_LAYOUT_MODE
+    {
+        D3D12_VIDEO_ENCODER_FRAME_SUBREGION_LAYOUT_MODE_FULL_FRAME	= 0,
+        D3D12_VIDEO_ENCODER_FRAME_SUBREGION_LAYOUT_MODE_BYTES_PER_SUBREGION	= 1,
+        D3D12_VIDEO_ENCODER_FRAME_SUBREGION_LAYOUT_MODE_SQUARE_UNITS_PER_SUBREGION_ROW_UNALIGNED	= 2,
+        D3D12_VIDEO_ENCODER_FRAME_SUBREGION_LAYOUT_MODE_UNIFORM_PARTITIONING_ROWS_PER_SUBREGION	= 3,
+        D3D12_VIDEO_ENCODER_FRAME_SUBREGION_LAYOUT_MODE_UNIFORM_PARTITIONING_SUBREGIONS_PER_FRAME	= 4
+    } 	D3D12_VIDEO_ENCODER_FRAME_SUBREGION_LAYOUT_MODE;
+
+typedef struct D3D12_FEATURE_DATA_VIDEO_ENCODER_FRAME_SUBREGION_LAYOUT_MODE
+    {
+    UINT NodeIndex;
+    D3D12_VIDEO_ENCODER_CODEC Codec;
+    D3D12_VIDEO_ENCODER_PROFILE_DESC Profile;
+    D3D12_VIDEO_ENCODER_LEVEL_SETTING Level;
+    D3D12_VIDEO_ENCODER_FRAME_SUBREGION_LAYOUT_MODE SubregionMode;
+    BOOL IsSupported;
+    } 	D3D12_FEATURE_DATA_VIDEO_ENCODER_FRAME_SUBREGION_LAYOUT_MODE;
+
+typedef 
+enum D3D12_VIDEO_ENCODER_HEAP_FLAGS
+    {
+        D3D12_VIDEO_ENCODER_HEAP_FLAG_NONE	= 0
+    } 	D3D12_VIDEO_ENCODER_HEAP_FLAGS;
+
+DEFINE_ENUM_FLAG_OPERATORS(D3D12_VIDEO_ENCODER_HEAP_FLAGS);
+typedef struct D3D12_VIDEO_ENCODER_HEAP_DESC
+    {
+    UINT NodeMask;
+    D3D12_VIDEO_ENCODER_HEAP_FLAGS Flags;
+    D3D12_VIDEO_ENCODER_CODEC EncodeCodec;
+    D3D12_VIDEO_ENCODER_PROFILE_DESC EncodeProfile;
+    D3D12_VIDEO_ENCODER_LEVEL_SETTING EncodeLevel;
+    UINT ResolutionsListCount;
+    _Field_size_full_(ResolutionsListCount)  const D3D12_VIDEO_ENCODER_PICTURE_RESOLUTION_DESC *pResolutionList;
+    } 	D3D12_VIDEO_ENCODER_HEAP_DESC;
+
+typedef struct D3D12_FEATURE_DATA_VIDEO_ENCODER_HEAP_SIZE
+    {
+    D3D12_VIDEO_ENCODER_HEAP_DESC HeapDesc;
+    BOOL IsSupported;
+    UINT64 MemoryPoolL0Size;
+    UINT64 MemoryPoolL1Size;
+    } 	D3D12_FEATURE_DATA_VIDEO_ENCODER_HEAP_SIZE;
+
+typedef 
+enum D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT_H264_FLAGS
+    {
+        D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT_H264_FLAG_NONE	= 0,
+        D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT_H264_FLAG_CABAC_ENCODING_SUPPORT	= 0x1,
+        D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT_H264_FLAG_INTRA_SLICE_CONSTRAINED_ENCODING_SUPPORT	= 0x2,
+        D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT_H264_FLAG_BFRAME_LTR_COMBINED_SUPPORT	= 0x4,
+        D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT_H264_FLAG_ADAPTIVE_8x8_TRANSFORM_ENCODING_SUPPORT	= 0x8,
+        D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT_H264_FLAG_DIRECT_SPATIAL_ENCODING_SUPPORT	= 0x10,
+        D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT_H264_FLAG_DIRECT_TEMPORAL_ENCODING_SUPPORT	= 0x20,
+        D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT_H264_FLAG_CONSTRAINED_INTRAPREDICTION_SUPPORT	= 0x40
+    } 	D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT_H264_FLAGS;
+
+DEFINE_ENUM_FLAG_OPERATORS(D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT_H264_FLAGS);
+typedef 
+enum D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_H264_SLICES_DEBLOCKING_MODES
+    {
+        D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_H264_SLICES_DEBLOCKING_MODE_0_ALL_LUMA_CHROMA_SLICE_BLOCK_EDGES_ALWAYS_FILTERED	= 0,
+        D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_H264_SLICES_DEBLOCKING_MODE_1_DISABLE_ALL_SLICE_BLOCK_EDGES	= 1,
+        D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_H264_SLICES_DEBLOCKING_MODE_2_DISABLE_SLICE_BOUNDARIES_BLOCKS	= 2,
+        D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_H264_SLICES_DEBLOCKING_MODE_3_USE_TWO_STAGE_DEBLOCKING	= 3,
+        D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_H264_SLICES_DEBLOCKING_MODE_4_DISABLE_CHROMA_BLOCK_EDGES	= 4,
+        D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_H264_SLICES_DEBLOCKING_MODE_5_DISABLE_CHROMA_BLOCK_EDGES_AND_LUMA_BOUNDARIES	= 5,
+        D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_H264_SLICES_DEBLOCKING_MODE_6_DISABLE_CHROMA_BLOCK_EDGES_AND_USE_LUMA_TWO_STAGE_DEBLOCKING	= 6
+    } 	D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_H264_SLICES_DEBLOCKING_MODES;
+
+typedef 
+enum D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_H264_SLICES_DEBLOCKING_MODE_FLAGS
+    {
+        D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_H264_SLICES_DEBLOCKING_MODE_FLAG_NONE	= 0,
+        D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_H264_SLICES_DEBLOCKING_MODE_FLAG_0_ALL_LUMA_CHROMA_SLICE_BLOCK_EDGES_ALWAYS_FILTERED	= ( 1 << D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_H264_SLICES_DEBLOCKING_MODE_0_ALL_LUMA_CHROMA_SLICE_BLOCK_EDGES_ALWAYS_FILTERED ) ,
+        D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_H264_SLICES_DEBLOCKING_MODE_FLAG_1_DISABLE_ALL_SLICE_BLOCK_EDGES	= ( 1 << D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_H264_SLICES_DEBLOCKING_MODE_1_DISABLE_ALL_SLICE_BLOCK_EDGES ) ,
+        D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_H264_SLICES_DEBLOCKING_MODE_FLAG_2_DISABLE_SLICE_BOUNDARIES_BLOCKS	= ( 1 << D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_H264_SLICES_DEBLOCKING_MODE_2_DISABLE_SLICE_BOUNDARIES_BLOCKS ) ,
+        D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_H264_SLICES_DEBLOCKING_MODE_FLAG_3_USE_TWO_STAGE_DEBLOCKING	= ( 1 << D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_H264_SLICES_DEBLOCKING_MODE_3_USE_TWO_STAGE_DEBLOCKING ) ,
+        D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_H264_SLICES_DEBLOCKING_MODE_FLAG_4_DISABLE_CHROMA_BLOCK_EDGES	= ( 1 << D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_H264_SLICES_DEBLOCKING_MODE_4_DISABLE_CHROMA_BLOCK_EDGES ) ,
+        D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_H264_SLICES_DEBLOCKING_MODE_FLAG_5_DISABLE_CHROMA_BLOCK_EDGES_AND_LUMA_BOUNDARIES	= ( 1 << D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_H264_SLICES_DEBLOCKING_MODE_5_DISABLE_CHROMA_BLOCK_EDGES_AND_LUMA_BOUNDARIES ) ,
+        D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_H264_SLICES_DEBLOCKING_MODE_FLAG_6_DISABLE_CHROMA_BLOCK_EDGES_AND_USE_LUMA_TWO_STAGE_DEBLOCKING	= ( 1 << D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_H264_SLICES_DEBLOCKING_MODE_6_DISABLE_CHROMA_BLOCK_EDGES_AND_USE_LUMA_TWO_STAGE_DEBLOCKING ) 
+    } 	D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_H264_SLICES_DEBLOCKING_MODE_FLAGS;
+
+DEFINE_ENUM_FLAG_OPERATORS(D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_H264_SLICES_DEBLOCKING_MODE_FLAGS);
+typedef struct D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT_H264
+    {
+    D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT_H264_FLAGS SupportFlags;
+    D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_H264_SLICES_DEBLOCKING_MODE_FLAGS DisableDeblockingFilterSupportedModes;
+    } 	D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT_H264;
+
+typedef 
+enum D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT_HEVC_FLAGS
+    {
+        D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT_HEVC_FLAG_NONE	= 0,
+        D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT_HEVC_FLAG_BFRAME_LTR_COMBINED_SUPPORT	= 0x1,
+        D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT_HEVC_FLAG_INTRA_SLICE_CONSTRAINED_ENCODING_SUPPORT	= 0x2,
+        D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT_HEVC_FLAG_CONSTRAINED_INTRAPREDICTION_SUPPORT	= 0x4,
+        D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT_HEVC_FLAG_SAO_FILTER_SUPPORT	= 0x8,
+        D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT_HEVC_FLAG_ASYMETRIC_MOTION_PARTITION_SUPPORT	= 0x10,
+        D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT_HEVC_FLAG_ASYMETRIC_MOTION_PARTITION_REQUIRED	= 0x20,
+        D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT_HEVC_FLAG_TRANSFORM_SKIP_SUPPORT	= 0x40,
+        D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT_HEVC_FLAG_DISABLING_LOOP_FILTER_ACROSS_SLICES_SUPPORT	= 0x80,
+        D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT_HEVC_FLAG_P_FRAMES_IMPLEMENTED_AS_LOW_DELAY_B_FRAMES	= 0x100
+    } 	D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT_HEVC_FLAGS;
+
+DEFINE_ENUM_FLAG_OPERATORS(D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT_HEVC_FLAGS);
+typedef 
+enum D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_HEVC_CUSIZE
+    {
+        D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_HEVC_CUSIZE_8x8	= 0,
+        D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_HEVC_CUSIZE_16x16	= 1,
+        D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_HEVC_CUSIZE_32x32	= 2,
+        D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_HEVC_CUSIZE_64x64	= 3
+    } 	D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_HEVC_CUSIZE;
+
+typedef 
+enum D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_HEVC_TUSIZE
+    {
+        D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_HEVC_TUSIZE_4x4	= 0,
+        D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_HEVC_TUSIZE_8x8	= 1,
+        D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_HEVC_TUSIZE_16x16	= 2,
+        D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_HEVC_TUSIZE_32x32	= 3
+    } 	D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_HEVC_TUSIZE;
+
+typedef struct D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT_HEVC
+    {
+    D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT_HEVC_FLAGS SupportFlags;
+    D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_HEVC_CUSIZE MinLumaCodingUnitSize;
+    D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_HEVC_CUSIZE MaxLumaCodingUnitSize;
+    D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_HEVC_TUSIZE MinLumaTransformUnitSize;
+    D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_HEVC_TUSIZE MaxLumaTransformUnitSize;
+    UCHAR max_transform_hierarchy_depth_inter;
+    UCHAR max_transform_hierarchy_depth_intra;
+    } 	D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT_HEVC;
+
+typedef struct D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT
+    {
+    UINT DataSize;
+    union 
+        {
+        D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT_H264 *pH264Support;
+        D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT_HEVC *pHEVCSupport;
+        } 	;
+    } 	D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT;
+
+typedef struct D3D12_FEATURE_DATA_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT
+    {
+    UINT NodeIndex;
+    D3D12_VIDEO_ENCODER_CODEC Codec;
+    D3D12_VIDEO_ENCODER_PROFILE_DESC Profile;
+    BOOL IsSupported;
+    D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT CodecSupportLimits;
+    } 	D3D12_FEATURE_DATA_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT;
+
+typedef struct D3D12_VIDEO_ENCODER_CODEC_PICTURE_CONTROL_SUPPORT_H264
+    {
+    UINT MaxL0ReferencesForP;
+    UINT MaxL0ReferencesForB;
+    UINT MaxL1ReferencesForB;
+    UINT MaxLongTermReferences;
+    UINT MaxDPBCapacity;
+    } 	D3D12_VIDEO_ENCODER_CODEC_PICTURE_CONTROL_SUPPORT_H264;
+
+typedef struct D3D12_VIDEO_ENCODER_CODEC_PICTURE_CONTROL_SUPPORT_HEVC
+    {
+    UINT MaxL0ReferencesForP;
+    UINT MaxL0ReferencesForB;
+    UINT MaxL1ReferencesForB;
+    UINT MaxLongTermReferences;
+    UINT MaxDPBCapacity;
+    } 	D3D12_VIDEO_ENCODER_CODEC_PICTURE_CONTROL_SUPPORT_HEVC;
+
+typedef struct D3D12_VIDEO_ENCODER_CODEC_PICTURE_CONTROL_SUPPORT
+    {
+    UINT DataSize;
+    union 
+        {
+        D3D12_VIDEO_ENCODER_CODEC_PICTURE_CONTROL_SUPPORT_H264 *pH264Support;
+        D3D12_VIDEO_ENCODER_CODEC_PICTURE_CONTROL_SUPPORT_HEVC *pHEVCSupport;
+        } 	;
+    } 	D3D12_VIDEO_ENCODER_CODEC_PICTURE_CONTROL_SUPPORT;
+
+typedef struct D3D12_FEATURE_DATA_VIDEO_ENCODER_CODEC_PICTURE_CONTROL_SUPPORT
+    {
+    UINT NodeIndex;
+    D3D12_VIDEO_ENCODER_CODEC Codec;
+    D3D12_VIDEO_ENCODER_PROFILE_DESC Profile;
+    BOOL IsSupported;
+    D3D12_VIDEO_ENCODER_CODEC_PICTURE_CONTROL_SUPPORT PictureSupport;
+    } 	D3D12_FEATURE_DATA_VIDEO_ENCODER_CODEC_PICTURE_CONTROL_SUPPORT;
+
+typedef 
+enum D3D12_VIDEO_ENCODER_SUPPORT_FLAGS
+    {
+        D3D12_VIDEO_ENCODER_SUPPORT_FLAG_NONE	= 0,
+        D3D12_VIDEO_ENCODER_SUPPORT_FLAG_GENERAL_SUPPORT_OK	= 0x1,
+        D3D12_VIDEO_ENCODER_SUPPORT_FLAG_RATE_CONTROL_RECONFIGURATION_AVAILABLE	= 0x2,
+        D3D12_VIDEO_ENCODER_SUPPORT_FLAG_RESOLUTION_RECONFIGURATION_AVAILABLE	= 0x4,
+        D3D12_VIDEO_ENCODER_SUPPORT_FLAG_RATE_CONTROL_VBV_SIZE_CONFIG_AVAILABLE	= 0x8,
+        D3D12_VIDEO_ENCODER_SUPPORT_FLAG_RATE_CONTROL_FRAME_ANALYSIS_AVAILABLE	= 0x10,
+        D3D12_VIDEO_ENCODER_SUPPORT_FLAG_RECONSTRUCTED_FRAMES_REQUIRE_TEXTURE_ARRAYS	= 0x20,
+        D3D12_VIDEO_ENCODER_SUPPORT_FLAG_RATE_CONTROL_DELTA_QP_AVAILABLE	= 0x40,
+        D3D12_VIDEO_ENCODER_SUPPORT_FLAG_SUBREGION_LAYOUT_RECONFIGURATION_AVAILABLE	= 0x80,
+        D3D12_VIDEO_ENCODER_SUPPORT_FLAG_RATE_CONTROL_ADJUSTABLE_QP_RANGE_AVAILABLE	= 0x100,
+        D3D12_VIDEO_ENCODER_SUPPORT_FLAG_RATE_CONTROL_INITIAL_QP_AVAILABLE	= 0x200,
+        D3D12_VIDEO_ENCODER_SUPPORT_FLAG_RATE_CONTROL_MAX_FRAME_SIZE_AVAILABLE	= 0x400,
+        D3D12_VIDEO_ENCODER_SUPPORT_FLAG_SEQUENCE_GOP_RECONFIGURATION_AVAILABLE	= 0x800,
+        D3D12_VIDEO_ENCODER_SUPPORT_FLAG_MOTION_ESTIMATION_PRECISION_MODE_LIMIT_AVAILABLE	= 0x1000
+    } 	D3D12_VIDEO_ENCODER_SUPPORT_FLAGS;
+
+DEFINE_ENUM_FLAG_OPERATORS(D3D12_VIDEO_ENCODER_SUPPORT_FLAGS);
+typedef 
+enum D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_H264_FLAGS
+    {
+        D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_H264_FLAG_NONE	= 0,
+        D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_H264_FLAG_USE_CONSTRAINED_INTRAPREDICTION	= 0x1,
+        D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_H264_FLAG_USE_ADAPTIVE_8x8_TRANSFORM	= 0x2,
+        D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_H264_FLAG_ENABLE_CABAC_ENCODING	= 0x4,
+        D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_H264_FLAG_ALLOW_REQUEST_INTRA_CONSTRAINED_SLICES	= 0x8
+    } 	D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_H264_FLAGS;
+
+DEFINE_ENUM_FLAG_OPERATORS(D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_H264_FLAGS);
+typedef 
+enum D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_H264_DIRECT_MODES
+    {
+        D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_H264_DIRECT_MODES_DISABLED	= 0,
+        D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_H264_DIRECT_MODES_TEMPORAL	= 1,
+        D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_H264_DIRECT_MODES_SPATIAL	= 2
+    } 	D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_H264_DIRECT_MODES;
+
+typedef struct D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_H264
+    {
+    D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_H264_FLAGS ConfigurationFlags;
+    D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_H264_DIRECT_MODES DirectModeConfig;
+    D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_H264_SLICES_DEBLOCKING_MODES DisableDeblockingFilterConfig;
+    } 	D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_H264;
+
+typedef 
+enum D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_HEVC_FLAGS
+    {
+        D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_HEVC_FLAG_NONE	= 0,
+        D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_HEVC_FLAG_DISABLE_LOOP_FILTER_ACROSS_SLICES	= 0x1,
+        D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_HEVC_FLAG_ALLOW_REQUEST_INTRA_CONSTRAINED_SLICES	= 0x2,
+        D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_HEVC_FLAG_ENABLE_SAO_FILTER	= 0x4,
+        D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_HEVC_FLAG_ENABLE_LONG_TERM_REFERENCES	= 0x8,
+        D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_HEVC_FLAG_USE_ASYMETRIC_MOTION_PARTITION	= 0x10,
+        D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_HEVC_FLAG_ENABLE_TRANSFORM_SKIPPING	= 0x20,
+        D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_HEVC_FLAG_USE_CONSTRAINED_INTRAPREDICTION	= 0x40
+    } 	D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_HEVC_FLAGS;
+
+DEFINE_ENUM_FLAG_OPERATORS(D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_HEVC_FLAGS);
+typedef struct D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_HEVC
+    {
+    D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_HEVC_FLAGS ConfigurationFlags;
+    D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_HEVC_CUSIZE MinLumaCodingUnitSize;
+    D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_HEVC_CUSIZE MaxLumaCodingUnitSize;
+    D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_HEVC_TUSIZE MinLumaTransformUnitSize;
+    D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_HEVC_TUSIZE MaxLumaTransformUnitSize;
+    UCHAR max_transform_hierarchy_depth_inter;
+    UCHAR max_transform_hierarchy_depth_intra;
+    } 	D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_HEVC;
+
+typedef struct D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION
+    {
+    UINT DataSize;
+    union 
+        {
+        D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_H264 *pH264Config;
+        D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_HEVC *pHEVCConfig;
+        } 	;
+    } 	D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION;
+
+typedef struct D3D12_VIDEO_ENCODER_INTRA_REFRESH
+    {
+    D3D12_VIDEO_ENCODER_INTRA_REFRESH_MODE Mode;
+    UINT IntraRefreshDuration;
+    } 	D3D12_VIDEO_ENCODER_INTRA_REFRESH;
+
+typedef 
+enum D3D12_VIDEO_ENCODER_MOTION_ESTIMATION_PRECISION_MODE
+    {
+        D3D12_VIDEO_ENCODER_MOTION_ESTIMATION_PRECISION_MODE_MAXIMUM	= 0,
+        D3D12_VIDEO_ENCODER_MOTION_ESTIMATION_PRECISION_MODE_FULL_PIXEL	= 1,
+        D3D12_VIDEO_ENCODER_MOTION_ESTIMATION_PRECISION_MODE_HALF_PIXEL	= 2,
+        D3D12_VIDEO_ENCODER_MOTION_ESTIMATION_PRECISION_MODE_QUARTER_PIXEL	= 3
+    } 	D3D12_VIDEO_ENCODER_MOTION_ESTIMATION_PRECISION_MODE;
+
+typedef struct D3D12_FEATURE_DATA_VIDEO_ENCODER_RESOLUTION_SUPPORT_LIMITS
+    {
+    UINT MaxSubregionsNumber;
+    UINT MaxIntraRefreshFrameDuration;
+    UINT SubregionBlockPixelsSize;
+    UINT QPMapRegionPixelsSize;
+    } 	D3D12_FEATURE_DATA_VIDEO_ENCODER_RESOLUTION_SUPPORT_LIMITS;
+
+typedef 
+enum D3D12_VIDEO_ENCODER_VALIDATION_FLAGS
+    {
+        D3D12_VIDEO_ENCODER_VALIDATION_FLAG_NONE	= 0,
+        D3D12_VIDEO_ENCODER_VALIDATION_FLAG_CODEC_NOT_SUPPORTED	= 0x1,
+        D3D12_VIDEO_ENCODER_VALIDATION_FLAG_INPUT_FORMAT_NOT_SUPPORTED	= 0x8,
+        D3D12_VIDEO_ENCODER_VALIDATION_FLAG_CODEC_CONFIGURATION_NOT_SUPPORTED	= 0x10,
+        D3D12_VIDEO_ENCODER_VALIDATION_FLAG_RATE_CONTROL_MODE_NOT_SUPPORTED	= 0x20,
+        D3D12_VIDEO_ENCODER_VALIDATION_FLAG_RATE_CONTROL_CONFIGURATION_NOT_SUPPORTED	= 0x40,
+        D3D12_VIDEO_ENCODER_VALIDATION_FLAG_INTRA_REFRESH_MODE_NOT_SUPPORTED	= 0x80,
+        D3D12_VIDEO_ENCODER_VALIDATION_FLAG_SUBREGION_LAYOUT_MODE_NOT_SUPPORTED	= 0x100,
+        D3D12_VIDEO_ENCODER_VALIDATION_FLAG_RESOLUTION_NOT_SUPPORTED_IN_LIST	= 0x200,
+        D3D12_VIDEO_ENCODER_VALIDATION_FLAG_GOP_STRUCTURE_NOT_SUPPORTED	= 0x800
+    } 	D3D12_VIDEO_ENCODER_VALIDATION_FLAGS;
+
+DEFINE_ENUM_FLAG_OPERATORS(D3D12_VIDEO_ENCODER_VALIDATION_FLAGS);
+typedef struct D3D12_VIDEO_ENCODER_SEQUENCE_GOP_STRUCTURE_H264
+    {
+    UINT GOPLength;
+    UINT PPicturePeriod;
+    UCHAR pic_order_cnt_type;
+    UCHAR log2_max_frame_num_minus4;
+    UCHAR log2_max_pic_order_cnt_lsb_minus4;
+    } 	D3D12_VIDEO_ENCODER_SEQUENCE_GOP_STRUCTURE_H264;
+
+typedef struct D3D12_VIDEO_ENCODER_SEQUENCE_GOP_STRUCTURE_HEVC
+    {
+    UINT GOPLength;
+    UINT PPicturePeriod;
+    UCHAR log2_max_pic_order_cnt_lsb_minus4;
+    } 	D3D12_VIDEO_ENCODER_SEQUENCE_GOP_STRUCTURE_HEVC;
+
+typedef struct D3D12_VIDEO_ENCODER_SEQUENCE_GOP_STRUCTURE
+    {
+    UINT DataSize;
+    union 
+        {
+        D3D12_VIDEO_ENCODER_SEQUENCE_GOP_STRUCTURE_H264 *pH264GroupOfPictures;
+        D3D12_VIDEO_ENCODER_SEQUENCE_GOP_STRUCTURE_HEVC *pHEVCGroupOfPictures;
+        } 	;
+    } 	D3D12_VIDEO_ENCODER_SEQUENCE_GOP_STRUCTURE;
+
+typedef struct D3D12_FEATURE_DATA_VIDEO_ENCODER_SUPPORT
+    {
+    UINT NodeIndex;
+    D3D12_VIDEO_ENCODER_CODEC Codec;
+    DXGI_FORMAT InputFormat;
+    D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION CodecConfiguration;
+    D3D12_VIDEO_ENCODER_SEQUENCE_GOP_STRUCTURE CodecGopSequence;
+    D3D12_VIDEO_ENCODER_RATE_CONTROL RateControl;
+    D3D12_VIDEO_ENCODER_INTRA_REFRESH_MODE IntraRefresh;
+    D3D12_VIDEO_ENCODER_FRAME_SUBREGION_LAYOUT_MODE SubregionFrameEncoding;
+    UINT ResolutionsListCount;
+    const D3D12_VIDEO_ENCODER_PICTURE_RESOLUTION_DESC *pResolutionList;
+    UINT MaxReferenceFramesInDPB;
+    D3D12_VIDEO_ENCODER_VALIDATION_FLAGS ValidationFlags;
+    D3D12_VIDEO_ENCODER_SUPPORT_FLAGS SupportFlags;
+    D3D12_VIDEO_ENCODER_PROFILE_DESC SuggestedProfile;
+    D3D12_VIDEO_ENCODER_LEVEL_SETTING SuggestedLevel;
+    _Field_size_full_(ResolutionsListCount)  D3D12_FEATURE_DATA_VIDEO_ENCODER_RESOLUTION_SUPPORT_LIMITS *pResolutionDependentSupport;
+    } 	D3D12_FEATURE_DATA_VIDEO_ENCODER_SUPPORT;
+
+typedef struct D3D12_FEATURE_DATA_VIDEO_ENCODER_RESOURCE_REQUIREMENTS
+    {
+    UINT NodeIndex;
+    D3D12_VIDEO_ENCODER_CODEC Codec;
+    D3D12_VIDEO_ENCODER_PROFILE_DESC Profile;
+    DXGI_FORMAT InputFormat;
+    D3D12_VIDEO_ENCODER_PICTURE_RESOLUTION_DESC PictureTargetResolution;
+    BOOL IsSupported;
+    UINT CompressedBitstreamBufferAccessAlignment;
+    UINT EncoderMetadataBufferAccessAlignment;
+    UINT MaxEncoderOutputMetadataBufferSize;
+    } 	D3D12_FEATURE_DATA_VIDEO_ENCODER_RESOURCE_REQUIREMENTS;
+
+typedef 
+enum D3D12_VIDEO_ENCODER_FLAGS
+    {
+        D3D12_VIDEO_ENCODER_FLAG_NONE	= 0
+    } 	D3D12_VIDEO_ENCODER_FLAGS;
+
+DEFINE_ENUM_FLAG_OPERATORS(D3D12_VIDEO_ENCODER_FLAGS);
+typedef struct D3D12_VIDEO_ENCODER_DESC
+    {
+    UINT NodeMask;
+    D3D12_VIDEO_ENCODER_FLAGS Flags;
+    D3D12_VIDEO_ENCODER_CODEC EncodeCodec;
+    D3D12_VIDEO_ENCODER_PROFILE_DESC EncodeProfile;
+    DXGI_FORMAT InputFormat;
+    D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION CodecConfiguration;
+    D3D12_VIDEO_ENCODER_MOTION_ESTIMATION_PRECISION_MODE MaxMotionEstimationPrecision;
+    } 	D3D12_VIDEO_ENCODER_DESC;
+
+
+
+extern RPC_IF_HANDLE __MIDL_itf_d3d12video_0000_0022_v0_0_c_ifspec;
+extern RPC_IF_HANDLE __MIDL_itf_d3d12video_0000_0022_v0_0_s_ifspec;
+
+#ifndef __ID3D12VideoEncoder_INTERFACE_DEFINED__
+#define __ID3D12VideoEncoder_INTERFACE_DEFINED__
+
+/* interface ID3D12VideoEncoder */
+/* [unique][local][object][uuid] */ 
+
+
+EXTERN_C const IID IID_ID3D12VideoEncoder;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("2E0D212D-8DF9-44A6-A770-BB289B182737")
+    ID3D12VideoEncoder : public ID3D12Pageable
+    {
+    public:
+        virtual UINT STDMETHODCALLTYPE GetNodeMask( void) = 0;
+        
+        virtual D3D12_VIDEO_ENCODER_FLAGS STDMETHODCALLTYPE GetEncoderFlags( void) = 0;
+        
+        virtual D3D12_VIDEO_ENCODER_CODEC STDMETHODCALLTYPE GetCodec( void) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE GetCodecProfile( 
+            _Inout_  D3D12_VIDEO_ENCODER_PROFILE_DESC dstProfile) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE GetCodecConfiguration( 
+            _Inout_  D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION dstCodecConfig) = 0;
+        
+        virtual DXGI_FORMAT STDMETHODCALLTYPE GetInputFormat( void) = 0;
+        
+        virtual D3D12_VIDEO_ENCODER_MOTION_ESTIMATION_PRECISION_MODE STDMETHODCALLTYPE GetMaxMotionEstimationPrecision( void) = 0;
+        
+    };
+    
+    
+#else 	/* C style interface */
+
+    typedef struct ID3D12VideoEncoderVtbl
+    {
+        BEGIN_INTERFACE
+        
+        DECLSPEC_XFGVIRT(IUnknown, QueryInterface)
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            ID3D12VideoEncoder * This,
+            REFIID riid,
+            _COM_Outptr_  void **ppvObject);
+        
+        DECLSPEC_XFGVIRT(IUnknown, AddRef)
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            ID3D12VideoEncoder * This);
+        
+        DECLSPEC_XFGVIRT(IUnknown, Release)
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            ID3D12VideoEncoder * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, GetPrivateData)
+        HRESULT ( STDMETHODCALLTYPE *GetPrivateData )( 
+            ID3D12VideoEncoder * This,
+            _In_  REFGUID guid,
+            _Inout_  UINT *pDataSize,
+            _Out_writes_bytes_opt_( *pDataSize )  void *pData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, SetPrivateData)
+        HRESULT ( STDMETHODCALLTYPE *SetPrivateData )( 
+            ID3D12VideoEncoder * This,
+            _In_  REFGUID guid,
+            _In_  UINT DataSize,
+            _In_reads_bytes_opt_( DataSize )  const void *pData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, SetPrivateDataInterface)
+        HRESULT ( STDMETHODCALLTYPE *SetPrivateDataInterface )( 
+            ID3D12VideoEncoder * This,
+            _In_  REFGUID guid,
+            _In_opt_  const IUnknown *pData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, SetName)
+        HRESULT ( STDMETHODCALLTYPE *SetName )( 
+            ID3D12VideoEncoder * This,
+            _In_z_  LPCWSTR Name);
+        
+        DECLSPEC_XFGVIRT(ID3D12DeviceChild, GetDevice)
+        HRESULT ( STDMETHODCALLTYPE *GetDevice )( 
+            ID3D12VideoEncoder * This,
+            REFIID riid,
+            _COM_Outptr_opt_  void **ppvDevice);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoEncoder, GetNodeMask)
+        UINT ( STDMETHODCALLTYPE *GetNodeMask )( 
+            ID3D12VideoEncoder * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoEncoder, GetEncoderFlags)
+        D3D12_VIDEO_ENCODER_FLAGS ( STDMETHODCALLTYPE *GetEncoderFlags )( 
+            ID3D12VideoEncoder * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoEncoder, GetCodec)
+        D3D12_VIDEO_ENCODER_CODEC ( STDMETHODCALLTYPE *GetCodec )( 
+            ID3D12VideoEncoder * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoEncoder, GetCodecProfile)
+        HRESULT ( STDMETHODCALLTYPE *GetCodecProfile )( 
+            ID3D12VideoEncoder * This,
+            _Inout_  D3D12_VIDEO_ENCODER_PROFILE_DESC dstProfile);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoEncoder, GetCodecConfiguration)
+        HRESULT ( STDMETHODCALLTYPE *GetCodecConfiguration )( 
+            ID3D12VideoEncoder * This,
+            _Inout_  D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION dstCodecConfig);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoEncoder, GetInputFormat)
+        DXGI_FORMAT ( STDMETHODCALLTYPE *GetInputFormat )( 
+            ID3D12VideoEncoder * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoEncoder, GetMaxMotionEstimationPrecision)
+        D3D12_VIDEO_ENCODER_MOTION_ESTIMATION_PRECISION_MODE ( STDMETHODCALLTYPE *GetMaxMotionEstimationPrecision )( 
+            ID3D12VideoEncoder * This);
+        
+        END_INTERFACE
+    } ID3D12VideoEncoderVtbl;
+
+    interface ID3D12VideoEncoder
+    {
+        CONST_VTBL struct ID3D12VideoEncoderVtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define ID3D12VideoEncoder_QueryInterface(This,riid,ppvObject)	\
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define ID3D12VideoEncoder_AddRef(This)	\
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define ID3D12VideoEncoder_Release(This)	\
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#define ID3D12VideoEncoder_GetPrivateData(This,guid,pDataSize,pData)	\
+    ( (This)->lpVtbl -> GetPrivateData(This,guid,pDataSize,pData) ) 
+
+#define ID3D12VideoEncoder_SetPrivateData(This,guid,DataSize,pData)	\
+    ( (This)->lpVtbl -> SetPrivateData(This,guid,DataSize,pData) ) 
+
+#define ID3D12VideoEncoder_SetPrivateDataInterface(This,guid,pData)	\
+    ( (This)->lpVtbl -> SetPrivateDataInterface(This,guid,pData) ) 
+
+#define ID3D12VideoEncoder_SetName(This,Name)	\
+    ( (This)->lpVtbl -> SetName(This,Name) ) 
+
+
+#define ID3D12VideoEncoder_GetDevice(This,riid,ppvDevice)	\
+    ( (This)->lpVtbl -> GetDevice(This,riid,ppvDevice) ) 
+
+
+
+#define ID3D12VideoEncoder_GetNodeMask(This)	\
+    ( (This)->lpVtbl -> GetNodeMask(This) ) 
+
+#define ID3D12VideoEncoder_GetEncoderFlags(This)	\
+    ( (This)->lpVtbl -> GetEncoderFlags(This) ) 
+
+#define ID3D12VideoEncoder_GetCodec(This)	\
+    ( (This)->lpVtbl -> GetCodec(This) ) 
+
+#define ID3D12VideoEncoder_GetCodecProfile(This,dstProfile)	\
+    ( (This)->lpVtbl -> GetCodecProfile(This,dstProfile) ) 
+
+#define ID3D12VideoEncoder_GetCodecConfiguration(This,dstCodecConfig)	\
+    ( (This)->lpVtbl -> GetCodecConfiguration(This,dstCodecConfig) ) 
+
+#define ID3D12VideoEncoder_GetInputFormat(This)	\
+    ( (This)->lpVtbl -> GetInputFormat(This) ) 
+
+#define ID3D12VideoEncoder_GetMaxMotionEstimationPrecision(This)	\
+    ( (This)->lpVtbl -> GetMaxMotionEstimationPrecision(This) ) 
+
+#endif /* COBJMACROS */
+
+
+#endif 	/* C style interface */
+
+
+
+
+#endif 	/* __ID3D12VideoEncoder_INTERFACE_DEFINED__ */
+
+
+#ifndef __ID3D12VideoEncoderHeap_INTERFACE_DEFINED__
+#define __ID3D12VideoEncoderHeap_INTERFACE_DEFINED__
+
+/* interface ID3D12VideoEncoderHeap */
+/* [unique][local][object][uuid] */ 
+
+
+EXTERN_C const IID IID_ID3D12VideoEncoderHeap;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("22B35D96-876A-44C0-B25E-FB8C9C7F1C4A")
+    ID3D12VideoEncoderHeap : public ID3D12Pageable
+    {
+    public:
+        virtual UINT STDMETHODCALLTYPE GetNodeMask( void) = 0;
+        
+        virtual D3D12_VIDEO_ENCODER_HEAP_FLAGS STDMETHODCALLTYPE GetEncoderHeapFlags( void) = 0;
+        
+        virtual D3D12_VIDEO_ENCODER_CODEC STDMETHODCALLTYPE GetCodec( void) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE GetCodecProfile( 
+            _Inout_  D3D12_VIDEO_ENCODER_PROFILE_DESC dstProfile) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE GetCodecLevel( 
+            _Inout_  D3D12_VIDEO_ENCODER_LEVEL_SETTING dstLevel) = 0;
+        
+        virtual UINT STDMETHODCALLTYPE GetResolutionListCount( void) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE GetResolutionList( 
+            const UINT ResolutionsListCount,
+            _Out_writes_(ResolutionsListCount)  D3D12_VIDEO_ENCODER_PICTURE_RESOLUTION_DESC *pResolutionList) = 0;
+        
+    };
+    
+    
+#else 	/* C style interface */
+
+    typedef struct ID3D12VideoEncoderHeapVtbl
+    {
+        BEGIN_INTERFACE
+        
+        DECLSPEC_XFGVIRT(IUnknown, QueryInterface)
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            ID3D12VideoEncoderHeap * This,
+            REFIID riid,
+            _COM_Outptr_  void **ppvObject);
+        
+        DECLSPEC_XFGVIRT(IUnknown, AddRef)
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            ID3D12VideoEncoderHeap * This);
+        
+        DECLSPEC_XFGVIRT(IUnknown, Release)
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            ID3D12VideoEncoderHeap * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, GetPrivateData)
+        HRESULT ( STDMETHODCALLTYPE *GetPrivateData )( 
+            ID3D12VideoEncoderHeap * This,
+            _In_  REFGUID guid,
+            _Inout_  UINT *pDataSize,
+            _Out_writes_bytes_opt_( *pDataSize )  void *pData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, SetPrivateData)
+        HRESULT ( STDMETHODCALLTYPE *SetPrivateData )( 
+            ID3D12VideoEncoderHeap * This,
+            _In_  REFGUID guid,
+            _In_  UINT DataSize,
+            _In_reads_bytes_opt_( DataSize )  const void *pData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, SetPrivateDataInterface)
+        HRESULT ( STDMETHODCALLTYPE *SetPrivateDataInterface )( 
+            ID3D12VideoEncoderHeap * This,
+            _In_  REFGUID guid,
+            _In_opt_  const IUnknown *pData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, SetName)
+        HRESULT ( STDMETHODCALLTYPE *SetName )( 
+            ID3D12VideoEncoderHeap * This,
+            _In_z_  LPCWSTR Name);
+        
+        DECLSPEC_XFGVIRT(ID3D12DeviceChild, GetDevice)
+        HRESULT ( STDMETHODCALLTYPE *GetDevice )( 
+            ID3D12VideoEncoderHeap * This,
+            REFIID riid,
+            _COM_Outptr_opt_  void **ppvDevice);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoEncoderHeap, GetNodeMask)
+        UINT ( STDMETHODCALLTYPE *GetNodeMask )( 
+            ID3D12VideoEncoderHeap * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoEncoderHeap, GetEncoderHeapFlags)
+        D3D12_VIDEO_ENCODER_HEAP_FLAGS ( STDMETHODCALLTYPE *GetEncoderHeapFlags )( 
+            ID3D12VideoEncoderHeap * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoEncoderHeap, GetCodec)
+        D3D12_VIDEO_ENCODER_CODEC ( STDMETHODCALLTYPE *GetCodec )( 
+            ID3D12VideoEncoderHeap * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoEncoderHeap, GetCodecProfile)
+        HRESULT ( STDMETHODCALLTYPE *GetCodecProfile )( 
+            ID3D12VideoEncoderHeap * This,
+            _Inout_  D3D12_VIDEO_ENCODER_PROFILE_DESC dstProfile);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoEncoderHeap, GetCodecLevel)
+        HRESULT ( STDMETHODCALLTYPE *GetCodecLevel )( 
+            ID3D12VideoEncoderHeap * This,
+            _Inout_  D3D12_VIDEO_ENCODER_LEVEL_SETTING dstLevel);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoEncoderHeap, GetResolutionListCount)
+        UINT ( STDMETHODCALLTYPE *GetResolutionListCount )( 
+            ID3D12VideoEncoderHeap * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoEncoderHeap, GetResolutionList)
+        HRESULT ( STDMETHODCALLTYPE *GetResolutionList )( 
+            ID3D12VideoEncoderHeap * This,
+            const UINT ResolutionsListCount,
+            _Out_writes_(ResolutionsListCount)  D3D12_VIDEO_ENCODER_PICTURE_RESOLUTION_DESC *pResolutionList);
+        
+        END_INTERFACE
+    } ID3D12VideoEncoderHeapVtbl;
+
+    interface ID3D12VideoEncoderHeap
+    {
+        CONST_VTBL struct ID3D12VideoEncoderHeapVtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define ID3D12VideoEncoderHeap_QueryInterface(This,riid,ppvObject)	\
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define ID3D12VideoEncoderHeap_AddRef(This)	\
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define ID3D12VideoEncoderHeap_Release(This)	\
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#define ID3D12VideoEncoderHeap_GetPrivateData(This,guid,pDataSize,pData)	\
+    ( (This)->lpVtbl -> GetPrivateData(This,guid,pDataSize,pData) ) 
+
+#define ID3D12VideoEncoderHeap_SetPrivateData(This,guid,DataSize,pData)	\
+    ( (This)->lpVtbl -> SetPrivateData(This,guid,DataSize,pData) ) 
+
+#define ID3D12VideoEncoderHeap_SetPrivateDataInterface(This,guid,pData)	\
+    ( (This)->lpVtbl -> SetPrivateDataInterface(This,guid,pData) ) 
+
+#define ID3D12VideoEncoderHeap_SetName(This,Name)	\
+    ( (This)->lpVtbl -> SetName(This,Name) ) 
+
+
+#define ID3D12VideoEncoderHeap_GetDevice(This,riid,ppvDevice)	\
+    ( (This)->lpVtbl -> GetDevice(This,riid,ppvDevice) ) 
+
+
+
+#define ID3D12VideoEncoderHeap_GetNodeMask(This)	\
+    ( (This)->lpVtbl -> GetNodeMask(This) ) 
+
+#define ID3D12VideoEncoderHeap_GetEncoderHeapFlags(This)	\
+    ( (This)->lpVtbl -> GetEncoderHeapFlags(This) ) 
+
+#define ID3D12VideoEncoderHeap_GetCodec(This)	\
+    ( (This)->lpVtbl -> GetCodec(This) ) 
+
+#define ID3D12VideoEncoderHeap_GetCodecProfile(This,dstProfile)	\
+    ( (This)->lpVtbl -> GetCodecProfile(This,dstProfile) ) 
+
+#define ID3D12VideoEncoderHeap_GetCodecLevel(This,dstLevel)	\
+    ( (This)->lpVtbl -> GetCodecLevel(This,dstLevel) ) 
+
+#define ID3D12VideoEncoderHeap_GetResolutionListCount(This)	\
+    ( (This)->lpVtbl -> GetResolutionListCount(This) ) 
+
+#define ID3D12VideoEncoderHeap_GetResolutionList(This,ResolutionsListCount,pResolutionList)	\
+    ( (This)->lpVtbl -> GetResolutionList(This,ResolutionsListCount,pResolutionList) ) 
+
+#endif /* COBJMACROS */
+
+
+#endif 	/* C style interface */
+
+
+
+
+#endif 	/* __ID3D12VideoEncoderHeap_INTERFACE_DEFINED__ */
+
+
+#ifndef __ID3D12VideoDevice3_INTERFACE_DEFINED__
+#define __ID3D12VideoDevice3_INTERFACE_DEFINED__
+
+/* interface ID3D12VideoDevice3 */
+/* [unique][local][object][uuid] */ 
+
+
+EXTERN_C const IID IID_ID3D12VideoDevice3;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("4243ADB4-3A32-4666-973C-0CCC5625DC44")
+    ID3D12VideoDevice3 : public ID3D12VideoDevice2
+    {
+    public:
+        virtual HRESULT STDMETHODCALLTYPE CreateVideoEncoder( 
+            _In_  const D3D12_VIDEO_ENCODER_DESC *pDesc,
+            _In_  REFIID riid,
+            _COM_Outptr_  void **ppVideoEncoder) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE CreateVideoEncoderHeap( 
+            _In_  const D3D12_VIDEO_ENCODER_HEAP_DESC *pDesc,
+            _In_  REFIID riid,
+            _COM_Outptr_  void **ppVideoEncoderHeap) = 0;
+        
+    };
+    
+    
+#else 	/* C style interface */
+
+    typedef struct ID3D12VideoDevice3Vtbl
+    {
+        BEGIN_INTERFACE
+        
+        DECLSPEC_XFGVIRT(IUnknown, QueryInterface)
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            ID3D12VideoDevice3 * This,
+            REFIID riid,
+            _COM_Outptr_  void **ppvObject);
+        
+        DECLSPEC_XFGVIRT(IUnknown, AddRef)
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            ID3D12VideoDevice3 * This);
+        
+        DECLSPEC_XFGVIRT(IUnknown, Release)
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            ID3D12VideoDevice3 * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoDevice, CheckFeatureSupport)
+        HRESULT ( STDMETHODCALLTYPE *CheckFeatureSupport )( 
+            ID3D12VideoDevice3 * This,
+            D3D12_FEATURE_VIDEO FeatureVideo,
+            _Inout_updates_bytes_(FeatureSupportDataSize)  void *pFeatureSupportData,
+            UINT FeatureSupportDataSize);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoDevice, CreateVideoDecoder)
+        HRESULT ( STDMETHODCALLTYPE *CreateVideoDecoder )( 
+            ID3D12VideoDevice3 * This,
+            _In_  const D3D12_VIDEO_DECODER_DESC *pDesc,
+            _In_  REFIID riid,
+            _COM_Outptr_  void **ppVideoDecoder);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoDevice, CreateVideoDecoderHeap)
+        HRESULT ( STDMETHODCALLTYPE *CreateVideoDecoderHeap )( 
+            ID3D12VideoDevice3 * This,
+            _In_  const D3D12_VIDEO_DECODER_HEAP_DESC *pVideoDecoderHeapDesc,
+            _In_  REFIID riid,
+            _COM_Outptr_  void **ppVideoDecoderHeap);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoDevice, CreateVideoProcessor)
+        HRESULT ( STDMETHODCALLTYPE *CreateVideoProcessor )( 
+            ID3D12VideoDevice3 * This,
+            UINT NodeMask,
+            _In_  const D3D12_VIDEO_PROCESS_OUTPUT_STREAM_DESC *pOutputStreamDesc,
+            UINT NumInputStreamDescs,
+            _In_reads_(NumInputStreamDescs)  const D3D12_VIDEO_PROCESS_INPUT_STREAM_DESC *pInputStreamDescs,
+            _In_  REFIID riid,
+            _COM_Outptr_  void **ppVideoProcessor);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoDevice1, CreateVideoMotionEstimator)
+        HRESULT ( STDMETHODCALLTYPE *CreateVideoMotionEstimator )( 
+            ID3D12VideoDevice3 * This,
+            _In_  const D3D12_VIDEO_MOTION_ESTIMATOR_DESC *pDesc,
+            _In_opt_  ID3D12ProtectedResourceSession *pProtectedResourceSession,
+            _In_  REFIID riid,
+            _COM_Outptr_  void **ppVideoMotionEstimator);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoDevice1, CreateVideoMotionVectorHeap)
+        HRESULT ( STDMETHODCALLTYPE *CreateVideoMotionVectorHeap )( 
+            ID3D12VideoDevice3 * This,
+            _In_  const D3D12_VIDEO_MOTION_VECTOR_HEAP_DESC *pDesc,
+            _In_opt_  ID3D12ProtectedResourceSession *pProtectedResourceSession,
+            _In_  REFIID riid,
+            _COM_Outptr_  void **ppVideoMotionVectorHeap);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoDevice2, CreateVideoDecoder1)
+        HRESULT ( STDMETHODCALLTYPE *CreateVideoDecoder1 )( 
+            ID3D12VideoDevice3 * This,
+            _In_  const D3D12_VIDEO_DECODER_DESC *pDesc,
+            _In_opt_  ID3D12ProtectedResourceSession *pProtectedResourceSession,
+            _In_  REFIID riid,
+            _COM_Outptr_  void **ppVideoDecoder);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoDevice2, CreateVideoDecoderHeap1)
+        HRESULT ( STDMETHODCALLTYPE *CreateVideoDecoderHeap1 )( 
+            ID3D12VideoDevice3 * This,
+            _In_  const D3D12_VIDEO_DECODER_HEAP_DESC *pVideoDecoderHeapDesc,
+            _In_opt_  ID3D12ProtectedResourceSession *pProtectedResourceSession,
+            _In_  REFIID riid,
+            _COM_Outptr_  void **ppVideoDecoderHeap);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoDevice2, CreateVideoProcessor1)
+        HRESULT ( STDMETHODCALLTYPE *CreateVideoProcessor1 )( 
+            ID3D12VideoDevice3 * This,
+            UINT NodeMask,
+            _In_  const D3D12_VIDEO_PROCESS_OUTPUT_STREAM_DESC *pOutputStreamDesc,
+            UINT NumInputStreamDescs,
+            _In_reads_(NumInputStreamDescs)  const D3D12_VIDEO_PROCESS_INPUT_STREAM_DESC *pInputStreamDescs,
+            _In_opt_  ID3D12ProtectedResourceSession *pProtectedResourceSession,
+            _In_  REFIID riid,
+            _COM_Outptr_  void **ppVideoProcessor);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoDevice2, CreateVideoExtensionCommand)
+        HRESULT ( STDMETHODCALLTYPE *CreateVideoExtensionCommand )( 
+            ID3D12VideoDevice3 * This,
+            _In_  const D3D12_VIDEO_EXTENSION_COMMAND_DESC *pDesc,
+            _In_reads_bytes_(CreationParametersDataSizeInBytes)  const void *pCreationParameters,
+            SIZE_T CreationParametersDataSizeInBytes,
+            _In_opt_  ID3D12ProtectedResourceSession *pProtectedResourceSession,
+            _In_  REFIID riid,
+            _COM_Outptr_  void **ppVideoExtensionCommand);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoDevice2, ExecuteExtensionCommand)
+        HRESULT ( STDMETHODCALLTYPE *ExecuteExtensionCommand )( 
+            ID3D12VideoDevice3 * This,
+            _In_  ID3D12VideoExtensionCommand *pExtensionCommand,
+            _In_reads_bytes_(ExecutionParametersSizeInBytes)  const void *pExecutionParameters,
+            SIZE_T ExecutionParametersSizeInBytes,
+            _Out_writes_bytes_(OutputDataSizeInBytes)  void *pOutputData,
+            SIZE_T OutputDataSizeInBytes);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoDevice3, CreateVideoEncoder)
+        HRESULT ( STDMETHODCALLTYPE *CreateVideoEncoder )( 
+            ID3D12VideoDevice3 * This,
+            _In_  const D3D12_VIDEO_ENCODER_DESC *pDesc,
+            _In_  REFIID riid,
+            _COM_Outptr_  void **ppVideoEncoder);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoDevice3, CreateVideoEncoderHeap)
+        HRESULT ( STDMETHODCALLTYPE *CreateVideoEncoderHeap )( 
+            ID3D12VideoDevice3 * This,
+            _In_  const D3D12_VIDEO_ENCODER_HEAP_DESC *pDesc,
+            _In_  REFIID riid,
+            _COM_Outptr_  void **ppVideoEncoderHeap);
+        
+        END_INTERFACE
+    } ID3D12VideoDevice3Vtbl;
+
+    interface ID3D12VideoDevice3
+    {
+        CONST_VTBL struct ID3D12VideoDevice3Vtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define ID3D12VideoDevice3_QueryInterface(This,riid,ppvObject)	\
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define ID3D12VideoDevice3_AddRef(This)	\
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define ID3D12VideoDevice3_Release(This)	\
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#define ID3D12VideoDevice3_CheckFeatureSupport(This,FeatureVideo,pFeatureSupportData,FeatureSupportDataSize)	\
+    ( (This)->lpVtbl -> CheckFeatureSupport(This,FeatureVideo,pFeatureSupportData,FeatureSupportDataSize) ) 
+
+#define ID3D12VideoDevice3_CreateVideoDecoder(This,pDesc,riid,ppVideoDecoder)	\
+    ( (This)->lpVtbl -> CreateVideoDecoder(This,pDesc,riid,ppVideoDecoder) ) 
+
+#define ID3D12VideoDevice3_CreateVideoDecoderHeap(This,pVideoDecoderHeapDesc,riid,ppVideoDecoderHeap)	\
+    ( (This)->lpVtbl -> CreateVideoDecoderHeap(This,pVideoDecoderHeapDesc,riid,ppVideoDecoderHeap) ) 
+
+#define ID3D12VideoDevice3_CreateVideoProcessor(This,NodeMask,pOutputStreamDesc,NumInputStreamDescs,pInputStreamDescs,riid,ppVideoProcessor)	\
+    ( (This)->lpVtbl -> CreateVideoProcessor(This,NodeMask,pOutputStreamDesc,NumInputStreamDescs,pInputStreamDescs,riid,ppVideoProcessor) ) 
+
+
+#define ID3D12VideoDevice3_CreateVideoMotionEstimator(This,pDesc,pProtectedResourceSession,riid,ppVideoMotionEstimator)	\
+    ( (This)->lpVtbl -> CreateVideoMotionEstimator(This,pDesc,pProtectedResourceSession,riid,ppVideoMotionEstimator) ) 
+
+#define ID3D12VideoDevice3_CreateVideoMotionVectorHeap(This,pDesc,pProtectedResourceSession,riid,ppVideoMotionVectorHeap)	\
+    ( (This)->lpVtbl -> CreateVideoMotionVectorHeap(This,pDesc,pProtectedResourceSession,riid,ppVideoMotionVectorHeap) ) 
+
+
+#define ID3D12VideoDevice3_CreateVideoDecoder1(This,pDesc,pProtectedResourceSession,riid,ppVideoDecoder)	\
+    ( (This)->lpVtbl -> CreateVideoDecoder1(This,pDesc,pProtectedResourceSession,riid,ppVideoDecoder) ) 
+
+#define ID3D12VideoDevice3_CreateVideoDecoderHeap1(This,pVideoDecoderHeapDesc,pProtectedResourceSession,riid,ppVideoDecoderHeap)	\
+    ( (This)->lpVtbl -> CreateVideoDecoderHeap1(This,pVideoDecoderHeapDesc,pProtectedResourceSession,riid,ppVideoDecoderHeap) ) 
+
+#define ID3D12VideoDevice3_CreateVideoProcessor1(This,NodeMask,pOutputStreamDesc,NumInputStreamDescs,pInputStreamDescs,pProtectedResourceSession,riid,ppVideoProcessor)	\
+    ( (This)->lpVtbl -> CreateVideoProcessor1(This,NodeMask,pOutputStreamDesc,NumInputStreamDescs,pInputStreamDescs,pProtectedResourceSession,riid,ppVideoProcessor) ) 
+
+#define ID3D12VideoDevice3_CreateVideoExtensionCommand(This,pDesc,pCreationParameters,CreationParametersDataSizeInBytes,pProtectedResourceSession,riid,ppVideoExtensionCommand)	\
+    ( (This)->lpVtbl -> CreateVideoExtensionCommand(This,pDesc,pCreationParameters,CreationParametersDataSizeInBytes,pProtectedResourceSession,riid,ppVideoExtensionCommand) ) 
+
+#define ID3D12VideoDevice3_ExecuteExtensionCommand(This,pExtensionCommand,pExecutionParameters,ExecutionParametersSizeInBytes,pOutputData,OutputDataSizeInBytes)	\
+    ( (This)->lpVtbl -> ExecuteExtensionCommand(This,pExtensionCommand,pExecutionParameters,ExecutionParametersSizeInBytes,pOutputData,OutputDataSizeInBytes) ) 
+
+
+#define ID3D12VideoDevice3_CreateVideoEncoder(This,pDesc,riid,ppVideoEncoder)	\
+    ( (This)->lpVtbl -> CreateVideoEncoder(This,pDesc,riid,ppVideoEncoder) ) 
+
+#define ID3D12VideoDevice3_CreateVideoEncoderHeap(This,pDesc,riid,ppVideoEncoderHeap)	\
+    ( (This)->lpVtbl -> CreateVideoEncoderHeap(This,pDesc,riid,ppVideoEncoderHeap) ) 
+
+#endif /* COBJMACROS */
+
+
+#endif 	/* C style interface */
+
+
+
+
+#endif 	/* __ID3D12VideoDevice3_INTERFACE_DEFINED__ */
+
+
+/* interface __MIDL_itf_d3d12video_0000_0025 */
+/* [local] */ 
+
+typedef 
+enum D3D12_VIDEO_ENCODER_FRAME_TYPE_H264
+    {
+        D3D12_VIDEO_ENCODER_FRAME_TYPE_H264_I_FRAME	= 0,
+        D3D12_VIDEO_ENCODER_FRAME_TYPE_H264_P_FRAME	= 1,
+        D3D12_VIDEO_ENCODER_FRAME_TYPE_H264_B_FRAME	= 2,
+        D3D12_VIDEO_ENCODER_FRAME_TYPE_H264_IDR_FRAME	= 3
+    } 	D3D12_VIDEO_ENCODER_FRAME_TYPE_H264;
+
+typedef struct D3D12_VIDEO_ENCODER_REFERENCE_PICTURE_DESCRIPTOR_H264
+    {
+    UINT ReconstructedPictureResourceIndex;
+    BOOL IsLongTermReference;
+    UINT LongTermPictureIdx;
+    UINT PictureOrderCountNumber;
+    UINT FrameDecodingOrderNumber;
+    UINT TemporalLayerIndex;
+    } 	D3D12_VIDEO_ENCODER_REFERENCE_PICTURE_DESCRIPTOR_H264;
+
+typedef 
+enum D3D12_VIDEO_ENCODER_PICTURE_CONTROL_CODEC_DATA_H264_FLAGS
+    {
+        D3D12_VIDEO_ENCODER_PICTURE_CONTROL_CODEC_DATA_H264_FLAG_NONE	= 0,
+        D3D12_VIDEO_ENCODER_PICTURE_CONTROL_CODEC_DATA_H264_FLAG_REQUEST_INTRA_CONSTRAINED_SLICES	= 0x1
+    } 	D3D12_VIDEO_ENCODER_PICTURE_CONTROL_CODEC_DATA_H264_FLAGS;
+
+DEFINE_ENUM_FLAG_OPERATORS(D3D12_VIDEO_ENCODER_PICTURE_CONTROL_CODEC_DATA_H264_FLAGS);
+typedef struct D3D12_VIDEO_ENCODER_PICTURE_CONTROL_CODEC_DATA_H264_REFERENCE_PICTURE_MARKING_OPERATION
+    {
+    UCHAR memory_management_control_operation;
+    UINT difference_of_pic_nums_minus1;
+    UINT long_term_pic_num;
+    UINT long_term_frame_idx;
+    UINT max_long_term_frame_idx_plus1;
+    } 	D3D12_VIDEO_ENCODER_PICTURE_CONTROL_CODEC_DATA_H264_REFERENCE_PICTURE_MARKING_OPERATION;
+
+typedef struct D3D12_VIDEO_ENCODER_PICTURE_CONTROL_CODEC_DATA_H264_REFERENCE_PICTURE_LIST_MODIFICATION_OPERATION
+    {
+    UCHAR modification_of_pic_nums_idc;
+    UINT abs_diff_pic_num_minus1;
+    UINT long_term_pic_num;
+    } 	D3D12_VIDEO_ENCODER_PICTURE_CONTROL_CODEC_DATA_H264_REFERENCE_PICTURE_LIST_MODIFICATION_OPERATION;
+
+typedef struct D3D12_VIDEO_ENCODER_PICTURE_CONTROL_CODEC_DATA_H264
+    {
+    D3D12_VIDEO_ENCODER_PICTURE_CONTROL_CODEC_DATA_H264_FLAGS Flags;
+    D3D12_VIDEO_ENCODER_FRAME_TYPE_H264 FrameType;
+    UINT pic_parameter_set_id;
+    UINT idr_pic_id;
+    UINT PictureOrderCountNumber;
+    UINT FrameDecodingOrderNumber;
+    UINT TemporalLayerIndex;
+    UINT List0ReferenceFramesCount;
+    _Field_size_full_(List0ReferenceFramesCount)  UINT *pList0ReferenceFrames;
+    UINT List1ReferenceFramesCount;
+    _Field_size_full_(List1ReferenceFramesCount)  UINT *pList1ReferenceFrames;
+    UINT ReferenceFramesReconPictureDescriptorsCount;
+    _Field_size_full_(ReferenceFramesReconPictureDescriptorsCount)  D3D12_VIDEO_ENCODER_REFERENCE_PICTURE_DESCRIPTOR_H264 *pReferenceFramesReconPictureDescriptors;
+    UCHAR adaptive_ref_pic_marking_mode_flag;
+    UINT RefPicMarkingOperationsCommandsCount;
+    _Field_size_full_(RefPicMarkingOperationsCommandsCount)  D3D12_VIDEO_ENCODER_PICTURE_CONTROL_CODEC_DATA_H264_REFERENCE_PICTURE_MARKING_OPERATION *pRefPicMarkingOperationsCommands;
+    UINT List0RefPicModificationsCount;
+    _Field_size_full_(List0RefPicModificationsCount)  D3D12_VIDEO_ENCODER_PICTURE_CONTROL_CODEC_DATA_H264_REFERENCE_PICTURE_LIST_MODIFICATION_OPERATION *pList0RefPicModifications;
+    UINT List1RefPicModificationsCount;
+    _Field_size_full_(List1RefPicModificationsCount)  D3D12_VIDEO_ENCODER_PICTURE_CONTROL_CODEC_DATA_H264_REFERENCE_PICTURE_LIST_MODIFICATION_OPERATION *pList1RefPicModifications;
+    UINT QPMapValuesCount;
+    _Field_size_full_(QPMapValuesCount)  INT8 *pRateControlQPMap;
+    } 	D3D12_VIDEO_ENCODER_PICTURE_CONTROL_CODEC_DATA_H264;
+
+typedef 
+enum D3D12_VIDEO_ENCODER_FRAME_TYPE_HEVC
+    {
+        D3D12_VIDEO_ENCODER_FRAME_TYPE_HEVC_I_FRAME	= 0,
+        D3D12_VIDEO_ENCODER_FRAME_TYPE_HEVC_P_FRAME	= 1,
+        D3D12_VIDEO_ENCODER_FRAME_TYPE_HEVC_B_FRAME	= 2,
+        D3D12_VIDEO_ENCODER_FRAME_TYPE_HEVC_IDR_FRAME	= 3
+    } 	D3D12_VIDEO_ENCODER_FRAME_TYPE_HEVC;
+
+typedef struct D3D12_VIDEO_ENCODER_REFERENCE_PICTURE_DESCRIPTOR_HEVC
+    {
+    UINT ReconstructedPictureResourceIndex;
+    BOOL IsRefUsedByCurrentPic;
+    BOOL IsLongTermReference;
+    UINT PictureOrderCountNumber;
+    UINT TemporalLayerIndex;
+    } 	D3D12_VIDEO_ENCODER_REFERENCE_PICTURE_DESCRIPTOR_HEVC;
+
+typedef 
+enum D3D12_VIDEO_ENCODER_PICTURE_CONTROL_CODEC_DATA_HEVC_FLAGS
+    {
+        D3D12_VIDEO_ENCODER_PICTURE_CONTROL_CODEC_DATA_HEVC_FLAG_NONE	= 0,
+        D3D12_VIDEO_ENCODER_PICTURE_CONTROL_CODEC_DATA_HEVC_FLAG_REQUEST_INTRA_CONSTRAINED_SLICES	= 0x1
+    } 	D3D12_VIDEO_ENCODER_PICTURE_CONTROL_CODEC_DATA_HEVC_FLAGS;
+
+DEFINE_ENUM_FLAG_OPERATORS(D3D12_VIDEO_ENCODER_PICTURE_CONTROL_CODEC_DATA_HEVC_FLAGS);
+typedef struct D3D12_VIDEO_ENCODER_PICTURE_CONTROL_CODEC_DATA_HEVC
+    {
+    D3D12_VIDEO_ENCODER_PICTURE_CONTROL_CODEC_DATA_HEVC_FLAGS Flags;
+    D3D12_VIDEO_ENCODER_FRAME_TYPE_HEVC FrameType;
+    UINT slice_pic_parameter_set_id;
+    UINT PictureOrderCountNumber;
+    UINT TemporalLayerIndex;
+    UINT List0ReferenceFramesCount;
+    _Field_size_full_(List0ReferenceFramesCount)  UINT *pList0ReferenceFrames;
+    UINT List1ReferenceFramesCount;
+    _Field_size_full_(List1ReferenceFramesCount)  UINT *pList1ReferenceFrames;
+    UINT ReferenceFramesReconPictureDescriptorsCount;
+    _Field_size_full_(ReferenceFramesReconPictureDescriptorsCount)  D3D12_VIDEO_ENCODER_REFERENCE_PICTURE_DESCRIPTOR_HEVC *pReferenceFramesReconPictureDescriptors;
+    UINT List0RefPicModificationsCount;
+    _Field_size_full_(List0RefPicModificationsCount)  UINT *pList0RefPicModifications;
+    UINT List1RefPicModificationsCount;
+    _Field_size_full_(List1RefPicModificationsCount)  UINT *pList1RefPicModifications;
+    UINT QPMapValuesCount;
+    _Field_size_full_(QPMapValuesCount)  INT8 *pRateControlQPMap;
+    } 	D3D12_VIDEO_ENCODER_PICTURE_CONTROL_CODEC_DATA_HEVC;
+
+typedef struct D3D12_VIDEO_ENCODER_PICTURE_CONTROL_CODEC_DATA
+    {
+    UINT DataSize;
+    union 
+        {
+        D3D12_VIDEO_ENCODER_PICTURE_CONTROL_CODEC_DATA_H264 *pH264PicData;
+        D3D12_VIDEO_ENCODER_PICTURE_CONTROL_CODEC_DATA_HEVC *pHEVCPicData;
+        } 	;
+    } 	D3D12_VIDEO_ENCODER_PICTURE_CONTROL_CODEC_DATA;
+
+typedef struct D3D12_VIDEO_ENCODE_REFERENCE_FRAMES
+    {
+    UINT NumTexture2Ds;
+    _Field_size_full_(NumTexture2Ds)  ID3D12Resource **ppTexture2Ds;
+    _Field_size_full_(NumTexture2Ds)  UINT *pSubresources;
+    } 	D3D12_VIDEO_ENCODE_REFERENCE_FRAMES;
+
+typedef 
+enum D3D12_VIDEO_ENCODER_PICTURE_CONTROL_FLAGS
+    {
+        D3D12_VIDEO_ENCODER_PICTURE_CONTROL_FLAG_NONE	= 0,
+        D3D12_VIDEO_ENCODER_PICTURE_CONTROL_FLAG_USED_AS_REFERENCE_PICTURE	= 0x1
+    } 	D3D12_VIDEO_ENCODER_PICTURE_CONTROL_FLAGS;
+
+DEFINE_ENUM_FLAG_OPERATORS(D3D12_VIDEO_ENCODER_PICTURE_CONTROL_FLAGS);
+typedef struct D3D12_VIDEO_ENCODER_PICTURE_CONTROL_DESC
+    {
+    UINT IntraRefreshFrameIndex;
+    D3D12_VIDEO_ENCODER_PICTURE_CONTROL_FLAGS Flags;
+    D3D12_VIDEO_ENCODER_PICTURE_CONTROL_CODEC_DATA PictureControlCodecData;
+    D3D12_VIDEO_ENCODE_REFERENCE_FRAMES ReferenceFrames;
+    } 	D3D12_VIDEO_ENCODER_PICTURE_CONTROL_DESC;
+
+typedef 
+enum D3D12_VIDEO_ENCODER_SEQUENCE_CONTROL_FLAGS
+    {
+        D3D12_VIDEO_ENCODER_SEQUENCE_CONTROL_FLAG_NONE	= 0,
+        D3D12_VIDEO_ENCODER_SEQUENCE_CONTROL_FLAG_RESOLUTION_CHANGE	= 0x1,
+        D3D12_VIDEO_ENCODER_SEQUENCE_CONTROL_FLAG_RATE_CONTROL_CHANGE	= 0x2,
+        D3D12_VIDEO_ENCODER_SEQUENCE_CONTROL_FLAG_SUBREGION_LAYOUT_CHANGE	= 0x4,
+        D3D12_VIDEO_ENCODER_SEQUENCE_CONTROL_FLAG_REQUEST_INTRA_REFRESH	= 0x8,
+        D3D12_VIDEO_ENCODER_SEQUENCE_CONTROL_FLAG_GOP_SEQUENCE_CHANGE	= 0x10
+    } 	D3D12_VIDEO_ENCODER_SEQUENCE_CONTROL_FLAGS;
+
+DEFINE_ENUM_FLAG_OPERATORS(D3D12_VIDEO_ENCODER_SEQUENCE_CONTROL_FLAGS);
+typedef struct D3D12_VIDEO_ENCODER_PICTURE_CONTROL_SUBREGIONS_LAYOUT_DATA_SLICES
+    {
+    union 
+        {
+        UINT MaxBytesPerSlice;
+        UINT NumberOfCodingUnitsPerSlice;
+        UINT NumberOfRowsPerSlice;
+        UINT NumberOfSlicesPerFrame;
+        } 	;
+    } 	D3D12_VIDEO_ENCODER_PICTURE_CONTROL_SUBREGIONS_LAYOUT_DATA_SLICES;
+
+typedef struct D3D12_VIDEO_ENCODER_PICTURE_CONTROL_SUBREGIONS_LAYOUT_DATA
+    {
+    UINT DataSize;
+    union 
+        {
+        const D3D12_VIDEO_ENCODER_PICTURE_CONTROL_SUBREGIONS_LAYOUT_DATA_SLICES *pSlicesPartition_H264;
+        const D3D12_VIDEO_ENCODER_PICTURE_CONTROL_SUBREGIONS_LAYOUT_DATA_SLICES *pSlicesPartition_HEVC;
+        } 	;
+    } 	D3D12_VIDEO_ENCODER_PICTURE_CONTROL_SUBREGIONS_LAYOUT_DATA;
+
+typedef struct D3D12_VIDEO_ENCODER_SEQUENCE_CONTROL_DESC
+    {
+    D3D12_VIDEO_ENCODER_SEQUENCE_CONTROL_FLAGS Flags;
+    D3D12_VIDEO_ENCODER_INTRA_REFRESH IntraRefreshConfig;
+    D3D12_VIDEO_ENCODER_RATE_CONTROL RateControl;
+    D3D12_VIDEO_ENCODER_PICTURE_RESOLUTION_DESC PictureTargetResolution;
+    D3D12_VIDEO_ENCODER_FRAME_SUBREGION_LAYOUT_MODE SelectedLayoutMode;
+    D3D12_VIDEO_ENCODER_PICTURE_CONTROL_SUBREGIONS_LAYOUT_DATA FrameSubregionsLayoutData;
+    D3D12_VIDEO_ENCODER_SEQUENCE_GOP_STRUCTURE CodecGopSequence;
+    } 	D3D12_VIDEO_ENCODER_SEQUENCE_CONTROL_DESC;
+
+typedef struct D3D12_VIDEO_ENCODER_ENCODEFRAME_INPUT_ARGUMENTS
+    {
+    D3D12_VIDEO_ENCODER_SEQUENCE_CONTROL_DESC SequenceControlDesc;
+    D3D12_VIDEO_ENCODER_PICTURE_CONTROL_DESC PictureControlDesc;
+    ID3D12Resource *pInputFrame;
+    UINT InputFrameSubresource;
+    UINT CurrentFrameBitstreamMetadataSize;
+    } 	D3D12_VIDEO_ENCODER_ENCODEFRAME_INPUT_ARGUMENTS;
+
+typedef struct D3D12_VIDEO_ENCODER_COMPRESSED_BITSTREAM
+    {
+    ID3D12Resource *pBuffer;
+    UINT64 FrameStartOffset;
+    } 	D3D12_VIDEO_ENCODER_COMPRESSED_BITSTREAM;
+
+typedef struct D3D12_VIDEO_ENCODER_RECONSTRUCTED_PICTURE
+    {
+    ID3D12Resource *pReconstructedPicture;
+    UINT ReconstructedPictureSubresource;
+    } 	D3D12_VIDEO_ENCODER_RECONSTRUCTED_PICTURE;
+
+typedef struct D3D12_VIDEO_ENCODER_FRAME_SUBREGION_METADATA
+    {
+    UINT64 bSize;
+    UINT64 bStartOffset;
+    UINT64 bHeaderSize;
+    } 	D3D12_VIDEO_ENCODER_FRAME_SUBREGION_METADATA;
+
+typedef 
+enum D3D12_VIDEO_ENCODER_ENCODE_ERROR_FLAGS
+    {
+        D3D12_VIDEO_ENCODER_ENCODE_ERROR_FLAG_NO_ERROR	= 0,
+        D3D12_VIDEO_ENCODER_ENCODE_ERROR_FLAG_CODEC_PICTURE_CONTROL_NOT_SUPPORTED	= 0x1,
+        D3D12_VIDEO_ENCODER_ENCODE_ERROR_FLAG_SUBREGION_LAYOUT_CONFIGURATION_NOT_SUPPORTED	= 0x2,
+        D3D12_VIDEO_ENCODER_ENCODE_ERROR_FLAG_INVALID_REFERENCE_PICTURES	= 0x4,
+        D3D12_VIDEO_ENCODER_ENCODE_ERROR_FLAG_RECONFIGURATION_REQUEST_NOT_SUPPORTED	= 0x8,
+        D3D12_VIDEO_ENCODER_ENCODE_ERROR_FLAG_INVALID_METADATA_BUFFER_SOURCE	= 0x10
+    } 	D3D12_VIDEO_ENCODER_ENCODE_ERROR_FLAGS;
+
+DEFINE_ENUM_FLAG_OPERATORS(D3D12_VIDEO_ENCODER_ENCODE_ERROR_FLAGS);
+typedef struct D3D12_VIDEO_ENCODER_OUTPUT_METADATA_STATISTICS
+    {
+    UINT64 AverageQP;
+    UINT64 IntraCodingUnitsCount;
+    UINT64 InterCodingUnitsCount;
+    UINT64 SkipCodingUnitsCount;
+    UINT64 AverageMotionEstimationXDirection;
+    UINT64 AverageMotionEstimationYDirection;
+    } 	D3D12_VIDEO_ENCODER_OUTPUT_METADATA_STATISTICS;
+
+typedef struct D3D12_VIDEO_ENCODER_OUTPUT_METADATA
+    {
+    UINT64 EncodeErrorFlags;
+    D3D12_VIDEO_ENCODER_OUTPUT_METADATA_STATISTICS EncodeStats;
+    UINT64 EncodedBitstreamWrittenBytesCount;
+    UINT64 WrittenSubregionsCount;
+    } 	D3D12_VIDEO_ENCODER_OUTPUT_METADATA;
+
+typedef struct D3D12_VIDEO_ENCODER_ENCODE_OPERATION_METADATA_BUFFER
+    {
+    ID3D12Resource *pBuffer;
+    UINT64 Offset;
+    } 	D3D12_VIDEO_ENCODER_ENCODE_OPERATION_METADATA_BUFFER;
+
+typedef struct D3D12_VIDEO_ENCODER_RESOLVE_METADATA_INPUT_ARGUMENTS
+    {
+    D3D12_VIDEO_ENCODER_CODEC EncoderCodec;
+    D3D12_VIDEO_ENCODER_PROFILE_DESC EncoderProfile;
+    DXGI_FORMAT EncoderInputFormat;
+    D3D12_VIDEO_ENCODER_PICTURE_RESOLUTION_DESC EncodedPictureEffectiveResolution;
+    D3D12_VIDEO_ENCODER_ENCODE_OPERATION_METADATA_BUFFER HWLayoutMetadata;
+    } 	D3D12_VIDEO_ENCODER_RESOLVE_METADATA_INPUT_ARGUMENTS;
+
+typedef struct D3D12_VIDEO_ENCODER_RESOLVE_METADATA_OUTPUT_ARGUMENTS
+    {
+    D3D12_VIDEO_ENCODER_ENCODE_OPERATION_METADATA_BUFFER ResolvedLayoutMetadata;
+    } 	D3D12_VIDEO_ENCODER_RESOLVE_METADATA_OUTPUT_ARGUMENTS;
+
+typedef struct D3D12_VIDEO_ENCODER_ENCODEFRAME_OUTPUT_ARGUMENTS
+    {
+    D3D12_VIDEO_ENCODER_COMPRESSED_BITSTREAM Bitstream;
+    D3D12_VIDEO_ENCODER_RECONSTRUCTED_PICTURE ReconstructedPicture;
+    D3D12_VIDEO_ENCODER_ENCODE_OPERATION_METADATA_BUFFER EncoderOutputMetadata;
+    } 	D3D12_VIDEO_ENCODER_ENCODEFRAME_OUTPUT_ARGUMENTS;
+
+
+
+extern RPC_IF_HANDLE __MIDL_itf_d3d12video_0000_0025_v0_0_c_ifspec;
+extern RPC_IF_HANDLE __MIDL_itf_d3d12video_0000_0025_v0_0_s_ifspec;
+
+#ifndef __ID3D12VideoEncodeCommandList2_INTERFACE_DEFINED__
+#define __ID3D12VideoEncodeCommandList2_INTERFACE_DEFINED__
+
+/* interface ID3D12VideoEncodeCommandList2 */
+/* [unique][local][object][uuid] */ 
+
+
+EXTERN_C const IID IID_ID3D12VideoEncodeCommandList2;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("895491e2-e701-46a9-9a1f-8d3480ed867a")
+    ID3D12VideoEncodeCommandList2 : public ID3D12VideoEncodeCommandList1
+    {
+    public:
+        virtual void STDMETHODCALLTYPE EncodeFrame( 
+            _In_  ID3D12VideoEncoder *pEncoder,
+            _In_  ID3D12VideoEncoderHeap *pHeap,
+            _In_  const D3D12_VIDEO_ENCODER_ENCODEFRAME_INPUT_ARGUMENTS *pInputArguments,
+            _In_  const D3D12_VIDEO_ENCODER_ENCODEFRAME_OUTPUT_ARGUMENTS *pOutputArguments) = 0;
+        
+        virtual void STDMETHODCALLTYPE ResolveEncoderOutputMetadata( 
+            _In_  const D3D12_VIDEO_ENCODER_RESOLVE_METADATA_INPUT_ARGUMENTS *pInputArguments,
+            _In_  const D3D12_VIDEO_ENCODER_RESOLVE_METADATA_OUTPUT_ARGUMENTS *pOutputArguments) = 0;
+        
+    };
+    
+    
+#else 	/* C style interface */
+
+    typedef struct ID3D12VideoEncodeCommandList2Vtbl
+    {
+        BEGIN_INTERFACE
+        
+        DECLSPEC_XFGVIRT(IUnknown, QueryInterface)
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            ID3D12VideoEncodeCommandList2 * This,
+            REFIID riid,
+            _COM_Outptr_  void **ppvObject);
+        
+        DECLSPEC_XFGVIRT(IUnknown, AddRef)
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            ID3D12VideoEncodeCommandList2 * This);
+        
+        DECLSPEC_XFGVIRT(IUnknown, Release)
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            ID3D12VideoEncodeCommandList2 * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, GetPrivateData)
+        HRESULT ( STDMETHODCALLTYPE *GetPrivateData )( 
+            ID3D12VideoEncodeCommandList2 * This,
+            _In_  REFGUID guid,
+            _Inout_  UINT *pDataSize,
+            _Out_writes_bytes_opt_( *pDataSize )  void *pData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, SetPrivateData)
+        HRESULT ( STDMETHODCALLTYPE *SetPrivateData )( 
+            ID3D12VideoEncodeCommandList2 * This,
+            _In_  REFGUID guid,
+            _In_  UINT DataSize,
+            _In_reads_bytes_opt_( DataSize )  const void *pData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, SetPrivateDataInterface)
+        HRESULT ( STDMETHODCALLTYPE *SetPrivateDataInterface )( 
+            ID3D12VideoEncodeCommandList2 * This,
+            _In_  REFGUID guid,
+            _In_opt_  const IUnknown *pData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, SetName)
+        HRESULT ( STDMETHODCALLTYPE *SetName )( 
+            ID3D12VideoEncodeCommandList2 * This,
+            _In_z_  LPCWSTR Name);
+        
+        DECLSPEC_XFGVIRT(ID3D12DeviceChild, GetDevice)
+        HRESULT ( STDMETHODCALLTYPE *GetDevice )( 
+            ID3D12VideoEncodeCommandList2 * This,
+            REFIID riid,
+            _COM_Outptr_opt_  void **ppvDevice);
+        
+        DECLSPEC_XFGVIRT(ID3D12CommandList, GetType)
+        D3D12_COMMAND_LIST_TYPE ( STDMETHODCALLTYPE *GetType )( 
+            ID3D12VideoEncodeCommandList2 * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoEncodeCommandList, Close)
+        HRESULT ( STDMETHODCALLTYPE *Close )( 
+            ID3D12VideoEncodeCommandList2 * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoEncodeCommandList, Reset)
+        HRESULT ( STDMETHODCALLTYPE *Reset )( 
+            ID3D12VideoEncodeCommandList2 * This,
+            _In_  ID3D12CommandAllocator *pAllocator);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoEncodeCommandList, ClearState)
+        void ( STDMETHODCALLTYPE *ClearState )( 
+            ID3D12VideoEncodeCommandList2 * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoEncodeCommandList, ResourceBarrier)
+        void ( STDMETHODCALLTYPE *ResourceBarrier )( 
+            ID3D12VideoEncodeCommandList2 * This,
+            _In_  UINT NumBarriers,
+            _In_reads_(NumBarriers)  const D3D12_RESOURCE_BARRIER *pBarriers);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoEncodeCommandList, DiscardResource)
+        void ( STDMETHODCALLTYPE *DiscardResource )( 
+            ID3D12VideoEncodeCommandList2 * This,
+            _In_  ID3D12Resource *pResource,
+            _In_opt_  const D3D12_DISCARD_REGION *pRegion);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoEncodeCommandList, BeginQuery)
+        void ( STDMETHODCALLTYPE *BeginQuery )( 
+            ID3D12VideoEncodeCommandList2 * This,
+            _In_  ID3D12QueryHeap *pQueryHeap,
+            _In_  D3D12_QUERY_TYPE Type,
+            _In_  UINT Index);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoEncodeCommandList, EndQuery)
+        void ( STDMETHODCALLTYPE *EndQuery )( 
+            ID3D12VideoEncodeCommandList2 * This,
+            _In_  ID3D12QueryHeap *pQueryHeap,
+            _In_  D3D12_QUERY_TYPE Type,
+            _In_  UINT Index);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoEncodeCommandList, ResolveQueryData)
+        void ( STDMETHODCALLTYPE *ResolveQueryData )( 
+            ID3D12VideoEncodeCommandList2 * This,
+            _In_  ID3D12QueryHeap *pQueryHeap,
+            _In_  D3D12_QUERY_TYPE Type,
+            _In_  UINT StartIndex,
+            _In_  UINT NumQueries,
+            _In_  ID3D12Resource *pDestinationBuffer,
+            _In_  UINT64 AlignedDestinationBufferOffset);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoEncodeCommandList, SetPredication)
+        void ( STDMETHODCALLTYPE *SetPredication )( 
+            ID3D12VideoEncodeCommandList2 * This,
+            _In_opt_  ID3D12Resource *pBuffer,
+            _In_  UINT64 AlignedBufferOffset,
+            _In_  D3D12_PREDICATION_OP Operation);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoEncodeCommandList, SetMarker)
+        void ( STDMETHODCALLTYPE *SetMarker )( 
+            ID3D12VideoEncodeCommandList2 * This,
+            UINT Metadata,
+            _In_reads_bytes_opt_(Size)  const void *pData,
+            UINT Size);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoEncodeCommandList, BeginEvent)
+        void ( STDMETHODCALLTYPE *BeginEvent )( 
+            ID3D12VideoEncodeCommandList2 * This,
+            UINT Metadata,
+            _In_reads_bytes_opt_(Size)  const void *pData,
+            UINT Size);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoEncodeCommandList, EndEvent)
+        void ( STDMETHODCALLTYPE *EndEvent )( 
+            ID3D12VideoEncodeCommandList2 * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoEncodeCommandList, EstimateMotion)
+        void ( STDMETHODCALLTYPE *EstimateMotion )( 
+            ID3D12VideoEncodeCommandList2 * This,
+            _In_  ID3D12VideoMotionEstimator *pMotionEstimator,
+            _In_  const D3D12_VIDEO_MOTION_ESTIMATOR_OUTPUT *pOutputArguments,
+            _In_  const D3D12_VIDEO_MOTION_ESTIMATOR_INPUT *pInputArguments);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoEncodeCommandList, ResolveMotionVectorHeap)
+        void ( STDMETHODCALLTYPE *ResolveMotionVectorHeap )( 
+            ID3D12VideoEncodeCommandList2 * This,
+            const D3D12_RESOLVE_VIDEO_MOTION_VECTOR_HEAP_OUTPUT *pOutputArguments,
+            const D3D12_RESOLVE_VIDEO_MOTION_VECTOR_HEAP_INPUT *pInputArguments);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoEncodeCommandList, WriteBufferImmediate)
+        void ( STDMETHODCALLTYPE *WriteBufferImmediate )( 
+            ID3D12VideoEncodeCommandList2 * This,
+            UINT Count,
+            _In_reads_(Count)  const D3D12_WRITEBUFFERIMMEDIATE_PARAMETER *pParams,
+            _In_reads_opt_(Count)  const D3D12_WRITEBUFFERIMMEDIATE_MODE *pModes);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoEncodeCommandList, SetProtectedResourceSession)
+        void ( STDMETHODCALLTYPE *SetProtectedResourceSession )( 
+            ID3D12VideoEncodeCommandList2 * This,
+            _In_opt_  ID3D12ProtectedResourceSession *pProtectedResourceSession);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoEncodeCommandList1, InitializeExtensionCommand)
+        void ( STDMETHODCALLTYPE *InitializeExtensionCommand )( 
+            ID3D12VideoEncodeCommandList2 * This,
+            _In_  ID3D12VideoExtensionCommand *pExtensionCommand,
+            _In_reads_bytes_(InitializationParametersSizeInBytes)  const void *pInitializationParameters,
+            SIZE_T InitializationParametersSizeInBytes);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoEncodeCommandList1, ExecuteExtensionCommand)
+        void ( STDMETHODCALLTYPE *ExecuteExtensionCommand )( 
+            ID3D12VideoEncodeCommandList2 * This,
+            _In_  ID3D12VideoExtensionCommand *pExtensionCommand,
+            _In_reads_bytes_(ExecutionParametersSizeInBytes)  const void *pExecutionParameters,
+            SIZE_T ExecutionParametersSizeInBytes);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoEncodeCommandList2, EncodeFrame)
+        void ( STDMETHODCALLTYPE *EncodeFrame )( 
+            ID3D12VideoEncodeCommandList2 * This,
+            _In_  ID3D12VideoEncoder *pEncoder,
+            _In_  ID3D12VideoEncoderHeap *pHeap,
+            _In_  const D3D12_VIDEO_ENCODER_ENCODEFRAME_INPUT_ARGUMENTS *pInputArguments,
+            _In_  const D3D12_VIDEO_ENCODER_ENCODEFRAME_OUTPUT_ARGUMENTS *pOutputArguments);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoEncodeCommandList2, ResolveEncoderOutputMetadata)
+        void ( STDMETHODCALLTYPE *ResolveEncoderOutputMetadata )( 
+            ID3D12VideoEncodeCommandList2 * This,
+            _In_  const D3D12_VIDEO_ENCODER_RESOLVE_METADATA_INPUT_ARGUMENTS *pInputArguments,
+            _In_  const D3D12_VIDEO_ENCODER_RESOLVE_METADATA_OUTPUT_ARGUMENTS *pOutputArguments);
+        
+        END_INTERFACE
+    } ID3D12VideoEncodeCommandList2Vtbl;
+
+    interface ID3D12VideoEncodeCommandList2
+    {
+        CONST_VTBL struct ID3D12VideoEncodeCommandList2Vtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define ID3D12VideoEncodeCommandList2_QueryInterface(This,riid,ppvObject)	\
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define ID3D12VideoEncodeCommandList2_AddRef(This)	\
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define ID3D12VideoEncodeCommandList2_Release(This)	\
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#define ID3D12VideoEncodeCommandList2_GetPrivateData(This,guid,pDataSize,pData)	\
+    ( (This)->lpVtbl -> GetPrivateData(This,guid,pDataSize,pData) ) 
+
+#define ID3D12VideoEncodeCommandList2_SetPrivateData(This,guid,DataSize,pData)	\
+    ( (This)->lpVtbl -> SetPrivateData(This,guid,DataSize,pData) ) 
+
+#define ID3D12VideoEncodeCommandList2_SetPrivateDataInterface(This,guid,pData)	\
+    ( (This)->lpVtbl -> SetPrivateDataInterface(This,guid,pData) ) 
+
+#define ID3D12VideoEncodeCommandList2_SetName(This,Name)	\
+    ( (This)->lpVtbl -> SetName(This,Name) ) 
+
+
+#define ID3D12VideoEncodeCommandList2_GetDevice(This,riid,ppvDevice)	\
+    ( (This)->lpVtbl -> GetDevice(This,riid,ppvDevice) ) 
+
+
+#define ID3D12VideoEncodeCommandList2_GetType(This)	\
+    ( (This)->lpVtbl -> GetType(This) ) 
+
+
+#define ID3D12VideoEncodeCommandList2_Close(This)	\
+    ( (This)->lpVtbl -> Close(This) ) 
+
+#define ID3D12VideoEncodeCommandList2_Reset(This,pAllocator)	\
+    ( (This)->lpVtbl -> Reset(This,pAllocator) ) 
+
+#define ID3D12VideoEncodeCommandList2_ClearState(This)	\
+    ( (This)->lpVtbl -> ClearState(This) ) 
+
+#define ID3D12VideoEncodeCommandList2_ResourceBarrier(This,NumBarriers,pBarriers)	\
+    ( (This)->lpVtbl -> ResourceBarrier(This,NumBarriers,pBarriers) ) 
+
+#define ID3D12VideoEncodeCommandList2_DiscardResource(This,pResource,pRegion)	\
+    ( (This)->lpVtbl -> DiscardResource(This,pResource,pRegion) ) 
+
+#define ID3D12VideoEncodeCommandList2_BeginQuery(This,pQueryHeap,Type,Index)	\
+    ( (This)->lpVtbl -> BeginQuery(This,pQueryHeap,Type,Index) ) 
+
+#define ID3D12VideoEncodeCommandList2_EndQuery(This,pQueryHeap,Type,Index)	\
+    ( (This)->lpVtbl -> EndQuery(This,pQueryHeap,Type,Index) ) 
+
+#define ID3D12VideoEncodeCommandList2_ResolveQueryData(This,pQueryHeap,Type,StartIndex,NumQueries,pDestinationBuffer,AlignedDestinationBufferOffset)	\
+    ( (This)->lpVtbl -> ResolveQueryData(This,pQueryHeap,Type,StartIndex,NumQueries,pDestinationBuffer,AlignedDestinationBufferOffset) ) 
+
+#define ID3D12VideoEncodeCommandList2_SetPredication(This,pBuffer,AlignedBufferOffset,Operation)	\
+    ( (This)->lpVtbl -> SetPredication(This,pBuffer,AlignedBufferOffset,Operation) ) 
+
+#define ID3D12VideoEncodeCommandList2_SetMarker(This,Metadata,pData,Size)	\
+    ( (This)->lpVtbl -> SetMarker(This,Metadata,pData,Size) ) 
+
+#define ID3D12VideoEncodeCommandList2_BeginEvent(This,Metadata,pData,Size)	\
+    ( (This)->lpVtbl -> BeginEvent(This,Metadata,pData,Size) ) 
+
+#define ID3D12VideoEncodeCommandList2_EndEvent(This)	\
+    ( (This)->lpVtbl -> EndEvent(This) ) 
+
+#define ID3D12VideoEncodeCommandList2_EstimateMotion(This,pMotionEstimator,pOutputArguments,pInputArguments)	\
+    ( (This)->lpVtbl -> EstimateMotion(This,pMotionEstimator,pOutputArguments,pInputArguments) ) 
+
+#define ID3D12VideoEncodeCommandList2_ResolveMotionVectorHeap(This,pOutputArguments,pInputArguments)	\
+    ( (This)->lpVtbl -> ResolveMotionVectorHeap(This,pOutputArguments,pInputArguments) ) 
+
+#define ID3D12VideoEncodeCommandList2_WriteBufferImmediate(This,Count,pParams,pModes)	\
+    ( (This)->lpVtbl -> WriteBufferImmediate(This,Count,pParams,pModes) ) 
+
+#define ID3D12VideoEncodeCommandList2_SetProtectedResourceSession(This,pProtectedResourceSession)	\
+    ( (This)->lpVtbl -> SetProtectedResourceSession(This,pProtectedResourceSession) ) 
+
+
+#define ID3D12VideoEncodeCommandList2_InitializeExtensionCommand(This,pExtensionCommand,pInitializationParameters,InitializationParametersSizeInBytes)	\
+    ( (This)->lpVtbl -> InitializeExtensionCommand(This,pExtensionCommand,pInitializationParameters,InitializationParametersSizeInBytes) ) 
+
+#define ID3D12VideoEncodeCommandList2_ExecuteExtensionCommand(This,pExtensionCommand,pExecutionParameters,ExecutionParametersSizeInBytes)	\
+    ( (This)->lpVtbl -> ExecuteExtensionCommand(This,pExtensionCommand,pExecutionParameters,ExecutionParametersSizeInBytes) ) 
+
+
+#define ID3D12VideoEncodeCommandList2_EncodeFrame(This,pEncoder,pHeap,pInputArguments,pOutputArguments)	\
+    ( (This)->lpVtbl -> EncodeFrame(This,pEncoder,pHeap,pInputArguments,pOutputArguments) ) 
+
+#define ID3D12VideoEncodeCommandList2_ResolveEncoderOutputMetadata(This,pInputArguments,pOutputArguments)	\
+    ( (This)->lpVtbl -> ResolveEncoderOutputMetadata(This,pInputArguments,pOutputArguments) ) 
+
+#endif /* COBJMACROS */
+
+
+#endif 	/* C style interface */
+
+
+
+
+#endif 	/* __ID3D12VideoEncodeCommandList2_INTERFACE_DEFINED__ */
+
+
+#ifndef __ID3D12VideoEncodeCommandList3_INTERFACE_DEFINED__
+#define __ID3D12VideoEncodeCommandList3_INTERFACE_DEFINED__
+
+/* interface ID3D12VideoEncodeCommandList3 */
+/* [unique][local][object][uuid] */ 
+
+
+EXTERN_C const IID IID_ID3D12VideoEncodeCommandList3;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("7f027b22-1515-4e85-aa0d-026486580576")
+    ID3D12VideoEncodeCommandList3 : public ID3D12VideoEncodeCommandList2
+    {
+    public:
+        virtual void STDMETHODCALLTYPE Barrier( 
+            UINT32 NumBarrierGroups,
+            _In_reads_(NumBarrierGroups)  const D3D12_BARRIER_GROUP *pBarrierGroups) = 0;
+        
+    };
+    
+    
+#else 	/* C style interface */
+
+    typedef struct ID3D12VideoEncodeCommandList3Vtbl
+    {
+        BEGIN_INTERFACE
+        
+        DECLSPEC_XFGVIRT(IUnknown, QueryInterface)
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            ID3D12VideoEncodeCommandList3 * This,
+            REFIID riid,
+            _COM_Outptr_  void **ppvObject);
+        
+        DECLSPEC_XFGVIRT(IUnknown, AddRef)
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            ID3D12VideoEncodeCommandList3 * This);
+        
+        DECLSPEC_XFGVIRT(IUnknown, Release)
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            ID3D12VideoEncodeCommandList3 * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, GetPrivateData)
+        HRESULT ( STDMETHODCALLTYPE *GetPrivateData )( 
+            ID3D12VideoEncodeCommandList3 * This,
+            _In_  REFGUID guid,
+            _Inout_  UINT *pDataSize,
+            _Out_writes_bytes_opt_( *pDataSize )  void *pData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, SetPrivateData)
+        HRESULT ( STDMETHODCALLTYPE *SetPrivateData )( 
+            ID3D12VideoEncodeCommandList3 * This,
+            _In_  REFGUID guid,
+            _In_  UINT DataSize,
+            _In_reads_bytes_opt_( DataSize )  const void *pData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, SetPrivateDataInterface)
+        HRESULT ( STDMETHODCALLTYPE *SetPrivateDataInterface )( 
+            ID3D12VideoEncodeCommandList3 * This,
+            _In_  REFGUID guid,
+            _In_opt_  const IUnknown *pData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, SetName)
+        HRESULT ( STDMETHODCALLTYPE *SetName )( 
+            ID3D12VideoEncodeCommandList3 * This,
+            _In_z_  LPCWSTR Name);
+        
+        DECLSPEC_XFGVIRT(ID3D12DeviceChild, GetDevice)
+        HRESULT ( STDMETHODCALLTYPE *GetDevice )( 
+            ID3D12VideoEncodeCommandList3 * This,
+            REFIID riid,
+            _COM_Outptr_opt_  void **ppvDevice);
+        
+        DECLSPEC_XFGVIRT(ID3D12CommandList, GetType)
+        D3D12_COMMAND_LIST_TYPE ( STDMETHODCALLTYPE *GetType )( 
+            ID3D12VideoEncodeCommandList3 * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoEncodeCommandList, Close)
+        HRESULT ( STDMETHODCALLTYPE *Close )( 
+            ID3D12VideoEncodeCommandList3 * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoEncodeCommandList, Reset)
+        HRESULT ( STDMETHODCALLTYPE *Reset )( 
+            ID3D12VideoEncodeCommandList3 * This,
+            _In_  ID3D12CommandAllocator *pAllocator);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoEncodeCommandList, ClearState)
+        void ( STDMETHODCALLTYPE *ClearState )( 
+            ID3D12VideoEncodeCommandList3 * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoEncodeCommandList, ResourceBarrier)
+        void ( STDMETHODCALLTYPE *ResourceBarrier )( 
+            ID3D12VideoEncodeCommandList3 * This,
+            _In_  UINT NumBarriers,
+            _In_reads_(NumBarriers)  const D3D12_RESOURCE_BARRIER *pBarriers);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoEncodeCommandList, DiscardResource)
+        void ( STDMETHODCALLTYPE *DiscardResource )( 
+            ID3D12VideoEncodeCommandList3 * This,
+            _In_  ID3D12Resource *pResource,
+            _In_opt_  const D3D12_DISCARD_REGION *pRegion);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoEncodeCommandList, BeginQuery)
+        void ( STDMETHODCALLTYPE *BeginQuery )( 
+            ID3D12VideoEncodeCommandList3 * This,
+            _In_  ID3D12QueryHeap *pQueryHeap,
+            _In_  D3D12_QUERY_TYPE Type,
+            _In_  UINT Index);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoEncodeCommandList, EndQuery)
+        void ( STDMETHODCALLTYPE *EndQuery )( 
+            ID3D12VideoEncodeCommandList3 * This,
+            _In_  ID3D12QueryHeap *pQueryHeap,
+            _In_  D3D12_QUERY_TYPE Type,
+            _In_  UINT Index);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoEncodeCommandList, ResolveQueryData)
+        void ( STDMETHODCALLTYPE *ResolveQueryData )( 
+            ID3D12VideoEncodeCommandList3 * This,
+            _In_  ID3D12QueryHeap *pQueryHeap,
+            _In_  D3D12_QUERY_TYPE Type,
+            _In_  UINT StartIndex,
+            _In_  UINT NumQueries,
+            _In_  ID3D12Resource *pDestinationBuffer,
+            _In_  UINT64 AlignedDestinationBufferOffset);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoEncodeCommandList, SetPredication)
+        void ( STDMETHODCALLTYPE *SetPredication )( 
+            ID3D12VideoEncodeCommandList3 * This,
+            _In_opt_  ID3D12Resource *pBuffer,
+            _In_  UINT64 AlignedBufferOffset,
+            _In_  D3D12_PREDICATION_OP Operation);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoEncodeCommandList, SetMarker)
+        void ( STDMETHODCALLTYPE *SetMarker )( 
+            ID3D12VideoEncodeCommandList3 * This,
+            UINT Metadata,
+            _In_reads_bytes_opt_(Size)  const void *pData,
+            UINT Size);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoEncodeCommandList, BeginEvent)
+        void ( STDMETHODCALLTYPE *BeginEvent )( 
+            ID3D12VideoEncodeCommandList3 * This,
+            UINT Metadata,
+            _In_reads_bytes_opt_(Size)  const void *pData,
+            UINT Size);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoEncodeCommandList, EndEvent)
+        void ( STDMETHODCALLTYPE *EndEvent )( 
+            ID3D12VideoEncodeCommandList3 * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoEncodeCommandList, EstimateMotion)
+        void ( STDMETHODCALLTYPE *EstimateMotion )( 
+            ID3D12VideoEncodeCommandList3 * This,
+            _In_  ID3D12VideoMotionEstimator *pMotionEstimator,
+            _In_  const D3D12_VIDEO_MOTION_ESTIMATOR_OUTPUT *pOutputArguments,
+            _In_  const D3D12_VIDEO_MOTION_ESTIMATOR_INPUT *pInputArguments);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoEncodeCommandList, ResolveMotionVectorHeap)
+        void ( STDMETHODCALLTYPE *ResolveMotionVectorHeap )( 
+            ID3D12VideoEncodeCommandList3 * This,
+            const D3D12_RESOLVE_VIDEO_MOTION_VECTOR_HEAP_OUTPUT *pOutputArguments,
+            const D3D12_RESOLVE_VIDEO_MOTION_VECTOR_HEAP_INPUT *pInputArguments);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoEncodeCommandList, WriteBufferImmediate)
+        void ( STDMETHODCALLTYPE *WriteBufferImmediate )( 
+            ID3D12VideoEncodeCommandList3 * This,
+            UINT Count,
+            _In_reads_(Count)  const D3D12_WRITEBUFFERIMMEDIATE_PARAMETER *pParams,
+            _In_reads_opt_(Count)  const D3D12_WRITEBUFFERIMMEDIATE_MODE *pModes);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoEncodeCommandList, SetProtectedResourceSession)
+        void ( STDMETHODCALLTYPE *SetProtectedResourceSession )( 
+            ID3D12VideoEncodeCommandList3 * This,
+            _In_opt_  ID3D12ProtectedResourceSession *pProtectedResourceSession);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoEncodeCommandList1, InitializeExtensionCommand)
+        void ( STDMETHODCALLTYPE *InitializeExtensionCommand )( 
+            ID3D12VideoEncodeCommandList3 * This,
+            _In_  ID3D12VideoExtensionCommand *pExtensionCommand,
+            _In_reads_bytes_(InitializationParametersSizeInBytes)  const void *pInitializationParameters,
+            SIZE_T InitializationParametersSizeInBytes);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoEncodeCommandList1, ExecuteExtensionCommand)
+        void ( STDMETHODCALLTYPE *ExecuteExtensionCommand )( 
+            ID3D12VideoEncodeCommandList3 * This,
+            _In_  ID3D12VideoExtensionCommand *pExtensionCommand,
+            _In_reads_bytes_(ExecutionParametersSizeInBytes)  const void *pExecutionParameters,
+            SIZE_T ExecutionParametersSizeInBytes);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoEncodeCommandList2, EncodeFrame)
+        void ( STDMETHODCALLTYPE *EncodeFrame )( 
+            ID3D12VideoEncodeCommandList3 * This,
+            _In_  ID3D12VideoEncoder *pEncoder,
+            _In_  ID3D12VideoEncoderHeap *pHeap,
+            _In_  const D3D12_VIDEO_ENCODER_ENCODEFRAME_INPUT_ARGUMENTS *pInputArguments,
+            _In_  const D3D12_VIDEO_ENCODER_ENCODEFRAME_OUTPUT_ARGUMENTS *pOutputArguments);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoEncodeCommandList2, ResolveEncoderOutputMetadata)
+        void ( STDMETHODCALLTYPE *ResolveEncoderOutputMetadata )( 
+            ID3D12VideoEncodeCommandList3 * This,
+            _In_  const D3D12_VIDEO_ENCODER_RESOLVE_METADATA_INPUT_ARGUMENTS *pInputArguments,
+            _In_  const D3D12_VIDEO_ENCODER_RESOLVE_METADATA_OUTPUT_ARGUMENTS *pOutputArguments);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoEncodeCommandList3, Barrier)
+        void ( STDMETHODCALLTYPE *Barrier )( 
+            ID3D12VideoEncodeCommandList3 * This,
+            UINT32 NumBarrierGroups,
+            _In_reads_(NumBarrierGroups)  const D3D12_BARRIER_GROUP *pBarrierGroups);
+        
+        END_INTERFACE
+    } ID3D12VideoEncodeCommandList3Vtbl;
+
+    interface ID3D12VideoEncodeCommandList3
+    {
+        CONST_VTBL struct ID3D12VideoEncodeCommandList3Vtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define ID3D12VideoEncodeCommandList3_QueryInterface(This,riid,ppvObject)	\
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define ID3D12VideoEncodeCommandList3_AddRef(This)	\
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define ID3D12VideoEncodeCommandList3_Release(This)	\
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#define ID3D12VideoEncodeCommandList3_GetPrivateData(This,guid,pDataSize,pData)	\
+    ( (This)->lpVtbl -> GetPrivateData(This,guid,pDataSize,pData) ) 
+
+#define ID3D12VideoEncodeCommandList3_SetPrivateData(This,guid,DataSize,pData)	\
+    ( (This)->lpVtbl -> SetPrivateData(This,guid,DataSize,pData) ) 
+
+#define ID3D12VideoEncodeCommandList3_SetPrivateDataInterface(This,guid,pData)	\
+    ( (This)->lpVtbl -> SetPrivateDataInterface(This,guid,pData) ) 
+
+#define ID3D12VideoEncodeCommandList3_SetName(This,Name)	\
+    ( (This)->lpVtbl -> SetName(This,Name) ) 
+
+
+#define ID3D12VideoEncodeCommandList3_GetDevice(This,riid,ppvDevice)	\
+    ( (This)->lpVtbl -> GetDevice(This,riid,ppvDevice) ) 
+
+
+#define ID3D12VideoEncodeCommandList3_GetType(This)	\
+    ( (This)->lpVtbl -> GetType(This) ) 
+
+
+#define ID3D12VideoEncodeCommandList3_Close(This)	\
+    ( (This)->lpVtbl -> Close(This) ) 
+
+#define ID3D12VideoEncodeCommandList3_Reset(This,pAllocator)	\
+    ( (This)->lpVtbl -> Reset(This,pAllocator) ) 
+
+#define ID3D12VideoEncodeCommandList3_ClearState(This)	\
+    ( (This)->lpVtbl -> ClearState(This) ) 
+
+#define ID3D12VideoEncodeCommandList3_ResourceBarrier(This,NumBarriers,pBarriers)	\
+    ( (This)->lpVtbl -> ResourceBarrier(This,NumBarriers,pBarriers) ) 
+
+#define ID3D12VideoEncodeCommandList3_DiscardResource(This,pResource,pRegion)	\
+    ( (This)->lpVtbl -> DiscardResource(This,pResource,pRegion) ) 
+
+#define ID3D12VideoEncodeCommandList3_BeginQuery(This,pQueryHeap,Type,Index)	\
+    ( (This)->lpVtbl -> BeginQuery(This,pQueryHeap,Type,Index) ) 
+
+#define ID3D12VideoEncodeCommandList3_EndQuery(This,pQueryHeap,Type,Index)	\
+    ( (This)->lpVtbl -> EndQuery(This,pQueryHeap,Type,Index) ) 
+
+#define ID3D12VideoEncodeCommandList3_ResolveQueryData(This,pQueryHeap,Type,StartIndex,NumQueries,pDestinationBuffer,AlignedDestinationBufferOffset)	\
+    ( (This)->lpVtbl -> ResolveQueryData(This,pQueryHeap,Type,StartIndex,NumQueries,pDestinationBuffer,AlignedDestinationBufferOffset) ) 
+
+#define ID3D12VideoEncodeCommandList3_SetPredication(This,pBuffer,AlignedBufferOffset,Operation)	\
+    ( (This)->lpVtbl -> SetPredication(This,pBuffer,AlignedBufferOffset,Operation) ) 
+
+#define ID3D12VideoEncodeCommandList3_SetMarker(This,Metadata,pData,Size)	\
+    ( (This)->lpVtbl -> SetMarker(This,Metadata,pData,Size) ) 
+
+#define ID3D12VideoEncodeCommandList3_BeginEvent(This,Metadata,pData,Size)	\
+    ( (This)->lpVtbl -> BeginEvent(This,Metadata,pData,Size) ) 
+
+#define ID3D12VideoEncodeCommandList3_EndEvent(This)	\
+    ( (This)->lpVtbl -> EndEvent(This) ) 
+
+#define ID3D12VideoEncodeCommandList3_EstimateMotion(This,pMotionEstimator,pOutputArguments,pInputArguments)	\
+    ( (This)->lpVtbl -> EstimateMotion(This,pMotionEstimator,pOutputArguments,pInputArguments) ) 
+
+#define ID3D12VideoEncodeCommandList3_ResolveMotionVectorHeap(This,pOutputArguments,pInputArguments)	\
+    ( (This)->lpVtbl -> ResolveMotionVectorHeap(This,pOutputArguments,pInputArguments) ) 
+
+#define ID3D12VideoEncodeCommandList3_WriteBufferImmediate(This,Count,pParams,pModes)	\
+    ( (This)->lpVtbl -> WriteBufferImmediate(This,Count,pParams,pModes) ) 
+
+#define ID3D12VideoEncodeCommandList3_SetProtectedResourceSession(This,pProtectedResourceSession)	\
+    ( (This)->lpVtbl -> SetProtectedResourceSession(This,pProtectedResourceSession) ) 
+
+
+#define ID3D12VideoEncodeCommandList3_InitializeExtensionCommand(This,pExtensionCommand,pInitializationParameters,InitializationParametersSizeInBytes)	\
+    ( (This)->lpVtbl -> InitializeExtensionCommand(This,pExtensionCommand,pInitializationParameters,InitializationParametersSizeInBytes) ) 
+
+#define ID3D12VideoEncodeCommandList3_ExecuteExtensionCommand(This,pExtensionCommand,pExecutionParameters,ExecutionParametersSizeInBytes)	\
+    ( (This)->lpVtbl -> ExecuteExtensionCommand(This,pExtensionCommand,pExecutionParameters,ExecutionParametersSizeInBytes) ) 
+
+
+#define ID3D12VideoEncodeCommandList3_EncodeFrame(This,pEncoder,pHeap,pInputArguments,pOutputArguments)	\
+    ( (This)->lpVtbl -> EncodeFrame(This,pEncoder,pHeap,pInputArguments,pOutputArguments) ) 
+
+#define ID3D12VideoEncodeCommandList3_ResolveEncoderOutputMetadata(This,pInputArguments,pOutputArguments)	\
+    ( (This)->lpVtbl -> ResolveEncoderOutputMetadata(This,pInputArguments,pOutputArguments) ) 
+
+
+#define ID3D12VideoEncodeCommandList3_Barrier(This,NumBarrierGroups,pBarrierGroups)	\
+    ( (This)->lpVtbl -> Barrier(This,NumBarrierGroups,pBarrierGroups) ) 
+
+#endif /* COBJMACROS */
+
+
+#endif 	/* C style interface */
+
+
+
+
+#endif 	/* __ID3D12VideoEncodeCommandList3_INTERFACE_DEFINED__ */
+
+
+/* interface __MIDL_itf_d3d12video_0000_0027 */
+/* [local] */ 
+
+#endif /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP | WINAPI_PARTITION_GAMES) */
+#pragma endregion
+DEFINE_GUID(IID_ID3D12VideoDecoderHeap,0x0946B7C9,0xEBF6,0x4047,0xBB,0x73,0x86,0x83,0xE2,0x7D,0xBB,0x1F);
+DEFINE_GUID(IID_ID3D12VideoDevice,0x1F052807,0x0B46,0x4ACC,0x8A,0x89,0x36,0x4F,0x79,0x37,0x18,0xA4);
+DEFINE_GUID(IID_ID3D12VideoDecoder,0xC59B6BDC,0x7720,0x4074,0xA1,0x36,0x17,0xA1,0x56,0x03,0x74,0x70);
+DEFINE_GUID(IID_ID3D12VideoProcessor,0x304FDB32,0xBEDE,0x410A,0x85,0x45,0x94,0x3A,0xC6,0xA4,0x61,0x38);
+DEFINE_GUID(IID_ID3D12VideoDecodeCommandList,0x3B60536E,0xAD29,0x4E64,0xA2,0x69,0xF8,0x53,0x83,0x7E,0x5E,0x53);
+DEFINE_GUID(IID_ID3D12VideoProcessCommandList,0xAEB2543A,0x167F,0x4682,0xAC,0xC8,0xD1,0x59,0xED,0x4A,0x62,0x09);
+DEFINE_GUID(IID_ID3D12VideoDecodeCommandList1,0xD52F011B,0xB56E,0x453C,0xA0,0x5A,0xA7,0xF3,0x11,0xC8,0xF4,0x72);
+DEFINE_GUID(IID_ID3D12VideoProcessCommandList1,0x542C5C4D,0x7596,0x434F,0x8C,0x93,0x4E,0xFA,0x67,0x66,0xF2,0x67);
+DEFINE_GUID(IID_ID3D12VideoMotionEstimator,0x33FDAE0E,0x098B,0x428F,0x87,0xBB,0x34,0xB6,0x95,0xDE,0x08,0xF8);
+DEFINE_GUID(IID_ID3D12VideoMotionVectorHeap,0x5BE17987,0x743A,0x4061,0x83,0x4B,0x23,0xD2,0x2D,0xAE,0xA5,0x05);
+DEFINE_GUID(IID_ID3D12VideoDevice1,0x981611AD,0xA144,0x4C83,0x98,0x90,0xF3,0x0E,0x26,0xD6,0x58,0xAB);
+DEFINE_GUID(IID_ID3D12VideoEncodeCommandList,0x8455293A,0x0CBD,0x4831,0x9B,0x39,0xFB,0xDB,0xAB,0x72,0x47,0x23);
+DEFINE_GUID(IID_ID3D12VideoDecoder1,0x79A2E5FB,0xCCD2,0x469A,0x9F,0xDE,0x19,0x5D,0x10,0x95,0x1F,0x7E);
+DEFINE_GUID(IID_ID3D12VideoDecoderHeap1,0xDA1D98C5,0x539F,0x41B2,0xBF,0x6B,0x11,0x98,0xA0,0x3B,0x6D,0x26);
+DEFINE_GUID(IID_ID3D12VideoProcessor1,0xF3CFE615,0x553F,0x425C,0x86,0xD8,0xEE,0x8C,0x1B,0x1F,0xB0,0x1C);
+DEFINE_GUID(IID_ID3D12VideoExtensionCommand,0x554E41E8,0xAE8E,0x4A8C,0xB7,0xD2,0x5B,0x4F,0x27,0x4A,0x30,0xE4);
+DEFINE_GUID(IID_ID3D12VideoDevice2,0xF019AC49,0xF838,0x4A95,0x9B,0x17,0x57,0x94,0x37,0xC8,0xF5,0x13);
+DEFINE_GUID(IID_ID3D12VideoDecodeCommandList2,0x6e120880,0xc114,0x4153,0x80,0x36,0xd2,0x47,0x05,0x1e,0x17,0x29);
+DEFINE_GUID(IID_ID3D12VideoDecodeCommandList3,0x2aee8c37,0x9562,0x42da,0x8a,0xbf,0x61,0xef,0xeb,0x2e,0x45,0x13);
+DEFINE_GUID(IID_ID3D12VideoProcessCommandList2,0xdb525ae4,0x6ad6,0x473c,0xba,0xa7,0x59,0xb2,0xe3,0x70,0x82,0xe4);
+DEFINE_GUID(IID_ID3D12VideoProcessCommandList3,0x1a0a4ca4,0x9f08,0x40ce,0x95,0x58,0xb4,0x11,0xfd,0x26,0x66,0xff);
+DEFINE_GUID(IID_ID3D12VideoEncodeCommandList1,0x94971eca,0x2bdb,0x4769,0x88,0xcf,0x36,0x75,0xea,0x75,0x7e,0xbc);
+DEFINE_GUID(IID_ID3D12VideoEncoder,0x2E0D212D,0x8DF9,0x44A6,0xA7,0x70,0xBB,0x28,0x9B,0x18,0x27,0x37);
+DEFINE_GUID(IID_ID3D12VideoEncoderHeap,0x22B35D96,0x876A,0x44C0,0xB2,0x5E,0xFB,0x8C,0x9C,0x7F,0x1C,0x4A);
+DEFINE_GUID(IID_ID3D12VideoDevice3,0x4243ADB4,0x3A32,0x4666,0x97,0x3C,0x0C,0xCC,0x56,0x25,0xDC,0x44);
+DEFINE_GUID(IID_ID3D12VideoEncodeCommandList2,0x895491e2,0xe701,0x46a9,0x9a,0x1f,0x8d,0x34,0x80,0xed,0x86,0x7a);
+DEFINE_GUID(IID_ID3D12VideoEncodeCommandList3,0x7f027b22,0x1515,0x4e85,0xaa,0x0d,0x02,0x64,0x86,0x58,0x05,0x76);
+
+
+extern RPC_IF_HANDLE __MIDL_itf_d3d12video_0000_0027_v0_0_c_ifspec;
+extern RPC_IF_HANDLE __MIDL_itf_d3d12video_0000_0027_v0_0_s_ifspec;
+
+/* Additional Prototypes for ALL interfaces */
+
+/* end of Additional Prototypes */
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+
+
diff --git a/thirdparty/directx_headers/d3dcommon.h b/thirdparty/directx_headers/d3dcommon.h
new file mode 100644
index 0000000000..33e7762374
--- /dev/null
+++ b/thirdparty/directx_headers/d3dcommon.h
@@ -0,0 +1,1116 @@
+/*-------------------------------------------------------------------------------------
+ *
+ * Copyright (c) Microsoft Corporation
+ * Licensed under the MIT license
+ *
+ *-------------------------------------------------------------------------------------*/
+
+
+/* this ALWAYS GENERATED file contains the definitions for the interfaces */
+
+
+ /* File created by MIDL compiler version 8.01.0628 */
+/* @@MIDL_FILE_HEADING(  ) */
+
+
+
+/* verify that the <rpcndr.h> version is high enough to compile this file*/
+#ifndef __REQUIRED_RPCNDR_H_VERSION__
+#define __REQUIRED_RPCNDR_H_VERSION__ 500
+#endif
+
+/* verify that the <rpcsal.h> version is high enough to compile this file*/
+#ifndef __REQUIRED_RPCSAL_H_VERSION__
+#define __REQUIRED_RPCSAL_H_VERSION__ 100
+#endif
+
+#include "rpc.h"
+#include "rpcndr.h"
+
+#ifndef __RPCNDR_H_VERSION__
+#error this stub requires an updated version of <rpcndr.h>
+#endif /* __RPCNDR_H_VERSION__ */
+
+#ifndef COM_NO_WINDOWS_H
+#include "windows.h"
+#include "ole2.h"
+#endif /*COM_NO_WINDOWS_H*/
+
+#ifndef __d3dcommon_h__
+#define __d3dcommon_h__
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+#pragma once
+#endif
+
+#ifndef DECLSPEC_XFGVIRT
+#if defined(_CONTROL_FLOW_GUARD_XFG)
+#define DECLSPEC_XFGVIRT(base, func) __declspec(xfg_virtual(base, func))
+#else
+#define DECLSPEC_XFGVIRT(base, func)
+#endif
+#endif
+
+/* Forward Declarations */ 
+
+#ifndef __ID3D10Blob_FWD_DEFINED__
+#define __ID3D10Blob_FWD_DEFINED__
+typedef interface ID3D10Blob ID3D10Blob;
+
+#endif 	/* __ID3D10Blob_FWD_DEFINED__ */
+
+
+#ifndef __ID3DDestructionNotifier_FWD_DEFINED__
+#define __ID3DDestructionNotifier_FWD_DEFINED__
+typedef interface ID3DDestructionNotifier ID3DDestructionNotifier;
+
+#endif 	/* __ID3DDestructionNotifier_FWD_DEFINED__ */
+
+
+/* header files for imported files */
+#include "oaidl.h"
+#include "ocidl.h"
+
+#ifdef __cplusplus
+extern "C"{
+#endif 
+
+
+/* interface __MIDL_itf_d3dcommon_0000_0000 */
+/* [local] */ 
+
+typedef 
+enum D3D_DRIVER_TYPE
+    {
+        D3D_DRIVER_TYPE_UNKNOWN	= 0,
+        D3D_DRIVER_TYPE_HARDWARE	= ( D3D_DRIVER_TYPE_UNKNOWN + 1 ) ,
+        D3D_DRIVER_TYPE_REFERENCE	= ( D3D_DRIVER_TYPE_HARDWARE + 1 ) ,
+        D3D_DRIVER_TYPE_NULL	= ( D3D_DRIVER_TYPE_REFERENCE + 1 ) ,
+        D3D_DRIVER_TYPE_SOFTWARE	= ( D3D_DRIVER_TYPE_NULL + 1 ) ,
+        D3D_DRIVER_TYPE_WARP	= ( D3D_DRIVER_TYPE_SOFTWARE + 1 ) 
+    } 	D3D_DRIVER_TYPE;
+
+typedef 
+enum D3D_FEATURE_LEVEL
+    {
+        D3D_FEATURE_LEVEL_1_0_CORE	= 0x1000,
+        D3D_FEATURE_LEVEL_9_1	= 0x9100,
+        D3D_FEATURE_LEVEL_9_2	= 0x9200,
+        D3D_FEATURE_LEVEL_9_3	= 0x9300,
+        D3D_FEATURE_LEVEL_10_0	= 0xa000,
+        D3D_FEATURE_LEVEL_10_1	= 0xa100,
+        D3D_FEATURE_LEVEL_11_0	= 0xb000,
+        D3D_FEATURE_LEVEL_11_1	= 0xb100,
+        D3D_FEATURE_LEVEL_12_0	= 0xc000,
+        D3D_FEATURE_LEVEL_12_1	= 0xc100,
+        D3D_FEATURE_LEVEL_12_2	= 0xc200
+    } 	D3D_FEATURE_LEVEL;
+
+#define D3D_FL9_1_REQ_TEXTURE1D_U_DIMENSION          2048
+#define D3D_FL9_3_REQ_TEXTURE1D_U_DIMENSION          4096
+#define D3D_FL9_1_REQ_TEXTURE2D_U_OR_V_DIMENSION     2048
+#define D3D_FL9_3_REQ_TEXTURE2D_U_OR_V_DIMENSION     4096
+#define D3D_FL9_1_REQ_TEXTURECUBE_DIMENSION          512
+#define D3D_FL9_3_REQ_TEXTURECUBE_DIMENSION          4096
+#define D3D_FL9_1_REQ_TEXTURE3D_U_V_OR_W_DIMENSION   256
+#define D3D_FL9_1_DEFAULT_MAX_ANISOTROPY             2
+#define D3D_FL9_1_IA_PRIMITIVE_MAX_COUNT             65535
+#define D3D_FL9_2_IA_PRIMITIVE_MAX_COUNT             1048575
+#define D3D_FL9_1_SIMULTANEOUS_RENDER_TARGET_COUNT   1
+#define D3D_FL9_3_SIMULTANEOUS_RENDER_TARGET_COUNT   4
+#define D3D_FL9_1_MAX_TEXTURE_REPEAT                 128
+#define D3D_FL9_2_MAX_TEXTURE_REPEAT                 2048
+#define D3D_FL9_3_MAX_TEXTURE_REPEAT                 8192
+typedef 
+enum D3D_PRIMITIVE_TOPOLOGY
+    {
+        D3D_PRIMITIVE_TOPOLOGY_UNDEFINED	= 0,
+        D3D_PRIMITIVE_TOPOLOGY_POINTLIST	= 1,
+        D3D_PRIMITIVE_TOPOLOGY_LINELIST	= 2,
+        D3D_PRIMITIVE_TOPOLOGY_LINESTRIP	= 3,
+        D3D_PRIMITIVE_TOPOLOGY_TRIANGLELIST	= 4,
+        D3D_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP	= 5,
+        D3D_PRIMITIVE_TOPOLOGY_TRIANGLEFAN	= 6,
+        D3D_PRIMITIVE_TOPOLOGY_LINELIST_ADJ	= 10,
+        D3D_PRIMITIVE_TOPOLOGY_LINESTRIP_ADJ	= 11,
+        D3D_PRIMITIVE_TOPOLOGY_TRIANGLELIST_ADJ	= 12,
+        D3D_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP_ADJ	= 13,
+        D3D_PRIMITIVE_TOPOLOGY_1_CONTROL_POINT_PATCHLIST	= 33,
+        D3D_PRIMITIVE_TOPOLOGY_2_CONTROL_POINT_PATCHLIST	= 34,
+        D3D_PRIMITIVE_TOPOLOGY_3_CONTROL_POINT_PATCHLIST	= 35,
+        D3D_PRIMITIVE_TOPOLOGY_4_CONTROL_POINT_PATCHLIST	= 36,
+        D3D_PRIMITIVE_TOPOLOGY_5_CONTROL_POINT_PATCHLIST	= 37,
+        D3D_PRIMITIVE_TOPOLOGY_6_CONTROL_POINT_PATCHLIST	= 38,
+        D3D_PRIMITIVE_TOPOLOGY_7_CONTROL_POINT_PATCHLIST	= 39,
+        D3D_PRIMITIVE_TOPOLOGY_8_CONTROL_POINT_PATCHLIST	= 40,
+        D3D_PRIMITIVE_TOPOLOGY_9_CONTROL_POINT_PATCHLIST	= 41,
+        D3D_PRIMITIVE_TOPOLOGY_10_CONTROL_POINT_PATCHLIST	= 42,
+        D3D_PRIMITIVE_TOPOLOGY_11_CONTROL_POINT_PATCHLIST	= 43,
+        D3D_PRIMITIVE_TOPOLOGY_12_CONTROL_POINT_PATCHLIST	= 44,
+        D3D_PRIMITIVE_TOPOLOGY_13_CONTROL_POINT_PATCHLIST	= 45,
+        D3D_PRIMITIVE_TOPOLOGY_14_CONTROL_POINT_PATCHLIST	= 46,
+        D3D_PRIMITIVE_TOPOLOGY_15_CONTROL_POINT_PATCHLIST	= 47,
+        D3D_PRIMITIVE_TOPOLOGY_16_CONTROL_POINT_PATCHLIST	= 48,
+        D3D_PRIMITIVE_TOPOLOGY_17_CONTROL_POINT_PATCHLIST	= 49,
+        D3D_PRIMITIVE_TOPOLOGY_18_CONTROL_POINT_PATCHLIST	= 50,
+        D3D_PRIMITIVE_TOPOLOGY_19_CONTROL_POINT_PATCHLIST	= 51,
+        D3D_PRIMITIVE_TOPOLOGY_20_CONTROL_POINT_PATCHLIST	= 52,
+        D3D_PRIMITIVE_TOPOLOGY_21_CONTROL_POINT_PATCHLIST	= 53,
+        D3D_PRIMITIVE_TOPOLOGY_22_CONTROL_POINT_PATCHLIST	= 54,
+        D3D_PRIMITIVE_TOPOLOGY_23_CONTROL_POINT_PATCHLIST	= 55,
+        D3D_PRIMITIVE_TOPOLOGY_24_CONTROL_POINT_PATCHLIST	= 56,
+        D3D_PRIMITIVE_TOPOLOGY_25_CONTROL_POINT_PATCHLIST	= 57,
+        D3D_PRIMITIVE_TOPOLOGY_26_CONTROL_POINT_PATCHLIST	= 58,
+        D3D_PRIMITIVE_TOPOLOGY_27_CONTROL_POINT_PATCHLIST	= 59,
+        D3D_PRIMITIVE_TOPOLOGY_28_CONTROL_POINT_PATCHLIST	= 60,
+        D3D_PRIMITIVE_TOPOLOGY_29_CONTROL_POINT_PATCHLIST	= 61,
+        D3D_PRIMITIVE_TOPOLOGY_30_CONTROL_POINT_PATCHLIST	= 62,
+        D3D_PRIMITIVE_TOPOLOGY_31_CONTROL_POINT_PATCHLIST	= 63,
+        D3D_PRIMITIVE_TOPOLOGY_32_CONTROL_POINT_PATCHLIST	= 64,
+        D3D10_PRIMITIVE_TOPOLOGY_UNDEFINED	= D3D_PRIMITIVE_TOPOLOGY_UNDEFINED,
+        D3D10_PRIMITIVE_TOPOLOGY_POINTLIST	= D3D_PRIMITIVE_TOPOLOGY_POINTLIST,
+        D3D10_PRIMITIVE_TOPOLOGY_LINELIST	= D3D_PRIMITIVE_TOPOLOGY_LINELIST,
+        D3D10_PRIMITIVE_TOPOLOGY_LINESTRIP	= D3D_PRIMITIVE_TOPOLOGY_LINESTRIP,
+        D3D10_PRIMITIVE_TOPOLOGY_TRIANGLELIST	= D3D_PRIMITIVE_TOPOLOGY_TRIANGLELIST,
+        D3D10_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP	= D3D_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP,
+        D3D10_PRIMITIVE_TOPOLOGY_LINELIST_ADJ	= D3D_PRIMITIVE_TOPOLOGY_LINELIST_ADJ,
+        D3D10_PRIMITIVE_TOPOLOGY_LINESTRIP_ADJ	= D3D_PRIMITIVE_TOPOLOGY_LINESTRIP_ADJ,
+        D3D10_PRIMITIVE_TOPOLOGY_TRIANGLELIST_ADJ	= D3D_PRIMITIVE_TOPOLOGY_TRIANGLELIST_ADJ,
+        D3D10_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP_ADJ	= D3D_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP_ADJ,
+        D3D11_PRIMITIVE_TOPOLOGY_UNDEFINED	= D3D_PRIMITIVE_TOPOLOGY_UNDEFINED,
+        D3D11_PRIMITIVE_TOPOLOGY_POINTLIST	= D3D_PRIMITIVE_TOPOLOGY_POINTLIST,
+        D3D11_PRIMITIVE_TOPOLOGY_LINELIST	= D3D_PRIMITIVE_TOPOLOGY_LINELIST,
+        D3D11_PRIMITIVE_TOPOLOGY_LINESTRIP	= D3D_PRIMITIVE_TOPOLOGY_LINESTRIP,
+        D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST	= D3D_PRIMITIVE_TOPOLOGY_TRIANGLELIST,
+        D3D11_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP	= D3D_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP,
+        D3D11_PRIMITIVE_TOPOLOGY_LINELIST_ADJ	= D3D_PRIMITIVE_TOPOLOGY_LINELIST_ADJ,
+        D3D11_PRIMITIVE_TOPOLOGY_LINESTRIP_ADJ	= D3D_PRIMITIVE_TOPOLOGY_LINESTRIP_ADJ,
+        D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST_ADJ	= D3D_PRIMITIVE_TOPOLOGY_TRIANGLELIST_ADJ,
+        D3D11_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP_ADJ	= D3D_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP_ADJ,
+        D3D11_PRIMITIVE_TOPOLOGY_1_CONTROL_POINT_PATCHLIST	= D3D_PRIMITIVE_TOPOLOGY_1_CONTROL_POINT_PATCHLIST,
+        D3D11_PRIMITIVE_TOPOLOGY_2_CONTROL_POINT_PATCHLIST	= D3D_PRIMITIVE_TOPOLOGY_2_CONTROL_POINT_PATCHLIST,
+        D3D11_PRIMITIVE_TOPOLOGY_3_CONTROL_POINT_PATCHLIST	= D3D_PRIMITIVE_TOPOLOGY_3_CONTROL_POINT_PATCHLIST,
+        D3D11_PRIMITIVE_TOPOLOGY_4_CONTROL_POINT_PATCHLIST	= D3D_PRIMITIVE_TOPOLOGY_4_CONTROL_POINT_PATCHLIST,
+        D3D11_PRIMITIVE_TOPOLOGY_5_CONTROL_POINT_PATCHLIST	= D3D_PRIMITIVE_TOPOLOGY_5_CONTROL_POINT_PATCHLIST,
+        D3D11_PRIMITIVE_TOPOLOGY_6_CONTROL_POINT_PATCHLIST	= D3D_PRIMITIVE_TOPOLOGY_6_CONTROL_POINT_PATCHLIST,
+        D3D11_PRIMITIVE_TOPOLOGY_7_CONTROL_POINT_PATCHLIST	= D3D_PRIMITIVE_TOPOLOGY_7_CONTROL_POINT_PATCHLIST,
+        D3D11_PRIMITIVE_TOPOLOGY_8_CONTROL_POINT_PATCHLIST	= D3D_PRIMITIVE_TOPOLOGY_8_CONTROL_POINT_PATCHLIST,
+        D3D11_PRIMITIVE_TOPOLOGY_9_CONTROL_POINT_PATCHLIST	= D3D_PRIMITIVE_TOPOLOGY_9_CONTROL_POINT_PATCHLIST,
+        D3D11_PRIMITIVE_TOPOLOGY_10_CONTROL_POINT_PATCHLIST	= D3D_PRIMITIVE_TOPOLOGY_10_CONTROL_POINT_PATCHLIST,
+        D3D11_PRIMITIVE_TOPOLOGY_11_CONTROL_POINT_PATCHLIST	= D3D_PRIMITIVE_TOPOLOGY_11_CONTROL_POINT_PATCHLIST,
+        D3D11_PRIMITIVE_TOPOLOGY_12_CONTROL_POINT_PATCHLIST	= D3D_PRIMITIVE_TOPOLOGY_12_CONTROL_POINT_PATCHLIST,
+        D3D11_PRIMITIVE_TOPOLOGY_13_CONTROL_POINT_PATCHLIST	= D3D_PRIMITIVE_TOPOLOGY_13_CONTROL_POINT_PATCHLIST,
+        D3D11_PRIMITIVE_TOPOLOGY_14_CONTROL_POINT_PATCHLIST	= D3D_PRIMITIVE_TOPOLOGY_14_CONTROL_POINT_PATCHLIST,
+        D3D11_PRIMITIVE_TOPOLOGY_15_CONTROL_POINT_PATCHLIST	= D3D_PRIMITIVE_TOPOLOGY_15_CONTROL_POINT_PATCHLIST,
+        D3D11_PRIMITIVE_TOPOLOGY_16_CONTROL_POINT_PATCHLIST	= D3D_PRIMITIVE_TOPOLOGY_16_CONTROL_POINT_PATCHLIST,
+        D3D11_PRIMITIVE_TOPOLOGY_17_CONTROL_POINT_PATCHLIST	= D3D_PRIMITIVE_TOPOLOGY_17_CONTROL_POINT_PATCHLIST,
+        D3D11_PRIMITIVE_TOPOLOGY_18_CONTROL_POINT_PATCHLIST	= D3D_PRIMITIVE_TOPOLOGY_18_CONTROL_POINT_PATCHLIST,
+        D3D11_PRIMITIVE_TOPOLOGY_19_CONTROL_POINT_PATCHLIST	= D3D_PRIMITIVE_TOPOLOGY_19_CONTROL_POINT_PATCHLIST,
+        D3D11_PRIMITIVE_TOPOLOGY_20_CONTROL_POINT_PATCHLIST	= D3D_PRIMITIVE_TOPOLOGY_20_CONTROL_POINT_PATCHLIST,
+        D3D11_PRIMITIVE_TOPOLOGY_21_CONTROL_POINT_PATCHLIST	= D3D_PRIMITIVE_TOPOLOGY_21_CONTROL_POINT_PATCHLIST,
+        D3D11_PRIMITIVE_TOPOLOGY_22_CONTROL_POINT_PATCHLIST	= D3D_PRIMITIVE_TOPOLOGY_22_CONTROL_POINT_PATCHLIST,
+        D3D11_PRIMITIVE_TOPOLOGY_23_CONTROL_POINT_PATCHLIST	= D3D_PRIMITIVE_TOPOLOGY_23_CONTROL_POINT_PATCHLIST,
+        D3D11_PRIMITIVE_TOPOLOGY_24_CONTROL_POINT_PATCHLIST	= D3D_PRIMITIVE_TOPOLOGY_24_CONTROL_POINT_PATCHLIST,
+        D3D11_PRIMITIVE_TOPOLOGY_25_CONTROL_POINT_PATCHLIST	= D3D_PRIMITIVE_TOPOLOGY_25_CONTROL_POINT_PATCHLIST,
+        D3D11_PRIMITIVE_TOPOLOGY_26_CONTROL_POINT_PATCHLIST	= D3D_PRIMITIVE_TOPOLOGY_26_CONTROL_POINT_PATCHLIST,
+        D3D11_PRIMITIVE_TOPOLOGY_27_CONTROL_POINT_PATCHLIST	= D3D_PRIMITIVE_TOPOLOGY_27_CONTROL_POINT_PATCHLIST,
+        D3D11_PRIMITIVE_TOPOLOGY_28_CONTROL_POINT_PATCHLIST	= D3D_PRIMITIVE_TOPOLOGY_28_CONTROL_POINT_PATCHLIST,
+        D3D11_PRIMITIVE_TOPOLOGY_29_CONTROL_POINT_PATCHLIST	= D3D_PRIMITIVE_TOPOLOGY_29_CONTROL_POINT_PATCHLIST,
+        D3D11_PRIMITIVE_TOPOLOGY_30_CONTROL_POINT_PATCHLIST	= D3D_PRIMITIVE_TOPOLOGY_30_CONTROL_POINT_PATCHLIST,
+        D3D11_PRIMITIVE_TOPOLOGY_31_CONTROL_POINT_PATCHLIST	= D3D_PRIMITIVE_TOPOLOGY_31_CONTROL_POINT_PATCHLIST,
+        D3D11_PRIMITIVE_TOPOLOGY_32_CONTROL_POINT_PATCHLIST	= D3D_PRIMITIVE_TOPOLOGY_32_CONTROL_POINT_PATCHLIST
+    } 	D3D_PRIMITIVE_TOPOLOGY;
+
+typedef 
+enum D3D_PRIMITIVE
+    {
+        D3D_PRIMITIVE_UNDEFINED	= 0,
+        D3D_PRIMITIVE_POINT	= 1,
+        D3D_PRIMITIVE_LINE	= 2,
+        D3D_PRIMITIVE_TRIANGLE	= 3,
+        D3D_PRIMITIVE_LINE_ADJ	= 6,
+        D3D_PRIMITIVE_TRIANGLE_ADJ	= 7,
+        D3D_PRIMITIVE_1_CONTROL_POINT_PATCH	= 8,
+        D3D_PRIMITIVE_2_CONTROL_POINT_PATCH	= 9,
+        D3D_PRIMITIVE_3_CONTROL_POINT_PATCH	= 10,
+        D3D_PRIMITIVE_4_CONTROL_POINT_PATCH	= 11,
+        D3D_PRIMITIVE_5_CONTROL_POINT_PATCH	= 12,
+        D3D_PRIMITIVE_6_CONTROL_POINT_PATCH	= 13,
+        D3D_PRIMITIVE_7_CONTROL_POINT_PATCH	= 14,
+        D3D_PRIMITIVE_8_CONTROL_POINT_PATCH	= 15,
+        D3D_PRIMITIVE_9_CONTROL_POINT_PATCH	= 16,
+        D3D_PRIMITIVE_10_CONTROL_POINT_PATCH	= 17,
+        D3D_PRIMITIVE_11_CONTROL_POINT_PATCH	= 18,
+        D3D_PRIMITIVE_12_CONTROL_POINT_PATCH	= 19,
+        D3D_PRIMITIVE_13_CONTROL_POINT_PATCH	= 20,
+        D3D_PRIMITIVE_14_CONTROL_POINT_PATCH	= 21,
+        D3D_PRIMITIVE_15_CONTROL_POINT_PATCH	= 22,
+        D3D_PRIMITIVE_16_CONTROL_POINT_PATCH	= 23,
+        D3D_PRIMITIVE_17_CONTROL_POINT_PATCH	= 24,
+        D3D_PRIMITIVE_18_CONTROL_POINT_PATCH	= 25,
+        D3D_PRIMITIVE_19_CONTROL_POINT_PATCH	= 26,
+        D3D_PRIMITIVE_20_CONTROL_POINT_PATCH	= 27,
+        D3D_PRIMITIVE_21_CONTROL_POINT_PATCH	= 28,
+        D3D_PRIMITIVE_22_CONTROL_POINT_PATCH	= 29,
+        D3D_PRIMITIVE_23_CONTROL_POINT_PATCH	= 30,
+        D3D_PRIMITIVE_24_CONTROL_POINT_PATCH	= 31,
+        D3D_PRIMITIVE_25_CONTROL_POINT_PATCH	= 32,
+        D3D_PRIMITIVE_26_CONTROL_POINT_PATCH	= 33,
+        D3D_PRIMITIVE_27_CONTROL_POINT_PATCH	= 34,
+        D3D_PRIMITIVE_28_CONTROL_POINT_PATCH	= 35,
+        D3D_PRIMITIVE_29_CONTROL_POINT_PATCH	= 36,
+        D3D_PRIMITIVE_30_CONTROL_POINT_PATCH	= 37,
+        D3D_PRIMITIVE_31_CONTROL_POINT_PATCH	= 38,
+        D3D_PRIMITIVE_32_CONTROL_POINT_PATCH	= 39,
+        D3D10_PRIMITIVE_UNDEFINED	= D3D_PRIMITIVE_UNDEFINED,
+        D3D10_PRIMITIVE_POINT	= D3D_PRIMITIVE_POINT,
+        D3D10_PRIMITIVE_LINE	= D3D_PRIMITIVE_LINE,
+        D3D10_PRIMITIVE_TRIANGLE	= D3D_PRIMITIVE_TRIANGLE,
+        D3D10_PRIMITIVE_LINE_ADJ	= D3D_PRIMITIVE_LINE_ADJ,
+        D3D10_PRIMITIVE_TRIANGLE_ADJ	= D3D_PRIMITIVE_TRIANGLE_ADJ,
+        D3D11_PRIMITIVE_UNDEFINED	= D3D_PRIMITIVE_UNDEFINED,
+        D3D11_PRIMITIVE_POINT	= D3D_PRIMITIVE_POINT,
+        D3D11_PRIMITIVE_LINE	= D3D_PRIMITIVE_LINE,
+        D3D11_PRIMITIVE_TRIANGLE	= D3D_PRIMITIVE_TRIANGLE,
+        D3D11_PRIMITIVE_LINE_ADJ	= D3D_PRIMITIVE_LINE_ADJ,
+        D3D11_PRIMITIVE_TRIANGLE_ADJ	= D3D_PRIMITIVE_TRIANGLE_ADJ,
+        D3D11_PRIMITIVE_1_CONTROL_POINT_PATCH	= D3D_PRIMITIVE_1_CONTROL_POINT_PATCH,
+        D3D11_PRIMITIVE_2_CONTROL_POINT_PATCH	= D3D_PRIMITIVE_2_CONTROL_POINT_PATCH,
+        D3D11_PRIMITIVE_3_CONTROL_POINT_PATCH	= D3D_PRIMITIVE_3_CONTROL_POINT_PATCH,
+        D3D11_PRIMITIVE_4_CONTROL_POINT_PATCH	= D3D_PRIMITIVE_4_CONTROL_POINT_PATCH,
+        D3D11_PRIMITIVE_5_CONTROL_POINT_PATCH	= D3D_PRIMITIVE_5_CONTROL_POINT_PATCH,
+        D3D11_PRIMITIVE_6_CONTROL_POINT_PATCH	= D3D_PRIMITIVE_6_CONTROL_POINT_PATCH,
+        D3D11_PRIMITIVE_7_CONTROL_POINT_PATCH	= D3D_PRIMITIVE_7_CONTROL_POINT_PATCH,
+        D3D11_PRIMITIVE_8_CONTROL_POINT_PATCH	= D3D_PRIMITIVE_8_CONTROL_POINT_PATCH,
+        D3D11_PRIMITIVE_9_CONTROL_POINT_PATCH	= D3D_PRIMITIVE_9_CONTROL_POINT_PATCH,
+        D3D11_PRIMITIVE_10_CONTROL_POINT_PATCH	= D3D_PRIMITIVE_10_CONTROL_POINT_PATCH,
+        D3D11_PRIMITIVE_11_CONTROL_POINT_PATCH	= D3D_PRIMITIVE_11_CONTROL_POINT_PATCH,
+        D3D11_PRIMITIVE_12_CONTROL_POINT_PATCH	= D3D_PRIMITIVE_12_CONTROL_POINT_PATCH,
+        D3D11_PRIMITIVE_13_CONTROL_POINT_PATCH	= D3D_PRIMITIVE_13_CONTROL_POINT_PATCH,
+        D3D11_PRIMITIVE_14_CONTROL_POINT_PATCH	= D3D_PRIMITIVE_14_CONTROL_POINT_PATCH,
+        D3D11_PRIMITIVE_15_CONTROL_POINT_PATCH	= D3D_PRIMITIVE_15_CONTROL_POINT_PATCH,
+        D3D11_PRIMITIVE_16_CONTROL_POINT_PATCH	= D3D_PRIMITIVE_16_CONTROL_POINT_PATCH,
+        D3D11_PRIMITIVE_17_CONTROL_POINT_PATCH	= D3D_PRIMITIVE_17_CONTROL_POINT_PATCH,
+        D3D11_PRIMITIVE_18_CONTROL_POINT_PATCH	= D3D_PRIMITIVE_18_CONTROL_POINT_PATCH,
+        D3D11_PRIMITIVE_19_CONTROL_POINT_PATCH	= D3D_PRIMITIVE_19_CONTROL_POINT_PATCH,
+        D3D11_PRIMITIVE_20_CONTROL_POINT_PATCH	= D3D_PRIMITIVE_20_CONTROL_POINT_PATCH,
+        D3D11_PRIMITIVE_21_CONTROL_POINT_PATCH	= D3D_PRIMITIVE_21_CONTROL_POINT_PATCH,
+        D3D11_PRIMITIVE_22_CONTROL_POINT_PATCH	= D3D_PRIMITIVE_22_CONTROL_POINT_PATCH,
+        D3D11_PRIMITIVE_23_CONTROL_POINT_PATCH	= D3D_PRIMITIVE_23_CONTROL_POINT_PATCH,
+        D3D11_PRIMITIVE_24_CONTROL_POINT_PATCH	= D3D_PRIMITIVE_24_CONTROL_POINT_PATCH,
+        D3D11_PRIMITIVE_25_CONTROL_POINT_PATCH	= D3D_PRIMITIVE_25_CONTROL_POINT_PATCH,
+        D3D11_PRIMITIVE_26_CONTROL_POINT_PATCH	= D3D_PRIMITIVE_26_CONTROL_POINT_PATCH,
+        D3D11_PRIMITIVE_27_CONTROL_POINT_PATCH	= D3D_PRIMITIVE_27_CONTROL_POINT_PATCH,
+        D3D11_PRIMITIVE_28_CONTROL_POINT_PATCH	= D3D_PRIMITIVE_28_CONTROL_POINT_PATCH,
+        D3D11_PRIMITIVE_29_CONTROL_POINT_PATCH	= D3D_PRIMITIVE_29_CONTROL_POINT_PATCH,
+        D3D11_PRIMITIVE_30_CONTROL_POINT_PATCH	= D3D_PRIMITIVE_30_CONTROL_POINT_PATCH,
+        D3D11_PRIMITIVE_31_CONTROL_POINT_PATCH	= D3D_PRIMITIVE_31_CONTROL_POINT_PATCH,
+        D3D11_PRIMITIVE_32_CONTROL_POINT_PATCH	= D3D_PRIMITIVE_32_CONTROL_POINT_PATCH
+    } 	D3D_PRIMITIVE;
+
+typedef 
+enum D3D_SRV_DIMENSION
+    {
+        D3D_SRV_DIMENSION_UNKNOWN	= 0,
+        D3D_SRV_DIMENSION_BUFFER	= 1,
+        D3D_SRV_DIMENSION_TEXTURE1D	= 2,
+        D3D_SRV_DIMENSION_TEXTURE1DARRAY	= 3,
+        D3D_SRV_DIMENSION_TEXTURE2D	= 4,
+        D3D_SRV_DIMENSION_TEXTURE2DARRAY	= 5,
+        D3D_SRV_DIMENSION_TEXTURE2DMS	= 6,
+        D3D_SRV_DIMENSION_TEXTURE2DMSARRAY	= 7,
+        D3D_SRV_DIMENSION_TEXTURE3D	= 8,
+        D3D_SRV_DIMENSION_TEXTURECUBE	= 9,
+        D3D_SRV_DIMENSION_TEXTURECUBEARRAY	= 10,
+        D3D_SRV_DIMENSION_BUFFEREX	= 11,
+        D3D10_SRV_DIMENSION_UNKNOWN	= D3D_SRV_DIMENSION_UNKNOWN,
+        D3D10_SRV_DIMENSION_BUFFER	= D3D_SRV_DIMENSION_BUFFER,
+        D3D10_SRV_DIMENSION_TEXTURE1D	= D3D_SRV_DIMENSION_TEXTURE1D,
+        D3D10_SRV_DIMENSION_TEXTURE1DARRAY	= D3D_SRV_DIMENSION_TEXTURE1DARRAY,
+        D3D10_SRV_DIMENSION_TEXTURE2D	= D3D_SRV_DIMENSION_TEXTURE2D,
+        D3D10_SRV_DIMENSION_TEXTURE2DARRAY	= D3D_SRV_DIMENSION_TEXTURE2DARRAY,
+        D3D10_SRV_DIMENSION_TEXTURE2DMS	= D3D_SRV_DIMENSION_TEXTURE2DMS,
+        D3D10_SRV_DIMENSION_TEXTURE2DMSARRAY	= D3D_SRV_DIMENSION_TEXTURE2DMSARRAY,
+        D3D10_SRV_DIMENSION_TEXTURE3D	= D3D_SRV_DIMENSION_TEXTURE3D,
+        D3D10_SRV_DIMENSION_TEXTURECUBE	= D3D_SRV_DIMENSION_TEXTURECUBE,
+        D3D10_1_SRV_DIMENSION_UNKNOWN	= D3D_SRV_DIMENSION_UNKNOWN,
+        D3D10_1_SRV_DIMENSION_BUFFER	= D3D_SRV_DIMENSION_BUFFER,
+        D3D10_1_SRV_DIMENSION_TEXTURE1D	= D3D_SRV_DIMENSION_TEXTURE1D,
+        D3D10_1_SRV_DIMENSION_TEXTURE1DARRAY	= D3D_SRV_DIMENSION_TEXTURE1DARRAY,
+        D3D10_1_SRV_DIMENSION_TEXTURE2D	= D3D_SRV_DIMENSION_TEXTURE2D,
+        D3D10_1_SRV_DIMENSION_TEXTURE2DARRAY	= D3D_SRV_DIMENSION_TEXTURE2DARRAY,
+        D3D10_1_SRV_DIMENSION_TEXTURE2DMS	= D3D_SRV_DIMENSION_TEXTURE2DMS,
+        D3D10_1_SRV_DIMENSION_TEXTURE2DMSARRAY	= D3D_SRV_DIMENSION_TEXTURE2DMSARRAY,
+        D3D10_1_SRV_DIMENSION_TEXTURE3D	= D3D_SRV_DIMENSION_TEXTURE3D,
+        D3D10_1_SRV_DIMENSION_TEXTURECUBE	= D3D_SRV_DIMENSION_TEXTURECUBE,
+        D3D10_1_SRV_DIMENSION_TEXTURECUBEARRAY	= D3D_SRV_DIMENSION_TEXTURECUBEARRAY,
+        D3D11_SRV_DIMENSION_UNKNOWN	= D3D_SRV_DIMENSION_UNKNOWN,
+        D3D11_SRV_DIMENSION_BUFFER	= D3D_SRV_DIMENSION_BUFFER,
+        D3D11_SRV_DIMENSION_TEXTURE1D	= D3D_SRV_DIMENSION_TEXTURE1D,
+        D3D11_SRV_DIMENSION_TEXTURE1DARRAY	= D3D_SRV_DIMENSION_TEXTURE1DARRAY,
+        D3D11_SRV_DIMENSION_TEXTURE2D	= D3D_SRV_DIMENSION_TEXTURE2D,
+        D3D11_SRV_DIMENSION_TEXTURE2DARRAY	= D3D_SRV_DIMENSION_TEXTURE2DARRAY,
+        D3D11_SRV_DIMENSION_TEXTURE2DMS	= D3D_SRV_DIMENSION_TEXTURE2DMS,
+        D3D11_SRV_DIMENSION_TEXTURE2DMSARRAY	= D3D_SRV_DIMENSION_TEXTURE2DMSARRAY,
+        D3D11_SRV_DIMENSION_TEXTURE3D	= D3D_SRV_DIMENSION_TEXTURE3D,
+        D3D11_SRV_DIMENSION_TEXTURECUBE	= D3D_SRV_DIMENSION_TEXTURECUBE,
+        D3D11_SRV_DIMENSION_TEXTURECUBEARRAY	= D3D_SRV_DIMENSION_TEXTURECUBEARRAY,
+        D3D11_SRV_DIMENSION_BUFFEREX	= D3D_SRV_DIMENSION_BUFFEREX
+    } 	D3D_SRV_DIMENSION;
+
+#define D3D_SHADER_FEATURE_DOUBLES                                                        0x00001
+#define D3D_SHADER_FEATURE_COMPUTE_SHADERS_PLUS_RAW_AND_STRUCTURED_BUFFERS_VIA_SHADER_4_X 0x00002
+#define D3D_SHADER_FEATURE_UAVS_AT_EVERY_STAGE                                            0x00004
+#define D3D_SHADER_FEATURE_64_UAVS                                                        0x00008
+#define D3D_SHADER_FEATURE_MINIMUM_PRECISION                                              0x00010
+#define D3D_SHADER_FEATURE_11_1_DOUBLE_EXTENSIONS                                         0x00020
+#define D3D_SHADER_FEATURE_11_1_SHADER_EXTENSIONS                                         0x00040
+#define D3D_SHADER_FEATURE_LEVEL_9_COMPARISON_FILTERING                                   0x00080
+#define D3D_SHADER_FEATURE_TILED_RESOURCES                                                0x00100
+#define D3D_SHADER_FEATURE_STENCIL_REF                                                    0x00200
+#define D3D_SHADER_FEATURE_INNER_COVERAGE                                                 0x00400
+#define D3D_SHADER_FEATURE_TYPED_UAV_LOAD_ADDITIONAL_FORMATS                              0x00800
+#define D3D_SHADER_FEATURE_ROVS                                                           0x01000
+#define D3D_SHADER_FEATURE_VIEWPORT_AND_RT_ARRAY_INDEX_FROM_ANY_SHADER_FEEDING_RASTERIZER 0x02000
+#define D3D_SHADER_FEATURE_WAVE_OPS                                                       0x04000
+#define D3D_SHADER_FEATURE_INT64_OPS                                                      0x08000
+#define D3D_SHADER_FEATURE_VIEW_ID                                                        0x10000
+#define D3D_SHADER_FEATURE_BARYCENTRICS                                                   0x20000
+#define D3D_SHADER_FEATURE_NATIVE_16BIT_OPS                                               0x40000
+#define D3D_SHADER_FEATURE_SHADING_RATE                                                   0x80000
+#define D3D_SHADER_FEATURE_RAYTRACING_TIER_1_1                                            0x100000
+#define D3D_SHADER_FEATURE_SAMPLER_FEEDBACK                                               0x200000
+#define D3D_SHADER_FEATURE_ATOMIC_INT64_ON_TYPED_RESOURCE                                 0x400000
+#define D3D_SHADER_FEATURE_ATOMIC_INT64_ON_GROUP_SHARED                                   0x800000
+#define D3D_SHADER_FEATURE_DERIVATIVES_IN_MESH_AND_AMPLIFICATION_SHADERS                  0x1000000
+#define D3D_SHADER_FEATURE_RESOURCE_DESCRIPTOR_HEAP_INDEXING                              0x2000000
+#define D3D_SHADER_FEATURE_SAMPLER_DESCRIPTOR_HEAP_INDEXING                               0x4000000
+#define D3D_SHADER_FEATURE_WAVE_MMA                                                       0x8000000
+#define D3D_SHADER_FEATURE_ATOMIC_INT64_ON_DESCRIPTOR_HEAP_RESOURCE                       0x10000000
+#define D3D_SHADER_FEATURE_ADVANCED_TEXTURE_OPS                                           0x20000000
+#define D3D_SHADER_FEATURE_WRITEABLE_MSAA_TEXTURES                                        0x40000000
+typedef struct _D3D_SHADER_MACRO
+    {
+    LPCSTR Name;
+    LPCSTR Definition;
+    } 	D3D_SHADER_MACRO;
+
+typedef struct _D3D_SHADER_MACRO *LPD3D_SHADER_MACRO;
+
+DEFINE_GUID(IID_ID3D10Blob, 0x8ba5fb08, 0x5195, 0x40e2, 0xac, 0x58, 0xd, 0x98, 0x9c, 0x3a, 0x1, 0x2);
+
+
+extern RPC_IF_HANDLE __MIDL_itf_d3dcommon_0000_0000_v0_0_c_ifspec;
+extern RPC_IF_HANDLE __MIDL_itf_d3dcommon_0000_0000_v0_0_s_ifspec;
+
+#ifndef __ID3D10Blob_INTERFACE_DEFINED__
+#define __ID3D10Blob_INTERFACE_DEFINED__
+
+/* interface ID3D10Blob */
+/* [unique][local][object][uuid] */ 
+
+
+EXTERN_C const IID IID_ID3D10Blob;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("8BA5FB08-5195-40e2-AC58-0D989C3A0102")
+    ID3D10Blob : public IUnknown
+    {
+    public:
+        virtual LPVOID STDMETHODCALLTYPE GetBufferPointer( void) = 0;
+        
+        virtual SIZE_T STDMETHODCALLTYPE GetBufferSize( void) = 0;
+        
+    };
+    
+    
+#else 	/* C style interface */
+
+    typedef struct ID3D10BlobVtbl
+    {
+        BEGIN_INTERFACE
+        
+        DECLSPEC_XFGVIRT(IUnknown, QueryInterface)
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            ID3D10Blob * This,
+            /* [in] */ REFIID riid,
+            /* [annotation][iid_is][out] */ 
+            _COM_Outptr_  void **ppvObject);
+        
+        DECLSPEC_XFGVIRT(IUnknown, AddRef)
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            ID3D10Blob * This);
+        
+        DECLSPEC_XFGVIRT(IUnknown, Release)
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            ID3D10Blob * This);
+        
+        DECLSPEC_XFGVIRT(ID3D10Blob, GetBufferPointer)
+        LPVOID ( STDMETHODCALLTYPE *GetBufferPointer )( 
+            ID3D10Blob * This);
+        
+        DECLSPEC_XFGVIRT(ID3D10Blob, GetBufferSize)
+        SIZE_T ( STDMETHODCALLTYPE *GetBufferSize )( 
+            ID3D10Blob * This);
+        
+        END_INTERFACE
+    } ID3D10BlobVtbl;
+
+    interface ID3D10Blob
+    {
+        CONST_VTBL struct ID3D10BlobVtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define ID3D10Blob_QueryInterface(This,riid,ppvObject)	\
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define ID3D10Blob_AddRef(This)	\
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define ID3D10Blob_Release(This)	\
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#define ID3D10Blob_GetBufferPointer(This)	\
+    ( (This)->lpVtbl -> GetBufferPointer(This) ) 
+
+#define ID3D10Blob_GetBufferSize(This)	\
+    ( (This)->lpVtbl -> GetBufferSize(This) ) 
+
+#endif /* COBJMACROS */
+
+
+#endif 	/* C style interface */
+
+
+
+
+#endif 	/* __ID3D10Blob_INTERFACE_DEFINED__ */
+
+
+/* interface __MIDL_itf_d3dcommon_0000_0001 */
+/* [local] */ 
+
+typedef interface ID3D10Blob* LPD3D10BLOB;
+typedef ID3D10Blob ID3DBlob;
+
+typedef ID3DBlob* LPD3DBLOB;
+#define IID_ID3DBlob IID_ID3D10Blob
+typedef void ( __stdcall *PFN_DESTRUCTION_CALLBACK )( 
+    void *pData);
+
+
+
+extern RPC_IF_HANDLE __MIDL_itf_d3dcommon_0000_0001_v0_0_c_ifspec;
+extern RPC_IF_HANDLE __MIDL_itf_d3dcommon_0000_0001_v0_0_s_ifspec;
+
+#ifndef __ID3DDestructionNotifier_INTERFACE_DEFINED__
+#define __ID3DDestructionNotifier_INTERFACE_DEFINED__
+
+/* interface ID3DDestructionNotifier */
+/* [unique][local][object][uuid] */ 
+
+
+EXTERN_C const IID IID_ID3DDestructionNotifier;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("a06eb39a-50da-425b-8c31-4eecd6c270f3")
+    ID3DDestructionNotifier : public IUnknown
+    {
+    public:
+        virtual HRESULT STDMETHODCALLTYPE RegisterDestructionCallback( 
+            /* [annotation] */ 
+            _In_  PFN_DESTRUCTION_CALLBACK callbackFn,
+            /* [annotation] */ 
+            _In_  void *pData,
+            /* [annotation] */ 
+            _Out_  UINT *pCallbackID) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE UnregisterDestructionCallback( 
+            /* [annotation] */ 
+            _In_  UINT callbackID) = 0;
+        
+    };
+    
+    
+#else 	/* C style interface */
+
+    typedef struct ID3DDestructionNotifierVtbl
+    {
+        BEGIN_INTERFACE
+        
+        DECLSPEC_XFGVIRT(IUnknown, QueryInterface)
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            ID3DDestructionNotifier * This,
+            /* [in] */ REFIID riid,
+            /* [annotation][iid_is][out] */ 
+            _COM_Outptr_  void **ppvObject);
+        
+        DECLSPEC_XFGVIRT(IUnknown, AddRef)
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            ID3DDestructionNotifier * This);
+        
+        DECLSPEC_XFGVIRT(IUnknown, Release)
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            ID3DDestructionNotifier * This);
+        
+        DECLSPEC_XFGVIRT(ID3DDestructionNotifier, RegisterDestructionCallback)
+        HRESULT ( STDMETHODCALLTYPE *RegisterDestructionCallback )( 
+            ID3DDestructionNotifier * This,
+            /* [annotation] */ 
+            _In_  PFN_DESTRUCTION_CALLBACK callbackFn,
+            /* [annotation] */ 
+            _In_  void *pData,
+            /* [annotation] */ 
+            _Out_  UINT *pCallbackID);
+        
+        DECLSPEC_XFGVIRT(ID3DDestructionNotifier, UnregisterDestructionCallback)
+        HRESULT ( STDMETHODCALLTYPE *UnregisterDestructionCallback )( 
+            ID3DDestructionNotifier * This,
+            /* [annotation] */ 
+            _In_  UINT callbackID);
+        
+        END_INTERFACE
+    } ID3DDestructionNotifierVtbl;
+
+    interface ID3DDestructionNotifier
+    {
+        CONST_VTBL struct ID3DDestructionNotifierVtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define ID3DDestructionNotifier_QueryInterface(This,riid,ppvObject)	\
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define ID3DDestructionNotifier_AddRef(This)	\
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define ID3DDestructionNotifier_Release(This)	\
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#define ID3DDestructionNotifier_RegisterDestructionCallback(This,callbackFn,pData,pCallbackID)	\
+    ( (This)->lpVtbl -> RegisterDestructionCallback(This,callbackFn,pData,pCallbackID) ) 
+
+#define ID3DDestructionNotifier_UnregisterDestructionCallback(This,callbackID)	\
+    ( (This)->lpVtbl -> UnregisterDestructionCallback(This,callbackID) ) 
+
+#endif /* COBJMACROS */
+
+
+#endif 	/* C style interface */
+
+
+
+
+#endif 	/* __ID3DDestructionNotifier_INTERFACE_DEFINED__ */
+
+
+/* interface __MIDL_itf_d3dcommon_0000_0002 */
+/* [local] */ 
+
+typedef 
+enum _D3D_INCLUDE_TYPE
+    {
+        D3D_INCLUDE_LOCAL	= 0,
+        D3D_INCLUDE_SYSTEM	= ( D3D_INCLUDE_LOCAL + 1 ) ,
+        D3D10_INCLUDE_LOCAL	= D3D_INCLUDE_LOCAL,
+        D3D10_INCLUDE_SYSTEM	= D3D_INCLUDE_SYSTEM,
+        D3D_INCLUDE_FORCE_DWORD	= 0x7fffffff
+    } 	D3D_INCLUDE_TYPE;
+
+typedef interface ID3DInclude ID3DInclude;
+#undef INTERFACE
+#define INTERFACE ID3DInclude
+DECLARE_INTERFACE(ID3DInclude)
+{
+    STDMETHOD(Open)(THIS_ D3D_INCLUDE_TYPE IncludeType, LPCSTR pFileName, LPCVOID pParentData, LPCVOID *ppData, UINT *pBytes) PURE;
+    STDMETHOD(Close)(THIS_ LPCVOID pData) PURE;
+};
+typedef ID3DInclude* LPD3DINCLUDE;
+typedef 
+enum _D3D_SHADER_VARIABLE_CLASS
+    {
+        D3D_SVC_SCALAR	= 0,
+        D3D_SVC_VECTOR	= ( D3D_SVC_SCALAR + 1 ) ,
+        D3D_SVC_MATRIX_ROWS	= ( D3D_SVC_VECTOR + 1 ) ,
+        D3D_SVC_MATRIX_COLUMNS	= ( D3D_SVC_MATRIX_ROWS + 1 ) ,
+        D3D_SVC_OBJECT	= ( D3D_SVC_MATRIX_COLUMNS + 1 ) ,
+        D3D_SVC_STRUCT	= ( D3D_SVC_OBJECT + 1 ) ,
+        D3D_SVC_INTERFACE_CLASS	= ( D3D_SVC_STRUCT + 1 ) ,
+        D3D_SVC_INTERFACE_POINTER	= ( D3D_SVC_INTERFACE_CLASS + 1 ) ,
+        D3D10_SVC_SCALAR	= D3D_SVC_SCALAR,
+        D3D10_SVC_VECTOR	= D3D_SVC_VECTOR,
+        D3D10_SVC_MATRIX_ROWS	= D3D_SVC_MATRIX_ROWS,
+        D3D10_SVC_MATRIX_COLUMNS	= D3D_SVC_MATRIX_COLUMNS,
+        D3D10_SVC_OBJECT	= D3D_SVC_OBJECT,
+        D3D10_SVC_STRUCT	= D3D_SVC_STRUCT,
+        D3D11_SVC_INTERFACE_CLASS	= D3D_SVC_INTERFACE_CLASS,
+        D3D11_SVC_INTERFACE_POINTER	= D3D_SVC_INTERFACE_POINTER,
+        D3D_SVC_FORCE_DWORD	= 0x7fffffff
+    } 	D3D_SHADER_VARIABLE_CLASS;
+
+typedef 
+enum _D3D_SHADER_VARIABLE_FLAGS
+    {
+        D3D_SVF_USERPACKED	= 1,
+        D3D_SVF_USED	= 2,
+        D3D_SVF_INTERFACE_POINTER	= 4,
+        D3D_SVF_INTERFACE_PARAMETER	= 8,
+        D3D10_SVF_USERPACKED	= D3D_SVF_USERPACKED,
+        D3D10_SVF_USED	= D3D_SVF_USED,
+        D3D11_SVF_INTERFACE_POINTER	= D3D_SVF_INTERFACE_POINTER,
+        D3D11_SVF_INTERFACE_PARAMETER	= D3D_SVF_INTERFACE_PARAMETER,
+        D3D_SVF_FORCE_DWORD	= 0x7fffffff
+    } 	D3D_SHADER_VARIABLE_FLAGS;
+
+typedef 
+enum _D3D_SHADER_VARIABLE_TYPE
+    {
+        D3D_SVT_VOID	= 0,
+        D3D_SVT_BOOL	= 1,
+        D3D_SVT_INT	= 2,
+        D3D_SVT_FLOAT	= 3,
+        D3D_SVT_STRING	= 4,
+        D3D_SVT_TEXTURE	= 5,
+        D3D_SVT_TEXTURE1D	= 6,
+        D3D_SVT_TEXTURE2D	= 7,
+        D3D_SVT_TEXTURE3D	= 8,
+        D3D_SVT_TEXTURECUBE	= 9,
+        D3D_SVT_SAMPLER	= 10,
+        D3D_SVT_SAMPLER1D	= 11,
+        D3D_SVT_SAMPLER2D	= 12,
+        D3D_SVT_SAMPLER3D	= 13,
+        D3D_SVT_SAMPLERCUBE	= 14,
+        D3D_SVT_PIXELSHADER	= 15,
+        D3D_SVT_VERTEXSHADER	= 16,
+        D3D_SVT_PIXELFRAGMENT	= 17,
+        D3D_SVT_VERTEXFRAGMENT	= 18,
+        D3D_SVT_UINT	= 19,
+        D3D_SVT_UINT8	= 20,
+        D3D_SVT_GEOMETRYSHADER	= 21,
+        D3D_SVT_RASTERIZER	= 22,
+        D3D_SVT_DEPTHSTENCIL	= 23,
+        D3D_SVT_BLEND	= 24,
+        D3D_SVT_BUFFER	= 25,
+        D3D_SVT_CBUFFER	= 26,
+        D3D_SVT_TBUFFER	= 27,
+        D3D_SVT_TEXTURE1DARRAY	= 28,
+        D3D_SVT_TEXTURE2DARRAY	= 29,
+        D3D_SVT_RENDERTARGETVIEW	= 30,
+        D3D_SVT_DEPTHSTENCILVIEW	= 31,
+        D3D_SVT_TEXTURE2DMS	= 32,
+        D3D_SVT_TEXTURE2DMSARRAY	= 33,
+        D3D_SVT_TEXTURECUBEARRAY	= 34,
+        D3D_SVT_HULLSHADER	= 35,
+        D3D_SVT_DOMAINSHADER	= 36,
+        D3D_SVT_INTERFACE_POINTER	= 37,
+        D3D_SVT_COMPUTESHADER	= 38,
+        D3D_SVT_DOUBLE	= 39,
+        D3D_SVT_RWTEXTURE1D	= 40,
+        D3D_SVT_RWTEXTURE1DARRAY	= 41,
+        D3D_SVT_RWTEXTURE2D	= 42,
+        D3D_SVT_RWTEXTURE2DARRAY	= 43,
+        D3D_SVT_RWTEXTURE3D	= 44,
+        D3D_SVT_RWBUFFER	= 45,
+        D3D_SVT_BYTEADDRESS_BUFFER	= 46,
+        D3D_SVT_RWBYTEADDRESS_BUFFER	= 47,
+        D3D_SVT_STRUCTURED_BUFFER	= 48,
+        D3D_SVT_RWSTRUCTURED_BUFFER	= 49,
+        D3D_SVT_APPEND_STRUCTURED_BUFFER	= 50,
+        D3D_SVT_CONSUME_STRUCTURED_BUFFER	= 51,
+        D3D_SVT_MIN8FLOAT	= 52,
+        D3D_SVT_MIN10FLOAT	= 53,
+        D3D_SVT_MIN16FLOAT	= 54,
+        D3D_SVT_MIN12INT	= 55,
+        D3D_SVT_MIN16INT	= 56,
+        D3D_SVT_MIN16UINT	= 57,
+        D3D_SVT_INT16	= 58,
+        D3D_SVT_UINT16	= 59,
+        D3D_SVT_FLOAT16	= 60,
+        D3D_SVT_INT64	= 61,
+        D3D_SVT_UINT64	= 62,
+        D3D10_SVT_VOID	= D3D_SVT_VOID,
+        D3D10_SVT_BOOL	= D3D_SVT_BOOL,
+        D3D10_SVT_INT	= D3D_SVT_INT,
+        D3D10_SVT_FLOAT	= D3D_SVT_FLOAT,
+        D3D10_SVT_STRING	= D3D_SVT_STRING,
+        D3D10_SVT_TEXTURE	= D3D_SVT_TEXTURE,
+        D3D10_SVT_TEXTURE1D	= D3D_SVT_TEXTURE1D,
+        D3D10_SVT_TEXTURE2D	= D3D_SVT_TEXTURE2D,
+        D3D10_SVT_TEXTURE3D	= D3D_SVT_TEXTURE3D,
+        D3D10_SVT_TEXTURECUBE	= D3D_SVT_TEXTURECUBE,
+        D3D10_SVT_SAMPLER	= D3D_SVT_SAMPLER,
+        D3D10_SVT_SAMPLER1D	= D3D_SVT_SAMPLER1D,
+        D3D10_SVT_SAMPLER2D	= D3D_SVT_SAMPLER2D,
+        D3D10_SVT_SAMPLER3D	= D3D_SVT_SAMPLER3D,
+        D3D10_SVT_SAMPLERCUBE	= D3D_SVT_SAMPLERCUBE,
+        D3D10_SVT_PIXELSHADER	= D3D_SVT_PIXELSHADER,
+        D3D10_SVT_VERTEXSHADER	= D3D_SVT_VERTEXSHADER,
+        D3D10_SVT_PIXELFRAGMENT	= D3D_SVT_PIXELFRAGMENT,
+        D3D10_SVT_VERTEXFRAGMENT	= D3D_SVT_VERTEXFRAGMENT,
+        D3D10_SVT_UINT	= D3D_SVT_UINT,
+        D3D10_SVT_UINT8	= D3D_SVT_UINT8,
+        D3D10_SVT_GEOMETRYSHADER	= D3D_SVT_GEOMETRYSHADER,
+        D3D10_SVT_RASTERIZER	= D3D_SVT_RASTERIZER,
+        D3D10_SVT_DEPTHSTENCIL	= D3D_SVT_DEPTHSTENCIL,
+        D3D10_SVT_BLEND	= D3D_SVT_BLEND,
+        D3D10_SVT_BUFFER	= D3D_SVT_BUFFER,
+        D3D10_SVT_CBUFFER	= D3D_SVT_CBUFFER,
+        D3D10_SVT_TBUFFER	= D3D_SVT_TBUFFER,
+        D3D10_SVT_TEXTURE1DARRAY	= D3D_SVT_TEXTURE1DARRAY,
+        D3D10_SVT_TEXTURE2DARRAY	= D3D_SVT_TEXTURE2DARRAY,
+        D3D10_SVT_RENDERTARGETVIEW	= D3D_SVT_RENDERTARGETVIEW,
+        D3D10_SVT_DEPTHSTENCILVIEW	= D3D_SVT_DEPTHSTENCILVIEW,
+        D3D10_SVT_TEXTURE2DMS	= D3D_SVT_TEXTURE2DMS,
+        D3D10_SVT_TEXTURE2DMSARRAY	= D3D_SVT_TEXTURE2DMSARRAY,
+        D3D10_SVT_TEXTURECUBEARRAY	= D3D_SVT_TEXTURECUBEARRAY,
+        D3D11_SVT_HULLSHADER	= D3D_SVT_HULLSHADER,
+        D3D11_SVT_DOMAINSHADER	= D3D_SVT_DOMAINSHADER,
+        D3D11_SVT_INTERFACE_POINTER	= D3D_SVT_INTERFACE_POINTER,
+        D3D11_SVT_COMPUTESHADER	= D3D_SVT_COMPUTESHADER,
+        D3D11_SVT_DOUBLE	= D3D_SVT_DOUBLE,
+        D3D11_SVT_RWTEXTURE1D	= D3D_SVT_RWTEXTURE1D,
+        D3D11_SVT_RWTEXTURE1DARRAY	= D3D_SVT_RWTEXTURE1DARRAY,
+        D3D11_SVT_RWTEXTURE2D	= D3D_SVT_RWTEXTURE2D,
+        D3D11_SVT_RWTEXTURE2DARRAY	= D3D_SVT_RWTEXTURE2DARRAY,
+        D3D11_SVT_RWTEXTURE3D	= D3D_SVT_RWTEXTURE3D,
+        D3D11_SVT_RWBUFFER	= D3D_SVT_RWBUFFER,
+        D3D11_SVT_BYTEADDRESS_BUFFER	= D3D_SVT_BYTEADDRESS_BUFFER,
+        D3D11_SVT_RWBYTEADDRESS_BUFFER	= D3D_SVT_RWBYTEADDRESS_BUFFER,
+        D3D11_SVT_STRUCTURED_BUFFER	= D3D_SVT_STRUCTURED_BUFFER,
+        D3D11_SVT_RWSTRUCTURED_BUFFER	= D3D_SVT_RWSTRUCTURED_BUFFER,
+        D3D11_SVT_APPEND_STRUCTURED_BUFFER	= D3D_SVT_APPEND_STRUCTURED_BUFFER,
+        D3D11_SVT_CONSUME_STRUCTURED_BUFFER	= D3D_SVT_CONSUME_STRUCTURED_BUFFER,
+        D3D_SVT_FORCE_DWORD	= 0x7fffffff
+    } 	D3D_SHADER_VARIABLE_TYPE;
+
+typedef 
+enum _D3D_SHADER_INPUT_FLAGS
+    {
+        D3D_SIF_USERPACKED	= 0x1,
+        D3D_SIF_COMPARISON_SAMPLER	= 0x2,
+        D3D_SIF_TEXTURE_COMPONENT_0	= 0x4,
+        D3D_SIF_TEXTURE_COMPONENT_1	= 0x8,
+        D3D_SIF_TEXTURE_COMPONENTS	= 0xc,
+        D3D_SIF_UNUSED	= 0x10,
+        D3D10_SIF_USERPACKED	= D3D_SIF_USERPACKED,
+        D3D10_SIF_COMPARISON_SAMPLER	= D3D_SIF_COMPARISON_SAMPLER,
+        D3D10_SIF_TEXTURE_COMPONENT_0	= D3D_SIF_TEXTURE_COMPONENT_0,
+        D3D10_SIF_TEXTURE_COMPONENT_1	= D3D_SIF_TEXTURE_COMPONENT_1,
+        D3D10_SIF_TEXTURE_COMPONENTS	= D3D_SIF_TEXTURE_COMPONENTS,
+        D3D_SIF_FORCE_DWORD	= 0x7fffffff
+    } 	D3D_SHADER_INPUT_FLAGS;
+
+typedef 
+enum _D3D_SHADER_INPUT_TYPE
+    {
+        D3D_SIT_CBUFFER	= 0,
+        D3D_SIT_TBUFFER	= ( D3D_SIT_CBUFFER + 1 ) ,
+        D3D_SIT_TEXTURE	= ( D3D_SIT_TBUFFER + 1 ) ,
+        D3D_SIT_SAMPLER	= ( D3D_SIT_TEXTURE + 1 ) ,
+        D3D_SIT_UAV_RWTYPED	= ( D3D_SIT_SAMPLER + 1 ) ,
+        D3D_SIT_STRUCTURED	= ( D3D_SIT_UAV_RWTYPED + 1 ) ,
+        D3D_SIT_UAV_RWSTRUCTURED	= ( D3D_SIT_STRUCTURED + 1 ) ,
+        D3D_SIT_BYTEADDRESS	= ( D3D_SIT_UAV_RWSTRUCTURED + 1 ) ,
+        D3D_SIT_UAV_RWBYTEADDRESS	= ( D3D_SIT_BYTEADDRESS + 1 ) ,
+        D3D_SIT_UAV_APPEND_STRUCTURED	= ( D3D_SIT_UAV_RWBYTEADDRESS + 1 ) ,
+        D3D_SIT_UAV_CONSUME_STRUCTURED	= ( D3D_SIT_UAV_APPEND_STRUCTURED + 1 ) ,
+        D3D_SIT_UAV_RWSTRUCTURED_WITH_COUNTER	= ( D3D_SIT_UAV_CONSUME_STRUCTURED + 1 ) ,
+        D3D_SIT_RTACCELERATIONSTRUCTURE	= ( D3D_SIT_UAV_RWSTRUCTURED_WITH_COUNTER + 1 ) ,
+        D3D_SIT_UAV_FEEDBACKTEXTURE	= ( D3D_SIT_RTACCELERATIONSTRUCTURE + 1 ) ,
+        D3D10_SIT_CBUFFER	= D3D_SIT_CBUFFER,
+        D3D10_SIT_TBUFFER	= D3D_SIT_TBUFFER,
+        D3D10_SIT_TEXTURE	= D3D_SIT_TEXTURE,
+        D3D10_SIT_SAMPLER	= D3D_SIT_SAMPLER,
+        D3D11_SIT_UAV_RWTYPED	= D3D_SIT_UAV_RWTYPED,
+        D3D11_SIT_STRUCTURED	= D3D_SIT_STRUCTURED,
+        D3D11_SIT_UAV_RWSTRUCTURED	= D3D_SIT_UAV_RWSTRUCTURED,
+        D3D11_SIT_BYTEADDRESS	= D3D_SIT_BYTEADDRESS,
+        D3D11_SIT_UAV_RWBYTEADDRESS	= D3D_SIT_UAV_RWBYTEADDRESS,
+        D3D11_SIT_UAV_APPEND_STRUCTURED	= D3D_SIT_UAV_APPEND_STRUCTURED,
+        D3D11_SIT_UAV_CONSUME_STRUCTURED	= D3D_SIT_UAV_CONSUME_STRUCTURED,
+        D3D11_SIT_UAV_RWSTRUCTURED_WITH_COUNTER	= D3D_SIT_UAV_RWSTRUCTURED_WITH_COUNTER
+    } 	D3D_SHADER_INPUT_TYPE;
+
+typedef 
+enum _D3D_SHADER_CBUFFER_FLAGS
+    {
+        D3D_CBF_USERPACKED	= 1,
+        D3D10_CBF_USERPACKED	= D3D_CBF_USERPACKED,
+        D3D_CBF_FORCE_DWORD	= 0x7fffffff
+    } 	D3D_SHADER_CBUFFER_FLAGS;
+
+typedef 
+enum _D3D_CBUFFER_TYPE
+    {
+        D3D_CT_CBUFFER	= 0,
+        D3D_CT_TBUFFER	= ( D3D_CT_CBUFFER + 1 ) ,
+        D3D_CT_INTERFACE_POINTERS	= ( D3D_CT_TBUFFER + 1 ) ,
+        D3D_CT_RESOURCE_BIND_INFO	= ( D3D_CT_INTERFACE_POINTERS + 1 ) ,
+        D3D10_CT_CBUFFER	= D3D_CT_CBUFFER,
+        D3D10_CT_TBUFFER	= D3D_CT_TBUFFER,
+        D3D11_CT_CBUFFER	= D3D_CT_CBUFFER,
+        D3D11_CT_TBUFFER	= D3D_CT_TBUFFER,
+        D3D11_CT_INTERFACE_POINTERS	= D3D_CT_INTERFACE_POINTERS,
+        D3D11_CT_RESOURCE_BIND_INFO	= D3D_CT_RESOURCE_BIND_INFO
+    } 	D3D_CBUFFER_TYPE;
+
+typedef 
+enum D3D_NAME
+    {
+        D3D_NAME_UNDEFINED	= 0,
+        D3D_NAME_POSITION	= 1,
+        D3D_NAME_CLIP_DISTANCE	= 2,
+        D3D_NAME_CULL_DISTANCE	= 3,
+        D3D_NAME_RENDER_TARGET_ARRAY_INDEX	= 4,
+        D3D_NAME_VIEWPORT_ARRAY_INDEX	= 5,
+        D3D_NAME_VERTEX_ID	= 6,
+        D3D_NAME_PRIMITIVE_ID	= 7,
+        D3D_NAME_INSTANCE_ID	= 8,
+        D3D_NAME_IS_FRONT_FACE	= 9,
+        D3D_NAME_SAMPLE_INDEX	= 10,
+        D3D_NAME_FINAL_QUAD_EDGE_TESSFACTOR	= 11,
+        D3D_NAME_FINAL_QUAD_INSIDE_TESSFACTOR	= 12,
+        D3D_NAME_FINAL_TRI_EDGE_TESSFACTOR	= 13,
+        D3D_NAME_FINAL_TRI_INSIDE_TESSFACTOR	= 14,
+        D3D_NAME_FINAL_LINE_DETAIL_TESSFACTOR	= 15,
+        D3D_NAME_FINAL_LINE_DENSITY_TESSFACTOR	= 16,
+        D3D_NAME_BARYCENTRICS	= 23,
+        D3D_NAME_SHADINGRATE	= 24,
+        D3D_NAME_CULLPRIMITIVE	= 25,
+        D3D_NAME_TARGET	= 64,
+        D3D_NAME_DEPTH	= 65,
+        D3D_NAME_COVERAGE	= 66,
+        D3D_NAME_DEPTH_GREATER_EQUAL	= 67,
+        D3D_NAME_DEPTH_LESS_EQUAL	= 68,
+        D3D_NAME_STENCIL_REF	= 69,
+        D3D_NAME_INNER_COVERAGE	= 70,
+        D3D10_NAME_UNDEFINED	= D3D_NAME_UNDEFINED,
+        D3D10_NAME_POSITION	= D3D_NAME_POSITION,
+        D3D10_NAME_CLIP_DISTANCE	= D3D_NAME_CLIP_DISTANCE,
+        D3D10_NAME_CULL_DISTANCE	= D3D_NAME_CULL_DISTANCE,
+        D3D10_NAME_RENDER_TARGET_ARRAY_INDEX	= D3D_NAME_RENDER_TARGET_ARRAY_INDEX,
+        D3D10_NAME_VIEWPORT_ARRAY_INDEX	= D3D_NAME_VIEWPORT_ARRAY_INDEX,
+        D3D10_NAME_VERTEX_ID	= D3D_NAME_VERTEX_ID,
+        D3D10_NAME_PRIMITIVE_ID	= D3D_NAME_PRIMITIVE_ID,
+        D3D10_NAME_INSTANCE_ID	= D3D_NAME_INSTANCE_ID,
+        D3D10_NAME_IS_FRONT_FACE	= D3D_NAME_IS_FRONT_FACE,
+        D3D10_NAME_SAMPLE_INDEX	= D3D_NAME_SAMPLE_INDEX,
+        D3D10_NAME_TARGET	= D3D_NAME_TARGET,
+        D3D10_NAME_DEPTH	= D3D_NAME_DEPTH,
+        D3D10_NAME_COVERAGE	= D3D_NAME_COVERAGE,
+        D3D11_NAME_FINAL_QUAD_EDGE_TESSFACTOR	= D3D_NAME_FINAL_QUAD_EDGE_TESSFACTOR,
+        D3D11_NAME_FINAL_QUAD_INSIDE_TESSFACTOR	= D3D_NAME_FINAL_QUAD_INSIDE_TESSFACTOR,
+        D3D11_NAME_FINAL_TRI_EDGE_TESSFACTOR	= D3D_NAME_FINAL_TRI_EDGE_TESSFACTOR,
+        D3D11_NAME_FINAL_TRI_INSIDE_TESSFACTOR	= D3D_NAME_FINAL_TRI_INSIDE_TESSFACTOR,
+        D3D11_NAME_FINAL_LINE_DETAIL_TESSFACTOR	= D3D_NAME_FINAL_LINE_DETAIL_TESSFACTOR,
+        D3D11_NAME_FINAL_LINE_DENSITY_TESSFACTOR	= D3D_NAME_FINAL_LINE_DENSITY_TESSFACTOR,
+        D3D11_NAME_DEPTH_GREATER_EQUAL	= D3D_NAME_DEPTH_GREATER_EQUAL,
+        D3D11_NAME_DEPTH_LESS_EQUAL	= D3D_NAME_DEPTH_LESS_EQUAL,
+        D3D11_NAME_STENCIL_REF	= D3D_NAME_STENCIL_REF,
+        D3D11_NAME_INNER_COVERAGE	= D3D_NAME_INNER_COVERAGE,
+        D3D12_NAME_BARYCENTRICS	= D3D_NAME_BARYCENTRICS,
+        D3D12_NAME_SHADINGRATE	= D3D_NAME_SHADINGRATE,
+        D3D12_NAME_CULLPRIMITIVE	= D3D_NAME_CULLPRIMITIVE
+    } 	D3D_NAME;
+
+typedef 
+enum D3D_RESOURCE_RETURN_TYPE
+    {
+        D3D_RETURN_TYPE_UNORM	= 1,
+        D3D_RETURN_TYPE_SNORM	= 2,
+        D3D_RETURN_TYPE_SINT	= 3,
+        D3D_RETURN_TYPE_UINT	= 4,
+        D3D_RETURN_TYPE_FLOAT	= 5,
+        D3D_RETURN_TYPE_MIXED	= 6,
+        D3D_RETURN_TYPE_DOUBLE	= 7,
+        D3D_RETURN_TYPE_CONTINUED	= 8,
+        D3D10_RETURN_TYPE_UNORM	= D3D_RETURN_TYPE_UNORM,
+        D3D10_RETURN_TYPE_SNORM	= D3D_RETURN_TYPE_SNORM,
+        D3D10_RETURN_TYPE_SINT	= D3D_RETURN_TYPE_SINT,
+        D3D10_RETURN_TYPE_UINT	= D3D_RETURN_TYPE_UINT,
+        D3D10_RETURN_TYPE_FLOAT	= D3D_RETURN_TYPE_FLOAT,
+        D3D10_RETURN_TYPE_MIXED	= D3D_RETURN_TYPE_MIXED,
+        D3D11_RETURN_TYPE_UNORM	= D3D_RETURN_TYPE_UNORM,
+        D3D11_RETURN_TYPE_SNORM	= D3D_RETURN_TYPE_SNORM,
+        D3D11_RETURN_TYPE_SINT	= D3D_RETURN_TYPE_SINT,
+        D3D11_RETURN_TYPE_UINT	= D3D_RETURN_TYPE_UINT,
+        D3D11_RETURN_TYPE_FLOAT	= D3D_RETURN_TYPE_FLOAT,
+        D3D11_RETURN_TYPE_MIXED	= D3D_RETURN_TYPE_MIXED,
+        D3D11_RETURN_TYPE_DOUBLE	= D3D_RETURN_TYPE_DOUBLE,
+        D3D11_RETURN_TYPE_CONTINUED	= D3D_RETURN_TYPE_CONTINUED
+    } 	D3D_RESOURCE_RETURN_TYPE;
+
+typedef 
+enum D3D_REGISTER_COMPONENT_TYPE
+    {
+        D3D_REGISTER_COMPONENT_UNKNOWN	= 0,
+        D3D_REGISTER_COMPONENT_UINT32	= 1,
+        D3D_REGISTER_COMPONENT_SINT32	= 2,
+        D3D_REGISTER_COMPONENT_FLOAT32	= 3,
+        D3D10_REGISTER_COMPONENT_UNKNOWN	= D3D_REGISTER_COMPONENT_UNKNOWN,
+        D3D10_REGISTER_COMPONENT_UINT32	= D3D_REGISTER_COMPONENT_UINT32,
+        D3D10_REGISTER_COMPONENT_SINT32	= D3D_REGISTER_COMPONENT_SINT32,
+        D3D10_REGISTER_COMPONENT_FLOAT32	= D3D_REGISTER_COMPONENT_FLOAT32
+    } 	D3D_REGISTER_COMPONENT_TYPE;
+
+typedef 
+enum D3D_TESSELLATOR_DOMAIN
+    {
+        D3D_TESSELLATOR_DOMAIN_UNDEFINED	= 0,
+        D3D_TESSELLATOR_DOMAIN_ISOLINE	= 1,
+        D3D_TESSELLATOR_DOMAIN_TRI	= 2,
+        D3D_TESSELLATOR_DOMAIN_QUAD	= 3,
+        D3D11_TESSELLATOR_DOMAIN_UNDEFINED	= D3D_TESSELLATOR_DOMAIN_UNDEFINED,
+        D3D11_TESSELLATOR_DOMAIN_ISOLINE	= D3D_TESSELLATOR_DOMAIN_ISOLINE,
+        D3D11_TESSELLATOR_DOMAIN_TRI	= D3D_TESSELLATOR_DOMAIN_TRI,
+        D3D11_TESSELLATOR_DOMAIN_QUAD	= D3D_TESSELLATOR_DOMAIN_QUAD
+    } 	D3D_TESSELLATOR_DOMAIN;
+
+typedef 
+enum D3D_TESSELLATOR_PARTITIONING
+    {
+        D3D_TESSELLATOR_PARTITIONING_UNDEFINED	= 0,
+        D3D_TESSELLATOR_PARTITIONING_INTEGER	= 1,
+        D3D_TESSELLATOR_PARTITIONING_POW2	= 2,
+        D3D_TESSELLATOR_PARTITIONING_FRACTIONAL_ODD	= 3,
+        D3D_TESSELLATOR_PARTITIONING_FRACTIONAL_EVEN	= 4,
+        D3D11_TESSELLATOR_PARTITIONING_UNDEFINED	= D3D_TESSELLATOR_PARTITIONING_UNDEFINED,
+        D3D11_TESSELLATOR_PARTITIONING_INTEGER	= D3D_TESSELLATOR_PARTITIONING_INTEGER,
+        D3D11_TESSELLATOR_PARTITIONING_POW2	= D3D_TESSELLATOR_PARTITIONING_POW2,
+        D3D11_TESSELLATOR_PARTITIONING_FRACTIONAL_ODD	= D3D_TESSELLATOR_PARTITIONING_FRACTIONAL_ODD,
+        D3D11_TESSELLATOR_PARTITIONING_FRACTIONAL_EVEN	= D3D_TESSELLATOR_PARTITIONING_FRACTIONAL_EVEN
+    } 	D3D_TESSELLATOR_PARTITIONING;
+
+typedef 
+enum D3D_TESSELLATOR_OUTPUT_PRIMITIVE
+    {
+        D3D_TESSELLATOR_OUTPUT_UNDEFINED	= 0,
+        D3D_TESSELLATOR_OUTPUT_POINT	= 1,
+        D3D_TESSELLATOR_OUTPUT_LINE	= 2,
+        D3D_TESSELLATOR_OUTPUT_TRIANGLE_CW	= 3,
+        D3D_TESSELLATOR_OUTPUT_TRIANGLE_CCW	= 4,
+        D3D11_TESSELLATOR_OUTPUT_UNDEFINED	= D3D_TESSELLATOR_OUTPUT_UNDEFINED,
+        D3D11_TESSELLATOR_OUTPUT_POINT	= D3D_TESSELLATOR_OUTPUT_POINT,
+        D3D11_TESSELLATOR_OUTPUT_LINE	= D3D_TESSELLATOR_OUTPUT_LINE,
+        D3D11_TESSELLATOR_OUTPUT_TRIANGLE_CW	= D3D_TESSELLATOR_OUTPUT_TRIANGLE_CW,
+        D3D11_TESSELLATOR_OUTPUT_TRIANGLE_CCW	= D3D_TESSELLATOR_OUTPUT_TRIANGLE_CCW
+    } 	D3D_TESSELLATOR_OUTPUT_PRIMITIVE;
+
+typedef 
+enum D3D_MIN_PRECISION
+    {
+        D3D_MIN_PRECISION_DEFAULT	= 0,
+        D3D_MIN_PRECISION_FLOAT_16	= 1,
+        D3D_MIN_PRECISION_FLOAT_2_8	= 2,
+        D3D_MIN_PRECISION_RESERVED	= 3,
+        D3D_MIN_PRECISION_SINT_16	= 4,
+        D3D_MIN_PRECISION_UINT_16	= 5,
+        D3D_MIN_PRECISION_ANY_16	= 0xf0,
+        D3D_MIN_PRECISION_ANY_10	= 0xf1
+    } 	D3D_MIN_PRECISION;
+
+typedef 
+enum D3D_INTERPOLATION_MODE
+    {
+        D3D_INTERPOLATION_UNDEFINED	= 0,
+        D3D_INTERPOLATION_CONSTANT	= 1,
+        D3D_INTERPOLATION_LINEAR	= 2,
+        D3D_INTERPOLATION_LINEAR_CENTROID	= 3,
+        D3D_INTERPOLATION_LINEAR_NOPERSPECTIVE	= 4,
+        D3D_INTERPOLATION_LINEAR_NOPERSPECTIVE_CENTROID	= 5,
+        D3D_INTERPOLATION_LINEAR_SAMPLE	= 6,
+        D3D_INTERPOLATION_LINEAR_NOPERSPECTIVE_SAMPLE	= 7
+    } 	D3D_INTERPOLATION_MODE;
+
+typedef 
+enum _D3D_PARAMETER_FLAGS
+    {
+        D3D_PF_NONE	= 0,
+        D3D_PF_IN	= 0x1,
+        D3D_PF_OUT	= 0x2,
+        D3D_PF_FORCE_DWORD	= 0x7fffffff
+    } 	D3D_PARAMETER_FLAGS;
+
+typedef 
+enum D3D_FORMAT_LAYOUT
+    {
+        D3DFL_STANDARD	= 0,
+        D3DFL_CUSTOM	= -1
+    } 	D3D_FORMAT_LAYOUT;
+
+typedef 
+enum D3D_FORMAT_TYPE_LEVEL
+    {
+        D3DFTL_NO_TYPE	= 0,
+        D3DFTL_PARTIAL_TYPE	= -2,
+        D3DFTL_FULL_TYPE	= -1
+    } 	D3D_FORMAT_TYPE_LEVEL;
+
+typedef 
+enum D3D_FORMAT_COMPONENT_NAME
+    {
+        D3DFCN_R	= -4,
+        D3DFCN_G	= -3,
+        D3DFCN_B	= -2,
+        D3DFCN_A	= -1,
+        D3DFCN_D	= 0,
+        D3DFCN_S	= 1,
+        D3DFCN_X	= 2
+    } 	D3D_FORMAT_COMPONENT_NAME;
+
+typedef 
+enum D3D_FORMAT_COMPONENT_INTERPRETATION
+    {
+        D3DFCI_TYPELESS	= 0,
+        D3DFCI_FLOAT	= -4,
+        D3DFCI_SNORM	= -3,
+        D3DFCI_UNORM	= -2,
+        D3DFCI_SINT	= -1,
+        D3DFCI_UINT	= 1,
+        D3DFCI_UNORM_SRGB	= 2,
+        D3DFCI_BIASED_FIXED_2_8	= 3
+    } 	D3D_FORMAT_COMPONENT_INTERPRETATION;
+
+DEFINE_GUID(WKPDID_D3DDebugObjectName,0x429b8c22,0x9188,0x4b0c,0x87,0x42,0xac,0xb0,0xbf,0x85,0xc2,0x00);
+DEFINE_GUID(WKPDID_D3DDebugObjectNameW,0x4cca5fd8,0x921f,0x42c8,0x85,0x66,0x70,0xca,0xf2,0xa9,0xb7,0x41);
+DEFINE_GUID(WKPDID_CommentStringW,0xd0149dc0,0x90e8,0x4ec8,0x81, 0x44, 0xe9, 0x00, 0xad, 0x26, 0x6b, 0xb2);
+DEFINE_GUID(WKPDID_D3D12UniqueObjectId, 0x1b39de15, 0xec04, 0x4bae, 0xba, 0x4d, 0x8c, 0xef, 0x79, 0xfc, 0x04, 0xc1);
+#define D3D_SET_OBJECT_NAME_N_A(pObject, Chars, pName) (pObject)->SetPrivateData(WKPDID_D3DDebugObjectName, Chars, pName)
+#define D3D_SET_OBJECT_NAME_A(pObject, pName) D3D_SET_OBJECT_NAME_N_A(pObject, lstrlenA(pName), pName)
+#define D3D_SET_OBJECT_NAME_N_W(pObject, Chars, pName) (pObject)->SetPrivateData(WKPDID_D3DDebugObjectNameW, Chars*2, pName)
+#define D3D_SET_OBJECT_NAME_W(pObject, pName) D3D_SET_OBJECT_NAME_N_W(pObject, wcslen(pName), pName)
+#define D3D_COMPONENT_MASK_X   1
+#define D3D_COMPONENT_MASK_Y   2
+#define D3D_COMPONENT_MASK_Z   4
+#define D3D_COMPONENT_MASK_W   8
+DEFINE_GUID(D3D_TEXTURE_LAYOUT_ROW_MAJOR,0xb5dc234f,0x72bb,0x4bec,0x97,0x05,0x8c,0xf2,0x58,0xdf,0x6b,0x6c);
+DEFINE_GUID(D3D_TEXTURE_LAYOUT_64KB_STANDARD_SWIZZLE,0x4c0f29e3,0x3f5f,0x4d35,0x84,0xc9,0xbc,0x09,0x83,0xb6,0x2c,0x28);
+
+
+extern RPC_IF_HANDLE __MIDL_itf_d3dcommon_0000_0002_v0_0_c_ifspec;
+extern RPC_IF_HANDLE __MIDL_itf_d3dcommon_0000_0002_v0_0_s_ifspec;
+
+/* Additional Prototypes for ALL interfaces */
+
+/* end of Additional Prototypes */
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+
+
diff --git a/thirdparty/directx_headers/d3dx12.h b/thirdparty/directx_headers/d3dx12.h
new file mode 100644
index 0000000000..bbe273d333
--- /dev/null
+++ b/thirdparty/directx_headers/d3dx12.h
@@ -0,0 +1,5459 @@
+//*********************************************************
+//
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License (MIT).
+//
+//*********************************************************
+
+#ifndef __D3DX12_H__
+#define __D3DX12_H__
+
+#include "d3d12.h"
+
+#if defined( __cplusplus )
+
+struct CD3DX12_DEFAULT {};
+extern const DECLSPEC_SELECTANY CD3DX12_DEFAULT D3D12_DEFAULT;
+
+//------------------------------------------------------------------------------------------------
+inline bool operator==( const D3D12_VIEWPORT& l, const D3D12_VIEWPORT& r ) noexcept
+{
+    return l.TopLeftX == r.TopLeftX && l.TopLeftY == r.TopLeftY && l.Width == r.Width &&
+        l.Height == r.Height && l.MinDepth == r.MinDepth && l.MaxDepth == r.MaxDepth;
+}
+
+//------------------------------------------------------------------------------------------------
+inline bool operator!=( const D3D12_VIEWPORT& l, const D3D12_VIEWPORT& r ) noexcept
+{ return !( l == r ); }
+
+//------------------------------------------------------------------------------------------------
+struct CD3DX12_RECT : public D3D12_RECT
+{
+    CD3DX12_RECT() = default;
+    explicit CD3DX12_RECT( const D3D12_RECT& o ) noexcept :
+        D3D12_RECT( o )
+    {}
+    explicit CD3DX12_RECT(
+        LONG Left,
+        LONG Top,
+        LONG Right,
+        LONG Bottom ) noexcept
+    {
+        left = Left;
+        top = Top;
+        right = Right;
+        bottom = Bottom;
+    }
+};
+
+//------------------------------------------------------------------------------------------------
+struct CD3DX12_VIEWPORT : public D3D12_VIEWPORT
+{
+    CD3DX12_VIEWPORT() = default;
+    explicit CD3DX12_VIEWPORT( const D3D12_VIEWPORT& o ) noexcept :
+        D3D12_VIEWPORT( o )
+    {}
+    explicit CD3DX12_VIEWPORT(
+        FLOAT topLeftX,
+        FLOAT topLeftY,
+        FLOAT width,
+        FLOAT height,
+        FLOAT minDepth = D3D12_MIN_DEPTH,
+        FLOAT maxDepth = D3D12_MAX_DEPTH ) noexcept
+    {
+        TopLeftX = topLeftX;
+        TopLeftY = topLeftY;
+        Width = width;
+        Height = height;
+        MinDepth = minDepth;
+        MaxDepth = maxDepth;
+    }
+    explicit CD3DX12_VIEWPORT(
+        _In_ ID3D12Resource* pResource,
+        UINT mipSlice = 0,
+        FLOAT topLeftX = 0.0f,
+        FLOAT topLeftY = 0.0f,
+        FLOAT minDepth = D3D12_MIN_DEPTH,
+        FLOAT maxDepth = D3D12_MAX_DEPTH ) noexcept
+    {
+        const auto Desc = pResource->GetDesc();
+        const UINT64 SubresourceWidth = Desc.Width >> mipSlice;
+        const UINT64 SubresourceHeight = Desc.Height >> mipSlice;
+        switch (Desc.Dimension)
+        {
+        case D3D12_RESOURCE_DIMENSION_BUFFER:
+            TopLeftX = topLeftX;
+            TopLeftY = 0.0f;
+            Width = float(Desc.Width) - topLeftX;
+            Height = 1.0f;
+            break;
+        case D3D12_RESOURCE_DIMENSION_TEXTURE1D:
+            TopLeftX = topLeftX;
+            TopLeftY = 0.0f;
+            Width = (SubresourceWidth ? float(SubresourceWidth) : 1.0f) - topLeftX;
+            Height = 1.0f;
+            break;
+        case D3D12_RESOURCE_DIMENSION_TEXTURE2D:
+        case D3D12_RESOURCE_DIMENSION_TEXTURE3D:
+            TopLeftX = topLeftX;
+            TopLeftY = topLeftY;
+            Width = (SubresourceWidth ? float(SubresourceWidth) : 1.0f) - topLeftX;
+            Height = (SubresourceHeight ? float(SubresourceHeight) : 1.0f) - topLeftY;
+            break;
+        default: break;
+        }
+
+        MinDepth = minDepth;
+        MaxDepth = maxDepth;
+    }
+};
+
+//------------------------------------------------------------------------------------------------
+struct CD3DX12_BOX : public D3D12_BOX
+{
+    CD3DX12_BOX() = default;
+    explicit CD3DX12_BOX( const D3D12_BOX& o ) noexcept :
+        D3D12_BOX( o )
+    {}
+    explicit CD3DX12_BOX(
+        LONG Left,
+        LONG Right ) noexcept
+    {
+        left = static_cast<UINT>(Left);
+        top = 0;
+        front = 0;
+        right = static_cast<UINT>(Right);
+        bottom = 1;
+        back = 1;
+    }
+    explicit CD3DX12_BOX(
+        LONG Left,
+        LONG Top,
+        LONG Right,
+        LONG Bottom ) noexcept
+    {
+        left = static_cast<UINT>(Left);
+        top = static_cast<UINT>(Top);
+        front = 0;
+        right = static_cast<UINT>(Right);
+        bottom = static_cast<UINT>(Bottom);
+        back = 1;
+    }
+    explicit CD3DX12_BOX(
+        LONG Left,
+        LONG Top,
+        LONG Front,
+        LONG Right,
+        LONG Bottom,
+        LONG Back ) noexcept
+    {
+        left = static_cast<UINT>(Left);
+        top = static_cast<UINT>(Top);
+        front = static_cast<UINT>(Front);
+        right = static_cast<UINT>(Right);
+        bottom = static_cast<UINT>(Bottom);
+        back = static_cast<UINT>(Back);
+    }
+};
+inline bool operator==( const D3D12_BOX& l, const D3D12_BOX& r ) noexcept
+{
+    return l.left == r.left && l.top == r.top && l.front == r.front &&
+        l.right == r.right && l.bottom == r.bottom && l.back == r.back;
+}
+inline bool operator!=( const D3D12_BOX& l, const D3D12_BOX& r ) noexcept
+{ return !( l == r ); }
+
+//------------------------------------------------------------------------------------------------
+struct CD3DX12_DEPTH_STENCIL_DESC : public D3D12_DEPTH_STENCIL_DESC
+{
+    CD3DX12_DEPTH_STENCIL_DESC() = default;
+    explicit CD3DX12_DEPTH_STENCIL_DESC( const D3D12_DEPTH_STENCIL_DESC& o ) noexcept :
+        D3D12_DEPTH_STENCIL_DESC( o )
+    {}
+    explicit CD3DX12_DEPTH_STENCIL_DESC( CD3DX12_DEFAULT ) noexcept
+    {
+        DepthEnable = TRUE;
+        DepthWriteMask = D3D12_DEPTH_WRITE_MASK_ALL;
+        DepthFunc = D3D12_COMPARISON_FUNC_LESS;
+        StencilEnable = FALSE;
+        StencilReadMask = D3D12_DEFAULT_STENCIL_READ_MASK;
+        StencilWriteMask = D3D12_DEFAULT_STENCIL_WRITE_MASK;
+        const D3D12_DEPTH_STENCILOP_DESC defaultStencilOp =
+        { D3D12_STENCIL_OP_KEEP, D3D12_STENCIL_OP_KEEP, D3D12_STENCIL_OP_KEEP, D3D12_COMPARISON_FUNC_ALWAYS };
+        FrontFace = defaultStencilOp;
+        BackFace = defaultStencilOp;
+    }
+    explicit CD3DX12_DEPTH_STENCIL_DESC(
+        BOOL depthEnable,
+        D3D12_DEPTH_WRITE_MASK depthWriteMask,
+        D3D12_COMPARISON_FUNC depthFunc,
+        BOOL stencilEnable,
+        UINT8 stencilReadMask,
+        UINT8 stencilWriteMask,
+        D3D12_STENCIL_OP frontStencilFailOp,
+        D3D12_STENCIL_OP frontStencilDepthFailOp,
+        D3D12_STENCIL_OP frontStencilPassOp,
+        D3D12_COMPARISON_FUNC frontStencilFunc,
+        D3D12_STENCIL_OP backStencilFailOp,
+        D3D12_STENCIL_OP backStencilDepthFailOp,
+        D3D12_STENCIL_OP backStencilPassOp,
+        D3D12_COMPARISON_FUNC backStencilFunc ) noexcept
+    {
+        DepthEnable = depthEnable;
+        DepthWriteMask = depthWriteMask;
+        DepthFunc = depthFunc;
+        StencilEnable = stencilEnable;
+        StencilReadMask = stencilReadMask;
+        StencilWriteMask = stencilWriteMask;
+        FrontFace.StencilFailOp = frontStencilFailOp;
+        FrontFace.StencilDepthFailOp = frontStencilDepthFailOp;
+        FrontFace.StencilPassOp = frontStencilPassOp;
+        FrontFace.StencilFunc = frontStencilFunc;
+        BackFace.StencilFailOp = backStencilFailOp;
+        BackFace.StencilDepthFailOp = backStencilDepthFailOp;
+        BackFace.StencilPassOp = backStencilPassOp;
+        BackFace.StencilFunc = backStencilFunc;
+    }
+};
+
+//------------------------------------------------------------------------------------------------
+struct CD3DX12_DEPTH_STENCIL_DESC1 : public D3D12_DEPTH_STENCIL_DESC1
+{
+    CD3DX12_DEPTH_STENCIL_DESC1() = default;
+    explicit CD3DX12_DEPTH_STENCIL_DESC1( const D3D12_DEPTH_STENCIL_DESC1& o ) noexcept :
+        D3D12_DEPTH_STENCIL_DESC1( o )
+    {}
+    explicit CD3DX12_DEPTH_STENCIL_DESC1( const D3D12_DEPTH_STENCIL_DESC& o ) noexcept
+    {
+        DepthEnable                  = o.DepthEnable;
+        DepthWriteMask               = o.DepthWriteMask;
+        DepthFunc                    = o.DepthFunc;
+        StencilEnable                = o.StencilEnable;
+        StencilReadMask              = o.StencilReadMask;
+        StencilWriteMask             = o.StencilWriteMask;
+        FrontFace.StencilFailOp      = o.FrontFace.StencilFailOp;
+        FrontFace.StencilDepthFailOp = o.FrontFace.StencilDepthFailOp;
+        FrontFace.StencilPassOp      = o.FrontFace.StencilPassOp;
+        FrontFace.StencilFunc        = o.FrontFace.StencilFunc;
+        BackFace.StencilFailOp       = o.BackFace.StencilFailOp;
+        BackFace.StencilDepthFailOp  = o.BackFace.StencilDepthFailOp;
+        BackFace.StencilPassOp       = o.BackFace.StencilPassOp;
+        BackFace.StencilFunc         = o.BackFace.StencilFunc;
+        DepthBoundsTestEnable        = FALSE;
+    }
+    explicit CD3DX12_DEPTH_STENCIL_DESC1( CD3DX12_DEFAULT ) noexcept
+    {
+        DepthEnable = TRUE;
+        DepthWriteMask = D3D12_DEPTH_WRITE_MASK_ALL;
+        DepthFunc = D3D12_COMPARISON_FUNC_LESS;
+        StencilEnable = FALSE;
+        StencilReadMask = D3D12_DEFAULT_STENCIL_READ_MASK;
+        StencilWriteMask = D3D12_DEFAULT_STENCIL_WRITE_MASK;
+        const D3D12_DEPTH_STENCILOP_DESC defaultStencilOp =
+        { D3D12_STENCIL_OP_KEEP, D3D12_STENCIL_OP_KEEP, D3D12_STENCIL_OP_KEEP, D3D12_COMPARISON_FUNC_ALWAYS };
+        FrontFace = defaultStencilOp;
+        BackFace = defaultStencilOp;
+        DepthBoundsTestEnable = FALSE;
+    }
+    explicit CD3DX12_DEPTH_STENCIL_DESC1(
+        BOOL depthEnable,
+        D3D12_DEPTH_WRITE_MASK depthWriteMask,
+        D3D12_COMPARISON_FUNC depthFunc,
+        BOOL stencilEnable,
+        UINT8 stencilReadMask,
+        UINT8 stencilWriteMask,
+        D3D12_STENCIL_OP frontStencilFailOp,
+        D3D12_STENCIL_OP frontStencilDepthFailOp,
+        D3D12_STENCIL_OP frontStencilPassOp,
+        D3D12_COMPARISON_FUNC frontStencilFunc,
+        D3D12_STENCIL_OP backStencilFailOp,
+        D3D12_STENCIL_OP backStencilDepthFailOp,
+        D3D12_STENCIL_OP backStencilPassOp,
+        D3D12_COMPARISON_FUNC backStencilFunc,
+        BOOL depthBoundsTestEnable ) noexcept
+    {
+        DepthEnable = depthEnable;
+        DepthWriteMask = depthWriteMask;
+        DepthFunc = depthFunc;
+        StencilEnable = stencilEnable;
+        StencilReadMask = stencilReadMask;
+        StencilWriteMask = stencilWriteMask;
+        FrontFace.StencilFailOp = frontStencilFailOp;
+        FrontFace.StencilDepthFailOp = frontStencilDepthFailOp;
+        FrontFace.StencilPassOp = frontStencilPassOp;
+        FrontFace.StencilFunc = frontStencilFunc;
+        BackFace.StencilFailOp = backStencilFailOp;
+        BackFace.StencilDepthFailOp = backStencilDepthFailOp;
+        BackFace.StencilPassOp = backStencilPassOp;
+        BackFace.StencilFunc = backStencilFunc;
+        DepthBoundsTestEnable = depthBoundsTestEnable;
+    }
+    operator D3D12_DEPTH_STENCIL_DESC() const noexcept
+    {
+        D3D12_DEPTH_STENCIL_DESC D;
+        D.DepthEnable                  = DepthEnable;
+        D.DepthWriteMask               = DepthWriteMask;
+        D.DepthFunc                    = DepthFunc;
+        D.StencilEnable                = StencilEnable;
+        D.StencilReadMask              = StencilReadMask;
+        D.StencilWriteMask             = StencilWriteMask;
+        D.FrontFace.StencilFailOp      = FrontFace.StencilFailOp;
+        D.FrontFace.StencilDepthFailOp = FrontFace.StencilDepthFailOp;
+        D.FrontFace.StencilPassOp      = FrontFace.StencilPassOp;
+        D.FrontFace.StencilFunc        = FrontFace.StencilFunc;
+        D.BackFace.StencilFailOp       = BackFace.StencilFailOp;
+        D.BackFace.StencilDepthFailOp  = BackFace.StencilDepthFailOp;
+        D.BackFace.StencilPassOp       = BackFace.StencilPassOp;
+        D.BackFace.StencilFunc         = BackFace.StencilFunc;
+        return D;
+    }
+};
+
+//------------------------------------------------------------------------------------------------
+struct CD3DX12_DEPTH_STENCIL_DESC2 : public D3D12_DEPTH_STENCIL_DESC2
+{
+    CD3DX12_DEPTH_STENCIL_DESC2() = default;
+    explicit CD3DX12_DEPTH_STENCIL_DESC2( const D3D12_DEPTH_STENCIL_DESC2& o ) noexcept :
+        D3D12_DEPTH_STENCIL_DESC2( o )
+    {}
+    explicit CD3DX12_DEPTH_STENCIL_DESC2( const D3D12_DEPTH_STENCIL_DESC1& o ) noexcept
+    {
+        DepthEnable                  = o.DepthEnable;
+        DepthWriteMask               = o.DepthWriteMask;
+        DepthFunc                    = o.DepthFunc;
+        StencilEnable                = o.StencilEnable;
+        FrontFace.StencilFailOp      = o.FrontFace.StencilFailOp;
+        FrontFace.StencilDepthFailOp = o.FrontFace.StencilDepthFailOp;
+        FrontFace.StencilPassOp      = o.FrontFace.StencilPassOp;
+        FrontFace.StencilFunc        = o.FrontFace.StencilFunc;
+        FrontFace.StencilReadMask    = o.StencilReadMask;
+        FrontFace.StencilWriteMask   = o.StencilWriteMask;
+
+        BackFace.StencilFailOp       = o.BackFace.StencilFailOp;
+        BackFace.StencilDepthFailOp  = o.BackFace.StencilDepthFailOp;
+        BackFace.StencilPassOp       = o.BackFace.StencilPassOp;
+        BackFace.StencilFunc         = o.BackFace.StencilFunc;
+        BackFace.StencilReadMask     = o.StencilReadMask;
+        BackFace.StencilWriteMask    = o.StencilWriteMask;
+        DepthBoundsTestEnable        = o.DepthBoundsTestEnable;
+    }
+    explicit CD3DX12_DEPTH_STENCIL_DESC2( const D3D12_DEPTH_STENCIL_DESC& o ) noexcept
+    {
+        DepthEnable                  = o.DepthEnable;
+        DepthWriteMask               = o.DepthWriteMask;
+        DepthFunc                    = o.DepthFunc;
+        StencilEnable                = o.StencilEnable;
+
+        FrontFace.StencilFailOp      = o.FrontFace.StencilFailOp;
+        FrontFace.StencilDepthFailOp = o.FrontFace.StencilDepthFailOp;
+        FrontFace.StencilPassOp      = o.FrontFace.StencilPassOp;
+        FrontFace.StencilFunc        = o.FrontFace.StencilFunc;
+        FrontFace.StencilReadMask    = o.StencilReadMask;
+        FrontFace.StencilWriteMask   = o.StencilWriteMask;
+
+        BackFace.StencilFailOp       = o.BackFace.StencilFailOp;
+        BackFace.StencilDepthFailOp  = o.BackFace.StencilDepthFailOp;
+        BackFace.StencilPassOp       = o.BackFace.StencilPassOp;
+        BackFace.StencilFunc         = o.BackFace.StencilFunc;
+        BackFace.StencilReadMask     = o.StencilReadMask;
+        BackFace.StencilWriteMask    = o.StencilWriteMask;
+
+        DepthBoundsTestEnable        = FALSE;
+    }
+    explicit CD3DX12_DEPTH_STENCIL_DESC2( CD3DX12_DEFAULT ) noexcept
+    {
+        DepthEnable = TRUE;
+        DepthWriteMask = D3D12_DEPTH_WRITE_MASK_ALL;
+        DepthFunc = D3D12_COMPARISON_FUNC_LESS;
+        StencilEnable = FALSE;
+        const D3D12_DEPTH_STENCILOP_DESC1 defaultStencilOp =
+        { D3D12_STENCIL_OP_KEEP, D3D12_STENCIL_OP_KEEP, D3D12_STENCIL_OP_KEEP, D3D12_COMPARISON_FUNC_ALWAYS, D3D12_DEFAULT_STENCIL_READ_MASK, D3D12_DEFAULT_STENCIL_WRITE_MASK };
+        FrontFace = defaultStencilOp;
+        BackFace = defaultStencilOp;
+        DepthBoundsTestEnable = FALSE;
+    }
+    explicit CD3DX12_DEPTH_STENCIL_DESC2(
+        BOOL depthEnable,
+        D3D12_DEPTH_WRITE_MASK depthWriteMask,
+        D3D12_COMPARISON_FUNC depthFunc,
+        BOOL stencilEnable,
+        D3D12_STENCIL_OP frontStencilFailOp,
+        D3D12_STENCIL_OP frontStencilDepthFailOp,
+        D3D12_STENCIL_OP frontStencilPassOp,
+        D3D12_COMPARISON_FUNC frontStencilFunc,
+        UINT8 frontStencilReadMask,
+        UINT8 frontStencilWriteMask,
+        D3D12_STENCIL_OP backStencilFailOp,
+        D3D12_STENCIL_OP backStencilDepthFailOp,
+        D3D12_STENCIL_OP backStencilPassOp,
+        D3D12_COMPARISON_FUNC backStencilFunc,
+        UINT8 backStencilReadMask,
+        UINT8 backStencilWriteMask,
+        BOOL depthBoundsTestEnable ) noexcept
+    {
+        DepthEnable = depthEnable;
+        DepthWriteMask = depthWriteMask;
+        DepthFunc = depthFunc;
+        StencilEnable = stencilEnable;
+
+        FrontFace.StencilFailOp = frontStencilFailOp;
+        FrontFace.StencilDepthFailOp = frontStencilDepthFailOp;
+        FrontFace.StencilPassOp = frontStencilPassOp;
+        FrontFace.StencilFunc = frontStencilFunc;
+        FrontFace.StencilReadMask = frontStencilReadMask;
+        FrontFace.StencilWriteMask = frontStencilWriteMask;
+
+        BackFace.StencilFailOp = backStencilFailOp;
+        BackFace.StencilDepthFailOp = backStencilDepthFailOp;
+        BackFace.StencilPassOp = backStencilPassOp;
+        BackFace.StencilFunc = backStencilFunc;
+        BackFace.StencilReadMask = backStencilReadMask;
+        BackFace.StencilWriteMask = backStencilWriteMask;
+
+        DepthBoundsTestEnable = depthBoundsTestEnable;
+    }
+
+    operator D3D12_DEPTH_STENCIL_DESC() const noexcept
+    {
+        D3D12_DEPTH_STENCIL_DESC D;
+        D.DepthEnable = DepthEnable;
+        D.DepthWriteMask = DepthWriteMask;
+        D.DepthFunc = DepthFunc;
+        D.StencilEnable = StencilEnable;
+        D.StencilReadMask = FrontFace.StencilReadMask;
+        D.StencilWriteMask = FrontFace.StencilWriteMask;
+        D.FrontFace.StencilFailOp = FrontFace.StencilFailOp;
+        D.FrontFace.StencilDepthFailOp = FrontFace.StencilDepthFailOp;
+        D.FrontFace.StencilPassOp = FrontFace.StencilPassOp;
+        D.FrontFace.StencilFunc = FrontFace.StencilFunc;
+        D.BackFace.StencilFailOp = BackFace.StencilFailOp;
+        D.BackFace.StencilDepthFailOp = BackFace.StencilDepthFailOp;
+        D.BackFace.StencilPassOp = BackFace.StencilPassOp;
+        D.BackFace.StencilFunc = BackFace.StencilFunc;
+        return D;
+    }
+};
+
+//------------------------------------------------------------------------------------------------
+struct CD3DX12_BLEND_DESC : public D3D12_BLEND_DESC
+{
+    CD3DX12_BLEND_DESC() = default;
+    explicit CD3DX12_BLEND_DESC( const D3D12_BLEND_DESC& o ) noexcept :
+        D3D12_BLEND_DESC( o )
+    {}
+    explicit CD3DX12_BLEND_DESC( CD3DX12_DEFAULT ) noexcept
+    {
+        AlphaToCoverageEnable = FALSE;
+        IndependentBlendEnable = FALSE;
+        const D3D12_RENDER_TARGET_BLEND_DESC defaultRenderTargetBlendDesc =
+        {
+            FALSE,FALSE,
+            D3D12_BLEND_ONE, D3D12_BLEND_ZERO, D3D12_BLEND_OP_ADD,
+            D3D12_BLEND_ONE, D3D12_BLEND_ZERO, D3D12_BLEND_OP_ADD,
+            D3D12_LOGIC_OP_NOOP,
+            D3D12_COLOR_WRITE_ENABLE_ALL,
+        };
+        for (UINT i = 0; i < D3D12_SIMULTANEOUS_RENDER_TARGET_COUNT; ++i)
+            RenderTarget[ i ] = defaultRenderTargetBlendDesc;
+    }
+};
+
+//------------------------------------------------------------------------------------------------
+struct CD3DX12_RASTERIZER_DESC : public D3D12_RASTERIZER_DESC
+{
+    CD3DX12_RASTERIZER_DESC() = default;
+    explicit CD3DX12_RASTERIZER_DESC( const D3D12_RASTERIZER_DESC& o ) noexcept :
+        D3D12_RASTERIZER_DESC( o )
+    {}
+    explicit CD3DX12_RASTERIZER_DESC( CD3DX12_DEFAULT ) noexcept
+    {
+        FillMode = D3D12_FILL_MODE_SOLID;
+        CullMode = D3D12_CULL_MODE_BACK;
+        FrontCounterClockwise = FALSE;
+        DepthBias = D3D12_DEFAULT_DEPTH_BIAS;
+        DepthBiasClamp = D3D12_DEFAULT_DEPTH_BIAS_CLAMP;
+        SlopeScaledDepthBias = D3D12_DEFAULT_SLOPE_SCALED_DEPTH_BIAS;
+        DepthClipEnable = TRUE;
+        MultisampleEnable = FALSE;
+        AntialiasedLineEnable = FALSE;
+        ForcedSampleCount = 0;
+        ConservativeRaster = D3D12_CONSERVATIVE_RASTERIZATION_MODE_OFF;
+    }
+    explicit CD3DX12_RASTERIZER_DESC(
+        D3D12_FILL_MODE fillMode,
+        D3D12_CULL_MODE cullMode,
+        BOOL frontCounterClockwise,
+        INT depthBias,
+        FLOAT depthBiasClamp,
+        FLOAT slopeScaledDepthBias,
+        BOOL depthClipEnable,
+        BOOL multisampleEnable,
+        BOOL antialiasedLineEnable,
+        UINT forcedSampleCount,
+        D3D12_CONSERVATIVE_RASTERIZATION_MODE conservativeRaster) noexcept
+    {
+        FillMode = fillMode;
+        CullMode = cullMode;
+        FrontCounterClockwise = frontCounterClockwise;
+        DepthBias = depthBias;
+        DepthBiasClamp = depthBiasClamp;
+        SlopeScaledDepthBias = slopeScaledDepthBias;
+        DepthClipEnable = depthClipEnable;
+        MultisampleEnable = multisampleEnable;
+        AntialiasedLineEnable = antialiasedLineEnable;
+        ForcedSampleCount = forcedSampleCount;
+        ConservativeRaster = conservativeRaster;
+    }
+};
+
+//------------------------------------------------------------------------------------------------
+struct CD3DX12_RESOURCE_ALLOCATION_INFO : public D3D12_RESOURCE_ALLOCATION_INFO
+{
+    CD3DX12_RESOURCE_ALLOCATION_INFO() = default;
+    explicit CD3DX12_RESOURCE_ALLOCATION_INFO( const D3D12_RESOURCE_ALLOCATION_INFO& o ) noexcept :
+        D3D12_RESOURCE_ALLOCATION_INFO( o )
+    {}
+    CD3DX12_RESOURCE_ALLOCATION_INFO(
+        UINT64 size,
+        UINT64 alignment ) noexcept
+    {
+        SizeInBytes = size;
+        Alignment = alignment;
+    }
+};
+
+//------------------------------------------------------------------------------------------------
+struct CD3DX12_HEAP_PROPERTIES : public D3D12_HEAP_PROPERTIES
+{
+    CD3DX12_HEAP_PROPERTIES() = default;
+    explicit CD3DX12_HEAP_PROPERTIES(const D3D12_HEAP_PROPERTIES &o) noexcept :
+        D3D12_HEAP_PROPERTIES(o)
+    {}
+    CD3DX12_HEAP_PROPERTIES(
+        D3D12_CPU_PAGE_PROPERTY cpuPageProperty,
+        D3D12_MEMORY_POOL memoryPoolPreference,
+        UINT creationNodeMask = 1,
+        UINT nodeMask = 1 ) noexcept
+    {
+        Type = D3D12_HEAP_TYPE_CUSTOM;
+        CPUPageProperty = cpuPageProperty;
+        MemoryPoolPreference = memoryPoolPreference;
+        CreationNodeMask = creationNodeMask;
+        VisibleNodeMask = nodeMask;
+    }
+    explicit CD3DX12_HEAP_PROPERTIES(
+        D3D12_HEAP_TYPE type,
+        UINT creationNodeMask = 1,
+        UINT nodeMask = 1 ) noexcept
+    {
+        Type = type;
+        CPUPageProperty = D3D12_CPU_PAGE_PROPERTY_UNKNOWN;
+        MemoryPoolPreference = D3D12_MEMORY_POOL_UNKNOWN;
+        CreationNodeMask = creationNodeMask;
+        VisibleNodeMask = nodeMask;
+    }
+    bool IsCPUAccessible() const noexcept
+    {
+        return Type == D3D12_HEAP_TYPE_UPLOAD || Type == D3D12_HEAP_TYPE_READBACK || (Type == D3D12_HEAP_TYPE_CUSTOM &&
+            (CPUPageProperty == D3D12_CPU_PAGE_PROPERTY_WRITE_COMBINE || CPUPageProperty == D3D12_CPU_PAGE_PROPERTY_WRITE_BACK));
+    }
+};
+inline bool operator==( const D3D12_HEAP_PROPERTIES& l, const D3D12_HEAP_PROPERTIES& r ) noexcept
+{
+    return l.Type == r.Type && l.CPUPageProperty == r.CPUPageProperty &&
+        l.MemoryPoolPreference == r.MemoryPoolPreference &&
+        l.CreationNodeMask == r.CreationNodeMask &&
+        l.VisibleNodeMask == r.VisibleNodeMask;
+}
+inline bool operator!=( const D3D12_HEAP_PROPERTIES& l, const D3D12_HEAP_PROPERTIES& r ) noexcept
+{ return !( l == r ); }
+
+//------------------------------------------------------------------------------------------------
+struct CD3DX12_HEAP_DESC : public D3D12_HEAP_DESC
+{
+    CD3DX12_HEAP_DESC() = default;
+    explicit CD3DX12_HEAP_DESC(const D3D12_HEAP_DESC &o) noexcept :
+        D3D12_HEAP_DESC(o)
+    {}
+    CD3DX12_HEAP_DESC(
+        UINT64 size,
+        D3D12_HEAP_PROPERTIES properties,
+        UINT64 alignment = 0,
+        D3D12_HEAP_FLAGS flags = D3D12_HEAP_FLAG_NONE ) noexcept
+    {
+        SizeInBytes = size;
+        Properties = properties;
+        Alignment = alignment;
+        Flags = flags;
+    }
+    CD3DX12_HEAP_DESC(
+        UINT64 size,
+        D3D12_HEAP_TYPE type,
+        UINT64 alignment = 0,
+        D3D12_HEAP_FLAGS flags = D3D12_HEAP_FLAG_NONE ) noexcept
+    {
+        SizeInBytes = size;
+        Properties = CD3DX12_HEAP_PROPERTIES( type );
+        Alignment = alignment;
+        Flags = flags;
+    }
+    CD3DX12_HEAP_DESC(
+        UINT64 size,
+        D3D12_CPU_PAGE_PROPERTY cpuPageProperty,
+        D3D12_MEMORY_POOL memoryPoolPreference,
+        UINT64 alignment = 0,
+        D3D12_HEAP_FLAGS flags = D3D12_HEAP_FLAG_NONE ) noexcept
+    {
+        SizeInBytes = size;
+        Properties = CD3DX12_HEAP_PROPERTIES( cpuPageProperty, memoryPoolPreference );
+        Alignment = alignment;
+        Flags = flags;
+    }
+    CD3DX12_HEAP_DESC(
+        const D3D12_RESOURCE_ALLOCATION_INFO& resAllocInfo,
+        D3D12_HEAP_PROPERTIES properties,
+        D3D12_HEAP_FLAGS flags = D3D12_HEAP_FLAG_NONE ) noexcept
+    {
+        SizeInBytes = resAllocInfo.SizeInBytes;
+        Properties = properties;
+        Alignment = resAllocInfo.Alignment;
+        Flags = flags;
+    }
+    CD3DX12_HEAP_DESC(
+        const D3D12_RESOURCE_ALLOCATION_INFO& resAllocInfo,
+        D3D12_HEAP_TYPE type,
+        D3D12_HEAP_FLAGS flags = D3D12_HEAP_FLAG_NONE ) noexcept
+    {
+        SizeInBytes = resAllocInfo.SizeInBytes;
+        Properties = CD3DX12_HEAP_PROPERTIES( type );
+        Alignment = resAllocInfo.Alignment;
+        Flags = flags;
+    }
+    CD3DX12_HEAP_DESC(
+        const D3D12_RESOURCE_ALLOCATION_INFO& resAllocInfo,
+        D3D12_CPU_PAGE_PROPERTY cpuPageProperty,
+        D3D12_MEMORY_POOL memoryPoolPreference,
+        D3D12_HEAP_FLAGS flags = D3D12_HEAP_FLAG_NONE ) noexcept
+    {
+        SizeInBytes = resAllocInfo.SizeInBytes;
+        Properties = CD3DX12_HEAP_PROPERTIES( cpuPageProperty, memoryPoolPreference );
+        Alignment = resAllocInfo.Alignment;
+        Flags = flags;
+    }
+    bool IsCPUAccessible() const noexcept
+    { return static_cast< const CD3DX12_HEAP_PROPERTIES* >( &Properties )->IsCPUAccessible(); }
+};
+inline bool operator==( const D3D12_HEAP_DESC& l, const D3D12_HEAP_DESC& r ) noexcept
+{
+    return l.SizeInBytes == r.SizeInBytes &&
+        l.Properties == r.Properties &&
+        l.Alignment == r.Alignment &&
+        l.Flags == r.Flags;
+}
+inline bool operator!=( const D3D12_HEAP_DESC& l, const D3D12_HEAP_DESC& r ) noexcept
+{ return !( l == r ); }
+
+//------------------------------------------------------------------------------------------------
+struct CD3DX12_CLEAR_VALUE : public D3D12_CLEAR_VALUE
+{
+    CD3DX12_CLEAR_VALUE() = default;
+    explicit CD3DX12_CLEAR_VALUE(const D3D12_CLEAR_VALUE &o) noexcept :
+        D3D12_CLEAR_VALUE(o)
+    {}
+    CD3DX12_CLEAR_VALUE(
+        DXGI_FORMAT format,
+        const FLOAT color[4] ) noexcept
+    {
+        Format = format;
+        memcpy( Color, color, sizeof( Color ) );
+    }
+    CD3DX12_CLEAR_VALUE(
+        DXGI_FORMAT format,
+        FLOAT depth,
+        UINT8 stencil ) noexcept
+    {
+        Format = format;
+        memset( &Color, 0, sizeof( Color ) );
+        /* Use memcpy to preserve NAN values */
+        memcpy( &DepthStencil.Depth, &depth, sizeof( depth ) );
+        DepthStencil.Stencil = stencil;
+    }
+};
+
+//------------------------------------------------------------------------------------------------
+struct CD3DX12_RANGE : public D3D12_RANGE
+{
+    CD3DX12_RANGE() = default;
+    explicit CD3DX12_RANGE(const D3D12_RANGE &o) noexcept :
+        D3D12_RANGE(o)
+    {}
+    CD3DX12_RANGE(
+        SIZE_T begin,
+        SIZE_T end ) noexcept
+    {
+        Begin = begin;
+        End = end;
+    }
+};
+
+//------------------------------------------------------------------------------------------------
+struct CD3DX12_RANGE_UINT64 : public D3D12_RANGE_UINT64
+{
+    CD3DX12_RANGE_UINT64() = default;
+    explicit CD3DX12_RANGE_UINT64(const D3D12_RANGE_UINT64 &o) noexcept :
+        D3D12_RANGE_UINT64(o)
+    {}
+    CD3DX12_RANGE_UINT64(
+        UINT64 begin,
+        UINT64 end ) noexcept
+    {
+        Begin = begin;
+        End = end;
+    }
+};
+
+//------------------------------------------------------------------------------------------------
+struct CD3DX12_SUBRESOURCE_RANGE_UINT64 : public D3D12_SUBRESOURCE_RANGE_UINT64
+{
+    CD3DX12_SUBRESOURCE_RANGE_UINT64() = default;
+    explicit CD3DX12_SUBRESOURCE_RANGE_UINT64(const D3D12_SUBRESOURCE_RANGE_UINT64 &o) noexcept :
+        D3D12_SUBRESOURCE_RANGE_UINT64(o)
+    {}
+    CD3DX12_SUBRESOURCE_RANGE_UINT64(
+        UINT subresource,
+        const D3D12_RANGE_UINT64& range ) noexcept
+    {
+        Subresource = subresource;
+        Range = range;
+    }
+    CD3DX12_SUBRESOURCE_RANGE_UINT64(
+        UINT subresource,
+        UINT64 begin,
+        UINT64 end ) noexcept
+    {
+        Subresource = subresource;
+        Range.Begin = begin;
+        Range.End = end;
+    }
+};
+
+//------------------------------------------------------------------------------------------------
+struct CD3DX12_SHADER_BYTECODE : public D3D12_SHADER_BYTECODE
+{
+    CD3DX12_SHADER_BYTECODE() = default;
+    explicit CD3DX12_SHADER_BYTECODE(const D3D12_SHADER_BYTECODE &o) noexcept :
+        D3D12_SHADER_BYTECODE(o)
+    {}
+    CD3DX12_SHADER_BYTECODE(
+        _In_ ID3DBlob* pShaderBlob ) noexcept
+    {
+        pShaderBytecode = pShaderBlob->GetBufferPointer();
+        BytecodeLength = pShaderBlob->GetBufferSize();
+    }
+    CD3DX12_SHADER_BYTECODE(
+        const void* _pShaderBytecode,
+        SIZE_T bytecodeLength ) noexcept
+    {
+        pShaderBytecode = _pShaderBytecode;
+        BytecodeLength = bytecodeLength;
+    }
+};
+
+//------------------------------------------------------------------------------------------------
+struct CD3DX12_TILED_RESOURCE_COORDINATE : public D3D12_TILED_RESOURCE_COORDINATE
+{
+    CD3DX12_TILED_RESOURCE_COORDINATE() = default;
+    explicit CD3DX12_TILED_RESOURCE_COORDINATE(const D3D12_TILED_RESOURCE_COORDINATE &o) noexcept :
+        D3D12_TILED_RESOURCE_COORDINATE(o)
+    {}
+    CD3DX12_TILED_RESOURCE_COORDINATE(
+        UINT x,
+        UINT y,
+        UINT z,
+        UINT subresource ) noexcept
+    {
+        X = x;
+        Y = y;
+        Z = z;
+        Subresource = subresource;
+    }
+};
+
+//------------------------------------------------------------------------------------------------
+struct CD3DX12_TILE_REGION_SIZE : public D3D12_TILE_REGION_SIZE
+{
+    CD3DX12_TILE_REGION_SIZE() = default;
+    explicit CD3DX12_TILE_REGION_SIZE(const D3D12_TILE_REGION_SIZE &o) noexcept :
+        D3D12_TILE_REGION_SIZE(o)
+    {}
+    CD3DX12_TILE_REGION_SIZE(
+        UINT numTiles,
+        BOOL useBox,
+        UINT width,
+        UINT16 height,
+        UINT16 depth ) noexcept
+    {
+        NumTiles = numTiles;
+        UseBox = useBox;
+        Width = width;
+        Height = height;
+        Depth = depth;
+    }
+};
+
+//------------------------------------------------------------------------------------------------
+struct CD3DX12_SUBRESOURCE_TILING : public D3D12_SUBRESOURCE_TILING
+{
+    CD3DX12_SUBRESOURCE_TILING() = default;
+    explicit CD3DX12_SUBRESOURCE_TILING(const D3D12_SUBRESOURCE_TILING &o) noexcept :
+        D3D12_SUBRESOURCE_TILING(o)
+    {}
+    CD3DX12_SUBRESOURCE_TILING(
+        UINT widthInTiles,
+        UINT16 heightInTiles,
+        UINT16 depthInTiles,
+        UINT startTileIndexInOverallResource ) noexcept
+    {
+        WidthInTiles = widthInTiles;
+        HeightInTiles = heightInTiles;
+        DepthInTiles = depthInTiles;
+        StartTileIndexInOverallResource = startTileIndexInOverallResource;
+    }
+};
+
+//------------------------------------------------------------------------------------------------
+struct CD3DX12_TILE_SHAPE : public D3D12_TILE_SHAPE
+{
+    CD3DX12_TILE_SHAPE() = default;
+    explicit CD3DX12_TILE_SHAPE(const D3D12_TILE_SHAPE &o) noexcept :
+        D3D12_TILE_SHAPE(o)
+    {}
+    CD3DX12_TILE_SHAPE(
+        UINT widthInTexels,
+        UINT heightInTexels,
+        UINT depthInTexels ) noexcept
+    {
+        WidthInTexels = widthInTexels;
+        HeightInTexels = heightInTexels;
+        DepthInTexels = depthInTexels;
+    }
+};
+
+//------------------------------------------------------------------------------------------------
+struct CD3DX12_RESOURCE_BARRIER : public D3D12_RESOURCE_BARRIER
+{
+    CD3DX12_RESOURCE_BARRIER() = default;
+    explicit CD3DX12_RESOURCE_BARRIER(const D3D12_RESOURCE_BARRIER &o) noexcept :
+        D3D12_RESOURCE_BARRIER(o)
+    {}
+    static inline CD3DX12_RESOURCE_BARRIER Transition(
+        _In_ ID3D12Resource* pResource,
+        D3D12_RESOURCE_STATES stateBefore,
+        D3D12_RESOURCE_STATES stateAfter,
+        UINT subresource = D3D12_RESOURCE_BARRIER_ALL_SUBRESOURCES,
+        D3D12_RESOURCE_BARRIER_FLAGS flags = D3D12_RESOURCE_BARRIER_FLAG_NONE) noexcept
+    {
+        CD3DX12_RESOURCE_BARRIER result = {};
+        D3D12_RESOURCE_BARRIER &barrier = result;
+        result.Type = D3D12_RESOURCE_BARRIER_TYPE_TRANSITION;
+        result.Flags = flags;
+        barrier.Transition.pResource = pResource;
+        barrier.Transition.StateBefore = stateBefore;
+        barrier.Transition.StateAfter = stateAfter;
+        barrier.Transition.Subresource = subresource;
+        return result;
+    }
+    static inline CD3DX12_RESOURCE_BARRIER Aliasing(
+        _In_ ID3D12Resource* pResourceBefore,
+        _In_ ID3D12Resource* pResourceAfter) noexcept
+    {
+        CD3DX12_RESOURCE_BARRIER result = {};
+        D3D12_RESOURCE_BARRIER &barrier = result;
+        result.Type = D3D12_RESOURCE_BARRIER_TYPE_ALIASING;
+        barrier.Aliasing.pResourceBefore = pResourceBefore;
+        barrier.Aliasing.pResourceAfter = pResourceAfter;
+        return result;
+    }
+    static inline CD3DX12_RESOURCE_BARRIER UAV(
+        _In_ ID3D12Resource* pResource) noexcept
+    {
+        CD3DX12_RESOURCE_BARRIER result = {};
+        D3D12_RESOURCE_BARRIER &barrier = result;
+        result.Type = D3D12_RESOURCE_BARRIER_TYPE_UAV;
+        barrier.UAV.pResource = pResource;
+        return result;
+    }
+};
+
+//------------------------------------------------------------------------------------------------
+struct CD3DX12_PACKED_MIP_INFO : public D3D12_PACKED_MIP_INFO
+{
+    CD3DX12_PACKED_MIP_INFO() = default;
+    explicit CD3DX12_PACKED_MIP_INFO(const D3D12_PACKED_MIP_INFO &o) noexcept :
+        D3D12_PACKED_MIP_INFO(o)
+    {}
+    CD3DX12_PACKED_MIP_INFO(
+        UINT8 numStandardMips,
+        UINT8 numPackedMips,
+        UINT numTilesForPackedMips,
+        UINT startTileIndexInOverallResource ) noexcept
+    {
+        NumStandardMips = numStandardMips;
+        NumPackedMips = numPackedMips;
+        NumTilesForPackedMips = numTilesForPackedMips;
+        StartTileIndexInOverallResource = startTileIndexInOverallResource;
+    }
+};
+
+//------------------------------------------------------------------------------------------------
+struct CD3DX12_SUBRESOURCE_FOOTPRINT : public D3D12_SUBRESOURCE_FOOTPRINT
+{
+    CD3DX12_SUBRESOURCE_FOOTPRINT() = default;
+    explicit CD3DX12_SUBRESOURCE_FOOTPRINT(const D3D12_SUBRESOURCE_FOOTPRINT &o) noexcept :
+        D3D12_SUBRESOURCE_FOOTPRINT(o)
+    {}
+    CD3DX12_SUBRESOURCE_FOOTPRINT(
+        DXGI_FORMAT format,
+        UINT width,
+        UINT height,
+        UINT depth,
+        UINT rowPitch ) noexcept
+    {
+        Format = format;
+        Width = width;
+        Height = height;
+        Depth = depth;
+        RowPitch = rowPitch;
+    }
+    explicit CD3DX12_SUBRESOURCE_FOOTPRINT(
+        const D3D12_RESOURCE_DESC& resDesc,
+        UINT rowPitch ) noexcept
+    {
+        Format = resDesc.Format;
+        Width = UINT( resDesc.Width );
+        Height = resDesc.Height;
+        Depth = (resDesc.Dimension == D3D12_RESOURCE_DIMENSION_TEXTURE3D ? resDesc.DepthOrArraySize : 1u);
+        RowPitch = rowPitch;
+    }
+};
+
+//------------------------------------------------------------------------------------------------
+struct CD3DX12_TEXTURE_COPY_LOCATION : public D3D12_TEXTURE_COPY_LOCATION
+{
+    CD3DX12_TEXTURE_COPY_LOCATION() = default;
+    explicit CD3DX12_TEXTURE_COPY_LOCATION(const D3D12_TEXTURE_COPY_LOCATION &o) noexcept :
+        D3D12_TEXTURE_COPY_LOCATION(o)
+    {}
+    CD3DX12_TEXTURE_COPY_LOCATION(_In_ ID3D12Resource* pRes) noexcept
+    {
+        pResource = pRes;
+        Type = D3D12_TEXTURE_COPY_TYPE_SUBRESOURCE_INDEX;
+        PlacedFootprint = {};
+    }
+    CD3DX12_TEXTURE_COPY_LOCATION(_In_ ID3D12Resource* pRes, D3D12_PLACED_SUBRESOURCE_FOOTPRINT const& Footprint) noexcept
+    {
+        pResource = pRes;
+        Type = D3D12_TEXTURE_COPY_TYPE_PLACED_FOOTPRINT;
+        PlacedFootprint = Footprint;
+    }
+    CD3DX12_TEXTURE_COPY_LOCATION(_In_ ID3D12Resource* pRes, UINT Sub) noexcept
+    {
+        pResource = pRes;
+        Type = D3D12_TEXTURE_COPY_TYPE_SUBRESOURCE_INDEX;
+        PlacedFootprint = {};
+        SubresourceIndex = Sub;
+    }
+};
+
+//------------------------------------------------------------------------------------------------
+struct CD3DX12_DESCRIPTOR_RANGE : public D3D12_DESCRIPTOR_RANGE
+{
+    CD3DX12_DESCRIPTOR_RANGE() = default;
+    explicit CD3DX12_DESCRIPTOR_RANGE(const D3D12_DESCRIPTOR_RANGE &o) noexcept :
+        D3D12_DESCRIPTOR_RANGE(o)
+    {}
+    CD3DX12_DESCRIPTOR_RANGE(
+        D3D12_DESCRIPTOR_RANGE_TYPE rangeType,
+        UINT numDescriptors,
+        UINT baseShaderRegister,
+        UINT registerSpace = 0,
+        UINT offsetInDescriptorsFromTableStart =
+        D3D12_DESCRIPTOR_RANGE_OFFSET_APPEND) noexcept
+    {
+        Init(rangeType, numDescriptors, baseShaderRegister, registerSpace, offsetInDescriptorsFromTableStart);
+    }
+
+    inline void Init(
+        D3D12_DESCRIPTOR_RANGE_TYPE rangeType,
+        UINT numDescriptors,
+        UINT baseShaderRegister,
+        UINT registerSpace = 0,
+        UINT offsetInDescriptorsFromTableStart =
+        D3D12_DESCRIPTOR_RANGE_OFFSET_APPEND) noexcept
+    {
+        Init(*this, rangeType, numDescriptors, baseShaderRegister, registerSpace, offsetInDescriptorsFromTableStart);
+    }
+
+    static inline void Init(
+        _Out_ D3D12_DESCRIPTOR_RANGE &range,
+        D3D12_DESCRIPTOR_RANGE_TYPE rangeType,
+        UINT numDescriptors,
+        UINT baseShaderRegister,
+        UINT registerSpace = 0,
+        UINT offsetInDescriptorsFromTableStart =
+        D3D12_DESCRIPTOR_RANGE_OFFSET_APPEND) noexcept
+    {
+        range.RangeType = rangeType;
+        range.NumDescriptors = numDescriptors;
+        range.BaseShaderRegister = baseShaderRegister;
+        range.RegisterSpace = registerSpace;
+        range.OffsetInDescriptorsFromTableStart = offsetInDescriptorsFromTableStart;
+    }
+};
+
+//------------------------------------------------------------------------------------------------
+struct CD3DX12_ROOT_DESCRIPTOR_TABLE : public D3D12_ROOT_DESCRIPTOR_TABLE
+{
+    CD3DX12_ROOT_DESCRIPTOR_TABLE() = default;
+    explicit CD3DX12_ROOT_DESCRIPTOR_TABLE(const D3D12_ROOT_DESCRIPTOR_TABLE &o) noexcept :
+        D3D12_ROOT_DESCRIPTOR_TABLE(o)
+    {}
+    CD3DX12_ROOT_DESCRIPTOR_TABLE(
+        UINT numDescriptorRanges,
+        _In_reads_opt_(numDescriptorRanges) const D3D12_DESCRIPTOR_RANGE* _pDescriptorRanges) noexcept
+    {
+        Init(numDescriptorRanges, _pDescriptorRanges);
+    }
+
+    inline void Init(
+        UINT numDescriptorRanges,
+        _In_reads_opt_(numDescriptorRanges) const D3D12_DESCRIPTOR_RANGE* _pDescriptorRanges) noexcept
+    {
+        Init(*this, numDescriptorRanges, _pDescriptorRanges);
+    }
+
+    static inline void Init(
+        _Out_ D3D12_ROOT_DESCRIPTOR_TABLE &rootDescriptorTable,
+        UINT numDescriptorRanges,
+        _In_reads_opt_(numDescriptorRanges) const D3D12_DESCRIPTOR_RANGE* _pDescriptorRanges) noexcept
+    {
+        rootDescriptorTable.NumDescriptorRanges = numDescriptorRanges;
+        rootDescriptorTable.pDescriptorRanges = _pDescriptorRanges;
+    }
+};
+
+//------------------------------------------------------------------------------------------------
+struct CD3DX12_ROOT_CONSTANTS : public D3D12_ROOT_CONSTANTS
+{
+    CD3DX12_ROOT_CONSTANTS() = default;
+    explicit CD3DX12_ROOT_CONSTANTS(const D3D12_ROOT_CONSTANTS &o) noexcept :
+        D3D12_ROOT_CONSTANTS(o)
+    {}
+    CD3DX12_ROOT_CONSTANTS(
+        UINT num32BitValues,
+        UINT shaderRegister,
+        UINT registerSpace = 0) noexcept
+    {
+        Init(num32BitValues, shaderRegister, registerSpace);
+    }
+
+    inline void Init(
+        UINT num32BitValues,
+        UINT shaderRegister,
+        UINT registerSpace = 0) noexcept
+    {
+        Init(*this, num32BitValues, shaderRegister, registerSpace);
+    }
+
+    static inline void Init(
+        _Out_ D3D12_ROOT_CONSTANTS &rootConstants,
+        UINT num32BitValues,
+        UINT shaderRegister,
+        UINT registerSpace = 0) noexcept
+    {
+        rootConstants.Num32BitValues = num32BitValues;
+        rootConstants.ShaderRegister = shaderRegister;
+        rootConstants.RegisterSpace = registerSpace;
+    }
+};
+
+//------------------------------------------------------------------------------------------------
+struct CD3DX12_ROOT_DESCRIPTOR : public D3D12_ROOT_DESCRIPTOR
+{
+    CD3DX12_ROOT_DESCRIPTOR() = default;
+    explicit CD3DX12_ROOT_DESCRIPTOR(const D3D12_ROOT_DESCRIPTOR &o) noexcept :
+        D3D12_ROOT_DESCRIPTOR(o)
+    {}
+    CD3DX12_ROOT_DESCRIPTOR(
+        UINT shaderRegister,
+        UINT registerSpace = 0) noexcept
+    {
+        Init(shaderRegister, registerSpace);
+    }
+
+    inline void Init(
+        UINT shaderRegister,
+        UINT registerSpace = 0) noexcept
+    {
+        Init(*this, shaderRegister, registerSpace);
+    }
+
+    static inline void Init(_Out_ D3D12_ROOT_DESCRIPTOR &table, UINT shaderRegister, UINT registerSpace = 0) noexcept
+    {
+        table.ShaderRegister = shaderRegister;
+        table.RegisterSpace = registerSpace;
+    }
+};
+
+//------------------------------------------------------------------------------------------------
+struct CD3DX12_ROOT_PARAMETER : public D3D12_ROOT_PARAMETER
+{
+    CD3DX12_ROOT_PARAMETER() = default;
+    explicit CD3DX12_ROOT_PARAMETER(const D3D12_ROOT_PARAMETER &o) noexcept :
+        D3D12_ROOT_PARAMETER(o)
+    {}
+
+    static inline void InitAsDescriptorTable(
+        _Out_ D3D12_ROOT_PARAMETER &rootParam,
+        UINT numDescriptorRanges,
+        _In_reads_(numDescriptorRanges) const D3D12_DESCRIPTOR_RANGE* pDescriptorRanges,
+        D3D12_SHADER_VISIBILITY visibility = D3D12_SHADER_VISIBILITY_ALL) noexcept
+    {
+        rootParam.ParameterType = D3D12_ROOT_PARAMETER_TYPE_DESCRIPTOR_TABLE;
+        rootParam.ShaderVisibility = visibility;
+        CD3DX12_ROOT_DESCRIPTOR_TABLE::Init(rootParam.DescriptorTable, numDescriptorRanges, pDescriptorRanges);
+    }
+
+    static inline void InitAsConstants(
+        _Out_ D3D12_ROOT_PARAMETER &rootParam,
+        UINT num32BitValues,
+        UINT shaderRegister,
+        UINT registerSpace = 0,
+        D3D12_SHADER_VISIBILITY visibility = D3D12_SHADER_VISIBILITY_ALL) noexcept
+    {
+        rootParam.ParameterType = D3D12_ROOT_PARAMETER_TYPE_32BIT_CONSTANTS;
+        rootParam.ShaderVisibility = visibility;
+        CD3DX12_ROOT_CONSTANTS::Init(rootParam.Constants, num32BitValues, shaderRegister, registerSpace);
+    }
+
+    static inline void InitAsConstantBufferView(
+        _Out_ D3D12_ROOT_PARAMETER &rootParam,
+        UINT shaderRegister,
+        UINT registerSpace = 0,
+        D3D12_SHADER_VISIBILITY visibility = D3D12_SHADER_VISIBILITY_ALL) noexcept
+    {
+        rootParam.ParameterType = D3D12_ROOT_PARAMETER_TYPE_CBV;
+        rootParam.ShaderVisibility = visibility;
+        CD3DX12_ROOT_DESCRIPTOR::Init(rootParam.Descriptor, shaderRegister, registerSpace);
+    }
+
+    static inline void InitAsShaderResourceView(
+        _Out_ D3D12_ROOT_PARAMETER &rootParam,
+        UINT shaderRegister,
+        UINT registerSpace = 0,
+        D3D12_SHADER_VISIBILITY visibility = D3D12_SHADER_VISIBILITY_ALL) noexcept
+    {
+        rootParam.ParameterType = D3D12_ROOT_PARAMETER_TYPE_SRV;
+        rootParam.ShaderVisibility = visibility;
+        CD3DX12_ROOT_DESCRIPTOR::Init(rootParam.Descriptor, shaderRegister, registerSpace);
+    }
+
+    static inline void InitAsUnorderedAccessView(
+        _Out_ D3D12_ROOT_PARAMETER &rootParam,
+        UINT shaderRegister,
+        UINT registerSpace = 0,
+        D3D12_SHADER_VISIBILITY visibility = D3D12_SHADER_VISIBILITY_ALL) noexcept
+    {
+        rootParam.ParameterType = D3D12_ROOT_PARAMETER_TYPE_UAV;
+        rootParam.ShaderVisibility = visibility;
+        CD3DX12_ROOT_DESCRIPTOR::Init(rootParam.Descriptor, shaderRegister, registerSpace);
+    }
+
+    inline void InitAsDescriptorTable(
+        UINT numDescriptorRanges,
+        _In_reads_(numDescriptorRanges) const D3D12_DESCRIPTOR_RANGE* pDescriptorRanges,
+        D3D12_SHADER_VISIBILITY visibility = D3D12_SHADER_VISIBILITY_ALL) noexcept
+    {
+        InitAsDescriptorTable(*this, numDescriptorRanges, pDescriptorRanges, visibility);
+    }
+
+    inline void InitAsConstants(
+        UINT num32BitValues,
+        UINT shaderRegister,
+        UINT registerSpace = 0,
+        D3D12_SHADER_VISIBILITY visibility = D3D12_SHADER_VISIBILITY_ALL) noexcept
+    {
+        InitAsConstants(*this, num32BitValues, shaderRegister, registerSpace, visibility);
+    }
+
+    inline void InitAsConstantBufferView(
+        UINT shaderRegister,
+        UINT registerSpace = 0,
+        D3D12_SHADER_VISIBILITY visibility = D3D12_SHADER_VISIBILITY_ALL) noexcept
+    {
+        InitAsConstantBufferView(*this, shaderRegister, registerSpace, visibility);
+    }
+
+    inline void InitAsShaderResourceView(
+        UINT shaderRegister,
+        UINT registerSpace = 0,
+        D3D12_SHADER_VISIBILITY visibility = D3D12_SHADER_VISIBILITY_ALL) noexcept
+    {
+        InitAsShaderResourceView(*this, shaderRegister, registerSpace, visibility);
+    }
+
+    inline void InitAsUnorderedAccessView(
+        UINT shaderRegister,
+        UINT registerSpace = 0,
+        D3D12_SHADER_VISIBILITY visibility = D3D12_SHADER_VISIBILITY_ALL) noexcept
+    {
+        InitAsUnorderedAccessView(*this, shaderRegister, registerSpace, visibility);
+    }
+};
+
+//------------------------------------------------------------------------------------------------
+struct CD3DX12_STATIC_SAMPLER_DESC : public D3D12_STATIC_SAMPLER_DESC
+{
+    CD3DX12_STATIC_SAMPLER_DESC() = default;
+    explicit CD3DX12_STATIC_SAMPLER_DESC(const D3D12_STATIC_SAMPLER_DESC &o) noexcept :
+        D3D12_STATIC_SAMPLER_DESC(o)
+    {}
+    CD3DX12_STATIC_SAMPLER_DESC(
+         UINT shaderRegister,
+         D3D12_FILTER filter = D3D12_FILTER_ANISOTROPIC,
+         D3D12_TEXTURE_ADDRESS_MODE addressU = D3D12_TEXTURE_ADDRESS_MODE_WRAP,
+         D3D12_TEXTURE_ADDRESS_MODE addressV = D3D12_TEXTURE_ADDRESS_MODE_WRAP,
+         D3D12_TEXTURE_ADDRESS_MODE addressW = D3D12_TEXTURE_ADDRESS_MODE_WRAP,
+         FLOAT mipLODBias = 0,
+         UINT maxAnisotropy = 16,
+         D3D12_COMPARISON_FUNC comparisonFunc = D3D12_COMPARISON_FUNC_LESS_EQUAL,
+         D3D12_STATIC_BORDER_COLOR borderColor = D3D12_STATIC_BORDER_COLOR_OPAQUE_WHITE,
+         FLOAT minLOD = 0.f,
+         FLOAT maxLOD = D3D12_FLOAT32_MAX,
+         D3D12_SHADER_VISIBILITY shaderVisibility = D3D12_SHADER_VISIBILITY_ALL,
+         UINT registerSpace = 0) noexcept
+    {
+        Init(
+            shaderRegister,
+            filter,
+            addressU,
+            addressV,
+            addressW,
+            mipLODBias,
+            maxAnisotropy,
+            comparisonFunc,
+            borderColor,
+            minLOD,
+            maxLOD,
+            shaderVisibility,
+            registerSpace);
+    }
+
+    static inline void Init(
+        _Out_ D3D12_STATIC_SAMPLER_DESC &samplerDesc,
+         UINT shaderRegister,
+         D3D12_FILTER filter = D3D12_FILTER_ANISOTROPIC,
+         D3D12_TEXTURE_ADDRESS_MODE addressU = D3D12_TEXTURE_ADDRESS_MODE_WRAP,
+         D3D12_TEXTURE_ADDRESS_MODE addressV = D3D12_TEXTURE_ADDRESS_MODE_WRAP,
+         D3D12_TEXTURE_ADDRESS_MODE addressW = D3D12_TEXTURE_ADDRESS_MODE_WRAP,
+         FLOAT mipLODBias = 0,
+         UINT maxAnisotropy = 16,
+         D3D12_COMPARISON_FUNC comparisonFunc = D3D12_COMPARISON_FUNC_LESS_EQUAL,
+         D3D12_STATIC_BORDER_COLOR borderColor = D3D12_STATIC_BORDER_COLOR_OPAQUE_WHITE,
+         FLOAT minLOD = 0.f,
+         FLOAT maxLOD = D3D12_FLOAT32_MAX,
+         D3D12_SHADER_VISIBILITY shaderVisibility = D3D12_SHADER_VISIBILITY_ALL,
+         UINT registerSpace = 0) noexcept
+    {
+        samplerDesc.ShaderRegister = shaderRegister;
+        samplerDesc.Filter = filter;
+        samplerDesc.AddressU = addressU;
+        samplerDesc.AddressV = addressV;
+        samplerDesc.AddressW = addressW;
+        samplerDesc.MipLODBias = mipLODBias;
+        samplerDesc.MaxAnisotropy = maxAnisotropy;
+        samplerDesc.ComparisonFunc = comparisonFunc;
+        samplerDesc.BorderColor = borderColor;
+        samplerDesc.MinLOD = minLOD;
+        samplerDesc.MaxLOD = maxLOD;
+        samplerDesc.ShaderVisibility = shaderVisibility;
+        samplerDesc.RegisterSpace = registerSpace;
+    }
+    inline void Init(
+         UINT shaderRegister,
+         D3D12_FILTER filter = D3D12_FILTER_ANISOTROPIC,
+         D3D12_TEXTURE_ADDRESS_MODE addressU = D3D12_TEXTURE_ADDRESS_MODE_WRAP,
+         D3D12_TEXTURE_ADDRESS_MODE addressV = D3D12_TEXTURE_ADDRESS_MODE_WRAP,
+         D3D12_TEXTURE_ADDRESS_MODE addressW = D3D12_TEXTURE_ADDRESS_MODE_WRAP,
+         FLOAT mipLODBias = 0,
+         UINT maxAnisotropy = 16,
+         D3D12_COMPARISON_FUNC comparisonFunc = D3D12_COMPARISON_FUNC_LESS_EQUAL,
+         D3D12_STATIC_BORDER_COLOR borderColor = D3D12_STATIC_BORDER_COLOR_OPAQUE_WHITE,
+         FLOAT minLOD = 0.f,
+         FLOAT maxLOD = D3D12_FLOAT32_MAX,
+         D3D12_SHADER_VISIBILITY shaderVisibility = D3D12_SHADER_VISIBILITY_ALL,
+         UINT registerSpace = 0) noexcept
+    {
+        Init(
+            *this,
+            shaderRegister,
+            filter,
+            addressU,
+            addressV,
+            addressW,
+            mipLODBias,
+            maxAnisotropy,
+            comparisonFunc,
+            borderColor,
+            minLOD,
+            maxLOD,
+            shaderVisibility,
+            registerSpace);
+    }
+
+};
+
+//------------------------------------------------------------------------------------------------
+struct CD3DX12_ROOT_SIGNATURE_DESC : public D3D12_ROOT_SIGNATURE_DESC
+{
+    CD3DX12_ROOT_SIGNATURE_DESC() = default;
+    explicit CD3DX12_ROOT_SIGNATURE_DESC(const D3D12_ROOT_SIGNATURE_DESC &o) noexcept :
+        D3D12_ROOT_SIGNATURE_DESC(o)
+    {}
+    CD3DX12_ROOT_SIGNATURE_DESC(
+        UINT numParameters,
+        _In_reads_opt_(numParameters) const D3D12_ROOT_PARAMETER* _pParameters,
+        UINT numStaticSamplers = 0,
+        _In_reads_opt_(numStaticSamplers) const D3D12_STATIC_SAMPLER_DESC* _pStaticSamplers = nullptr,
+        D3D12_ROOT_SIGNATURE_FLAGS flags = D3D12_ROOT_SIGNATURE_FLAG_NONE) noexcept
+    {
+        Init(numParameters, _pParameters, numStaticSamplers, _pStaticSamplers, flags);
+    }
+    CD3DX12_ROOT_SIGNATURE_DESC(CD3DX12_DEFAULT) noexcept
+    {
+        Init(0, nullptr, 0, nullptr, D3D12_ROOT_SIGNATURE_FLAG_NONE);
+    }
+
+    inline void Init(
+        UINT numParameters,
+        _In_reads_opt_(numParameters) const D3D12_ROOT_PARAMETER* _pParameters,
+        UINT numStaticSamplers = 0,
+        _In_reads_opt_(numStaticSamplers) const D3D12_STATIC_SAMPLER_DESC* _pStaticSamplers = nullptr,
+        D3D12_ROOT_SIGNATURE_FLAGS flags = D3D12_ROOT_SIGNATURE_FLAG_NONE) noexcept
+    {
+        Init(*this, numParameters, _pParameters, numStaticSamplers, _pStaticSamplers, flags);
+    }
+
+    static inline void Init(
+        _Out_ D3D12_ROOT_SIGNATURE_DESC &desc,
+        UINT numParameters,
+        _In_reads_opt_(numParameters) const D3D12_ROOT_PARAMETER* _pParameters,
+        UINT numStaticSamplers = 0,
+        _In_reads_opt_(numStaticSamplers) const D3D12_STATIC_SAMPLER_DESC* _pStaticSamplers = nullptr,
+        D3D12_ROOT_SIGNATURE_FLAGS flags = D3D12_ROOT_SIGNATURE_FLAG_NONE) noexcept
+    {
+        desc.NumParameters = numParameters;
+        desc.pParameters = _pParameters;
+        desc.NumStaticSamplers = numStaticSamplers;
+        desc.pStaticSamplers = _pStaticSamplers;
+        desc.Flags = flags;
+    }
+};
+
+//------------------------------------------------------------------------------------------------
+struct CD3DX12_DESCRIPTOR_RANGE1 : public D3D12_DESCRIPTOR_RANGE1
+{
+    CD3DX12_DESCRIPTOR_RANGE1() = default;
+    explicit CD3DX12_DESCRIPTOR_RANGE1(const D3D12_DESCRIPTOR_RANGE1 &o) noexcept :
+        D3D12_DESCRIPTOR_RANGE1(o)
+    {}
+    CD3DX12_DESCRIPTOR_RANGE1(
+        D3D12_DESCRIPTOR_RANGE_TYPE rangeType,
+        UINT numDescriptors,
+        UINT baseShaderRegister,
+        UINT registerSpace = 0,
+        D3D12_DESCRIPTOR_RANGE_FLAGS flags = D3D12_DESCRIPTOR_RANGE_FLAG_NONE,
+        UINT offsetInDescriptorsFromTableStart =
+        D3D12_DESCRIPTOR_RANGE_OFFSET_APPEND) noexcept
+    {
+        Init(rangeType, numDescriptors, baseShaderRegister, registerSpace, flags, offsetInDescriptorsFromTableStart);
+    }
+
+    inline void Init(
+        D3D12_DESCRIPTOR_RANGE_TYPE rangeType,
+        UINT numDescriptors,
+        UINT baseShaderRegister,
+        UINT registerSpace = 0,
+        D3D12_DESCRIPTOR_RANGE_FLAGS flags = D3D12_DESCRIPTOR_RANGE_FLAG_NONE,
+        UINT offsetInDescriptorsFromTableStart =
+        D3D12_DESCRIPTOR_RANGE_OFFSET_APPEND) noexcept
+    {
+        Init(*this, rangeType, numDescriptors, baseShaderRegister, registerSpace, flags, offsetInDescriptorsFromTableStart);
+    }
+
+    static inline void Init(
+        _Out_ D3D12_DESCRIPTOR_RANGE1 &range,
+        D3D12_DESCRIPTOR_RANGE_TYPE rangeType,
+        UINT numDescriptors,
+        UINT baseShaderRegister,
+        UINT registerSpace = 0,
+        D3D12_DESCRIPTOR_RANGE_FLAGS flags = D3D12_DESCRIPTOR_RANGE_FLAG_NONE,
+        UINT offsetInDescriptorsFromTableStart =
+        D3D12_DESCRIPTOR_RANGE_OFFSET_APPEND) noexcept
+    {
+        range.RangeType = rangeType;
+        range.NumDescriptors = numDescriptors;
+        range.BaseShaderRegister = baseShaderRegister;
+        range.RegisterSpace = registerSpace;
+        range.Flags = flags;
+        range.OffsetInDescriptorsFromTableStart = offsetInDescriptorsFromTableStart;
+    }
+};
+
+//------------------------------------------------------------------------------------------------
+struct CD3DX12_ROOT_DESCRIPTOR_TABLE1 : public D3D12_ROOT_DESCRIPTOR_TABLE1
+{
+    CD3DX12_ROOT_DESCRIPTOR_TABLE1() = default;
+    explicit CD3DX12_ROOT_DESCRIPTOR_TABLE1(const D3D12_ROOT_DESCRIPTOR_TABLE1 &o) noexcept :
+        D3D12_ROOT_DESCRIPTOR_TABLE1(o)
+    {}
+    CD3DX12_ROOT_DESCRIPTOR_TABLE1(
+        UINT numDescriptorRanges,
+        _In_reads_opt_(numDescriptorRanges) const D3D12_DESCRIPTOR_RANGE1* _pDescriptorRanges) noexcept
+    {
+        Init(numDescriptorRanges, _pDescriptorRanges);
+    }
+
+    inline void Init(
+        UINT numDescriptorRanges,
+        _In_reads_opt_(numDescriptorRanges) const D3D12_DESCRIPTOR_RANGE1* _pDescriptorRanges) noexcept
+    {
+        Init(*this, numDescriptorRanges, _pDescriptorRanges);
+    }
+
+    static inline void Init(
+        _Out_ D3D12_ROOT_DESCRIPTOR_TABLE1 &rootDescriptorTable,
+        UINT numDescriptorRanges,
+        _In_reads_opt_(numDescriptorRanges) const D3D12_DESCRIPTOR_RANGE1* _pDescriptorRanges) noexcept
+    {
+        rootDescriptorTable.NumDescriptorRanges = numDescriptorRanges;
+        rootDescriptorTable.pDescriptorRanges = _pDescriptorRanges;
+    }
+};
+
+//------------------------------------------------------------------------------------------------
+struct CD3DX12_ROOT_DESCRIPTOR1 : public D3D12_ROOT_DESCRIPTOR1
+{
+    CD3DX12_ROOT_DESCRIPTOR1() = default;
+    explicit CD3DX12_ROOT_DESCRIPTOR1(const D3D12_ROOT_DESCRIPTOR1 &o) noexcept :
+        D3D12_ROOT_DESCRIPTOR1(o)
+    {}
+    CD3DX12_ROOT_DESCRIPTOR1(
+        UINT shaderRegister,
+        UINT registerSpace = 0,
+        D3D12_ROOT_DESCRIPTOR_FLAGS flags = D3D12_ROOT_DESCRIPTOR_FLAG_NONE) noexcept
+    {
+        Init(shaderRegister, registerSpace, flags);
+    }
+
+    inline void Init(
+        UINT shaderRegister,
+        UINT registerSpace = 0,
+        D3D12_ROOT_DESCRIPTOR_FLAGS flags = D3D12_ROOT_DESCRIPTOR_FLAG_NONE) noexcept
+    {
+        Init(*this, shaderRegister, registerSpace, flags);
+    }
+
+    static inline void Init(
+        _Out_ D3D12_ROOT_DESCRIPTOR1 &table,
+        UINT shaderRegister,
+        UINT registerSpace = 0,
+        D3D12_ROOT_DESCRIPTOR_FLAGS flags = D3D12_ROOT_DESCRIPTOR_FLAG_NONE) noexcept
+    {
+        table.ShaderRegister = shaderRegister;
+        table.RegisterSpace = registerSpace;
+        table.Flags = flags;
+    }
+};
+
+//------------------------------------------------------------------------------------------------
+struct CD3DX12_ROOT_PARAMETER1 : public D3D12_ROOT_PARAMETER1
+{
+    CD3DX12_ROOT_PARAMETER1() = default;
+    explicit CD3DX12_ROOT_PARAMETER1(const D3D12_ROOT_PARAMETER1 &o) noexcept :
+        D3D12_ROOT_PARAMETER1(o)
+    {}
+
+    static inline void InitAsDescriptorTable(
+        _Out_ D3D12_ROOT_PARAMETER1 &rootParam,
+        UINT numDescriptorRanges,
+        _In_reads_(numDescriptorRanges) const D3D12_DESCRIPTOR_RANGE1* pDescriptorRanges,
+        D3D12_SHADER_VISIBILITY visibility = D3D12_SHADER_VISIBILITY_ALL) noexcept
+    {
+        rootParam.ParameterType = D3D12_ROOT_PARAMETER_TYPE_DESCRIPTOR_TABLE;
+        rootParam.ShaderVisibility = visibility;
+        CD3DX12_ROOT_DESCRIPTOR_TABLE1::Init(rootParam.DescriptorTable, numDescriptorRanges, pDescriptorRanges);
+    }
+
+    static inline void InitAsConstants(
+        _Out_ D3D12_ROOT_PARAMETER1 &rootParam,
+        UINT num32BitValues,
+        UINT shaderRegister,
+        UINT registerSpace = 0,
+        D3D12_SHADER_VISIBILITY visibility = D3D12_SHADER_VISIBILITY_ALL) noexcept
+    {
+        rootParam.ParameterType = D3D12_ROOT_PARAMETER_TYPE_32BIT_CONSTANTS;
+        rootParam.ShaderVisibility = visibility;
+        CD3DX12_ROOT_CONSTANTS::Init(rootParam.Constants, num32BitValues, shaderRegister, registerSpace);
+    }
+
+    static inline void InitAsConstantBufferView(
+        _Out_ D3D12_ROOT_PARAMETER1 &rootParam,
+        UINT shaderRegister,
+        UINT registerSpace = 0,
+        D3D12_ROOT_DESCRIPTOR_FLAGS flags = D3D12_ROOT_DESCRIPTOR_FLAG_NONE,
+        D3D12_SHADER_VISIBILITY visibility = D3D12_SHADER_VISIBILITY_ALL) noexcept
+    {
+        rootParam.ParameterType = D3D12_ROOT_PARAMETER_TYPE_CBV;
+        rootParam.ShaderVisibility = visibility;
+        CD3DX12_ROOT_DESCRIPTOR1::Init(rootParam.Descriptor, shaderRegister, registerSpace, flags);
+    }
+
+    static inline void InitAsShaderResourceView(
+        _Out_ D3D12_ROOT_PARAMETER1 &rootParam,
+        UINT shaderRegister,
+        UINT registerSpace = 0,
+        D3D12_ROOT_DESCRIPTOR_FLAGS flags = D3D12_ROOT_DESCRIPTOR_FLAG_NONE,
+        D3D12_SHADER_VISIBILITY visibility = D3D12_SHADER_VISIBILITY_ALL) noexcept
+    {
+        rootParam.ParameterType = D3D12_ROOT_PARAMETER_TYPE_SRV;
+        rootParam.ShaderVisibility = visibility;
+        CD3DX12_ROOT_DESCRIPTOR1::Init(rootParam.Descriptor, shaderRegister, registerSpace, flags);
+    }
+
+    static inline void InitAsUnorderedAccessView(
+        _Out_ D3D12_ROOT_PARAMETER1 &rootParam,
+        UINT shaderRegister,
+        UINT registerSpace = 0,
+        D3D12_ROOT_DESCRIPTOR_FLAGS flags = D3D12_ROOT_DESCRIPTOR_FLAG_NONE,
+        D3D12_SHADER_VISIBILITY visibility = D3D12_SHADER_VISIBILITY_ALL) noexcept
+    {
+        rootParam.ParameterType = D3D12_ROOT_PARAMETER_TYPE_UAV;
+        rootParam.ShaderVisibility = visibility;
+        CD3DX12_ROOT_DESCRIPTOR1::Init(rootParam.Descriptor, shaderRegister, registerSpace, flags);
+    }
+
+    inline void InitAsDescriptorTable(
+        UINT numDescriptorRanges,
+        _In_reads_(numDescriptorRanges) const D3D12_DESCRIPTOR_RANGE1* pDescriptorRanges,
+        D3D12_SHADER_VISIBILITY visibility = D3D12_SHADER_VISIBILITY_ALL) noexcept
+    {
+        InitAsDescriptorTable(*this, numDescriptorRanges, pDescriptorRanges, visibility);
+    }
+
+    inline void InitAsConstants(
+        UINT num32BitValues,
+        UINT shaderRegister,
+        UINT registerSpace = 0,
+        D3D12_SHADER_VISIBILITY visibility = D3D12_SHADER_VISIBILITY_ALL) noexcept
+    {
+        InitAsConstants(*this, num32BitValues, shaderRegister, registerSpace, visibility);
+    }
+
+    inline void InitAsConstantBufferView(
+        UINT shaderRegister,
+        UINT registerSpace = 0,
+        D3D12_ROOT_DESCRIPTOR_FLAGS flags = D3D12_ROOT_DESCRIPTOR_FLAG_NONE,
+        D3D12_SHADER_VISIBILITY visibility = D3D12_SHADER_VISIBILITY_ALL) noexcept
+    {
+        InitAsConstantBufferView(*this, shaderRegister, registerSpace, flags, visibility);
+    }
+
+    inline void InitAsShaderResourceView(
+        UINT shaderRegister,
+        UINT registerSpace = 0,
+        D3D12_ROOT_DESCRIPTOR_FLAGS flags = D3D12_ROOT_DESCRIPTOR_FLAG_NONE,
+        D3D12_SHADER_VISIBILITY visibility = D3D12_SHADER_VISIBILITY_ALL) noexcept
+    {
+        InitAsShaderResourceView(*this, shaderRegister, registerSpace, flags, visibility);
+    }
+
+    inline void InitAsUnorderedAccessView(
+        UINT shaderRegister,
+        UINT registerSpace = 0,
+        D3D12_ROOT_DESCRIPTOR_FLAGS flags = D3D12_ROOT_DESCRIPTOR_FLAG_NONE,
+        D3D12_SHADER_VISIBILITY visibility = D3D12_SHADER_VISIBILITY_ALL) noexcept
+    {
+        InitAsUnorderedAccessView(*this, shaderRegister, registerSpace, flags, visibility);
+    }
+};
+
+//------------------------------------------------------------------------------------------------
+struct CD3DX12_VERSIONED_ROOT_SIGNATURE_DESC : public D3D12_VERSIONED_ROOT_SIGNATURE_DESC
+{
+    CD3DX12_VERSIONED_ROOT_SIGNATURE_DESC() = default;
+    explicit CD3DX12_VERSIONED_ROOT_SIGNATURE_DESC(const D3D12_VERSIONED_ROOT_SIGNATURE_DESC &o) noexcept :
+        D3D12_VERSIONED_ROOT_SIGNATURE_DESC(o)
+    {}
+    explicit CD3DX12_VERSIONED_ROOT_SIGNATURE_DESC(const D3D12_ROOT_SIGNATURE_DESC &o) noexcept
+    {
+        Version = D3D_ROOT_SIGNATURE_VERSION_1_0;
+        Desc_1_0 = o;
+    }
+    explicit CD3DX12_VERSIONED_ROOT_SIGNATURE_DESC(const D3D12_ROOT_SIGNATURE_DESC1 &o) noexcept
+    {
+        Version = D3D_ROOT_SIGNATURE_VERSION_1_1;
+        Desc_1_1 = o;
+    }
+    CD3DX12_VERSIONED_ROOT_SIGNATURE_DESC(
+        UINT numParameters,
+        _In_reads_opt_(numParameters) const D3D12_ROOT_PARAMETER* _pParameters,
+        UINT numStaticSamplers = 0,
+        _In_reads_opt_(numStaticSamplers) const D3D12_STATIC_SAMPLER_DESC* _pStaticSamplers = nullptr,
+        D3D12_ROOT_SIGNATURE_FLAGS flags = D3D12_ROOT_SIGNATURE_FLAG_NONE) noexcept
+    {
+        Init_1_0(numParameters, _pParameters, numStaticSamplers, _pStaticSamplers, flags);
+    }
+    CD3DX12_VERSIONED_ROOT_SIGNATURE_DESC(
+        UINT numParameters,
+        _In_reads_opt_(numParameters) const D3D12_ROOT_PARAMETER1* _pParameters,
+        UINT numStaticSamplers = 0,
+        _In_reads_opt_(numStaticSamplers) const D3D12_STATIC_SAMPLER_DESC* _pStaticSamplers = nullptr,
+        D3D12_ROOT_SIGNATURE_FLAGS flags = D3D12_ROOT_SIGNATURE_FLAG_NONE) noexcept
+    {
+        Init_1_1(numParameters, _pParameters, numStaticSamplers, _pStaticSamplers, flags);
+    }
+    CD3DX12_VERSIONED_ROOT_SIGNATURE_DESC(CD3DX12_DEFAULT) noexcept
+    {
+        Init_1_1(0, nullptr, 0, nullptr, D3D12_ROOT_SIGNATURE_FLAG_NONE);
+    }
+
+    inline void Init_1_0(
+        UINT numParameters,
+        _In_reads_opt_(numParameters) const D3D12_ROOT_PARAMETER* _pParameters,
+        UINT numStaticSamplers = 0,
+        _In_reads_opt_(numStaticSamplers) const D3D12_STATIC_SAMPLER_DESC* _pStaticSamplers = nullptr,
+        D3D12_ROOT_SIGNATURE_FLAGS flags = D3D12_ROOT_SIGNATURE_FLAG_NONE) noexcept
+    {
+        Init_1_0(*this, numParameters, _pParameters, numStaticSamplers, _pStaticSamplers, flags);
+    }
+
+    static inline void Init_1_0(
+        _Out_ D3D12_VERSIONED_ROOT_SIGNATURE_DESC &desc,
+        UINT numParameters,
+        _In_reads_opt_(numParameters) const D3D12_ROOT_PARAMETER* _pParameters,
+        UINT numStaticSamplers = 0,
+        _In_reads_opt_(numStaticSamplers) const D3D12_STATIC_SAMPLER_DESC* _pStaticSamplers = nullptr,
+        D3D12_ROOT_SIGNATURE_FLAGS flags = D3D12_ROOT_SIGNATURE_FLAG_NONE) noexcept
+    {
+        desc.Version = D3D_ROOT_SIGNATURE_VERSION_1_0;
+        desc.Desc_1_0.NumParameters = numParameters;
+        desc.Desc_1_0.pParameters = _pParameters;
+        desc.Desc_1_0.NumStaticSamplers = numStaticSamplers;
+        desc.Desc_1_0.pStaticSamplers = _pStaticSamplers;
+        desc.Desc_1_0.Flags = flags;
+    }
+
+    inline void Init_1_1(
+        UINT numParameters,
+        _In_reads_opt_(numParameters) const D3D12_ROOT_PARAMETER1* _pParameters,
+        UINT numStaticSamplers = 0,
+        _In_reads_opt_(numStaticSamplers) const D3D12_STATIC_SAMPLER_DESC* _pStaticSamplers = nullptr,
+        D3D12_ROOT_SIGNATURE_FLAGS flags = D3D12_ROOT_SIGNATURE_FLAG_NONE) noexcept
+    {
+        Init_1_1(*this, numParameters, _pParameters, numStaticSamplers, _pStaticSamplers, flags);
+    }
+
+    static inline void Init_1_1(
+        _Out_ D3D12_VERSIONED_ROOT_SIGNATURE_DESC &desc,
+        UINT numParameters,
+        _In_reads_opt_(numParameters) const D3D12_ROOT_PARAMETER1* _pParameters,
+        UINT numStaticSamplers = 0,
+        _In_reads_opt_(numStaticSamplers) const D3D12_STATIC_SAMPLER_DESC* _pStaticSamplers = nullptr,
+        D3D12_ROOT_SIGNATURE_FLAGS flags = D3D12_ROOT_SIGNATURE_FLAG_NONE) noexcept
+    {
+        desc.Version = D3D_ROOT_SIGNATURE_VERSION_1_1;
+        desc.Desc_1_1.NumParameters = numParameters;
+        desc.Desc_1_1.pParameters = _pParameters;
+        desc.Desc_1_1.NumStaticSamplers = numStaticSamplers;
+        desc.Desc_1_1.pStaticSamplers = _pStaticSamplers;
+        desc.Desc_1_1.Flags = flags;
+    }
+};
+
+//------------------------------------------------------------------------------------------------
+struct CD3DX12_CPU_DESCRIPTOR_HANDLE : public D3D12_CPU_DESCRIPTOR_HANDLE
+{
+    CD3DX12_CPU_DESCRIPTOR_HANDLE() = default;
+    explicit CD3DX12_CPU_DESCRIPTOR_HANDLE(const D3D12_CPU_DESCRIPTOR_HANDLE &o) noexcept :
+        D3D12_CPU_DESCRIPTOR_HANDLE(o)
+    {}
+    CD3DX12_CPU_DESCRIPTOR_HANDLE(CD3DX12_DEFAULT) noexcept { ptr = 0; }
+    CD3DX12_CPU_DESCRIPTOR_HANDLE(_In_ const D3D12_CPU_DESCRIPTOR_HANDLE &other, INT offsetScaledByIncrementSize) noexcept
+    {
+        InitOffsetted(other, offsetScaledByIncrementSize);
+    }
+    CD3DX12_CPU_DESCRIPTOR_HANDLE(_In_ const D3D12_CPU_DESCRIPTOR_HANDLE &other, INT offsetInDescriptors, UINT descriptorIncrementSize) noexcept
+    {
+        InitOffsetted(other, offsetInDescriptors, descriptorIncrementSize);
+    }
+    CD3DX12_CPU_DESCRIPTOR_HANDLE& Offset(INT offsetInDescriptors, UINT descriptorIncrementSize) noexcept
+    {
+        ptr = SIZE_T(INT64(ptr) + INT64(offsetInDescriptors) * INT64(descriptorIncrementSize));
+        return *this;
+    }
+    CD3DX12_CPU_DESCRIPTOR_HANDLE& Offset(INT offsetScaledByIncrementSize) noexcept
+    {
+        ptr = SIZE_T(INT64(ptr) + INT64(offsetScaledByIncrementSize));
+        return *this;
+    }
+    bool operator==(_In_ const D3D12_CPU_DESCRIPTOR_HANDLE& other) const noexcept
+    {
+        return (ptr == other.ptr);
+    }
+    bool operator!=(_In_ const D3D12_CPU_DESCRIPTOR_HANDLE& other) const noexcept
+    {
+        return (ptr != other.ptr);
+    }
+    CD3DX12_CPU_DESCRIPTOR_HANDLE &operator=(const D3D12_CPU_DESCRIPTOR_HANDLE &other) noexcept
+    {
+        ptr = other.ptr;
+        return *this;
+    }
+
+    inline void InitOffsetted(_In_ const D3D12_CPU_DESCRIPTOR_HANDLE &base, INT offsetScaledByIncrementSize) noexcept
+    {
+        InitOffsetted(*this, base, offsetScaledByIncrementSize);
+    }
+
+    inline void InitOffsetted(_In_ const D3D12_CPU_DESCRIPTOR_HANDLE &base, INT offsetInDescriptors, UINT descriptorIncrementSize) noexcept
+    {
+        InitOffsetted(*this, base, offsetInDescriptors, descriptorIncrementSize);
+    }
+
+    static inline void InitOffsetted(_Out_ D3D12_CPU_DESCRIPTOR_HANDLE &handle, _In_ const D3D12_CPU_DESCRIPTOR_HANDLE &base, INT offsetScaledByIncrementSize) noexcept
+    {
+        handle.ptr = SIZE_T(INT64(base.ptr) + INT64(offsetScaledByIncrementSize));
+    }
+
+    static inline void InitOffsetted(_Out_ D3D12_CPU_DESCRIPTOR_HANDLE &handle, _In_ const D3D12_CPU_DESCRIPTOR_HANDLE &base, INT offsetInDescriptors, UINT descriptorIncrementSize) noexcept
+    {
+        handle.ptr = SIZE_T(INT64(base.ptr) + INT64(offsetInDescriptors) * INT64(descriptorIncrementSize));
+    }
+};
+
+//------------------------------------------------------------------------------------------------
+struct CD3DX12_GPU_DESCRIPTOR_HANDLE : public D3D12_GPU_DESCRIPTOR_HANDLE
+{
+    CD3DX12_GPU_DESCRIPTOR_HANDLE() = default;
+    explicit CD3DX12_GPU_DESCRIPTOR_HANDLE(const D3D12_GPU_DESCRIPTOR_HANDLE &o) noexcept :
+        D3D12_GPU_DESCRIPTOR_HANDLE(o)
+    {}
+    CD3DX12_GPU_DESCRIPTOR_HANDLE(CD3DX12_DEFAULT) noexcept { ptr = 0; }
+    CD3DX12_GPU_DESCRIPTOR_HANDLE(_In_ const D3D12_GPU_DESCRIPTOR_HANDLE &other, INT offsetScaledByIncrementSize) noexcept
+    {
+        InitOffsetted(other, offsetScaledByIncrementSize);
+    }
+    CD3DX12_GPU_DESCRIPTOR_HANDLE(_In_ const D3D12_GPU_DESCRIPTOR_HANDLE &other, INT offsetInDescriptors, UINT descriptorIncrementSize) noexcept
+    {
+        InitOffsetted(other, offsetInDescriptors, descriptorIncrementSize);
+    }
+    CD3DX12_GPU_DESCRIPTOR_HANDLE& Offset(INT offsetInDescriptors, UINT descriptorIncrementSize) noexcept
+    {
+        ptr = UINT64(INT64(ptr) + INT64(offsetInDescriptors) * INT64(descriptorIncrementSize));
+        return *this;
+    }
+    CD3DX12_GPU_DESCRIPTOR_HANDLE& Offset(INT offsetScaledByIncrementSize) noexcept
+    {
+        ptr = UINT64(INT64(ptr) + INT64(offsetScaledByIncrementSize));
+        return *this;
+    }
+    inline bool operator==(_In_ const D3D12_GPU_DESCRIPTOR_HANDLE& other) const noexcept
+    {
+        return (ptr == other.ptr);
+    }
+    inline bool operator!=(_In_ const D3D12_GPU_DESCRIPTOR_HANDLE& other) const noexcept
+    {
+        return (ptr != other.ptr);
+    }
+    CD3DX12_GPU_DESCRIPTOR_HANDLE &operator=(const D3D12_GPU_DESCRIPTOR_HANDLE &other) noexcept
+    {
+        ptr = other.ptr;
+        return *this;
+    }
+
+    inline void InitOffsetted(_In_ const D3D12_GPU_DESCRIPTOR_HANDLE &base, INT offsetScaledByIncrementSize) noexcept
+    {
+        InitOffsetted(*this, base, offsetScaledByIncrementSize);
+    }
+
+    inline void InitOffsetted(_In_ const D3D12_GPU_DESCRIPTOR_HANDLE &base, INT offsetInDescriptors, UINT descriptorIncrementSize) noexcept
+    {
+        InitOffsetted(*this, base, offsetInDescriptors, descriptorIncrementSize);
+    }
+
+    static inline void InitOffsetted(_Out_ D3D12_GPU_DESCRIPTOR_HANDLE &handle, _In_ const D3D12_GPU_DESCRIPTOR_HANDLE &base, INT offsetScaledByIncrementSize) noexcept
+    {
+        handle.ptr = UINT64(INT64(base.ptr) + INT64(offsetScaledByIncrementSize));
+    }
+
+    static inline void InitOffsetted(_Out_ D3D12_GPU_DESCRIPTOR_HANDLE &handle, _In_ const D3D12_GPU_DESCRIPTOR_HANDLE &base, INT offsetInDescriptors, UINT descriptorIncrementSize) noexcept
+    {
+        handle.ptr = UINT64(INT64(base.ptr) + INT64(offsetInDescriptors) * INT64(descriptorIncrementSize));
+    }
+};
+
+//------------------------------------------------------------------------------------------------
+constexpr UINT D3D12CalcSubresource( UINT MipSlice, UINT ArraySlice, UINT PlaneSlice, UINT MipLevels, UINT ArraySize ) noexcept
+{
+    return MipSlice + ArraySlice * MipLevels + PlaneSlice * MipLevels * ArraySize;
+}
+
+//------------------------------------------------------------------------------------------------
+template <typename T, typename U, typename V>
+inline void D3D12DecomposeSubresource( UINT Subresource, UINT MipLevels, UINT ArraySize, _Out_ T& MipSlice, _Out_ U& ArraySlice, _Out_ V& PlaneSlice ) noexcept
+{
+    MipSlice = static_cast<T>(Subresource % MipLevels);
+    ArraySlice = static_cast<U>((Subresource / MipLevels) % ArraySize);
+    PlaneSlice = static_cast<V>(Subresource / (MipLevels * ArraySize));
+}
+
+//------------------------------------------------------------------------------------------------
+inline UINT8 D3D12GetFormatPlaneCount(
+    _In_ ID3D12Device* pDevice,
+    DXGI_FORMAT Format
+    ) noexcept
+{
+    D3D12_FEATURE_DATA_FORMAT_INFO formatInfo = { Format, 0 };
+    if (FAILED(pDevice->CheckFeatureSupport(D3D12_FEATURE_FORMAT_INFO, &formatInfo, sizeof(formatInfo))))
+    {
+        return 0;
+    }
+    return formatInfo.PlaneCount;
+}
+
+//------------------------------------------------------------------------------------------------
+struct CD3DX12_RESOURCE_DESC : public D3D12_RESOURCE_DESC
+{
+    CD3DX12_RESOURCE_DESC() = default;
+    explicit CD3DX12_RESOURCE_DESC( const D3D12_RESOURCE_DESC& o ) noexcept :
+        D3D12_RESOURCE_DESC( o )
+    {}
+    CD3DX12_RESOURCE_DESC(
+        D3D12_RESOURCE_DIMENSION dimension,
+        UINT64 alignment,
+        UINT64 width,
+        UINT height,
+        UINT16 depthOrArraySize,
+        UINT16 mipLevels,
+        DXGI_FORMAT format,
+        UINT sampleCount,
+        UINT sampleQuality,
+        D3D12_TEXTURE_LAYOUT layout,
+        D3D12_RESOURCE_FLAGS flags ) noexcept
+    {
+        Dimension = dimension;
+        Alignment = alignment;
+        Width = width;
+        Height = height;
+        DepthOrArraySize = depthOrArraySize;
+        MipLevels = mipLevels;
+        Format = format;
+        SampleDesc.Count = sampleCount;
+        SampleDesc.Quality = sampleQuality;
+        Layout = layout;
+        Flags = flags;
+    }
+    static inline CD3DX12_RESOURCE_DESC Buffer(
+        const D3D12_RESOURCE_ALLOCATION_INFO& resAllocInfo,
+        D3D12_RESOURCE_FLAGS flags = D3D12_RESOURCE_FLAG_NONE ) noexcept
+    {
+        return CD3DX12_RESOURCE_DESC( D3D12_RESOURCE_DIMENSION_BUFFER, resAllocInfo.Alignment, resAllocInfo.SizeInBytes,
+            1, 1, 1, DXGI_FORMAT_UNKNOWN, 1, 0, D3D12_TEXTURE_LAYOUT_ROW_MAJOR, flags );
+    }
+    static inline CD3DX12_RESOURCE_DESC Buffer(
+        UINT64 width,
+        D3D12_RESOURCE_FLAGS flags = D3D12_RESOURCE_FLAG_NONE,
+        UINT64 alignment = 0 ) noexcept
+    {
+        return CD3DX12_RESOURCE_DESC( D3D12_RESOURCE_DIMENSION_BUFFER, alignment, width, 1, 1, 1,
+            DXGI_FORMAT_UNKNOWN, 1, 0, D3D12_TEXTURE_LAYOUT_ROW_MAJOR, flags );
+    }
+    static inline CD3DX12_RESOURCE_DESC Tex1D(
+        DXGI_FORMAT format,
+        UINT64 width,
+        UINT16 arraySize = 1,
+        UINT16 mipLevels = 0,
+        D3D12_RESOURCE_FLAGS flags = D3D12_RESOURCE_FLAG_NONE,
+        D3D12_TEXTURE_LAYOUT layout = D3D12_TEXTURE_LAYOUT_UNKNOWN,
+        UINT64 alignment = 0 ) noexcept
+    {
+        return CD3DX12_RESOURCE_DESC( D3D12_RESOURCE_DIMENSION_TEXTURE1D, alignment, width, 1, arraySize,
+            mipLevels, format, 1, 0, layout, flags );
+    }
+    static inline CD3DX12_RESOURCE_DESC Tex2D(
+        DXGI_FORMAT format,
+        UINT64 width,
+        UINT height,
+        UINT16 arraySize = 1,
+        UINT16 mipLevels = 0,
+        UINT sampleCount = 1,
+        UINT sampleQuality = 0,
+        D3D12_RESOURCE_FLAGS flags = D3D12_RESOURCE_FLAG_NONE,
+        D3D12_TEXTURE_LAYOUT layout = D3D12_TEXTURE_LAYOUT_UNKNOWN,
+        UINT64 alignment = 0 ) noexcept
+    {
+        return CD3DX12_RESOURCE_DESC( D3D12_RESOURCE_DIMENSION_TEXTURE2D, alignment, width, height, arraySize,
+            mipLevels, format, sampleCount, sampleQuality, layout, flags );
+    }
+    static inline CD3DX12_RESOURCE_DESC Tex3D(
+        DXGI_FORMAT format,
+        UINT64 width,
+        UINT height,
+        UINT16 depth,
+        UINT16 mipLevels = 0,
+        D3D12_RESOURCE_FLAGS flags = D3D12_RESOURCE_FLAG_NONE,
+        D3D12_TEXTURE_LAYOUT layout = D3D12_TEXTURE_LAYOUT_UNKNOWN,
+        UINT64 alignment = 0 ) noexcept
+    {
+        return CD3DX12_RESOURCE_DESC( D3D12_RESOURCE_DIMENSION_TEXTURE3D, alignment, width, height, depth,
+            mipLevels, format, 1, 0, layout, flags );
+    }
+    inline UINT16 Depth() const noexcept
+    { return (Dimension == D3D12_RESOURCE_DIMENSION_TEXTURE3D ? DepthOrArraySize : 1u); }
+    inline UINT16 ArraySize() const noexcept
+    { return (Dimension != D3D12_RESOURCE_DIMENSION_TEXTURE3D ? DepthOrArraySize : 1u); }
+    inline UINT8 PlaneCount(_In_ ID3D12Device* pDevice) const noexcept
+    { return D3D12GetFormatPlaneCount(pDevice, Format); }
+    inline UINT Subresources(_In_ ID3D12Device* pDevice) const noexcept
+    { return static_cast<UINT>(MipLevels) * ArraySize() * PlaneCount(pDevice); }
+    inline UINT CalcSubresource(UINT MipSlice, UINT ArraySlice, UINT PlaneSlice) noexcept
+    { return D3D12CalcSubresource(MipSlice, ArraySlice, PlaneSlice, MipLevels, ArraySize()); }
+};
+inline bool operator==( const D3D12_RESOURCE_DESC& l, const D3D12_RESOURCE_DESC& r ) noexcept
+{
+    return l.Dimension == r.Dimension &&
+        l.Alignment == r.Alignment &&
+        l.Width == r.Width &&
+        l.Height == r.Height &&
+        l.DepthOrArraySize == r.DepthOrArraySize &&
+        l.MipLevels == r.MipLevels &&
+        l.Format == r.Format &&
+        l.SampleDesc.Count == r.SampleDesc.Count &&
+        l.SampleDesc.Quality == r.SampleDesc.Quality &&
+        l.Layout == r.Layout &&
+        l.Flags == r.Flags;
+}
+inline bool operator!=( const D3D12_RESOURCE_DESC& l, const D3D12_RESOURCE_DESC& r ) noexcept
+{ return !( l == r ); }
+
+//------------------------------------------------------------------------------------------------
+struct CD3DX12_RESOURCE_DESC1 : public D3D12_RESOURCE_DESC1
+{
+    CD3DX12_RESOURCE_DESC1() = default;
+    explicit CD3DX12_RESOURCE_DESC1( const D3D12_RESOURCE_DESC1& o ) noexcept :
+        D3D12_RESOURCE_DESC1( o )
+    {}
+    explicit CD3DX12_RESOURCE_DESC1( const D3D12_RESOURCE_DESC& o ) noexcept
+    {
+        Dimension = o.Dimension;
+        Alignment = o.Alignment;
+        Width = o.Width;
+        Height = o.Height;
+        DepthOrArraySize = o.DepthOrArraySize;
+        MipLevels = o.MipLevels;
+        Format = o.Format;
+        SampleDesc = o.SampleDesc;
+        Layout = o.Layout;
+        Flags = o.Flags;
+        SamplerFeedbackMipRegion = {};
+    }
+    CD3DX12_RESOURCE_DESC1(
+        D3D12_RESOURCE_DIMENSION dimension,
+        UINT64 alignment,
+        UINT64 width,
+        UINT height,
+        UINT16 depthOrArraySize,
+        UINT16 mipLevels,
+        DXGI_FORMAT format,
+        UINT sampleCount,
+        UINT sampleQuality,
+        D3D12_TEXTURE_LAYOUT layout,
+        D3D12_RESOURCE_FLAGS flags,
+        UINT samplerFeedbackMipRegionWidth = 0,
+        UINT samplerFeedbackMipRegionHeight = 0,
+        UINT samplerFeedbackMipRegionDepth = 0) noexcept
+    {
+        Dimension = dimension;
+        Alignment = alignment;
+        Width = width;
+        Height = height;
+        DepthOrArraySize = depthOrArraySize;
+        MipLevels = mipLevels;
+        Format = format;
+        SampleDesc.Count = sampleCount;
+        SampleDesc.Quality = sampleQuality;
+        Layout = layout;
+        Flags = flags;
+        SamplerFeedbackMipRegion.Width = samplerFeedbackMipRegionWidth;
+        SamplerFeedbackMipRegion.Height = samplerFeedbackMipRegionHeight;
+        SamplerFeedbackMipRegion.Depth = samplerFeedbackMipRegionDepth;
+    }
+    static inline CD3DX12_RESOURCE_DESC1 Buffer(
+        const D3D12_RESOURCE_ALLOCATION_INFO& resAllocInfo,
+        D3D12_RESOURCE_FLAGS flags = D3D12_RESOURCE_FLAG_NONE ) noexcept
+    {
+        return CD3DX12_RESOURCE_DESC1( D3D12_RESOURCE_DIMENSION_BUFFER, resAllocInfo.Alignment, resAllocInfo.SizeInBytes,
+            1, 1, 1, DXGI_FORMAT_UNKNOWN, 1, 0, D3D12_TEXTURE_LAYOUT_ROW_MAJOR, flags, 0, 0, 0 );
+    }
+    static inline CD3DX12_RESOURCE_DESC1 Buffer(
+        UINT64 width,
+        D3D12_RESOURCE_FLAGS flags = D3D12_RESOURCE_FLAG_NONE,
+        UINT64 alignment = 0 ) noexcept
+    {
+        return CD3DX12_RESOURCE_DESC1( D3D12_RESOURCE_DIMENSION_BUFFER, alignment, width, 1, 1, 1,
+            DXGI_FORMAT_UNKNOWN, 1, 0, D3D12_TEXTURE_LAYOUT_ROW_MAJOR, flags, 0, 0, 0 );
+    }
+    static inline CD3DX12_RESOURCE_DESC1 Tex1D(
+        DXGI_FORMAT format,
+        UINT64 width,
+        UINT16 arraySize = 1,
+        UINT16 mipLevels = 0,
+        D3D12_RESOURCE_FLAGS flags = D3D12_RESOURCE_FLAG_NONE,
+        D3D12_TEXTURE_LAYOUT layout = D3D12_TEXTURE_LAYOUT_UNKNOWN,
+        UINT64 alignment = 0 ) noexcept
+    {
+        return CD3DX12_RESOURCE_DESC1( D3D12_RESOURCE_DIMENSION_TEXTURE1D, alignment, width, 1, arraySize,
+            mipLevels, format, 1, 0, layout, flags, 0, 0, 0 );
+    }
+    static inline CD3DX12_RESOURCE_DESC1 Tex2D(
+        DXGI_FORMAT format,
+        UINT64 width,
+        UINT height,
+        UINT16 arraySize = 1,
+        UINT16 mipLevels = 0,
+        UINT sampleCount = 1,
+        UINT sampleQuality = 0,
+        D3D12_RESOURCE_FLAGS flags = D3D12_RESOURCE_FLAG_NONE,
+        D3D12_TEXTURE_LAYOUT layout = D3D12_TEXTURE_LAYOUT_UNKNOWN,
+        UINT64 alignment = 0,
+        UINT samplerFeedbackMipRegionWidth = 0,
+        UINT samplerFeedbackMipRegionHeight = 0,
+        UINT samplerFeedbackMipRegionDepth = 0) noexcept
+    {
+        return CD3DX12_RESOURCE_DESC1( D3D12_RESOURCE_DIMENSION_TEXTURE2D, alignment, width, height, arraySize,
+            mipLevels, format, sampleCount, sampleQuality, layout, flags, samplerFeedbackMipRegionWidth,
+            samplerFeedbackMipRegionHeight, samplerFeedbackMipRegionDepth );
+    }
+    static inline CD3DX12_RESOURCE_DESC1 Tex3D(
+        DXGI_FORMAT format,
+        UINT64 width,
+        UINT height,
+        UINT16 depth,
+        UINT16 mipLevels = 0,
+        D3D12_RESOURCE_FLAGS flags = D3D12_RESOURCE_FLAG_NONE,
+        D3D12_TEXTURE_LAYOUT layout = D3D12_TEXTURE_LAYOUT_UNKNOWN,
+        UINT64 alignment = 0 ) noexcept
+    {
+        return CD3DX12_RESOURCE_DESC1( D3D12_RESOURCE_DIMENSION_TEXTURE3D, alignment, width, height, depth,
+            mipLevels, format, 1, 0, layout, flags, 0, 0, 0 );
+    }
+    inline UINT16 Depth() const noexcept
+    { return (Dimension == D3D12_RESOURCE_DIMENSION_TEXTURE3D ? DepthOrArraySize : 1u); }
+    inline UINT16 ArraySize() const noexcept
+    { return (Dimension != D3D12_RESOURCE_DIMENSION_TEXTURE3D ? DepthOrArraySize : 1u); }
+    inline UINT8 PlaneCount(_In_ ID3D12Device* pDevice) const noexcept
+    { return D3D12GetFormatPlaneCount(pDevice, Format); }
+    inline UINT Subresources(_In_ ID3D12Device* pDevice) const noexcept
+    { return static_cast<UINT>(MipLevels) * ArraySize() * PlaneCount(pDevice); }
+    inline UINT CalcSubresource(UINT MipSlice, UINT ArraySlice, UINT PlaneSlice) noexcept
+    { return D3D12CalcSubresource(MipSlice, ArraySlice, PlaneSlice, MipLevels, ArraySize()); }
+};
+inline bool operator==( const D3D12_RESOURCE_DESC1& l, const D3D12_RESOURCE_DESC1& r ) noexcept
+{
+    return l.Dimension == r.Dimension &&
+        l.Alignment == r.Alignment &&
+        l.Width == r.Width &&
+        l.Height == r.Height &&
+        l.DepthOrArraySize == r.DepthOrArraySize &&
+        l.MipLevels == r.MipLevels &&
+        l.Format == r.Format &&
+        l.SampleDesc.Count == r.SampleDesc.Count &&
+        l.SampleDesc.Quality == r.SampleDesc.Quality &&
+        l.Layout == r.Layout &&
+        l.Flags == r.Flags &&
+        l.SamplerFeedbackMipRegion.Width == r.SamplerFeedbackMipRegion.Width &&
+        l.SamplerFeedbackMipRegion.Height == r.SamplerFeedbackMipRegion.Height &&
+        l.SamplerFeedbackMipRegion.Depth == r.SamplerFeedbackMipRegion.Depth;
+}
+inline bool operator!=( const D3D12_RESOURCE_DESC1& l, const D3D12_RESOURCE_DESC1& r ) noexcept
+{ return !( l == r ); }
+
+//------------------------------------------------------------------------------------------------
+struct CD3DX12_VIEW_INSTANCING_DESC : public D3D12_VIEW_INSTANCING_DESC
+{
+    CD3DX12_VIEW_INSTANCING_DESC() = default;
+    explicit CD3DX12_VIEW_INSTANCING_DESC( const D3D12_VIEW_INSTANCING_DESC& o ) noexcept :
+        D3D12_VIEW_INSTANCING_DESC( o )
+    {}
+    explicit CD3DX12_VIEW_INSTANCING_DESC( CD3DX12_DEFAULT ) noexcept
+    {
+        ViewInstanceCount = 0;
+        pViewInstanceLocations = nullptr;
+        Flags = D3D12_VIEW_INSTANCING_FLAG_NONE;
+    }
+    explicit CD3DX12_VIEW_INSTANCING_DESC(
+        UINT InViewInstanceCount,
+        const D3D12_VIEW_INSTANCE_LOCATION* InViewInstanceLocations,
+        D3D12_VIEW_INSTANCING_FLAGS InFlags) noexcept
+    {
+        ViewInstanceCount = InViewInstanceCount;
+        pViewInstanceLocations = InViewInstanceLocations;
+        Flags = InFlags;
+    }
+};
+
+//------------------------------------------------------------------------------------------------
+// Row-by-row memcpy
+inline void MemcpySubresource(
+    _In_ const D3D12_MEMCPY_DEST* pDest,
+    _In_ const D3D12_SUBRESOURCE_DATA* pSrc,
+    SIZE_T RowSizeInBytes,
+    UINT NumRows,
+    UINT NumSlices) noexcept
+{
+    for (UINT z = 0; z < NumSlices; ++z)
+    {
+        auto pDestSlice = static_cast<BYTE*>(pDest->pData) + pDest->SlicePitch * z;
+        auto pSrcSlice = static_cast<const BYTE*>(pSrc->pData) + pSrc->SlicePitch * LONG_PTR(z);
+        for (UINT y = 0; y < NumRows; ++y)
+        {
+            memcpy(pDestSlice + pDest->RowPitch * y,
+                   pSrcSlice + pSrc->RowPitch * LONG_PTR(y),
+                   RowSizeInBytes);
+        }
+    }
+}
+
+//------------------------------------------------------------------------------------------------
+// Row-by-row memcpy
+inline void MemcpySubresource(
+    _In_ const D3D12_MEMCPY_DEST* pDest,
+    _In_ const void* pResourceData,
+    _In_ const D3D12_SUBRESOURCE_INFO* pSrc,
+    SIZE_T RowSizeInBytes,
+    UINT NumRows,
+    UINT NumSlices) noexcept
+{
+    for (UINT z = 0; z < NumSlices; ++z)
+    {
+        auto pDestSlice = static_cast<BYTE*>(pDest->pData) + pDest->SlicePitch * z;
+        auto pSrcSlice = (static_cast<const BYTE*>(pResourceData) + pSrc->Offset) + pSrc->DepthPitch * ULONG_PTR(z);
+        for (UINT y = 0; y < NumRows; ++y)
+        {
+            memcpy(pDestSlice + pDest->RowPitch * y,
+                pSrcSlice + pSrc->RowPitch * ULONG_PTR(y),
+                RowSizeInBytes);
+        }
+    }
+}
+
+//------------------------------------------------------------------------------------------------
+// Returns required size of a buffer to be used for data upload
+inline UINT64 GetRequiredIntermediateSize(
+    _In_ ID3D12Resource* pDestinationResource,
+    _In_range_(0,D3D12_REQ_SUBRESOURCES) UINT FirstSubresource,
+    _In_range_(0,D3D12_REQ_SUBRESOURCES-FirstSubresource) UINT NumSubresources) noexcept
+{
+    const auto Desc = pDestinationResource->GetDesc();
+    UINT64 RequiredSize = 0;
+
+    ID3D12Device* pDevice = nullptr;
+    pDestinationResource->GetDevice(IID_ID3D12Device, reinterpret_cast<void**>(&pDevice));
+    pDevice->GetCopyableFootprints(&Desc, FirstSubresource, NumSubresources, 0, nullptr, nullptr, nullptr, &RequiredSize);
+    pDevice->Release();
+
+    return RequiredSize;
+}
+
+//------------------------------------------------------------------------------------------------
+// All arrays must be populated (e.g. by calling GetCopyableFootprints)
+inline UINT64 UpdateSubresources(
+    _In_ ID3D12GraphicsCommandList* pCmdList,
+    _In_ ID3D12Resource* pDestinationResource,
+    _In_ ID3D12Resource* pIntermediate,
+    _In_range_(0,D3D12_REQ_SUBRESOURCES) UINT FirstSubresource,
+    _In_range_(0,D3D12_REQ_SUBRESOURCES-FirstSubresource) UINT NumSubresources,
+    UINT64 RequiredSize,
+    _In_reads_(NumSubresources) const D3D12_PLACED_SUBRESOURCE_FOOTPRINT* pLayouts,
+    _In_reads_(NumSubresources) const UINT* pNumRows,
+    _In_reads_(NumSubresources) const UINT64* pRowSizesInBytes,
+    _In_reads_(NumSubresources) const D3D12_SUBRESOURCE_DATA* pSrcData) noexcept
+{
+    // Minor validation
+    const auto IntermediateDesc = pIntermediate->GetDesc();
+    const auto DestinationDesc = pDestinationResource->GetDesc();
+    if (IntermediateDesc.Dimension != D3D12_RESOURCE_DIMENSION_BUFFER ||
+        IntermediateDesc.Width < RequiredSize + pLayouts[0].Offset ||
+        RequiredSize > SIZE_T(-1) ||
+        (DestinationDesc.Dimension == D3D12_RESOURCE_DIMENSION_BUFFER &&
+            (FirstSubresource != 0 || NumSubresources != 1)))
+    {
+        return 0;
+    }
+
+    BYTE* pData;
+    HRESULT hr = pIntermediate->Map(0, nullptr, reinterpret_cast<void**>(&pData));
+    if (FAILED(hr))
+    {
+        return 0;
+    }
+
+    for (UINT i = 0; i < NumSubresources; ++i)
+    {
+        if (pRowSizesInBytes[i] > SIZE_T(-1)) return 0;
+        D3D12_MEMCPY_DEST DestData = { pData + pLayouts[i].Offset, pLayouts[i].Footprint.RowPitch, SIZE_T(pLayouts[i].Footprint.RowPitch) * SIZE_T(pNumRows[i]) };
+        MemcpySubresource(&DestData, &pSrcData[i], static_cast<SIZE_T>(pRowSizesInBytes[i]), pNumRows[i], pLayouts[i].Footprint.Depth);
+    }
+    pIntermediate->Unmap(0, nullptr);
+
+    if (DestinationDesc.Dimension == D3D12_RESOURCE_DIMENSION_BUFFER)
+    {
+        pCmdList->CopyBufferRegion(
+            pDestinationResource, 0, pIntermediate, pLayouts[0].Offset, pLayouts[0].Footprint.Width);
+    }
+    else
+    {
+        for (UINT i = 0; i < NumSubresources; ++i)
+        {
+            const CD3DX12_TEXTURE_COPY_LOCATION Dst(pDestinationResource, i + FirstSubresource);
+            const CD3DX12_TEXTURE_COPY_LOCATION Src(pIntermediate, pLayouts[i]);
+            pCmdList->CopyTextureRegion(&Dst, 0, 0, 0, &Src, nullptr);
+        }
+    }
+    return RequiredSize;
+}
+
+//------------------------------------------------------------------------------------------------
+// All arrays must be populated (e.g. by calling GetCopyableFootprints)
+inline UINT64 UpdateSubresources(
+    _In_ ID3D12GraphicsCommandList* pCmdList,
+    _In_ ID3D12Resource* pDestinationResource,
+    _In_ ID3D12Resource* pIntermediate,
+    _In_range_(0,D3D12_REQ_SUBRESOURCES) UINT FirstSubresource,
+    _In_range_(0,D3D12_REQ_SUBRESOURCES-FirstSubresource) UINT NumSubresources,
+    UINT64 RequiredSize,
+    _In_reads_(NumSubresources) const D3D12_PLACED_SUBRESOURCE_FOOTPRINT* pLayouts,
+    _In_reads_(NumSubresources) const UINT* pNumRows,
+    _In_reads_(NumSubresources) const UINT64* pRowSizesInBytes,
+    _In_ const void* pResourceData,
+    _In_reads_(NumSubresources) const D3D12_SUBRESOURCE_INFO* pSrcData) noexcept
+{
+    // Minor validation
+    const auto IntermediateDesc = pIntermediate->GetDesc();
+    const auto DestinationDesc = pDestinationResource->GetDesc();
+    if (IntermediateDesc.Dimension != D3D12_RESOURCE_DIMENSION_BUFFER ||
+        IntermediateDesc.Width < RequiredSize + pLayouts[0].Offset ||
+        RequiredSize > SIZE_T(-1) ||
+        (DestinationDesc.Dimension == D3D12_RESOURCE_DIMENSION_BUFFER &&
+            (FirstSubresource != 0 || NumSubresources != 1)))
+    {
+        return 0;
+    }
+
+    BYTE* pData;
+    HRESULT hr = pIntermediate->Map(0, nullptr, reinterpret_cast<void**>(&pData));
+    if (FAILED(hr))
+    {
+        return 0;
+    }
+
+    for (UINT i = 0; i < NumSubresources; ++i)
+    {
+        if (pRowSizesInBytes[i] > SIZE_T(-1)) return 0;
+        D3D12_MEMCPY_DEST DestData = { pData + pLayouts[i].Offset, pLayouts[i].Footprint.RowPitch, SIZE_T(pLayouts[i].Footprint.RowPitch) * SIZE_T(pNumRows[i]) };
+        MemcpySubresource(&DestData, pResourceData, &pSrcData[i], static_cast<SIZE_T>(pRowSizesInBytes[i]), pNumRows[i], pLayouts[i].Footprint.Depth);
+    }
+    pIntermediate->Unmap(0, nullptr);
+
+    if (DestinationDesc.Dimension == D3D12_RESOURCE_DIMENSION_BUFFER)
+    {
+        pCmdList->CopyBufferRegion(
+            pDestinationResource, 0, pIntermediate, pLayouts[0].Offset, pLayouts[0].Footprint.Width);
+    }
+    else
+    {
+        for (UINT i = 0; i < NumSubresources; ++i)
+        {
+            const CD3DX12_TEXTURE_COPY_LOCATION Dst(pDestinationResource, i + FirstSubresource);
+            const CD3DX12_TEXTURE_COPY_LOCATION Src(pIntermediate, pLayouts[i]);
+            pCmdList->CopyTextureRegion(&Dst, 0, 0, 0, &Src, nullptr);
+        }
+    }
+    return RequiredSize;
+}
+
+//------------------------------------------------------------------------------------------------
+// Heap-allocating UpdateSubresources implementation
+inline UINT64 UpdateSubresources(
+    _In_ ID3D12GraphicsCommandList* pCmdList,
+    _In_ ID3D12Resource* pDestinationResource,
+    _In_ ID3D12Resource* pIntermediate,
+    UINT64 IntermediateOffset,
+    _In_range_(0,D3D12_REQ_SUBRESOURCES) UINT FirstSubresource,
+    _In_range_(0,D3D12_REQ_SUBRESOURCES-FirstSubresource) UINT NumSubresources,
+    _In_reads_(NumSubresources) const D3D12_SUBRESOURCE_DATA* pSrcData) noexcept
+{
+    UINT64 RequiredSize = 0;
+    const auto MemToAlloc = static_cast<UINT64>(sizeof(D3D12_PLACED_SUBRESOURCE_FOOTPRINT) + sizeof(UINT) + sizeof(UINT64)) * NumSubresources;
+    if (MemToAlloc > SIZE_MAX)
+    {
+       return 0;
+    }
+    void* pMem = HeapAlloc(GetProcessHeap(), 0, static_cast<SIZE_T>(MemToAlloc));
+    if (pMem == nullptr)
+    {
+       return 0;
+    }
+    auto pLayouts = static_cast<D3D12_PLACED_SUBRESOURCE_FOOTPRINT*>(pMem);
+    auto pRowSizesInBytes = reinterpret_cast<UINT64*>(pLayouts + NumSubresources);
+    auto pNumRows = reinterpret_cast<UINT*>(pRowSizesInBytes + NumSubresources);
+
+    const auto Desc = pDestinationResource->GetDesc();
+    ID3D12Device* pDevice = nullptr;
+    pDestinationResource->GetDevice(IID_ID3D12Device, reinterpret_cast<void**>(&pDevice));
+    pDevice->GetCopyableFootprints(&Desc, FirstSubresource, NumSubresources, IntermediateOffset, pLayouts, pNumRows, pRowSizesInBytes, &RequiredSize);
+    pDevice->Release();
+
+    const UINT64 Result = UpdateSubresources(pCmdList, pDestinationResource, pIntermediate, FirstSubresource, NumSubresources, RequiredSize, pLayouts, pNumRows, pRowSizesInBytes, pSrcData);
+    HeapFree(GetProcessHeap(), 0, pMem);
+    return Result;
+}
+
+//------------------------------------------------------------------------------------------------
+// Heap-allocating UpdateSubresources implementation
+inline UINT64 UpdateSubresources(
+    _In_ ID3D12GraphicsCommandList* pCmdList,
+    _In_ ID3D12Resource* pDestinationResource,
+    _In_ ID3D12Resource* pIntermediate,
+    UINT64 IntermediateOffset,
+    _In_range_(0,D3D12_REQ_SUBRESOURCES) UINT FirstSubresource,
+    _In_range_(0,D3D12_REQ_SUBRESOURCES-FirstSubresource) UINT NumSubresources,
+    _In_ const void* pResourceData,
+    _In_reads_(NumSubresources) const D3D12_SUBRESOURCE_INFO* pSrcData) noexcept
+{
+    UINT64 RequiredSize = 0;
+    const auto MemToAlloc = static_cast<UINT64>(sizeof(D3D12_PLACED_SUBRESOURCE_FOOTPRINT) + sizeof(UINT) + sizeof(UINT64)) * NumSubresources;
+    if (MemToAlloc > SIZE_MAX)
+    {
+        return 0;
+    }
+    void* pMem = HeapAlloc(GetProcessHeap(), 0, static_cast<SIZE_T>(MemToAlloc));
+    if (pMem == nullptr)
+    {
+        return 0;
+    }
+    auto pLayouts = static_cast<D3D12_PLACED_SUBRESOURCE_FOOTPRINT*>(pMem);
+    auto pRowSizesInBytes = reinterpret_cast<UINT64*>(pLayouts + NumSubresources);
+    auto pNumRows = reinterpret_cast<UINT*>(pRowSizesInBytes + NumSubresources);
+
+    const auto Desc = pDestinationResource->GetDesc();
+    ID3D12Device* pDevice = nullptr;
+    pDestinationResource->GetDevice(IID_ID3D12Device, reinterpret_cast<void**>(&pDevice));
+    pDevice->GetCopyableFootprints(&Desc, FirstSubresource, NumSubresources, IntermediateOffset, pLayouts, pNumRows, pRowSizesInBytes, &RequiredSize);
+    pDevice->Release();
+
+    const UINT64 Result = UpdateSubresources(pCmdList, pDestinationResource, pIntermediate, FirstSubresource, NumSubresources, RequiredSize, pLayouts, pNumRows, pRowSizesInBytes, pResourceData, pSrcData);
+    HeapFree(GetProcessHeap(), 0, pMem);
+    return Result;
+}
+
+//------------------------------------------------------------------------------------------------
+// Stack-allocating UpdateSubresources implementation
+template <UINT MaxSubresources>
+inline UINT64 UpdateSubresources(
+    _In_ ID3D12GraphicsCommandList* pCmdList,
+    _In_ ID3D12Resource* pDestinationResource,
+    _In_ ID3D12Resource* pIntermediate,
+    UINT64 IntermediateOffset,
+    _In_range_(0,MaxSubresources) UINT FirstSubresource,
+    _In_range_(1,MaxSubresources-FirstSubresource) UINT NumSubresources,
+    _In_reads_(NumSubresources) const D3D12_SUBRESOURCE_DATA* pSrcData) noexcept
+{
+    UINT64 RequiredSize = 0;
+    D3D12_PLACED_SUBRESOURCE_FOOTPRINT Layouts[MaxSubresources];
+    UINT NumRows[MaxSubresources];
+    UINT64 RowSizesInBytes[MaxSubresources];
+
+    const auto Desc = pDestinationResource->GetDesc();
+    ID3D12Device* pDevice = nullptr;
+    pDestinationResource->GetDevice(IID_ID3D12Device, reinterpret_cast<void**>(&pDevice));
+    pDevice->GetCopyableFootprints(&Desc, FirstSubresource, NumSubresources, IntermediateOffset, Layouts, NumRows, RowSizesInBytes, &RequiredSize);
+    pDevice->Release();
+
+    return UpdateSubresources(pCmdList, pDestinationResource, pIntermediate, FirstSubresource, NumSubresources, RequiredSize, Layouts, NumRows, RowSizesInBytes, pSrcData);
+}
+
+//------------------------------------------------------------------------------------------------
+// Stack-allocating UpdateSubresources implementation
+template <UINT MaxSubresources>
+inline UINT64 UpdateSubresources(
+    _In_ ID3D12GraphicsCommandList* pCmdList,
+    _In_ ID3D12Resource* pDestinationResource,
+    _In_ ID3D12Resource* pIntermediate,
+    UINT64 IntermediateOffset,
+    _In_range_(0,MaxSubresources) UINT FirstSubresource,
+    _In_range_(1,MaxSubresources-FirstSubresource) UINT NumSubresources,
+    _In_ const void* pResourceData,
+    _In_reads_(NumSubresources) const D3D12_SUBRESOURCE_INFO* pSrcData) noexcept
+{
+    UINT64 RequiredSize = 0;
+    D3D12_PLACED_SUBRESOURCE_FOOTPRINT Layouts[MaxSubresources];
+    UINT NumRows[MaxSubresources];
+    UINT64 RowSizesInBytes[MaxSubresources];
+
+    const auto Desc = pDestinationResource->GetDesc();
+    ID3D12Device* pDevice = nullptr;
+    pDestinationResource->GetDevice(IID_ID3D12Device, reinterpret_cast<void**>(&pDevice));
+    pDevice->GetCopyableFootprints(&Desc, FirstSubresource, NumSubresources, IntermediateOffset, Layouts, NumRows, RowSizesInBytes, &RequiredSize);
+    pDevice->Release();
+
+    return UpdateSubresources(pCmdList, pDestinationResource, pIntermediate, FirstSubresource, NumSubresources, RequiredSize, Layouts, NumRows, RowSizesInBytes, pResourceData, pSrcData);
+}
+
+//------------------------------------------------------------------------------------------------
+constexpr bool D3D12IsLayoutOpaque( D3D12_TEXTURE_LAYOUT Layout ) noexcept
+{ return Layout == D3D12_TEXTURE_LAYOUT_UNKNOWN || Layout == D3D12_TEXTURE_LAYOUT_64KB_UNDEFINED_SWIZZLE; }
+
+//------------------------------------------------------------------------------------------------
+template <typename t_CommandListType>
+inline ID3D12CommandList * const * CommandListCast(t_CommandListType * const * pp) noexcept
+{
+    // This cast is useful for passing strongly typed command list pointers into
+    // ExecuteCommandLists.
+    // This cast is valid as long as the const-ness is respected. D3D12 APIs do
+    // respect the const-ness of their arguments.
+    return reinterpret_cast<ID3D12CommandList * const *>(pp);
+}
+
+//------------------------------------------------------------------------------------------------
+// D3D12 exports a new method for serializing root signatures in the Windows 10 Anniversary Update.
+// To help enable root signature 1.1 features when they are available and not require maintaining
+// two code paths for building root signatures, this helper method reconstructs a 1.0 signature when
+// 1.1 is not supported.
+inline HRESULT D3DX12SerializeVersionedRootSignature(
+    _In_ const D3D12_VERSIONED_ROOT_SIGNATURE_DESC* pRootSignatureDesc,
+    D3D_ROOT_SIGNATURE_VERSION MaxVersion,
+    _Outptr_ ID3DBlob** ppBlob,
+    _Always_(_Outptr_opt_result_maybenull_) ID3DBlob** ppErrorBlob) noexcept
+{
+    if (ppErrorBlob != nullptr)
+    {
+        *ppErrorBlob = nullptr;
+    }
+
+    switch (MaxVersion)
+    {
+        case D3D_ROOT_SIGNATURE_VERSION_1_0:
+            switch (pRootSignatureDesc->Version)
+            {
+                case D3D_ROOT_SIGNATURE_VERSION_1_0:
+                    return D3D12SerializeRootSignature(&pRootSignatureDesc->Desc_1_0, D3D_ROOT_SIGNATURE_VERSION_1, ppBlob, ppErrorBlob);
+
+                case D3D_ROOT_SIGNATURE_VERSION_1_1:
+                {
+                    HRESULT hr = S_OK;
+                    const D3D12_ROOT_SIGNATURE_DESC1& desc_1_1 = pRootSignatureDesc->Desc_1_1;
+
+                    const SIZE_T ParametersSize = sizeof(D3D12_ROOT_PARAMETER) * desc_1_1.NumParameters;
+                    void* pParameters = (ParametersSize > 0) ? HeapAlloc(GetProcessHeap(), 0, ParametersSize) : nullptr;
+                    if (ParametersSize > 0 && pParameters == nullptr)
+                    {
+                        hr = E_OUTOFMEMORY;
+                    }
+                    auto pParameters_1_0 = static_cast<D3D12_ROOT_PARAMETER*>(pParameters);
+
+                    if (SUCCEEDED(hr))
+                    {
+                        for (UINT n = 0; n < desc_1_1.NumParameters; n++)
+                        {
+                            __analysis_assume(ParametersSize == sizeof(D3D12_ROOT_PARAMETER) * desc_1_1.NumParameters);
+                            pParameters_1_0[n].ParameterType = desc_1_1.pParameters[n].ParameterType;
+                            pParameters_1_0[n].ShaderVisibility = desc_1_1.pParameters[n].ShaderVisibility;
+
+                            switch (desc_1_1.pParameters[n].ParameterType)
+                            {
+                            case D3D12_ROOT_PARAMETER_TYPE_32BIT_CONSTANTS:
+                                pParameters_1_0[n].Constants.Num32BitValues = desc_1_1.pParameters[n].Constants.Num32BitValues;
+                                pParameters_1_0[n].Constants.RegisterSpace = desc_1_1.pParameters[n].Constants.RegisterSpace;
+                                pParameters_1_0[n].Constants.ShaderRegister = desc_1_1.pParameters[n].Constants.ShaderRegister;
+                                break;
+
+                            case D3D12_ROOT_PARAMETER_TYPE_CBV:
+                            case D3D12_ROOT_PARAMETER_TYPE_SRV:
+                            case D3D12_ROOT_PARAMETER_TYPE_UAV:
+                                pParameters_1_0[n].Descriptor.RegisterSpace = desc_1_1.pParameters[n].Descriptor.RegisterSpace;
+                                pParameters_1_0[n].Descriptor.ShaderRegister = desc_1_1.pParameters[n].Descriptor.ShaderRegister;
+                                break;
+
+                            case D3D12_ROOT_PARAMETER_TYPE_DESCRIPTOR_TABLE:
+                                const D3D12_ROOT_DESCRIPTOR_TABLE1& table_1_1 = desc_1_1.pParameters[n].DescriptorTable;
+
+                                const SIZE_T DescriptorRangesSize = sizeof(D3D12_DESCRIPTOR_RANGE) * table_1_1.NumDescriptorRanges;
+                                void* pDescriptorRanges = (DescriptorRangesSize > 0 && SUCCEEDED(hr)) ? HeapAlloc(GetProcessHeap(), 0, DescriptorRangesSize) : nullptr;
+                                if (DescriptorRangesSize > 0 && pDescriptorRanges == nullptr)
+                                {
+                                    hr = E_OUTOFMEMORY;
+                                }
+                                auto pDescriptorRanges_1_0 = static_cast<D3D12_DESCRIPTOR_RANGE*>(pDescriptorRanges);
+
+                                if (SUCCEEDED(hr))
+                                {
+                                    for (UINT x = 0; x < table_1_1.NumDescriptorRanges; x++)
+                                    {
+                                        __analysis_assume(DescriptorRangesSize == sizeof(D3D12_DESCRIPTOR_RANGE) * table_1_1.NumDescriptorRanges);
+                                        pDescriptorRanges_1_0[x].BaseShaderRegister = table_1_1.pDescriptorRanges[x].BaseShaderRegister;
+                                        pDescriptorRanges_1_0[x].NumDescriptors = table_1_1.pDescriptorRanges[x].NumDescriptors;
+                                        pDescriptorRanges_1_0[x].OffsetInDescriptorsFromTableStart = table_1_1.pDescriptorRanges[x].OffsetInDescriptorsFromTableStart;
+                                        pDescriptorRanges_1_0[x].RangeType = table_1_1.pDescriptorRanges[x].RangeType;
+                                        pDescriptorRanges_1_0[x].RegisterSpace = table_1_1.pDescriptorRanges[x].RegisterSpace;
+                                    }
+                                }
+
+                                D3D12_ROOT_DESCRIPTOR_TABLE& table_1_0 = pParameters_1_0[n].DescriptorTable;
+                                table_1_0.NumDescriptorRanges = table_1_1.NumDescriptorRanges;
+                                table_1_0.pDescriptorRanges = pDescriptorRanges_1_0;
+                            }
+                        }
+                    }
+
+                    if (SUCCEEDED(hr))
+                    {
+                        const CD3DX12_ROOT_SIGNATURE_DESC desc_1_0(desc_1_1.NumParameters, pParameters_1_0, desc_1_1.NumStaticSamplers, desc_1_1.pStaticSamplers, desc_1_1.Flags);
+                        hr = D3D12SerializeRootSignature(&desc_1_0, D3D_ROOT_SIGNATURE_VERSION_1, ppBlob, ppErrorBlob);
+                    }
+
+                    if (pParameters)
+                    {
+                        for (UINT n = 0; n < desc_1_1.NumParameters; n++)
+                        {
+                            if (desc_1_1.pParameters[n].ParameterType == D3D12_ROOT_PARAMETER_TYPE_DESCRIPTOR_TABLE)
+                            {
+                                auto pDescriptorRanges_1_0 = pParameters_1_0[n].DescriptorTable.pDescriptorRanges;
+                                HeapFree(GetProcessHeap(), 0, reinterpret_cast<void*>(const_cast<D3D12_DESCRIPTOR_RANGE*>(pDescriptorRanges_1_0)));
+                            }
+                        }
+                        HeapFree(GetProcessHeap(), 0, pParameters);
+                    }
+                    return hr;
+                }
+            }
+            break;
+
+        case D3D_ROOT_SIGNATURE_VERSION_1_1:
+            return D3D12SerializeVersionedRootSignature(pRootSignatureDesc, ppBlob, ppErrorBlob);
+    }
+
+    return E_INVALIDARG;
+}
+
+//------------------------------------------------------------------------------------------------
+struct CD3DX12_RT_FORMAT_ARRAY : public D3D12_RT_FORMAT_ARRAY
+{
+    CD3DX12_RT_FORMAT_ARRAY() = default;
+    explicit CD3DX12_RT_FORMAT_ARRAY(const D3D12_RT_FORMAT_ARRAY& o) noexcept
+        : D3D12_RT_FORMAT_ARRAY(o)
+    {}
+    explicit CD3DX12_RT_FORMAT_ARRAY(_In_reads_(NumFormats) const DXGI_FORMAT* pFormats, UINT NumFormats) noexcept
+    {
+        NumRenderTargets = NumFormats;
+        memcpy(RTFormats, pFormats, sizeof(RTFormats));
+        // assumes ARRAY_SIZE(pFormats) == ARRAY_SIZE(RTFormats)
+    }
+};
+
+//------------------------------------------------------------------------------------------------
+// Pipeline State Stream Helpers
+//------------------------------------------------------------------------------------------------
+
+//------------------------------------------------------------------------------------------------
+// Stream Subobjects, i.e. elements of a stream
+
+struct DefaultSampleMask { operator UINT() noexcept { return UINT_MAX; } };
+struct DefaultSampleDesc { operator DXGI_SAMPLE_DESC() noexcept { return DXGI_SAMPLE_DESC{1, 0}; } };
+
+#pragma warning(push)
+#pragma warning(disable : 4324)
+template <typename InnerStructType, D3D12_PIPELINE_STATE_SUBOBJECT_TYPE Type, typename DefaultArg = InnerStructType>
+class alignas(void*) CD3DX12_PIPELINE_STATE_STREAM_SUBOBJECT
+{
+private:
+    D3D12_PIPELINE_STATE_SUBOBJECT_TYPE pssType;
+    InnerStructType pssInner;
+public:
+    CD3DX12_PIPELINE_STATE_STREAM_SUBOBJECT() noexcept : pssType(Type), pssInner(DefaultArg()) {}
+    CD3DX12_PIPELINE_STATE_STREAM_SUBOBJECT(InnerStructType const& i) noexcept : pssType(Type), pssInner(i) {}
+    CD3DX12_PIPELINE_STATE_STREAM_SUBOBJECT& operator=(InnerStructType const& i) noexcept { pssType = Type; pssInner = i; return *this; }
+    operator InnerStructType const&() const noexcept { return pssInner; }
+    operator InnerStructType&() noexcept { return pssInner; }
+    InnerStructType* operator&() noexcept { return &pssInner; }
+    InnerStructType const* operator&() const noexcept { return &pssInner; }
+};
+#pragma warning(pop)
+typedef CD3DX12_PIPELINE_STATE_STREAM_SUBOBJECT< D3D12_PIPELINE_STATE_FLAGS,         D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_FLAGS>                             CD3DX12_PIPELINE_STATE_STREAM_FLAGS;
+typedef CD3DX12_PIPELINE_STATE_STREAM_SUBOBJECT< UINT,                               D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_NODE_MASK>                         CD3DX12_PIPELINE_STATE_STREAM_NODE_MASK;
+typedef CD3DX12_PIPELINE_STATE_STREAM_SUBOBJECT< ID3D12RootSignature*,               D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_ROOT_SIGNATURE>                    CD3DX12_PIPELINE_STATE_STREAM_ROOT_SIGNATURE;
+typedef CD3DX12_PIPELINE_STATE_STREAM_SUBOBJECT< D3D12_INPUT_LAYOUT_DESC,            D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_INPUT_LAYOUT>                      CD3DX12_PIPELINE_STATE_STREAM_INPUT_LAYOUT;
+typedef CD3DX12_PIPELINE_STATE_STREAM_SUBOBJECT< D3D12_INDEX_BUFFER_STRIP_CUT_VALUE, D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_IB_STRIP_CUT_VALUE>                CD3DX12_PIPELINE_STATE_STREAM_IB_STRIP_CUT_VALUE;
+typedef CD3DX12_PIPELINE_STATE_STREAM_SUBOBJECT< D3D12_PRIMITIVE_TOPOLOGY_TYPE,      D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_PRIMITIVE_TOPOLOGY>                CD3DX12_PIPELINE_STATE_STREAM_PRIMITIVE_TOPOLOGY;
+typedef CD3DX12_PIPELINE_STATE_STREAM_SUBOBJECT< D3D12_SHADER_BYTECODE,              D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_VS>                                CD3DX12_PIPELINE_STATE_STREAM_VS;
+typedef CD3DX12_PIPELINE_STATE_STREAM_SUBOBJECT< D3D12_SHADER_BYTECODE,              D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_GS>                                CD3DX12_PIPELINE_STATE_STREAM_GS;
+typedef CD3DX12_PIPELINE_STATE_STREAM_SUBOBJECT< D3D12_STREAM_OUTPUT_DESC,           D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_STREAM_OUTPUT>                     CD3DX12_PIPELINE_STATE_STREAM_STREAM_OUTPUT;
+typedef CD3DX12_PIPELINE_STATE_STREAM_SUBOBJECT< D3D12_SHADER_BYTECODE,              D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_HS>                                CD3DX12_PIPELINE_STATE_STREAM_HS;
+typedef CD3DX12_PIPELINE_STATE_STREAM_SUBOBJECT< D3D12_SHADER_BYTECODE,              D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_DS>                                CD3DX12_PIPELINE_STATE_STREAM_DS;
+typedef CD3DX12_PIPELINE_STATE_STREAM_SUBOBJECT< D3D12_SHADER_BYTECODE,              D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_PS>                                CD3DX12_PIPELINE_STATE_STREAM_PS;
+typedef CD3DX12_PIPELINE_STATE_STREAM_SUBOBJECT< D3D12_SHADER_BYTECODE,              D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_AS>                                CD3DX12_PIPELINE_STATE_STREAM_AS;
+typedef CD3DX12_PIPELINE_STATE_STREAM_SUBOBJECT< D3D12_SHADER_BYTECODE,              D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_MS>                                CD3DX12_PIPELINE_STATE_STREAM_MS;
+typedef CD3DX12_PIPELINE_STATE_STREAM_SUBOBJECT< D3D12_SHADER_BYTECODE,              D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_CS>                                CD3DX12_PIPELINE_STATE_STREAM_CS;
+typedef CD3DX12_PIPELINE_STATE_STREAM_SUBOBJECT< CD3DX12_BLEND_DESC,                 D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_BLEND,          CD3DX12_DEFAULT>   CD3DX12_PIPELINE_STATE_STREAM_BLEND_DESC;
+typedef CD3DX12_PIPELINE_STATE_STREAM_SUBOBJECT< CD3DX12_DEPTH_STENCIL_DESC,         D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_DEPTH_STENCIL,  CD3DX12_DEFAULT>   CD3DX12_PIPELINE_STATE_STREAM_DEPTH_STENCIL;
+typedef CD3DX12_PIPELINE_STATE_STREAM_SUBOBJECT< CD3DX12_DEPTH_STENCIL_DESC1,        D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_DEPTH_STENCIL1, CD3DX12_DEFAULT>   CD3DX12_PIPELINE_STATE_STREAM_DEPTH_STENCIL1;
+typedef CD3DX12_PIPELINE_STATE_STREAM_SUBOBJECT< CD3DX12_DEPTH_STENCIL_DESC2,        D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_DEPTH_STENCIL2, CD3DX12_DEFAULT>   CD3DX12_PIPELINE_STATE_STREAM_DEPTH_STENCIL2;
+typedef CD3DX12_PIPELINE_STATE_STREAM_SUBOBJECT< DXGI_FORMAT,                        D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_DEPTH_STENCIL_FORMAT>              CD3DX12_PIPELINE_STATE_STREAM_DEPTH_STENCIL_FORMAT;
+typedef CD3DX12_PIPELINE_STATE_STREAM_SUBOBJECT< CD3DX12_RASTERIZER_DESC,            D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_RASTERIZER,     CD3DX12_DEFAULT>   CD3DX12_PIPELINE_STATE_STREAM_RASTERIZER;
+typedef CD3DX12_PIPELINE_STATE_STREAM_SUBOBJECT< D3D12_RT_FORMAT_ARRAY,              D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_RENDER_TARGET_FORMATS>             CD3DX12_PIPELINE_STATE_STREAM_RENDER_TARGET_FORMATS;
+typedef CD3DX12_PIPELINE_STATE_STREAM_SUBOBJECT< DXGI_SAMPLE_DESC,                   D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_SAMPLE_DESC,    DefaultSampleDesc> CD3DX12_PIPELINE_STATE_STREAM_SAMPLE_DESC;
+typedef CD3DX12_PIPELINE_STATE_STREAM_SUBOBJECT< UINT,                               D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_SAMPLE_MASK,    DefaultSampleMask> CD3DX12_PIPELINE_STATE_STREAM_SAMPLE_MASK;
+typedef CD3DX12_PIPELINE_STATE_STREAM_SUBOBJECT< D3D12_CACHED_PIPELINE_STATE,        D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_CACHED_PSO>                        CD3DX12_PIPELINE_STATE_STREAM_CACHED_PSO;
+typedef CD3DX12_PIPELINE_STATE_STREAM_SUBOBJECT< CD3DX12_VIEW_INSTANCING_DESC,       D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_VIEW_INSTANCING, CD3DX12_DEFAULT>  CD3DX12_PIPELINE_STATE_STREAM_VIEW_INSTANCING;
+
+//------------------------------------------------------------------------------------------------
+// Stream Parser Helpers
+
+struct ID3DX12PipelineParserCallbacks
+{
+    // Subobject Callbacks
+    virtual void FlagsCb(D3D12_PIPELINE_STATE_FLAGS) {}
+    virtual void NodeMaskCb(UINT) {}
+    virtual void RootSignatureCb(ID3D12RootSignature*) {}
+    virtual void InputLayoutCb(const D3D12_INPUT_LAYOUT_DESC&) {}
+    virtual void IBStripCutValueCb(D3D12_INDEX_BUFFER_STRIP_CUT_VALUE) {}
+    virtual void PrimitiveTopologyTypeCb(D3D12_PRIMITIVE_TOPOLOGY_TYPE) {}
+    virtual void VSCb(const D3D12_SHADER_BYTECODE&) {}
+    virtual void GSCb(const D3D12_SHADER_BYTECODE&) {}
+    virtual void StreamOutputCb(const D3D12_STREAM_OUTPUT_DESC&) {}
+    virtual void HSCb(const D3D12_SHADER_BYTECODE&) {}
+    virtual void DSCb(const D3D12_SHADER_BYTECODE&) {}
+    virtual void PSCb(const D3D12_SHADER_BYTECODE&) {}
+    virtual void CSCb(const D3D12_SHADER_BYTECODE&) {}
+    virtual void ASCb(const D3D12_SHADER_BYTECODE&) {}
+    virtual void MSCb(const D3D12_SHADER_BYTECODE&) {}
+    virtual void BlendStateCb(const D3D12_BLEND_DESC&) {}
+    virtual void DepthStencilStateCb(const D3D12_DEPTH_STENCIL_DESC&) {}
+    virtual void DepthStencilState1Cb(const D3D12_DEPTH_STENCIL_DESC1&) {}
+    virtual void DepthStencilState2Cb(const D3D12_DEPTH_STENCIL_DESC2&) {}
+    virtual void DSVFormatCb(DXGI_FORMAT) {}
+    virtual void RasterizerStateCb(const D3D12_RASTERIZER_DESC&) {}
+    virtual void RTVFormatsCb(const D3D12_RT_FORMAT_ARRAY&) {}
+    virtual void SampleDescCb(const DXGI_SAMPLE_DESC&) {}
+    virtual void SampleMaskCb(UINT) {}
+    virtual void ViewInstancingCb(const D3D12_VIEW_INSTANCING_DESC&) {}
+    virtual void CachedPSOCb(const D3D12_CACHED_PIPELINE_STATE&) {}
+
+    // Error Callbacks
+    virtual void ErrorBadInputParameter(UINT /*ParameterIndex*/) {}
+    virtual void ErrorDuplicateSubobject(D3D12_PIPELINE_STATE_SUBOBJECT_TYPE /*DuplicateType*/) {}
+    virtual void ErrorUnknownSubobject(UINT /*UnknownTypeValue*/) {}
+
+    virtual ~ID3DX12PipelineParserCallbacks() = default;
+};
+
+struct D3DX12_MESH_SHADER_PIPELINE_STATE_DESC
+{
+    ID3D12RootSignature*          pRootSignature;
+    D3D12_SHADER_BYTECODE         AS;
+    D3D12_SHADER_BYTECODE         MS;
+    D3D12_SHADER_BYTECODE         PS;
+    D3D12_BLEND_DESC              BlendState;
+    UINT                          SampleMask;
+    D3D12_RASTERIZER_DESC         RasterizerState;
+    D3D12_DEPTH_STENCIL_DESC      DepthStencilState;
+    D3D12_PRIMITIVE_TOPOLOGY_TYPE PrimitiveTopologyType;
+    UINT                          NumRenderTargets;
+    DXGI_FORMAT                   RTVFormats[ D3D12_SIMULTANEOUS_RENDER_TARGET_COUNT ];
+    DXGI_FORMAT                   DSVFormat;
+    DXGI_SAMPLE_DESC              SampleDesc;
+    UINT                          NodeMask;
+    D3D12_CACHED_PIPELINE_STATE   CachedPSO;
+    D3D12_PIPELINE_STATE_FLAGS    Flags;
+};
+
+
+// Use CD3DX12_PIPELINE_STATE_STREAM3 for D3D12_DEPTH_STENCIL_DESC2 when CheckFeatureSupport returns true for Options14::IndependentFrontAndBackStencilSupported is true
+// Use CD3DX12_PIPELINE_STATE_STREAM2 for OS Build 19041+ (where there is a new mesh shader pipeline).
+// Use CD3DX12_PIPELINE_STATE_STREAM1 for OS Build 16299+ (where there is a new view instancing subobject).
+// Use CD3DX12_PIPELINE_STATE_STREAM for OS Build 15063+ support.
+struct CD3DX12_PIPELINE_STATE_STREAM3
+{
+    CD3DX12_PIPELINE_STATE_STREAM3() = default;
+    // Mesh and amplification shaders must be set manually, since they do not have representation in D3D12_GRAPHICS_PIPELINE_STATE_DESC
+    CD3DX12_PIPELINE_STATE_STREAM3(const D3D12_GRAPHICS_PIPELINE_STATE_DESC& Desc) noexcept
+        : Flags(Desc.Flags)
+        , NodeMask(Desc.NodeMask)
+        , pRootSignature(Desc.pRootSignature)
+        , InputLayout(Desc.InputLayout)
+        , IBStripCutValue(Desc.IBStripCutValue)
+        , PrimitiveTopologyType(Desc.PrimitiveTopologyType)
+        , VS(Desc.VS)
+        , GS(Desc.GS)
+        , StreamOutput(Desc.StreamOutput)
+        , HS(Desc.HS)
+        , DS(Desc.DS)
+        , PS(Desc.PS)
+        , BlendState(CD3DX12_BLEND_DESC(Desc.BlendState))
+        , DepthStencilState(CD3DX12_DEPTH_STENCIL_DESC2(Desc.DepthStencilState))
+        , DSVFormat(Desc.DSVFormat)
+        , RasterizerState(CD3DX12_RASTERIZER_DESC(Desc.RasterizerState))
+        , RTVFormats(CD3DX12_RT_FORMAT_ARRAY(Desc.RTVFormats, Desc.NumRenderTargets))
+        , SampleDesc(Desc.SampleDesc)
+        , SampleMask(Desc.SampleMask)
+        , CachedPSO(Desc.CachedPSO)
+        , ViewInstancingDesc(CD3DX12_VIEW_INSTANCING_DESC(CD3DX12_DEFAULT()))
+    {}
+    CD3DX12_PIPELINE_STATE_STREAM3(const D3DX12_MESH_SHADER_PIPELINE_STATE_DESC& Desc) noexcept
+        : Flags(Desc.Flags)
+        , NodeMask(Desc.NodeMask)
+        , pRootSignature(Desc.pRootSignature)
+        , PrimitiveTopologyType(Desc.PrimitiveTopologyType)
+        , PS(Desc.PS)
+        , AS(Desc.AS)
+        , MS(Desc.MS)
+        , BlendState(CD3DX12_BLEND_DESC(Desc.BlendState))
+        , DepthStencilState(CD3DX12_DEPTH_STENCIL_DESC2(Desc.DepthStencilState))
+        , DSVFormat(Desc.DSVFormat)
+        , RasterizerState(CD3DX12_RASTERIZER_DESC(Desc.RasterizerState))
+        , RTVFormats(CD3DX12_RT_FORMAT_ARRAY(Desc.RTVFormats, Desc.NumRenderTargets))
+        , SampleDesc(Desc.SampleDesc)
+        , SampleMask(Desc.SampleMask)
+        , CachedPSO(Desc.CachedPSO)
+        , ViewInstancingDesc(CD3DX12_VIEW_INSTANCING_DESC(CD3DX12_DEFAULT()))
+    {}
+    CD3DX12_PIPELINE_STATE_STREAM3(const D3D12_COMPUTE_PIPELINE_STATE_DESC& Desc) noexcept
+        : Flags(Desc.Flags)
+        , NodeMask(Desc.NodeMask)
+        , pRootSignature(Desc.pRootSignature)
+        , CS(CD3DX12_SHADER_BYTECODE(Desc.CS))
+        , CachedPSO(Desc.CachedPSO)
+    {
+        static_cast<D3D12_DEPTH_STENCIL_DESC2&>(DepthStencilState).DepthEnable = false;
+    }
+    CD3DX12_PIPELINE_STATE_STREAM_FLAGS Flags;
+    CD3DX12_PIPELINE_STATE_STREAM_NODE_MASK NodeMask;
+    CD3DX12_PIPELINE_STATE_STREAM_ROOT_SIGNATURE pRootSignature;
+    CD3DX12_PIPELINE_STATE_STREAM_INPUT_LAYOUT InputLayout;
+    CD3DX12_PIPELINE_STATE_STREAM_IB_STRIP_CUT_VALUE IBStripCutValue;
+    CD3DX12_PIPELINE_STATE_STREAM_PRIMITIVE_TOPOLOGY PrimitiveTopologyType;
+    CD3DX12_PIPELINE_STATE_STREAM_VS VS;
+    CD3DX12_PIPELINE_STATE_STREAM_GS GS;
+    CD3DX12_PIPELINE_STATE_STREAM_STREAM_OUTPUT StreamOutput;
+    CD3DX12_PIPELINE_STATE_STREAM_HS HS;
+    CD3DX12_PIPELINE_STATE_STREAM_DS DS;
+    CD3DX12_PIPELINE_STATE_STREAM_PS PS;
+    CD3DX12_PIPELINE_STATE_STREAM_AS AS;
+    CD3DX12_PIPELINE_STATE_STREAM_MS MS;
+    CD3DX12_PIPELINE_STATE_STREAM_CS CS;
+    CD3DX12_PIPELINE_STATE_STREAM_BLEND_DESC BlendState;
+    CD3DX12_PIPELINE_STATE_STREAM_DEPTH_STENCIL2 DepthStencilState;
+    CD3DX12_PIPELINE_STATE_STREAM_DEPTH_STENCIL_FORMAT DSVFormat;
+    CD3DX12_PIPELINE_STATE_STREAM_RASTERIZER RasterizerState;
+    CD3DX12_PIPELINE_STATE_STREAM_RENDER_TARGET_FORMATS RTVFormats;
+    CD3DX12_PIPELINE_STATE_STREAM_SAMPLE_DESC SampleDesc;
+    CD3DX12_PIPELINE_STATE_STREAM_SAMPLE_MASK SampleMask;
+    CD3DX12_PIPELINE_STATE_STREAM_CACHED_PSO CachedPSO;
+    CD3DX12_PIPELINE_STATE_STREAM_VIEW_INSTANCING ViewInstancingDesc;
+    
+    D3D12_GRAPHICS_PIPELINE_STATE_DESC GraphicsDescV0() const noexcept
+    {
+        D3D12_GRAPHICS_PIPELINE_STATE_DESC D;
+        D.Flags                 = this->Flags;
+        D.NodeMask              = this->NodeMask;
+        D.pRootSignature        = this->pRootSignature;
+        D.InputLayout           = this->InputLayout;
+        D.IBStripCutValue       = this->IBStripCutValue;
+        D.PrimitiveTopologyType = this->PrimitiveTopologyType;
+        D.VS                    = this->VS;
+        D.GS                    = this->GS;
+        D.StreamOutput          = this->StreamOutput;
+        D.HS                    = this->HS;
+        D.DS                    = this->DS;
+        D.PS                    = this->PS;
+        D.BlendState            = this->BlendState;
+        D.DepthStencilState     = CD3DX12_DEPTH_STENCIL_DESC2(D3D12_DEPTH_STENCIL_DESC2(this->DepthStencilState));
+        D.DSVFormat             = this->DSVFormat;
+        D.RasterizerState       = this->RasterizerState;
+        D.NumRenderTargets      = D3D12_RT_FORMAT_ARRAY(this->RTVFormats).NumRenderTargets;
+        memcpy(D.RTVFormats, D3D12_RT_FORMAT_ARRAY(this->RTVFormats).RTFormats, sizeof(D.RTVFormats));
+        D.SampleDesc            = this->SampleDesc;
+        D.SampleMask            = this->SampleMask;
+        D.CachedPSO             = this->CachedPSO;
+        return D;
+    }
+    D3D12_COMPUTE_PIPELINE_STATE_DESC ComputeDescV0() const noexcept
+    {
+        D3D12_COMPUTE_PIPELINE_STATE_DESC D;
+        D.Flags                 = this->Flags;
+        D.NodeMask              = this->NodeMask;
+        D.pRootSignature        = this->pRootSignature;
+        D.CS                    = this->CS;
+        D.CachedPSO             = this->CachedPSO;
+        return D;
+    }
+};
+
+
+// CD3DX12_PIPELINE_STATE_STREAM2 Works on OS Build 19041+ (where there is a new mesh shader pipeline).
+// Use CD3DX12_PIPELINE_STATE_STREAM1 for OS Build 16299+ (where there is a new view instancing subobject).
+// Use CD3DX12_PIPELINE_STATE_STREAM for OS Build 15063+ support.
+struct CD3DX12_PIPELINE_STATE_STREAM2
+{
+    CD3DX12_PIPELINE_STATE_STREAM2() = default;
+    // Mesh and amplification shaders must be set manually, since they do not have representation in D3D12_GRAPHICS_PIPELINE_STATE_DESC
+    CD3DX12_PIPELINE_STATE_STREAM2(const D3D12_GRAPHICS_PIPELINE_STATE_DESC& Desc) noexcept
+        : Flags(Desc.Flags)
+        , NodeMask(Desc.NodeMask)
+        , pRootSignature(Desc.pRootSignature)
+        , InputLayout(Desc.InputLayout)
+        , IBStripCutValue(Desc.IBStripCutValue)
+        , PrimitiveTopologyType(Desc.PrimitiveTopologyType)
+        , VS(Desc.VS)
+        , GS(Desc.GS)
+        , StreamOutput(Desc.StreamOutput)
+        , HS(Desc.HS)
+        , DS(Desc.DS)
+        , PS(Desc.PS)
+        , BlendState(CD3DX12_BLEND_DESC(Desc.BlendState))
+        , DepthStencilState(CD3DX12_DEPTH_STENCIL_DESC1(Desc.DepthStencilState))
+        , DSVFormat(Desc.DSVFormat)
+        , RasterizerState(CD3DX12_RASTERIZER_DESC(Desc.RasterizerState))
+        , RTVFormats(CD3DX12_RT_FORMAT_ARRAY(Desc.RTVFormats, Desc.NumRenderTargets))
+        , SampleDesc(Desc.SampleDesc)
+        , SampleMask(Desc.SampleMask)
+        , CachedPSO(Desc.CachedPSO)
+        , ViewInstancingDesc(CD3DX12_VIEW_INSTANCING_DESC(CD3DX12_DEFAULT()))
+    {}
+    CD3DX12_PIPELINE_STATE_STREAM2(const D3DX12_MESH_SHADER_PIPELINE_STATE_DESC& Desc) noexcept
+        : Flags(Desc.Flags)
+        , NodeMask(Desc.NodeMask)
+        , pRootSignature(Desc.pRootSignature)
+        , PrimitiveTopologyType(Desc.PrimitiveTopologyType)
+        , PS(Desc.PS)
+        , AS(Desc.AS)
+        , MS(Desc.MS)
+        , BlendState(CD3DX12_BLEND_DESC(Desc.BlendState))
+        , DepthStencilState(CD3DX12_DEPTH_STENCIL_DESC1(Desc.DepthStencilState))
+        , DSVFormat(Desc.DSVFormat)
+        , RasterizerState(CD3DX12_RASTERIZER_DESC(Desc.RasterizerState))
+        , RTVFormats(CD3DX12_RT_FORMAT_ARRAY(Desc.RTVFormats, Desc.NumRenderTargets))
+        , SampleDesc(Desc.SampleDesc)
+        , SampleMask(Desc.SampleMask)
+        , CachedPSO(Desc.CachedPSO)
+        , ViewInstancingDesc(CD3DX12_VIEW_INSTANCING_DESC(CD3DX12_DEFAULT()))
+    {}
+    CD3DX12_PIPELINE_STATE_STREAM2(const D3D12_COMPUTE_PIPELINE_STATE_DESC& Desc) noexcept
+        : Flags(Desc.Flags)
+        , NodeMask(Desc.NodeMask)
+        , pRootSignature(Desc.pRootSignature)
+        , CS(CD3DX12_SHADER_BYTECODE(Desc.CS))
+        , CachedPSO(Desc.CachedPSO)
+    {
+        static_cast<D3D12_DEPTH_STENCIL_DESC1&>(DepthStencilState).DepthEnable = false;
+    }
+    CD3DX12_PIPELINE_STATE_STREAM_FLAGS Flags;
+    CD3DX12_PIPELINE_STATE_STREAM_NODE_MASK NodeMask;
+    CD3DX12_PIPELINE_STATE_STREAM_ROOT_SIGNATURE pRootSignature;
+    CD3DX12_PIPELINE_STATE_STREAM_INPUT_LAYOUT InputLayout;
+    CD3DX12_PIPELINE_STATE_STREAM_IB_STRIP_CUT_VALUE IBStripCutValue;
+    CD3DX12_PIPELINE_STATE_STREAM_PRIMITIVE_TOPOLOGY PrimitiveTopologyType;
+    CD3DX12_PIPELINE_STATE_STREAM_VS VS;
+    CD3DX12_PIPELINE_STATE_STREAM_GS GS;
+    CD3DX12_PIPELINE_STATE_STREAM_STREAM_OUTPUT StreamOutput;
+    CD3DX12_PIPELINE_STATE_STREAM_HS HS;
+    CD3DX12_PIPELINE_STATE_STREAM_DS DS;
+    CD3DX12_PIPELINE_STATE_STREAM_PS PS;
+    CD3DX12_PIPELINE_STATE_STREAM_AS AS;
+    CD3DX12_PIPELINE_STATE_STREAM_MS MS;
+    CD3DX12_PIPELINE_STATE_STREAM_CS CS;
+    CD3DX12_PIPELINE_STATE_STREAM_BLEND_DESC BlendState;
+    CD3DX12_PIPELINE_STATE_STREAM_DEPTH_STENCIL1 DepthStencilState;
+    CD3DX12_PIPELINE_STATE_STREAM_DEPTH_STENCIL_FORMAT DSVFormat;
+    CD3DX12_PIPELINE_STATE_STREAM_RASTERIZER RasterizerState;
+    CD3DX12_PIPELINE_STATE_STREAM_RENDER_TARGET_FORMATS RTVFormats;
+    CD3DX12_PIPELINE_STATE_STREAM_SAMPLE_DESC SampleDesc;
+    CD3DX12_PIPELINE_STATE_STREAM_SAMPLE_MASK SampleMask;
+    CD3DX12_PIPELINE_STATE_STREAM_CACHED_PSO CachedPSO;
+    CD3DX12_PIPELINE_STATE_STREAM_VIEW_INSTANCING ViewInstancingDesc;
+    D3D12_GRAPHICS_PIPELINE_STATE_DESC GraphicsDescV0() const noexcept
+    {
+        D3D12_GRAPHICS_PIPELINE_STATE_DESC D;
+        D.Flags                 = this->Flags;
+        D.NodeMask              = this->NodeMask;
+        D.pRootSignature        = this->pRootSignature;
+        D.InputLayout           = this->InputLayout;
+        D.IBStripCutValue       = this->IBStripCutValue;
+        D.PrimitiveTopologyType = this->PrimitiveTopologyType;
+        D.VS                    = this->VS;
+        D.GS                    = this->GS;
+        D.StreamOutput          = this->StreamOutput;
+        D.HS                    = this->HS;
+        D.DS                    = this->DS;
+        D.PS                    = this->PS;
+        D.BlendState            = this->BlendState;
+        D.DepthStencilState     = CD3DX12_DEPTH_STENCIL_DESC1(D3D12_DEPTH_STENCIL_DESC1(this->DepthStencilState));
+        D.DSVFormat             = this->DSVFormat;
+        D.RasterizerState       = this->RasterizerState;
+        D.NumRenderTargets      = D3D12_RT_FORMAT_ARRAY(this->RTVFormats).NumRenderTargets;
+        memcpy(D.RTVFormats, D3D12_RT_FORMAT_ARRAY(this->RTVFormats).RTFormats, sizeof(D.RTVFormats));
+        D.SampleDesc            = this->SampleDesc;
+        D.SampleMask            = this->SampleMask;
+        D.CachedPSO             = this->CachedPSO;
+        return D;
+    }
+    D3D12_COMPUTE_PIPELINE_STATE_DESC ComputeDescV0() const noexcept
+    {
+        D3D12_COMPUTE_PIPELINE_STATE_DESC D;
+        D.Flags                 = this->Flags;
+        D.NodeMask              = this->NodeMask;
+        D.pRootSignature        = this->pRootSignature;
+        D.CS                    = this->CS;
+        D.CachedPSO             = this->CachedPSO;
+        return D;
+    }
+};
+
+// CD3DX12_PIPELINE_STATE_STREAM1 Works on OS Build 16299+ (where there is a new view instancing subobject).
+// Use CD3DX12_PIPELINE_STATE_STREAM for OS Build 15063+ support.
+struct CD3DX12_PIPELINE_STATE_STREAM1
+{
+    CD3DX12_PIPELINE_STATE_STREAM1() = default;
+    // Mesh and amplification shaders must be set manually, since they do not have representation in D3D12_GRAPHICS_PIPELINE_STATE_DESC
+    CD3DX12_PIPELINE_STATE_STREAM1(const D3D12_GRAPHICS_PIPELINE_STATE_DESC& Desc) noexcept
+        : Flags(Desc.Flags)
+        , NodeMask(Desc.NodeMask)
+        , pRootSignature(Desc.pRootSignature)
+        , InputLayout(Desc.InputLayout)
+        , IBStripCutValue(Desc.IBStripCutValue)
+        , PrimitiveTopologyType(Desc.PrimitiveTopologyType)
+        , VS(Desc.VS)
+        , GS(Desc.GS)
+        , StreamOutput(Desc.StreamOutput)
+        , HS(Desc.HS)
+        , DS(Desc.DS)
+        , PS(Desc.PS)
+        , BlendState(CD3DX12_BLEND_DESC(Desc.BlendState))
+        , DepthStencilState(CD3DX12_DEPTH_STENCIL_DESC1(Desc.DepthStencilState))
+        , DSVFormat(Desc.DSVFormat)
+        , RasterizerState(CD3DX12_RASTERIZER_DESC(Desc.RasterizerState))
+        , RTVFormats(CD3DX12_RT_FORMAT_ARRAY(Desc.RTVFormats, Desc.NumRenderTargets))
+        , SampleDesc(Desc.SampleDesc)
+        , SampleMask(Desc.SampleMask)
+        , CachedPSO(Desc.CachedPSO)
+        , ViewInstancingDesc(CD3DX12_VIEW_INSTANCING_DESC(CD3DX12_DEFAULT()))
+    {}
+    CD3DX12_PIPELINE_STATE_STREAM1(const D3DX12_MESH_SHADER_PIPELINE_STATE_DESC& Desc) noexcept
+        : Flags(Desc.Flags)
+        , NodeMask(Desc.NodeMask)
+        , pRootSignature(Desc.pRootSignature)
+        , PrimitiveTopologyType(Desc.PrimitiveTopologyType)
+        , PS(Desc.PS)
+        , BlendState(CD3DX12_BLEND_DESC(Desc.BlendState))
+        , DepthStencilState(CD3DX12_DEPTH_STENCIL_DESC1(Desc.DepthStencilState))
+        , DSVFormat(Desc.DSVFormat)
+        , RasterizerState(CD3DX12_RASTERIZER_DESC(Desc.RasterizerState))
+        , RTVFormats(CD3DX12_RT_FORMAT_ARRAY(Desc.RTVFormats, Desc.NumRenderTargets))
+        , SampleDesc(Desc.SampleDesc)
+        , SampleMask(Desc.SampleMask)
+        , CachedPSO(Desc.CachedPSO)
+        , ViewInstancingDesc(CD3DX12_VIEW_INSTANCING_DESC(CD3DX12_DEFAULT()))
+    {}
+    CD3DX12_PIPELINE_STATE_STREAM1(const D3D12_COMPUTE_PIPELINE_STATE_DESC& Desc) noexcept
+        : Flags(Desc.Flags)
+        , NodeMask(Desc.NodeMask)
+        , pRootSignature(Desc.pRootSignature)
+        , CS(CD3DX12_SHADER_BYTECODE(Desc.CS))
+        , CachedPSO(Desc.CachedPSO)
+    {
+        static_cast<D3D12_DEPTH_STENCIL_DESC1&>(DepthStencilState).DepthEnable = false;
+    }
+    CD3DX12_PIPELINE_STATE_STREAM_FLAGS Flags;
+    CD3DX12_PIPELINE_STATE_STREAM_NODE_MASK NodeMask;
+    CD3DX12_PIPELINE_STATE_STREAM_ROOT_SIGNATURE pRootSignature;
+    CD3DX12_PIPELINE_STATE_STREAM_INPUT_LAYOUT InputLayout;
+    CD3DX12_PIPELINE_STATE_STREAM_IB_STRIP_CUT_VALUE IBStripCutValue;
+    CD3DX12_PIPELINE_STATE_STREAM_PRIMITIVE_TOPOLOGY PrimitiveTopologyType;
+    CD3DX12_PIPELINE_STATE_STREAM_VS VS;
+    CD3DX12_PIPELINE_STATE_STREAM_GS GS;
+    CD3DX12_PIPELINE_STATE_STREAM_STREAM_OUTPUT StreamOutput;
+    CD3DX12_PIPELINE_STATE_STREAM_HS HS;
+    CD3DX12_PIPELINE_STATE_STREAM_DS DS;
+    CD3DX12_PIPELINE_STATE_STREAM_PS PS;
+    CD3DX12_PIPELINE_STATE_STREAM_CS CS;
+    CD3DX12_PIPELINE_STATE_STREAM_BLEND_DESC BlendState;
+    CD3DX12_PIPELINE_STATE_STREAM_DEPTH_STENCIL1 DepthStencilState;
+    CD3DX12_PIPELINE_STATE_STREAM_DEPTH_STENCIL_FORMAT DSVFormat;
+    CD3DX12_PIPELINE_STATE_STREAM_RASTERIZER RasterizerState;
+    CD3DX12_PIPELINE_STATE_STREAM_RENDER_TARGET_FORMATS RTVFormats;
+    CD3DX12_PIPELINE_STATE_STREAM_SAMPLE_DESC SampleDesc;
+    CD3DX12_PIPELINE_STATE_STREAM_SAMPLE_MASK SampleMask;
+    CD3DX12_PIPELINE_STATE_STREAM_CACHED_PSO CachedPSO;
+    CD3DX12_PIPELINE_STATE_STREAM_VIEW_INSTANCING ViewInstancingDesc;
+    D3D12_GRAPHICS_PIPELINE_STATE_DESC GraphicsDescV0() const noexcept
+    {
+        D3D12_GRAPHICS_PIPELINE_STATE_DESC D;
+        D.Flags                 = this->Flags;
+        D.NodeMask              = this->NodeMask;
+        D.pRootSignature        = this->pRootSignature;
+        D.InputLayout           = this->InputLayout;
+        D.IBStripCutValue       = this->IBStripCutValue;
+        D.PrimitiveTopologyType = this->PrimitiveTopologyType;
+        D.VS                    = this->VS;
+        D.GS                    = this->GS;
+        D.StreamOutput          = this->StreamOutput;
+        D.HS                    = this->HS;
+        D.DS                    = this->DS;
+        D.PS                    = this->PS;
+        D.BlendState            = this->BlendState;
+        D.DepthStencilState     = CD3DX12_DEPTH_STENCIL_DESC1(D3D12_DEPTH_STENCIL_DESC1(this->DepthStencilState));
+        D.DSVFormat             = this->DSVFormat;
+        D.RasterizerState       = this->RasterizerState;
+        D.NumRenderTargets      = D3D12_RT_FORMAT_ARRAY(this->RTVFormats).NumRenderTargets;
+        memcpy(D.RTVFormats, D3D12_RT_FORMAT_ARRAY(this->RTVFormats).RTFormats, sizeof(D.RTVFormats));
+        D.SampleDesc            = this->SampleDesc;
+        D.SampleMask            = this->SampleMask;
+        D.CachedPSO             = this->CachedPSO;
+        return D;
+    }
+    D3D12_COMPUTE_PIPELINE_STATE_DESC ComputeDescV0() const noexcept
+    {
+        D3D12_COMPUTE_PIPELINE_STATE_DESC D;
+        D.Flags                 = this->Flags;
+        D.NodeMask              = this->NodeMask;
+        D.pRootSignature        = this->pRootSignature;
+        D.CS                    = this->CS;
+        D.CachedPSO             = this->CachedPSO;
+        return D;
+    }
+};
+
+
+struct CD3DX12_PIPELINE_MESH_STATE_STREAM
+{
+    CD3DX12_PIPELINE_MESH_STATE_STREAM() = default;
+    CD3DX12_PIPELINE_MESH_STATE_STREAM(const D3DX12_MESH_SHADER_PIPELINE_STATE_DESC& Desc) noexcept
+        : Flags(Desc.Flags)
+        , NodeMask(Desc.NodeMask)
+        , pRootSignature(Desc.pRootSignature)
+        , PS(Desc.PS)
+        , AS(Desc.AS)
+        , MS(Desc.MS)
+        , BlendState(CD3DX12_BLEND_DESC(Desc.BlendState))
+        , DepthStencilState(CD3DX12_DEPTH_STENCIL_DESC1(Desc.DepthStencilState))
+        , DSVFormat(Desc.DSVFormat)
+        , RasterizerState(CD3DX12_RASTERIZER_DESC(Desc.RasterizerState))
+        , RTVFormats(CD3DX12_RT_FORMAT_ARRAY(Desc.RTVFormats, Desc.NumRenderTargets))
+        , SampleDesc(Desc.SampleDesc)
+        , SampleMask(Desc.SampleMask)
+        , CachedPSO(Desc.CachedPSO)
+        , ViewInstancingDesc(CD3DX12_VIEW_INSTANCING_DESC(CD3DX12_DEFAULT()))
+    {}
+    CD3DX12_PIPELINE_STATE_STREAM_FLAGS Flags;
+    CD3DX12_PIPELINE_STATE_STREAM_NODE_MASK NodeMask;
+    CD3DX12_PIPELINE_STATE_STREAM_ROOT_SIGNATURE pRootSignature;
+    CD3DX12_PIPELINE_STATE_STREAM_PS PS;
+    CD3DX12_PIPELINE_STATE_STREAM_AS AS;
+    CD3DX12_PIPELINE_STATE_STREAM_MS MS;
+    CD3DX12_PIPELINE_STATE_STREAM_BLEND_DESC BlendState;
+    CD3DX12_PIPELINE_STATE_STREAM_DEPTH_STENCIL1 DepthStencilState;
+    CD3DX12_PIPELINE_STATE_STREAM_DEPTH_STENCIL_FORMAT DSVFormat;
+    CD3DX12_PIPELINE_STATE_STREAM_RASTERIZER RasterizerState;
+    CD3DX12_PIPELINE_STATE_STREAM_RENDER_TARGET_FORMATS RTVFormats;
+    CD3DX12_PIPELINE_STATE_STREAM_SAMPLE_DESC SampleDesc;
+    CD3DX12_PIPELINE_STATE_STREAM_SAMPLE_MASK SampleMask;
+    CD3DX12_PIPELINE_STATE_STREAM_CACHED_PSO CachedPSO;
+    CD3DX12_PIPELINE_STATE_STREAM_VIEW_INSTANCING ViewInstancingDesc;
+    D3DX12_MESH_SHADER_PIPELINE_STATE_DESC MeshShaderDescV0() const noexcept
+    {
+        D3DX12_MESH_SHADER_PIPELINE_STATE_DESC D;
+        D.Flags                 = this->Flags;
+        D.NodeMask              = this->NodeMask;
+        D.pRootSignature        = this->pRootSignature;
+        D.PS                    = this->PS;
+        D.AS                    = this->AS;
+        D.MS                    = this->MS;
+        D.BlendState            = this->BlendState;
+        D.DepthStencilState     = CD3DX12_DEPTH_STENCIL_DESC1(D3D12_DEPTH_STENCIL_DESC1(this->DepthStencilState));
+        D.DSVFormat             = this->DSVFormat;
+        D.RasterizerState       = this->RasterizerState;
+        D.NumRenderTargets      = D3D12_RT_FORMAT_ARRAY(this->RTVFormats).NumRenderTargets;
+        memcpy(D.RTVFormats, D3D12_RT_FORMAT_ARRAY(this->RTVFormats).RTFormats, sizeof(D.RTVFormats));
+        D.SampleDesc            = this->SampleDesc;
+        D.SampleMask            = this->SampleMask;
+        D.CachedPSO             = this->CachedPSO;
+        return D;
+    }
+};
+
+// CD3DX12_PIPELINE_STATE_STREAM works on OS Build 15063+ but does not support new subobject(s) added in OS Build 16299+.
+// See CD3DX12_PIPELINE_STATE_STREAM1 for instance.
+struct CD3DX12_PIPELINE_STATE_STREAM
+{
+    CD3DX12_PIPELINE_STATE_STREAM() = default;
+    CD3DX12_PIPELINE_STATE_STREAM(const D3D12_GRAPHICS_PIPELINE_STATE_DESC& Desc) noexcept
+        : Flags(Desc.Flags)
+        , NodeMask(Desc.NodeMask)
+        , pRootSignature(Desc.pRootSignature)
+        , InputLayout(Desc.InputLayout)
+        , IBStripCutValue(Desc.IBStripCutValue)
+        , PrimitiveTopologyType(Desc.PrimitiveTopologyType)
+        , VS(Desc.VS)
+        , GS(Desc.GS)
+        , StreamOutput(Desc.StreamOutput)
+        , HS(Desc.HS)
+        , DS(Desc.DS)
+        , PS(Desc.PS)
+        , BlendState(CD3DX12_BLEND_DESC(Desc.BlendState))
+        , DepthStencilState(CD3DX12_DEPTH_STENCIL_DESC1(Desc.DepthStencilState))
+        , DSVFormat(Desc.DSVFormat)
+        , RasterizerState(CD3DX12_RASTERIZER_DESC(Desc.RasterizerState))
+        , RTVFormats(CD3DX12_RT_FORMAT_ARRAY(Desc.RTVFormats, Desc.NumRenderTargets))
+        , SampleDesc(Desc.SampleDesc)
+        , SampleMask(Desc.SampleMask)
+        , CachedPSO(Desc.CachedPSO)
+    {}
+    CD3DX12_PIPELINE_STATE_STREAM(const D3D12_COMPUTE_PIPELINE_STATE_DESC& Desc) noexcept
+        : Flags(Desc.Flags)
+        , NodeMask(Desc.NodeMask)
+        , pRootSignature(Desc.pRootSignature)
+        , CS(CD3DX12_SHADER_BYTECODE(Desc.CS))
+        , CachedPSO(Desc.CachedPSO)
+    {}
+    CD3DX12_PIPELINE_STATE_STREAM_FLAGS Flags;
+    CD3DX12_PIPELINE_STATE_STREAM_NODE_MASK NodeMask;
+    CD3DX12_PIPELINE_STATE_STREAM_ROOT_SIGNATURE pRootSignature;
+    CD3DX12_PIPELINE_STATE_STREAM_INPUT_LAYOUT InputLayout;
+    CD3DX12_PIPELINE_STATE_STREAM_IB_STRIP_CUT_VALUE IBStripCutValue;
+    CD3DX12_PIPELINE_STATE_STREAM_PRIMITIVE_TOPOLOGY PrimitiveTopologyType;
+    CD3DX12_PIPELINE_STATE_STREAM_VS VS;
+    CD3DX12_PIPELINE_STATE_STREAM_GS GS;
+    CD3DX12_PIPELINE_STATE_STREAM_STREAM_OUTPUT StreamOutput;
+    CD3DX12_PIPELINE_STATE_STREAM_HS HS;
+    CD3DX12_PIPELINE_STATE_STREAM_DS DS;
+    CD3DX12_PIPELINE_STATE_STREAM_PS PS;
+    CD3DX12_PIPELINE_STATE_STREAM_CS CS;
+    CD3DX12_PIPELINE_STATE_STREAM_BLEND_DESC BlendState;
+    CD3DX12_PIPELINE_STATE_STREAM_DEPTH_STENCIL1 DepthStencilState;
+    CD3DX12_PIPELINE_STATE_STREAM_DEPTH_STENCIL_FORMAT DSVFormat;
+    CD3DX12_PIPELINE_STATE_STREAM_RASTERIZER RasterizerState;
+    CD3DX12_PIPELINE_STATE_STREAM_RENDER_TARGET_FORMATS RTVFormats;
+    CD3DX12_PIPELINE_STATE_STREAM_SAMPLE_DESC SampleDesc;
+    CD3DX12_PIPELINE_STATE_STREAM_SAMPLE_MASK SampleMask;
+    CD3DX12_PIPELINE_STATE_STREAM_CACHED_PSO CachedPSO;
+    D3D12_GRAPHICS_PIPELINE_STATE_DESC GraphicsDescV0() const noexcept
+    {
+        D3D12_GRAPHICS_PIPELINE_STATE_DESC D;
+        D.Flags                 = this->Flags;
+        D.NodeMask              = this->NodeMask;
+        D.pRootSignature        = this->pRootSignature;
+        D.InputLayout           = this->InputLayout;
+        D.IBStripCutValue       = this->IBStripCutValue;
+        D.PrimitiveTopologyType = this->PrimitiveTopologyType;
+        D.VS                    = this->VS;
+        D.GS                    = this->GS;
+        D.StreamOutput          = this->StreamOutput;
+        D.HS                    = this->HS;
+        D.DS                    = this->DS;
+        D.PS                    = this->PS;
+        D.BlendState            = this->BlendState;
+        D.DepthStencilState     = CD3DX12_DEPTH_STENCIL_DESC1(D3D12_DEPTH_STENCIL_DESC1(this->DepthStencilState));
+        D.DSVFormat             = this->DSVFormat;
+        D.RasterizerState       = this->RasterizerState;
+        D.NumRenderTargets      = D3D12_RT_FORMAT_ARRAY(this->RTVFormats).NumRenderTargets;
+        memcpy(D.RTVFormats, D3D12_RT_FORMAT_ARRAY(this->RTVFormats).RTFormats, sizeof(D.RTVFormats));
+        D.SampleDesc            = this->SampleDesc;
+        D.SampleMask            = this->SampleMask;
+        D.CachedPSO             = this->CachedPSO;
+        return D;
+    }
+    D3D12_COMPUTE_PIPELINE_STATE_DESC ComputeDescV0() const noexcept
+    {
+        D3D12_COMPUTE_PIPELINE_STATE_DESC D;
+        D.Flags                 = this->Flags;
+        D.NodeMask              = this->NodeMask;
+        D.pRootSignature        = this->pRootSignature;
+        D.CS                    = this->CS;
+        D.CachedPSO             = this->CachedPSO;
+        return D;
+    }
+};
+
+struct CD3DX12_PIPELINE_STATE_STREAM2_PARSE_HELPER : public ID3DX12PipelineParserCallbacks
+{
+    CD3DX12_PIPELINE_STATE_STREAM2 PipelineStream;
+    CD3DX12_PIPELINE_STATE_STREAM2_PARSE_HELPER() noexcept
+        : SeenDSS(false)
+    {
+        // Adjust defaults to account for absent members.
+        PipelineStream.PrimitiveTopologyType = D3D12_PRIMITIVE_TOPOLOGY_TYPE_TRIANGLE;
+
+        // Depth disabled if no DSV format specified.
+        static_cast<D3D12_DEPTH_STENCIL_DESC1&>(PipelineStream.DepthStencilState).DepthEnable = false;
+    }
+
+    // ID3DX12PipelineParserCallbacks
+    void FlagsCb(D3D12_PIPELINE_STATE_FLAGS Flags) override {PipelineStream.Flags = Flags;}
+    void NodeMaskCb(UINT NodeMask) override {PipelineStream.NodeMask = NodeMask;}
+    void RootSignatureCb(ID3D12RootSignature* pRootSignature) override {PipelineStream.pRootSignature = pRootSignature;}
+    void InputLayoutCb(const D3D12_INPUT_LAYOUT_DESC& InputLayout) override {PipelineStream.InputLayout = InputLayout;}
+    void IBStripCutValueCb(D3D12_INDEX_BUFFER_STRIP_CUT_VALUE IBStripCutValue) override {PipelineStream.IBStripCutValue = IBStripCutValue;}
+    void PrimitiveTopologyTypeCb(D3D12_PRIMITIVE_TOPOLOGY_TYPE PrimitiveTopologyType) override {PipelineStream.PrimitiveTopologyType = PrimitiveTopologyType;}
+    void VSCb(const D3D12_SHADER_BYTECODE& VS) override {PipelineStream.VS = VS;}
+    void GSCb(const D3D12_SHADER_BYTECODE& GS) override {PipelineStream.GS = GS;}
+    void StreamOutputCb(const D3D12_STREAM_OUTPUT_DESC& StreamOutput) override {PipelineStream.StreamOutput = StreamOutput;}
+    void HSCb(const D3D12_SHADER_BYTECODE& HS) override {PipelineStream.HS = HS;}
+    void DSCb(const D3D12_SHADER_BYTECODE& DS) override {PipelineStream.DS = DS;}
+    void PSCb(const D3D12_SHADER_BYTECODE& PS) override {PipelineStream.PS = PS;}
+    void CSCb(const D3D12_SHADER_BYTECODE& CS) override {PipelineStream.CS = CS;}
+    void ASCb(const D3D12_SHADER_BYTECODE& AS) override {PipelineStream.AS = AS;}
+    void MSCb(const D3D12_SHADER_BYTECODE& MS) override {PipelineStream.MS = MS;}
+    void BlendStateCb(const D3D12_BLEND_DESC& BlendState) override {PipelineStream.BlendState = CD3DX12_BLEND_DESC(BlendState);}
+    void DepthStencilStateCb(const D3D12_DEPTH_STENCIL_DESC& DepthStencilState) override
+    {
+        PipelineStream.DepthStencilState = CD3DX12_DEPTH_STENCIL_DESC1(DepthStencilState);
+        SeenDSS = true;
+    }
+    void DepthStencilState1Cb(const D3D12_DEPTH_STENCIL_DESC1& DepthStencilState) override
+    {
+        PipelineStream.DepthStencilState = CD3DX12_DEPTH_STENCIL_DESC1(DepthStencilState);
+        SeenDSS = true;
+    }
+    void DSVFormatCb(DXGI_FORMAT DSVFormat) override
+    {
+        PipelineStream.DSVFormat = DSVFormat;
+        if (!SeenDSS && DSVFormat != DXGI_FORMAT_UNKNOWN)
+        {
+            // Re-enable depth for the default state.
+            static_cast<D3D12_DEPTH_STENCIL_DESC1&>(PipelineStream.DepthStencilState).DepthEnable = true;
+        }
+    }
+    void RasterizerStateCb(const D3D12_RASTERIZER_DESC& RasterizerState) override {PipelineStream.RasterizerState = CD3DX12_RASTERIZER_DESC(RasterizerState);}
+    void RTVFormatsCb(const D3D12_RT_FORMAT_ARRAY& RTVFormats) override {PipelineStream.RTVFormats = RTVFormats;}
+    void SampleDescCb(const DXGI_SAMPLE_DESC& SampleDesc) override {PipelineStream.SampleDesc = SampleDesc;}
+    void SampleMaskCb(UINT SampleMask) override {PipelineStream.SampleMask = SampleMask;}
+    void ViewInstancingCb(const D3D12_VIEW_INSTANCING_DESC& ViewInstancingDesc) override {PipelineStream.ViewInstancingDesc = CD3DX12_VIEW_INSTANCING_DESC(ViewInstancingDesc);}
+    void CachedPSOCb(const D3D12_CACHED_PIPELINE_STATE& CachedPSO) override {PipelineStream.CachedPSO = CachedPSO;}
+
+private:
+    bool SeenDSS;
+};
+
+
+struct CD3DX12_PIPELINE_STATE_STREAM3_PARSE_HELPER : public ID3DX12PipelineParserCallbacks
+{
+    CD3DX12_PIPELINE_STATE_STREAM3 PipelineStream;
+    CD3DX12_PIPELINE_STATE_STREAM3_PARSE_HELPER() noexcept
+        : SeenDSS(false)
+    {
+        // Adjust defaults to account for absent members.
+        PipelineStream.PrimitiveTopologyType = D3D12_PRIMITIVE_TOPOLOGY_TYPE_TRIANGLE;
+
+        // Depth disabled if no DSV format specified.
+        static_cast<D3D12_DEPTH_STENCIL_DESC2&>(PipelineStream.DepthStencilState).DepthEnable = false;
+    }
+
+    // ID3DX12PipelineParserCallbacks
+    void FlagsCb(D3D12_PIPELINE_STATE_FLAGS Flags) override { PipelineStream.Flags = Flags; }
+    void NodeMaskCb(UINT NodeMask) override { PipelineStream.NodeMask = NodeMask; }
+    void RootSignatureCb(ID3D12RootSignature* pRootSignature) override { PipelineStream.pRootSignature = pRootSignature; }
+    void InputLayoutCb(const D3D12_INPUT_LAYOUT_DESC& InputLayout) override { PipelineStream.InputLayout = InputLayout; }
+    void IBStripCutValueCb(D3D12_INDEX_BUFFER_STRIP_CUT_VALUE IBStripCutValue) override { PipelineStream.IBStripCutValue = IBStripCutValue; }
+    void PrimitiveTopologyTypeCb(D3D12_PRIMITIVE_TOPOLOGY_TYPE PrimitiveTopologyType) override { PipelineStream.PrimitiveTopologyType = PrimitiveTopologyType; }
+    void VSCb(const D3D12_SHADER_BYTECODE& VS) override { PipelineStream.VS = VS; }
+    void GSCb(const D3D12_SHADER_BYTECODE& GS) override { PipelineStream.GS = GS; }
+    void StreamOutputCb(const D3D12_STREAM_OUTPUT_DESC& StreamOutput) override { PipelineStream.StreamOutput = StreamOutput; }
+    void HSCb(const D3D12_SHADER_BYTECODE& HS) override { PipelineStream.HS = HS; }
+    void DSCb(const D3D12_SHADER_BYTECODE& DS) override { PipelineStream.DS = DS; }
+    void PSCb(const D3D12_SHADER_BYTECODE& PS) override { PipelineStream.PS = PS; }
+    void CSCb(const D3D12_SHADER_BYTECODE& CS) override { PipelineStream.CS = CS; }
+    void ASCb(const D3D12_SHADER_BYTECODE& AS) override { PipelineStream.AS = AS; }
+    void MSCb(const D3D12_SHADER_BYTECODE& MS) override { PipelineStream.MS = MS; }
+    void BlendStateCb(const D3D12_BLEND_DESC& BlendState) override { PipelineStream.BlendState = CD3DX12_BLEND_DESC(BlendState); }
+    void DepthStencilStateCb(const D3D12_DEPTH_STENCIL_DESC& DepthStencilState) override
+    {
+        PipelineStream.DepthStencilState = CD3DX12_DEPTH_STENCIL_DESC2(DepthStencilState);
+        SeenDSS = true;
+    }
+    void DepthStencilState1Cb(const D3D12_DEPTH_STENCIL_DESC1& DepthStencilState) override
+    {
+        PipelineStream.DepthStencilState = CD3DX12_DEPTH_STENCIL_DESC2(DepthStencilState);
+        SeenDSS = true;
+    }
+    void DepthStencilState2Cb(const D3D12_DEPTH_STENCIL_DESC2& DepthStencilState) override
+    {
+        PipelineStream.DepthStencilState = CD3DX12_DEPTH_STENCIL_DESC2(DepthStencilState);
+        SeenDSS = true;
+    }
+    void DSVFormatCb(DXGI_FORMAT DSVFormat) override
+    {
+        PipelineStream.DSVFormat = DSVFormat;
+        if (!SeenDSS && DSVFormat != DXGI_FORMAT_UNKNOWN)
+        {
+            // Re-enable depth for the default state.
+            static_cast<D3D12_DEPTH_STENCIL_DESC2&>(PipelineStream.DepthStencilState).DepthEnable = true;
+        }
+    }
+    void RasterizerStateCb(const D3D12_RASTERIZER_DESC& RasterizerState) override { PipelineStream.RasterizerState = CD3DX12_RASTERIZER_DESC(RasterizerState); }
+    void RTVFormatsCb(const D3D12_RT_FORMAT_ARRAY& RTVFormats) override { PipelineStream.RTVFormats = RTVFormats; }
+    void SampleDescCb(const DXGI_SAMPLE_DESC& SampleDesc) override { PipelineStream.SampleDesc = SampleDesc; }
+    void SampleMaskCb(UINT SampleMask) override { PipelineStream.SampleMask = SampleMask; }
+    void ViewInstancingCb(const D3D12_VIEW_INSTANCING_DESC& ViewInstancingDesc) override { PipelineStream.ViewInstancingDesc = CD3DX12_VIEW_INSTANCING_DESC(ViewInstancingDesc); }
+    void CachedPSOCb(const D3D12_CACHED_PIPELINE_STATE& CachedPSO) override { PipelineStream.CachedPSO = CachedPSO; }
+
+private:
+    bool SeenDSS;
+};
+
+struct CD3DX12_PIPELINE_STATE_STREAM_PARSE_HELPER : public ID3DX12PipelineParserCallbacks
+{
+    CD3DX12_PIPELINE_STATE_STREAM1 PipelineStream;
+    CD3DX12_PIPELINE_STATE_STREAM_PARSE_HELPER() noexcept
+        : SeenDSS(false)
+    {
+        // Adjust defaults to account for absent members.
+        PipelineStream.PrimitiveTopologyType = D3D12_PRIMITIVE_TOPOLOGY_TYPE_TRIANGLE;
+
+        // Depth disabled if no DSV format specified.
+        static_cast<D3D12_DEPTH_STENCIL_DESC1&>(PipelineStream.DepthStencilState).DepthEnable = false;
+    }
+
+    // ID3DX12PipelineParserCallbacks
+    void FlagsCb(D3D12_PIPELINE_STATE_FLAGS Flags) override {PipelineStream.Flags = Flags;}
+    void NodeMaskCb(UINT NodeMask) override {PipelineStream.NodeMask = NodeMask;}
+    void RootSignatureCb(ID3D12RootSignature* pRootSignature) override {PipelineStream.pRootSignature = pRootSignature;}
+    void InputLayoutCb(const D3D12_INPUT_LAYOUT_DESC& InputLayout) override {PipelineStream.InputLayout = InputLayout;}
+    void IBStripCutValueCb(D3D12_INDEX_BUFFER_STRIP_CUT_VALUE IBStripCutValue) override {PipelineStream.IBStripCutValue = IBStripCutValue;}
+    void PrimitiveTopologyTypeCb(D3D12_PRIMITIVE_TOPOLOGY_TYPE PrimitiveTopologyType) override {PipelineStream.PrimitiveTopologyType = PrimitiveTopologyType;}
+    void VSCb(const D3D12_SHADER_BYTECODE& VS) override {PipelineStream.VS = VS;}
+    void GSCb(const D3D12_SHADER_BYTECODE& GS) override {PipelineStream.GS = GS;}
+    void StreamOutputCb(const D3D12_STREAM_OUTPUT_DESC& StreamOutput) override {PipelineStream.StreamOutput = StreamOutput;}
+    void HSCb(const D3D12_SHADER_BYTECODE& HS) override {PipelineStream.HS = HS;}
+    void DSCb(const D3D12_SHADER_BYTECODE& DS) override {PipelineStream.DS = DS;}
+    void PSCb(const D3D12_SHADER_BYTECODE& PS) override {PipelineStream.PS = PS;}
+    void CSCb(const D3D12_SHADER_BYTECODE& CS) override {PipelineStream.CS = CS;}
+    void BlendStateCb(const D3D12_BLEND_DESC& BlendState) override {PipelineStream.BlendState = CD3DX12_BLEND_DESC(BlendState);}
+    void DepthStencilStateCb(const D3D12_DEPTH_STENCIL_DESC& DepthStencilState) override
+    {
+        PipelineStream.DepthStencilState = CD3DX12_DEPTH_STENCIL_DESC1(DepthStencilState);
+        SeenDSS = true;
+    }
+    void DepthStencilState1Cb(const D3D12_DEPTH_STENCIL_DESC1& DepthStencilState) override
+    {
+        PipelineStream.DepthStencilState = CD3DX12_DEPTH_STENCIL_DESC1(DepthStencilState);
+        SeenDSS = true;
+    }
+    void DSVFormatCb(DXGI_FORMAT DSVFormat) override
+    {
+        PipelineStream.DSVFormat = DSVFormat;
+        if (!SeenDSS && DSVFormat != DXGI_FORMAT_UNKNOWN)
+        {
+            // Re-enable depth for the default state.
+            static_cast<D3D12_DEPTH_STENCIL_DESC1&>(PipelineStream.DepthStencilState).DepthEnable = true;
+        }
+    }
+    void RasterizerStateCb(const D3D12_RASTERIZER_DESC& RasterizerState) override {PipelineStream.RasterizerState = CD3DX12_RASTERIZER_DESC(RasterizerState);}
+    void RTVFormatsCb(const D3D12_RT_FORMAT_ARRAY& RTVFormats) override {PipelineStream.RTVFormats = RTVFormats;}
+    void SampleDescCb(const DXGI_SAMPLE_DESC& SampleDesc) override {PipelineStream.SampleDesc = SampleDesc;}
+    void SampleMaskCb(UINT SampleMask) override {PipelineStream.SampleMask = SampleMask;}
+    void ViewInstancingCb(const D3D12_VIEW_INSTANCING_DESC& ViewInstancingDesc) override {PipelineStream.ViewInstancingDesc = CD3DX12_VIEW_INSTANCING_DESC(ViewInstancingDesc);}
+    void CachedPSOCb(const D3D12_CACHED_PIPELINE_STATE& CachedPSO) override {PipelineStream.CachedPSO = CachedPSO;}
+
+private:
+    bool SeenDSS;
+};
+
+inline D3D12_PIPELINE_STATE_SUBOBJECT_TYPE D3DX12GetBaseSubobjectType(D3D12_PIPELINE_STATE_SUBOBJECT_TYPE SubobjectType) noexcept
+{
+    switch (SubobjectType)
+    {
+    case D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_DEPTH_STENCIL1:
+        return D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_DEPTH_STENCIL;
+    case D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_DEPTH_STENCIL2:
+        return D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_DEPTH_STENCIL;
+    default:
+        return SubobjectType;
+    }
+}
+
+inline HRESULT D3DX12ParsePipelineStream(const D3D12_PIPELINE_STATE_STREAM_DESC& Desc, ID3DX12PipelineParserCallbacks* pCallbacks)
+{
+    if (pCallbacks == nullptr)
+    {
+        return E_INVALIDARG;
+    }
+
+    if (Desc.SizeInBytes == 0 || Desc.pPipelineStateSubobjectStream == nullptr)
+    {
+        pCallbacks->ErrorBadInputParameter(1); // first parameter issue
+        return E_INVALIDARG;
+    }
+
+    bool SubobjectSeen[D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_MAX_VALID] = {};
+    for (SIZE_T CurOffset = 0, SizeOfSubobject = 0; CurOffset < Desc.SizeInBytes; CurOffset += SizeOfSubobject)
+    {
+        BYTE* pStream = static_cast<BYTE*>(Desc.pPipelineStateSubobjectStream)+CurOffset;
+        auto SubobjectType = *reinterpret_cast<D3D12_PIPELINE_STATE_SUBOBJECT_TYPE*>(pStream);
+        if (SubobjectType < 0 || SubobjectType >= D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_MAX_VALID)
+        {
+            pCallbacks->ErrorUnknownSubobject(SubobjectType);
+            return E_INVALIDARG;
+        }
+        if (SubobjectSeen[D3DX12GetBaseSubobjectType(SubobjectType)])
+        {
+            pCallbacks->ErrorDuplicateSubobject(SubobjectType);
+            return E_INVALIDARG; // disallow subobject duplicates in a stream
+        }
+        SubobjectSeen[SubobjectType] = true;
+        switch (SubobjectType)
+        {
+        case D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_ROOT_SIGNATURE:
+            pCallbacks->RootSignatureCb(*reinterpret_cast<decltype(CD3DX12_PIPELINE_STATE_STREAM::pRootSignature)*>(pStream));
+            SizeOfSubobject = sizeof(CD3DX12_PIPELINE_STATE_STREAM::pRootSignature);
+            break;
+        case D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_VS:
+            pCallbacks->VSCb(*reinterpret_cast<decltype(CD3DX12_PIPELINE_STATE_STREAM::VS)*>(pStream));
+            SizeOfSubobject = sizeof(CD3DX12_PIPELINE_STATE_STREAM::VS);
+            break;
+        case D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_PS:
+            pCallbacks->PSCb(*reinterpret_cast<decltype(CD3DX12_PIPELINE_STATE_STREAM::PS)*>(pStream));
+            SizeOfSubobject = sizeof(CD3DX12_PIPELINE_STATE_STREAM::PS);
+            break;
+        case D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_DS:
+            pCallbacks->DSCb(*reinterpret_cast<decltype(CD3DX12_PIPELINE_STATE_STREAM::DS)*>(pStream));
+            SizeOfSubobject = sizeof(CD3DX12_PIPELINE_STATE_STREAM::DS);
+            break;
+        case D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_HS:
+            pCallbacks->HSCb(*reinterpret_cast<decltype(CD3DX12_PIPELINE_STATE_STREAM::HS)*>(pStream));
+            SizeOfSubobject = sizeof(CD3DX12_PIPELINE_STATE_STREAM::HS);
+            break;
+        case D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_GS:
+            pCallbacks->GSCb(*reinterpret_cast<decltype(CD3DX12_PIPELINE_STATE_STREAM::GS)*>(pStream));
+            SizeOfSubobject = sizeof(CD3DX12_PIPELINE_STATE_STREAM::GS);
+            break;
+        case D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_CS:
+            pCallbacks->CSCb(*reinterpret_cast<decltype(CD3DX12_PIPELINE_STATE_STREAM::CS)*>(pStream));
+            SizeOfSubobject = sizeof(CD3DX12_PIPELINE_STATE_STREAM::CS);
+            break;
+        case D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_AS:
+            pCallbacks->ASCb(*reinterpret_cast<decltype(CD3DX12_PIPELINE_STATE_STREAM2::AS)*>(pStream));
+            SizeOfSubobject = sizeof(CD3DX12_PIPELINE_STATE_STREAM2::AS);
+            break;
+        case D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_MS:
+            pCallbacks->MSCb(*reinterpret_cast<decltype(CD3DX12_PIPELINE_STATE_STREAM2::MS)*>(pStream));
+            SizeOfSubobject = sizeof(CD3DX12_PIPELINE_STATE_STREAM2::MS);
+            break;
+        case D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_STREAM_OUTPUT:
+            pCallbacks->StreamOutputCb(*reinterpret_cast<decltype(CD3DX12_PIPELINE_STATE_STREAM::StreamOutput)*>(pStream));
+            SizeOfSubobject = sizeof(CD3DX12_PIPELINE_STATE_STREAM::StreamOutput);
+            break;
+        case D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_BLEND:
+            pCallbacks->BlendStateCb(*reinterpret_cast<decltype(CD3DX12_PIPELINE_STATE_STREAM::BlendState)*>(pStream));
+            SizeOfSubobject = sizeof(CD3DX12_PIPELINE_STATE_STREAM::BlendState);
+            break;
+        case D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_SAMPLE_MASK:
+            pCallbacks->SampleMaskCb(*reinterpret_cast<decltype(CD3DX12_PIPELINE_STATE_STREAM::SampleMask)*>(pStream));
+            SizeOfSubobject = sizeof(CD3DX12_PIPELINE_STATE_STREAM::SampleMask);
+            break;
+        case D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_RASTERIZER:
+            pCallbacks->RasterizerStateCb(*reinterpret_cast<decltype(CD3DX12_PIPELINE_STATE_STREAM::RasterizerState)*>(pStream));
+            SizeOfSubobject = sizeof(CD3DX12_PIPELINE_STATE_STREAM::RasterizerState);
+            break;
+        case D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_DEPTH_STENCIL:
+            pCallbacks->DepthStencilStateCb(*reinterpret_cast<CD3DX12_PIPELINE_STATE_STREAM_DEPTH_STENCIL*>(pStream));
+            SizeOfSubobject = sizeof(CD3DX12_PIPELINE_STATE_STREAM_DEPTH_STENCIL);
+            break;
+        case D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_DEPTH_STENCIL1:
+            pCallbacks->DepthStencilState1Cb(*reinterpret_cast<decltype(CD3DX12_PIPELINE_STATE_STREAM::DepthStencilState)*>(pStream));
+            SizeOfSubobject = sizeof(CD3DX12_PIPELINE_STATE_STREAM::DepthStencilState);
+            break;
+        case D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_DEPTH_STENCIL2:
+            pCallbacks->DepthStencilState2Cb(*reinterpret_cast<decltype(CD3DX12_PIPELINE_STATE_STREAM3::DepthStencilState)*>(pStream));
+            SizeOfSubobject = sizeof(CD3DX12_PIPELINE_STATE_STREAM3::DepthStencilState);
+            break;
+        case D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_INPUT_LAYOUT:
+            pCallbacks->InputLayoutCb(*reinterpret_cast<decltype(CD3DX12_PIPELINE_STATE_STREAM::InputLayout)*>(pStream));
+            SizeOfSubobject = sizeof(CD3DX12_PIPELINE_STATE_STREAM::InputLayout);
+            break;
+        case D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_IB_STRIP_CUT_VALUE:
+            pCallbacks->IBStripCutValueCb(*reinterpret_cast<decltype(CD3DX12_PIPELINE_STATE_STREAM::IBStripCutValue)*>(pStream));
+            SizeOfSubobject = sizeof(CD3DX12_PIPELINE_STATE_STREAM::IBStripCutValue);
+            break;
+        case D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_PRIMITIVE_TOPOLOGY:
+            pCallbacks->PrimitiveTopologyTypeCb(*reinterpret_cast<decltype(CD3DX12_PIPELINE_STATE_STREAM::PrimitiveTopologyType)*>(pStream));
+            SizeOfSubobject = sizeof(CD3DX12_PIPELINE_STATE_STREAM::PrimitiveTopologyType);
+            break;
+        case D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_RENDER_TARGET_FORMATS:
+            pCallbacks->RTVFormatsCb(*reinterpret_cast<decltype(CD3DX12_PIPELINE_STATE_STREAM::RTVFormats)*>(pStream));
+            SizeOfSubobject = sizeof(CD3DX12_PIPELINE_STATE_STREAM::RTVFormats);
+            break;
+        case D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_DEPTH_STENCIL_FORMAT:
+            pCallbacks->DSVFormatCb(*reinterpret_cast<decltype(CD3DX12_PIPELINE_STATE_STREAM::DSVFormat)*>(pStream));
+            SizeOfSubobject = sizeof(CD3DX12_PIPELINE_STATE_STREAM::DSVFormat);
+            break;
+        case D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_SAMPLE_DESC:
+            pCallbacks->SampleDescCb(*reinterpret_cast<decltype(CD3DX12_PIPELINE_STATE_STREAM::SampleDesc)*>(pStream));
+            SizeOfSubobject = sizeof(CD3DX12_PIPELINE_STATE_STREAM::SampleDesc);
+            break;
+        case D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_NODE_MASK:
+            pCallbacks->NodeMaskCb(*reinterpret_cast<decltype(CD3DX12_PIPELINE_STATE_STREAM::NodeMask)*>(pStream));
+            SizeOfSubobject = sizeof(CD3DX12_PIPELINE_STATE_STREAM::NodeMask);
+            break;
+        case D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_CACHED_PSO:
+            pCallbacks->CachedPSOCb(*reinterpret_cast<decltype(CD3DX12_PIPELINE_STATE_STREAM::CachedPSO)*>(pStream));
+            SizeOfSubobject = sizeof(CD3DX12_PIPELINE_STATE_STREAM::CachedPSO);
+            break;
+        case D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_FLAGS:
+            pCallbacks->FlagsCb(*reinterpret_cast<decltype(CD3DX12_PIPELINE_STATE_STREAM::Flags)*>(pStream));
+            SizeOfSubobject = sizeof(CD3DX12_PIPELINE_STATE_STREAM::Flags);
+            break;
+        case D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_VIEW_INSTANCING:
+            pCallbacks->ViewInstancingCb(*reinterpret_cast<decltype(CD3DX12_PIPELINE_STATE_STREAM1::ViewInstancingDesc)*>(pStream));
+            SizeOfSubobject = sizeof(CD3DX12_PIPELINE_STATE_STREAM1::ViewInstancingDesc);
+            break;
+        default:
+            pCallbacks->ErrorUnknownSubobject(SubobjectType);
+            return E_INVALIDARG;
+        }
+    }
+
+    return S_OK;
+}
+
+//------------------------------------------------------------------------------------------------
+inline bool operator==( const D3D12_CLEAR_VALUE &a, const D3D12_CLEAR_VALUE &b) noexcept
+{
+    if (a.Format != b.Format) return false;
+    if (a.Format == DXGI_FORMAT_D24_UNORM_S8_UINT
+     || a.Format == DXGI_FORMAT_D16_UNORM
+     || a.Format == DXGI_FORMAT_D32_FLOAT
+     || a.Format == DXGI_FORMAT_D32_FLOAT_S8X24_UINT)
+    {
+        return (a.DepthStencil.Depth == b.DepthStencil.Depth) &&
+          (a.DepthStencil.Stencil == b.DepthStencil.Stencil);
+    } else {
+        return (a.Color[0] == b.Color[0]) &&
+               (a.Color[1] == b.Color[1]) &&
+               (a.Color[2] == b.Color[2]) &&
+               (a.Color[3] == b.Color[3]);
+    }
+}
+inline bool operator==( const D3D12_RENDER_PASS_BEGINNING_ACCESS_CLEAR_PARAMETERS &a, const D3D12_RENDER_PASS_BEGINNING_ACCESS_CLEAR_PARAMETERS &b) noexcept
+{
+    return a.ClearValue == b.ClearValue;
+}
+inline bool operator==( const D3D12_RENDER_PASS_ENDING_ACCESS_RESOLVE_PARAMETERS &a, const D3D12_RENDER_PASS_ENDING_ACCESS_RESOLVE_PARAMETERS &b) noexcept
+{
+    if (a.pSrcResource != b.pSrcResource) return false;
+    if (a.pDstResource != b.pDstResource) return false;
+    if (a.SubresourceCount != b.SubresourceCount) return false;
+    if (a.Format != b.Format) return false;
+    if (a.ResolveMode != b.ResolveMode) return false;
+    if (a.PreserveResolveSource != b.PreserveResolveSource) return false;
+    return true;
+}
+inline bool operator==( const D3D12_RENDER_PASS_BEGINNING_ACCESS &a, const D3D12_RENDER_PASS_BEGINNING_ACCESS &b) noexcept
+{
+    if (a.Type != b.Type) return false;
+    if (a.Type == D3D12_RENDER_PASS_BEGINNING_ACCESS_TYPE_CLEAR && !(a.Clear == b.Clear)) return false;
+    return true;
+}
+inline bool operator==( const D3D12_RENDER_PASS_ENDING_ACCESS &a, const D3D12_RENDER_PASS_ENDING_ACCESS &b) noexcept
+{
+    if (a.Type != b.Type) return false;
+    if (a.Type == D3D12_RENDER_PASS_ENDING_ACCESS_TYPE_RESOLVE && !(a.Resolve == b.Resolve)) return false;
+    return true;
+}
+inline bool operator==( const D3D12_RENDER_PASS_RENDER_TARGET_DESC &a, const D3D12_RENDER_PASS_RENDER_TARGET_DESC &b) noexcept
+{
+    if (a.cpuDescriptor.ptr != b.cpuDescriptor.ptr) return false;
+    if (!(a.BeginningAccess == b.BeginningAccess)) return false;
+    if (!(a.EndingAccess == b.EndingAccess)) return false;
+    return true;
+}
+inline bool operator==( const D3D12_RENDER_PASS_DEPTH_STENCIL_DESC &a, const D3D12_RENDER_PASS_DEPTH_STENCIL_DESC &b) noexcept
+{
+    if (a.cpuDescriptor.ptr != b.cpuDescriptor.ptr) return false;
+    if (!(a.DepthBeginningAccess == b.DepthBeginningAccess)) return false;
+    if (!(a.StencilBeginningAccess == b.StencilBeginningAccess)) return false;
+    if (!(a.DepthEndingAccess == b.DepthEndingAccess)) return false;
+    if (!(a.StencilEndingAccess == b.StencilEndingAccess)) return false;
+    return true;
+}
+
+
+#ifndef D3DX12_NO_STATE_OBJECT_HELPERS
+
+//================================================================================================
+// D3DX12 State Object Creation Helpers
+//
+// Helper classes for creating new style state objects out of an arbitrary set of subobjects.
+// Uses STL
+//
+// Start by instantiating CD3DX12_STATE_OBJECT_DESC (see its public methods).
+// One of its methods is CreateSubobject(), which has a comment showing a couple of options for
+// defining subobjects using the helper classes for each subobject (CD3DX12_DXIL_LIBRARY_SUBOBJECT
+// etc.). The subobject helpers each have methods specific to the subobject for configuring its
+// contents.
+//
+//================================================================================================
+#include <list>
+#include <memory>
+#include <string>
+#include <vector>
+#ifndef D3DX12_USE_ATL
+#include <wrl/client.h>
+#define D3DX12_COM_PTR Microsoft::WRL::ComPtr
+#define D3DX12_COM_PTR_GET(x) x.Get()
+#define D3DX12_COM_PTR_ADDRESSOF(x) x.GetAddressOf()
+#else
+#include <atlbase.h>
+#define D3DX12_COM_PTR ATL::CComPtr
+#define D3DX12_COM_PTR_GET(x) x.p
+#define D3DX12_COM_PTR_ADDRESSOF(x) &x.p
+#endif
+
+//------------------------------------------------------------------------------------------------
+class CD3DX12_STATE_OBJECT_DESC
+{
+public:
+    CD3DX12_STATE_OBJECT_DESC() noexcept
+    {
+        Init(D3D12_STATE_OBJECT_TYPE_COLLECTION);
+    }
+    CD3DX12_STATE_OBJECT_DESC(D3D12_STATE_OBJECT_TYPE Type) noexcept
+    {
+        Init(Type);
+    }
+    void SetStateObjectType(D3D12_STATE_OBJECT_TYPE Type) noexcept { m_Desc.Type = Type; }
+    operator const D3D12_STATE_OBJECT_DESC&()
+    {
+        // Do final preparation work
+        m_RepointedAssociations.clear();
+        m_SubobjectArray.clear();
+        m_SubobjectArray.reserve(m_Desc.NumSubobjects);
+        // Flatten subobjects into an array (each flattened subobject still has a
+        // member that's a pointer to its desc that's not flattened)
+        for (auto Iter = m_SubobjectList.begin();
+            Iter != m_SubobjectList.end(); Iter++)
+        {
+            m_SubobjectArray.push_back(*Iter);
+            // Store new location in array so we can redirect pointers contained in subobjects
+            Iter->pSubobjectArrayLocation = &m_SubobjectArray.back();
+        }
+        // For subobjects with pointer fields, create a new copy of those subobject definitions
+        // with fixed pointers
+        for (UINT i = 0; i < m_Desc.NumSubobjects; i++)
+        {
+            if (m_SubobjectArray[i].Type == D3D12_STATE_SUBOBJECT_TYPE_SUBOBJECT_TO_EXPORTS_ASSOCIATION)
+            {
+                auto pOriginalSubobjectAssociation =
+                    static_cast<const D3D12_SUBOBJECT_TO_EXPORTS_ASSOCIATION*>(m_SubobjectArray[i].pDesc);
+                D3D12_SUBOBJECT_TO_EXPORTS_ASSOCIATION Repointed = *pOriginalSubobjectAssociation;
+                auto pWrapper =
+                    static_cast<const SUBOBJECT_WRAPPER*>(pOriginalSubobjectAssociation->pSubobjectToAssociate);
+                Repointed.pSubobjectToAssociate = pWrapper->pSubobjectArrayLocation;
+                m_RepointedAssociations.push_back(Repointed);
+                m_SubobjectArray[i].pDesc = &m_RepointedAssociations.back();
+            }
+        }
+        // Below: using ugly way to get pointer in case .data() is not defined
+        m_Desc.pSubobjects = m_Desc.NumSubobjects ? &m_SubobjectArray[0] : nullptr;
+        return m_Desc;
+    }
+    operator const D3D12_STATE_OBJECT_DESC*()
+    {
+        // Cast calls the above final preparation work
+        return &static_cast<const D3D12_STATE_OBJECT_DESC&>(*this);
+    }
+
+    // CreateSubobject creates a sububject helper (e.g. CD3DX12_HIT_GROUP_SUBOBJECT)
+    // whose lifetime is owned by this class.
+    // e.g.
+    //
+    //    CD3DX12_STATE_OBJECT_DESC Collection1(D3D12_STATE_OBJECT_TYPE_COLLECTION);
+    //    auto Lib0 = Collection1.CreateSubobject<CD3DX12_DXIL_LIBRARY_SUBOBJECT>();
+    //    Lib0->SetDXILLibrary(&pMyAppDxilLibs[0]);
+    //    Lib0->DefineExport(L"rayGenShader0"); // in practice these export listings might be
+    //                                          // data/engine driven
+    //    etc.
+    //
+    // Alternatively, users can instantiate sububject helpers explicitly, such as via local
+    // variables instead, passing the state object desc that should point to it into the helper
+    // constructor (or call mySubobjectHelper.AddToStateObject(Collection1)).
+    // In this alternative scenario, the user must keep the subobject alive as long as the state
+    // object it is associated with is alive, else its pointer references will be stale.
+    // e.g.
+    //
+    //    CD3DX12_STATE_OBJECT_DESC RaytracingState2(D3D12_STATE_OBJECT_TYPE_RAYTRACING_PIPELINE);
+    //    CD3DX12_DXIL_LIBRARY_SUBOBJECT LibA(RaytracingState2);
+    //    LibA.SetDXILLibrary(&pMyAppDxilLibs[4]); // not manually specifying exports
+    //                                             // - meaning all exports in the libraries
+    //                                             // are exported
+    //    etc.
+
+    template<typename T>
+    T* CreateSubobject()
+    {
+        T* pSubobject = new T(*this);
+        m_OwnedSubobjectHelpers.emplace_back(pSubobject);
+        return pSubobject;
+    }
+
+private:
+    D3D12_STATE_SUBOBJECT* TrackSubobject(D3D12_STATE_SUBOBJECT_TYPE Type, void* pDesc)
+    {
+        SUBOBJECT_WRAPPER Subobject;
+        Subobject.pSubobjectArrayLocation = nullptr;
+        Subobject.Type = Type;
+        Subobject.pDesc = pDesc;
+        m_SubobjectList.push_back(Subobject);
+        m_Desc.NumSubobjects++;
+        return &m_SubobjectList.back();
+    }
+    void Init(D3D12_STATE_OBJECT_TYPE Type) noexcept
+    {
+        SetStateObjectType(Type);
+        m_Desc.pSubobjects = nullptr;
+        m_Desc.NumSubobjects = 0;
+        m_SubobjectList.clear();
+        m_SubobjectArray.clear();
+        m_RepointedAssociations.clear();
+    }
+    typedef struct SUBOBJECT_WRAPPER : public D3D12_STATE_SUBOBJECT
+    {
+        D3D12_STATE_SUBOBJECT* pSubobjectArrayLocation; // new location when flattened into array
+                                                        // for repointing pointers in subobjects
+    } SUBOBJECT_WRAPPER;
+    D3D12_STATE_OBJECT_DESC m_Desc;
+    std::list<SUBOBJECT_WRAPPER>   m_SubobjectList; // Pointers to list nodes handed out so
+                                                    // these can be edited live
+    std::vector<D3D12_STATE_SUBOBJECT> m_SubobjectArray; // Built at the end, copying list contents
+
+    std::list<D3D12_SUBOBJECT_TO_EXPORTS_ASSOCIATION>
+            m_RepointedAssociations; // subobject type that contains pointers to other subobjects,
+                                     // repointed to flattened array
+
+    class StringContainer
+    {
+    public:
+        LPCWSTR LocalCopy(LPCWSTR string, bool bSingleString = false)
+        {
+            if (string)
+            {
+                if (bSingleString)
+                {
+                    m_Strings.clear();
+                    m_Strings.push_back(string);
+                }
+                else
+                {
+                    m_Strings.push_back(string);
+                }
+                return m_Strings.back().c_str();
+            }
+            else
+            {
+                return nullptr;
+            }
+        }
+        void clear() noexcept { m_Strings.clear(); }
+    private:
+        std::list<std::wstring> m_Strings;
+    };
+
+    class SUBOBJECT_HELPER_BASE
+    {
+    public:
+        SUBOBJECT_HELPER_BASE() noexcept { Init(); }
+        virtual ~SUBOBJECT_HELPER_BASE() = default;
+        virtual D3D12_STATE_SUBOBJECT_TYPE Type() const noexcept = 0;
+        void AddToStateObject(CD3DX12_STATE_OBJECT_DESC& ContainingStateObject)
+        {
+            m_pSubobject = ContainingStateObject.TrackSubobject(Type(), Data());
+        }
+    protected:
+        virtual void* Data() noexcept = 0;
+        void Init() noexcept { m_pSubobject = nullptr; }
+        D3D12_STATE_SUBOBJECT* m_pSubobject;
+    };
+
+#if(__cplusplus >= 201103L)
+    std::list<std::unique_ptr<const SUBOBJECT_HELPER_BASE>> m_OwnedSubobjectHelpers;
+#else
+    class OWNED_HELPER
+    {
+    public:
+        OWNED_HELPER(const SUBOBJECT_HELPER_BASE* pHelper) noexcept { m_pHelper = pHelper; }
+        ~OWNED_HELPER() { delete m_pHelper; }
+        const SUBOBJECT_HELPER_BASE* m_pHelper;
+    };
+
+    std::list<OWNED_HELPER> m_OwnedSubobjectHelpers;
+#endif
+
+    friend class CD3DX12_DXIL_LIBRARY_SUBOBJECT;
+    friend class CD3DX12_EXISTING_COLLECTION_SUBOBJECT;
+    friend class CD3DX12_SUBOBJECT_TO_EXPORTS_ASSOCIATION_SUBOBJECT;
+    friend class CD3DX12_DXIL_SUBOBJECT_TO_EXPORTS_ASSOCIATION;
+    friend class CD3DX12_HIT_GROUP_SUBOBJECT;
+    friend class CD3DX12_RAYTRACING_SHADER_CONFIG_SUBOBJECT;
+    friend class CD3DX12_RAYTRACING_PIPELINE_CONFIG_SUBOBJECT;
+    friend class CD3DX12_RAYTRACING_PIPELINE_CONFIG1_SUBOBJECT;
+    friend class CD3DX12_GLOBAL_ROOT_SIGNATURE_SUBOBJECT;
+    friend class CD3DX12_LOCAL_ROOT_SIGNATURE_SUBOBJECT;
+    friend class CD3DX12_STATE_OBJECT_CONFIG_SUBOBJECT;
+    friend class CD3DX12_NODE_MASK_SUBOBJECT;
+};
+
+//------------------------------------------------------------------------------------------------
+class CD3DX12_DXIL_LIBRARY_SUBOBJECT
+    : public CD3DX12_STATE_OBJECT_DESC::SUBOBJECT_HELPER_BASE
+{
+public:
+    CD3DX12_DXIL_LIBRARY_SUBOBJECT() noexcept
+    {
+        Init();
+    }
+    CD3DX12_DXIL_LIBRARY_SUBOBJECT(CD3DX12_STATE_OBJECT_DESC& ContainingStateObject)
+    {
+        Init();
+        AddToStateObject(ContainingStateObject);
+    }
+    void SetDXILLibrary(const D3D12_SHADER_BYTECODE* pCode) noexcept
+    {
+        static const D3D12_SHADER_BYTECODE Default = {};
+        m_Desc.DXILLibrary = pCode ? *pCode : Default;
+    }
+    void DefineExport(
+        LPCWSTR Name,
+        LPCWSTR ExportToRename = nullptr,
+        D3D12_EXPORT_FLAGS Flags = D3D12_EXPORT_FLAG_NONE)
+    {
+        D3D12_EXPORT_DESC Export;
+        Export.Name = m_Strings.LocalCopy(Name);
+        Export.ExportToRename = m_Strings.LocalCopy(ExportToRename);
+        Export.Flags = Flags;
+        m_Exports.push_back(Export);
+        m_Desc.pExports = &m_Exports[0];  // using ugly way to get pointer in case .data() is not defined
+        m_Desc.NumExports = static_cast<UINT>(m_Exports.size());
+    }
+    template<size_t N>
+    void DefineExports(LPCWSTR(&Exports)[N])
+    {
+        for (UINT i = 0; i < N; i++)
+        {
+            DefineExport(Exports[i]);
+        }
+    }
+    void DefineExports(const LPCWSTR* Exports, UINT N)
+    {
+        for (UINT i = 0; i < N; i++)
+        {
+            DefineExport(Exports[i]);
+        }
+    }
+    D3D12_STATE_SUBOBJECT_TYPE Type() const noexcept override
+    {
+        return D3D12_STATE_SUBOBJECT_TYPE_DXIL_LIBRARY;
+    }
+    operator const D3D12_STATE_SUBOBJECT&() const noexcept { return *m_pSubobject; }
+    operator const D3D12_DXIL_LIBRARY_DESC&() const noexcept { return m_Desc; }
+private:
+    void Init() noexcept
+    {
+        SUBOBJECT_HELPER_BASE::Init();
+        m_Desc = {};
+        m_Strings.clear();
+        m_Exports.clear();
+    }
+    void* Data() noexcept override { return &m_Desc; }
+    D3D12_DXIL_LIBRARY_DESC m_Desc;
+    CD3DX12_STATE_OBJECT_DESC::StringContainer m_Strings;
+    std::vector<D3D12_EXPORT_DESC> m_Exports;
+};
+
+//------------------------------------------------------------------------------------------------
+class CD3DX12_EXISTING_COLLECTION_SUBOBJECT
+    : public CD3DX12_STATE_OBJECT_DESC::SUBOBJECT_HELPER_BASE
+{
+public:
+    CD3DX12_EXISTING_COLLECTION_SUBOBJECT() noexcept
+    {
+        Init();
+    }
+    CD3DX12_EXISTING_COLLECTION_SUBOBJECT(CD3DX12_STATE_OBJECT_DESC& ContainingStateObject)
+    {
+        Init();
+        AddToStateObject(ContainingStateObject);
+    }
+    void SetExistingCollection(ID3D12StateObject*pExistingCollection) noexcept
+    {
+        m_Desc.pExistingCollection = pExistingCollection;
+        m_CollectionRef = pExistingCollection;
+    }
+    void DefineExport(
+        LPCWSTR Name,
+        LPCWSTR ExportToRename = nullptr,
+        D3D12_EXPORT_FLAGS Flags = D3D12_EXPORT_FLAG_NONE)
+    {
+        D3D12_EXPORT_DESC Export;
+        Export.Name = m_Strings.LocalCopy(Name);
+        Export.ExportToRename = m_Strings.LocalCopy(ExportToRename);
+        Export.Flags = Flags;
+        m_Exports.push_back(Export);
+        m_Desc.pExports = &m_Exports[0]; // using ugly way to get pointer in case .data() is not defined
+        m_Desc.NumExports = static_cast<UINT>(m_Exports.size());
+    }
+    template<size_t N>
+    void DefineExports(LPCWSTR(&Exports)[N])
+    {
+        for (UINT i = 0; i < N; i++)
+        {
+            DefineExport(Exports[i]);
+        }
+    }
+    void DefineExports(const LPCWSTR* Exports, UINT N)
+    {
+        for (UINT i = 0; i < N; i++)
+        {
+            DefineExport(Exports[i]);
+        }
+    }
+    D3D12_STATE_SUBOBJECT_TYPE Type() const noexcept override
+    {
+        return D3D12_STATE_SUBOBJECT_TYPE_EXISTING_COLLECTION;
+    }
+    operator const D3D12_STATE_SUBOBJECT&() const noexcept { return *m_pSubobject; }
+    operator const D3D12_EXISTING_COLLECTION_DESC&() const noexcept { return m_Desc; }
+private:
+    void Init() noexcept
+    {
+        SUBOBJECT_HELPER_BASE::Init();
+        m_Desc = {};
+        m_CollectionRef = nullptr;
+        m_Strings.clear();
+        m_Exports.clear();
+    }
+    void* Data() noexcept override { return &m_Desc; }
+    D3D12_EXISTING_COLLECTION_DESC m_Desc;
+    D3DX12_COM_PTR<ID3D12StateObject> m_CollectionRef;
+    CD3DX12_STATE_OBJECT_DESC::StringContainer m_Strings;
+    std::vector<D3D12_EXPORT_DESC> m_Exports;
+};
+
+//------------------------------------------------------------------------------------------------
+class CD3DX12_SUBOBJECT_TO_EXPORTS_ASSOCIATION_SUBOBJECT
+    : public CD3DX12_STATE_OBJECT_DESC::SUBOBJECT_HELPER_BASE
+{
+public:
+    CD3DX12_SUBOBJECT_TO_EXPORTS_ASSOCIATION_SUBOBJECT() noexcept
+    {
+        Init();
+    }
+    CD3DX12_SUBOBJECT_TO_EXPORTS_ASSOCIATION_SUBOBJECT(CD3DX12_STATE_OBJECT_DESC& ContainingStateObject)
+    {
+        Init();
+        AddToStateObject(ContainingStateObject);
+    }
+    void SetSubobjectToAssociate(const D3D12_STATE_SUBOBJECT& SubobjectToAssociate) noexcept
+    {
+        m_Desc.pSubobjectToAssociate = &SubobjectToAssociate;
+    }
+    void AddExport(LPCWSTR Export)
+    {
+        m_Desc.NumExports++;
+        m_Exports.push_back(m_Strings.LocalCopy(Export));
+        m_Desc.pExports = &m_Exports[0];  // using ugly way to get pointer in case .data() is not defined
+    }
+    template<size_t N>
+    void AddExports(LPCWSTR (&Exports)[N])
+    {
+        for (UINT i = 0; i < N; i++)
+        {
+            AddExport(Exports[i]);
+        }
+    }
+    void AddExports(const LPCWSTR* Exports, UINT N)
+    {
+        for (UINT i = 0; i < N; i++)
+        {
+            AddExport(Exports[i]);
+        }
+    }
+    D3D12_STATE_SUBOBJECT_TYPE Type() const noexcept override
+    {
+        return D3D12_STATE_SUBOBJECT_TYPE_SUBOBJECT_TO_EXPORTS_ASSOCIATION;
+    }
+    operator const D3D12_STATE_SUBOBJECT&() const noexcept { return *m_pSubobject; }
+    operator const D3D12_SUBOBJECT_TO_EXPORTS_ASSOCIATION&() const noexcept { return m_Desc; }
+private:
+    void Init() noexcept
+    {
+        SUBOBJECT_HELPER_BASE::Init();
+        m_Desc = {};
+        m_Strings.clear();
+        m_Exports.clear();
+    }
+    void* Data() noexcept override { return &m_Desc; }
+    D3D12_SUBOBJECT_TO_EXPORTS_ASSOCIATION m_Desc;
+    CD3DX12_STATE_OBJECT_DESC::StringContainer m_Strings;
+    std::vector<LPCWSTR> m_Exports;
+};
+
+//------------------------------------------------------------------------------------------------
+class CD3DX12_DXIL_SUBOBJECT_TO_EXPORTS_ASSOCIATION
+    : public CD3DX12_STATE_OBJECT_DESC::SUBOBJECT_HELPER_BASE
+{
+public:
+    CD3DX12_DXIL_SUBOBJECT_TO_EXPORTS_ASSOCIATION() noexcept
+    {
+        Init();
+    }
+    CD3DX12_DXIL_SUBOBJECT_TO_EXPORTS_ASSOCIATION(CD3DX12_STATE_OBJECT_DESC& ContainingStateObject)
+    {
+        Init();
+        AddToStateObject(ContainingStateObject);
+    }
+    void SetSubobjectNameToAssociate(LPCWSTR SubobjectToAssociate)
+    {
+        m_Desc.SubobjectToAssociate = m_SubobjectName.LocalCopy(SubobjectToAssociate, true);
+    }
+    void AddExport(LPCWSTR Export)
+    {
+        m_Desc.NumExports++;
+        m_Exports.push_back(m_Strings.LocalCopy(Export));
+        m_Desc.pExports = &m_Exports[0];  // using ugly way to get pointer in case .data() is not defined
+    }
+    template<size_t N>
+    void AddExports(LPCWSTR (&Exports)[N])
+    {
+        for (UINT i = 0; i < N; i++)
+        {
+            AddExport(Exports[i]);
+        }
+    }
+    void AddExports(const LPCWSTR* Exports, UINT N)
+    {
+        for (UINT i = 0; i < N; i++)
+        {
+            AddExport(Exports[i]);
+        }
+    }
+    D3D12_STATE_SUBOBJECT_TYPE Type() const noexcept override
+    {
+        return D3D12_STATE_SUBOBJECT_TYPE_DXIL_SUBOBJECT_TO_EXPORTS_ASSOCIATION;
+    }
+    operator const D3D12_STATE_SUBOBJECT&() const noexcept { return *m_pSubobject; }
+    operator const D3D12_DXIL_SUBOBJECT_TO_EXPORTS_ASSOCIATION&() const noexcept { return m_Desc; }
+private:
+    void Init() noexcept
+    {
+        SUBOBJECT_HELPER_BASE::Init();
+        m_Desc = {};
+        m_Strings.clear();
+        m_SubobjectName.clear();
+        m_Exports.clear();
+    }
+    void* Data() noexcept override { return &m_Desc; }
+    D3D12_DXIL_SUBOBJECT_TO_EXPORTS_ASSOCIATION m_Desc;
+    CD3DX12_STATE_OBJECT_DESC::StringContainer m_Strings;
+    CD3DX12_STATE_OBJECT_DESC::StringContainer m_SubobjectName;
+    std::vector<LPCWSTR> m_Exports;
+};
+
+//------------------------------------------------------------------------------------------------
+class CD3DX12_HIT_GROUP_SUBOBJECT
+    : public CD3DX12_STATE_OBJECT_DESC::SUBOBJECT_HELPER_BASE
+{
+public:
+    CD3DX12_HIT_GROUP_SUBOBJECT() noexcept
+    {
+        Init();
+    }
+    CD3DX12_HIT_GROUP_SUBOBJECT(CD3DX12_STATE_OBJECT_DESC& ContainingStateObject)
+    {
+        Init();
+        AddToStateObject(ContainingStateObject);
+    }
+    void SetHitGroupExport(LPCWSTR exportName)
+    {
+        m_Desc.HitGroupExport = m_Strings[0].LocalCopy(exportName, true);
+    }
+    void SetHitGroupType(D3D12_HIT_GROUP_TYPE Type) noexcept { m_Desc.Type = Type; }
+    void SetAnyHitShaderImport(LPCWSTR importName)
+    {
+        m_Desc.AnyHitShaderImport = m_Strings[1].LocalCopy(importName, true);
+    }
+    void SetClosestHitShaderImport(LPCWSTR importName)
+    {
+        m_Desc.ClosestHitShaderImport = m_Strings[2].LocalCopy(importName, true);
+    }
+    void SetIntersectionShaderImport(LPCWSTR importName)
+    {
+        m_Desc.IntersectionShaderImport = m_Strings[3].LocalCopy(importName, true);
+    }
+    D3D12_STATE_SUBOBJECT_TYPE Type() const noexcept override
+    {
+        return D3D12_STATE_SUBOBJECT_TYPE_HIT_GROUP;
+    }
+    operator const D3D12_STATE_SUBOBJECT&() const noexcept { return *m_pSubobject; }
+    operator const D3D12_HIT_GROUP_DESC&() const noexcept { return m_Desc; }
+private:
+    void Init() noexcept
+    {
+        SUBOBJECT_HELPER_BASE::Init();
+        m_Desc = {};
+        for (UINT i = 0; i < m_NumStrings; i++)
+        {
+            m_Strings[i].clear();
+        }
+    }
+    void* Data() noexcept override { return &m_Desc; }
+    D3D12_HIT_GROUP_DESC m_Desc;
+    static constexpr UINT m_NumStrings = 4;
+    CD3DX12_STATE_OBJECT_DESC::StringContainer
+        m_Strings[m_NumStrings]; // one string for every entrypoint name
+};
+
+//------------------------------------------------------------------------------------------------
+class CD3DX12_RAYTRACING_SHADER_CONFIG_SUBOBJECT
+    : public CD3DX12_STATE_OBJECT_DESC::SUBOBJECT_HELPER_BASE
+{
+public:
+    CD3DX12_RAYTRACING_SHADER_CONFIG_SUBOBJECT() noexcept
+    {
+        Init();
+    }
+    CD3DX12_RAYTRACING_SHADER_CONFIG_SUBOBJECT(CD3DX12_STATE_OBJECT_DESC& ContainingStateObject)
+    {
+        Init();
+        AddToStateObject(ContainingStateObject);
+    }
+    void Config(UINT MaxPayloadSizeInBytes, UINT MaxAttributeSizeInBytes) noexcept
+    {
+        m_Desc.MaxPayloadSizeInBytes = MaxPayloadSizeInBytes;
+        m_Desc.MaxAttributeSizeInBytes = MaxAttributeSizeInBytes;
+    }
+    D3D12_STATE_SUBOBJECT_TYPE Type() const noexcept override
+    {
+        return D3D12_STATE_SUBOBJECT_TYPE_RAYTRACING_SHADER_CONFIG;
+    }
+    operator const D3D12_STATE_SUBOBJECT&() const noexcept { return *m_pSubobject; }
+    operator const D3D12_RAYTRACING_SHADER_CONFIG&() const noexcept { return m_Desc; }
+private:
+    void Init() noexcept
+    {
+        SUBOBJECT_HELPER_BASE::Init();
+        m_Desc = {};
+    }
+    void* Data() noexcept override { return &m_Desc; }
+    D3D12_RAYTRACING_SHADER_CONFIG m_Desc;
+};
+
+//------------------------------------------------------------------------------------------------
+class CD3DX12_RAYTRACING_PIPELINE_CONFIG_SUBOBJECT
+    : public CD3DX12_STATE_OBJECT_DESC::SUBOBJECT_HELPER_BASE
+{
+public:
+    CD3DX12_RAYTRACING_PIPELINE_CONFIG_SUBOBJECT() noexcept
+    {
+        Init();
+    }
+    CD3DX12_RAYTRACING_PIPELINE_CONFIG_SUBOBJECT(CD3DX12_STATE_OBJECT_DESC& ContainingStateObject)
+    {
+        Init();
+        AddToStateObject(ContainingStateObject);
+    }
+    void Config(UINT MaxTraceRecursionDepth) noexcept
+    {
+        m_Desc.MaxTraceRecursionDepth = MaxTraceRecursionDepth;
+    }
+    D3D12_STATE_SUBOBJECT_TYPE Type() const noexcept override
+    {
+        return D3D12_STATE_SUBOBJECT_TYPE_RAYTRACING_PIPELINE_CONFIG;
+    }
+    operator const D3D12_STATE_SUBOBJECT&() const noexcept { return *m_pSubobject; }
+    operator const D3D12_RAYTRACING_PIPELINE_CONFIG&() const noexcept { return m_Desc; }
+private:
+    void Init() noexcept
+    {
+        SUBOBJECT_HELPER_BASE::Init();
+        m_Desc = {};
+    }
+    void* Data() noexcept override { return &m_Desc; }
+    D3D12_RAYTRACING_PIPELINE_CONFIG m_Desc;
+};
+
+//------------------------------------------------------------------------------------------------
+class CD3DX12_RAYTRACING_PIPELINE_CONFIG1_SUBOBJECT
+    : public CD3DX12_STATE_OBJECT_DESC::SUBOBJECT_HELPER_BASE
+{
+public:
+    CD3DX12_RAYTRACING_PIPELINE_CONFIG1_SUBOBJECT() noexcept
+    {
+        Init();
+    }
+    CD3DX12_RAYTRACING_PIPELINE_CONFIG1_SUBOBJECT(CD3DX12_STATE_OBJECT_DESC& ContainingStateObject)
+    {
+        Init();
+        AddToStateObject(ContainingStateObject);
+    }
+    void Config(UINT MaxTraceRecursionDepth, D3D12_RAYTRACING_PIPELINE_FLAGS Flags) noexcept
+    {
+        m_Desc.MaxTraceRecursionDepth = MaxTraceRecursionDepth;
+        m_Desc.Flags = Flags;
+    }
+    D3D12_STATE_SUBOBJECT_TYPE Type() const noexcept override
+    {
+        return D3D12_STATE_SUBOBJECT_TYPE_RAYTRACING_PIPELINE_CONFIG1;
+    }
+    operator const D3D12_STATE_SUBOBJECT&() const noexcept { return *m_pSubobject; }
+    operator const D3D12_RAYTRACING_PIPELINE_CONFIG1&() const noexcept { return m_Desc; }
+private:
+    void Init() noexcept
+    {
+        SUBOBJECT_HELPER_BASE::Init();
+        m_Desc = {};
+    }
+    void* Data() noexcept override { return &m_Desc; }
+    D3D12_RAYTRACING_PIPELINE_CONFIG1 m_Desc;
+};
+
+//------------------------------------------------------------------------------------------------
+class CD3DX12_GLOBAL_ROOT_SIGNATURE_SUBOBJECT
+    : public CD3DX12_STATE_OBJECT_DESC::SUBOBJECT_HELPER_BASE
+{
+public:
+    CD3DX12_GLOBAL_ROOT_SIGNATURE_SUBOBJECT() noexcept
+    {
+        Init();
+    }
+    CD3DX12_GLOBAL_ROOT_SIGNATURE_SUBOBJECT(CD3DX12_STATE_OBJECT_DESC& ContainingStateObject)
+    {
+        Init();
+        AddToStateObject(ContainingStateObject);
+    }
+    void SetRootSignature(ID3D12RootSignature* pRootSig) noexcept
+    {
+        m_pRootSig = pRootSig;
+    }
+    D3D12_STATE_SUBOBJECT_TYPE Type() const noexcept override
+    {
+        return D3D12_STATE_SUBOBJECT_TYPE_GLOBAL_ROOT_SIGNATURE;
+    }
+    operator const D3D12_STATE_SUBOBJECT&() const noexcept { return *m_pSubobject; }
+    operator ID3D12RootSignature*() const noexcept { return D3DX12_COM_PTR_GET(m_pRootSig); }
+private:
+    void Init() noexcept
+    {
+        SUBOBJECT_HELPER_BASE::Init();
+        m_pRootSig = nullptr;
+    }
+    void* Data() noexcept override { return D3DX12_COM_PTR_ADDRESSOF(m_pRootSig); }
+    D3DX12_COM_PTR<ID3D12RootSignature> m_pRootSig;
+};
+
+//------------------------------------------------------------------------------------------------
+class CD3DX12_LOCAL_ROOT_SIGNATURE_SUBOBJECT
+    : public CD3DX12_STATE_OBJECT_DESC::SUBOBJECT_HELPER_BASE
+{
+public:
+    CD3DX12_LOCAL_ROOT_SIGNATURE_SUBOBJECT() noexcept
+    {
+        Init();
+    }
+    CD3DX12_LOCAL_ROOT_SIGNATURE_SUBOBJECT(CD3DX12_STATE_OBJECT_DESC& ContainingStateObject)
+    {
+        Init();
+        AddToStateObject(ContainingStateObject);
+    }
+    void SetRootSignature(ID3D12RootSignature* pRootSig) noexcept
+    {
+        m_pRootSig = pRootSig;
+    }
+    D3D12_STATE_SUBOBJECT_TYPE Type() const noexcept override
+    {
+        return D3D12_STATE_SUBOBJECT_TYPE_LOCAL_ROOT_SIGNATURE;
+    }
+    operator const D3D12_STATE_SUBOBJECT&() const noexcept { return *m_pSubobject; }
+    operator ID3D12RootSignature*() const noexcept { return D3DX12_COM_PTR_GET(m_pRootSig); }
+private:
+    void Init() noexcept
+    {
+        SUBOBJECT_HELPER_BASE::Init();
+        m_pRootSig = nullptr;
+    }
+    void* Data() noexcept override { return D3DX12_COM_PTR_ADDRESSOF(m_pRootSig); }
+    D3DX12_COM_PTR<ID3D12RootSignature> m_pRootSig;
+};
+
+//------------------------------------------------------------------------------------------------
+class CD3DX12_STATE_OBJECT_CONFIG_SUBOBJECT
+    : public CD3DX12_STATE_OBJECT_DESC::SUBOBJECT_HELPER_BASE
+{
+public:
+    CD3DX12_STATE_OBJECT_CONFIG_SUBOBJECT() noexcept
+    {
+        Init();
+    }
+    CD3DX12_STATE_OBJECT_CONFIG_SUBOBJECT(CD3DX12_STATE_OBJECT_DESC& ContainingStateObject)
+    {
+        Init();
+        AddToStateObject(ContainingStateObject);
+    }
+    void SetFlags(D3D12_STATE_OBJECT_FLAGS Flags) noexcept
+    {
+        m_Desc.Flags = Flags;
+    }
+    D3D12_STATE_SUBOBJECT_TYPE Type() const noexcept override
+    {
+        return D3D12_STATE_SUBOBJECT_TYPE_STATE_OBJECT_CONFIG;
+    }
+    operator const D3D12_STATE_SUBOBJECT&() const noexcept { return *m_pSubobject; }
+    operator const D3D12_STATE_OBJECT_CONFIG&() const noexcept { return m_Desc; }
+private:
+    void Init() noexcept
+    {
+        SUBOBJECT_HELPER_BASE::Init();
+        m_Desc = {};
+    }
+    void* Data() noexcept override { return &m_Desc; }
+    D3D12_STATE_OBJECT_CONFIG m_Desc;
+};
+
+//------------------------------------------------------------------------------------------------
+class CD3DX12_NODE_MASK_SUBOBJECT
+    : public CD3DX12_STATE_OBJECT_DESC::SUBOBJECT_HELPER_BASE
+{
+public:
+    CD3DX12_NODE_MASK_SUBOBJECT() noexcept
+    {
+        Init();
+    }
+    CD3DX12_NODE_MASK_SUBOBJECT(CD3DX12_STATE_OBJECT_DESC& ContainingStateObject)
+    {
+        Init();
+        AddToStateObject(ContainingStateObject);
+    }
+    void SetNodeMask(UINT NodeMask) noexcept
+    {
+        m_Desc.NodeMask = NodeMask;
+    }
+    D3D12_STATE_SUBOBJECT_TYPE Type() const noexcept override
+    {
+        return D3D12_STATE_SUBOBJECT_TYPE_NODE_MASK;
+    }
+    operator const D3D12_STATE_SUBOBJECT&() const noexcept { return *m_pSubobject; }
+    operator const D3D12_NODE_MASK&() const noexcept { return m_Desc; }
+private:
+    void Init() noexcept
+    {
+        SUBOBJECT_HELPER_BASE::Init();
+        m_Desc = {};
+    }
+    void* Data() noexcept override { return &m_Desc; }
+    D3D12_NODE_MASK m_Desc;
+};
+
+#endif // !D3DX12_NO_STATE_OBJECT_HELPERS
+
+
+//================================================================================================
+// D3DX12 Enhanced Barrier Helpers
+//================================================================================================
+
+class CD3DX12_BARRIER_SUBRESOURCE_RANGE : public D3D12_BARRIER_SUBRESOURCE_RANGE
+{
+public:
+    CD3DX12_BARRIER_SUBRESOURCE_RANGE() = default;
+    CD3DX12_BARRIER_SUBRESOURCE_RANGE(const D3D12_BARRIER_SUBRESOURCE_RANGE &o) noexcept :
+        D3D12_BARRIER_SUBRESOURCE_RANGE(o)
+    {}
+    explicit CD3DX12_BARRIER_SUBRESOURCE_RANGE(UINT Subresource) noexcept :
+        D3D12_BARRIER_SUBRESOURCE_RANGE{ Subresource, 0, 0, 0, 0, 0 }
+    {}
+    CD3DX12_BARRIER_SUBRESOURCE_RANGE(
+        UINT FirstMipLevel,
+        UINT NumMips,
+        UINT FirstArraySlice,
+        UINT NumArraySlices,
+        UINT FirstPlane = 0,
+        UINT NumPlanes = 1) noexcept :
+        D3D12_BARRIER_SUBRESOURCE_RANGE
+        {
+            FirstMipLevel,
+            NumMips,
+            FirstArraySlice,
+            NumArraySlices,
+            FirstPlane,
+            NumPlanes
+        }
+    {}
+};
+
+class CD3DX12_GLOBAL_BARRIER : public D3D12_GLOBAL_BARRIER
+{
+public:
+    CD3DX12_GLOBAL_BARRIER() = default;
+    CD3DX12_GLOBAL_BARRIER(const D3D12_GLOBAL_BARRIER &o) noexcept : D3D12_GLOBAL_BARRIER(o){}
+    CD3DX12_GLOBAL_BARRIER(
+        D3D12_BARRIER_SYNC syncBefore,
+        D3D12_BARRIER_SYNC syncAfter,
+        D3D12_BARRIER_ACCESS accessBefore,
+        D3D12_BARRIER_ACCESS accessAfter) noexcept : D3D12_GLOBAL_BARRIER {
+            syncBefore,
+            syncAfter,
+            accessBefore,
+            accessAfter
+        }
+    {}
+};
+
+class CD3DX12_BUFFER_BARRIER : public D3D12_BUFFER_BARRIER
+{
+public:
+    CD3DX12_BUFFER_BARRIER() = default;
+    CD3DX12_BUFFER_BARRIER(const D3D12_BUFFER_BARRIER &o) noexcept : D3D12_BUFFER_BARRIER(o){}
+    CD3DX12_BUFFER_BARRIER(
+        D3D12_BARRIER_SYNC syncBefore,
+        D3D12_BARRIER_SYNC syncAfter,
+        D3D12_BARRIER_ACCESS accessBefore,
+        D3D12_BARRIER_ACCESS accessAfter,
+        ID3D12Resource *pRes) noexcept : D3D12_BUFFER_BARRIER {
+            syncBefore,
+            syncAfter,
+            accessBefore,
+            accessAfter,
+            pRes,
+            0, ULLONG_MAX
+        }
+    {}
+};
+
+class CD3DX12_TEXTURE_BARRIER : public D3D12_TEXTURE_BARRIER
+{
+public:
+    CD3DX12_TEXTURE_BARRIER() = default;
+    CD3DX12_TEXTURE_BARRIER(const D3D12_TEXTURE_BARRIER &o) noexcept : D3D12_TEXTURE_BARRIER(o){}
+    CD3DX12_TEXTURE_BARRIER(
+        D3D12_BARRIER_SYNC syncBefore,
+        D3D12_BARRIER_SYNC syncAfter,
+        D3D12_BARRIER_ACCESS accessBefore,
+        D3D12_BARRIER_ACCESS accessAfter,
+        D3D12_BARRIER_LAYOUT layoutBefore,
+        D3D12_BARRIER_LAYOUT layoutAfter,
+        ID3D12Resource *pRes,
+        const D3D12_BARRIER_SUBRESOURCE_RANGE &subresources,
+        D3D12_TEXTURE_BARRIER_FLAGS flag = D3D12_TEXTURE_BARRIER_FLAG_NONE) noexcept : D3D12_TEXTURE_BARRIER {
+            syncBefore,
+            syncAfter,
+            accessBefore,
+            accessAfter,
+            layoutBefore,
+            layoutAfter,
+            pRes,
+            subresources,
+            flag
+        }
+    {}
+};
+
+class CD3DX12_BARRIER_GROUP : public D3D12_BARRIER_GROUP
+{
+public:
+    CD3DX12_BARRIER_GROUP() = default;
+    CD3DX12_BARRIER_GROUP(const D3D12_BARRIER_GROUP &o) noexcept : D3D12_BARRIER_GROUP(o){}
+    CD3DX12_BARRIER_GROUP(UINT32 numBarriers, const D3D12_BUFFER_BARRIER *pBarriers) noexcept
+    {
+        Type = D3D12_BARRIER_TYPE_BUFFER;
+        NumBarriers = numBarriers;
+        pBufferBarriers = pBarriers;
+    }
+    CD3DX12_BARRIER_GROUP(UINT32 numBarriers, const D3D12_TEXTURE_BARRIER *pBarriers) noexcept
+    {
+        Type = D3D12_BARRIER_TYPE_TEXTURE;
+        NumBarriers = numBarriers;
+        pTextureBarriers = pBarriers;
+    }
+    CD3DX12_BARRIER_GROUP(UINT32 numBarriers, const D3D12_GLOBAL_BARRIER *pBarriers) noexcept
+    {
+        Type = D3D12_BARRIER_TYPE_GLOBAL;
+        NumBarriers = numBarriers;
+        pGlobalBarriers = pBarriers;
+    }
+};
+
+
+#ifndef D3DX12_NO_CHECK_FEATURE_SUPPORT_CLASS
+
+//================================================================================================
+// D3DX12 Check Feature Support
+//================================================================================================
+
+#include <vector>
+
+class CD3DX12FeatureSupport
+{
+public: // Function declaration
+    // Default constructor that creates an empty object
+    CD3DX12FeatureSupport() noexcept;
+
+    // Initialize data from the given device
+    HRESULT Init(ID3D12Device* pDevice);
+
+    // Retreives the status of the object. If an error occurred in the initialization process, the function returns the error code.
+    HRESULT GetStatus() const noexcept { return m_hStatus; }
+
+    // Getter functions for each feature class
+    // D3D12_OPTIONS
+    BOOL DoublePrecisionFloatShaderOps() const noexcept;
+    BOOL OutputMergerLogicOp() const noexcept;
+    D3D12_SHADER_MIN_PRECISION_SUPPORT MinPrecisionSupport() const noexcept;
+    D3D12_TILED_RESOURCES_TIER TiledResourcesTier() const noexcept;
+    D3D12_RESOURCE_BINDING_TIER ResourceBindingTier() const noexcept;
+    BOOL PSSpecifiedStencilRefSupported() const noexcept;
+    BOOL TypedUAVLoadAdditionalFormats() const noexcept;
+    BOOL ROVsSupported() const noexcept;
+    D3D12_CONSERVATIVE_RASTERIZATION_TIER ConservativeRasterizationTier() const noexcept;
+    BOOL StandardSwizzle64KBSupported() const noexcept;
+    BOOL CrossAdapterRowMajorTextureSupported() const noexcept;
+    BOOL VPAndRTArrayIndexFromAnyShaderFeedingRasterizerSupportedWithoutGSEmulation() const noexcept;
+    D3D12_RESOURCE_HEAP_TIER ResourceHeapTier() const noexcept;
+    D3D12_CROSS_NODE_SHARING_TIER CrossNodeSharingTier() const noexcept;
+    UINT MaxGPUVirtualAddressBitsPerResource() const noexcept;
+
+    // FEATURE_LEVELS
+    D3D_FEATURE_LEVEL MaxSupportedFeatureLevel() const noexcept;
+
+    // FORMAT_SUPPORT
+    HRESULT FormatSupport(DXGI_FORMAT Format, D3D12_FORMAT_SUPPORT1& Support1, D3D12_FORMAT_SUPPORT2& Support2) const;
+
+    // MUTLTISAMPLE_QUALITY_LEVELS
+    HRESULT MultisampleQualityLevels(DXGI_FORMAT Format, UINT SampleCount, D3D12_MULTISAMPLE_QUALITY_LEVEL_FLAGS Flags, UINT& NumQualityLevels) const;
+
+    // FORMAT_INFO
+    HRESULT FormatInfo(DXGI_FORMAT Format, UINT8& PlaneCount) const;
+
+    // GPU_VIRTUAL_ADDRESS_SUPPORT
+    UINT MaxGPUVirtualAddressBitsPerProcess() const noexcept;
+
+    // SHADER_MODEL
+    D3D_SHADER_MODEL HighestShaderModel() const noexcept;
+
+    // D3D12_OPTIONS1
+    BOOL WaveOps() const noexcept;
+    UINT WaveLaneCountMin() const noexcept;
+    UINT WaveLaneCountMax() const noexcept;
+    UINT TotalLaneCount() const noexcept;
+    BOOL ExpandedComputeResourceStates() const noexcept;
+    BOOL Int64ShaderOps() const noexcept;
+
+    // PROTECTED_RESOURCE_SESSION_SUPPORT
+    D3D12_PROTECTED_RESOURCE_SESSION_SUPPORT_FLAGS ProtectedResourceSessionSupport(UINT NodeIndex = 0) const;
+
+    // ROOT_SIGNATURE
+    D3D_ROOT_SIGNATURE_VERSION HighestRootSignatureVersion() const noexcept;
+
+    // ARCHITECTURE1
+    BOOL TileBasedRenderer(UINT NodeIndex = 0) const;
+    BOOL UMA(UINT NodeIndex = 0) const;
+    BOOL CacheCoherentUMA(UINT NodeIndex = 0) const;
+    BOOL IsolatedMMU(UINT NodeIndex = 0) const;
+
+    // D3D12_OPTIONS2
+    BOOL DepthBoundsTestSupported() const noexcept;
+    D3D12_PROGRAMMABLE_SAMPLE_POSITIONS_TIER ProgrammableSamplePositionsTier() const noexcept;
+
+    // SHADER_CACHE
+    D3D12_SHADER_CACHE_SUPPORT_FLAGS ShaderCacheSupportFlags() const noexcept;
+
+    // COMMAND_QUEUE_PRIORITY
+    BOOL CommandQueuePrioritySupported(D3D12_COMMAND_LIST_TYPE CommandListType, UINT Priority);
+
+    // D3D12_OPTIONS3
+    BOOL CopyQueueTimestampQueriesSupported() const noexcept;
+    BOOL CastingFullyTypedFormatSupported() const noexcept;
+    D3D12_COMMAND_LIST_SUPPORT_FLAGS WriteBufferImmediateSupportFlags() const noexcept;
+    D3D12_VIEW_INSTANCING_TIER ViewInstancingTier() const noexcept;
+    BOOL BarycentricsSupported() const noexcept;
+
+    // EXISTING_HEAPS
+    BOOL ExistingHeapsSupported() const noexcept;
+
+    // D3D12_OPTIONS4
+    BOOL MSAA64KBAlignedTextureSupported() const noexcept;
+    D3D12_SHARED_RESOURCE_COMPATIBILITY_TIER SharedResourceCompatibilityTier() const noexcept;
+    BOOL Native16BitShaderOpsSupported() const noexcept;
+
+    // SERIALIZATION
+    D3D12_HEAP_SERIALIZATION_TIER HeapSerializationTier(UINT NodeIndex = 0) const;
+
+    // CROSS_NODE
+    // CrossNodeSharingTier handled in D3D12Options
+    BOOL CrossNodeAtomicShaderInstructions() const noexcept;
+
+    // D3D12_OPTIONS5
+    BOOL SRVOnlyTiledResourceTier3() const noexcept;
+    D3D12_RENDER_PASS_TIER RenderPassesTier() const noexcept;
+    D3D12_RAYTRACING_TIER RaytracingTier() const noexcept;
+
+    // DISPLAYABLE
+    BOOL DisplayableTexture() const noexcept;
+    // SharedResourceCompatibilityTier handled in D3D12Options4
+
+    // D3D12_OPTIONS6
+    BOOL AdditionalShadingRatesSupported() const noexcept;
+    BOOL PerPrimitiveShadingRateSupportedWithViewportIndexing() const noexcept;
+    D3D12_VARIABLE_SHADING_RATE_TIER VariableShadingRateTier() const noexcept;
+    UINT ShadingRateImageTileSize() const noexcept;
+    BOOL BackgroundProcessingSupported() const noexcept;
+
+    // QUERY_META_COMMAND
+    HRESULT QueryMetaCommand(D3D12_FEATURE_DATA_QUERY_META_COMMAND& dQueryMetaCommand) const;
+
+    // D3D12_OPTIONS7
+    D3D12_MESH_SHADER_TIER MeshShaderTier() const noexcept;
+    D3D12_SAMPLER_FEEDBACK_TIER SamplerFeedbackTier() const noexcept;
+
+    // PROTECTED_RESOURCE_SESSION_TYPE_COUNT
+    UINT ProtectedResourceSessionTypeCount(UINT NodeIndex = 0) const;
+
+    // PROTECTED_RESOURCE_SESSION_TYPES
+    std::vector<GUID> ProtectedResourceSessionTypes(UINT NodeIndex = 0) const;
+
+    // D3D12_OPTIONS8
+    BOOL UnalignedBlockTexturesSupported() const noexcept;
+
+    // D3D12_OPTIONS9
+    BOOL MeshShaderPipelineStatsSupported() const noexcept;
+    BOOL MeshShaderSupportsFullRangeRenderTargetArrayIndex() const noexcept;
+    BOOL AtomicInt64OnTypedResourceSupported() const noexcept;
+    BOOL AtomicInt64OnGroupSharedSupported() const noexcept;
+    BOOL DerivativesInMeshAndAmplificationShadersSupported() const noexcept;
+    D3D12_WAVE_MMA_TIER WaveMMATier() const noexcept;
+
+    // D3D12_OPTIONS10
+    BOOL VariableRateShadingSumCombinerSupported() const noexcept;
+    BOOL MeshShaderPerPrimitiveShadingRateSupported() const noexcept;
+
+    // D3D12_OPTIONS11
+    BOOL AtomicInt64OnDescriptorHeapResourceSupported() const noexcept;
+
+    // D3D12_OPTIONS12
+    D3D12_TRI_STATE MSPrimitivesPipelineStatisticIncludesCulledPrimitives() const noexcept;
+    BOOL EnhancedBarriersSupported() const noexcept;
+    BOOL RelaxedFormatCastingSupported() const noexcept;
+
+    // D3D12_OPTIONS13
+    BOOL UnrestrictedBufferTextureCopyPitchSupported() const noexcept;
+    BOOL UnrestrictedVertexElementAlignmentSupported() const noexcept;
+    BOOL InvertedViewportHeightFlipsYSupported() const noexcept;
+    BOOL InvertedViewportDepthFlipsZSupported() const noexcept;
+    BOOL TextureCopyBetweenDimensionsSupported() const noexcept;
+    BOOL AlphaBlendFactorSupported() const noexcept;
+
+    // D3D12_OPTIONS14
+    BOOL AdvancedTextureOpsSupported() const noexcept;
+    BOOL WriteableMSAATexturesSupported() const noexcept;
+    BOOL IndependentFrontAndBackStencilRefMaskSupported() const noexcept;
+
+    // D3D12_OPTIONS15
+    BOOL TriangleFanSupported() const noexcept;
+    BOOL DynamicIndexBufferStripCutSupported() const noexcept;
+
+private: // Private structs and helpers declaration
+    struct ProtectedResourceSessionTypesLocal : D3D12_FEATURE_DATA_PROTECTED_RESOURCE_SESSION_TYPES
+    {
+        std::vector<GUID> TypeVec;
+    };
+
+    // Helper function to decide the highest shader model supported by the system
+    // Stores the result in m_dShaderModel
+    // Must be updated whenever a new shader model is added to the d3d12.h header
+    HRESULT QueryHighestShaderModel();
+
+    // Helper function to decide the highest root signature supported
+    // Must be updated whenever a new root signature version is added to the d3d12.h header
+    HRESULT QueryHighestRootSignatureVersion();
+
+    // Helper funcion to decide the highest feature level
+    HRESULT QueryHighestFeatureLevel();
+
+    // Helper function to initialize local protected resource session types structs
+    HRESULT QueryProtectedResourceSessionTypes(UINT NodeIndex, UINT Count);
+
+private: // Member data
+    // Pointer to the underlying device
+    ID3D12Device* m_pDevice;
+
+    // Stores the error code from initialization
+    HRESULT m_hStatus;
+
+    // Feature support data structs
+    D3D12_FEATURE_DATA_D3D12_OPTIONS m_dOptions;
+    D3D_FEATURE_LEVEL m_eMaxFeatureLevel;
+    D3D12_FEATURE_DATA_GPU_VIRTUAL_ADDRESS_SUPPORT m_dGPUVASupport;
+    D3D12_FEATURE_DATA_SHADER_MODEL m_dShaderModel;
+    D3D12_FEATURE_DATA_D3D12_OPTIONS1 m_dOptions1;
+    std::vector<D3D12_FEATURE_DATA_PROTECTED_RESOURCE_SESSION_SUPPORT> m_dProtectedResourceSessionSupport;
+    D3D12_FEATURE_DATA_ROOT_SIGNATURE m_dRootSignature;
+    std::vector<D3D12_FEATURE_DATA_ARCHITECTURE1> m_dArchitecture1;
+    D3D12_FEATURE_DATA_D3D12_OPTIONS2 m_dOptions2;
+    D3D12_FEATURE_DATA_SHADER_CACHE m_dShaderCache;
+    D3D12_FEATURE_DATA_COMMAND_QUEUE_PRIORITY m_dCommandQueuePriority;
+    D3D12_FEATURE_DATA_D3D12_OPTIONS3 m_dOptions3;
+    D3D12_FEATURE_DATA_EXISTING_HEAPS m_dExistingHeaps;
+    D3D12_FEATURE_DATA_D3D12_OPTIONS4 m_dOptions4;
+    std::vector<D3D12_FEATURE_DATA_SERIALIZATION> m_dSerialization; // Cat2 NodeIndex
+    D3D12_FEATURE_DATA_CROSS_NODE m_dCrossNode;
+    D3D12_FEATURE_DATA_D3D12_OPTIONS5 m_dOptions5;
+    D3D12_FEATURE_DATA_DISPLAYABLE m_dDisplayable;
+    D3D12_FEATURE_DATA_D3D12_OPTIONS6 m_dOptions6;
+    D3D12_FEATURE_DATA_D3D12_OPTIONS7 m_dOptions7;
+    std::vector<D3D12_FEATURE_DATA_PROTECTED_RESOURCE_SESSION_TYPE_COUNT> m_dProtectedResourceSessionTypeCount; // Cat2 NodeIndex
+    std::vector<ProtectedResourceSessionTypesLocal> m_dProtectedResourceSessionTypes; // Cat3
+    D3D12_FEATURE_DATA_D3D12_OPTIONS8 m_dOptions8;
+    D3D12_FEATURE_DATA_D3D12_OPTIONS9 m_dOptions9;
+    D3D12_FEATURE_DATA_D3D12_OPTIONS10 m_dOptions10;
+    D3D12_FEATURE_DATA_D3D12_OPTIONS11 m_dOptions11;
+    D3D12_FEATURE_DATA_D3D12_OPTIONS12 m_dOptions12;
+    D3D12_FEATURE_DATA_D3D12_OPTIONS13 m_dOptions13;
+    D3D12_FEATURE_DATA_D3D12_OPTIONS14 m_dOptions14;
+    D3D12_FEATURE_DATA_D3D12_OPTIONS15 m_dOptions15;
+};
+
+// Implementations for CD3DX12FeatureSupport functions
+
+// Macro to set up a getter function for each entry in feature support data
+// The getter function will have the same name as the feature option name
+#define FEATURE_SUPPORT_GET(RETTYPE,FEATURE,OPTION) \
+inline RETTYPE CD3DX12FeatureSupport::OPTION() const noexcept \
+{ \
+    return FEATURE.OPTION; \
+}
+
+// Macro to set up a getter function for each entry in feature support data
+// Also specifies the name for the function which can be different from the feature name
+#define FEATURE_SUPPORT_GET_NAME(RETTYPE,FEATURE,OPTION,NAME) \
+inline RETTYPE CD3DX12FeatureSupport::NAME() const noexcept \
+{\
+    return FEATURE.OPTION; \
+}
+
+// Macro to set up a getter function for feature data indexed by the graphics node ID
+// The default parameter is 0, or the first availabe graphics device node
+#define FEATURE_SUPPORT_GET_NODE_INDEXED(RETTYPE,FEATURE,OPTION) \
+inline RETTYPE CD3DX12FeatureSupport::OPTION(UINT NodeIndex) const \
+{\
+    return FEATURE[NodeIndex].OPTION; \
+}
+
+// Macro to set up a getter function for feature data indexed by NodeIndex
+// Allows a custom name for the getter function
+#define FEATURE_SUPPORT_GET_NODE_INDEXED_NAME(RETTYPE,FEATURE,OPTION,NAME) \
+inline RETTYPE CD3DX12FeatureSupport::NAME(UINT NodeIndex) const \
+{\
+    return FEATURE[NodeIndex].OPTION; \
+}
+
+inline CD3DX12FeatureSupport::CD3DX12FeatureSupport() noexcept
+: m_pDevice(nullptr)
+, m_hStatus(E_INVALIDARG)
+, m_dOptions{}
+, m_eMaxFeatureLevel{}
+, m_dGPUVASupport{}
+, m_dShaderModel{}
+, m_dOptions1{}
+, m_dRootSignature{}
+, m_dOptions2{}
+, m_dShaderCache{}
+, m_dCommandQueuePriority{}
+, m_dOptions3{}
+, m_dExistingHeaps{}
+, m_dOptions4{}
+, m_dCrossNode{}
+, m_dOptions5{}
+, m_dDisplayable{}
+, m_dOptions6{}
+, m_dOptions7{}
+, m_dOptions8{}
+, m_dOptions9{}
+, m_dOptions10{}
+, m_dOptions11{}
+, m_dOptions12{}
+, m_dOptions13{}
+, m_dOptions14{}
+, m_dOptions15{}
+{}
+
+inline HRESULT CD3DX12FeatureSupport::Init(ID3D12Device* pDevice)
+{
+    if (!pDevice)
+    {
+        m_hStatus = E_INVALIDARG;
+        return m_hStatus;
+    }
+
+    m_pDevice = pDevice;
+
+    // Initialize static feature support data structures
+    if (FAILED(m_pDevice->CheckFeatureSupport(D3D12_FEATURE_D3D12_OPTIONS, &m_dOptions, sizeof(m_dOptions))))
+    {
+        m_dOptions.DoublePrecisionFloatShaderOps = false;
+        m_dOptions.OutputMergerLogicOp = false;
+        m_dOptions.MinPrecisionSupport = D3D12_SHADER_MIN_PRECISION_SUPPORT_NONE;
+        m_dOptions.TiledResourcesTier = D3D12_TILED_RESOURCES_TIER_NOT_SUPPORTED;
+        m_dOptions.ResourceBindingTier = static_cast<D3D12_RESOURCE_BINDING_TIER>(0);
+        m_dOptions.PSSpecifiedStencilRefSupported = false;
+        m_dOptions.TypedUAVLoadAdditionalFormats = false;
+        m_dOptions.ROVsSupported = false;
+        m_dOptions.ConservativeRasterizationTier = D3D12_CONSERVATIVE_RASTERIZATION_TIER_NOT_SUPPORTED;
+        m_dOptions.MaxGPUVirtualAddressBitsPerResource = 0;
+        m_dOptions.StandardSwizzle64KBSupported = false;
+        m_dOptions.CrossNodeSharingTier = D3D12_CROSS_NODE_SHARING_TIER_NOT_SUPPORTED;
+        m_dOptions.CrossAdapterRowMajorTextureSupported = false;
+        m_dOptions.VPAndRTArrayIndexFromAnyShaderFeedingRasterizerSupportedWithoutGSEmulation = false;
+        m_dOptions.ResourceHeapTier = static_cast<D3D12_RESOURCE_HEAP_TIER>(0);
+    }
+
+    if (FAILED(m_pDevice->CheckFeatureSupport(D3D12_FEATURE_GPU_VIRTUAL_ADDRESS_SUPPORT, &m_dGPUVASupport, sizeof(m_dGPUVASupport))))
+    {
+        m_dGPUVASupport.MaxGPUVirtualAddressBitsPerProcess = 0;
+        m_dGPUVASupport.MaxGPUVirtualAddressBitsPerResource = 0;
+    }
+
+    if (FAILED(m_pDevice->CheckFeatureSupport(D3D12_FEATURE_D3D12_OPTIONS1, &m_dOptions1, sizeof(m_dOptions1))))
+    {
+        m_dOptions1.WaveOps = false;
+        m_dOptions1.WaveLaneCountMax = 0;
+        m_dOptions1.WaveLaneCountMin = 0;
+        m_dOptions1.TotalLaneCount = 0;
+        m_dOptions1.ExpandedComputeResourceStates = 0;
+        m_dOptions1.Int64ShaderOps = 0;
+    }
+
+    if (FAILED(m_pDevice->CheckFeatureSupport(D3D12_FEATURE_D3D12_OPTIONS2, &m_dOptions2, sizeof(m_dOptions2))))
+    {
+        m_dOptions2.DepthBoundsTestSupported = false;
+        m_dOptions2.ProgrammableSamplePositionsTier = D3D12_PROGRAMMABLE_SAMPLE_POSITIONS_TIER_NOT_SUPPORTED;
+    }
+
+    if (FAILED(m_pDevice->CheckFeatureSupport(D3D12_FEATURE_SHADER_CACHE, &m_dShaderCache, sizeof(m_dShaderCache))))
+    {
+        m_dShaderCache.SupportFlags = D3D12_SHADER_CACHE_SUPPORT_NONE;
+    }
+
+    if (FAILED(m_pDevice->CheckFeatureSupport(D3D12_FEATURE_D3D12_OPTIONS3, &m_dOptions3, sizeof(m_dOptions3))))
+    {
+        m_dOptions3.CopyQueueTimestampQueriesSupported = false;
+        m_dOptions3.CastingFullyTypedFormatSupported = false;
+        m_dOptions3.WriteBufferImmediateSupportFlags = D3D12_COMMAND_LIST_SUPPORT_FLAG_NONE;
+        m_dOptions3.ViewInstancingTier = D3D12_VIEW_INSTANCING_TIER_NOT_SUPPORTED;
+        m_dOptions3.BarycentricsSupported = false;
+    }
+
+    if (FAILED(m_pDevice->CheckFeatureSupport(D3D12_FEATURE_EXISTING_HEAPS, &m_dExistingHeaps, sizeof(m_dExistingHeaps))))
+    {
+        m_dExistingHeaps.Supported = false;
+    }
+
+    if (FAILED(m_pDevice->CheckFeatureSupport(D3D12_FEATURE_D3D12_OPTIONS4, &m_dOptions4, sizeof(m_dOptions4))))
+    {
+        m_dOptions4.MSAA64KBAlignedTextureSupported = false;
+        m_dOptions4.Native16BitShaderOpsSupported = false;
+        m_dOptions4.SharedResourceCompatibilityTier = D3D12_SHARED_RESOURCE_COMPATIBILITY_TIER_0;
+    }
+
+    if (FAILED(m_pDevice->CheckFeatureSupport(D3D12_FEATURE_CROSS_NODE, &m_dCrossNode, sizeof(m_dCrossNode))))
+    {
+        m_dCrossNode.SharingTier = D3D12_CROSS_NODE_SHARING_TIER_NOT_SUPPORTED;
+        m_dCrossNode.AtomicShaderInstructions = false;
+    }
+
+    if (FAILED(m_pDevice->CheckFeatureSupport(D3D12_FEATURE_D3D12_OPTIONS5, &m_dOptions5, sizeof(m_dOptions5))))
+    {
+        m_dOptions5.SRVOnlyTiledResourceTier3 = false;
+        m_dOptions5.RenderPassesTier = D3D12_RENDER_PASS_TIER_0;
+        m_dOptions5.RaytracingTier = D3D12_RAYTRACING_TIER_NOT_SUPPORTED;
+    }
+
+    if (FAILED(m_pDevice->CheckFeatureSupport(D3D12_FEATURE_DISPLAYABLE, &m_dDisplayable, sizeof(m_dDisplayable))))
+    {
+        m_dDisplayable.DisplayableTexture = false;
+        m_dDisplayable.SharedResourceCompatibilityTier = D3D12_SHARED_RESOURCE_COMPATIBILITY_TIER_0;
+    }
+
+    if (FAILED(m_pDevice->CheckFeatureSupport(D3D12_FEATURE_D3D12_OPTIONS6, &m_dOptions6, sizeof(m_dOptions6))))
+    {
+        m_dOptions6.AdditionalShadingRatesSupported = false;
+        m_dOptions6.PerPrimitiveShadingRateSupportedWithViewportIndexing = false;
+        m_dOptions6.VariableShadingRateTier = D3D12_VARIABLE_SHADING_RATE_TIER_NOT_SUPPORTED;
+        m_dOptions6.ShadingRateImageTileSize = 0;
+        m_dOptions6.BackgroundProcessingSupported = false;
+    }
+
+    if (FAILED(m_pDevice->CheckFeatureSupport(D3D12_FEATURE_D3D12_OPTIONS7, &m_dOptions7, sizeof(m_dOptions7))))
+    {
+        m_dOptions7.MeshShaderTier = D3D12_MESH_SHADER_TIER_NOT_SUPPORTED;
+        m_dOptions7.SamplerFeedbackTier = D3D12_SAMPLER_FEEDBACK_TIER_NOT_SUPPORTED;
+    }
+
+    if (FAILED(m_pDevice->CheckFeatureSupport(D3D12_FEATURE_D3D12_OPTIONS8, &m_dOptions8, sizeof(m_dOptions8))))
+    {
+        m_dOptions8.UnalignedBlockTexturesSupported = false;
+    }
+
+    if (FAILED(m_pDevice->CheckFeatureSupport(D3D12_FEATURE_D3D12_OPTIONS9, &m_dOptions9, sizeof(m_dOptions9))))
+    {
+        m_dOptions9.MeshShaderPipelineStatsSupported = false;
+        m_dOptions9.MeshShaderSupportsFullRangeRenderTargetArrayIndex = false;
+        m_dOptions9.AtomicInt64OnGroupSharedSupported = false;
+        m_dOptions9.AtomicInt64OnTypedResourceSupported = false;
+        m_dOptions9.DerivativesInMeshAndAmplificationShadersSupported = false;
+        m_dOptions9.WaveMMATier = D3D12_WAVE_MMA_TIER_NOT_SUPPORTED;
+    }
+
+    if (FAILED(m_pDevice->CheckFeatureSupport(D3D12_FEATURE_D3D12_OPTIONS10, &m_dOptions10, sizeof(m_dOptions10))))
+    {
+        m_dOptions10.MeshShaderPerPrimitiveShadingRateSupported = false;
+        m_dOptions10.VariableRateShadingSumCombinerSupported = false;
+    }
+
+    if (FAILED(m_pDevice->CheckFeatureSupport(D3D12_FEATURE_D3D12_OPTIONS11, &m_dOptions11, sizeof(m_dOptions11))))
+    {
+        m_dOptions11.AtomicInt64OnDescriptorHeapResourceSupported = false;
+    }
+
+    if (FAILED(m_pDevice->CheckFeatureSupport(D3D12_FEATURE_D3D12_OPTIONS12, &m_dOptions12, sizeof(m_dOptions12))))
+    {
+        m_dOptions12.MSPrimitivesPipelineStatisticIncludesCulledPrimitives = D3D12_TRI_STATE::D3D12_TRI_STATE_UNKNOWN;
+        m_dOptions12.EnhancedBarriersSupported = false;
+        m_dOptions12.RelaxedFormatCastingSupported = false;
+    }
+
+    if (FAILED(m_pDevice->CheckFeatureSupport(D3D12_FEATURE_D3D12_OPTIONS13, &m_dOptions13, sizeof(m_dOptions13))))
+    {
+        m_dOptions13.UnrestrictedBufferTextureCopyPitchSupported = false;
+        m_dOptions13.UnrestrictedVertexElementAlignmentSupported = false;
+        m_dOptions13.InvertedViewportHeightFlipsYSupported = false;
+        m_dOptions13.InvertedViewportDepthFlipsZSupported = false;
+        m_dOptions13.TextureCopyBetweenDimensionsSupported = false;
+        m_dOptions13.AlphaBlendFactorSupported = false;
+    }
+
+    if (FAILED(m_pDevice->CheckFeatureSupport(D3D12_FEATURE_D3D12_OPTIONS14, &m_dOptions14, sizeof(m_dOptions14))))
+    {
+        m_dOptions14.AdvancedTextureOpsSupported = false;
+        m_dOptions14.WriteableMSAATexturesSupported = false;
+        m_dOptions14.IndependentFrontAndBackStencilRefMaskSupported = false;
+    }
+
+    if (FAILED(m_pDevice->CheckFeatureSupport(D3D12_FEATURE_D3D12_OPTIONS15, &m_dOptions15, sizeof(m_dOptions15))))
+    {
+        m_dOptions15.TriangleFanSupported = false;
+        m_dOptions15.DynamicIndexBufferStripCutSupported = false;
+    }
+
+    // Initialize per-node feature support data structures
+    const UINT uNodeCount = m_pDevice->GetNodeCount();
+    m_dProtectedResourceSessionSupport.resize(uNodeCount);
+    m_dArchitecture1.resize(uNodeCount);
+    m_dSerialization.resize(uNodeCount);
+    m_dProtectedResourceSessionTypeCount.resize(uNodeCount);
+    m_dProtectedResourceSessionTypes.resize(uNodeCount);
+    for (UINT NodeIndex = 0; NodeIndex < uNodeCount; NodeIndex++)
+    {
+        m_dProtectedResourceSessionSupport[NodeIndex].NodeIndex = NodeIndex;
+        if (FAILED(m_pDevice->CheckFeatureSupport(D3D12_FEATURE_PROTECTED_RESOURCE_SESSION_SUPPORT, &m_dProtectedResourceSessionSupport[NodeIndex], sizeof(m_dProtectedResourceSessionSupport[NodeIndex]))))
+        {
+            m_dProtectedResourceSessionSupport[NodeIndex].Support = D3D12_PROTECTED_RESOURCE_SESSION_SUPPORT_FLAG_NONE;
+        }
+
+        m_dArchitecture1[NodeIndex].NodeIndex = NodeIndex;
+        if (FAILED(m_pDevice->CheckFeatureSupport(D3D12_FEATURE_ARCHITECTURE1, &m_dArchitecture1[NodeIndex], sizeof(m_dArchitecture1[NodeIndex]))))
+        {
+            D3D12_FEATURE_DATA_ARCHITECTURE dArchLocal = {};
+            dArchLocal.NodeIndex = NodeIndex;
+            if (FAILED(m_pDevice->CheckFeatureSupport(D3D12_FEATURE_ARCHITECTURE, &dArchLocal, sizeof(dArchLocal))))
+            {
+                dArchLocal.TileBasedRenderer = false;
+                dArchLocal.UMA = false;
+                dArchLocal.CacheCoherentUMA = false;
+            }
+
+            m_dArchitecture1[NodeIndex].TileBasedRenderer = dArchLocal.TileBasedRenderer;
+            m_dArchitecture1[NodeIndex].UMA = dArchLocal.UMA;
+            m_dArchitecture1[NodeIndex].CacheCoherentUMA = dArchLocal.CacheCoherentUMA;
+            m_dArchitecture1[NodeIndex].IsolatedMMU = false;
+        }
+
+        m_dSerialization[NodeIndex].NodeIndex = NodeIndex;
+        if (FAILED(m_pDevice->CheckFeatureSupport(D3D12_FEATURE_SERIALIZATION, &m_dSerialization[NodeIndex], sizeof(m_dSerialization[NodeIndex]))))
+        {
+            m_dSerialization[NodeIndex].HeapSerializationTier = D3D12_HEAP_SERIALIZATION_TIER_0;
+        }
+
+        m_dProtectedResourceSessionTypeCount[NodeIndex].NodeIndex = NodeIndex;
+        if (FAILED(m_pDevice->CheckFeatureSupport(D3D12_FEATURE_PROTECTED_RESOURCE_SESSION_TYPE_COUNT, &m_dProtectedResourceSessionTypeCount[NodeIndex], sizeof(m_dProtectedResourceSessionTypeCount[NodeIndex]))))
+        {
+            m_dProtectedResourceSessionTypeCount[NodeIndex].Count = 0;
+        }
+
+        // Special procedure to initialize local protected resource session types structs
+        // Must wait until session type count initialized
+        QueryProtectedResourceSessionTypes(NodeIndex, m_dProtectedResourceSessionTypeCount[NodeIndex].Count);
+    }
+
+    // Initialize features that requires highest version check
+    if (FAILED(m_hStatus = QueryHighestShaderModel()))
+    {
+        return m_hStatus;
+    }
+
+    if (FAILED(m_hStatus = QueryHighestRootSignatureVersion()))
+    {
+        return m_hStatus;
+    }
+
+    // Initialize Feature Levels data
+    if (FAILED(m_hStatus = QueryHighestFeatureLevel()))
+    {
+        return m_hStatus;
+    }
+
+    return m_hStatus;
+}
+
+// 0: D3D12_OPTIONS
+FEATURE_SUPPORT_GET(BOOL, m_dOptions, DoublePrecisionFloatShaderOps);
+FEATURE_SUPPORT_GET(BOOL, m_dOptions, OutputMergerLogicOp);
+FEATURE_SUPPORT_GET(D3D12_SHADER_MIN_PRECISION_SUPPORT, m_dOptions, MinPrecisionSupport);
+FEATURE_SUPPORT_GET(D3D12_TILED_RESOURCES_TIER, m_dOptions, TiledResourcesTier);
+FEATURE_SUPPORT_GET(D3D12_RESOURCE_BINDING_TIER, m_dOptions, ResourceBindingTier);
+FEATURE_SUPPORT_GET(BOOL, m_dOptions, PSSpecifiedStencilRefSupported);
+FEATURE_SUPPORT_GET(BOOL, m_dOptions, TypedUAVLoadAdditionalFormats);
+FEATURE_SUPPORT_GET(BOOL, m_dOptions, ROVsSupported);
+FEATURE_SUPPORT_GET(D3D12_CONSERVATIVE_RASTERIZATION_TIER, m_dOptions, ConservativeRasterizationTier);
+FEATURE_SUPPORT_GET(BOOL, m_dOptions, StandardSwizzle64KBSupported);
+FEATURE_SUPPORT_GET(BOOL, m_dOptions, CrossAdapterRowMajorTextureSupported);
+FEATURE_SUPPORT_GET(BOOL, m_dOptions, VPAndRTArrayIndexFromAnyShaderFeedingRasterizerSupportedWithoutGSEmulation);
+FEATURE_SUPPORT_GET(D3D12_RESOURCE_HEAP_TIER, m_dOptions, ResourceHeapTier);
+
+// Special procedure for handling caps that is also part of other features
+inline D3D12_CROSS_NODE_SHARING_TIER CD3DX12FeatureSupport::CrossNodeSharingTier() const noexcept
+{
+    if (m_dCrossNode.SharingTier > D3D12_CROSS_NODE_SHARING_TIER_NOT_SUPPORTED)
+    {
+        return m_dCrossNode.SharingTier;
+    }
+    else
+    {
+        return m_dOptions.CrossNodeSharingTier;
+    }
+}
+
+inline UINT CD3DX12FeatureSupport::MaxGPUVirtualAddressBitsPerResource() const noexcept
+{
+    if (m_dOptions.MaxGPUVirtualAddressBitsPerResource > 0)
+    {
+        return m_dOptions.MaxGPUVirtualAddressBitsPerResource;
+    }
+    else
+    {
+        return m_dGPUVASupport.MaxGPUVirtualAddressBitsPerResource;
+    }
+}
+
+// 1: Architecture
+// Combined with Architecture1
+
+// 2: Feature Levels
+// Simply returns the highest supported feature level
+inline D3D_FEATURE_LEVEL CD3DX12FeatureSupport::MaxSupportedFeatureLevel() const noexcept
+{
+    return m_eMaxFeatureLevel;
+}
+
+// 3: Feature Format Support
+inline HRESULT CD3DX12FeatureSupport::FormatSupport(DXGI_FORMAT Format, D3D12_FORMAT_SUPPORT1& Support1, D3D12_FORMAT_SUPPORT2& Support2) const
+{
+    D3D12_FEATURE_DATA_FORMAT_SUPPORT dFormatSupport;
+    dFormatSupport.Format = Format;
+
+    // It is possible that the function call returns an error
+    HRESULT result = m_pDevice->CheckFeatureSupport(D3D12_FEATURE_FORMAT_SUPPORT, &dFormatSupport, sizeof(D3D12_FEATURE_DATA_FORMAT_SUPPORT));
+
+    Support1 = dFormatSupport.Support1;
+    Support2 = dFormatSupport.Support2; // Two outputs. Probably better just to take in the struct as an argument?
+
+    return result;
+}
+
+// 4: Multisample Quality Levels
+inline HRESULT CD3DX12FeatureSupport::MultisampleQualityLevels(DXGI_FORMAT Format, UINT SampleCount, D3D12_MULTISAMPLE_QUALITY_LEVEL_FLAGS Flags, UINT& NumQualityLevels) const
+{
+    D3D12_FEATURE_DATA_MULTISAMPLE_QUALITY_LEVELS dMultisampleQualityLevels;
+    dMultisampleQualityLevels.Format = Format;
+    dMultisampleQualityLevels.SampleCount = SampleCount;
+    dMultisampleQualityLevels.Flags = Flags;
+
+    HRESULT result = m_pDevice->CheckFeatureSupport(D3D12_FEATURE_MULTISAMPLE_QUALITY_LEVELS, &dMultisampleQualityLevels, sizeof(D3D12_FEATURE_DATA_MULTISAMPLE_QUALITY_LEVELS));
+
+    if (SUCCEEDED(result))
+    {
+        NumQualityLevels = dMultisampleQualityLevels.NumQualityLevels;
+    }
+    else
+    {
+        NumQualityLevels = 0;
+    }
+
+    return result;
+}
+
+// 5: Format Info
+inline HRESULT CD3DX12FeatureSupport::FormatInfo(DXGI_FORMAT Format, UINT8& PlaneCount) const
+{
+    D3D12_FEATURE_DATA_FORMAT_INFO dFormatInfo;
+    dFormatInfo.Format = Format;
+
+    HRESULT result = m_pDevice->CheckFeatureSupport(D3D12_FEATURE_FORMAT_INFO, &dFormatInfo, sizeof(D3D12_FEATURE_DATA_FORMAT_INFO));
+    if (FAILED(result))
+    {
+        PlaneCount = 0;
+    }
+    else
+    {
+        PlaneCount = dFormatInfo.PlaneCount;
+    }
+    return result;
+}
+
+// 6: GPU Virtual Address Support
+// MaxGPUVirtualAddressBitsPerResource handled in D3D12Options
+FEATURE_SUPPORT_GET(UINT, m_dGPUVASupport, MaxGPUVirtualAddressBitsPerProcess);
+
+// 7: Shader Model
+inline D3D_SHADER_MODEL CD3DX12FeatureSupport::HighestShaderModel() const noexcept
+{
+    return m_dShaderModel.HighestShaderModel;
+}
+
+// 8: D3D12 Options1
+FEATURE_SUPPORT_GET(BOOL, m_dOptions1, WaveOps);
+FEATURE_SUPPORT_GET(UINT, m_dOptions1, WaveLaneCountMin);
+FEATURE_SUPPORT_GET(UINT, m_dOptions1, WaveLaneCountMax);
+FEATURE_SUPPORT_GET(UINT, m_dOptions1, TotalLaneCount);
+FEATURE_SUPPORT_GET(BOOL, m_dOptions1, ExpandedComputeResourceStates);
+FEATURE_SUPPORT_GET(BOOL, m_dOptions1, Int64ShaderOps);
+
+// 10: Protected Resource Session Support
+inline D3D12_PROTECTED_RESOURCE_SESSION_SUPPORT_FLAGS CD3DX12FeatureSupport::ProtectedResourceSessionSupport(UINT NodeIndex) const
+{
+    return m_dProtectedResourceSessionSupport[NodeIndex].Support;
+}
+
+// 12: Root Signature
+inline D3D_ROOT_SIGNATURE_VERSION CD3DX12FeatureSupport::HighestRootSignatureVersion() const noexcept
+{
+    return m_dRootSignature.HighestVersion;
+}
+
+// 16: Architecture1
+// Same data fields can be queried from m_dArchitecture
+FEATURE_SUPPORT_GET_NODE_INDEXED(BOOL, m_dArchitecture1, TileBasedRenderer);
+FEATURE_SUPPORT_GET_NODE_INDEXED(BOOL, m_dArchitecture1, UMA);
+FEATURE_SUPPORT_GET_NODE_INDEXED(BOOL, m_dArchitecture1, CacheCoherentUMA);
+FEATURE_SUPPORT_GET_NODE_INDEXED(BOOL, m_dArchitecture1, IsolatedMMU);
+
+// 18: D3D12 Options2
+FEATURE_SUPPORT_GET(BOOL, m_dOptions2, DepthBoundsTestSupported);
+FEATURE_SUPPORT_GET(D3D12_PROGRAMMABLE_SAMPLE_POSITIONS_TIER, m_dOptions2, ProgrammableSamplePositionsTier);
+
+// 19: Shader Cache
+FEATURE_SUPPORT_GET_NAME(D3D12_SHADER_CACHE_SUPPORT_FLAGS, m_dShaderCache, SupportFlags, ShaderCacheSupportFlags);
+
+// 20: Command Queue Priority
+inline BOOL CD3DX12FeatureSupport::CommandQueuePrioritySupported(D3D12_COMMAND_LIST_TYPE CommandListType, UINT Priority)
+{
+    m_dCommandQueuePriority.CommandListType = CommandListType;
+    m_dCommandQueuePriority.Priority = Priority;
+
+    if (FAILED(m_pDevice->CheckFeatureSupport(D3D12_FEATURE_COMMAND_QUEUE_PRIORITY, &m_dCommandQueuePriority, sizeof(D3D12_FEATURE_DATA_COMMAND_QUEUE_PRIORITY))))
+    {
+        return false;
+    }
+
+    return m_dCommandQueuePriority.PriorityForTypeIsSupported;
+}
+
+// 21: D3D12 Options3
+FEATURE_SUPPORT_GET(BOOL, m_dOptions3, CopyQueueTimestampQueriesSupported);
+FEATURE_SUPPORT_GET(BOOL, m_dOptions3, CastingFullyTypedFormatSupported);
+FEATURE_SUPPORT_GET(D3D12_COMMAND_LIST_SUPPORT_FLAGS, m_dOptions3, WriteBufferImmediateSupportFlags);
+FEATURE_SUPPORT_GET(D3D12_VIEW_INSTANCING_TIER, m_dOptions3, ViewInstancingTier);
+FEATURE_SUPPORT_GET(BOOL, m_dOptions3, BarycentricsSupported);
+
+// 22: Existing Heaps
+FEATURE_SUPPORT_GET_NAME(BOOL, m_dExistingHeaps, Supported, ExistingHeapsSupported);
+
+// 23: D3D12 Options4
+FEATURE_SUPPORT_GET(BOOL, m_dOptions4, MSAA64KBAlignedTextureSupported);
+FEATURE_SUPPORT_GET(D3D12_SHARED_RESOURCE_COMPATIBILITY_TIER, m_dOptions4, SharedResourceCompatibilityTier);
+FEATURE_SUPPORT_GET(BOOL, m_dOptions4, Native16BitShaderOpsSupported);
+
+// 24: Serialization
+FEATURE_SUPPORT_GET_NODE_INDEXED(D3D12_HEAP_SERIALIZATION_TIER, m_dSerialization, HeapSerializationTier);
+
+// 25: Cross Node
+// CrossNodeSharingTier handled in D3D12Options
+FEATURE_SUPPORT_GET_NAME(BOOL, m_dCrossNode, AtomicShaderInstructions, CrossNodeAtomicShaderInstructions);
+
+// 27: D3D12 Options5
+FEATURE_SUPPORT_GET(BOOL, m_dOptions5, SRVOnlyTiledResourceTier3);
+FEATURE_SUPPORT_GET(D3D12_RENDER_PASS_TIER, m_dOptions5, RenderPassesTier);
+FEATURE_SUPPORT_GET(D3D12_RAYTRACING_TIER, m_dOptions5, RaytracingTier);
+
+// 28: Displayable
+FEATURE_SUPPORT_GET(BOOL, m_dDisplayable, DisplayableTexture);
+// SharedResourceCompatibilityTier handled in D3D12Options4
+
+// 30: D3D12 Options6
+FEATURE_SUPPORT_GET(BOOL, m_dOptions6, AdditionalShadingRatesSupported);
+FEATURE_SUPPORT_GET(BOOL, m_dOptions6, PerPrimitiveShadingRateSupportedWithViewportIndexing);
+FEATURE_SUPPORT_GET(D3D12_VARIABLE_SHADING_RATE_TIER, m_dOptions6, VariableShadingRateTier);
+FEATURE_SUPPORT_GET(UINT, m_dOptions6, ShadingRateImageTileSize);
+FEATURE_SUPPORT_GET(BOOL, m_dOptions6, BackgroundProcessingSupported);
+
+// 31: Query Meta Command
+// Keep the original call routine
+inline HRESULT CD3DX12FeatureSupport::QueryMetaCommand(D3D12_FEATURE_DATA_QUERY_META_COMMAND& dQueryMetaCommand) const
+{
+    return m_pDevice->CheckFeatureSupport(D3D12_FEATURE_QUERY_META_COMMAND, &dQueryMetaCommand, sizeof(D3D12_FEATURE_DATA_QUERY_META_COMMAND));
+}
+
+// 32: D3D12 Options7
+FEATURE_SUPPORT_GET(D3D12_MESH_SHADER_TIER, m_dOptions7, MeshShaderTier);
+FEATURE_SUPPORT_GET(D3D12_SAMPLER_FEEDBACK_TIER, m_dOptions7, SamplerFeedbackTier);
+
+// 33: Protected Resource Session Type Count
+FEATURE_SUPPORT_GET_NODE_INDEXED_NAME(UINT, m_dProtectedResourceSessionTypeCount, Count, ProtectedResourceSessionTypeCount);
+
+// 34: Protected Resource Session Types
+FEATURE_SUPPORT_GET_NODE_INDEXED_NAME(std::vector<GUID>, m_dProtectedResourceSessionTypes, TypeVec, ProtectedResourceSessionTypes);
+
+// 36: Options8
+FEATURE_SUPPORT_GET(BOOL, m_dOptions8, UnalignedBlockTexturesSupported);
+
+// 37: Options9
+FEATURE_SUPPORT_GET(BOOL, m_dOptions9, MeshShaderPipelineStatsSupported);
+FEATURE_SUPPORT_GET(BOOL, m_dOptions9, MeshShaderSupportsFullRangeRenderTargetArrayIndex);
+FEATURE_SUPPORT_GET(BOOL, m_dOptions9, AtomicInt64OnTypedResourceSupported);
+FEATURE_SUPPORT_GET(BOOL, m_dOptions9, AtomicInt64OnGroupSharedSupported);
+FEATURE_SUPPORT_GET(BOOL, m_dOptions9, DerivativesInMeshAndAmplificationShadersSupported);
+FEATURE_SUPPORT_GET(D3D12_WAVE_MMA_TIER, m_dOptions9, WaveMMATier);
+
+// 39: Options10
+FEATURE_SUPPORT_GET(BOOL, m_dOptions10, VariableRateShadingSumCombinerSupported);
+FEATURE_SUPPORT_GET(BOOL, m_dOptions10, MeshShaderPerPrimitiveShadingRateSupported);
+
+// 40: Options11
+FEATURE_SUPPORT_GET(BOOL, m_dOptions11, AtomicInt64OnDescriptorHeapResourceSupported);
+
+// 41: Options12
+FEATURE_SUPPORT_GET(D3D12_TRI_STATE, m_dOptions12, MSPrimitivesPipelineStatisticIncludesCulledPrimitives);
+FEATURE_SUPPORT_GET(BOOL, m_dOptions12, EnhancedBarriersSupported);
+FEATURE_SUPPORT_GET(BOOL, m_dOptions12, RelaxedFormatCastingSupported);
+
+// 42: Options13
+FEATURE_SUPPORT_GET(BOOL, m_dOptions13, UnrestrictedBufferTextureCopyPitchSupported);
+FEATURE_SUPPORT_GET(BOOL, m_dOptions13, UnrestrictedVertexElementAlignmentSupported);
+FEATURE_SUPPORT_GET(BOOL, m_dOptions13, InvertedViewportHeightFlipsYSupported);
+FEATURE_SUPPORT_GET(BOOL, m_dOptions13, InvertedViewportDepthFlipsZSupported);
+FEATURE_SUPPORT_GET(BOOL, m_dOptions13, TextureCopyBetweenDimensionsSupported);
+FEATURE_SUPPORT_GET(BOOL, m_dOptions13, AlphaBlendFactorSupported);
+
+// 43: Options14
+FEATURE_SUPPORT_GET(BOOL, m_dOptions14, AdvancedTextureOpsSupported);
+FEATURE_SUPPORT_GET(BOOL, m_dOptions14, WriteableMSAATexturesSupported);
+FEATURE_SUPPORT_GET(BOOL, m_dOptions14, IndependentFrontAndBackStencilRefMaskSupported);
+
+// 44: Options15
+FEATURE_SUPPORT_GET(BOOL, m_dOptions15, TriangleFanSupported);
+FEATURE_SUPPORT_GET(BOOL, m_dOptions15, DynamicIndexBufferStripCutSupported);
+
+// Helper function to decide the highest shader model supported by the system
+// Stores the result in m_dShaderModel
+// Must be updated whenever a new shader model is added to the d3d12.h header
+inline HRESULT CD3DX12FeatureSupport::QueryHighestShaderModel()
+{
+    // Check support in descending order
+    HRESULT result;
+
+    const D3D_SHADER_MODEL allModelVersions[] =
+    {
+        D3D_SHADER_MODEL_6_8,
+        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
+    };
+    constexpr size_t numModelVersions = sizeof(allModelVersions) / sizeof(D3D_SHADER_MODEL);
+
+    for (size_t i = 0; i < numModelVersions; i++)
+    {
+        m_dShaderModel.HighestShaderModel = allModelVersions[i];
+        result = m_pDevice->CheckFeatureSupport(D3D12_FEATURE_SHADER_MODEL, &m_dShaderModel, sizeof(D3D12_FEATURE_DATA_SHADER_MODEL));
+        if (result != E_INVALIDARG)
+        {
+            // Indicates that the version is recognizable by the runtime and stored in the struct
+            // Also terminate on unexpected error code
+            if (FAILED(result))
+            {
+                m_dShaderModel.HighestShaderModel = static_cast<D3D_SHADER_MODEL>(0);
+            }
+            return result;
+        }
+    }
+
+    // Shader model may not be supported. Continue the rest initializations
+    m_dShaderModel.HighestShaderModel = static_cast<D3D_SHADER_MODEL>(0);
+    return S_OK;
+}
+
+// Helper function to decide the highest root signature supported
+// Must be updated whenever a new root signature version is added to the d3d12.h header
+inline HRESULT CD3DX12FeatureSupport::QueryHighestRootSignatureVersion()
+{
+    HRESULT result;
+
+    const D3D_ROOT_SIGNATURE_VERSION allRootSignatureVersions[] =
+    {
+        D3D_ROOT_SIGNATURE_VERSION_1_1,
+        D3D_ROOT_SIGNATURE_VERSION_1_0,
+        D3D_ROOT_SIGNATURE_VERSION_1,
+    };
+    constexpr size_t numRootSignatureVersions = sizeof(allRootSignatureVersions) / sizeof(D3D_ROOT_SIGNATURE_VERSION);
+
+    for (size_t i = 0; i < numRootSignatureVersions; i++)
+    {
+        m_dRootSignature.HighestVersion = allRootSignatureVersions[i];
+        result = m_pDevice->CheckFeatureSupport(D3D12_FEATURE_ROOT_SIGNATURE, &m_dRootSignature, sizeof(D3D12_FEATURE_DATA_ROOT_SIGNATURE));
+        if (result != E_INVALIDARG)
+        {
+            if (FAILED(result))
+            {
+                m_dRootSignature.HighestVersion = static_cast<D3D_ROOT_SIGNATURE_VERSION>(0);
+            }
+            // If succeeded, the highest version is already written into the member struct
+            return result;
+        }
+    }
+
+    // No version left. Set to invalid value and continue.
+    m_dRootSignature.HighestVersion = static_cast<D3D_ROOT_SIGNATURE_VERSION>(0);
+    return S_OK;
+}
+
+// Helper funcion to decide the highest feature level
+inline HRESULT CD3DX12FeatureSupport::QueryHighestFeatureLevel()
+{
+    HRESULT result;
+
+    // Check against a list of all feature levels present in d3dcommon.h
+    // Needs to be updated for future feature levels
+    const D3D_FEATURE_LEVEL allLevels[] =
+    {
+        D3D_FEATURE_LEVEL_12_2,
+        D3D_FEATURE_LEVEL_12_1,
+        D3D_FEATURE_LEVEL_12_0,
+        D3D_FEATURE_LEVEL_11_1,
+        D3D_FEATURE_LEVEL_11_0,
+        D3D_FEATURE_LEVEL_10_1,
+        D3D_FEATURE_LEVEL_10_0,
+        D3D_FEATURE_LEVEL_9_3,
+        D3D_FEATURE_LEVEL_9_2,
+        D3D_FEATURE_LEVEL_9_1,
+        D3D_FEATURE_LEVEL_1_0_CORE
+    };
+
+    D3D12_FEATURE_DATA_FEATURE_LEVELS dFeatureLevel;
+    dFeatureLevel.NumFeatureLevels = static_cast<UINT>(sizeof(allLevels) / sizeof(D3D_FEATURE_LEVEL));
+    dFeatureLevel.pFeatureLevelsRequested = allLevels;
+
+    result = m_pDevice->CheckFeatureSupport(D3D12_FEATURE_FEATURE_LEVELS, &dFeatureLevel, sizeof(D3D12_FEATURE_DATA_FEATURE_LEVELS));
+    if (SUCCEEDED(result))
+    {
+        m_eMaxFeatureLevel = dFeatureLevel.MaxSupportedFeatureLevel;
+    }
+    else
+    {
+        m_eMaxFeatureLevel = static_cast<D3D_FEATURE_LEVEL>(0);
+
+        if (result == DXGI_ERROR_UNSUPPORTED)
+        {
+            // Indicates that none supported. Continue initialization
+            result = S_OK;
+        }
+    }
+    return result;
+}
+
+// Helper function to initialize local protected resource session types structs
+inline HRESULT CD3DX12FeatureSupport::QueryProtectedResourceSessionTypes(UINT NodeIndex, UINT Count)
+{
+    auto& CurrentPRSTypes = m_dProtectedResourceSessionTypes[NodeIndex];
+    CurrentPRSTypes.NodeIndex = NodeIndex;
+    CurrentPRSTypes.Count = Count;
+    CurrentPRSTypes.TypeVec.resize(CurrentPRSTypes.Count);
+    CurrentPRSTypes.pTypes = CurrentPRSTypes.TypeVec.data();
+
+    HRESULT result = m_pDevice->CheckFeatureSupport(D3D12_FEATURE_PROTECTED_RESOURCE_SESSION_TYPES, &m_dProtectedResourceSessionTypes[NodeIndex], sizeof(D3D12_FEATURE_DATA_PROTECTED_RESOURCE_SESSION_TYPES));
+    if (FAILED(result))
+    {
+        // Resize TypeVec to empty
+        CurrentPRSTypes.TypeVec.clear();
+    }
+
+    return result;
+}
+
+#undef FEATURE_SUPPORT_GET
+#undef FEATURE_SUPPORT_GET_NAME
+#undef FEATURE_SUPPORT_GET_NODE_INDEXED
+#undef FEATURE_SUPPORT_GET_NODE_INDEXED_NAME
+
+// end CD3DX12FeatureSupport
+
+#endif // !D3DX12_NO_CHECK_FEATURE_SUPPORT_CLASS
+
+#undef D3DX12_COM_PTR
+#undef D3DX12_COM_PTR_GET
+#undef D3DX12_COM_PTR_ADDRESSOF
+
+#endif // defined( __cplusplus )
+
+#endif //__D3DX12_H__
+
diff --git a/thirdparty/directx_headers/dxcore.h b/thirdparty/directx_headers/dxcore.h
new file mode 100644
index 0000000000..4244eaa60f
--- /dev/null
+++ b/thirdparty/directx_headers/dxcore.h
@@ -0,0 +1,41 @@
+/************************************************************
+*                                                           *
+* Copyright (c) Microsoft Corporation.                      *
+* Licensed under the MIT license.                           *
+*                                                           *
+************************************************************/
+
+#ifndef _DXCOREEXTMODULE_H_
+#define _DXCOREEXTMODULE_H_
+
+#include <winapifamily.h>
+#include "dxcore_interface.h"
+
+#pragma region Application Family or OneCore Family
+#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP | WINAPI_PARTITION_SYSTEM)
+
+#if (_WIN32_WINNT >= _WIN32_WINNT_WIN10)
+
+STDAPI
+DXCoreCreateAdapterFactory(
+    REFIID riid,
+    _COM_Outptr_ void** ppvFactory
+);
+
+template <class T>
+HRESULT
+DXCoreCreateAdapterFactory(
+    _COM_Outptr_ T** ppvFactory
+)
+{
+    return DXCoreCreateAdapterFactory(IID_PPV_ARGS(ppvFactory));
+}
+
+#endif // (_WIN32_WINNT >= _WIN32_WINNT_WIN10)
+
+#endif /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP | WINAPI_PARTITION_SYSTEM) */
+#pragma endregion
+
+#endif // _DXCOREEXTMODULE_H_
+
+
diff --git a/thirdparty/directx_headers/dxcore_interface.h b/thirdparty/directx_headers/dxcore_interface.h
new file mode 100644
index 0000000000..b487fe13fb
--- /dev/null
+++ b/thirdparty/directx_headers/dxcore_interface.h
@@ -0,0 +1,316 @@
+//
+// DXCore Interface
+// Copyright (C) Microsoft Corporation.
+// Licensed under the MIT license.
+//
+
+#ifndef __dxcore_interface_h__
+#define __dxcore_interface_h__
+
+#ifndef COM_NO_WINDOWS_H
+#include "windows.h"
+#include "ole2.h"
+#endif /*COM_NO_WINDOWS_H*/
+
+#include <stdint.h>
+
+#ifdef __cplusplus
+
+#define _FACDXCORE    0x880
+#define MAKE_DXCORE_HRESULT( code )     MAKE_HRESULT( 1, _FACDXCORE, code )
+
+enum class DXCoreAdapterProperty : uint32_t
+{
+    InstanceLuid = 0,
+    DriverVersion = 1,
+    DriverDescription = 2,
+    HardwareID = 3, // Use HardwareIDParts instead, if available.
+    KmdModelVersion = 4,
+    ComputePreemptionGranularity = 5,
+    GraphicsPreemptionGranularity = 6,
+    DedicatedAdapterMemory = 7,
+    DedicatedSystemMemory = 8,
+    SharedSystemMemory = 9,
+    AcgCompatible = 10,
+    IsHardware = 11,
+    IsIntegrated = 12,
+    IsDetachable = 13,
+    HardwareIDParts = 14
+};
+
+enum class DXCoreAdapterState : uint32_t
+{
+    IsDriverUpdateInProgress = 0,
+    AdapterMemoryBudget = 1
+};
+
+enum class DXCoreSegmentGroup : uint32_t
+{
+    Local = 0,
+    NonLocal = 1
+};
+
+enum class DXCoreNotificationType : uint32_t
+{
+    AdapterListStale = 0,
+    AdapterNoLongerValid = 1,
+    AdapterBudgetChange = 2,
+    AdapterHardwareContentProtectionTeardown = 3
+};
+
+enum class DXCoreAdapterPreference : uint32_t
+{
+    Hardware = 0,
+    MinimumPower = 1,
+    HighPerformance = 2
+};
+
+struct DXCoreHardwareID
+{
+    uint32_t vendorID;
+    uint32_t deviceID;
+    uint32_t subSysID;
+    uint32_t revision;
+};
+
+struct DXCoreHardwareIDParts
+{
+    uint32_t vendorID;
+    uint32_t deviceID;
+    uint32_t subSystemID;
+    uint32_t subVendorID;
+    uint32_t revisionID;
+};
+
+struct DXCoreAdapterMemoryBudgetNodeSegmentGroup
+{
+    uint32_t nodeIndex;
+    DXCoreSegmentGroup segmentGroup;
+};
+
+struct DXCoreAdapterMemoryBudget
+{
+    uint64_t budget;
+    uint64_t currentUsage;
+    uint64_t availableForReservation;
+    uint64_t currentReservation;
+};
+
+typedef void (STDMETHODCALLTYPE *PFN_DXCORE_NOTIFICATION_CALLBACK)(
+    DXCoreNotificationType notificationType,
+    _In_ IUnknown *object,
+    _In_opt_ void *context);
+
+static_assert(sizeof(bool) == 1, "bool assumed as one byte");
+
+DEFINE_GUID(IID_IDXCoreAdapterFactory, 0x78ee5945, 0xc36e, 0x4b13, 0xa6, 0x69, 0x00, 0x5d, 0xd1, 0x1c, 0x0f, 0x06);
+DEFINE_GUID(IID_IDXCoreAdapterList, 0x526c7776, 0x40e9, 0x459b, 0xb7, 0x11, 0xf3, 0x2a, 0xd7, 0x6d, 0xfc, 0x28);
+DEFINE_GUID(IID_IDXCoreAdapter, 0xf0db4c7f, 0xfe5a, 0x42a2, 0xbd, 0x62, 0xf2, 0xa6, 0xcf, 0x6f, 0xc8, 0x3e);
+DEFINE_GUID(DXCORE_ADAPTER_ATTRIBUTE_D3D11_GRAPHICS, 0x8c47866b, 0x7583, 0x450d, 0xf0, 0xf0, 0x6b, 0xad, 0xa8, 0x95, 0xaf, 0x4b);
+DEFINE_GUID(DXCORE_ADAPTER_ATTRIBUTE_D3D12_GRAPHICS, 0x0c9ece4d, 0x2f6e, 0x4f01, 0x8c, 0x96, 0xe8, 0x9e, 0x33, 0x1b, 0x47, 0xb1);
+DEFINE_GUID(DXCORE_ADAPTER_ATTRIBUTE_D3D12_CORE_COMPUTE, 0x248e2800, 0xa793, 0x4724, 0xab, 0xaa, 0x23, 0xa6, 0xde, 0x1b, 0xe0, 0x90);
+
+/* interface IDXCoreAdapter */
+MIDL_INTERFACE("f0db4c7f-fe5a-42a2-bd62-f2a6cf6fc83e")
+IDXCoreAdapter : public IUnknown
+{
+public:
+    virtual bool STDMETHODCALLTYPE IsValid() = 0;
+
+    virtual bool STDMETHODCALLTYPE IsAttributeSupported( 
+        REFGUID attributeGUID) = 0;
+
+    virtual bool STDMETHODCALLTYPE IsPropertySupported( 
+        DXCoreAdapterProperty property) = 0;
+
+    virtual HRESULT STDMETHODCALLTYPE GetProperty( 
+        DXCoreAdapterProperty property,
+        size_t bufferSize,
+        _Out_writes_bytes_(bufferSize)  void *propertyData) = 0;
+
+    template <class T>
+    HRESULT GetProperty( 
+        DXCoreAdapterProperty property,
+        _Out_writes_bytes_(sizeof(T))  T *propertyData)
+    {
+        return GetProperty(property,
+                           sizeof(T),
+                           (void*)propertyData);
+    }
+
+    virtual HRESULT STDMETHODCALLTYPE GetPropertySize( 
+        DXCoreAdapterProperty property,
+        _Out_ size_t *bufferSize) = 0;
+
+    virtual bool STDMETHODCALLTYPE IsQueryStateSupported( 
+        DXCoreAdapterState property) = 0;
+
+    virtual HRESULT STDMETHODCALLTYPE QueryState( 
+        DXCoreAdapterState state,
+        size_t inputStateDetailsSize,
+        _In_reads_bytes_opt_(inputStateDetailsSize) const void *inputStateDetails,
+        size_t outputBufferSize,
+        _Out_writes_bytes_(outputBufferSize) void *outputBuffer) = 0;
+
+    template <class T1, class T2>
+    HRESULT QueryState( 
+        DXCoreAdapterState state,
+        _In_reads_bytes_opt_(sizeof(T1)) const T1 *inputStateDetails,
+        _Out_writes_bytes_(sizeof(T2)) T2 *outputBuffer)
+    {
+        return QueryState(state,
+                          sizeof(T1),
+                          (const void*)inputStateDetails,
+                          sizeof(T2),
+                          (void*)outputBuffer);
+    }
+
+    template <class T>
+    HRESULT QueryState( 
+        DXCoreAdapterState state,
+        _Out_writes_bytes_(sizeof(T)) T *outputBuffer)
+    {
+        return QueryState(state,
+                          0,
+                          nullptr,
+                          sizeof(T),
+                          (void*)outputBuffer);
+    }
+
+    virtual bool STDMETHODCALLTYPE IsSetStateSupported( 
+        DXCoreAdapterState property) = 0;
+
+    virtual HRESULT STDMETHODCALLTYPE SetState( 
+        DXCoreAdapterState state,
+        size_t inputStateDetailsSize,
+        _In_reads_bytes_opt_(inputStateDetailsSize) const void *inputStateDetails,
+        size_t inputDataSize,
+        _In_reads_bytes_(inputDataSize) const void *inputData) = 0;
+
+    template <class T1, class T2>
+    HRESULT SetState( 
+        DXCoreAdapterState state,
+        const T1 *inputStateDetails,
+        const T2 *inputData)
+    {
+        return SetState(state,
+                        sizeof(T1),
+                        (const void*)inputStateDetails,
+                        sizeof(T2),
+                        (const void*)inputData);
+    }
+
+    virtual HRESULT STDMETHODCALLTYPE GetFactory(
+        REFIID riid,
+        _COM_Outptr_ void** ppvFactory
+    ) = 0;
+
+    template <class T>
+    HRESULT GetFactory(
+        _COM_Outptr_ T** ppvFactory
+    )
+    {
+        return GetFactory(IID_PPV_ARGS(ppvFactory));
+    }
+};
+
+/* interface IDXCoreAdapterList */
+MIDL_INTERFACE("526c7776-40e9-459b-b711-f32ad76dfc28")
+IDXCoreAdapterList : public IUnknown
+{
+public:
+    virtual HRESULT STDMETHODCALLTYPE GetAdapter( 
+        uint32_t index,
+        REFIID riid,
+        _COM_Outptr_ void **ppvAdapter) = 0;
+
+    template<class T>
+    HRESULT STDMETHODCALLTYPE GetAdapter( 
+        uint32_t index,
+        _COM_Outptr_ T **ppvAdapter)
+    {
+        return GetAdapter(index,
+                          IID_PPV_ARGS(ppvAdapter));
+    }
+
+    virtual uint32_t STDMETHODCALLTYPE GetAdapterCount() = 0;
+
+    virtual bool STDMETHODCALLTYPE IsStale() = 0;
+
+    virtual HRESULT STDMETHODCALLTYPE GetFactory(
+        REFIID riid,
+        _COM_Outptr_ void** ppvFactory
+    ) = 0;
+
+    template <class T>
+    HRESULT GetFactory(
+        _COM_Outptr_ T** ppvFactory
+    )
+    {
+        return GetFactory(IID_PPV_ARGS(ppvFactory));
+    }
+
+    virtual HRESULT STDMETHODCALLTYPE Sort(
+        uint32_t numPreferences,
+        _In_reads_(numPreferences) const DXCoreAdapterPreference* preferences) = 0;
+
+    virtual bool STDMETHODCALLTYPE IsAdapterPreferenceSupported( 
+        DXCoreAdapterPreference preference) = 0;
+};
+
+/* interface IDXCoreAdapterFactory */
+MIDL_INTERFACE("78ee5945-c36e-4b13-a669-005dd11c0f06")
+IDXCoreAdapterFactory : public IUnknown
+{
+public:
+
+    virtual HRESULT STDMETHODCALLTYPE CreateAdapterList( 
+        uint32_t numAttributes,
+        _In_reads_(numAttributes) const GUID *filterAttributes,
+        REFIID riid,
+        _COM_Outptr_ void **ppvAdapterList) = 0;
+
+    template<class T>
+    HRESULT STDMETHODCALLTYPE CreateAdapterList( 
+        uint32_t numAttributes,
+        _In_reads_(numAttributes) const GUID *filterAttributes,
+        _COM_Outptr_ T **ppvAdapterList)
+    {
+        return CreateAdapterList(numAttributes,
+                                 filterAttributes,
+                                 IID_PPV_ARGS(ppvAdapterList));
+    }
+
+    virtual HRESULT STDMETHODCALLTYPE GetAdapterByLuid( 
+        const LUID &adapterLUID,
+        REFIID riid,
+        _COM_Outptr_ void **ppvAdapter) = 0;
+
+    template<class T>
+    HRESULT STDMETHODCALLTYPE GetAdapterByLuid( 
+        const LUID &adapterLUID,
+        _COM_Outptr_ T **ppvAdapter)
+    {
+        return GetAdapterByLuid(adapterLUID,
+                                IID_PPV_ARGS(ppvAdapter));
+    }
+
+    virtual bool STDMETHODCALLTYPE IsNotificationTypeSupported( 
+        DXCoreNotificationType notificationType) = 0;
+
+    virtual HRESULT STDMETHODCALLTYPE RegisterEventNotification( 
+        _In_ IUnknown *dxCoreObject,
+        DXCoreNotificationType notificationType,
+        _In_ PFN_DXCORE_NOTIFICATION_CALLBACK callbackFunction,
+        _In_opt_ void *callbackContext,
+        _Out_ uint32_t *eventCookie) = 0;
+
+    virtual HRESULT STDMETHODCALLTYPE UnregisterEventNotification( 
+        uint32_t eventCookie) = 0;
+};
+
+#endif // __cplusplus
+
+#endif // __dxcore_interface_h__
+
+
diff --git a/thirdparty/directx_headers/dxgicommon.h b/thirdparty/directx_headers/dxgicommon.h
new file mode 100644
index 0000000000..f83aa01e61
--- /dev/null
+++ b/thirdparty/directx_headers/dxgicommon.h
@@ -0,0 +1,57 @@
+//
+//    Copyright (C) Microsoft Corporation.
+//    Licensed under the MIT license
+//
+
+#ifndef __dxgicommon_h__
+#define __dxgicommon_h__
+
+
+typedef struct DXGI_RATIONAL
+{
+    UINT Numerator;
+    UINT Denominator;
+} DXGI_RATIONAL;
+
+// The following values are used with DXGI_SAMPLE_DESC::Quality:
+#define DXGI_STANDARD_MULTISAMPLE_QUALITY_PATTERN 0xffffffff
+#define DXGI_CENTER_MULTISAMPLE_QUALITY_PATTERN 0xfffffffe
+
+typedef struct DXGI_SAMPLE_DESC
+{
+    UINT Count;
+    UINT Quality;
+} DXGI_SAMPLE_DESC;
+
+typedef enum DXGI_COLOR_SPACE_TYPE
+{
+    DXGI_COLOR_SPACE_RGB_FULL_G22_NONE_P709             = 0,
+    DXGI_COLOR_SPACE_RGB_FULL_G10_NONE_P709             = 1,
+    DXGI_COLOR_SPACE_RGB_STUDIO_G22_NONE_P709           = 2,
+    DXGI_COLOR_SPACE_RGB_STUDIO_G22_NONE_P2020          = 3,
+    DXGI_COLOR_SPACE_RESERVED                           = 4,
+    DXGI_COLOR_SPACE_YCBCR_FULL_G22_NONE_P709_X601      = 5,
+    DXGI_COLOR_SPACE_YCBCR_STUDIO_G22_LEFT_P601         = 6,
+    DXGI_COLOR_SPACE_YCBCR_FULL_G22_LEFT_P601           = 7,
+    DXGI_COLOR_SPACE_YCBCR_STUDIO_G22_LEFT_P709         = 8,
+    DXGI_COLOR_SPACE_YCBCR_FULL_G22_LEFT_P709           = 9,
+    DXGI_COLOR_SPACE_YCBCR_STUDIO_G22_LEFT_P2020        = 10,
+    DXGI_COLOR_SPACE_YCBCR_FULL_G22_LEFT_P2020          = 11,
+    DXGI_COLOR_SPACE_RGB_FULL_G2084_NONE_P2020          = 12,
+    DXGI_COLOR_SPACE_YCBCR_STUDIO_G2084_LEFT_P2020      = 13,
+    DXGI_COLOR_SPACE_RGB_STUDIO_G2084_NONE_P2020        = 14,
+    DXGI_COLOR_SPACE_YCBCR_STUDIO_G22_TOPLEFT_P2020     = 15,
+    DXGI_COLOR_SPACE_YCBCR_STUDIO_G2084_TOPLEFT_P2020   = 16,
+    DXGI_COLOR_SPACE_RGB_FULL_G22_NONE_P2020            = 17,
+    DXGI_COLOR_SPACE_YCBCR_STUDIO_GHLG_TOPLEFT_P2020    = 18,
+    DXGI_COLOR_SPACE_YCBCR_FULL_GHLG_TOPLEFT_P2020      = 19,
+    DXGI_COLOR_SPACE_RGB_STUDIO_G24_NONE_P709           = 20,
+    DXGI_COLOR_SPACE_RGB_STUDIO_G24_NONE_P2020          = 21,
+    DXGI_COLOR_SPACE_YCBCR_STUDIO_G24_LEFT_P709         = 22,
+    DXGI_COLOR_SPACE_YCBCR_STUDIO_G24_LEFT_P2020        = 23,
+    DXGI_COLOR_SPACE_YCBCR_STUDIO_G24_TOPLEFT_P2020     = 24,
+    DXGI_COLOR_SPACE_CUSTOM                             = 0xFFFFFFFF
+} DXGI_COLOR_SPACE_TYPE;
+
+#endif // __dxgicommon_h__
+
diff --git a/thirdparty/directx_headers/dxgiformat.h b/thirdparty/directx_headers/dxgiformat.h
new file mode 100644
index 0000000000..52aae1b2be
--- /dev/null
+++ b/thirdparty/directx_headers/dxgiformat.h
@@ -0,0 +1,142 @@
+//
+//    Copyright (C) Microsoft Corporation.
+//    Licensed under the MIT license
+//
+
+#ifndef __dxgiformat_h__
+#define __dxgiformat_h__
+
+#define DXGI_FORMAT_DEFINED 1
+
+typedef enum DXGI_FORMAT
+{
+    DXGI_FORMAT_UNKNOWN	                                = 0,
+    DXGI_FORMAT_R32G32B32A32_TYPELESS                   = 1,
+    DXGI_FORMAT_R32G32B32A32_FLOAT                      = 2,
+    DXGI_FORMAT_R32G32B32A32_UINT                       = 3,
+    DXGI_FORMAT_R32G32B32A32_SINT                       = 4,
+    DXGI_FORMAT_R32G32B32_TYPELESS                      = 5,
+    DXGI_FORMAT_R32G32B32_FLOAT                         = 6,
+    DXGI_FORMAT_R32G32B32_UINT                          = 7,
+    DXGI_FORMAT_R32G32B32_SINT                          = 8,
+    DXGI_FORMAT_R16G16B16A16_TYPELESS                   = 9,
+    DXGI_FORMAT_R16G16B16A16_FLOAT                      = 10,
+    DXGI_FORMAT_R16G16B16A16_UNORM                      = 11,
+    DXGI_FORMAT_R16G16B16A16_UINT                       = 12,
+    DXGI_FORMAT_R16G16B16A16_SNORM                      = 13,
+    DXGI_FORMAT_R16G16B16A16_SINT                       = 14,
+    DXGI_FORMAT_R32G32_TYPELESS                         = 15,
+    DXGI_FORMAT_R32G32_FLOAT                            = 16,
+    DXGI_FORMAT_R32G32_UINT                             = 17,
+    DXGI_FORMAT_R32G32_SINT                             = 18,
+    DXGI_FORMAT_R32G8X24_TYPELESS                       = 19,
+    DXGI_FORMAT_D32_FLOAT_S8X24_UINT                    = 20,
+    DXGI_FORMAT_R32_FLOAT_X8X24_TYPELESS                = 21,
+    DXGI_FORMAT_X32_TYPELESS_G8X24_UINT                 = 22,
+    DXGI_FORMAT_R10G10B10A2_TYPELESS                    = 23,
+    DXGI_FORMAT_R10G10B10A2_UNORM                       = 24,
+    DXGI_FORMAT_R10G10B10A2_UINT                        = 25,
+    DXGI_FORMAT_R11G11B10_FLOAT                         = 26,
+    DXGI_FORMAT_R8G8B8A8_TYPELESS                       = 27,
+    DXGI_FORMAT_R8G8B8A8_UNORM                          = 28,
+    DXGI_FORMAT_R8G8B8A8_UNORM_SRGB                     = 29,
+    DXGI_FORMAT_R8G8B8A8_UINT                           = 30,
+    DXGI_FORMAT_R8G8B8A8_SNORM                          = 31,
+    DXGI_FORMAT_R8G8B8A8_SINT                           = 32,
+    DXGI_FORMAT_R16G16_TYPELESS                         = 33,
+    DXGI_FORMAT_R16G16_FLOAT                            = 34,
+    DXGI_FORMAT_R16G16_UNORM                            = 35,
+    DXGI_FORMAT_R16G16_UINT                             = 36,
+    DXGI_FORMAT_R16G16_SNORM                            = 37,
+    DXGI_FORMAT_R16G16_SINT                             = 38,
+    DXGI_FORMAT_R32_TYPELESS                            = 39,
+    DXGI_FORMAT_D32_FLOAT                               = 40,
+    DXGI_FORMAT_R32_FLOAT                               = 41,
+    DXGI_FORMAT_R32_UINT                                = 42,
+    DXGI_FORMAT_R32_SINT                                = 43,
+    DXGI_FORMAT_R24G8_TYPELESS                          = 44,
+    DXGI_FORMAT_D24_UNORM_S8_UINT                       = 45,
+    DXGI_FORMAT_R24_UNORM_X8_TYPELESS                   = 46,
+    DXGI_FORMAT_X24_TYPELESS_G8_UINT                    = 47,
+    DXGI_FORMAT_R8G8_TYPELESS                           = 48,
+    DXGI_FORMAT_R8G8_UNORM                              = 49,
+    DXGI_FORMAT_R8G8_UINT                               = 50,
+    DXGI_FORMAT_R8G8_SNORM                              = 51,
+    DXGI_FORMAT_R8G8_SINT                               = 52,
+    DXGI_FORMAT_R16_TYPELESS                            = 53,
+    DXGI_FORMAT_R16_FLOAT                               = 54,
+    DXGI_FORMAT_D16_UNORM                               = 55,
+    DXGI_FORMAT_R16_UNORM                               = 56,
+    DXGI_FORMAT_R16_UINT                                = 57,
+    DXGI_FORMAT_R16_SNORM                               = 58,
+    DXGI_FORMAT_R16_SINT                                = 59,
+    DXGI_FORMAT_R8_TYPELESS                             = 60,
+    DXGI_FORMAT_R8_UNORM                                = 61,
+    DXGI_FORMAT_R8_UINT                                 = 62,
+    DXGI_FORMAT_R8_SNORM                                = 63,
+    DXGI_FORMAT_R8_SINT                                 = 64,
+    DXGI_FORMAT_A8_UNORM                                = 65,
+    DXGI_FORMAT_R1_UNORM                                = 66,
+    DXGI_FORMAT_R9G9B9E5_SHAREDEXP                      = 67,
+    DXGI_FORMAT_R8G8_B8G8_UNORM                         = 68,
+    DXGI_FORMAT_G8R8_G8B8_UNORM                         = 69,
+    DXGI_FORMAT_BC1_TYPELESS                            = 70,
+    DXGI_FORMAT_BC1_UNORM                               = 71,
+    DXGI_FORMAT_BC1_UNORM_SRGB                          = 72,
+    DXGI_FORMAT_BC2_TYPELESS                            = 73,
+    DXGI_FORMAT_BC2_UNORM                               = 74,
+    DXGI_FORMAT_BC2_UNORM_SRGB                          = 75,
+    DXGI_FORMAT_BC3_TYPELESS                            = 76,
+    DXGI_FORMAT_BC3_UNORM                               = 77,
+    DXGI_FORMAT_BC3_UNORM_SRGB                          = 78,
+    DXGI_FORMAT_BC4_TYPELESS                            = 79,
+    DXGI_FORMAT_BC4_UNORM                               = 80,
+    DXGI_FORMAT_BC4_SNORM                               = 81,
+    DXGI_FORMAT_BC5_TYPELESS                            = 82,
+    DXGI_FORMAT_BC5_UNORM                               = 83,
+    DXGI_FORMAT_BC5_SNORM                               = 84,
+    DXGI_FORMAT_B5G6R5_UNORM                            = 85,
+    DXGI_FORMAT_B5G5R5A1_UNORM                          = 86,
+    DXGI_FORMAT_B8G8R8A8_UNORM                          = 87,
+    DXGI_FORMAT_B8G8R8X8_UNORM                          = 88,
+    DXGI_FORMAT_R10G10B10_XR_BIAS_A2_UNORM              = 89,
+    DXGI_FORMAT_B8G8R8A8_TYPELESS                       = 90,
+    DXGI_FORMAT_B8G8R8A8_UNORM_SRGB                     = 91,
+    DXGI_FORMAT_B8G8R8X8_TYPELESS                       = 92,
+    DXGI_FORMAT_B8G8R8X8_UNORM_SRGB                     = 93,
+    DXGI_FORMAT_BC6H_TYPELESS                           = 94,
+    DXGI_FORMAT_BC6H_UF16                               = 95,
+    DXGI_FORMAT_BC6H_SF16                               = 96,
+    DXGI_FORMAT_BC7_TYPELESS                            = 97,
+    DXGI_FORMAT_BC7_UNORM                               = 98,
+    DXGI_FORMAT_BC7_UNORM_SRGB                          = 99,
+    DXGI_FORMAT_AYUV                                    = 100,
+    DXGI_FORMAT_Y410                                    = 101,
+    DXGI_FORMAT_Y416                                    = 102,
+    DXGI_FORMAT_NV12                                    = 103,
+    DXGI_FORMAT_P010                                    = 104,
+    DXGI_FORMAT_P016                                    = 105,
+    DXGI_FORMAT_420_OPAQUE                              = 106,
+    DXGI_FORMAT_YUY2                                    = 107,
+    DXGI_FORMAT_Y210                                    = 108,
+    DXGI_FORMAT_Y216                                    = 109,
+    DXGI_FORMAT_NV11                                    = 110,
+    DXGI_FORMAT_AI44                                    = 111,
+    DXGI_FORMAT_IA44                                    = 112,
+    DXGI_FORMAT_P8                                      = 113,
+    DXGI_FORMAT_A8P8                                    = 114,
+    DXGI_FORMAT_B4G4R4A4_UNORM                          = 115,
+
+    DXGI_FORMAT_P208                                    = 130,
+    DXGI_FORMAT_V208                                    = 131,
+    DXGI_FORMAT_V408                                    = 132,
+
+
+    DXGI_FORMAT_SAMPLER_FEEDBACK_MIN_MIP_OPAQUE         = 189,
+    DXGI_FORMAT_SAMPLER_FEEDBACK_MIP_REGION_USED_OPAQUE = 190,
+
+
+    DXGI_FORMAT_FORCE_UINT                  = 0xffffffff
+} DXGI_FORMAT;
+
+#endif // __dxgiformat_h__