From 584973b97239ec41bd092a6ce3c2af66d23a298c Mon Sep 17 00:00:00 2001 From: Amer Koleci Date: Mon, 5 Sep 2022 12:07:08 +0200 Subject: [PATCH] Initial D3D11 generation. --- src/Generator/ApiData.cs | 1 + src/Generator/Program.cs | 91 +- .../Generated/{D3D11.xml => Direct3D11.xml} | 0 .../Generated/Graphics/Direct3D.cs | 1 - .../Generated/Graphics/Direct3D11.cs | 38628 ++++++++++++++++ .../Generated/Graphics/Dxgi.Common.cs | 9 - src/Vortice.Win32/Generated/Graphics/Dxgi.cs | 39 +- 7 files changed, 38716 insertions(+), 53 deletions(-) rename src/Vortice.Win32/Generated/{D3D11.xml => Direct3D11.xml} (100%) create mode 100644 src/Vortice.Win32/Generated/Graphics/Direct3D11.cs diff --git a/src/Generator/ApiData.cs b/src/Generator/ApiData.cs index ae51d64..a99444c 100644 --- a/src/Generator/ApiData.cs +++ b/src/Generator/ApiData.cs @@ -111,6 +111,7 @@ public class ApiType public int Size { get; set; } public int PackingSize { get; set; } public ApiStructField[] Fields { get; set; } + public ApiType[] NestedTypes { get; set; } // Com public string Guid { get; set; } diff --git a/src/Generator/Program.cs b/src/Generator/Program.cs index da2068e..282bba0 100644 --- a/src/Generator/Program.cs +++ b/src/Generator/Program.cs @@ -1,6 +1,7 @@ // Copyright © Amer Koleci and Contributors. // Licensed under the MIT License (MIT). See LICENSE in the repository root for more information. +using System.Globalization; using System.Text; using Newtonsoft.Json; @@ -12,7 +13,8 @@ public static class Program { "Graphics.Dxgi.Common.json", "Graphics.Dxgi.json", - "Graphics.Direct3D.json" + "Graphics.Direct3D.json", + "Graphics.Direct3D11.json" }; private static readonly Dictionary s_csNameMappings = new() @@ -94,6 +96,14 @@ public static class Program { "D3D_SHADER_INPUT_FLAGS", "D3D_SIF" }, { "D3D_SHADER_INPUT_TYPE", "D3D_SIT" }, { "D3D_SHADER_CBUFFER_FLAGS", "D3D_CBF" }, + + // D3D11 + { "D3D11_INPUT_CLASSIFICATION", "D3D11_INPUT" }, + { "D3D11_FILL_MODE", "D3D11_FILL" }, + { "D3D11_CULL_MODE", "D3D11_CULL" }, + { "D3D11_BIND_FLAG", "D3D11_BIND" }, + { "D3D11_CPU_ACCESS_FLAG", "D3D11_CPU_ACCESS" }, + { "D3D11_RESOURCE_MISC_FLAG", "D3D11_RESOURCE_MISC" }, }; private static readonly Dictionary s_partRenames = new() @@ -155,6 +165,7 @@ public static class Program { "MIN12INT", "Min12Int" }, { "MIN16INT", "Min16Int" }, { "MIN16UINT", "Min16Uint" }, + { "KEYEDMUTEX", "KeyedMutex" }, }; private static readonly Dictionary s_knownEnumValueNames = new() @@ -246,7 +257,7 @@ public static class Program // Generate docs DocGenerator.Generate(new[] { "D3D" }, Path.Combine(outputPath, "Direct3D.xml")); DocGenerator.Generate(new[] { "DXGI" }, Path.Combine(outputPath, "Dxgi.xml")); - DocGenerator.Generate(new[] { "D3D11" }, Path.Combine(outputPath, "D3D11.xml")); + DocGenerator.Generate(new[] { "D3D11" }, Path.Combine(outputPath, "Direct3D11.xml")); return 0; } @@ -316,6 +327,16 @@ public static class Program { writer.WriteLine($"public static readonly HResult {constant.Name} = {constant.Value};"); } + else if (typeName == "float") + { + float floatValue = Convert.ToSingle(constant.Value); + writer.WriteLine($"public const float {constant.Name} = {floatValue.ToString(CultureInfo.InvariantCulture)}f;"); + } + else if (typeName == "double") + { + double dblValue = Convert.ToDouble(constant.Value); + writer.WriteLine($"public const double {constant.Name} = {dblValue.ToString(CultureInfo.InvariantCulture)};"); + } else { writer.WriteLine($"public const {typeName} {constant.Name} = {constant.Value};"); @@ -456,7 +477,9 @@ public static class Program writer.WriteLine($"/// {enumType.Name}"); bool isFlags = false; - if (enumType.Flags || csTypeName.EndsWith("Flags")) + if (enumType.Flags || + csTypeName.EndsWith("Flag") || + csTypeName.EndsWith("Flags")) { isFlags = true; writer.WriteLine("[Flags]"); @@ -491,6 +514,12 @@ public static class Program } } + if (value.Name.EndsWith("_MESSAGES_START") || + value.Name.EndsWith("_MESSAGES_END")) + { + continue; + } + string enumValueName = GetPrettyFieldName(value.Name, enumPrefix); if (enumType.Name == "D3D_SHADER_VARIABLE_TYPE") @@ -519,26 +548,46 @@ public static class Program writer.WriteLine(); } - private static void GenerateStruct(CodeWriter writer, ApiType structType) + private static void GenerateStruct(CodeWriter writer, ApiType structType, bool nestedType = false) { - string csTypeName = GetDataTypeName(structType.Name, out string structPrefix); - AddCsMapping(writer.Api, structType.Name, csTypeName); + string csTypeName; + string structPrefix = string.Empty; - writer.WriteLine($"/// "); - - if (s_generateUnmanagedDocs) + if (nestedType) { - writer.WriteLine($"/// {structType.Name}"); + csTypeName = structType.Name; + } + else + { + csTypeName = GetDataTypeName(structType.Name, out structPrefix); + AddCsMapping(writer.Api, structType.Name, csTypeName); + + writer.WriteLine($"/// "); + + if (s_generateUnmanagedDocs) + { + writer.WriteLine($"/// {structType.Name}"); + } } using (writer.PushBlock($"public partial struct {csTypeName}")) { + int fieldIndex = 0; foreach (ApiStructField field in structType.Fields) { if (field.Name.EndsWith("_FORCE_DWORD")) continue; - string fieldValueName = GetPrettyFieldName(field.Name, structPrefix); + string fieldValueName; + if (nestedType) + { + fieldValueName = field.Name; + } + else + { + fieldValueName = GetPrettyFieldName(field.Name, structPrefix); + } + string fieldTypeName = GetTypeName(field.Type); writer.WriteLine($"/// "); @@ -614,9 +663,26 @@ public static class Program writer.WriteLine($"public {unsafePrefix}{fieldTypeName} {fieldValueName};"); } + if (fieldIndex < structType.Fields.Length - 1) + { + writer.WriteLine(); + } + + fieldIndex++; + } + + // Generate nested types + if (structType.NestedTypes.Length > 0) + { writer.WriteLine(); + + foreach (ApiType nestedTypeToGenerate in structType.NestedTypes) + { + GenerateStruct(writer, nestedTypeToGenerate, true); + } } } + writer.WriteLine(); } @@ -898,7 +964,8 @@ public static class Program private static bool ShouldSkipConstant(ApiDataConstant constant) { if (constant.Name == "_FACDXGI" || - constant.Name == "DXGI_FORMAT_DEFINED") + constant.Name == "DXGI_FORMAT_DEFINED" || + constant.Name == "D3D11_FLOAT32_MAX") { return true; } diff --git a/src/Vortice.Win32/Generated/D3D11.xml b/src/Vortice.Win32/Generated/Direct3D11.xml similarity index 100% rename from src/Vortice.Win32/Generated/D3D11.xml rename to src/Vortice.Win32/Generated/Direct3D11.xml diff --git a/src/Vortice.Win32/Generated/Graphics/Direct3D.cs b/src/Vortice.Win32/Generated/Graphics/Direct3D.cs index 1e1be43..5e4cc43 100644 --- a/src/Vortice.Win32/Generated/Graphics/Direct3D.cs +++ b/src/Vortice.Win32/Generated/Graphics/Direct3D.cs @@ -1080,7 +1080,6 @@ public partial struct ShaderMacro /// public unsafe byte* Definition; - } #endregion Structs diff --git a/src/Vortice.Win32/Generated/Graphics/Direct3D11.cs b/src/Vortice.Win32/Generated/Graphics/Direct3D11.cs new file mode 100644 index 0000000..d4deced --- /dev/null +++ b/src/Vortice.Win32/Generated/Graphics/Direct3D11.cs @@ -0,0 +1,38628 @@ +// ------------------------------------------------------------------------------ +// +// This code was generated by a tool. +// +// Changes to this file may cause incorrect behavior and will be lost if +// the code is regenerated. +// +// ------------------------------------------------------------------------------ + +using System; +using System.Diagnostics; +using System.Runtime.CompilerServices; +using System.Diagnostics.CodeAnalysis; + +#if !NET6_0_OR_GREATER +using MemoryMarshal = Win32.MemoryMarshal; +#endif + +namespace Win32.Graphics.Direct3D11; + +public static partial class Apis +{ + public const uint D3D11_16BIT_INDEX_STRIP_CUT_VALUE = 65535; + public const uint D3D11_32BIT_INDEX_STRIP_CUT_VALUE = 4294967295; + public const uint D3D11_8BIT_INDEX_STRIP_CUT_VALUE = 255; + public const uint D3D11_ARRAY_AXIS_ADDRESS_RANGE_BIT_COUNT = 9; + public const uint D3D11_CLIP_OR_CULL_DISTANCE_COUNT = 8; + public const uint D3D11_CLIP_OR_CULL_DISTANCE_ELEMENT_COUNT = 2; + public const uint D3D11_COMMONSHADER_CONSTANT_BUFFER_API_SLOT_COUNT = 14; + public const uint D3D11_COMMONSHADER_CONSTANT_BUFFER_COMPONENTS = 4; + public const uint D3D11_COMMONSHADER_CONSTANT_BUFFER_COMPONENT_BIT_COUNT = 32; + public const uint D3D11_COMMONSHADER_CONSTANT_BUFFER_HW_SLOT_COUNT = 15; + public const uint D3D11_COMMONSHADER_CONSTANT_BUFFER_PARTIAL_UPDATE_EXTENTS_BYTE_ALIGNMENT = 16; + public const uint D3D11_COMMONSHADER_CONSTANT_BUFFER_REGISTER_COMPONENTS = 4; + public const uint D3D11_COMMONSHADER_CONSTANT_BUFFER_REGISTER_COUNT = 15; + public const uint D3D11_COMMONSHADER_CONSTANT_BUFFER_REGISTER_READS_PER_INST = 1; + public const uint D3D11_COMMONSHADER_CONSTANT_BUFFER_REGISTER_READ_PORTS = 1; + public const uint D3D11_COMMONSHADER_FLOWCONTROL_NESTING_LIMIT = 64; + public const uint D3D11_COMMONSHADER_IMMEDIATE_CONSTANT_BUFFER_REGISTER_COMPONENTS = 4; + public const uint D3D11_COMMONSHADER_IMMEDIATE_CONSTANT_BUFFER_REGISTER_COUNT = 1; + public const uint D3D11_COMMONSHADER_IMMEDIATE_CONSTANT_BUFFER_REGISTER_READS_PER_INST = 1; + public const uint D3D11_COMMONSHADER_IMMEDIATE_CONSTANT_BUFFER_REGISTER_READ_PORTS = 1; + public const uint D3D11_COMMONSHADER_IMMEDIATE_VALUE_COMPONENT_BIT_COUNT = 32; + public const uint D3D11_COMMONSHADER_INPUT_RESOURCE_REGISTER_COMPONENTS = 1; + public const uint D3D11_COMMONSHADER_INPUT_RESOURCE_REGISTER_COUNT = 128; + public const uint D3D11_COMMONSHADER_INPUT_RESOURCE_REGISTER_READS_PER_INST = 1; + public const uint D3D11_COMMONSHADER_INPUT_RESOURCE_REGISTER_READ_PORTS = 1; + public const uint D3D11_COMMONSHADER_INPUT_RESOURCE_SLOT_COUNT = 128; + public const uint D3D11_COMMONSHADER_SAMPLER_REGISTER_COMPONENTS = 1; + public const uint D3D11_COMMONSHADER_SAMPLER_REGISTER_COUNT = 16; + public const uint D3D11_COMMONSHADER_SAMPLER_REGISTER_READS_PER_INST = 1; + public const uint D3D11_COMMONSHADER_SAMPLER_REGISTER_READ_PORTS = 1; + public const uint D3D11_COMMONSHADER_SAMPLER_SLOT_COUNT = 16; + public const uint D3D11_COMMONSHADER_SUBROUTINE_NESTING_LIMIT = 32; + public const uint D3D11_COMMONSHADER_TEMP_REGISTER_COMPONENTS = 4; + public const uint D3D11_COMMONSHADER_TEMP_REGISTER_COMPONENT_BIT_COUNT = 32; + public const uint D3D11_COMMONSHADER_TEMP_REGISTER_COUNT = 4096; + public const uint D3D11_COMMONSHADER_TEMP_REGISTER_READS_PER_INST = 3; + public const uint D3D11_COMMONSHADER_TEMP_REGISTER_READ_PORTS = 3; + public const uint D3D11_COMMONSHADER_TEXCOORD_RANGE_REDUCTION_MAX = 10; + public const int D3D11_COMMONSHADER_TEXCOORD_RANGE_REDUCTION_MIN = -10; + public const int D3D11_COMMONSHADER_TEXEL_OFFSET_MAX_NEGATIVE = -8; + public const uint D3D11_COMMONSHADER_TEXEL_OFFSET_MAX_POSITIVE = 7; + public const uint D3D11_CS_4_X_BUCKET00_MAX_BYTES_TGSM_WRITABLE_PER_THREAD = 256; + public const uint D3D11_CS_4_X_BUCKET00_MAX_NUM_THREADS_PER_GROUP = 64; + public const uint D3D11_CS_4_X_BUCKET01_MAX_BYTES_TGSM_WRITABLE_PER_THREAD = 240; + public const uint D3D11_CS_4_X_BUCKET01_MAX_NUM_THREADS_PER_GROUP = 68; + public const uint D3D11_CS_4_X_BUCKET02_MAX_BYTES_TGSM_WRITABLE_PER_THREAD = 224; + public const uint D3D11_CS_4_X_BUCKET02_MAX_NUM_THREADS_PER_GROUP = 72; + public const uint D3D11_CS_4_X_BUCKET03_MAX_BYTES_TGSM_WRITABLE_PER_THREAD = 208; + public const uint D3D11_CS_4_X_BUCKET03_MAX_NUM_THREADS_PER_GROUP = 76; + public const uint D3D11_CS_4_X_BUCKET04_MAX_BYTES_TGSM_WRITABLE_PER_THREAD = 192; + public const uint D3D11_CS_4_X_BUCKET04_MAX_NUM_THREADS_PER_GROUP = 84; + public const uint D3D11_CS_4_X_BUCKET05_MAX_BYTES_TGSM_WRITABLE_PER_THREAD = 176; + public const uint D3D11_CS_4_X_BUCKET05_MAX_NUM_THREADS_PER_GROUP = 92; + public const uint D3D11_CS_4_X_BUCKET06_MAX_BYTES_TGSM_WRITABLE_PER_THREAD = 160; + public const uint D3D11_CS_4_X_BUCKET06_MAX_NUM_THREADS_PER_GROUP = 100; + public const uint D3D11_CS_4_X_BUCKET07_MAX_BYTES_TGSM_WRITABLE_PER_THREAD = 144; + public const uint D3D11_CS_4_X_BUCKET07_MAX_NUM_THREADS_PER_GROUP = 112; + public const uint D3D11_CS_4_X_BUCKET08_MAX_BYTES_TGSM_WRITABLE_PER_THREAD = 128; + public const uint D3D11_CS_4_X_BUCKET08_MAX_NUM_THREADS_PER_GROUP = 128; + public const uint D3D11_CS_4_X_BUCKET09_MAX_BYTES_TGSM_WRITABLE_PER_THREAD = 112; + public const uint D3D11_CS_4_X_BUCKET09_MAX_NUM_THREADS_PER_GROUP = 144; + public const uint D3D11_CS_4_X_BUCKET10_MAX_BYTES_TGSM_WRITABLE_PER_THREAD = 96; + public const uint D3D11_CS_4_X_BUCKET10_MAX_NUM_THREADS_PER_GROUP = 168; + public const uint D3D11_CS_4_X_BUCKET11_MAX_BYTES_TGSM_WRITABLE_PER_THREAD = 80; + public const uint D3D11_CS_4_X_BUCKET11_MAX_NUM_THREADS_PER_GROUP = 204; + public const uint D3D11_CS_4_X_BUCKET12_MAX_BYTES_TGSM_WRITABLE_PER_THREAD = 64; + public const uint D3D11_CS_4_X_BUCKET12_MAX_NUM_THREADS_PER_GROUP = 256; + public const uint D3D11_CS_4_X_BUCKET13_MAX_BYTES_TGSM_WRITABLE_PER_THREAD = 48; + public const uint D3D11_CS_4_X_BUCKET13_MAX_NUM_THREADS_PER_GROUP = 340; + public const uint D3D11_CS_4_X_BUCKET14_MAX_BYTES_TGSM_WRITABLE_PER_THREAD = 32; + public const uint D3D11_CS_4_X_BUCKET14_MAX_NUM_THREADS_PER_GROUP = 512; + public const uint D3D11_CS_4_X_BUCKET15_MAX_BYTES_TGSM_WRITABLE_PER_THREAD = 16; + public const uint D3D11_CS_4_X_BUCKET15_MAX_NUM_THREADS_PER_GROUP = 768; + public const uint D3D11_CS_4_X_DISPATCH_MAX_THREAD_GROUPS_IN_Z_DIMENSION = 1; + public const uint D3D11_CS_4_X_RAW_UAV_BYTE_ALIGNMENT = 256; + public const uint D3D11_CS_4_X_THREAD_GROUP_MAX_THREADS_PER_GROUP = 768; + public const uint D3D11_CS_4_X_THREAD_GROUP_MAX_X = 768; + public const uint D3D11_CS_4_X_THREAD_GROUP_MAX_Y = 768; + public const uint D3D11_CS_4_X_UAV_REGISTER_COUNT = 1; + public const uint D3D11_CS_DISPATCH_MAX_THREAD_GROUPS_PER_DIMENSION = 65535; + public const uint D3D11_CS_TGSM_REGISTER_COUNT = 8192; + public const uint D3D11_CS_TGSM_REGISTER_READS_PER_INST = 1; + public const uint D3D11_CS_TGSM_RESOURCE_REGISTER_COMPONENTS = 1; + public const uint D3D11_CS_TGSM_RESOURCE_REGISTER_READ_PORTS = 1; + public const uint D3D11_CS_THREADGROUPID_REGISTER_COMPONENTS = 3; + public const uint D3D11_CS_THREADGROUPID_REGISTER_COUNT = 1; + public const uint D3D11_CS_THREADIDINGROUPFLATTENED_REGISTER_COMPONENTS = 1; + public const uint D3D11_CS_THREADIDINGROUPFLATTENED_REGISTER_COUNT = 1; + public const uint D3D11_CS_THREADIDINGROUP_REGISTER_COMPONENTS = 3; + public const uint D3D11_CS_THREADIDINGROUP_REGISTER_COUNT = 1; + public const uint D3D11_CS_THREADID_REGISTER_COMPONENTS = 3; + public const uint D3D11_CS_THREADID_REGISTER_COUNT = 1; + public const uint D3D11_CS_THREAD_GROUP_MAX_THREADS_PER_GROUP = 1024; + public const uint D3D11_CS_THREAD_GROUP_MAX_X = 1024; + public const uint D3D11_CS_THREAD_GROUP_MAX_Y = 1024; + public const uint D3D11_CS_THREAD_GROUP_MAX_Z = 64; + public const uint D3D11_CS_THREAD_GROUP_MIN_X = 1; + public const uint D3D11_CS_THREAD_GROUP_MIN_Y = 1; + public const uint D3D11_CS_THREAD_GROUP_MIN_Z = 1; + public const uint D3D11_CS_THREAD_LOCAL_TEMP_REGISTER_POOL = 16384; + public const float D3D11_DEFAULT_BLEND_FACTOR_ALPHA = 1f; + public const float D3D11_DEFAULT_BLEND_FACTOR_BLUE = 1f; + public const float D3D11_DEFAULT_BLEND_FACTOR_GREEN = 1f; + public const float D3D11_DEFAULT_BLEND_FACTOR_RED = 1f; + public const float D3D11_DEFAULT_BORDER_COLOR_COMPONENT = 0f; + public const uint D3D11_DEFAULT_DEPTH_BIAS = 0; + public const float D3D11_DEFAULT_DEPTH_BIAS_CLAMP = 0f; + public const uint D3D11_DEFAULT_MAX_ANISOTROPY = 16; + public const float D3D11_DEFAULT_MIP_LOD_BIAS = 0f; + public const uint D3D11_DEFAULT_RENDER_TARGET_ARRAY_INDEX = 0; + public const uint D3D11_DEFAULT_SAMPLE_MASK = 4294967295; + public const uint D3D11_DEFAULT_SCISSOR_ENDX = 0; + public const uint D3D11_DEFAULT_SCISSOR_ENDY = 0; + public const uint D3D11_DEFAULT_SCISSOR_STARTX = 0; + public const uint D3D11_DEFAULT_SCISSOR_STARTY = 0; + public const float D3D11_DEFAULT_SLOPE_SCALED_DEPTH_BIAS = 0f; + public const uint D3D11_DEFAULT_STENCIL_READ_MASK = 255; + public const uint D3D11_DEFAULT_STENCIL_REFERENCE = 0; + public const uint D3D11_DEFAULT_STENCIL_WRITE_MASK = 255; + public const uint D3D11_DEFAULT_VIEWPORT_AND_SCISSORRECT_INDEX = 0; + public const uint D3D11_DEFAULT_VIEWPORT_HEIGHT = 0; + public const float D3D11_DEFAULT_VIEWPORT_MAX_DEPTH = 0f; + public const float D3D11_DEFAULT_VIEWPORT_MIN_DEPTH = 0f; + public const uint D3D11_DEFAULT_VIEWPORT_TOPLEFTX = 0; + public const uint D3D11_DEFAULT_VIEWPORT_TOPLEFTY = 0; + public const uint D3D11_DEFAULT_VIEWPORT_WIDTH = 0; + public const uint D3D11_DS_INPUT_CONTROL_POINTS_MAX_TOTAL_SCALARS = 3968; + public const uint D3D11_DS_INPUT_CONTROL_POINT_REGISTER_COMPONENTS = 4; + public const uint D3D11_DS_INPUT_CONTROL_POINT_REGISTER_COMPONENT_BIT_COUNT = 32; + public const uint D3D11_DS_INPUT_CONTROL_POINT_REGISTER_COUNT = 32; + public const uint D3D11_DS_INPUT_CONTROL_POINT_REGISTER_READS_PER_INST = 2; + public const uint D3D11_DS_INPUT_CONTROL_POINT_REGISTER_READ_PORTS = 1; + public const uint D3D11_DS_INPUT_DOMAIN_POINT_REGISTER_COMPONENTS = 3; + public const uint D3D11_DS_INPUT_DOMAIN_POINT_REGISTER_COMPONENT_BIT_COUNT = 32; + public const uint D3D11_DS_INPUT_DOMAIN_POINT_REGISTER_COUNT = 1; + public const uint D3D11_DS_INPUT_DOMAIN_POINT_REGISTER_READS_PER_INST = 2; + public const uint D3D11_DS_INPUT_DOMAIN_POINT_REGISTER_READ_PORTS = 1; + public const uint D3D11_DS_INPUT_PATCH_CONSTANT_REGISTER_COMPONENTS = 4; + public const uint D3D11_DS_INPUT_PATCH_CONSTANT_REGISTER_COMPONENT_BIT_COUNT = 32; + public const uint D3D11_DS_INPUT_PATCH_CONSTANT_REGISTER_COUNT = 32; + public const uint D3D11_DS_INPUT_PATCH_CONSTANT_REGISTER_READS_PER_INST = 2; + public const uint D3D11_DS_INPUT_PATCH_CONSTANT_REGISTER_READ_PORTS = 1; + public const uint D3D11_DS_INPUT_PRIMITIVE_ID_REGISTER_COMPONENTS = 1; + public const uint D3D11_DS_INPUT_PRIMITIVE_ID_REGISTER_COMPONENT_BIT_COUNT = 32; + public const uint D3D11_DS_INPUT_PRIMITIVE_ID_REGISTER_COUNT = 1; + public const uint D3D11_DS_INPUT_PRIMITIVE_ID_REGISTER_READS_PER_INST = 2; + public const uint D3D11_DS_INPUT_PRIMITIVE_ID_REGISTER_READ_PORTS = 1; + public const uint D3D11_DS_OUTPUT_REGISTER_COMPONENTS = 4; + public const uint D3D11_DS_OUTPUT_REGISTER_COMPONENT_BIT_COUNT = 32; + public const uint D3D11_DS_OUTPUT_REGISTER_COUNT = 32; + public const double D3D11_FLOAT16_FUSED_TOLERANCE_IN_ULP = 0.6; + public const float D3D11_FLOAT32_TO_INTEGER_TOLERANCE_IN_ULP = 0.6f; + public const float D3D11_FLOAT_TO_SRGB_EXPONENT_DENOMINATOR = 2.4f; + public const float D3D11_FLOAT_TO_SRGB_EXPONENT_NUMERATOR = 1f; + public const float D3D11_FLOAT_TO_SRGB_OFFSET = 0.055f; + public const float D3D11_FLOAT_TO_SRGB_SCALE_1 = 12.92f; + public const float D3D11_FLOAT_TO_SRGB_SCALE_2 = 1.055f; + public const float D3D11_FLOAT_TO_SRGB_THRESHOLD = 0.0031308f; + public const float D3D11_FTOI_INSTRUCTION_MAX_INPUT = 2.1474836E+09f; + public const float D3D11_FTOI_INSTRUCTION_MIN_INPUT = -2.1474836E+09f; + public const float D3D11_FTOU_INSTRUCTION_MAX_INPUT = 4.2949673E+09f; + public const float D3D11_FTOU_INSTRUCTION_MIN_INPUT = 0f; + public const uint D3D11_GS_INPUT_INSTANCE_ID_READS_PER_INST = 2; + public const uint D3D11_GS_INPUT_INSTANCE_ID_READ_PORTS = 1; + public const uint D3D11_GS_INPUT_INSTANCE_ID_REGISTER_COMPONENTS = 1; + public const uint D3D11_GS_INPUT_INSTANCE_ID_REGISTER_COMPONENT_BIT_COUNT = 32; + public const uint D3D11_GS_INPUT_INSTANCE_ID_REGISTER_COUNT = 1; + public const uint D3D11_GS_INPUT_PRIM_CONST_REGISTER_COMPONENTS = 1; + public const uint D3D11_GS_INPUT_PRIM_CONST_REGISTER_COMPONENT_BIT_COUNT = 32; + public const uint D3D11_GS_INPUT_PRIM_CONST_REGISTER_COUNT = 1; + public const uint D3D11_GS_INPUT_PRIM_CONST_REGISTER_READS_PER_INST = 2; + public const uint D3D11_GS_INPUT_PRIM_CONST_REGISTER_READ_PORTS = 1; + public const uint D3D11_GS_INPUT_REGISTER_COMPONENTS = 4; + public const uint D3D11_GS_INPUT_REGISTER_COMPONENT_BIT_COUNT = 32; + public const uint D3D11_GS_INPUT_REGISTER_COUNT = 32; + public const uint D3D11_GS_INPUT_REGISTER_READS_PER_INST = 2; + public const uint D3D11_GS_INPUT_REGISTER_READ_PORTS = 1; + public const uint D3D11_GS_INPUT_REGISTER_VERTICES = 32; + public const uint D3D11_GS_MAX_INSTANCE_COUNT = 32; + public const uint D3D11_GS_MAX_OUTPUT_VERTEX_COUNT_ACROSS_INSTANCES = 1024; + public const uint D3D11_GS_OUTPUT_ELEMENTS = 32; + public const uint D3D11_GS_OUTPUT_REGISTER_COMPONENTS = 4; + public const uint D3D11_GS_OUTPUT_REGISTER_COMPONENT_BIT_COUNT = 32; + public const uint D3D11_GS_OUTPUT_REGISTER_COUNT = 32; + public const uint D3D11_HS_CONTROL_POINT_PHASE_INPUT_REGISTER_COUNT = 32; + public const uint D3D11_HS_CONTROL_POINT_PHASE_OUTPUT_REGISTER_COUNT = 32; + public const uint D3D11_HS_CONTROL_POINT_REGISTER_COMPONENTS = 4; + public const uint D3D11_HS_CONTROL_POINT_REGISTER_COMPONENT_BIT_COUNT = 32; + public const uint D3D11_HS_CONTROL_POINT_REGISTER_READS_PER_INST = 2; + public const uint D3D11_HS_CONTROL_POINT_REGISTER_READ_PORTS = 1; + public const uint D3D11_HS_FORK_PHASE_INSTANCE_COUNT_UPPER_BOUND = 4294967295; + public const uint D3D11_HS_INPUT_FORK_INSTANCE_ID_REGISTER_COMPONENTS = 1; + public const uint D3D11_HS_INPUT_FORK_INSTANCE_ID_REGISTER_COMPONENT_BIT_COUNT = 32; + public const uint D3D11_HS_INPUT_FORK_INSTANCE_ID_REGISTER_COUNT = 1; + public const uint D3D11_HS_INPUT_FORK_INSTANCE_ID_REGISTER_READS_PER_INST = 2; + public const uint D3D11_HS_INPUT_FORK_INSTANCE_ID_REGISTER_READ_PORTS = 1; + public const uint D3D11_HS_INPUT_JOIN_INSTANCE_ID_REGISTER_COMPONENTS = 1; + public const uint D3D11_HS_INPUT_JOIN_INSTANCE_ID_REGISTER_COMPONENT_BIT_COUNT = 32; + public const uint D3D11_HS_INPUT_JOIN_INSTANCE_ID_REGISTER_COUNT = 1; + public const uint D3D11_HS_INPUT_JOIN_INSTANCE_ID_REGISTER_READS_PER_INST = 2; + public const uint D3D11_HS_INPUT_JOIN_INSTANCE_ID_REGISTER_READ_PORTS = 1; + public const uint D3D11_HS_INPUT_PRIMITIVE_ID_REGISTER_COMPONENTS = 1; + public const uint D3D11_HS_INPUT_PRIMITIVE_ID_REGISTER_COMPONENT_BIT_COUNT = 32; + public const uint D3D11_HS_INPUT_PRIMITIVE_ID_REGISTER_COUNT = 1; + public const uint D3D11_HS_INPUT_PRIMITIVE_ID_REGISTER_READS_PER_INST = 2; + public const uint D3D11_HS_INPUT_PRIMITIVE_ID_REGISTER_READ_PORTS = 1; + public const uint D3D11_HS_JOIN_PHASE_INSTANCE_COUNT_UPPER_BOUND = 4294967295; + public const float D3D11_HS_MAXTESSFACTOR_LOWER_BOUND = 1f; + public const float D3D11_HS_MAXTESSFACTOR_UPPER_BOUND = 64f; + public const uint D3D11_HS_OUTPUT_CONTROL_POINTS_MAX_TOTAL_SCALARS = 3968; + public const uint D3D11_HS_OUTPUT_CONTROL_POINT_ID_REGISTER_COMPONENTS = 1; + public const uint D3D11_HS_OUTPUT_CONTROL_POINT_ID_REGISTER_COMPONENT_BIT_COUNT = 32; + public const uint D3D11_HS_OUTPUT_CONTROL_POINT_ID_REGISTER_COUNT = 1; + public const uint D3D11_HS_OUTPUT_CONTROL_POINT_ID_REGISTER_READS_PER_INST = 2; + public const uint D3D11_HS_OUTPUT_CONTROL_POINT_ID_REGISTER_READ_PORTS = 1; + public const uint D3D11_HS_OUTPUT_PATCH_CONSTANT_REGISTER_COMPONENTS = 4; + public const uint D3D11_HS_OUTPUT_PATCH_CONSTANT_REGISTER_COMPONENT_BIT_COUNT = 32; + public const uint D3D11_HS_OUTPUT_PATCH_CONSTANT_REGISTER_COUNT = 32; + public const uint D3D11_HS_OUTPUT_PATCH_CONSTANT_REGISTER_READS_PER_INST = 2; + public const uint D3D11_HS_OUTPUT_PATCH_CONSTANT_REGISTER_READ_PORTS = 1; + public const uint D3D11_HS_OUTPUT_PATCH_CONSTANT_REGISTER_SCALAR_COMPONENTS = 128; + public const uint D3D11_IA_DEFAULT_INDEX_BUFFER_OFFSET_IN_BYTES = 0; + public const uint D3D11_IA_DEFAULT_PRIMITIVE_TOPOLOGY = 0; + public const uint D3D11_IA_DEFAULT_VERTEX_BUFFER_OFFSET_IN_BYTES = 0; + public const uint D3D11_IA_INDEX_INPUT_RESOURCE_SLOT_COUNT = 1; + public const uint D3D11_IA_INSTANCE_ID_BIT_COUNT = 32; + public const uint D3D11_IA_INTEGER_ARITHMETIC_BIT_COUNT = 32; + public const uint D3D11_IA_PATCH_MAX_CONTROL_POINT_COUNT = 32; + public const uint D3D11_IA_PRIMITIVE_ID_BIT_COUNT = 32; + public const uint D3D11_IA_VERTEX_ID_BIT_COUNT = 32; + public const uint D3D11_IA_VERTEX_INPUT_RESOURCE_SLOT_COUNT = 32; + public const uint D3D11_IA_VERTEX_INPUT_STRUCTURE_ELEMENTS_COMPONENTS = 128; + public const uint D3D11_IA_VERTEX_INPUT_STRUCTURE_ELEMENT_COUNT = 32; + public const uint D3D11_INTEGER_DIVIDE_BY_ZERO_QUOTIENT = 4294967295; + public const uint D3D11_INTEGER_DIVIDE_BY_ZERO_REMAINDER = 4294967295; + public const uint D3D11_KEEP_RENDER_TARGETS_AND_DEPTH_STENCIL = 4294967295; + public const uint D3D11_KEEP_UNORDERED_ACCESS_VIEWS = 4294967295; + public const float D3D11_LINEAR_GAMMA = 1f; + public const uint D3D11_MAJOR_VERSION = 11; + public const float D3D11_MAX_BORDER_COLOR_COMPONENT = 1f; + public const float D3D11_MAX_DEPTH = 1f; + public const uint D3D11_MAX_MAXANISOTROPY = 16; + public const uint D3D11_MAX_MULTISAMPLE_SAMPLE_COUNT = 32; + public const float D3D11_MAX_POSITION_VALUE = 3.4028236E+34f; + public const uint D3D11_MAX_TEXTURE_DIMENSION_2_TO_EXP = 17; + public const uint D3D11_MINOR_VERSION = 0; + public const float D3D11_MIN_BORDER_COLOR_COMPONENT = 0f; + public const float D3D11_MIN_DEPTH = 0f; + public const uint D3D11_MIN_MAXANISOTROPY = 0; + public const float D3D11_MIP_LOD_BIAS_MAX = 15.99f; + public const float D3D11_MIP_LOD_BIAS_MIN = -16f; + public const uint D3D11_MIP_LOD_FRACTIONAL_BIT_COUNT = 8; + public const uint D3D11_MIP_LOD_RANGE_BIT_COUNT = 8; + public const float D3D11_MULTISAMPLE_ANTIALIAS_LINE_WIDTH = 1.4f; + public const uint D3D11_NONSAMPLE_FETCH_OUT_OF_RANGE_ACCESS_RESULT = 0; + public const uint D3D11_PIXEL_ADDRESS_RANGE_BIT_COUNT = 15; + public const uint D3D11_PRE_SCISSOR_PIXEL_ADDRESS_RANGE_BIT_COUNT = 16; + public const uint D3D11_PS_CS_UAV_REGISTER_COMPONENTS = 1; + public const uint D3D11_PS_CS_UAV_REGISTER_COUNT = 8; + public const uint D3D11_PS_CS_UAV_REGISTER_READS_PER_INST = 1; + public const uint D3D11_PS_CS_UAV_REGISTER_READ_PORTS = 1; + public const uint D3D11_PS_FRONTFACING_DEFAULT_VALUE = 4294967295; + public const uint D3D11_PS_FRONTFACING_FALSE_VALUE = 0; + public const uint D3D11_PS_FRONTFACING_TRUE_VALUE = 4294967295; + public const uint D3D11_PS_INPUT_REGISTER_COMPONENTS = 4; + public const uint D3D11_PS_INPUT_REGISTER_COMPONENT_BIT_COUNT = 32; + public const uint D3D11_PS_INPUT_REGISTER_COUNT = 32; + public const uint D3D11_PS_INPUT_REGISTER_READS_PER_INST = 2; + public const uint D3D11_PS_INPUT_REGISTER_READ_PORTS = 1; + public const float D3D11_PS_LEGACY_PIXEL_CENTER_FRACTIONAL_COMPONENT = 0f; + public const uint D3D11_PS_OUTPUT_DEPTH_REGISTER_COMPONENTS = 1; + public const uint D3D11_PS_OUTPUT_DEPTH_REGISTER_COMPONENT_BIT_COUNT = 32; + public const uint D3D11_PS_OUTPUT_DEPTH_REGISTER_COUNT = 1; + public const uint D3D11_PS_OUTPUT_MASK_REGISTER_COMPONENTS = 1; + public const uint D3D11_PS_OUTPUT_MASK_REGISTER_COMPONENT_BIT_COUNT = 32; + public const uint D3D11_PS_OUTPUT_MASK_REGISTER_COUNT = 1; + public const uint D3D11_PS_OUTPUT_REGISTER_COMPONENTS = 4; + public const uint D3D11_PS_OUTPUT_REGISTER_COMPONENT_BIT_COUNT = 32; + public const uint D3D11_PS_OUTPUT_REGISTER_COUNT = 8; + public const float D3D11_PS_PIXEL_CENTER_FRACTIONAL_COMPONENT = 0.5f; + public const uint D3D11_RAW_UAV_SRV_BYTE_ALIGNMENT = 16; + public const uint D3D11_REQ_BLEND_OBJECT_COUNT_PER_DEVICE = 4096; + public const uint D3D11_REQ_BUFFER_RESOURCE_TEXEL_COUNT_2_TO_EXP = 27; + public const uint D3D11_REQ_CONSTANT_BUFFER_ELEMENT_COUNT = 4096; + public const uint D3D11_REQ_DEPTH_STENCIL_OBJECT_COUNT_PER_DEVICE = 4096; + public const uint D3D11_REQ_DRAWINDEXED_INDEX_COUNT_2_TO_EXP = 32; + public const uint D3D11_REQ_DRAW_VERTEX_COUNT_2_TO_EXP = 32; + public const uint D3D11_REQ_FILTERING_HW_ADDRESSABLE_RESOURCE_DIMENSION = 16384; + public const uint D3D11_REQ_GS_INVOCATION_32BIT_OUTPUT_COMPONENT_LIMIT = 1024; + public const uint D3D11_REQ_IMMEDIATE_CONSTANT_BUFFER_ELEMENT_COUNT = 4096; + public const uint D3D11_REQ_MAXANISOTROPY = 16; + public const uint D3D11_REQ_MIP_LEVELS = 15; + public const uint D3D11_REQ_MULTI_ELEMENT_STRUCTURE_SIZE_IN_BYTES = 2048; + public const uint D3D11_REQ_RASTERIZER_OBJECT_COUNT_PER_DEVICE = 4096; + public const uint D3D11_REQ_RENDER_TO_BUFFER_WINDOW_WIDTH = 16384; + public const uint D3D11_REQ_RESOURCE_SIZE_IN_MEGABYTES_EXPRESSION_A_TERM = 128; + public const float D3D11_REQ_RESOURCE_SIZE_IN_MEGABYTES_EXPRESSION_B_TERM = 0.25f; + public const uint D3D11_REQ_RESOURCE_SIZE_IN_MEGABYTES_EXPRESSION_C_TERM = 2048; + public const uint D3D11_REQ_RESOURCE_VIEW_COUNT_PER_DEVICE_2_TO_EXP = 20; + public const uint D3D11_REQ_SAMPLER_OBJECT_COUNT_PER_DEVICE = 4096; + public const uint D3D11_REQ_TEXTURE1D_ARRAY_AXIS_DIMENSION = 2048; + public const uint D3D11_REQ_TEXTURE1D_U_DIMENSION = 16384; + public const uint D3D11_REQ_TEXTURE2D_ARRAY_AXIS_DIMENSION = 2048; + public const uint D3D11_REQ_TEXTURE2D_U_OR_V_DIMENSION = 16384; + public const uint D3D11_REQ_TEXTURE3D_U_V_OR_W_DIMENSION = 2048; + public const uint D3D11_REQ_TEXTURECUBE_DIMENSION = 16384; + public const uint D3D11_RESINFO_INSTRUCTION_MISSING_COMPONENT_RETVAL = 0; + public const uint D3D11_SHADER_MAJOR_VERSION = 5; + public const uint D3D11_SHADER_MAX_INSTANCES = 65535; + public const uint D3D11_SHADER_MAX_INTERFACES = 253; + public const uint D3D11_SHADER_MAX_INTERFACE_CALL_SITES = 4096; + public const uint D3D11_SHADER_MAX_TYPES = 65535; + public const uint D3D11_SHADER_MINOR_VERSION = 0; + public const uint D3D11_SHIFT_INSTRUCTION_PAD_VALUE = 0; + public const uint D3D11_SHIFT_INSTRUCTION_SHIFT_VALUE_BIT_COUNT = 5; + public const uint D3D11_SIMULTANEOUS_RENDER_TARGET_COUNT = 8; + public const uint D3D11_SO_BUFFER_MAX_STRIDE_IN_BYTES = 2048; + public const uint D3D11_SO_BUFFER_MAX_WRITE_WINDOW_IN_BYTES = 512; + public const uint D3D11_SO_BUFFER_SLOT_COUNT = 4; + public const uint D3D11_SO_DDI_REGISTER_INDEX_DENOTING_GAP = 4294967295; + public const uint D3D11_SO_NO_RASTERIZED_STREAM = 4294967295; + public const uint D3D11_SO_OUTPUT_COMPONENT_COUNT = 128; + public const uint D3D11_SO_STREAM_COUNT = 4; + public const uint D3D11_SPEC_DATE_DAY = 16; + public const uint D3D11_SPEC_DATE_MONTH = 5; + public const uint D3D11_SPEC_DATE_YEAR = 2011; + public const double D3D11_SPEC_VERSION = 1.07; + public const float D3D11_SRGB_GAMMA = 2.2f; + public const float D3D11_SRGB_TO_FLOAT_DENOMINATOR_1 = 12.92f; + public const float D3D11_SRGB_TO_FLOAT_DENOMINATOR_2 = 1.055f; + public const float D3D11_SRGB_TO_FLOAT_EXPONENT = 2.4f; + public const float D3D11_SRGB_TO_FLOAT_OFFSET = 0.055f; + public const float D3D11_SRGB_TO_FLOAT_THRESHOLD = 0.04045f; + public const float D3D11_SRGB_TO_FLOAT_TOLERANCE_IN_ULP = 0.5f; + public const uint D3D11_STANDARD_COMPONENT_BIT_COUNT = 32; + public const uint D3D11_STANDARD_COMPONENT_BIT_COUNT_DOUBLED = 64; + public const uint D3D11_STANDARD_MAXIMUM_ELEMENT_ALIGNMENT_BYTE_MULTIPLE = 4; + public const uint D3D11_STANDARD_PIXEL_COMPONENT_COUNT = 128; + public const uint D3D11_STANDARD_PIXEL_ELEMENT_COUNT = 32; + public const uint D3D11_STANDARD_VECTOR_SIZE = 4; + public const uint D3D11_STANDARD_VERTEX_ELEMENT_COUNT = 32; + public const uint D3D11_STANDARD_VERTEX_TOTAL_COMPONENT_COUNT = 64; + public const uint D3D11_SUBPIXEL_FRACTIONAL_BIT_COUNT = 8; + public const uint D3D11_SUBTEXEL_FRACTIONAL_BIT_COUNT = 8; + public const uint D3D11_TESSELLATOR_MAX_EVEN_TESSELLATION_FACTOR = 64; + public const uint D3D11_TESSELLATOR_MAX_ISOLINE_DENSITY_TESSELLATION_FACTOR = 64; + public const uint D3D11_TESSELLATOR_MAX_ODD_TESSELLATION_FACTOR = 63; + public const uint D3D11_TESSELLATOR_MAX_TESSELLATION_FACTOR = 64; + public const uint D3D11_TESSELLATOR_MIN_EVEN_TESSELLATION_FACTOR = 2; + public const uint D3D11_TESSELLATOR_MIN_ISOLINE_DENSITY_TESSELLATION_FACTOR = 1; + public const uint D3D11_TESSELLATOR_MIN_ODD_TESSELLATION_FACTOR = 1; + public const uint D3D11_TEXEL_ADDRESS_RANGE_BIT_COUNT = 16; + public const uint D3D11_UNBOUND_MEMORY_ACCESS_RESULT = 0; + public const uint D3D11_VIEWPORT_AND_SCISSORRECT_MAX_INDEX = 15; + public const uint D3D11_VIEWPORT_AND_SCISSORRECT_OBJECT_COUNT_PER_PIPELINE = 16; + public const uint D3D11_VIEWPORT_BOUNDS_MAX = 32767; + public const int D3D11_VIEWPORT_BOUNDS_MIN = -32768; + public const uint D3D11_VS_INPUT_REGISTER_COMPONENTS = 4; + public const uint D3D11_VS_INPUT_REGISTER_COMPONENT_BIT_COUNT = 32; + public const uint D3D11_VS_INPUT_REGISTER_COUNT = 32; + public const uint D3D11_VS_INPUT_REGISTER_READS_PER_INST = 2; + public const uint D3D11_VS_INPUT_REGISTER_READ_PORTS = 1; + public const uint D3D11_VS_OUTPUT_REGISTER_COMPONENTS = 4; + public const uint D3D11_VS_OUTPUT_REGISTER_COMPONENT_BIT_COUNT = 32; + public const uint D3D11_VS_OUTPUT_REGISTER_COUNT = 32; + public const uint D3D11_WHQL_CONTEXT_COUNT_FOR_RESOURCE_LIMIT = 10; + public const uint D3D11_WHQL_DRAWINDEXED_INDEX_COUNT_2_TO_EXP = 25; + public const uint D3D11_WHQL_DRAW_VERTEX_COUNT_2_TO_EXP = 25; + public const uint D3D11_1_UAV_SLOT_COUNT = 64; + public const uint D3D11_2_TILED_RESOURCE_TILE_SIZE_IN_BYTES = 65536; + public const uint D3D11_4_VIDEO_DECODER_MAX_HISTOGRAM_COMPONENTS = 4; + public const uint D3D11_4_VIDEO_DECODER_HISTOGRAM_OFFSET_ALIGNMENT = 256; + public const uint _FACD3D11 = 2172; + public const uint D3D11_APPEND_ALIGNED_ELEMENT = 4294967295; + public const uint D3D11_FILTER_REDUCTION_TYPE_MASK = 3; + public const uint D3D11_FILTER_REDUCTION_TYPE_SHIFT = 7; + public const uint D3D11_FILTER_TYPE_MASK = 3; + public const uint D3D11_MIN_FILTER_SHIFT = 4; + public const uint D3D11_MAG_FILTER_SHIFT = 2; + public const uint D3D11_MIP_FILTER_SHIFT = 0; + public const uint D3D11_COMPARISON_FILTERING_BIT = 128; + public const uint D3D11_ANISOTROPIC_FILTERING_BIT = 64; + public static readonly Guid D3D11_DECODER_PROFILE_MPEG2_MOCOMP = new Guid(0xe6a9f44b, 0x61b0, 0x4563, 0x9e, 0xa4, 0x63, 0xd2, 0xa3, 0xc6, 0xfe, 0x66); + public static readonly Guid D3D11_DECODER_PROFILE_MPEG2_IDCT = new Guid(0xbf22ad00, 0x03ea, 0x4690, 0x80, 0x77, 0x47, 0x33, 0x46, 0x20, 0x9b, 0x7e); + public static readonly Guid D3D11_DECODER_PROFILE_MPEG2_VLD = new Guid(0xee27417f, 0x5e28, 0x4e65, 0xbe, 0xea, 0x1d, 0x26, 0xb5, 0x08, 0xad, 0xc9); + public static readonly Guid D3D11_DECODER_PROFILE_MPEG1_VLD = new Guid(0x6f3ec719, 0x3735, 0x42cc, 0x80, 0x63, 0x65, 0xcc, 0x3c, 0xb3, 0x66, 0x16); + public static readonly Guid D3D11_DECODER_PROFILE_MPEG2and1_VLD = new Guid(0x86695f12, 0x340e, 0x4f04, 0x9f, 0xd3, 0x92, 0x53, 0xdd, 0x32, 0x74, 0x60); + public static readonly Guid D3D11_DECODER_PROFILE_H264_MOCOMP_NOFGT = new Guid(0x1b81be64, 0xa0c7, 0x11d3, 0xb9, 0x84, 0x00, 0xc0, 0x4f, 0x2e, 0x73, 0xc5); + public static readonly Guid D3D11_DECODER_PROFILE_H264_MOCOMP_FGT = new Guid(0x1b81be65, 0xa0c7, 0x11d3, 0xb9, 0x84, 0x00, 0xc0, 0x4f, 0x2e, 0x73, 0xc5); + public static readonly Guid D3D11_DECODER_PROFILE_H264_IDCT_NOFGT = new Guid(0x1b81be66, 0xa0c7, 0x11d3, 0xb9, 0x84, 0x00, 0xc0, 0x4f, 0x2e, 0x73, 0xc5); + public static readonly Guid D3D11_DECODER_PROFILE_H264_IDCT_FGT = new Guid(0x1b81be67, 0xa0c7, 0x11d3, 0xb9, 0x84, 0x00, 0xc0, 0x4f, 0x2e, 0x73, 0xc5); + public static readonly Guid D3D11_DECODER_PROFILE_H264_VLD_NOFGT = new Guid(0x1b81be68, 0xa0c7, 0x11d3, 0xb9, 0x84, 0x00, 0xc0, 0x4f, 0x2e, 0x73, 0xc5); + public static readonly Guid D3D11_DECODER_PROFILE_H264_VLD_FGT = new Guid(0x1b81be69, 0xa0c7, 0x11d3, 0xb9, 0x84, 0x00, 0xc0, 0x4f, 0x2e, 0x73, 0xc5); + public static readonly Guid D3D11_DECODER_PROFILE_H264_VLD_WITHFMOASO_NOFGT = new Guid(0xd5f04ff9, 0x3418, 0x45d8, 0x95, 0x61, 0x32, 0xa7, 0x6a, 0xae, 0x2d, 0xdd); + public static readonly Guid D3D11_DECODER_PROFILE_H264_VLD_STEREO_PROGRESSIVE_NOFGT = new Guid(0xd79be8da, 0x0cf1, 0x4c81, 0xb8, 0x2a, 0x69, 0xa4, 0xe2, 0x36, 0xf4, 0x3d); + public static readonly Guid D3D11_DECODER_PROFILE_H264_VLD_STEREO_NOFGT = new Guid(0xf9aaccbb, 0xc2b6, 0x4cfc, 0x87, 0x79, 0x57, 0x07, 0xb1, 0x76, 0x05, 0x52); + public static readonly Guid D3D11_DECODER_PROFILE_H264_VLD_MULTIVIEW_NOFGT = new Guid(0x705b9d82, 0x76cf, 0x49d6, 0xb7, 0xe6, 0xac, 0x88, 0x72, 0xdb, 0x01, 0x3c); + public static readonly Guid D3D11_DECODER_PROFILE_WMV8_POSTPROC = new Guid(0x1b81be80, 0xa0c7, 0x11d3, 0xb9, 0x84, 0x00, 0xc0, 0x4f, 0x2e, 0x73, 0xc5); + public static readonly Guid D3D11_DECODER_PROFILE_WMV8_MOCOMP = new Guid(0x1b81be81, 0xa0c7, 0x11d3, 0xb9, 0x84, 0x00, 0xc0, 0x4f, 0x2e, 0x73, 0xc5); + public static readonly Guid D3D11_DECODER_PROFILE_WMV9_POSTPROC = new Guid(0x1b81be90, 0xa0c7, 0x11d3, 0xb9, 0x84, 0x00, 0xc0, 0x4f, 0x2e, 0x73, 0xc5); + public static readonly Guid D3D11_DECODER_PROFILE_WMV9_MOCOMP = new Guid(0x1b81be91, 0xa0c7, 0x11d3, 0xb9, 0x84, 0x00, 0xc0, 0x4f, 0x2e, 0x73, 0xc5); + public static readonly Guid D3D11_DECODER_PROFILE_WMV9_IDCT = new Guid(0x1b81be94, 0xa0c7, 0x11d3, 0xb9, 0x84, 0x00, 0xc0, 0x4f, 0x2e, 0x73, 0xc5); + public static readonly Guid D3D11_DECODER_PROFILE_VC1_POSTPROC = new Guid(0x1b81bea0, 0xa0c7, 0x11d3, 0xb9, 0x84, 0x00, 0xc0, 0x4f, 0x2e, 0x73, 0xc5); + public static readonly Guid D3D11_DECODER_PROFILE_VC1_MOCOMP = new Guid(0x1b81bea1, 0xa0c7, 0x11d3, 0xb9, 0x84, 0x00, 0xc0, 0x4f, 0x2e, 0x73, 0xc5); + public static readonly Guid D3D11_DECODER_PROFILE_VC1_IDCT = new Guid(0x1b81bea2, 0xa0c7, 0x11d3, 0xb9, 0x84, 0x00, 0xc0, 0x4f, 0x2e, 0x73, 0xc5); + public static readonly Guid D3D11_DECODER_PROFILE_VC1_VLD = new Guid(0x1b81bea3, 0xa0c7, 0x11d3, 0xb9, 0x84, 0x00, 0xc0, 0x4f, 0x2e, 0x73, 0xc5); + public static readonly Guid D3D11_DECODER_PROFILE_VC1_D2010 = new Guid(0x1b81bea4, 0xa0c7, 0x11d3, 0xb9, 0x84, 0x00, 0xc0, 0x4f, 0x2e, 0x73, 0xc5); + public static readonly Guid D3D11_DECODER_PROFILE_MPEG4PT2_VLD_SIMPLE = new Guid(0xefd64d74, 0xc9e8, 0x41d7, 0xa5, 0xe9, 0xe9, 0xb0, 0xe3, 0x9f, 0xa3, 0x19); + public static readonly Guid D3D11_DECODER_PROFILE_MPEG4PT2_VLD_ADVSIMPLE_NOGMC = new Guid(0xed418a9f, 0x010d, 0x4eda, 0x9a, 0xe3, 0x9a, 0x65, 0x35, 0x8d, 0x8d, 0x2e); + public static readonly Guid D3D11_DECODER_PROFILE_MPEG4PT2_VLD_ADVSIMPLE_GMC = new Guid(0xab998b5b, 0x4258, 0x44a9, 0x9f, 0xeb, 0x94, 0xe5, 0x97, 0xa6, 0xba, 0xae); + public static readonly Guid D3D11_DECODER_PROFILE_HEVC_VLD_MAIN = new Guid(0x5b11d51b, 0x2f4c, 0x4452, 0xbc, 0xc3, 0x09, 0xf2, 0xa1, 0x16, 0x0c, 0xc0); + public static readonly Guid D3D11_DECODER_PROFILE_HEVC_VLD_MAIN10 = new Guid(0x107af0e0, 0xef1a, 0x4d19, 0xab, 0xa8, 0x67, 0xa1, 0x63, 0x07, 0x3d, 0x13); + public static readonly Guid D3D11_DECODER_PROFILE_VP9_VLD_PROFILE0 = new Guid(0x463707f8, 0xa1d0, 0x4585, 0x87, 0x6d, 0x83, 0xaa, 0x6d, 0x60, 0xb8, 0x9e); + public static readonly Guid D3D11_DECODER_PROFILE_VP9_VLD_10BIT_PROFILE2 = new Guid(0xa4c749ef, 0x6ecf, 0x48aa, 0x84, 0x48, 0x50, 0xa7, 0xa1, 0x16, 0x5f, 0xf7); + public static readonly Guid D3D11_DECODER_PROFILE_VP8_VLD = new Guid(0x90b899ea, 0x3a62, 0x4705, 0x88, 0xb3, 0x8d, 0xf0, 0x4b, 0x27, 0x44, 0xe7); + public static readonly Guid D3D11_DECODER_PROFILE_AV1_VLD_PROFILE0 = new Guid(0xb8be4ccb, 0xcf53, 0x46ba, 0x8d, 0x59, 0xd6, 0xb8, 0xa6, 0xda, 0x5d, 0x2a); + public static readonly Guid D3D11_DECODER_PROFILE_AV1_VLD_PROFILE1 = new Guid(0x6936ff0f, 0x45b1, 0x4163, 0x9c, 0xc1, 0x64, 0x6e, 0xf6, 0x94, 0x61, 0x08); + public static readonly Guid D3D11_DECODER_PROFILE_AV1_VLD_PROFILE2 = new Guid(0x0c5f2aa1, 0xe541, 0x4089, 0xbb, 0x7b, 0x98, 0x11, 0x0a, 0x19, 0xd7, 0xc8); + public static readonly Guid D3D11_DECODER_PROFILE_AV1_VLD_12BIT_PROFILE2 = new Guid(0x17127009, 0xa00f, 0x4ce1, 0x99, 0x4e, 0xbf, 0x40, 0x81, 0xf6, 0xf3, 0xf0); + public static readonly Guid D3D11_DECODER_PROFILE_AV1_VLD_12BIT_PROFILE2_420 = new Guid(0x2d80bed6, 0x9cac, 0x4835, 0x9e, 0x91, 0x32, 0x7b, 0xbc, 0x4f, 0x9e, 0xe8); + public static readonly Guid D3D11_CRYPTO_TYPE_AES128_CTR = new Guid(0x9b6bd711, 0x4f74, 0x41c9, 0x9e, 0x7b, 0x0b, 0xe2, 0xd7, 0xd9, 0x3b, 0x4f); + public static readonly Guid D3D11_DECODER_ENCRYPTION_HW_CENC = new Guid(0x89d6ac4f, 0x09f2, 0x4229, 0xb2, 0xcd, 0x37, 0x74, 0x0a, 0x6d, 0xfd, 0x81); + public static readonly Guid D3D11_DECODER_BITSTREAM_ENCRYPTION_TYPE_CENC = new Guid(0xb0405235, 0xc13d, 0x44f2, 0x9a, 0xe5, 0xdd, 0x48, 0xe0, 0x8e, 0x5b, 0x67); + public static readonly Guid D3D11_DECODER_BITSTREAM_ENCRYPTION_TYPE_CBCS = new Guid(0x422d9319, 0x9d21, 0x4bb7, 0x93, 0x71, 0xfa, 0xf5, 0xa8, 0x2c, 0x3e, 0x04); + public static readonly Guid D3D11_KEY_EXCHANGE_HW_PROTECTION = new Guid(0xb1170d8a, 0x628d, 0x4da3, 0xad, 0x3b, 0x82, 0xdd, 0xb0, 0x8b, 0x49, 0x70); + public static readonly Guid D3D11_AUTHENTICATED_QUERY_PROTECTION = new Guid(0xa84eb584, 0xc495, 0x48aa, 0xb9, 0x4d, 0x8b, 0xd2, 0xd6, 0xfb, 0xce, 0x05); + public static readonly Guid D3D11_AUTHENTICATED_QUERY_CHANNEL_TYPE = new Guid(0xbc1b18a5, 0xb1fb, 0x42ab, 0xbd, 0x94, 0xb5, 0x82, 0x8b, 0x4b, 0xf7, 0xbe); + public static readonly Guid D3D11_AUTHENTICATED_QUERY_DEVICE_HANDLE = new Guid(0xec1c539d, 0x8cff, 0x4e2a, 0xbc, 0xc4, 0xf5, 0x69, 0x2f, 0x99, 0xf4, 0x80); + public static readonly Guid D3D11_AUTHENTICATED_QUERY_CRYPTO_SESSION = new Guid(0x2634499e, 0xd018, 0x4d74, 0xac, 0x17, 0x7f, 0x72, 0x40, 0x59, 0x52, 0x8d); + public static readonly Guid D3D11_AUTHENTICATED_QUERY_RESTRICTED_SHARED_RESOURCE_PROCESS_COUNT = new Guid(0x0db207b3, 0x9450, 0x46a6, 0x82, 0xde, 0x1b, 0x96, 0xd4, 0x4f, 0x9c, 0xf2); + public static readonly Guid D3D11_AUTHENTICATED_QUERY_RESTRICTED_SHARED_RESOURCE_PROCESS = new Guid(0x649bbadb, 0xf0f4, 0x4639, 0xa1, 0x5b, 0x24, 0x39, 0x3f, 0xc3, 0xab, 0xac); + public static readonly Guid D3D11_AUTHENTICATED_QUERY_UNRESTRICTED_PROTECTED_SHARED_RESOURCE_COUNT = new Guid(0x012f0bd6, 0xe662, 0x4474, 0xbe, 0xfd, 0xaa, 0x53, 0xe5, 0x14, 0x3c, 0x6d); + public static readonly Guid D3D11_AUTHENTICATED_QUERY_OUTPUT_ID_COUNT = new Guid(0x2c042b5e, 0x8c07, 0x46d5, 0xaa, 0xbe, 0x8f, 0x75, 0xcb, 0xad, 0x4c, 0x31); + public static readonly Guid D3D11_AUTHENTICATED_QUERY_OUTPUT_ID = new Guid(0x839ddca3, 0x9b4e, 0x41e4, 0xb0, 0x53, 0x89, 0x2b, 0xd2, 0xa1, 0x1e, 0xe7); + public static readonly Guid D3D11_AUTHENTICATED_QUERY_ACCESSIBILITY_ATTRIBUTES = new Guid(0x6214d9d2, 0x432c, 0x4abb, 0x9f, 0xce, 0x21, 0x6e, 0xea, 0x26, 0x9e, 0x3b); + public static readonly Guid D3D11_AUTHENTICATED_QUERY_ENCRYPTION_WHEN_ACCESSIBLE_GUID_COUNT = new Guid(0xb30f7066, 0x203c, 0x4b07, 0x93, 0xfc, 0xce, 0xaa, 0xfd, 0x61, 0x24, 0x1e); + public static readonly Guid D3D11_AUTHENTICATED_QUERY_ENCRYPTION_WHEN_ACCESSIBLE_GUID = new Guid(0xf83a5958, 0xe986, 0x4bda, 0xbe, 0xb0, 0x41, 0x1f, 0x6a, 0x7a, 0x01, 0xb7); + public static readonly Guid D3D11_AUTHENTICATED_QUERY_CURRENT_ENCRYPTION_WHEN_ACCESSIBLE = new Guid(0xec1791c7, 0xdad3, 0x4f15, 0x9e, 0xc3, 0xfa, 0xa9, 0x3d, 0x60, 0xd4, 0xf0); + public static readonly Guid D3D11_AUTHENTICATED_CONFIGURE_INITIALIZE = new Guid(0x06114bdb, 0x3523, 0x470a, 0x8d, 0xca, 0xfb, 0xc2, 0x84, 0x51, 0x54, 0xf0); + public static readonly Guid D3D11_AUTHENTICATED_CONFIGURE_PROTECTION = new Guid(0x50455658, 0x3f47, 0x4362, 0xbf, 0x99, 0xbf, 0xdf, 0xcd, 0xe9, 0xed, 0x29); + public static readonly Guid D3D11_AUTHENTICATED_CONFIGURE_CRYPTO_SESSION = new Guid(0x6346cc54, 0x2cfc, 0x4ad4, 0x82, 0x24, 0xd1, 0x58, 0x37, 0xde, 0x77, 0x00); + public static readonly Guid D3D11_AUTHENTICATED_CONFIGURE_SHARED_RESOURCE = new Guid(0x0772d047, 0x1b40, 0x48e8, 0x9c, 0xa6, 0xb5, 0xf5, 0x10, 0xde, 0x9f, 0x01); + public static readonly Guid D3D11_AUTHENTICATED_CONFIGURE_ENCRYPTION_WHEN_ACCESSIBLE = new Guid(0x41fff286, 0x6ae0, 0x4d43, 0x9d, 0x55, 0xa4, 0x6e, 0x9e, 0xfd, 0x15, 0x8a); + public static readonly Guid D3D11_KEY_EXCHANGE_RSAES_OAEP = new Guid(0xc1949895, 0xd72a, 0x4a1d, 0x8e, 0x5d, 0xed, 0x85, 0x7d, 0x17, 0x15, 0x20); + public const uint D3D11_SDK_VERSION = 7; + public const uint D3D11_PACKED_TILE = 4294967295; + public const uint D3D11_SDK_LAYERS_VERSION = 1; + public const uint D3D11_DEBUG_FEATURE_FLUSH_PER_RENDER_OP = 1; + public const uint D3D11_DEBUG_FEATURE_FINISH_PER_RENDER_OP = 2; + public const uint D3D11_DEBUG_FEATURE_PRESENT_PER_RENDER_OP = 4; + public const uint D3D11_DEBUG_FEATURE_ALWAYS_DISCARD_OFFERED_RESOURCE = 8; + public const uint D3D11_DEBUG_FEATURE_NEVER_DISCARD_OFFERED_RESOURCE = 16; + public const uint D3D11_DEBUG_FEATURE_AVOID_BEHAVIOR_CHANGING_DEBUG_AIDS = 64; + public const uint D3D11_DEBUG_FEATURE_DISABLE_TILED_RESOURCE_MAPPING_TRACKING_AND_VALIDATION = 128; + public static readonly Guid DXGI_DEBUG_D3D11 = new Guid(0x4b99317b, 0xac39, 0x4aa6, 0xbb, 0x0b, 0xba, 0xa0, 0x47, 0x84, 0x79, 0x8f); + public const uint D3D11_INFO_QUEUE_DEFAULT_MESSAGE_COUNT_LIMIT = 1024; + public const int D3D_RETURN_PARAMETER_INDEX = -1; + public const uint D3D_SHADER_REQUIRES_DOUBLES = 1; + public const uint D3D_SHADER_REQUIRES_EARLY_DEPTH_STENCIL = 2; + public const uint D3D_SHADER_REQUIRES_UAVS_AT_EVERY_STAGE = 4; + public const uint D3D_SHADER_REQUIRES_64_UAVS = 8; + public const uint D3D_SHADER_REQUIRES_MINIMUM_PRECISION = 16; + public const uint D3D_SHADER_REQUIRES_11_1_DOUBLE_EXTENSIONS = 32; + public const uint D3D_SHADER_REQUIRES_11_1_SHADER_EXTENSIONS = 64; + public const uint D3D_SHADER_REQUIRES_LEVEL_9_COMPARISON_FILTERING = 128; + public const uint D3D_SHADER_REQUIRES_TILED_RESOURCES = 256; + public const uint D3D11_TRACE_COMPONENT_X = 1; + public const uint D3D11_TRACE_COMPONENT_Y = 2; + public const uint D3D11_TRACE_COMPONENT_Z = 4; + public const uint D3D11_TRACE_COMPONENT_W = 8; + public const uint D3D11_SHADER_TRACE_FLAG_RECORD_REGISTER_WRITES = 1; + public const uint D3D11_SHADER_TRACE_FLAG_RECORD_REGISTER_READS = 2; + public const uint D3D11_TRACE_REGISTER_FLAGS_RELATIVE_INDEXING = 1; + public const uint D3D11_TRACE_MISC_GS_EMIT = 1; + public const uint D3D11_TRACE_MISC_GS_CUT = 2; + public const uint D3D11_TRACE_MISC_PS_DISCARD = 4; + public const uint D3D11_TRACE_MISC_GS_EMIT_STREAM = 8; + public const uint D3D11_TRACE_MISC_GS_CUT_STREAM = 16; + public const uint D3D11_TRACE_MISC_HALT = 32; + public const uint D3D11_TRACE_MISC_MESSAGE = 64; + public const uint D3DX11_FFT_MAX_PRECOMPUTE_BUFFERS = 4; + public const uint D3DX11_FFT_MAX_TEMP_BUFFERS = 4; + public const uint D3DX11_FFT_MAX_DIMENSIONS = 32; +} + +#region Enums +/// +/// D3D11_INPUT_CLASSIFICATION +public enum InputClassification : int +{ + /// + /// D3D11_INPUT_PER_VERTEX_DATA + PerVertexData = 0, + /// + /// D3D11_INPUT_PER_INSTANCE_DATA + PerInstanceData = 1, +} + +/// +/// D3D11_FILL_MODE +public enum FillMode : int +{ + /// + /// D3D11_FILL_WIREFRAME + Wireframe = 2, + /// + /// D3D11_FILL_SOLID + Solid = 3, +} + +/// +/// D3D11_CULL_MODE +public enum CullMode : int +{ + /// + /// D3D11_CULL_NONE + None = 1, + /// + /// D3D11_CULL_FRONT + Front = 2, + /// + /// D3D11_CULL_BACK + Back = 3, +} + +/// +/// D3D11_RESOURCE_DIMENSION +public enum ResourceDimension : int +{ + /// + /// D3D11_RESOURCE_DIMENSION_UNKNOWN + Unknown = 0, + /// + /// D3D11_RESOURCE_DIMENSION_BUFFER + Buffer = 1, + /// + /// D3D11_RESOURCE_DIMENSION_TEXTURE1D + Texture1D = 2, + /// + /// D3D11_RESOURCE_DIMENSION_TEXTURE2D + Texture2D = 3, + /// + /// D3D11_RESOURCE_DIMENSION_TEXTURE3D + Texture3D = 4, +} + +/// +/// D3D11_DSV_DIMENSION +public enum DsvDimension : int +{ + /// + /// D3D11_DSV_DIMENSION_UNKNOWN + Unknown = 0, + /// + /// D3D11_DSV_DIMENSION_TEXTURE1D + Texture1D = 1, + /// + /// D3D11_DSV_DIMENSION_TEXTURE1DARRAY + Texture1DArray = 2, + /// + /// D3D11_DSV_DIMENSION_TEXTURE2D + Texture2D = 3, + /// + /// D3D11_DSV_DIMENSION_TEXTURE2DARRAY + Texture2DArray = 4, + /// + /// D3D11_DSV_DIMENSION_TEXTURE2DMS + Texture2DMs = 5, + /// + /// D3D11_DSV_DIMENSION_TEXTURE2DMSARRAY + Texture2DMsArray = 6, +} + +/// +/// D3D11_RTV_DIMENSION +public enum RtvDimension : int +{ + /// + /// D3D11_RTV_DIMENSION_UNKNOWN + Unknown = 0, + /// + /// D3D11_RTV_DIMENSION_BUFFER + Buffer = 1, + /// + /// D3D11_RTV_DIMENSION_TEXTURE1D + Texture1D = 2, + /// + /// D3D11_RTV_DIMENSION_TEXTURE1DARRAY + Texture1DArray = 3, + /// + /// D3D11_RTV_DIMENSION_TEXTURE2D + Texture2D = 4, + /// + /// D3D11_RTV_DIMENSION_TEXTURE2DARRAY + Texture2DArray = 5, + /// + /// D3D11_RTV_DIMENSION_TEXTURE2DMS + Texture2DMs = 6, + /// + /// D3D11_RTV_DIMENSION_TEXTURE2DMSARRAY + Texture2DMsArray = 7, + /// + /// D3D11_RTV_DIMENSION_TEXTURE3D + Texture3D = 8, +} + +/// +/// D3D11_UAV_DIMENSION +public enum UavDimension : int +{ + /// + /// D3D11_UAV_DIMENSION_UNKNOWN + Unknown = 0, + /// + /// D3D11_UAV_DIMENSION_BUFFER + Buffer = 1, + /// + /// D3D11_UAV_DIMENSION_TEXTURE1D + Texture1D = 2, + /// + /// D3D11_UAV_DIMENSION_TEXTURE1DARRAY + Texture1DArray = 3, + /// + /// D3D11_UAV_DIMENSION_TEXTURE2D + Texture2D = 4, + /// + /// D3D11_UAV_DIMENSION_TEXTURE2DARRAY + Texture2DArray = 5, + /// + /// D3D11_UAV_DIMENSION_TEXTURE3D + Texture3D = 8, +} + +/// +/// D3D11_USAGE +public enum Usage : int +{ + /// + /// D3D11_USAGE_DEFAULT + Default = 0, + /// + /// D3D11_USAGE_IMMUTABLE + Immutable = 1, + /// + /// D3D11_USAGE_DYNAMIC + Dynamic = 2, + /// + /// D3D11_USAGE_STAGING + Staging = 3, +} + +/// +/// D3D11_BIND_FLAG +[Flags] +public enum BindFlag : uint +{ + None = 0, + /// + /// D3D11_BIND_VERTEX_BUFFER + VertexBuffer = 1, + /// + /// D3D11_BIND_INDEX_BUFFER + IndexBuffer = 2, + /// + /// D3D11_BIND_CONSTANT_BUFFER + ConstantBuffer = 4, + /// + /// D3D11_BIND_SHADER_RESOURCE + ShaderResource = 8, + /// + /// D3D11_BIND_STREAM_OUTPUT + StreamOutput = 16, + /// + /// D3D11_BIND_RENDER_TARGET + RenderTarget = 32, + /// + /// D3D11_BIND_DEPTH_STENCIL + DepthStencil = 64, + /// + /// D3D11_BIND_UNORDERED_ACCESS + UnorderedAccess = 128, + /// + /// D3D11_BIND_DECODER + Decoder = 512, + /// + /// D3D11_BIND_VIDEO_ENCODER + VideoEncoder = 1024, +} + +/// +/// D3D11_CPU_ACCESS_FLAG +[Flags] +public enum CpuAccessFlag : uint +{ + None = 0, + /// + /// D3D11_CPU_ACCESS_WRITE + Write = 65536, + /// + /// D3D11_CPU_ACCESS_READ + Read = 131072, +} + +/// +/// D3D11_RESOURCE_MISC_FLAG +[Flags] +public enum ResourceMiscFlag : uint +{ + None = 0, + /// + /// D3D11_RESOURCE_MISC_GENERATE_MIPS + GenerateMips = 1, + /// + /// D3D11_RESOURCE_MISC_SHARED + Shared = 2, + /// + /// D3D11_RESOURCE_MISC_TEXTURECUBE + TextureCube = 4, + /// + /// D3D11_RESOURCE_MISC_DRAWINDIRECT_ARGS + DrawindirectArgs = 16, + /// + /// D3D11_RESOURCE_MISC_BUFFER_ALLOW_RAW_VIEWS + BufferAllowRawViews = 32, + /// + /// D3D11_RESOURCE_MISC_BUFFER_STRUCTURED + BufferStructured = 64, + /// + /// D3D11_RESOURCE_MISC_RESOURCE_CLAMP + ResourceClamp = 128, + /// + /// D3D11_RESOURCE_MISC_SHARED_KEYEDMUTEX + SharedKeyedMutex = 256, + /// + /// D3D11_RESOURCE_MISC_GDI_COMPATIBLE + GDICompatible = 512, + /// + /// D3D11_RESOURCE_MISC_SHARED_NTHANDLE + SharedNthandle = 2048, + /// + /// D3D11_RESOURCE_MISC_RESTRICTED_CONTENT + RestrictedContent = 4096, + /// + /// D3D11_RESOURCE_MISC_RESTRICT_SHARED_RESOURCE + RestrictSharedResource = 8192, + /// + /// D3D11_RESOURCE_MISC_RESTRICT_SHARED_RESOURCE_DRIVER + RestrictSharedResourceDriver = 16384, + /// + /// D3D11_RESOURCE_MISC_GUARDED + Guarded = 32768, + /// + /// D3D11_RESOURCE_MISC_TILE_POOL + TilePool = 131072, + /// + /// D3D11_RESOURCE_MISC_TILED + Tiled = 262144, + /// + /// D3D11_RESOURCE_MISC_HW_PROTECTED + HWProtected = 524288, + /// + /// D3D11_RESOURCE_MISC_SHARED_DISPLAYABLE + SharedDisplayable = 1048576, + /// + /// D3D11_RESOURCE_MISC_SHARED_EXCLUSIVE_WRITER + SharedExclusiveWriter = 2097152, +} + +/// +/// D3D11_MAP +public enum Map : int +{ + /// + /// D3D11_MAP_READ + Read = 1, + /// + /// D3D11_MAP_WRITE + Write = 2, + /// + /// D3D11_MAP_READ_WRITE + ReadWrite = 3, + /// + /// D3D11_MAP_WRITE_DISCARD + WriteDiscard = 4, + /// + /// D3D11_MAP_WRITE_NO_OVERWRITE + WriteNoOverwrite = 5, +} + +/// +/// D3D11_MAP_FLAG +[Flags] +public enum MapFlag : int +{ + None = 0, + /// + /// D3D11_MAP_FLAG_DO_NOT_WAIT + DoNotWait = 1048576, +} + +/// +/// D3D11_RAISE_FLAG +[Flags] +public enum RaiseFlag : int +{ + None = 0, + /// + /// D3D11_RAISE_FLAG_DRIVER_INTERNAL_ERROR + DriverInternalError = 1, +} + +/// +/// D3D11_CLEAR_FLAG +[Flags] +public enum ClearFlag : int +{ + None = 0, + /// + /// D3D11_CLEAR_DEPTH + D3D11_CLEAR_DEPTH = 1, + /// + /// D3D11_CLEAR_STENCIL + D3D11_CLEAR_STENCIL = 2, +} + +/// +/// D3D11_COMPARISON_FUNC +public enum ComparisonFunc : int +{ + /// + /// D3D11_COMPARISON_NEVER + D3D11_COMPARISON_NEVER = 1, + /// + /// D3D11_COMPARISON_LESS + D3D11_COMPARISON_LESS = 2, + /// + /// D3D11_COMPARISON_EQUAL + D3D11_COMPARISON_EQUAL = 3, + /// + /// D3D11_COMPARISON_LESS_EQUAL + D3D11_COMPARISON_LESS_EQUAL = 4, + /// + /// D3D11_COMPARISON_GREATER + D3D11_COMPARISON_GREATER = 5, + /// + /// D3D11_COMPARISON_NOT_EQUAL + D3D11_COMPARISON_NOT_EQUAL = 6, + /// + /// D3D11_COMPARISON_GREATER_EQUAL + D3D11_COMPARISON_GREATER_EQUAL = 7, + /// + /// D3D11_COMPARISON_ALWAYS + D3D11_COMPARISON_ALWAYS = 8, +} + +/// +/// D3D11_DEPTH_WRITE_MASK +public enum DepthWriteMask : int +{ + /// + /// D3D11_DEPTH_WRITE_MASK_ZERO + Zero = 0, + /// + /// D3D11_DEPTH_WRITE_MASK_ALL + All = 1, +} + +/// +/// D3D11_STENCIL_OP +public enum StencilOp : int +{ + /// + /// D3D11_STENCIL_OP_KEEP + Keep = 1, + /// + /// D3D11_STENCIL_OP_ZERO + Zero = 2, + /// + /// D3D11_STENCIL_OP_REPLACE + Replace = 3, + /// + /// D3D11_STENCIL_OP_INCR_SAT + IncrSat = 4, + /// + /// D3D11_STENCIL_OP_DECR_SAT + DecrSat = 5, + /// + /// D3D11_STENCIL_OP_INVERT + Invert = 6, + /// + /// D3D11_STENCIL_OP_INCR + Incr = 7, + /// + /// D3D11_STENCIL_OP_DECR + Decr = 8, +} + +/// +/// D3D11_BLEND +public enum Blend : int +{ + /// + /// D3D11_BLEND_ZERO + Zero = 1, + /// + /// D3D11_BLEND_ONE + One = 2, + /// + /// D3D11_BLEND_SRC_COLOR + SrcColor = 3, + /// + /// D3D11_BLEND_INV_SRC_COLOR + InvSrcColor = 4, + /// + /// D3D11_BLEND_SRC_ALPHA + SrcAlpha = 5, + /// + /// D3D11_BLEND_INV_SRC_ALPHA + InvSrcAlpha = 6, + /// + /// D3D11_BLEND_DEST_ALPHA + DestAlpha = 7, + /// + /// D3D11_BLEND_INV_DEST_ALPHA + InvDestAlpha = 8, + /// + /// D3D11_BLEND_DEST_COLOR + DestColor = 9, + /// + /// D3D11_BLEND_INV_DEST_COLOR + InvDestColor = 10, + /// + /// D3D11_BLEND_SRC_ALPHA_SAT + SrcAlphaSat = 11, + /// + /// D3D11_BLEND_BLEND_FACTOR + BlendFactor = 14, + /// + /// D3D11_BLEND_INV_BLEND_FACTOR + InvBlendFactor = 15, + /// + /// D3D11_BLEND_SRC1_COLOR + Src1Color = 16, + /// + /// D3D11_BLEND_INV_SRC1_COLOR + InvSrc1Color = 17, + /// + /// D3D11_BLEND_SRC1_ALPHA + Src1Alpha = 18, + /// + /// D3D11_BLEND_INV_SRC1_ALPHA + InvSrc1Alpha = 19, +} + +/// +/// D3D11_BLEND_OP +public enum BlendOp : int +{ + /// + /// D3D11_BLEND_OP_ADD + Add = 1, + /// + /// D3D11_BLEND_OP_SUBTRACT + Subtract = 2, + /// + /// D3D11_BLEND_OP_REV_SUBTRACT + RevSubtract = 3, + /// + /// D3D11_BLEND_OP_MIN + Min = 4, + /// + /// D3D11_BLEND_OP_MAX + Max = 5, +} + +/// +/// D3D11_COLOR_WRITE_ENABLE +public enum ColorWriteEnable : int +{ + /// + /// D3D11_COLOR_WRITE_ENABLE_RED + Red = 1, + /// + /// D3D11_COLOR_WRITE_ENABLE_GREEN + Green = 2, + /// + /// D3D11_COLOR_WRITE_ENABLE_BLUE + Blue = 4, + /// + /// D3D11_COLOR_WRITE_ENABLE_ALPHA + Alpha = 8, + /// + /// D3D11_COLOR_WRITE_ENABLE_ALL + All = 15, +} + +/// +/// D3D11_TEXTURECUBE_FACE +public enum TextureCubeFace : int +{ + /// + /// D3D11_TEXTURECUBE_FACE_POSITIVE_X + PositiveX = 0, + /// + /// D3D11_TEXTURECUBE_FACE_NEGATIVE_X + NegativeX = 1, + /// + /// D3D11_TEXTURECUBE_FACE_POSITIVE_Y + PositiveY = 2, + /// + /// D3D11_TEXTURECUBE_FACE_NEGATIVE_Y + NegativeY = 3, + /// + /// D3D11_TEXTURECUBE_FACE_POSITIVE_Z + PositiveZ = 4, + /// + /// D3D11_TEXTURECUBE_FACE_NEGATIVE_Z + NegativeZ = 5, +} + +/// +/// D3D11_BUFFEREX_SRV_FLAG +[Flags] +public enum BufferExtendedSrvFlag : int +{ + None = 0, + /// + /// D3D11_BUFFEREX_SRV_FLAG_RAW + Raw = 1, +} + +/// +/// D3D11_DSV_FLAG +[Flags] +public enum DsvFlag : int +{ + None = 0, + /// + /// D3D11_DSV_READ_ONLY_DEPTH + D3D11_DSV_READ_ONLY_DEPTH = 1, + /// + /// D3D11_DSV_READ_ONLY_STENCIL + D3D11_DSV_READ_ONLY_STENCIL = 2, +} + +/// +/// D3D11_BUFFER_UAV_FLAG +[Flags] +public enum BufferUavFlag : int +{ + None = 0, + /// + /// D3D11_BUFFER_UAV_FLAG_RAW + Raw = 1, + /// + /// D3D11_BUFFER_UAV_FLAG_APPEND + Append = 2, + /// + /// D3D11_BUFFER_UAV_FLAG_COUNTER + Counter = 4, +} + +/// +/// D3D11_FILTER +public enum Filter : int +{ + /// + /// D3D11_FILTER_MIN_MAG_MIP_POINT + MinMagMipPoint = 0, + /// + /// D3D11_FILTER_MIN_MAG_POINT_MIP_LINEAR + MinMagPointMipLinear = 1, + /// + /// D3D11_FILTER_MIN_POINT_MAG_LINEAR_MIP_POINT + MinPointMagLinearMipPoint = 4, + /// + /// D3D11_FILTER_MIN_POINT_MAG_MIP_LINEAR + MinPointMagMipLinear = 5, + /// + /// D3D11_FILTER_MIN_LINEAR_MAG_MIP_POINT + MinLinearMagMipPoint = 16, + /// + /// D3D11_FILTER_MIN_LINEAR_MAG_POINT_MIP_LINEAR + MinLinearMagPointMipLinear = 17, + /// + /// D3D11_FILTER_MIN_MAG_LINEAR_MIP_POINT + MinMagLinearMipPoint = 20, + /// + /// D3D11_FILTER_MIN_MAG_MIP_LINEAR + MinMagMipLinear = 21, + /// + /// D3D11_FILTER_ANISOTROPIC + Anisotropic = 85, + /// + /// D3D11_FILTER_COMPARISON_MIN_MAG_MIP_POINT + ComparisonMinMagMipPoint = 128, + /// + /// D3D11_FILTER_COMPARISON_MIN_MAG_POINT_MIP_LINEAR + ComparisonMinMagPointMipLinear = 129, + /// + /// D3D11_FILTER_COMPARISON_MIN_POINT_MAG_LINEAR_MIP_POINT + ComparisonMinPointMagLinearMipPoint = 132, + /// + /// D3D11_FILTER_COMPARISON_MIN_POINT_MAG_MIP_LINEAR + ComparisonMinPointMagMipLinear = 133, + /// + /// D3D11_FILTER_COMPARISON_MIN_LINEAR_MAG_MIP_POINT + ComparisonMinLinearMagMipPoint = 144, + /// + /// D3D11_FILTER_COMPARISON_MIN_LINEAR_MAG_POINT_MIP_LINEAR + ComparisonMinLinearMagPointMipLinear = 145, + /// + /// D3D11_FILTER_COMPARISON_MIN_MAG_LINEAR_MIP_POINT + ComparisonMinMagLinearMipPoint = 148, + /// + /// D3D11_FILTER_COMPARISON_MIN_MAG_MIP_LINEAR + ComparisonMinMagMipLinear = 149, + /// + /// D3D11_FILTER_COMPARISON_ANISOTROPIC + ComparisonAnisotropic = 213, + /// + /// D3D11_FILTER_MINIMUM_MIN_MAG_MIP_POINT + MinimumMinMagMipPoint = 256, + /// + /// D3D11_FILTER_MINIMUM_MIN_MAG_POINT_MIP_LINEAR + MinimumMinMagPointMipLinear = 257, + /// + /// D3D11_FILTER_MINIMUM_MIN_POINT_MAG_LINEAR_MIP_POINT + MinimumMinPointMagLinearMipPoint = 260, + /// + /// D3D11_FILTER_MINIMUM_MIN_POINT_MAG_MIP_LINEAR + MinimumMinPointMagMipLinear = 261, + /// + /// D3D11_FILTER_MINIMUM_MIN_LINEAR_MAG_MIP_POINT + MinimumMinLinearMagMipPoint = 272, + /// + /// D3D11_FILTER_MINIMUM_MIN_LINEAR_MAG_POINT_MIP_LINEAR + MinimumMinLinearMagPointMipLinear = 273, + /// + /// D3D11_FILTER_MINIMUM_MIN_MAG_LINEAR_MIP_POINT + MinimumMinMagLinearMipPoint = 276, + /// + /// D3D11_FILTER_MINIMUM_MIN_MAG_MIP_LINEAR + MinimumMinMagMipLinear = 277, + /// + /// D3D11_FILTER_MINIMUM_ANISOTROPIC + MinimumAnisotropic = 341, + /// + /// D3D11_FILTER_MAXIMUM_MIN_MAG_MIP_POINT + MaximumMinMagMipPoint = 384, + /// + /// D3D11_FILTER_MAXIMUM_MIN_MAG_POINT_MIP_LINEAR + MaximumMinMagPointMipLinear = 385, + /// + /// D3D11_FILTER_MAXIMUM_MIN_POINT_MAG_LINEAR_MIP_POINT + MaximumMinPointMagLinearMipPoint = 388, + /// + /// D3D11_FILTER_MAXIMUM_MIN_POINT_MAG_MIP_LINEAR + MaximumMinPointMagMipLinear = 389, + /// + /// D3D11_FILTER_MAXIMUM_MIN_LINEAR_MAG_MIP_POINT + MaximumMinLinearMagMipPoint = 400, + /// + /// D3D11_FILTER_MAXIMUM_MIN_LINEAR_MAG_POINT_MIP_LINEAR + MaximumMinLinearMagPointMipLinear = 401, + /// + /// D3D11_FILTER_MAXIMUM_MIN_MAG_LINEAR_MIP_POINT + MaximumMinMagLinearMipPoint = 404, + /// + /// D3D11_FILTER_MAXIMUM_MIN_MAG_MIP_LINEAR + MaximumMinMagMipLinear = 405, + /// + /// D3D11_FILTER_MAXIMUM_ANISOTROPIC + MaximumAnisotropic = 469, +} + +/// +/// D3D11_FILTER_TYPE +public enum FilterType : int +{ + /// + /// D3D11_FILTER_TYPE_POINT + Point = 0, + /// + /// D3D11_FILTER_TYPE_LINEAR + Linear = 1, +} + +/// +/// D3D11_FILTER_REDUCTION_TYPE +public enum FilterReductionType : int +{ + /// + /// D3D11_FILTER_REDUCTION_TYPE_STANDARD + Standard = 0, + /// + /// D3D11_FILTER_REDUCTION_TYPE_COMPARISON + Comparison = 1, + /// + /// D3D11_FILTER_REDUCTION_TYPE_MINIMUM + Minimum = 2, + /// + /// D3D11_FILTER_REDUCTION_TYPE_MAXIMUM + Maximum = 3, +} + +/// +/// D3D11_TEXTURE_ADDRESS_MODE +public enum TextureAddressMode : int +{ + /// + /// D3D11_TEXTURE_ADDRESS_WRAP + D3D11_TEXTURE_ADDRESS_WRAP = 1, + /// + /// D3D11_TEXTURE_ADDRESS_MIRROR + D3D11_TEXTURE_ADDRESS_MIRROR = 2, + /// + /// D3D11_TEXTURE_ADDRESS_CLAMP + D3D11_TEXTURE_ADDRESS_CLAMP = 3, + /// + /// D3D11_TEXTURE_ADDRESS_BORDER + D3D11_TEXTURE_ADDRESS_BORDER = 4, + /// + /// D3D11_TEXTURE_ADDRESS_MIRROR_ONCE + D3D11_TEXTURE_ADDRESS_MIRROR_ONCE = 5, +} + +/// +/// D3D11_FORMAT_SUPPORT +public enum FormatSupport : int +{ + /// + /// D3D11_FORMAT_SUPPORT_BUFFER + Buffer = 1, + /// + /// D3D11_FORMAT_SUPPORT_IA_VERTEX_BUFFER + IaVertexBuffer = 2, + /// + /// D3D11_FORMAT_SUPPORT_IA_INDEX_BUFFER + IaIndexBuffer = 4, + /// + /// D3D11_FORMAT_SUPPORT_SO_BUFFER + SoBuffer = 8, + /// + /// D3D11_FORMAT_SUPPORT_TEXTURE1D + Texture1D = 16, + /// + /// D3D11_FORMAT_SUPPORT_TEXTURE2D + Texture2D = 32, + /// + /// D3D11_FORMAT_SUPPORT_TEXTURE3D + Texture3D = 64, + /// + /// D3D11_FORMAT_SUPPORT_TEXTURECUBE + TextureCube = 128, + /// + /// D3D11_FORMAT_SUPPORT_SHADER_LOAD + ShaderLoad = 256, + /// + /// D3D11_FORMAT_SUPPORT_SHADER_SAMPLE + ShaderSample = 512, + /// + /// D3D11_FORMAT_SUPPORT_SHADER_SAMPLE_COMPARISON + ShaderSampleComparison = 1024, + /// + /// D3D11_FORMAT_SUPPORT_SHADER_SAMPLE_MONO_TEXT + ShaderSampleMonoText = 2048, + /// + /// D3D11_FORMAT_SUPPORT_MIP + Mip = 4096, + /// + /// D3D11_FORMAT_SUPPORT_MIP_AUTOGEN + MipAutogen = 8192, + /// + /// D3D11_FORMAT_SUPPORT_RENDER_TARGET + RenderTarget = 16384, + /// + /// D3D11_FORMAT_SUPPORT_BLENDABLE + Blendable = 32768, + /// + /// D3D11_FORMAT_SUPPORT_DEPTH_STENCIL + DepthStencil = 65536, + /// + /// D3D11_FORMAT_SUPPORT_CPU_LOCKABLE + CpuLockable = 131072, + /// + /// D3D11_FORMAT_SUPPORT_MULTISAMPLE_RESOLVE + MultisampleResolve = 262144, + /// + /// D3D11_FORMAT_SUPPORT_DISPLAY + Display = 524288, + /// + /// D3D11_FORMAT_SUPPORT_CAST_WITHIN_BIT_LAYOUT + CastWithinBitLayout = 1048576, + /// + /// D3D11_FORMAT_SUPPORT_MULTISAMPLE_RENDERTARGET + MultisampleRendertarget = 2097152, + /// + /// D3D11_FORMAT_SUPPORT_MULTISAMPLE_LOAD + MultisampleLoad = 4194304, + /// + /// D3D11_FORMAT_SUPPORT_SHADER_GATHER + ShaderGather = 8388608, + /// + /// D3D11_FORMAT_SUPPORT_BACK_BUFFER_CAST + BackBufferCast = 16777216, + /// + /// D3D11_FORMAT_SUPPORT_TYPED_UNORDERED_ACCESS_VIEW + TypedUnorderedAccessView = 33554432, + /// + /// D3D11_FORMAT_SUPPORT_SHADER_GATHER_COMPARISON + ShaderGatherComparison = 67108864, + /// + /// D3D11_FORMAT_SUPPORT_DECODER_OUTPUT + DecoderOutput = 134217728, + /// + /// D3D11_FORMAT_SUPPORT_VIDEO_PROCESSOR_OUTPUT + VideoProcessorOutput = 268435456, + /// + /// D3D11_FORMAT_SUPPORT_VIDEO_PROCESSOR_INPUT + VideoProcessorInput = 536870912, + /// + /// D3D11_FORMAT_SUPPORT_VIDEO_ENCODER + VideoEncoder = 1073741824, +} + +/// +/// D3D11_FORMAT_SUPPORT2 +public enum FormatSupport2 : int +{ + /// + /// D3D11_FORMAT_SUPPORT2_UAV_ATOMIC_ADD + UavAtomicAdd = 1, + /// + /// D3D11_FORMAT_SUPPORT2_UAV_ATOMIC_BITWISE_OPS + UavAtomicBitwiseOps = 2, + /// + /// D3D11_FORMAT_SUPPORT2_UAV_ATOMIC_COMPARE_STORE_OR_COMPARE_EXCHANGE + UavAtomicCompareStoreOrCompareExchange = 4, + /// + /// D3D11_FORMAT_SUPPORT2_UAV_ATOMIC_EXCHANGE + UavAtomicExchange = 8, + /// + /// D3D11_FORMAT_SUPPORT2_UAV_ATOMIC_SIGNED_MIN_OR_MAX + UavAtomicSignedMinOrMax = 16, + /// + /// D3D11_FORMAT_SUPPORT2_UAV_ATOMIC_UNSIGNED_MIN_OR_MAX + UavAtomicUnsignedMinOrMax = 32, + /// + /// D3D11_FORMAT_SUPPORT2_UAV_TYPED_LOAD + UavTypedLoad = 64, + /// + /// D3D11_FORMAT_SUPPORT2_UAV_TYPED_STORE + UavTypedStore = 128, + /// + /// D3D11_FORMAT_SUPPORT2_OUTPUT_MERGER_LOGIC_OP + OutputMergerLogicOp = 256, + /// + /// D3D11_FORMAT_SUPPORT2_TILED + Tiled = 512, + /// + /// D3D11_FORMAT_SUPPORT2_SHAREABLE + Shareable = 1024, + /// + /// D3D11_FORMAT_SUPPORT2_MULTIPLANE_OVERLAY + MultiplaneOverlay = 16384, +} + +/// +/// D3D11_ASYNC_GETDATA_FLAG +[Flags] +public enum AsyncGetdataFlag : int +{ + None = 0, + /// + /// D3D11_ASYNC_GETDATA_DONOTFLUSH + D3D11_ASYNC_GETDATA_DONOTFLUSH = 1, +} + +/// +/// D3D11_QUERY +public enum Query : int +{ + /// + /// D3D11_QUERY_EVENT + Event = 0, + /// + /// D3D11_QUERY_OCCLUSION + Occlusion = 1, + /// + /// D3D11_QUERY_TIMESTAMP + Timestamp = 2, + /// + /// D3D11_QUERY_TIMESTAMP_DISJOINT + TimestampDisjoint = 3, + /// + /// D3D11_QUERY_PIPELINE_STATISTICS + PipelineStatistics = 4, + /// + /// D3D11_QUERY_OCCLUSION_PREDICATE + OcclusionPredicate = 5, + /// + /// D3D11_QUERY_SO_STATISTICS + SoStatistics = 6, + /// + /// D3D11_QUERY_SO_OVERFLOW_PREDICATE + SoOverflowPredicate = 7, + /// + /// D3D11_QUERY_SO_STATISTICS_STREAM0 + SoStatisticsStream0 = 8, + /// + /// D3D11_QUERY_SO_OVERFLOW_PREDICATE_STREAM0 + SoOverflowPredicateStream0 = 9, + /// + /// D3D11_QUERY_SO_STATISTICS_STREAM1 + SoStatisticsStream1 = 10, + /// + /// D3D11_QUERY_SO_OVERFLOW_PREDICATE_STREAM1 + SoOverflowPredicateStream1 = 11, + /// + /// D3D11_QUERY_SO_STATISTICS_STREAM2 + SoStatisticsStream2 = 12, + /// + /// D3D11_QUERY_SO_OVERFLOW_PREDICATE_STREAM2 + SoOverflowPredicateStream2 = 13, + /// + /// D3D11_QUERY_SO_STATISTICS_STREAM3 + SoStatisticsStream3 = 14, + /// + /// D3D11_QUERY_SO_OVERFLOW_PREDICATE_STREAM3 + SoOverflowPredicateStream3 = 15, +} + +/// +/// D3D11_QUERY_MISC_FLAG +[Flags] +public enum QueryMiscFlag : int +{ + None = 0, + /// + /// D3D11_QUERY_MISC_PREDICATEHINT + D3D11_QUERY_MISC_PREDICATEHINT = 1, +} + +/// +/// D3D11_COUNTER +public enum Counter : int +{ + /// + /// D3D11_COUNTER_DEVICE_DEPENDENT_0 + DeviceDependent0 = 1073741824, +} + +/// +/// D3D11_COUNTER_TYPE +public enum CounterType : int +{ + /// + /// D3D11_COUNTER_TYPE_FLOAT32 + Float32 = 0, + /// + /// D3D11_COUNTER_TYPE_UINT16 + Uint16 = 1, + /// + /// D3D11_COUNTER_TYPE_UINT32 + Uint32 = 2, + /// + /// D3D11_COUNTER_TYPE_UINT64 + Uint64 = 3, +} + +/// +/// D3D11_STANDARD_MULTISAMPLE_QUALITY_LEVELS +public enum StandardMultisampleQualityLevels : int +{ + /// + /// D3D11_STANDARD_MULTISAMPLE_PATTERN + D3D11_STANDARD_MULTISAMPLE_PATTERN = -1, + /// + /// D3D11_CENTER_MULTISAMPLE_PATTERN + D3D11_CENTER_MULTISAMPLE_PATTERN = -2, +} + +/// +/// D3D11_DEVICE_CONTEXT_TYPE +public enum DeviceContextType : int +{ + /// + /// D3D11_DEVICE_CONTEXT_IMMEDIATE + D3D11_DEVICE_CONTEXT_IMMEDIATE = 0, + /// + /// D3D11_DEVICE_CONTEXT_DEFERRED + D3D11_DEVICE_CONTEXT_DEFERRED = 1, +} + +/// +/// D3D11_FEATURE +public enum Feature : int +{ + /// + /// D3D11_FEATURE_THREADING + Threading = 0, + /// + /// D3D11_FEATURE_DOUBLES + Doubles = 1, + /// + /// D3D11_FEATURE_FORMAT_SUPPORT + FormatSupport = 2, + /// + /// D3D11_FEATURE_FORMAT_SUPPORT2 + FormatSupport2 = 3, + /// + /// D3D11_FEATURE_D3D10_X_HARDWARE_OPTIONS + XHardwareOptions = 4, + /// + /// D3D11_FEATURE_D3D11_OPTIONS + Options = 5, + /// + /// D3D11_FEATURE_ARCHITECTURE_INFO + ArchitectureInfo = 6, + /// + /// D3D11_FEATURE_D3D9_OPTIONS + D3d9Options = 7, + /// + /// D3D11_FEATURE_SHADER_MIN_PRECISION_SUPPORT + ShaderMinPrecisionSupport = 8, + /// + /// D3D11_FEATURE_D3D9_SHADOW_SUPPORT + D3d9ShadowSupport = 9, + /// + /// D3D11_FEATURE_D3D11_OPTIONS1 + Options1 = 10, + /// + /// D3D11_FEATURE_D3D9_SIMPLE_INSTANCING_SUPPORT + D3d9SimpleInstancingSupport = 11, + /// + /// D3D11_FEATURE_MARKER_SUPPORT + MarkerSupport = 12, + /// + /// D3D11_FEATURE_D3D9_OPTIONS1 + D3d9Options1 = 13, + /// + /// D3D11_FEATURE_D3D11_OPTIONS2 + Options2 = 14, + /// + /// D3D11_FEATURE_D3D11_OPTIONS3 + Options3 = 15, + /// + /// D3D11_FEATURE_GPU_VIRTUAL_ADDRESS_SUPPORT + GpuVirtualAddressSupport = 16, + /// + /// D3D11_FEATURE_D3D11_OPTIONS4 + Options4 = 17, + /// + /// D3D11_FEATURE_SHADER_CACHE + ShaderCache = 18, + /// + /// D3D11_FEATURE_D3D11_OPTIONS5 + Options5 = 19, + /// + /// D3D11_FEATURE_DISPLAYABLE + Displayable = 20, +} + +/// +/// D3D11_SHADER_MIN_PRECISION_SUPPORT +public enum ShaderMinPrecisionSupport : int +{ + /// + /// D3D11_SHADER_MIN_PRECISION_10_BIT + D3D11_SHADER_MIN_PRECISION_10_BIT = 1, + /// + /// D3D11_SHADER_MIN_PRECISION_16_BIT + D3D11_SHADER_MIN_PRECISION_16_BIT = 2, +} + +/// +/// D3D11_TILED_RESOURCES_TIER +public enum TiledResourcesTier : int +{ + /// + /// D3D11_TILED_RESOURCES_NOT_SUPPORTED + D3D11_TILED_RESOURCES_NOT_SUPPORTED = 0, + /// + /// D3D11_TILED_RESOURCES_TIER_1 + _1 = 1, + /// + /// D3D11_TILED_RESOURCES_TIER_2 + _2 = 2, + /// + /// D3D11_TILED_RESOURCES_TIER_3 + _3 = 3, +} + +/// +/// D3D11_CONSERVATIVE_RASTERIZATION_TIER +public enum ConservativeRasterizationTier : int +{ + /// + /// D3D11_CONSERVATIVE_RASTERIZATION_NOT_SUPPORTED + D3D11_CONSERVATIVE_RASTERIZATION_NOT_SUPPORTED = 0, + /// + /// D3D11_CONSERVATIVE_RASTERIZATION_TIER_1 + _1 = 1, + /// + /// D3D11_CONSERVATIVE_RASTERIZATION_TIER_2 + _2 = 2, + /// + /// D3D11_CONSERVATIVE_RASTERIZATION_TIER_3 + _3 = 3, +} + +/// +/// D3D11_SHADER_CACHE_SUPPORT_FLAGS +[Flags] +public enum ShaderCacheSupportFlags : int +{ + None = 0, + /// + /// D3D11_SHADER_CACHE_SUPPORT_NONE + D3D11_SHADER_CACHE_SUPPORT_NONE = 0, + /// + /// D3D11_SHADER_CACHE_SUPPORT_AUTOMATIC_INPROC_CACHE + D3D11_SHADER_CACHE_SUPPORT_AUTOMATIC_INPROC_CACHE = 1, + /// + /// D3D11_SHADER_CACHE_SUPPORT_AUTOMATIC_DISK_CACHE + D3D11_SHADER_CACHE_SUPPORT_AUTOMATIC_DISK_CACHE = 2, +} + +/// +/// D3D11_SHARED_RESOURCE_TIER +public enum SharedResourceTier : int +{ + /// + /// D3D11_SHARED_RESOURCE_TIER_0 + _0 = 0, + /// + /// D3D11_SHARED_RESOURCE_TIER_1 + _1 = 1, + /// + /// D3D11_SHARED_RESOURCE_TIER_2 + _2 = 2, + /// + /// D3D11_SHARED_RESOURCE_TIER_3 + _3 = 3, +} + +/// +/// D3D11_VIDEO_DECODER_BUFFER_TYPE +public enum VideoDecoderBufferType : int +{ + /// + /// D3D11_VIDEO_DECODER_BUFFER_PICTURE_PARAMETERS + D3D11_VIDEO_DECODER_BUFFER_PICTURE_PARAMETERS = 0, + /// + /// D3D11_VIDEO_DECODER_BUFFER_MACROBLOCK_CONTROL + D3D11_VIDEO_DECODER_BUFFER_MACROBLOCK_CONTROL = 1, + /// + /// D3D11_VIDEO_DECODER_BUFFER_RESIDUAL_DIFFERENCE + D3D11_VIDEO_DECODER_BUFFER_RESIDUAL_DIFFERENCE = 2, + /// + /// D3D11_VIDEO_DECODER_BUFFER_DEBLOCKING_CONTROL + D3D11_VIDEO_DECODER_BUFFER_DEBLOCKING_CONTROL = 3, + /// + /// D3D11_VIDEO_DECODER_BUFFER_INVERSE_QUANTIZATION_MATRIX + D3D11_VIDEO_DECODER_BUFFER_INVERSE_QUANTIZATION_MATRIX = 4, + /// + /// D3D11_VIDEO_DECODER_BUFFER_SLICE_CONTROL + D3D11_VIDEO_DECODER_BUFFER_SLICE_CONTROL = 5, + /// + /// D3D11_VIDEO_DECODER_BUFFER_BITSTREAM + D3D11_VIDEO_DECODER_BUFFER_BITSTREAM = 6, + /// + /// D3D11_VIDEO_DECODER_BUFFER_MOTION_VECTOR + D3D11_VIDEO_DECODER_BUFFER_MOTION_VECTOR = 7, + /// + /// D3D11_VIDEO_DECODER_BUFFER_FILM_GRAIN + D3D11_VIDEO_DECODER_BUFFER_FILM_GRAIN = 8, +} + +/// +/// D3D11_VIDEO_PROCESSOR_FORMAT_SUPPORT +public enum VideoProcessorFormatSupport : int +{ + /// + /// D3D11_VIDEO_PROCESSOR_FORMAT_SUPPORT_INPUT + Input = 1, + /// + /// D3D11_VIDEO_PROCESSOR_FORMAT_SUPPORT_OUTPUT + Output = 2, +} + +/// +/// D3D11_VIDEO_PROCESSOR_DEVICE_CAPS +public enum VideoProcessorDeviceCaps : int +{ + /// + /// D3D11_VIDEO_PROCESSOR_DEVICE_CAPS_LINEAR_SPACE + LinearSpace = 1, + /// + /// D3D11_VIDEO_PROCESSOR_DEVICE_CAPS_xvYCC + Xvycc = 2, + /// + /// D3D11_VIDEO_PROCESSOR_DEVICE_CAPS_RGB_RANGE_CONVERSION + RgbRangeConversion = 4, + /// + /// D3D11_VIDEO_PROCESSOR_DEVICE_CAPS_YCbCr_MATRIX_CONVERSION + YcbcrMatrixConversion = 8, + /// + /// D3D11_VIDEO_PROCESSOR_DEVICE_CAPS_NOMINAL_RANGE + NominalRange = 16, +} + +/// +/// D3D11_VIDEO_PROCESSOR_FEATURE_CAPS +public enum VideoProcessorFeatureCaps : int +{ + /// + /// D3D11_VIDEO_PROCESSOR_FEATURE_CAPS_ALPHA_FILL + AlphaFill = 1, + /// + /// D3D11_VIDEO_PROCESSOR_FEATURE_CAPS_CONSTRICTION + Constriction = 2, + /// + /// D3D11_VIDEO_PROCESSOR_FEATURE_CAPS_LUMA_KEY + LumaKey = 4, + /// + /// D3D11_VIDEO_PROCESSOR_FEATURE_CAPS_ALPHA_PALETTE + AlphaPalette = 8, + /// + /// D3D11_VIDEO_PROCESSOR_FEATURE_CAPS_LEGACY + Legacy = 16, + /// + /// D3D11_VIDEO_PROCESSOR_FEATURE_CAPS_STEREO + Stereo = 32, + /// + /// D3D11_VIDEO_PROCESSOR_FEATURE_CAPS_ROTATION + Rotation = 64, + /// + /// D3D11_VIDEO_PROCESSOR_FEATURE_CAPS_ALPHA_STREAM + AlphaStream = 128, + /// + /// D3D11_VIDEO_PROCESSOR_FEATURE_CAPS_PIXEL_ASPECT_RATIO + PixelAspectRatio = 256, + /// + /// D3D11_VIDEO_PROCESSOR_FEATURE_CAPS_MIRROR + Mirror = 512, + /// + /// D3D11_VIDEO_PROCESSOR_FEATURE_CAPS_SHADER_USAGE + ShaderUsage = 1024, + /// + /// D3D11_VIDEO_PROCESSOR_FEATURE_CAPS_METADATA_HDR10 + MetadataHdr10 = 2048, +} + +/// +/// D3D11_VIDEO_PROCESSOR_FILTER_CAPS +public enum VideoProcessorFilterCaps : int +{ + /// + /// D3D11_VIDEO_PROCESSOR_FILTER_CAPS_BRIGHTNESS + Brightness = 1, + /// + /// D3D11_VIDEO_PROCESSOR_FILTER_CAPS_CONTRAST + Contrast = 2, + /// + /// D3D11_VIDEO_PROCESSOR_FILTER_CAPS_HUE + Hue = 4, + /// + /// D3D11_VIDEO_PROCESSOR_FILTER_CAPS_SATURATION + Saturation = 8, + /// + /// D3D11_VIDEO_PROCESSOR_FILTER_CAPS_NOISE_REDUCTION + NoiseReduction = 16, + /// + /// D3D11_VIDEO_PROCESSOR_FILTER_CAPS_EDGE_ENHANCEMENT + EdgeEnhancement = 32, + /// + /// D3D11_VIDEO_PROCESSOR_FILTER_CAPS_ANAMORPHIC_SCALING + AnamorphicScaling = 64, + /// + /// D3D11_VIDEO_PROCESSOR_FILTER_CAPS_STEREO_ADJUSTMENT + StereoAdjustment = 128, +} + +/// +/// D3D11_VIDEO_PROCESSOR_FORMAT_CAPS +public enum VideoProcessorFormatCaps : int +{ + /// + /// D3D11_VIDEO_PROCESSOR_FORMAT_CAPS_RGB_INTERLACED + RgbInterlaced = 1, + /// + /// D3D11_VIDEO_PROCESSOR_FORMAT_CAPS_RGB_PROCAMP + RgbProcamp = 2, + /// + /// D3D11_VIDEO_PROCESSOR_FORMAT_CAPS_RGB_LUMA_KEY + RgbLumaKey = 4, + /// + /// D3D11_VIDEO_PROCESSOR_FORMAT_CAPS_PALETTE_INTERLACED + PaletteInterlaced = 8, +} + +/// +/// D3D11_VIDEO_PROCESSOR_AUTO_STREAM_CAPS +public enum VideoProcessorAutoStreamCaps : int +{ + /// + /// D3D11_VIDEO_PROCESSOR_AUTO_STREAM_CAPS_DENOISE + Denoise = 1, + /// + /// D3D11_VIDEO_PROCESSOR_AUTO_STREAM_CAPS_DERINGING + Deringing = 2, + /// + /// D3D11_VIDEO_PROCESSOR_AUTO_STREAM_CAPS_EDGE_ENHANCEMENT + EdgeEnhancement = 4, + /// + /// D3D11_VIDEO_PROCESSOR_AUTO_STREAM_CAPS_COLOR_CORRECTION + ColorCorrection = 8, + /// + /// D3D11_VIDEO_PROCESSOR_AUTO_STREAM_CAPS_FLESH_TONE_MAPPING + FleshToneMapping = 16, + /// + /// D3D11_VIDEO_PROCESSOR_AUTO_STREAM_CAPS_IMAGE_STABILIZATION + ImageStabilization = 32, + /// + /// D3D11_VIDEO_PROCESSOR_AUTO_STREAM_CAPS_SUPER_RESOLUTION + SuperResolution = 64, + /// + /// D3D11_VIDEO_PROCESSOR_AUTO_STREAM_CAPS_ANAMORPHIC_SCALING + AnamorphicScaling = 128, +} + +/// +/// D3D11_VIDEO_PROCESSOR_STEREO_CAPS +public enum VideoProcessorStereoCaps : int +{ + /// + /// D3D11_VIDEO_PROCESSOR_STEREO_CAPS_MONO_OFFSET + MonoOffset = 1, + /// + /// D3D11_VIDEO_PROCESSOR_STEREO_CAPS_ROW_INTERLEAVED + RowInterleaved = 2, + /// + /// D3D11_VIDEO_PROCESSOR_STEREO_CAPS_COLUMN_INTERLEAVED + ColumnInterleaved = 4, + /// + /// D3D11_VIDEO_PROCESSOR_STEREO_CAPS_CHECKERBOARD + Checkerboard = 8, + /// + /// D3D11_VIDEO_PROCESSOR_STEREO_CAPS_FLIP_MODE + FlipMode = 16, +} + +/// +/// D3D11_VIDEO_PROCESSOR_PROCESSOR_CAPS +public enum VideoProcessorProcessorCaps : int +{ + /// + /// D3D11_VIDEO_PROCESSOR_PROCESSOR_CAPS_DEINTERLACE_BLEND + DeinterlaceBlend = 1, + /// + /// D3D11_VIDEO_PROCESSOR_PROCESSOR_CAPS_DEINTERLACE_BOB + DeinterlaceBob = 2, + /// + /// D3D11_VIDEO_PROCESSOR_PROCESSOR_CAPS_DEINTERLACE_ADAPTIVE + DeinterlaceAdaptive = 4, + /// + /// D3D11_VIDEO_PROCESSOR_PROCESSOR_CAPS_DEINTERLACE_MOTION_COMPENSATION + DeinterlaceMotionCompensation = 8, + /// + /// D3D11_VIDEO_PROCESSOR_PROCESSOR_CAPS_INVERSE_TELECINE + InverseTelecine = 16, + /// + /// D3D11_VIDEO_PROCESSOR_PROCESSOR_CAPS_FRAME_RATE_CONVERSION + FrameRateConversion = 32, +} + +/// +/// D3D11_VIDEO_PROCESSOR_ITELECINE_CAPS +public enum VideoProcessorItelecineCaps : int +{ + /// + /// D3D11_VIDEO_PROCESSOR_ITELECINE_CAPS_32 + _32 = 1, + /// + /// D3D11_VIDEO_PROCESSOR_ITELECINE_CAPS_22 + _22 = 2, + /// + /// D3D11_VIDEO_PROCESSOR_ITELECINE_CAPS_2224 + _2224 = 4, + /// + /// D3D11_VIDEO_PROCESSOR_ITELECINE_CAPS_2332 + _2332 = 8, + /// + /// D3D11_VIDEO_PROCESSOR_ITELECINE_CAPS_32322 + _32322 = 16, + /// + /// D3D11_VIDEO_PROCESSOR_ITELECINE_CAPS_55 + _55 = 32, + /// + /// D3D11_VIDEO_PROCESSOR_ITELECINE_CAPS_64 + _64 = 64, + /// + /// D3D11_VIDEO_PROCESSOR_ITELECINE_CAPS_87 + _87 = 128, + /// + /// D3D11_VIDEO_PROCESSOR_ITELECINE_CAPS_222222222223 + _222222222223 = 256, + /// + /// D3D11_VIDEO_PROCESSOR_ITELECINE_CAPS_OTHER + Other = -2147483648, +} + +/// +/// D3D11_CONTENT_PROTECTION_CAPS +public enum ContentProtectionCaps : int +{ + /// + /// D3D11_CONTENT_PROTECTION_CAPS_SOFTWARE + Software = 1, + /// + /// D3D11_CONTENT_PROTECTION_CAPS_HARDWARE + Hardware = 2, + /// + /// D3D11_CONTENT_PROTECTION_CAPS_PROTECTION_ALWAYS_ON + ProtectionAlwaysOn = 4, + /// + /// D3D11_CONTENT_PROTECTION_CAPS_PARTIAL_DECRYPTION + PartialDecryption = 8, + /// + /// D3D11_CONTENT_PROTECTION_CAPS_CONTENT_KEY + ContentKey = 16, + /// + /// D3D11_CONTENT_PROTECTION_CAPS_FRESHEN_SESSION_KEY + FreshenSessionKey = 32, + /// + /// D3D11_CONTENT_PROTECTION_CAPS_ENCRYPTED_READ_BACK + EncryptedReadBack = 64, + /// + /// D3D11_CONTENT_PROTECTION_CAPS_ENCRYPTED_READ_BACK_KEY + EncryptedReadBackKey = 128, + /// + /// D3D11_CONTENT_PROTECTION_CAPS_SEQUENTIAL_CTR_IV + SequentialCtrIv = 256, + /// + /// D3D11_CONTENT_PROTECTION_CAPS_ENCRYPT_SLICEDATA_ONLY + EncryptSlicedataOnly = 512, + /// + /// D3D11_CONTENT_PROTECTION_CAPS_DECRYPTION_BLT + DecryptionBlt = 1024, + /// + /// D3D11_CONTENT_PROTECTION_CAPS_HARDWARE_PROTECT_UNCOMPRESSED + HardwareProtectUncompressed = 2048, + /// + /// D3D11_CONTENT_PROTECTION_CAPS_HARDWARE_PROTECTED_MEMORY_PAGEABLE + HardwareProtectedMemoryPageable = 4096, + /// + /// D3D11_CONTENT_PROTECTION_CAPS_HARDWARE_TEARDOWN + HardwareTeardown = 8192, + /// + /// D3D11_CONTENT_PROTECTION_CAPS_HARDWARE_DRM_COMMUNICATION + HardwareDrmCommunication = 16384, + /// + /// D3D11_CONTENT_PROTECTION_CAPS_HARDWARE_DRM_COMMUNICATION_MULTI_THREADED + HardwareDrmCommunicationMultiThreaded = 32768, +} + +/// +/// D3D11_VIDEO_PROCESSOR_FILTER +public enum VideoProcessorFilter : int +{ + /// + /// D3D11_VIDEO_PROCESSOR_FILTER_BRIGHTNESS + Brightness = 0, + /// + /// D3D11_VIDEO_PROCESSOR_FILTER_CONTRAST + Contrast = 1, + /// + /// D3D11_VIDEO_PROCESSOR_FILTER_HUE + Hue = 2, + /// + /// D3D11_VIDEO_PROCESSOR_FILTER_SATURATION + Saturation = 3, + /// + /// D3D11_VIDEO_PROCESSOR_FILTER_NOISE_REDUCTION + NoiseReduction = 4, + /// + /// D3D11_VIDEO_PROCESSOR_FILTER_EDGE_ENHANCEMENT + EdgeEnhancement = 5, + /// + /// D3D11_VIDEO_PROCESSOR_FILTER_ANAMORPHIC_SCALING + AnamorphicScaling = 6, + /// + /// D3D11_VIDEO_PROCESSOR_FILTER_STEREO_ADJUSTMENT + StereoAdjustment = 7, +} + +/// +/// D3D11_VIDEO_FRAME_FORMAT +public enum VideoFrameFormat : int +{ + /// + /// D3D11_VIDEO_FRAME_FORMAT_PROGRESSIVE + Progressive = 0, + /// + /// D3D11_VIDEO_FRAME_FORMAT_INTERLACED_TOP_FIELD_FIRST + InterlacedTopFieldFirst = 1, + /// + /// D3D11_VIDEO_FRAME_FORMAT_INTERLACED_BOTTOM_FIELD_FIRST + InterlacedBottomFieldFirst = 2, +} + +/// +/// D3D11_VIDEO_USAGE +public enum VideoUsage : int +{ + /// + /// D3D11_VIDEO_USAGE_PLAYBACK_NORMAL + PlaybackNormal = 0, + /// + /// D3D11_VIDEO_USAGE_OPTIMAL_SPEED + OptimalSpeed = 1, + /// + /// D3D11_VIDEO_USAGE_OPTIMAL_QUALITY + OptimalQuality = 2, +} + +/// +/// D3D11_VIDEO_PROCESSOR_NOMINAL_RANGE +public enum VideoProcessorNominalRange : int +{ + /// + /// D3D11_VIDEO_PROCESSOR_NOMINAL_RANGE_UNDEFINED + Undefined = 0, + /// + /// D3D11_VIDEO_PROCESSOR_NOMINAL_RANGE_16_235 + _16235 = 1, + /// + /// D3D11_VIDEO_PROCESSOR_NOMINAL_RANGE_0_255 + _0255 = 2, +} + +/// +/// D3D11_VIDEO_PROCESSOR_ALPHA_FILL_MODE +public enum VideoProcessorAlphaFillMode : int +{ + /// + /// D3D11_VIDEO_PROCESSOR_ALPHA_FILL_MODE_OPAQUE + Opaque = 0, + /// + /// D3D11_VIDEO_PROCESSOR_ALPHA_FILL_MODE_BACKGROUND + Background = 1, + /// + /// D3D11_VIDEO_PROCESSOR_ALPHA_FILL_MODE_DESTINATION + Destination = 2, + /// + /// D3D11_VIDEO_PROCESSOR_ALPHA_FILL_MODE_SOURCE_STREAM + SourceStream = 3, +} + +/// +/// D3D11_VIDEO_PROCESSOR_OUTPUT_RATE +public enum VideoProcessorOutputRate : int +{ + /// + /// D3D11_VIDEO_PROCESSOR_OUTPUT_RATE_NORMAL + Normal = 0, + /// + /// D3D11_VIDEO_PROCESSOR_OUTPUT_RATE_HALF + Half = 1, + /// + /// D3D11_VIDEO_PROCESSOR_OUTPUT_RATE_CUSTOM + Custom = 2, +} + +/// +/// D3D11_VIDEO_PROCESSOR_STEREO_FORMAT +public enum VideoProcessorStereoFormat : int +{ + /// + /// D3D11_VIDEO_PROCESSOR_STEREO_FORMAT_MONO + Mono = 0, + /// + /// D3D11_VIDEO_PROCESSOR_STEREO_FORMAT_HORIZONTAL + Horizontal = 1, + /// + /// D3D11_VIDEO_PROCESSOR_STEREO_FORMAT_VERTICAL + Vertical = 2, + /// + /// D3D11_VIDEO_PROCESSOR_STEREO_FORMAT_SEPARATE + Separate = 3, + /// + /// D3D11_VIDEO_PROCESSOR_STEREO_FORMAT_MONO_OFFSET + MonoOffset = 4, + /// + /// D3D11_VIDEO_PROCESSOR_STEREO_FORMAT_ROW_INTERLEAVED + RowInterleaved = 5, + /// + /// D3D11_VIDEO_PROCESSOR_STEREO_FORMAT_COLUMN_INTERLEAVED + ColumnInterleaved = 6, + /// + /// D3D11_VIDEO_PROCESSOR_STEREO_FORMAT_CHECKERBOARD + Checkerboard = 7, +} + +/// +/// D3D11_VIDEO_PROCESSOR_STEREO_FLIP_MODE +public enum VideoProcessorStereoFlipMode : int +{ + /// + /// D3D11_VIDEO_PROCESSOR_STEREO_FLIP_NONE + D3D11_VIDEO_PROCESSOR_STEREO_FLIP_NONE = 0, + /// + /// D3D11_VIDEO_PROCESSOR_STEREO_FLIP_FRAME0 + D3D11_VIDEO_PROCESSOR_STEREO_FLIP_FRAME0 = 1, + /// + /// D3D11_VIDEO_PROCESSOR_STEREO_FLIP_FRAME1 + D3D11_VIDEO_PROCESSOR_STEREO_FLIP_FRAME1 = 2, +} + +/// +/// D3D11_VIDEO_PROCESSOR_ROTATION +public enum VideoProcessorRotation : int +{ + /// + /// D3D11_VIDEO_PROCESSOR_ROTATION_IDENTITY + Identity = 0, + /// + /// D3D11_VIDEO_PROCESSOR_ROTATION_90 + _90 = 1, + /// + /// D3D11_VIDEO_PROCESSOR_ROTATION_180 + _180 = 2, + /// + /// D3D11_VIDEO_PROCESSOR_ROTATION_270 + _270 = 3, +} + +/// +/// D3D11_AUTHENTICATED_CHANNEL_TYPE +public enum AuthenticatedChannelType : int +{ + /// + /// D3D11_AUTHENTICATED_CHANNEL_D3D11 + D3D11_AUTHENTICATED_CHANNEL_D3D11 = 1, + /// + /// D3D11_AUTHENTICATED_CHANNEL_DRIVER_SOFTWARE + D3D11_AUTHENTICATED_CHANNEL_DRIVER_SOFTWARE = 2, + /// + /// D3D11_AUTHENTICATED_CHANNEL_DRIVER_HARDWARE + D3D11_AUTHENTICATED_CHANNEL_DRIVER_HARDWARE = 3, +} + +/// +/// D3D11_AUTHENTICATED_PROCESS_IDENTIFIER_TYPE +public enum AuthenticatedProcessIdentifierType : int +{ + /// + /// D3D11_PROCESSIDTYPE_UNKNOWN + D3D11_PROCESSIDTYPE_UNKNOWN = 0, + /// + /// D3D11_PROCESSIDTYPE_DWM + D3D11_PROCESSIDTYPE_DWM = 1, + /// + /// D3D11_PROCESSIDTYPE_HANDLE + D3D11_PROCESSIDTYPE_HANDLE = 2, +} + +/// +/// D3D11_BUS_TYPE +public enum BusType : int +{ + /// + /// D3D11_BUS_TYPE_OTHER + Other = 0, + /// + /// D3D11_BUS_TYPE_PCI + Pci = 1, + /// + /// D3D11_BUS_TYPE_PCIX + Pcix = 2, + /// + /// D3D11_BUS_TYPE_PCIEXPRESS + Pciexpress = 3, + /// + /// D3D11_BUS_TYPE_AGP + Agp = 4, + /// + /// D3D11_BUS_IMPL_MODIFIER_INSIDE_OF_CHIPSET + D3D11_BUS_IMPL_MODIFIER_INSIDE_OF_CHIPSET = 65536, + /// + /// D3D11_BUS_IMPL_MODIFIER_TRACKS_ON_MOTHER_BOARD_TO_CHIP + D3D11_BUS_IMPL_MODIFIER_TRACKS_ON_MOTHER_BOARD_TO_CHIP = 131072, + /// + /// D3D11_BUS_IMPL_MODIFIER_TRACKS_ON_MOTHER_BOARD_TO_SOCKET + D3D11_BUS_IMPL_MODIFIER_TRACKS_ON_MOTHER_BOARD_TO_SOCKET = 196608, + /// + /// D3D11_BUS_IMPL_MODIFIER_DAUGHTER_BOARD_CONNECTOR + D3D11_BUS_IMPL_MODIFIER_DAUGHTER_BOARD_CONNECTOR = 262144, + /// + /// D3D11_BUS_IMPL_MODIFIER_DAUGHTER_BOARD_CONNECTOR_INSIDE_OF_NUAE + D3D11_BUS_IMPL_MODIFIER_DAUGHTER_BOARD_CONNECTOR_INSIDE_OF_NUAE = 327680, + /// + /// D3D11_BUS_IMPL_MODIFIER_NON_STANDARD + D3D11_BUS_IMPL_MODIFIER_NON_STANDARD = -2147483648, +} + +/// +/// D3D11_VDOV_DIMENSION +public enum VdovDimension : int +{ + /// + /// D3D11_VDOV_DIMENSION_UNKNOWN + Unknown = 0, + /// + /// D3D11_VDOV_DIMENSION_TEXTURE2D + Texture2D = 1, +} + +/// +/// D3D11_VPIV_DIMENSION +public enum VpivDimension : int +{ + /// + /// D3D11_VPIV_DIMENSION_UNKNOWN + Unknown = 0, + /// + /// D3D11_VPIV_DIMENSION_TEXTURE2D + Texture2D = 1, +} + +/// +/// D3D11_VPOV_DIMENSION +public enum VpovDimension : int +{ + /// + /// D3D11_VPOV_DIMENSION_UNKNOWN + Unknown = 0, + /// + /// D3D11_VPOV_DIMENSION_TEXTURE2D + Texture2D = 1, + /// + /// D3D11_VPOV_DIMENSION_TEXTURE2DARRAY + Texture2DArray = 2, +} + +/// +/// D3D11_CREATE_DEVICE_FLAG +[Flags] +public enum CreateDeviceFlag : uint +{ + None = 0, + /// + /// D3D11_CREATE_DEVICE_SINGLETHREADED + D3D11_CREATE_DEVICE_SINGLETHREADED = 1, + /// + /// D3D11_CREATE_DEVICE_DEBUG + D3D11_CREATE_DEVICE_DEBUG = 2, + /// + /// D3D11_CREATE_DEVICE_SWITCH_TO_REF + D3D11_CREATE_DEVICE_SWITCH_TO_REF = 4, + /// + /// D3D11_CREATE_DEVICE_PREVENT_INTERNAL_THREADING_OPTIMIZATIONS + D3D11_CREATE_DEVICE_PREVENT_INTERNAL_THREADING_OPTIMIZATIONS = 8, + /// + /// D3D11_CREATE_DEVICE_BGRA_SUPPORT + D3D11_CREATE_DEVICE_BGRA_SUPPORT = 32, + /// + /// D3D11_CREATE_DEVICE_DEBUGGABLE + D3D11_CREATE_DEVICE_DEBUGGABLE = 64, + /// + /// D3D11_CREATE_DEVICE_PREVENT_ALTERING_LAYER_SETTINGS_FROM_REGISTRY + D3D11_CREATE_DEVICE_PREVENT_ALTERING_LAYER_SETTINGS_FROM_REGISTRY = 128, + /// + /// D3D11_CREATE_DEVICE_DISABLE_GPU_TIMEOUT + D3D11_CREATE_DEVICE_DISABLE_GPU_TIMEOUT = 256, + /// + /// D3D11_CREATE_DEVICE_VIDEO_SUPPORT + D3D11_CREATE_DEVICE_VIDEO_SUPPORT = 2048, +} + +/// +/// D3D11_RLDO_FLAGS +[Flags] +public enum RldoFlags : int +{ + None = 0, + /// + /// D3D11_RLDO_SUMMARY + D3D11_RLDO_SUMMARY = 1, + /// + /// D3D11_RLDO_DETAIL + D3D11_RLDO_DETAIL = 2, + /// + /// D3D11_RLDO_IGNORE_INTERNAL + D3D11_RLDO_IGNORE_INTERNAL = 4, +} + +/// +/// D3D11_SHADER_TRACKING_RESOURCE_TYPE +public enum ShaderTrackingResourceType : int +{ + /// + /// D3D11_SHADER_TRACKING_RESOURCE_TYPE_NONE + None = 0, + /// + /// D3D11_SHADER_TRACKING_RESOURCE_TYPE_UAV_DEVICEMEMORY + UavDevicememory = 1, + /// + /// D3D11_SHADER_TRACKING_RESOURCE_TYPE_NON_UAV_DEVICEMEMORY + NonUavDevicememory = 2, + /// + /// D3D11_SHADER_TRACKING_RESOURCE_TYPE_ALL_DEVICEMEMORY + AllDevicememory = 3, + /// + /// D3D11_SHADER_TRACKING_RESOURCE_TYPE_GROUPSHARED_MEMORY + GroupsharedMemory = 4, + /// + /// D3D11_SHADER_TRACKING_RESOURCE_TYPE_ALL_SHARED_MEMORY + AllSharedMemory = 5, + /// + /// D3D11_SHADER_TRACKING_RESOURCE_TYPE_GROUPSHARED_NON_UAV + GroupsharedNonUav = 6, + /// + /// D3D11_SHADER_TRACKING_RESOURCE_TYPE_ALL + All = 7, +} + +/// +/// D3D11_SHADER_TRACKING_OPTIONS +public enum ShaderTrackingOptions : int +{ + /// + /// D3D11_SHADER_TRACKING_OPTION_IGNORE + D3D11_SHADER_TRACKING_OPTION_IGNORE = 0, + /// + /// D3D11_SHADER_TRACKING_OPTION_TRACK_UNINITIALIZED + D3D11_SHADER_TRACKING_OPTION_TRACK_UNINITIALIZED = 1, + /// + /// D3D11_SHADER_TRACKING_OPTION_TRACK_RAW + D3D11_SHADER_TRACKING_OPTION_TRACK_RAW = 2, + /// + /// D3D11_SHADER_TRACKING_OPTION_TRACK_WAR + D3D11_SHADER_TRACKING_OPTION_TRACK_WAR = 4, + /// + /// D3D11_SHADER_TRACKING_OPTION_TRACK_WAW + D3D11_SHADER_TRACKING_OPTION_TRACK_WAW = 8, + /// + /// D3D11_SHADER_TRACKING_OPTION_ALLOW_SAME + D3D11_SHADER_TRACKING_OPTION_ALLOW_SAME = 16, + /// + /// D3D11_SHADER_TRACKING_OPTION_TRACK_ATOMIC_CONSISTENCY + D3D11_SHADER_TRACKING_OPTION_TRACK_ATOMIC_CONSISTENCY = 32, + /// + /// D3D11_SHADER_TRACKING_OPTION_TRACK_RAW_ACROSS_THREADGROUPS + D3D11_SHADER_TRACKING_OPTION_TRACK_RAW_ACROSS_THREADGROUPS = 64, + /// + /// D3D11_SHADER_TRACKING_OPTION_TRACK_WAR_ACROSS_THREADGROUPS + D3D11_SHADER_TRACKING_OPTION_TRACK_WAR_ACROSS_THREADGROUPS = 128, + /// + /// D3D11_SHADER_TRACKING_OPTION_TRACK_WAW_ACROSS_THREADGROUPS + D3D11_SHADER_TRACKING_OPTION_TRACK_WAW_ACROSS_THREADGROUPS = 256, + /// + /// D3D11_SHADER_TRACKING_OPTION_TRACK_ATOMIC_CONSISTENCY_ACROSS_THREADGROUPS + D3D11_SHADER_TRACKING_OPTION_TRACK_ATOMIC_CONSISTENCY_ACROSS_THREADGROUPS = 512, + /// + /// D3D11_SHADER_TRACKING_OPTION_UAV_SPECIFIC_FLAGS + D3D11_SHADER_TRACKING_OPTION_UAV_SPECIFIC_FLAGS = 960, + /// + /// D3D11_SHADER_TRACKING_OPTION_ALL_HAZARDS + D3D11_SHADER_TRACKING_OPTION_ALL_HAZARDS = 1006, + /// + /// D3D11_SHADER_TRACKING_OPTION_ALL_HAZARDS_ALLOWING_SAME + D3D11_SHADER_TRACKING_OPTION_ALL_HAZARDS_ALLOWING_SAME = 1022, + /// + /// D3D11_SHADER_TRACKING_OPTION_ALL_OPTIONS + D3D11_SHADER_TRACKING_OPTION_ALL_OPTIONS = 1023, +} + +/// +/// D3D11_MESSAGE_CATEGORY +public enum MessageCategory : int +{ + /// + /// D3D11_MESSAGE_CATEGORY_APPLICATION_DEFINED + ApplicationDefined = 0, + /// + /// D3D11_MESSAGE_CATEGORY_MISCELLANEOUS + Miscellaneous = 1, + /// + /// D3D11_MESSAGE_CATEGORY_INITIALIZATION + Initialization = 2, + /// + /// D3D11_MESSAGE_CATEGORY_CLEANUP + Cleanup = 3, + /// + /// D3D11_MESSAGE_CATEGORY_COMPILATION + Compilation = 4, + /// + /// D3D11_MESSAGE_CATEGORY_STATE_CREATION + StateCreation = 5, + /// + /// D3D11_MESSAGE_CATEGORY_STATE_SETTING + StateSetting = 6, + /// + /// D3D11_MESSAGE_CATEGORY_STATE_GETTING + StateGetting = 7, + /// + /// D3D11_MESSAGE_CATEGORY_RESOURCE_MANIPULATION + ResourceManipulation = 8, + /// + /// D3D11_MESSAGE_CATEGORY_EXECUTION + Execution = 9, + /// + /// D3D11_MESSAGE_CATEGORY_SHADER + Shader = 10, +} + +/// +/// D3D11_MESSAGE_SEVERITY +public enum MessageSeverity : int +{ + /// + /// D3D11_MESSAGE_SEVERITY_CORRUPTION + Corruption = 0, + /// + /// D3D11_MESSAGE_SEVERITY_ERROR + Error = 1, + /// + /// D3D11_MESSAGE_SEVERITY_WARNING + Warning = 2, + /// + /// D3D11_MESSAGE_SEVERITY_INFO + Info = 3, + /// + /// D3D11_MESSAGE_SEVERITY_MESSAGE + Message = 4, +} + +/// +/// D3D11_MESSAGE_ID +public enum MessageId : int +{ + /// + /// D3D11_MESSAGE_ID_UNKNOWN + Unknown = 0, + /// + /// D3D11_MESSAGE_ID_DEVICE_IASETVERTEXBUFFERS_HAZARD + DeviceIasetvertexbuffersHazard = 1, + /// + /// D3D11_MESSAGE_ID_DEVICE_IASETINDEXBUFFER_HAZARD + DeviceIasetindexbufferHazard = 2, + /// + /// D3D11_MESSAGE_ID_DEVICE_VSSETSHADERRESOURCES_HAZARD + DeviceVssetshaderresourcesHazard = 3, + /// + /// D3D11_MESSAGE_ID_DEVICE_VSSETCONSTANTBUFFERS_HAZARD + DeviceVssetconstantbuffersHazard = 4, + /// + /// D3D11_MESSAGE_ID_DEVICE_GSSETSHADERRESOURCES_HAZARD + DeviceGssetshaderresourcesHazard = 5, + /// + /// D3D11_MESSAGE_ID_DEVICE_GSSETCONSTANTBUFFERS_HAZARD + DeviceGssetconstantbuffersHazard = 6, + /// + /// D3D11_MESSAGE_ID_DEVICE_PSSETSHADERRESOURCES_HAZARD + DevicePssetshaderresourcesHazard = 7, + /// + /// D3D11_MESSAGE_ID_DEVICE_PSSETCONSTANTBUFFERS_HAZARD + DevicePssetconstantbuffersHazard = 8, + /// + /// D3D11_MESSAGE_ID_DEVICE_OMSETRENDERTARGETS_HAZARD + DeviceOmsetrendertargetsHazard = 9, + /// + /// D3D11_MESSAGE_ID_DEVICE_SOSETTARGETS_HAZARD + DeviceSosettargetsHazard = 10, + /// + /// D3D11_MESSAGE_ID_STRING_FROM_APPLICATION + StringFromApplication = 11, + /// + /// D3D11_MESSAGE_ID_CORRUPTED_THIS + CorruptedThis = 12, + /// + /// D3D11_MESSAGE_ID_CORRUPTED_PARAMETER1 + CorruptedParameter1 = 13, + /// + /// D3D11_MESSAGE_ID_CORRUPTED_PARAMETER2 + CorruptedParameter2 = 14, + /// + /// D3D11_MESSAGE_ID_CORRUPTED_PARAMETER3 + CorruptedParameter3 = 15, + /// + /// D3D11_MESSAGE_ID_CORRUPTED_PARAMETER4 + CorruptedParameter4 = 16, + /// + /// D3D11_MESSAGE_ID_CORRUPTED_PARAMETER5 + CorruptedParameter5 = 17, + /// + /// D3D11_MESSAGE_ID_CORRUPTED_PARAMETER6 + CorruptedParameter6 = 18, + /// + /// D3D11_MESSAGE_ID_CORRUPTED_PARAMETER7 + CorruptedParameter7 = 19, + /// + /// D3D11_MESSAGE_ID_CORRUPTED_PARAMETER8 + CorruptedParameter8 = 20, + /// + /// D3D11_MESSAGE_ID_CORRUPTED_PARAMETER9 + CorruptedParameter9 = 21, + /// + /// D3D11_MESSAGE_ID_CORRUPTED_PARAMETER10 + CorruptedParameter10 = 22, + /// + /// D3D11_MESSAGE_ID_CORRUPTED_PARAMETER11 + CorruptedParameter11 = 23, + /// + /// D3D11_MESSAGE_ID_CORRUPTED_PARAMETER12 + CorruptedParameter12 = 24, + /// + /// D3D11_MESSAGE_ID_CORRUPTED_PARAMETER13 + CorruptedParameter13 = 25, + /// + /// D3D11_MESSAGE_ID_CORRUPTED_PARAMETER14 + CorruptedParameter14 = 26, + /// + /// D3D11_MESSAGE_ID_CORRUPTED_PARAMETER15 + CorruptedParameter15 = 27, + /// + /// D3D11_MESSAGE_ID_CORRUPTED_MULTITHREADING + CorruptedMultithreading = 28, + /// + /// D3D11_MESSAGE_ID_MESSAGE_REPORTING_OUTOFMEMORY + MessageReportingOutofmemory = 29, + /// + /// D3D11_MESSAGE_ID_IASETINPUTLAYOUT_UNBINDDELETINGOBJECT + IasetinputlayoutUnbinddeletingobject = 30, + /// + /// D3D11_MESSAGE_ID_IASETVERTEXBUFFERS_UNBINDDELETINGOBJECT + IasetvertexbuffersUnbinddeletingobject = 31, + /// + /// D3D11_MESSAGE_ID_IASETINDEXBUFFER_UNBINDDELETINGOBJECT + IasetindexbufferUnbinddeletingobject = 32, + /// + /// D3D11_MESSAGE_ID_VSSETSHADER_UNBINDDELETINGOBJECT + VssetshaderUnbinddeletingobject = 33, + /// + /// D3D11_MESSAGE_ID_VSSETSHADERRESOURCES_UNBINDDELETINGOBJECT + VssetshaderresourcesUnbinddeletingobject = 34, + /// + /// D3D11_MESSAGE_ID_VSSETCONSTANTBUFFERS_UNBINDDELETINGOBJECT + VssetconstantbuffersUnbinddeletingobject = 35, + /// + /// D3D11_MESSAGE_ID_VSSETSAMPLERS_UNBINDDELETINGOBJECT + VssetsamplersUnbinddeletingobject = 36, + /// + /// D3D11_MESSAGE_ID_GSSETSHADER_UNBINDDELETINGOBJECT + GssetshaderUnbinddeletingobject = 37, + /// + /// D3D11_MESSAGE_ID_GSSETSHADERRESOURCES_UNBINDDELETINGOBJECT + GssetshaderresourcesUnbinddeletingobject = 38, + /// + /// D3D11_MESSAGE_ID_GSSETCONSTANTBUFFERS_UNBINDDELETINGOBJECT + GssetconstantbuffersUnbinddeletingobject = 39, + /// + /// D3D11_MESSAGE_ID_GSSETSAMPLERS_UNBINDDELETINGOBJECT + GssetsamplersUnbinddeletingobject = 40, + /// + /// D3D11_MESSAGE_ID_SOSETTARGETS_UNBINDDELETINGOBJECT + SosettargetsUnbinddeletingobject = 41, + /// + /// D3D11_MESSAGE_ID_PSSETSHADER_UNBINDDELETINGOBJECT + PssetshaderUnbinddeletingobject = 42, + /// + /// D3D11_MESSAGE_ID_PSSETSHADERRESOURCES_UNBINDDELETINGOBJECT + PssetshaderresourcesUnbinddeletingobject = 43, + /// + /// D3D11_MESSAGE_ID_PSSETCONSTANTBUFFERS_UNBINDDELETINGOBJECT + PssetconstantbuffersUnbinddeletingobject = 44, + /// + /// D3D11_MESSAGE_ID_PSSETSAMPLERS_UNBINDDELETINGOBJECT + PssetsamplersUnbinddeletingobject = 45, + /// + /// D3D11_MESSAGE_ID_RSSETSTATE_UNBINDDELETINGOBJECT + RssetstateUnbinddeletingobject = 46, + /// + /// D3D11_MESSAGE_ID_OMSETBLENDSTATE_UNBINDDELETINGOBJECT + OmsetblendstateUnbinddeletingobject = 47, + /// + /// D3D11_MESSAGE_ID_OMSETDEPTHSTENCILSTATE_UNBINDDELETINGOBJECT + OmsetdepthstencilstateUnbinddeletingobject = 48, + /// + /// D3D11_MESSAGE_ID_OMSETRENDERTARGETS_UNBINDDELETINGOBJECT + OmsetrendertargetsUnbinddeletingobject = 49, + /// + /// D3D11_MESSAGE_ID_SETPREDICATION_UNBINDDELETINGOBJECT + SetpredicationUnbinddeletingobject = 50, + /// + /// D3D11_MESSAGE_ID_GETPRIVATEDATA_MOREDATA + GetprivatedataMoredata = 51, + /// + /// D3D11_MESSAGE_ID_SETPRIVATEDATA_INVALIDFREEDATA + SetprivatedataInvalidfreedata = 52, + /// + /// D3D11_MESSAGE_ID_SETPRIVATEDATA_INVALIDIUNKNOWN + SetprivatedataInvalidiunknown = 53, + /// + /// D3D11_MESSAGE_ID_SETPRIVATEDATA_INVALIDFLAGS + SetprivatedataInvalidflags = 54, + /// + /// D3D11_MESSAGE_ID_SETPRIVATEDATA_CHANGINGPARAMS + SetprivatedataChangingparams = 55, + /// + /// D3D11_MESSAGE_ID_SETPRIVATEDATA_OUTOFMEMORY + SetprivatedataOutofmemory = 56, + /// + /// D3D11_MESSAGE_ID_CREATEBUFFER_UNRECOGNIZEDFORMAT + CreatebufferUnrecognizedformat = 57, + /// + /// D3D11_MESSAGE_ID_CREATEBUFFER_INVALIDSAMPLES + CreatebufferInvalidsamples = 58, + /// + /// D3D11_MESSAGE_ID_CREATEBUFFER_UNRECOGNIZEDUSAGE + CreatebufferUnrecognizedusage = 59, + /// + /// D3D11_MESSAGE_ID_CREATEBUFFER_UNRECOGNIZEDBINDFLAGS + CreatebufferUnrecognizedbindflags = 60, + /// + /// D3D11_MESSAGE_ID_CREATEBUFFER_UNRECOGNIZEDCPUACCESSFLAGS + CreatebufferUnrecognizedcpuaccessflags = 61, + /// + /// D3D11_MESSAGE_ID_CREATEBUFFER_UNRECOGNIZEDMISCFLAGS + CreatebufferUnrecognizedmiscflags = 62, + /// + /// D3D11_MESSAGE_ID_CREATEBUFFER_INVALIDCPUACCESSFLAGS + CreatebufferInvalidcpuaccessflags = 63, + /// + /// D3D11_MESSAGE_ID_CREATEBUFFER_INVALIDBINDFLAGS + CreatebufferInvalidbindflags = 64, + /// + /// D3D11_MESSAGE_ID_CREATEBUFFER_INVALIDINITIALDATA + CreatebufferInvalidinitialdata = 65, + /// + /// D3D11_MESSAGE_ID_CREATEBUFFER_INVALIDDIMENSIONS + CreatebufferInvaliddimensions = 66, + /// + /// D3D11_MESSAGE_ID_CREATEBUFFER_INVALIDMIPLEVELS + CreatebufferInvalidmiplevels = 67, + /// + /// D3D11_MESSAGE_ID_CREATEBUFFER_INVALIDMISCFLAGS + CreatebufferInvalidmiscflags = 68, + /// + /// D3D11_MESSAGE_ID_CREATEBUFFER_INVALIDARG_RETURN + CreatebufferInvalidargReturn = 69, + /// + /// D3D11_MESSAGE_ID_CREATEBUFFER_OUTOFMEMORY_RETURN + CreatebufferOutofmemoryReturn = 70, + /// + /// D3D11_MESSAGE_ID_CREATEBUFFER_NULLDESC + CreatebufferNulldesc = 71, + /// + /// D3D11_MESSAGE_ID_CREATEBUFFER_INVALIDCONSTANTBUFFERBINDINGS + CreatebufferInvalidconstantbufferbindings = 72, + /// + /// D3D11_MESSAGE_ID_CREATEBUFFER_LARGEALLOCATION + CreatebufferLargeallocation = 73, + /// + /// D3D11_MESSAGE_ID_CREATETEXTURE1D_UNRECOGNIZEDFORMAT + Createtexture1dUnrecognizedformat = 74, + /// + /// D3D11_MESSAGE_ID_CREATETEXTURE1D_UNSUPPORTEDFORMAT + Createtexture1dUnsupportedformat = 75, + /// + /// D3D11_MESSAGE_ID_CREATETEXTURE1D_INVALIDSAMPLES + Createtexture1dInvalidsamples = 76, + /// + /// D3D11_MESSAGE_ID_CREATETEXTURE1D_UNRECOGNIZEDUSAGE + Createtexture1dUnrecognizedusage = 77, + /// + /// D3D11_MESSAGE_ID_CREATETEXTURE1D_UNRECOGNIZEDBINDFLAGS + Createtexture1dUnrecognizedbindflags = 78, + /// + /// D3D11_MESSAGE_ID_CREATETEXTURE1D_UNRECOGNIZEDCPUACCESSFLAGS + Createtexture1dUnrecognizedcpuaccessflags = 79, + /// + /// D3D11_MESSAGE_ID_CREATETEXTURE1D_UNRECOGNIZEDMISCFLAGS + Createtexture1dUnrecognizedmiscflags = 80, + /// + /// D3D11_MESSAGE_ID_CREATETEXTURE1D_INVALIDCPUACCESSFLAGS + Createtexture1dInvalidcpuaccessflags = 81, + /// + /// D3D11_MESSAGE_ID_CREATETEXTURE1D_INVALIDBINDFLAGS + Createtexture1dInvalidbindflags = 82, + /// + /// D3D11_MESSAGE_ID_CREATETEXTURE1D_INVALIDINITIALDATA + Createtexture1dInvalidinitialdata = 83, + /// + /// D3D11_MESSAGE_ID_CREATETEXTURE1D_INVALIDDIMENSIONS + Createtexture1dInvaliddimensions = 84, + /// + /// D3D11_MESSAGE_ID_CREATETEXTURE1D_INVALIDMIPLEVELS + Createtexture1dInvalidmiplevels = 85, + /// + /// D3D11_MESSAGE_ID_CREATETEXTURE1D_INVALIDMISCFLAGS + Createtexture1dInvalidmiscflags = 86, + /// + /// D3D11_MESSAGE_ID_CREATETEXTURE1D_INVALIDARG_RETURN + Createtexture1dInvalidargReturn = 87, + /// + /// D3D11_MESSAGE_ID_CREATETEXTURE1D_OUTOFMEMORY_RETURN + Createtexture1dOutofmemoryReturn = 88, + /// + /// D3D11_MESSAGE_ID_CREATETEXTURE1D_NULLDESC + Createtexture1dNulldesc = 89, + /// + /// D3D11_MESSAGE_ID_CREATETEXTURE1D_LARGEALLOCATION + Createtexture1dLargeallocation = 90, + /// + /// D3D11_MESSAGE_ID_CREATETEXTURE2D_UNRECOGNIZEDFORMAT + Createtexture2dUnrecognizedformat = 91, + /// + /// D3D11_MESSAGE_ID_CREATETEXTURE2D_UNSUPPORTEDFORMAT + Createtexture2dUnsupportedformat = 92, + /// + /// D3D11_MESSAGE_ID_CREATETEXTURE2D_INVALIDSAMPLES + Createtexture2dInvalidsamples = 93, + /// + /// D3D11_MESSAGE_ID_CREATETEXTURE2D_UNRECOGNIZEDUSAGE + Createtexture2dUnrecognizedusage = 94, + /// + /// D3D11_MESSAGE_ID_CREATETEXTURE2D_UNRECOGNIZEDBINDFLAGS + Createtexture2dUnrecognizedbindflags = 95, + /// + /// D3D11_MESSAGE_ID_CREATETEXTURE2D_UNRECOGNIZEDCPUACCESSFLAGS + Createtexture2dUnrecognizedcpuaccessflags = 96, + /// + /// D3D11_MESSAGE_ID_CREATETEXTURE2D_UNRECOGNIZEDMISCFLAGS + Createtexture2dUnrecognizedmiscflags = 97, + /// + /// D3D11_MESSAGE_ID_CREATETEXTURE2D_INVALIDCPUACCESSFLAGS + Createtexture2dInvalidcpuaccessflags = 98, + /// + /// D3D11_MESSAGE_ID_CREATETEXTURE2D_INVALIDBINDFLAGS + Createtexture2dInvalidbindflags = 99, + /// + /// D3D11_MESSAGE_ID_CREATETEXTURE2D_INVALIDINITIALDATA + Createtexture2dInvalidinitialdata = 100, + /// + /// D3D11_MESSAGE_ID_CREATETEXTURE2D_INVALIDDIMENSIONS + Createtexture2dInvaliddimensions = 101, + /// + /// D3D11_MESSAGE_ID_CREATETEXTURE2D_INVALIDMIPLEVELS + Createtexture2dInvalidmiplevels = 102, + /// + /// D3D11_MESSAGE_ID_CREATETEXTURE2D_INVALIDMISCFLAGS + Createtexture2dInvalidmiscflags = 103, + /// + /// D3D11_MESSAGE_ID_CREATETEXTURE2D_INVALIDARG_RETURN + Createtexture2dInvalidargReturn = 104, + /// + /// D3D11_MESSAGE_ID_CREATETEXTURE2D_OUTOFMEMORY_RETURN + Createtexture2dOutofmemoryReturn = 105, + /// + /// D3D11_MESSAGE_ID_CREATETEXTURE2D_NULLDESC + Createtexture2dNulldesc = 106, + /// + /// D3D11_MESSAGE_ID_CREATETEXTURE2D_LARGEALLOCATION + Createtexture2dLargeallocation = 107, + /// + /// D3D11_MESSAGE_ID_CREATETEXTURE3D_UNRECOGNIZEDFORMAT + Createtexture3dUnrecognizedformat = 108, + /// + /// D3D11_MESSAGE_ID_CREATETEXTURE3D_UNSUPPORTEDFORMAT + Createtexture3dUnsupportedformat = 109, + /// + /// D3D11_MESSAGE_ID_CREATETEXTURE3D_INVALIDSAMPLES + Createtexture3dInvalidsamples = 110, + /// + /// D3D11_MESSAGE_ID_CREATETEXTURE3D_UNRECOGNIZEDUSAGE + Createtexture3dUnrecognizedusage = 111, + /// + /// D3D11_MESSAGE_ID_CREATETEXTURE3D_UNRECOGNIZEDBINDFLAGS + Createtexture3dUnrecognizedbindflags = 112, + /// + /// D3D11_MESSAGE_ID_CREATETEXTURE3D_UNRECOGNIZEDCPUACCESSFLAGS + Createtexture3dUnrecognizedcpuaccessflags = 113, + /// + /// D3D11_MESSAGE_ID_CREATETEXTURE3D_UNRECOGNIZEDMISCFLAGS + Createtexture3dUnrecognizedmiscflags = 114, + /// + /// D3D11_MESSAGE_ID_CREATETEXTURE3D_INVALIDCPUACCESSFLAGS + Createtexture3dInvalidcpuaccessflags = 115, + /// + /// D3D11_MESSAGE_ID_CREATETEXTURE3D_INVALIDBINDFLAGS + Createtexture3dInvalidbindflags = 116, + /// + /// D3D11_MESSAGE_ID_CREATETEXTURE3D_INVALIDINITIALDATA + Createtexture3dInvalidinitialdata = 117, + /// + /// D3D11_MESSAGE_ID_CREATETEXTURE3D_INVALIDDIMENSIONS + Createtexture3dInvaliddimensions = 118, + /// + /// D3D11_MESSAGE_ID_CREATETEXTURE3D_INVALIDMIPLEVELS + Createtexture3dInvalidmiplevels = 119, + /// + /// D3D11_MESSAGE_ID_CREATETEXTURE3D_INVALIDMISCFLAGS + Createtexture3dInvalidmiscflags = 120, + /// + /// D3D11_MESSAGE_ID_CREATETEXTURE3D_INVALIDARG_RETURN + Createtexture3dInvalidargReturn = 121, + /// + /// D3D11_MESSAGE_ID_CREATETEXTURE3D_OUTOFMEMORY_RETURN + Createtexture3dOutofmemoryReturn = 122, + /// + /// D3D11_MESSAGE_ID_CREATETEXTURE3D_NULLDESC + Createtexture3dNulldesc = 123, + /// + /// D3D11_MESSAGE_ID_CREATETEXTURE3D_LARGEALLOCATION + Createtexture3dLargeallocation = 124, + /// + /// D3D11_MESSAGE_ID_CREATESHADERRESOURCEVIEW_UNRECOGNIZEDFORMAT + CreateshaderresourceviewUnrecognizedformat = 125, + /// + /// D3D11_MESSAGE_ID_CREATESHADERRESOURCEVIEW_INVALIDDESC + CreateshaderresourceviewInvaliddesc = 126, + /// + /// D3D11_MESSAGE_ID_CREATESHADERRESOURCEVIEW_INVALIDFORMAT + CreateshaderresourceviewInvalidformat = 127, + /// + /// D3D11_MESSAGE_ID_CREATESHADERRESOURCEVIEW_INVALIDDIMENSIONS + CreateshaderresourceviewInvaliddimensions = 128, + /// + /// D3D11_MESSAGE_ID_CREATESHADERRESOURCEVIEW_INVALIDRESOURCE + CreateshaderresourceviewInvalidresource = 129, + /// + /// D3D11_MESSAGE_ID_CREATESHADERRESOURCEVIEW_TOOMANYOBJECTS + CreateshaderresourceviewToomanyobjects = 130, + /// + /// D3D11_MESSAGE_ID_CREATESHADERRESOURCEVIEW_INVALIDARG_RETURN + CreateshaderresourceviewInvalidargReturn = 131, + /// + /// D3D11_MESSAGE_ID_CREATESHADERRESOURCEVIEW_OUTOFMEMORY_RETURN + CreateshaderresourceviewOutofmemoryReturn = 132, + /// + /// D3D11_MESSAGE_ID_CREATERENDERTARGETVIEW_UNRECOGNIZEDFORMAT + CreaterendertargetviewUnrecognizedformat = 133, + /// + /// D3D11_MESSAGE_ID_CREATERENDERTARGETVIEW_UNSUPPORTEDFORMAT + CreaterendertargetviewUnsupportedformat = 134, + /// + /// D3D11_MESSAGE_ID_CREATERENDERTARGETVIEW_INVALIDDESC + CreaterendertargetviewInvaliddesc = 135, + /// + /// D3D11_MESSAGE_ID_CREATERENDERTARGETVIEW_INVALIDFORMAT + CreaterendertargetviewInvalidformat = 136, + /// + /// D3D11_MESSAGE_ID_CREATERENDERTARGETVIEW_INVALIDDIMENSIONS + CreaterendertargetviewInvaliddimensions = 137, + /// + /// D3D11_MESSAGE_ID_CREATERENDERTARGETVIEW_INVALIDRESOURCE + CreaterendertargetviewInvalidresource = 138, + /// + /// D3D11_MESSAGE_ID_CREATERENDERTARGETVIEW_TOOMANYOBJECTS + CreaterendertargetviewToomanyobjects = 139, + /// + /// D3D11_MESSAGE_ID_CREATERENDERTARGETVIEW_INVALIDARG_RETURN + CreaterendertargetviewInvalidargReturn = 140, + /// + /// D3D11_MESSAGE_ID_CREATERENDERTARGETVIEW_OUTOFMEMORY_RETURN + CreaterendertargetviewOutofmemoryReturn = 141, + /// + /// D3D11_MESSAGE_ID_CREATEDEPTHSTENCILVIEW_UNRECOGNIZEDFORMAT + CreatedepthstencilviewUnrecognizedformat = 142, + /// + /// D3D11_MESSAGE_ID_CREATEDEPTHSTENCILVIEW_INVALIDDESC + CreatedepthstencilviewInvaliddesc = 143, + /// + /// D3D11_MESSAGE_ID_CREATEDEPTHSTENCILVIEW_INVALIDFORMAT + CreatedepthstencilviewInvalidformat = 144, + /// + /// D3D11_MESSAGE_ID_CREATEDEPTHSTENCILVIEW_INVALIDDIMENSIONS + CreatedepthstencilviewInvaliddimensions = 145, + /// + /// D3D11_MESSAGE_ID_CREATEDEPTHSTENCILVIEW_INVALIDRESOURCE + CreatedepthstencilviewInvalidresource = 146, + /// + /// D3D11_MESSAGE_ID_CREATEDEPTHSTENCILVIEW_TOOMANYOBJECTS + CreatedepthstencilviewToomanyobjects = 147, + /// + /// D3D11_MESSAGE_ID_CREATEDEPTHSTENCILVIEW_INVALIDARG_RETURN + CreatedepthstencilviewInvalidargReturn = 148, + /// + /// D3D11_MESSAGE_ID_CREATEDEPTHSTENCILVIEW_OUTOFMEMORY_RETURN + CreatedepthstencilviewOutofmemoryReturn = 149, + /// + /// D3D11_MESSAGE_ID_CREATEINPUTLAYOUT_OUTOFMEMORY + CreateinputlayoutOutofmemory = 150, + /// + /// D3D11_MESSAGE_ID_CREATEINPUTLAYOUT_TOOMANYELEMENTS + CreateinputlayoutToomanyelements = 151, + /// + /// D3D11_MESSAGE_ID_CREATEINPUTLAYOUT_INVALIDFORMAT + CreateinputlayoutInvalidformat = 152, + /// + /// D3D11_MESSAGE_ID_CREATEINPUTLAYOUT_INCOMPATIBLEFORMAT + CreateinputlayoutIncompatibleformat = 153, + /// + /// D3D11_MESSAGE_ID_CREATEINPUTLAYOUT_INVALIDSLOT + CreateinputlayoutInvalidslot = 154, + /// + /// D3D11_MESSAGE_ID_CREATEINPUTLAYOUT_INVALIDINPUTSLOTCLASS + CreateinputlayoutInvalidinputslotclass = 155, + /// + /// D3D11_MESSAGE_ID_CREATEINPUTLAYOUT_STEPRATESLOTCLASSMISMATCH + CreateinputlayoutSteprateslotclassmismatch = 156, + /// + /// D3D11_MESSAGE_ID_CREATEINPUTLAYOUT_INVALIDSLOTCLASSCHANGE + CreateinputlayoutInvalidslotclasschange = 157, + /// + /// D3D11_MESSAGE_ID_CREATEINPUTLAYOUT_INVALIDSTEPRATECHANGE + CreateinputlayoutInvalidstepratechange = 158, + /// + /// D3D11_MESSAGE_ID_CREATEINPUTLAYOUT_INVALIDALIGNMENT + CreateinputlayoutInvalidalignment = 159, + /// + /// D3D11_MESSAGE_ID_CREATEINPUTLAYOUT_DUPLICATESEMANTIC + CreateinputlayoutDuplicatesemantic = 160, + /// + /// D3D11_MESSAGE_ID_CREATEINPUTLAYOUT_UNPARSEABLEINPUTSIGNATURE + CreateinputlayoutUnparseableinputsignature = 161, + /// + /// D3D11_MESSAGE_ID_CREATEINPUTLAYOUT_NULLSEMANTIC + CreateinputlayoutNullsemantic = 162, + /// + /// D3D11_MESSAGE_ID_CREATEINPUTLAYOUT_MISSINGELEMENT + CreateinputlayoutMissingelement = 163, + /// + /// D3D11_MESSAGE_ID_CREATEINPUTLAYOUT_NULLDESC + CreateinputlayoutNulldesc = 164, + /// + /// D3D11_MESSAGE_ID_CREATEVERTEXSHADER_OUTOFMEMORY + CreatevertexshaderOutofmemory = 165, + /// + /// D3D11_MESSAGE_ID_CREATEVERTEXSHADER_INVALIDSHADERBYTECODE + CreatevertexshaderInvalidshaderbytecode = 166, + /// + /// D3D11_MESSAGE_ID_CREATEVERTEXSHADER_INVALIDSHADERTYPE + CreatevertexshaderInvalidshadertype = 167, + /// + /// D3D11_MESSAGE_ID_CREATEGEOMETRYSHADER_OUTOFMEMORY + CreategeometryshaderOutofmemory = 168, + /// + /// D3D11_MESSAGE_ID_CREATEGEOMETRYSHADER_INVALIDSHADERBYTECODE + CreategeometryshaderInvalidshaderbytecode = 169, + /// + /// D3D11_MESSAGE_ID_CREATEGEOMETRYSHADER_INVALIDSHADERTYPE + CreategeometryshaderInvalidshadertype = 170, + /// + /// D3D11_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_OUTOFMEMORY + CreategeometryshaderwithstreamoutputOutofmemory = 171, + /// + /// D3D11_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_INVALIDSHADERBYTECODE + CreategeometryshaderwithstreamoutputInvalidshaderbytecode = 172, + /// + /// D3D11_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_INVALIDSHADERTYPE + CreategeometryshaderwithstreamoutputInvalidshadertype = 173, + /// + /// D3D11_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_INVALIDNUMENTRIES + CreategeometryshaderwithstreamoutputInvalidnumentries = 174, + /// + /// D3D11_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_OUTPUTSTREAMSTRIDEUNUSED + CreategeometryshaderwithstreamoutputOutputstreamstrideunused = 175, + /// + /// D3D11_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_UNEXPECTEDDECL + CreategeometryshaderwithstreamoutputUnexpecteddecl = 176, + /// + /// D3D11_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_EXPECTEDDECL + CreategeometryshaderwithstreamoutputExpecteddecl = 177, + /// + /// D3D11_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_OUTPUTSLOT0EXPECTED + CreategeometryshaderwithstreamoutputOutputslot0expected = 178, + /// + /// D3D11_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_INVALIDOUTPUTSLOT + CreategeometryshaderwithstreamoutputInvalidoutputslot = 179, + /// + /// D3D11_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_ONLYONEELEMENTPERSLOT + CreategeometryshaderwithstreamoutputOnlyoneelementperslot = 180, + /// + /// D3D11_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_INVALIDCOMPONENTCOUNT + CreategeometryshaderwithstreamoutputInvalidcomponentcount = 181, + /// + /// D3D11_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_INVALIDSTARTCOMPONENTANDCOMPONENTCOUNT + CreategeometryshaderwithstreamoutputInvalidstartcomponentandcomponentcount = 182, + /// + /// D3D11_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_INVALIDGAPDEFINITION + CreategeometryshaderwithstreamoutputInvalidgapdefinition = 183, + /// + /// D3D11_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_REPEATEDOUTPUT + CreategeometryshaderwithstreamoutputRepeatedoutput = 184, + /// + /// D3D11_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_INVALIDOUTPUTSTREAMSTRIDE + CreategeometryshaderwithstreamoutputInvalidoutputstreamstride = 185, + /// + /// D3D11_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_MISSINGSEMANTIC + CreategeometryshaderwithstreamoutputMissingsemantic = 186, + /// + /// D3D11_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_MASKMISMATCH + CreategeometryshaderwithstreamoutputMaskmismatch = 187, + /// + /// D3D11_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_CANTHAVEONLYGAPS + CreategeometryshaderwithstreamoutputCanthaveonlygaps = 188, + /// + /// D3D11_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_DECLTOOCOMPLEX + CreategeometryshaderwithstreamoutputDecltoocomplex = 189, + /// + /// D3D11_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_MISSINGOUTPUTSIGNATURE + CreategeometryshaderwithstreamoutputMissingoutputsignature = 190, + /// + /// D3D11_MESSAGE_ID_CREATEPIXELSHADER_OUTOFMEMORY + CreatepixelshaderOutofmemory = 191, + /// + /// D3D11_MESSAGE_ID_CREATEPIXELSHADER_INVALIDSHADERBYTECODE + CreatepixelshaderInvalidshaderbytecode = 192, + /// + /// D3D11_MESSAGE_ID_CREATEPIXELSHADER_INVALIDSHADERTYPE + CreatepixelshaderInvalidshadertype = 193, + /// + /// D3D11_MESSAGE_ID_CREATERASTERIZERSTATE_INVALIDFILLMODE + CreaterasterizerstateInvalidfillmode = 194, + /// + /// D3D11_MESSAGE_ID_CREATERASTERIZERSTATE_INVALIDCULLMODE + CreaterasterizerstateInvalidcullmode = 195, + /// + /// D3D11_MESSAGE_ID_CREATERASTERIZERSTATE_INVALIDDEPTHBIASCLAMP + CreaterasterizerstateInvaliddepthbiasclamp = 196, + /// + /// D3D11_MESSAGE_ID_CREATERASTERIZERSTATE_INVALIDSLOPESCALEDDEPTHBIAS + CreaterasterizerstateInvalidslopescaleddepthbias = 197, + /// + /// D3D11_MESSAGE_ID_CREATERASTERIZERSTATE_TOOMANYOBJECTS + CreaterasterizerstateToomanyobjects = 198, + /// + /// D3D11_MESSAGE_ID_CREATERASTERIZERSTATE_NULLDESC + CreaterasterizerstateNulldesc = 199, + /// + /// D3D11_MESSAGE_ID_CREATEDEPTHSTENCILSTATE_INVALIDDEPTHWRITEMASK + CreatedepthstencilstateInvaliddepthwritemask = 200, + /// + /// D3D11_MESSAGE_ID_CREATEDEPTHSTENCILSTATE_INVALIDDEPTHFUNC + CreatedepthstencilstateInvaliddepthfunc = 201, + /// + /// D3D11_MESSAGE_ID_CREATEDEPTHSTENCILSTATE_INVALIDFRONTFACESTENCILFAILOP + CreatedepthstencilstateInvalidfrontfacestencilfailop = 202, + /// + /// D3D11_MESSAGE_ID_CREATEDEPTHSTENCILSTATE_INVALIDFRONTFACESTENCILZFAILOP + CreatedepthstencilstateInvalidfrontfacestencilzfailop = 203, + /// + /// D3D11_MESSAGE_ID_CREATEDEPTHSTENCILSTATE_INVALIDFRONTFACESTENCILPASSOP + CreatedepthstencilstateInvalidfrontfacestencilpassop = 204, + /// + /// D3D11_MESSAGE_ID_CREATEDEPTHSTENCILSTATE_INVALIDFRONTFACESTENCILFUNC + CreatedepthstencilstateInvalidfrontfacestencilfunc = 205, + /// + /// D3D11_MESSAGE_ID_CREATEDEPTHSTENCILSTATE_INVALIDBACKFACESTENCILFAILOP + CreatedepthstencilstateInvalidbackfacestencilfailop = 206, + /// + /// D3D11_MESSAGE_ID_CREATEDEPTHSTENCILSTATE_INVALIDBACKFACESTENCILZFAILOP + CreatedepthstencilstateInvalidbackfacestencilzfailop = 207, + /// + /// D3D11_MESSAGE_ID_CREATEDEPTHSTENCILSTATE_INVALIDBACKFACESTENCILPASSOP + CreatedepthstencilstateInvalidbackfacestencilpassop = 208, + /// + /// D3D11_MESSAGE_ID_CREATEDEPTHSTENCILSTATE_INVALIDBACKFACESTENCILFUNC + CreatedepthstencilstateInvalidbackfacestencilfunc = 209, + /// + /// D3D11_MESSAGE_ID_CREATEDEPTHSTENCILSTATE_TOOMANYOBJECTS + CreatedepthstencilstateToomanyobjects = 210, + /// + /// D3D11_MESSAGE_ID_CREATEDEPTHSTENCILSTATE_NULLDESC + CreatedepthstencilstateNulldesc = 211, + /// + /// D3D11_MESSAGE_ID_CREATEBLENDSTATE_INVALIDSRCBLEND + CreateblendstateInvalidsrcblend = 212, + /// + /// D3D11_MESSAGE_ID_CREATEBLENDSTATE_INVALIDDESTBLEND + CreateblendstateInvaliddestblend = 213, + /// + /// D3D11_MESSAGE_ID_CREATEBLENDSTATE_INVALIDBLENDOP + CreateblendstateInvalidblendop = 214, + /// + /// D3D11_MESSAGE_ID_CREATEBLENDSTATE_INVALIDSRCBLENDALPHA + CreateblendstateInvalidsrcblendalpha = 215, + /// + /// D3D11_MESSAGE_ID_CREATEBLENDSTATE_INVALIDDESTBLENDALPHA + CreateblendstateInvaliddestblendalpha = 216, + /// + /// D3D11_MESSAGE_ID_CREATEBLENDSTATE_INVALIDBLENDOPALPHA + CreateblendstateInvalidblendopalpha = 217, + /// + /// D3D11_MESSAGE_ID_CREATEBLENDSTATE_INVALIDRENDERTARGETWRITEMASK + CreateblendstateInvalidrendertargetwritemask = 218, + /// + /// D3D11_MESSAGE_ID_CREATEBLENDSTATE_TOOMANYOBJECTS + CreateblendstateToomanyobjects = 219, + /// + /// D3D11_MESSAGE_ID_CREATEBLENDSTATE_NULLDESC + CreateblendstateNulldesc = 220, + /// + /// D3D11_MESSAGE_ID_CREATESAMPLERSTATE_INVALIDFILTER + CreatesamplerstateInvalidfilter = 221, + /// + /// D3D11_MESSAGE_ID_CREATESAMPLERSTATE_INVALIDADDRESSU + CreatesamplerstateInvalidaddressu = 222, + /// + /// D3D11_MESSAGE_ID_CREATESAMPLERSTATE_INVALIDADDRESSV + CreatesamplerstateInvalidaddressv = 223, + /// + /// D3D11_MESSAGE_ID_CREATESAMPLERSTATE_INVALIDADDRESSW + CreatesamplerstateInvalidaddressw = 224, + /// + /// D3D11_MESSAGE_ID_CREATESAMPLERSTATE_INVALIDMIPLODBIAS + CreatesamplerstateInvalidmiplodbias = 225, + /// + /// D3D11_MESSAGE_ID_CREATESAMPLERSTATE_INVALIDMAXANISOTROPY + CreatesamplerstateInvalidmaxanisotropy = 226, + /// + /// D3D11_MESSAGE_ID_CREATESAMPLERSTATE_INVALIDCOMPARISONFUNC + CreatesamplerstateInvalidcomparisonfunc = 227, + /// + /// D3D11_MESSAGE_ID_CREATESAMPLERSTATE_INVALIDMINLOD + CreatesamplerstateInvalidminlod = 228, + /// + /// D3D11_MESSAGE_ID_CREATESAMPLERSTATE_INVALIDMAXLOD + CreatesamplerstateInvalidmaxlod = 229, + /// + /// D3D11_MESSAGE_ID_CREATESAMPLERSTATE_TOOMANYOBJECTS + CreatesamplerstateToomanyobjects = 230, + /// + /// D3D11_MESSAGE_ID_CREATESAMPLERSTATE_NULLDESC + CreatesamplerstateNulldesc = 231, + /// + /// D3D11_MESSAGE_ID_CREATEQUERYORPREDICATE_INVALIDQUERY + CreatequeryorpredicateInvalidquery = 232, + /// + /// D3D11_MESSAGE_ID_CREATEQUERYORPREDICATE_INVALIDMISCFLAGS + CreatequeryorpredicateInvalidmiscflags = 233, + /// + /// D3D11_MESSAGE_ID_CREATEQUERYORPREDICATE_UNEXPECTEDMISCFLAG + CreatequeryorpredicateUnexpectedmiscflag = 234, + /// + /// D3D11_MESSAGE_ID_CREATEQUERYORPREDICATE_NULLDESC + CreatequeryorpredicateNulldesc = 235, + /// + /// D3D11_MESSAGE_ID_DEVICE_IASETPRIMITIVETOPOLOGY_TOPOLOGY_UNRECOGNIZED + DeviceIasetprimitivetopologyTopologyUnrecognized = 236, + /// + /// D3D11_MESSAGE_ID_DEVICE_IASETPRIMITIVETOPOLOGY_TOPOLOGY_UNDEFINED + DeviceIasetprimitivetopologyTopologyUndefined = 237, + /// + /// D3D11_MESSAGE_ID_IASETVERTEXBUFFERS_INVALIDBUFFER + IasetvertexbuffersInvalidbuffer = 238, + /// + /// D3D11_MESSAGE_ID_DEVICE_IASETVERTEXBUFFERS_OFFSET_TOO_LARGE + DeviceIasetvertexbuffersOffsetTooLarge = 239, + /// + /// D3D11_MESSAGE_ID_DEVICE_IASETVERTEXBUFFERS_BUFFERS_EMPTY + DeviceIasetvertexbuffersBuffersEmpty = 240, + /// + /// D3D11_MESSAGE_ID_IASETINDEXBUFFER_INVALIDBUFFER + IasetindexbufferInvalidbuffer = 241, + /// + /// D3D11_MESSAGE_ID_DEVICE_IASETINDEXBUFFER_FORMAT_INVALID + DeviceIasetindexbufferFormatInvalid = 242, + /// + /// D3D11_MESSAGE_ID_DEVICE_IASETINDEXBUFFER_OFFSET_TOO_LARGE + DeviceIasetindexbufferOffsetTooLarge = 243, + /// + /// D3D11_MESSAGE_ID_DEVICE_IASETINDEXBUFFER_OFFSET_UNALIGNED + DeviceIasetindexbufferOffsetUnaligned = 244, + /// + /// D3D11_MESSAGE_ID_DEVICE_VSSETSHADERRESOURCES_VIEWS_EMPTY + DeviceVssetshaderresourcesViewsEmpty = 245, + /// + /// D3D11_MESSAGE_ID_VSSETCONSTANTBUFFERS_INVALIDBUFFER + VssetconstantbuffersInvalidbuffer = 246, + /// + /// D3D11_MESSAGE_ID_DEVICE_VSSETCONSTANTBUFFERS_BUFFERS_EMPTY + DeviceVssetconstantbuffersBuffersEmpty = 247, + /// + /// D3D11_MESSAGE_ID_DEVICE_VSSETSAMPLERS_SAMPLERS_EMPTY + DeviceVssetsamplersSamplersEmpty = 248, + /// + /// D3D11_MESSAGE_ID_DEVICE_GSSETSHADERRESOURCES_VIEWS_EMPTY + DeviceGssetshaderresourcesViewsEmpty = 249, + /// + /// D3D11_MESSAGE_ID_GSSETCONSTANTBUFFERS_INVALIDBUFFER + GssetconstantbuffersInvalidbuffer = 250, + /// + /// D3D11_MESSAGE_ID_DEVICE_GSSETCONSTANTBUFFERS_BUFFERS_EMPTY + DeviceGssetconstantbuffersBuffersEmpty = 251, + /// + /// D3D11_MESSAGE_ID_DEVICE_GSSETSAMPLERS_SAMPLERS_EMPTY + DeviceGssetsamplersSamplersEmpty = 252, + /// + /// D3D11_MESSAGE_ID_SOSETTARGETS_INVALIDBUFFER + SosettargetsInvalidbuffer = 253, + /// + /// D3D11_MESSAGE_ID_DEVICE_SOSETTARGETS_OFFSET_UNALIGNED + DeviceSosettargetsOffsetUnaligned = 254, + /// + /// D3D11_MESSAGE_ID_DEVICE_PSSETSHADERRESOURCES_VIEWS_EMPTY + DevicePssetshaderresourcesViewsEmpty = 255, + /// + /// D3D11_MESSAGE_ID_PSSETCONSTANTBUFFERS_INVALIDBUFFER + PssetconstantbuffersInvalidbuffer = 256, + /// + /// D3D11_MESSAGE_ID_DEVICE_PSSETCONSTANTBUFFERS_BUFFERS_EMPTY + DevicePssetconstantbuffersBuffersEmpty = 257, + /// + /// D3D11_MESSAGE_ID_DEVICE_PSSETSAMPLERS_SAMPLERS_EMPTY + DevicePssetsamplersSamplersEmpty = 258, + /// + /// D3D11_MESSAGE_ID_DEVICE_RSSETVIEWPORTS_INVALIDVIEWPORT + DeviceRssetviewportsInvalidviewport = 259, + /// + /// D3D11_MESSAGE_ID_DEVICE_RSSETSCISSORRECTS_INVALIDSCISSOR + DeviceRssetscissorrectsInvalidscissor = 260, + /// + /// D3D11_MESSAGE_ID_CLEARRENDERTARGETVIEW_DENORMFLUSH + ClearrendertargetviewDenormflush = 261, + /// + /// D3D11_MESSAGE_ID_CLEARDEPTHSTENCILVIEW_DENORMFLUSH + CleardepthstencilviewDenormflush = 262, + /// + /// D3D11_MESSAGE_ID_CLEARDEPTHSTENCILVIEW_INVALID + CleardepthstencilviewInvalid = 263, + /// + /// D3D11_MESSAGE_ID_DEVICE_IAGETVERTEXBUFFERS_BUFFERS_EMPTY + DeviceIagetvertexbuffersBuffersEmpty = 264, + /// + /// D3D11_MESSAGE_ID_DEVICE_VSGETSHADERRESOURCES_VIEWS_EMPTY + DeviceVsgetshaderresourcesViewsEmpty = 265, + /// + /// D3D11_MESSAGE_ID_DEVICE_VSGETCONSTANTBUFFERS_BUFFERS_EMPTY + DeviceVsgetconstantbuffersBuffersEmpty = 266, + /// + /// D3D11_MESSAGE_ID_DEVICE_VSGETSAMPLERS_SAMPLERS_EMPTY + DeviceVsgetsamplersSamplersEmpty = 267, + /// + /// D3D11_MESSAGE_ID_DEVICE_GSGETSHADERRESOURCES_VIEWS_EMPTY + DeviceGsgetshaderresourcesViewsEmpty = 268, + /// + /// D3D11_MESSAGE_ID_DEVICE_GSGETCONSTANTBUFFERS_BUFFERS_EMPTY + DeviceGsgetconstantbuffersBuffersEmpty = 269, + /// + /// D3D11_MESSAGE_ID_DEVICE_GSGETSAMPLERS_SAMPLERS_EMPTY + DeviceGsgetsamplersSamplersEmpty = 270, + /// + /// D3D11_MESSAGE_ID_DEVICE_SOGETTARGETS_BUFFERS_EMPTY + DeviceSogettargetsBuffersEmpty = 271, + /// + /// D3D11_MESSAGE_ID_DEVICE_PSGETSHADERRESOURCES_VIEWS_EMPTY + DevicePsgetshaderresourcesViewsEmpty = 272, + /// + /// D3D11_MESSAGE_ID_DEVICE_PSGETCONSTANTBUFFERS_BUFFERS_EMPTY + DevicePsgetconstantbuffersBuffersEmpty = 273, + /// + /// D3D11_MESSAGE_ID_DEVICE_PSGETSAMPLERS_SAMPLERS_EMPTY + DevicePsgetsamplersSamplersEmpty = 274, + /// + /// D3D11_MESSAGE_ID_DEVICE_RSGETVIEWPORTS_VIEWPORTS_EMPTY + DeviceRsgetviewportsViewportsEmpty = 275, + /// + /// D3D11_MESSAGE_ID_DEVICE_RSGETSCISSORRECTS_RECTS_EMPTY + DeviceRsgetscissorrectsRectsEmpty = 276, + /// + /// D3D11_MESSAGE_ID_DEVICE_GENERATEMIPS_RESOURCE_INVALID + DeviceGeneratemipsResourceInvalid = 277, + /// + /// D3D11_MESSAGE_ID_COPYSUBRESOURCEREGION_INVALIDDESTINATIONSUBRESOURCE + CopysubresourceregionInvaliddestinationsubresource = 278, + /// + /// D3D11_MESSAGE_ID_COPYSUBRESOURCEREGION_INVALIDSOURCESUBRESOURCE + CopysubresourceregionInvalidsourcesubresource = 279, + /// + /// D3D11_MESSAGE_ID_COPYSUBRESOURCEREGION_INVALIDSOURCEBOX + CopysubresourceregionInvalidsourcebox = 280, + /// + /// D3D11_MESSAGE_ID_COPYSUBRESOURCEREGION_INVALIDSOURCE + CopysubresourceregionInvalidsource = 281, + /// + /// D3D11_MESSAGE_ID_COPYSUBRESOURCEREGION_INVALIDDESTINATIONSTATE + CopysubresourceregionInvaliddestinationstate = 282, + /// + /// D3D11_MESSAGE_ID_COPYSUBRESOURCEREGION_INVALIDSOURCESTATE + CopysubresourceregionInvalidsourcestate = 283, + /// + /// D3D11_MESSAGE_ID_COPYRESOURCE_INVALIDSOURCE + CopyresourceInvalidsource = 284, + /// + /// D3D11_MESSAGE_ID_COPYRESOURCE_INVALIDDESTINATIONSTATE + CopyresourceInvaliddestinationstate = 285, + /// + /// D3D11_MESSAGE_ID_COPYRESOURCE_INVALIDSOURCESTATE + CopyresourceInvalidsourcestate = 286, + /// + /// D3D11_MESSAGE_ID_UPDATESUBRESOURCE_INVALIDDESTINATIONSUBRESOURCE + UpdatesubresourceInvaliddestinationsubresource = 287, + /// + /// D3D11_MESSAGE_ID_UPDATESUBRESOURCE_INVALIDDESTINATIONBOX + UpdatesubresourceInvaliddestinationbox = 288, + /// + /// D3D11_MESSAGE_ID_UPDATESUBRESOURCE_INVALIDDESTINATIONSTATE + UpdatesubresourceInvaliddestinationstate = 289, + /// + /// D3D11_MESSAGE_ID_DEVICE_RESOLVESUBRESOURCE_DESTINATION_INVALID + DeviceResolvesubresourceDestinationInvalid = 290, + /// + /// D3D11_MESSAGE_ID_DEVICE_RESOLVESUBRESOURCE_DESTINATION_SUBRESOURCE_INVALID + DeviceResolvesubresourceDestinationSubresourceInvalid = 291, + /// + /// D3D11_MESSAGE_ID_DEVICE_RESOLVESUBRESOURCE_SOURCE_INVALID + DeviceResolvesubresourceSourceInvalid = 292, + /// + /// D3D11_MESSAGE_ID_DEVICE_RESOLVESUBRESOURCE_SOURCE_SUBRESOURCE_INVALID + DeviceResolvesubresourceSourceSubresourceInvalid = 293, + /// + /// D3D11_MESSAGE_ID_DEVICE_RESOLVESUBRESOURCE_FORMAT_INVALID + DeviceResolvesubresourceFormatInvalid = 294, + /// + /// D3D11_MESSAGE_ID_BUFFER_MAP_INVALIDMAPTYPE + BufferMapInvalidmaptype = 295, + /// + /// D3D11_MESSAGE_ID_BUFFER_MAP_INVALIDFLAGS + BufferMapInvalidflags = 296, + /// + /// D3D11_MESSAGE_ID_BUFFER_MAP_ALREADYMAPPED + BufferMapAlreadymapped = 297, + /// + /// D3D11_MESSAGE_ID_BUFFER_MAP_DEVICEREMOVED_RETURN + BufferMapDeviceremovedReturn = 298, + /// + /// D3D11_MESSAGE_ID_BUFFER_UNMAP_NOTMAPPED + BufferUnmapNotmapped = 299, + /// + /// D3D11_MESSAGE_ID_TEXTURE1D_MAP_INVALIDMAPTYPE + Texture1DMapInvalidmaptype = 300, + /// + /// D3D11_MESSAGE_ID_TEXTURE1D_MAP_INVALIDSUBRESOURCE + Texture1DMapInvalidsubresource = 301, + /// + /// D3D11_MESSAGE_ID_TEXTURE1D_MAP_INVALIDFLAGS + Texture1DMapInvalidflags = 302, + /// + /// D3D11_MESSAGE_ID_TEXTURE1D_MAP_ALREADYMAPPED + Texture1DMapAlreadymapped = 303, + /// + /// D3D11_MESSAGE_ID_TEXTURE1D_MAP_DEVICEREMOVED_RETURN + Texture1DMapDeviceremovedReturn = 304, + /// + /// D3D11_MESSAGE_ID_TEXTURE1D_UNMAP_INVALIDSUBRESOURCE + Texture1DUnmapInvalidsubresource = 305, + /// + /// D3D11_MESSAGE_ID_TEXTURE1D_UNMAP_NOTMAPPED + Texture1DUnmapNotmapped = 306, + /// + /// D3D11_MESSAGE_ID_TEXTURE2D_MAP_INVALIDMAPTYPE + Texture2DMapInvalidmaptype = 307, + /// + /// D3D11_MESSAGE_ID_TEXTURE2D_MAP_INVALIDSUBRESOURCE + Texture2DMapInvalidsubresource = 308, + /// + /// D3D11_MESSAGE_ID_TEXTURE2D_MAP_INVALIDFLAGS + Texture2DMapInvalidflags = 309, + /// + /// D3D11_MESSAGE_ID_TEXTURE2D_MAP_ALREADYMAPPED + Texture2DMapAlreadymapped = 310, + /// + /// D3D11_MESSAGE_ID_TEXTURE2D_MAP_DEVICEREMOVED_RETURN + Texture2DMapDeviceremovedReturn = 311, + /// + /// D3D11_MESSAGE_ID_TEXTURE2D_UNMAP_INVALIDSUBRESOURCE + Texture2DUnmapInvalidsubresource = 312, + /// + /// D3D11_MESSAGE_ID_TEXTURE2D_UNMAP_NOTMAPPED + Texture2DUnmapNotmapped = 313, + /// + /// D3D11_MESSAGE_ID_TEXTURE3D_MAP_INVALIDMAPTYPE + Texture3DMapInvalidmaptype = 314, + /// + /// D3D11_MESSAGE_ID_TEXTURE3D_MAP_INVALIDSUBRESOURCE + Texture3DMapInvalidsubresource = 315, + /// + /// D3D11_MESSAGE_ID_TEXTURE3D_MAP_INVALIDFLAGS + Texture3DMapInvalidflags = 316, + /// + /// D3D11_MESSAGE_ID_TEXTURE3D_MAP_ALREADYMAPPED + Texture3DMapAlreadymapped = 317, + /// + /// D3D11_MESSAGE_ID_TEXTURE3D_MAP_DEVICEREMOVED_RETURN + Texture3DMapDeviceremovedReturn = 318, + /// + /// D3D11_MESSAGE_ID_TEXTURE3D_UNMAP_INVALIDSUBRESOURCE + Texture3DUnmapInvalidsubresource = 319, + /// + /// D3D11_MESSAGE_ID_TEXTURE3D_UNMAP_NOTMAPPED + Texture3DUnmapNotmapped = 320, + /// + /// D3D11_MESSAGE_ID_CHECKFORMATSUPPORT_FORMAT_DEPRECATED + CheckformatsupportFormatDeprecated = 321, + /// + /// D3D11_MESSAGE_ID_CHECKMULTISAMPLEQUALITYLEVELS_FORMAT_DEPRECATED + CheckmultisamplequalitylevelsFormatDeprecated = 322, + /// + /// D3D11_MESSAGE_ID_SETEXCEPTIONMODE_UNRECOGNIZEDFLAGS + SetexceptionmodeUnrecognizedflags = 323, + /// + /// D3D11_MESSAGE_ID_SETEXCEPTIONMODE_INVALIDARG_RETURN + SetexceptionmodeInvalidargReturn = 324, + /// + /// D3D11_MESSAGE_ID_SETEXCEPTIONMODE_DEVICEREMOVED_RETURN + SetexceptionmodeDeviceremovedReturn = 325, + /// + /// D3D11_MESSAGE_ID_REF_SIMULATING_INFINITELY_FAST_HARDWARE + RefSimulatingInfinitelyFastHardware = 326, + /// + /// D3D11_MESSAGE_ID_REF_THREADING_MODE + RefThreadingMode = 327, + /// + /// D3D11_MESSAGE_ID_REF_UMDRIVER_EXCEPTION + RefUmdriverException = 328, + /// + /// D3D11_MESSAGE_ID_REF_KMDRIVER_EXCEPTION + RefKmdriverException = 329, + /// + /// D3D11_MESSAGE_ID_REF_HARDWARE_EXCEPTION + RefHardwareException = 330, + /// + /// D3D11_MESSAGE_ID_REF_ACCESSING_INDEXABLE_TEMP_OUT_OF_RANGE + RefAccessingIndexableTempOutOfRange = 331, + /// + /// D3D11_MESSAGE_ID_REF_PROBLEM_PARSING_SHADER + RefProblemParsingShader = 332, + /// + /// D3D11_MESSAGE_ID_REF_OUT_OF_MEMORY + RefOutOfMemory = 333, + /// + /// D3D11_MESSAGE_ID_REF_INFO + RefInfo = 334, + /// + /// D3D11_MESSAGE_ID_DEVICE_DRAW_VERTEXPOS_OVERFLOW + DeviceDrawVertexposOverflow = 335, + /// + /// D3D11_MESSAGE_ID_DEVICE_DRAWINDEXED_INDEXPOS_OVERFLOW + DeviceDrawindexedIndexposOverflow = 336, + /// + /// D3D11_MESSAGE_ID_DEVICE_DRAWINSTANCED_VERTEXPOS_OVERFLOW + DeviceDrawinstancedVertexposOverflow = 337, + /// + /// D3D11_MESSAGE_ID_DEVICE_DRAWINSTANCED_INSTANCEPOS_OVERFLOW + DeviceDrawinstancedInstanceposOverflow = 338, + /// + /// D3D11_MESSAGE_ID_DEVICE_DRAWINDEXEDINSTANCED_INSTANCEPOS_OVERFLOW + DeviceDrawindexedinstancedInstanceposOverflow = 339, + /// + /// D3D11_MESSAGE_ID_DEVICE_DRAWINDEXEDINSTANCED_INDEXPOS_OVERFLOW + DeviceDrawindexedinstancedIndexposOverflow = 340, + /// + /// D3D11_MESSAGE_ID_DEVICE_DRAW_VERTEX_SHADER_NOT_SET + DeviceDrawVertexShaderNotSet = 341, + /// + /// D3D11_MESSAGE_ID_DEVICE_SHADER_LINKAGE_SEMANTICNAME_NOT_FOUND + DeviceShaderLinkageSemanticnameNotFound = 342, + /// + /// D3D11_MESSAGE_ID_DEVICE_SHADER_LINKAGE_REGISTERINDEX + DeviceShaderLinkageRegisterindex = 343, + /// + /// D3D11_MESSAGE_ID_DEVICE_SHADER_LINKAGE_COMPONENTTYPE + DeviceShaderLinkageComponenttype = 344, + /// + /// D3D11_MESSAGE_ID_DEVICE_SHADER_LINKAGE_REGISTERMASK + DeviceShaderLinkageRegistermask = 345, + /// + /// D3D11_MESSAGE_ID_DEVICE_SHADER_LINKAGE_SYSTEMVALUE + DeviceShaderLinkageSystemvalue = 346, + /// + /// D3D11_MESSAGE_ID_DEVICE_SHADER_LINKAGE_NEVERWRITTEN_ALWAYSREADS + DeviceShaderLinkageNeverwrittenAlwaysreads = 347, + /// + /// D3D11_MESSAGE_ID_DEVICE_DRAW_VERTEX_BUFFER_NOT_SET + DeviceDrawVertexBufferNotSet = 348, + /// + /// D3D11_MESSAGE_ID_DEVICE_DRAW_INPUTLAYOUT_NOT_SET + DeviceDrawInputlayoutNotSet = 349, + /// + /// D3D11_MESSAGE_ID_DEVICE_DRAW_CONSTANT_BUFFER_NOT_SET + DeviceDrawConstantBufferNotSet = 350, + /// + /// D3D11_MESSAGE_ID_DEVICE_DRAW_CONSTANT_BUFFER_TOO_SMALL + DeviceDrawConstantBufferTooSmall = 351, + /// + /// D3D11_MESSAGE_ID_DEVICE_DRAW_SAMPLER_NOT_SET + DeviceDrawSamplerNotSet = 352, + /// + /// D3D11_MESSAGE_ID_DEVICE_DRAW_SHADERRESOURCEVIEW_NOT_SET + DeviceDrawShaderresourceviewNotSet = 353, + /// + /// D3D11_MESSAGE_ID_DEVICE_DRAW_VIEW_DIMENSION_MISMATCH + DeviceDrawViewDimensionMismatch = 354, + /// + /// D3D11_MESSAGE_ID_DEVICE_DRAW_VERTEX_BUFFER_STRIDE_TOO_SMALL + DeviceDrawVertexBufferStrideTooSmall = 355, + /// + /// D3D11_MESSAGE_ID_DEVICE_DRAW_VERTEX_BUFFER_TOO_SMALL + DeviceDrawVertexBufferTooSmall = 356, + /// + /// D3D11_MESSAGE_ID_DEVICE_DRAW_INDEX_BUFFER_NOT_SET + DeviceDrawIndexBufferNotSet = 357, + /// + /// D3D11_MESSAGE_ID_DEVICE_DRAW_INDEX_BUFFER_FORMAT_INVALID + DeviceDrawIndexBufferFormatInvalid = 358, + /// + /// D3D11_MESSAGE_ID_DEVICE_DRAW_INDEX_BUFFER_TOO_SMALL + DeviceDrawIndexBufferTooSmall = 359, + /// + /// D3D11_MESSAGE_ID_DEVICE_DRAW_GS_INPUT_PRIMITIVE_MISMATCH + DeviceDrawGsInputPrimitiveMismatch = 360, + /// + /// D3D11_MESSAGE_ID_DEVICE_DRAW_RESOURCE_RETURN_TYPE_MISMATCH + DeviceDrawResourceReturnTypeMismatch = 361, + /// + /// D3D11_MESSAGE_ID_DEVICE_DRAW_POSITION_NOT_PRESENT + DeviceDrawPositionNotPresent = 362, + /// + /// D3D11_MESSAGE_ID_DEVICE_DRAW_OUTPUT_STREAM_NOT_SET + DeviceDrawOutputStreamNotSet = 363, + /// + /// D3D11_MESSAGE_ID_DEVICE_DRAW_BOUND_RESOURCE_MAPPED + DeviceDrawBoundResourceMapped = 364, + /// + /// D3D11_MESSAGE_ID_DEVICE_DRAW_INVALID_PRIMITIVETOPOLOGY + DeviceDrawInvalidPrimitivetopology = 365, + /// + /// D3D11_MESSAGE_ID_DEVICE_DRAW_VERTEX_OFFSET_UNALIGNED + DeviceDrawVertexOffsetUnaligned = 366, + /// + /// D3D11_MESSAGE_ID_DEVICE_DRAW_VERTEX_STRIDE_UNALIGNED + DeviceDrawVertexStrideUnaligned = 367, + /// + /// D3D11_MESSAGE_ID_DEVICE_DRAW_INDEX_OFFSET_UNALIGNED + DeviceDrawIndexOffsetUnaligned = 368, + /// + /// D3D11_MESSAGE_ID_DEVICE_DRAW_OUTPUT_STREAM_OFFSET_UNALIGNED + DeviceDrawOutputStreamOffsetUnaligned = 369, + /// + /// D3D11_MESSAGE_ID_DEVICE_DRAW_RESOURCE_FORMAT_LD_UNSUPPORTED + DeviceDrawResourceFormatLdUnsupported = 370, + /// + /// D3D11_MESSAGE_ID_DEVICE_DRAW_RESOURCE_FORMAT_SAMPLE_UNSUPPORTED + DeviceDrawResourceFormatSampleUnsupported = 371, + /// + /// D3D11_MESSAGE_ID_DEVICE_DRAW_RESOURCE_FORMAT_SAMPLE_C_UNSUPPORTED + DeviceDrawResourceFormatSampleCUnsupported = 372, + /// + /// D3D11_MESSAGE_ID_DEVICE_DRAW_RESOURCE_MULTISAMPLE_UNSUPPORTED + DeviceDrawResourceMultisampleUnsupported = 373, + /// + /// D3D11_MESSAGE_ID_DEVICE_DRAW_SO_TARGETS_BOUND_WITHOUT_SOURCE + DeviceDrawSoTargetsBoundWithoutSource = 374, + /// + /// D3D11_MESSAGE_ID_DEVICE_DRAW_SO_STRIDE_LARGER_THAN_BUFFER + DeviceDrawSoStrideLargerThanBuffer = 375, + /// + /// D3D11_MESSAGE_ID_DEVICE_DRAW_OM_RENDER_TARGET_DOES_NOT_SUPPORT_BLENDING + DeviceDrawOmRenderTargetDoesNotSupportBlending = 376, + /// + /// D3D11_MESSAGE_ID_DEVICE_DRAW_OM_DUAL_SOURCE_BLENDING_CAN_ONLY_HAVE_RENDER_TARGET_0 + DeviceDrawOmDualSourceBlendingCanOnlyHaveRenderTarget0 = 377, + /// + /// D3D11_MESSAGE_ID_DEVICE_REMOVAL_PROCESS_AT_FAULT + DeviceRemovalProcessAtFault = 378, + /// + /// D3D11_MESSAGE_ID_DEVICE_REMOVAL_PROCESS_POSSIBLY_AT_FAULT + DeviceRemovalProcessPossiblyAtFault = 379, + /// + /// D3D11_MESSAGE_ID_DEVICE_REMOVAL_PROCESS_NOT_AT_FAULT + DeviceRemovalProcessNotAtFault = 380, + /// + /// D3D11_MESSAGE_ID_DEVICE_OPEN_SHARED_RESOURCE_INVALIDARG_RETURN + DeviceOpenSharedResourceInvalidargReturn = 381, + /// + /// D3D11_MESSAGE_ID_DEVICE_OPEN_SHARED_RESOURCE_OUTOFMEMORY_RETURN + DeviceOpenSharedResourceOutofmemoryReturn = 382, + /// + /// D3D11_MESSAGE_ID_DEVICE_OPEN_SHARED_RESOURCE_BADINTERFACE_RETURN + DeviceOpenSharedResourceBadinterfaceReturn = 383, + /// + /// D3D11_MESSAGE_ID_DEVICE_DRAW_VIEWPORT_NOT_SET + DeviceDrawViewportNotSet = 384, + /// + /// D3D11_MESSAGE_ID_CREATEINPUTLAYOUT_TRAILING_DIGIT_IN_SEMANTIC + CreateinputlayoutTrailingDigitInSemantic = 385, + /// + /// D3D11_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_TRAILING_DIGIT_IN_SEMANTIC + CreategeometryshaderwithstreamoutputTrailingDigitInSemantic = 386, + /// + /// D3D11_MESSAGE_ID_DEVICE_RSSETVIEWPORTS_DENORMFLUSH + DeviceRssetviewportsDenormflush = 387, + /// + /// D3D11_MESSAGE_ID_OMSETRENDERTARGETS_INVALIDVIEW + OmsetrendertargetsInvalidview = 388, + /// + /// D3D11_MESSAGE_ID_DEVICE_SETTEXTFILTERSIZE_INVALIDDIMENSIONS + DeviceSettextfiltersizeInvaliddimensions = 389, + /// + /// D3D11_MESSAGE_ID_DEVICE_DRAW_SAMPLER_MISMATCH + DeviceDrawSamplerMismatch = 390, + /// + /// D3D11_MESSAGE_ID_CREATEINPUTLAYOUT_TYPE_MISMATCH + CreateinputlayoutTypeMismatch = 391, + /// + /// D3D11_MESSAGE_ID_BLENDSTATE_GETDESC_LEGACY + BlendstateGetdescLegacy = 392, + /// + /// D3D11_MESSAGE_ID_SHADERRESOURCEVIEW_GETDESC_LEGACY + ShaderresourceviewGetdescLegacy = 393, + /// + /// D3D11_MESSAGE_ID_CREATEQUERY_OUTOFMEMORY_RETURN + CreatequeryOutofmemoryReturn = 394, + /// + /// D3D11_MESSAGE_ID_CREATEPREDICATE_OUTOFMEMORY_RETURN + CreatepredicateOutofmemoryReturn = 395, + /// + /// D3D11_MESSAGE_ID_CREATECOUNTER_OUTOFRANGE_COUNTER + CreatecounterOutofrangeCounter = 396, + /// + /// D3D11_MESSAGE_ID_CREATECOUNTER_SIMULTANEOUS_ACTIVE_COUNTERS_EXHAUSTED + CreatecounterSimultaneousActiveCountersExhausted = 397, + /// + /// D3D11_MESSAGE_ID_CREATECOUNTER_UNSUPPORTED_WELLKNOWN_COUNTER + CreatecounterUnsupportedWellknownCounter = 398, + /// + /// D3D11_MESSAGE_ID_CREATECOUNTER_OUTOFMEMORY_RETURN + CreatecounterOutofmemoryReturn = 399, + /// + /// D3D11_MESSAGE_ID_CREATECOUNTER_NONEXCLUSIVE_RETURN + CreatecounterNonexclusiveReturn = 400, + /// + /// D3D11_MESSAGE_ID_CREATECOUNTER_NULLDESC + CreatecounterNulldesc = 401, + /// + /// D3D11_MESSAGE_ID_CHECKCOUNTER_OUTOFRANGE_COUNTER + CheckcounterOutofrangeCounter = 402, + /// + /// D3D11_MESSAGE_ID_CHECKCOUNTER_UNSUPPORTED_WELLKNOWN_COUNTER + CheckcounterUnsupportedWellknownCounter = 403, + /// + /// D3D11_MESSAGE_ID_SETPREDICATION_INVALID_PREDICATE_STATE + SetpredicationInvalidPredicateState = 404, + /// + /// D3D11_MESSAGE_ID_QUERY_BEGIN_UNSUPPORTED + QueryBeginUnsupported = 405, + /// + /// D3D11_MESSAGE_ID_PREDICATE_BEGIN_DURING_PREDICATION + PredicateBeginDuringPredication = 406, + /// + /// D3D11_MESSAGE_ID_QUERY_BEGIN_DUPLICATE + QueryBeginDuplicate = 407, + /// + /// D3D11_MESSAGE_ID_QUERY_BEGIN_ABANDONING_PREVIOUS_RESULTS + QueryBeginAbandoningPreviousResults = 408, + /// + /// D3D11_MESSAGE_ID_PREDICATE_END_DURING_PREDICATION + PredicateEndDuringPredication = 409, + /// + /// D3D11_MESSAGE_ID_QUERY_END_ABANDONING_PREVIOUS_RESULTS + QueryEndAbandoningPreviousResults = 410, + /// + /// D3D11_MESSAGE_ID_QUERY_END_WITHOUT_BEGIN + QueryEndWithoutBegin = 411, + /// + /// D3D11_MESSAGE_ID_QUERY_GETDATA_INVALID_DATASIZE + QueryGetdataInvalidDatasize = 412, + /// + /// D3D11_MESSAGE_ID_QUERY_GETDATA_INVALID_FLAGS + QueryGetdataInvalidFlags = 413, + /// + /// D3D11_MESSAGE_ID_QUERY_GETDATA_INVALID_CALL + QueryGetdataInvalidCall = 414, + /// + /// D3D11_MESSAGE_ID_DEVICE_DRAW_PS_OUTPUT_TYPE_MISMATCH + DeviceDrawPsOutputTypeMismatch = 415, + /// + /// D3D11_MESSAGE_ID_DEVICE_DRAW_RESOURCE_FORMAT_GATHER_UNSUPPORTED + DeviceDrawResourceFormatGatherUnsupported = 416, + /// + /// D3D11_MESSAGE_ID_DEVICE_DRAW_INVALID_USE_OF_CENTER_MULTISAMPLE_PATTERN + DeviceDrawInvalidUseOfCenterMultisamplePattern = 417, + /// + /// D3D11_MESSAGE_ID_DEVICE_IASETVERTEXBUFFERS_STRIDE_TOO_LARGE + DeviceIasetvertexbuffersStrideTooLarge = 418, + /// + /// D3D11_MESSAGE_ID_DEVICE_IASETVERTEXBUFFERS_INVALIDRANGE + DeviceIasetvertexbuffersInvalidrange = 419, + /// + /// D3D11_MESSAGE_ID_CREATEINPUTLAYOUT_EMPTY_LAYOUT + CreateinputlayoutEmptyLayout = 420, + /// + /// D3D11_MESSAGE_ID_DEVICE_DRAW_RESOURCE_SAMPLE_COUNT_MISMATCH + DeviceDrawResourceSampleCountMismatch = 421, + /// + /// D3D11_MESSAGE_ID_LIVE_OBJECT_SUMMARY + LiveObjectSummary = 422, + /// + /// D3D11_MESSAGE_ID_LIVE_BUFFER + LiveBuffer = 423, + /// + /// D3D11_MESSAGE_ID_LIVE_TEXTURE1D + LiveTexture1D = 424, + /// + /// D3D11_MESSAGE_ID_LIVE_TEXTURE2D + LiveTexture2D = 425, + /// + /// D3D11_MESSAGE_ID_LIVE_TEXTURE3D + LiveTexture3D = 426, + /// + /// D3D11_MESSAGE_ID_LIVE_SHADERRESOURCEVIEW + LiveShaderresourceview = 427, + /// + /// D3D11_MESSAGE_ID_LIVE_RENDERTARGETVIEW + LiveRenderTargetView = 428, + /// + /// D3D11_MESSAGE_ID_LIVE_DEPTHSTENCILVIEW + LiveDepthStencilView = 429, + /// + /// D3D11_MESSAGE_ID_LIVE_VERTEXSHADER + LiveVertexShader = 430, + /// + /// D3D11_MESSAGE_ID_LIVE_GEOMETRYSHADER + LiveGeometryShader = 431, + /// + /// D3D11_MESSAGE_ID_LIVE_PIXELSHADER + LivePixelShader = 432, + /// + /// D3D11_MESSAGE_ID_LIVE_INPUTLAYOUT + LiveInputlayout = 433, + /// + /// D3D11_MESSAGE_ID_LIVE_SAMPLER + LiveSampler = 434, + /// + /// D3D11_MESSAGE_ID_LIVE_BLENDSTATE + LiveBlendstate = 435, + /// + /// D3D11_MESSAGE_ID_LIVE_DEPTHSTENCILSTATE + LiveDepthstencilstate = 436, + /// + /// D3D11_MESSAGE_ID_LIVE_RASTERIZERSTATE + LiveRasterizerstate = 437, + /// + /// D3D11_MESSAGE_ID_LIVE_QUERY + LiveQuery = 438, + /// + /// D3D11_MESSAGE_ID_LIVE_PREDICATE + LivePredicate = 439, + /// + /// D3D11_MESSAGE_ID_LIVE_COUNTER + LiveCounter = 440, + /// + /// D3D11_MESSAGE_ID_LIVE_DEVICE + LiveDevice = 441, + /// + /// D3D11_MESSAGE_ID_LIVE_SWAPCHAIN + LiveSwapchain = 442, + /// + /// D3D11_MESSAGE_ID_CREATEDEPTHSTENCILSTATE_STENCIL_NO_TWO_SIDED + CreatedepthstencilstateStencilNoTwoSided = 1048577, + /// + /// D3D11_MESSAGE_ID_CREATERASTERIZERSTATE_DepthBiasClamp_NOT_SUPPORTED + CreaterasterizerstateDepthbiasclampNotSupported = 1048578, + /// + /// D3D11_MESSAGE_ID_CREATESAMPLERSTATE_NO_COMPARISON_SUPPORT + CreatesamplerstateNoComparisonSupport = 1048579, + /// + /// D3D11_MESSAGE_ID_CREATESAMPLERSTATE_EXCESSIVE_ANISOTROPY + CreatesamplerstateExcessiveAnisotropy = 1048580, + /// + /// D3D11_MESSAGE_ID_CREATESAMPLERSTATE_BORDER_OUT_OF_RANGE + CreatesamplerstateBorderOutOfRange = 1048581, + /// + /// D3D11_MESSAGE_ID_VSSETSAMPLERS_NOT_SUPPORTED + VssetsamplersNotSupported = 1048582, + /// + /// D3D11_MESSAGE_ID_VSSETSAMPLERS_TOO_MANY_SAMPLERS + VssetsamplersTooManySamplers = 1048583, + /// + /// D3D11_MESSAGE_ID_PSSETSAMPLERS_TOO_MANY_SAMPLERS + PssetsamplersTooManySamplers = 1048584, + /// + /// D3D11_MESSAGE_ID_CREATERESOURCE_NO_ARRAYS + CreateresourceNoArrays = 1048585, + /// + /// D3D11_MESSAGE_ID_CREATERESOURCE_NO_VB_AND_IB_BIND + CreateresourceNoVbAndIbBind = 1048586, + /// + /// D3D11_MESSAGE_ID_CREATERESOURCE_NO_TEXTURE_1D + CreateresourceNoTexture1d = 1048587, + /// + /// D3D11_MESSAGE_ID_CREATERESOURCE_DIMENSION_OUT_OF_RANGE + CreateresourceDimensionOutOfRange = 1048588, + /// + /// D3D11_MESSAGE_ID_CREATERESOURCE_NOT_BINDABLE_AS_SHADER_RESOURCE + CreateresourceNotBindableAsShaderResource = 1048589, + /// + /// D3D11_MESSAGE_ID_OMSETRENDERTARGETS_TOO_MANY_RENDER_TARGETS + OmsetrendertargetsTooManyRenderTargets = 1048590, + /// + /// D3D11_MESSAGE_ID_OMSETRENDERTARGETS_NO_DIFFERING_BIT_DEPTHS + OmsetrendertargetsNoDifferingBitDepths = 1048591, + /// + /// D3D11_MESSAGE_ID_IASETVERTEXBUFFERS_BAD_BUFFER_INDEX + IasetvertexbuffersBadBufferIndex = 1048592, + /// + /// D3D11_MESSAGE_ID_DEVICE_RSSETVIEWPORTS_TOO_MANY_VIEWPORTS + DeviceRssetviewportsTooManyViewports = 1048593, + /// + /// D3D11_MESSAGE_ID_DEVICE_IASETPRIMITIVETOPOLOGY_ADJACENCY_UNSUPPORTED + DeviceIasetprimitivetopologyAdjacencyUnsupported = 1048594, + /// + /// D3D11_MESSAGE_ID_DEVICE_RSSETSCISSORRECTS_TOO_MANY_SCISSORS + DeviceRssetscissorrectsTooManyScissors = 1048595, + /// + /// D3D11_MESSAGE_ID_COPYRESOURCE_ONLY_TEXTURE_2D_WITHIN_GPU_MEMORY + CopyresourceOnlyTexture2dWithinGpuMemory = 1048596, + /// + /// D3D11_MESSAGE_ID_COPYRESOURCE_NO_TEXTURE_3D_READBACK + CopyresourceNoTexture3dReadback = 1048597, + /// + /// D3D11_MESSAGE_ID_COPYRESOURCE_NO_TEXTURE_ONLY_READBACK + CopyresourceNoTextureOnlyReadback = 1048598, + /// + /// D3D11_MESSAGE_ID_CREATEINPUTLAYOUT_UNSUPPORTED_FORMAT + CreateinputlayoutUnsupportedFormat = 1048599, + /// + /// D3D11_MESSAGE_ID_CREATEBLENDSTATE_NO_ALPHA_TO_COVERAGE + CreateblendstateNoAlphaToCoverage = 1048600, + /// + /// D3D11_MESSAGE_ID_CREATERASTERIZERSTATE_DepthClipEnable_MUST_BE_TRUE + CreaterasterizerstateDepthclipenableMustBeTrue = 1048601, + /// + /// D3D11_MESSAGE_ID_DRAWINDEXED_STARTINDEXLOCATION_MUST_BE_POSITIVE + DrawindexedStartindexlocationMustBePositive = 1048602, + /// + /// D3D11_MESSAGE_ID_CREATESHADERRESOURCEVIEW_MUST_USE_LOWEST_LOD + CreateshaderresourceviewMustUseLowestLod = 1048603, + /// + /// D3D11_MESSAGE_ID_CREATESAMPLERSTATE_MINLOD_MUST_NOT_BE_FRACTIONAL + CreatesamplerstateMinlodMustNotBeFractional = 1048604, + /// + /// D3D11_MESSAGE_ID_CREATESAMPLERSTATE_MAXLOD_MUST_BE_FLT_MAX + CreatesamplerstateMaxlodMustBeFltMax = 1048605, + /// + /// D3D11_MESSAGE_ID_CREATESHADERRESOURCEVIEW_FIRSTARRAYSLICE_MUST_BE_ZERO + CreateshaderresourceviewFirstarraysliceMustBeZero = 1048606, + /// + /// D3D11_MESSAGE_ID_CREATESHADERRESOURCEVIEW_CUBES_MUST_HAVE_6_SIDES + CreateshaderresourceviewCubesMustHave6Sides = 1048607, + /// + /// D3D11_MESSAGE_ID_CREATERESOURCE_NOT_BINDABLE_AS_RENDER_TARGET + CreateresourceNotBindableAsRenderTarget = 1048608, + /// + /// D3D11_MESSAGE_ID_CREATERESOURCE_NO_DWORD_INDEX_BUFFER + CreateresourceNoDwordIndexBuffer = 1048609, + /// + /// D3D11_MESSAGE_ID_CREATERESOURCE_MSAA_PRECLUDES_SHADER_RESOURCE + CreateresourceMsaaPrecludesShaderResource = 1048610, + /// + /// D3D11_MESSAGE_ID_CREATERESOURCE_PRESENTATION_PRECLUDES_SHADER_RESOURCE + CreateresourcePresentationPrecludesShaderResource = 1048611, + /// + /// D3D11_MESSAGE_ID_CREATEBLENDSTATE_NO_INDEPENDENT_BLEND_ENABLE + CreateblendstateNoIndependentBlendEnable = 1048612, + /// + /// D3D11_MESSAGE_ID_CREATEBLENDSTATE_NO_INDEPENDENT_WRITE_MASKS + CreateblendstateNoIndependentWriteMasks = 1048613, + /// + /// D3D11_MESSAGE_ID_CREATERESOURCE_NO_STREAM_OUT + CreateresourceNoStreamOut = 1048614, + /// + /// D3D11_MESSAGE_ID_CREATERESOURCE_ONLY_VB_IB_FOR_BUFFERS + CreateresourceOnlyVbIbForBuffers = 1048615, + /// + /// D3D11_MESSAGE_ID_CREATERESOURCE_NO_AUTOGEN_FOR_VOLUMES + CreateresourceNoAutogenForVolumes = 1048616, + /// + /// D3D11_MESSAGE_ID_CREATERESOURCE_DXGI_FORMAT_R8G8B8A8_CANNOT_BE_SHARED + CreateresourceFormatR8g8b8a8CannotBeShared = 1048617, + /// + /// D3D11_MESSAGE_ID_VSSHADERRESOURCES_NOT_SUPPORTED + VsshaderresourcesNotSupported = 1048618, + /// + /// D3D11_MESSAGE_ID_GEOMETRY_SHADER_NOT_SUPPORTED + GeometryShaderNotSupported = 1048619, + /// + /// D3D11_MESSAGE_ID_STREAM_OUT_NOT_SUPPORTED + StreamOutNotSupported = 1048620, + /// + /// D3D11_MESSAGE_ID_TEXT_FILTER_NOT_SUPPORTED + TextFilterNotSupported = 1048621, + /// + /// D3D11_MESSAGE_ID_CREATEBLENDSTATE_NO_SEPARATE_ALPHA_BLEND + CreateblendstateNoSeparateAlphaBlend = 1048622, + /// + /// D3D11_MESSAGE_ID_CREATEBLENDSTATE_NO_MRT_BLEND + CreateblendstateNoMrtBlend = 1048623, + /// + /// D3D11_MESSAGE_ID_CREATEBLENDSTATE_OPERATION_NOT_SUPPORTED + CreateblendstateOperationNotSupported = 1048624, + /// + /// D3D11_MESSAGE_ID_CREATESAMPLERSTATE_NO_MIRRORONCE + CreatesamplerstateNoMirroronce = 1048625, + /// + /// D3D11_MESSAGE_ID_DRAWINSTANCED_NOT_SUPPORTED + DrawinstancedNotSupported = 1048626, + /// + /// D3D11_MESSAGE_ID_DRAWINDEXEDINSTANCED_NOT_SUPPORTED_BELOW_9_3 + DrawindexedinstancedNotSupportedBelow93 = 1048627, + /// + /// D3D11_MESSAGE_ID_DRAWINDEXED_POINTLIST_UNSUPPORTED + DrawindexedPointListUnsupported = 1048628, + /// + /// D3D11_MESSAGE_ID_SETBLENDSTATE_SAMPLE_MASK_CANNOT_BE_ZERO + SetblendstateSampleMaskCannotBeZero = 1048629, + /// + /// D3D11_MESSAGE_ID_CREATERESOURCE_DIMENSION_EXCEEDS_FEATURE_LEVEL_DEFINITION + CreateresourceDimensionExceedsFeatureLevelDefinition = 1048630, + /// + /// D3D11_MESSAGE_ID_CREATERESOURCE_ONLY_SINGLE_MIP_LEVEL_DEPTH_STENCIL_SUPPORTED + CreateresourceOnlySingleMipLevelDepthStencilSupported = 1048631, + /// + /// D3D11_MESSAGE_ID_DEVICE_RSSETSCISSORRECTS_NEGATIVESCISSOR + DeviceRssetscissorrectsNegativescissor = 1048632, + /// + /// D3D11_MESSAGE_ID_SLOT_ZERO_MUST_BE_D3D10_INPUT_PER_VERTEX_DATA + SlotZeroMustBeInputPerVertexData = 1048633, + /// + /// D3D11_MESSAGE_ID_CREATERESOURCE_NON_POW_2_MIPMAP + CreateresourceNonPow2Mipmap = 1048634, + /// + /// D3D11_MESSAGE_ID_CREATESAMPLERSTATE_BORDER_NOT_SUPPORTED + CreatesamplerstateBorderNotSupported = 1048635, + /// + /// D3D11_MESSAGE_ID_OMSETRENDERTARGETS_NO_SRGB_MRT + OmsetrendertargetsNoSrgbMrt = 1048636, + /// + /// D3D11_MESSAGE_ID_COPYRESOURCE_NO_3D_MISMATCHED_UPDATES + CopyresourceNo3dMismatchedUpdates = 1048637, + /// + /// D3D11_MESSAGE_ID_CREATEDEPTHSTENCILVIEW_INVALIDFLAGS + CreatedepthstencilviewInvalidflags = 2097153, + /// + /// D3D11_MESSAGE_ID_CREATEVERTEXSHADER_INVALIDCLASSLINKAGE + CreatevertexshaderInvalidclasslinkage = 2097154, + /// + /// D3D11_MESSAGE_ID_CREATEGEOMETRYSHADER_INVALIDCLASSLINKAGE + CreategeometryshaderInvalidclasslinkage = 2097155, + /// + /// D3D11_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_INVALIDNUMSTREAMS + CreategeometryshaderwithstreamoutputInvalidnumstreams = 2097156, + /// + /// D3D11_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_INVALIDSTREAMTORASTERIZER + CreategeometryshaderwithstreamoutputInvalidstreamtorasterizer = 2097157, + /// + /// D3D11_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_UNEXPECTEDSTREAMS + CreategeometryshaderwithstreamoutputUnexpectedstreams = 2097158, + /// + /// D3D11_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_INVALIDCLASSLINKAGE + CreategeometryshaderwithstreamoutputInvalidclasslinkage = 2097159, + /// + /// D3D11_MESSAGE_ID_CREATEPIXELSHADER_INVALIDCLASSLINKAGE + CreatepixelshaderInvalidclasslinkage = 2097160, + /// + /// D3D11_MESSAGE_ID_CREATEDEFERREDCONTEXT_INVALID_COMMANDLISTFLAGS + CreatedeferredcontextInvalidCommandlistflags = 2097161, + /// + /// D3D11_MESSAGE_ID_CREATEDEFERREDCONTEXT_SINGLETHREADED + CreatedeferredcontextSinglethreaded = 2097162, + /// + /// D3D11_MESSAGE_ID_CREATEDEFERREDCONTEXT_INVALIDARG_RETURN + CreatedeferredcontextInvalidargReturn = 2097163, + /// + /// D3D11_MESSAGE_ID_CREATEDEFERREDCONTEXT_INVALID_CALL_RETURN + CreatedeferredcontextInvalidCallReturn = 2097164, + /// + /// D3D11_MESSAGE_ID_CREATEDEFERREDCONTEXT_OUTOFMEMORY_RETURN + CreatedeferredcontextOutofmemoryReturn = 2097165, + /// + /// D3D11_MESSAGE_ID_FINISHDISPLAYLIST_ONIMMEDIATECONTEXT + FinishdisplaylistOnimmediatecontext = 2097166, + /// + /// D3D11_MESSAGE_ID_FINISHDISPLAYLIST_OUTOFMEMORY_RETURN + FinishdisplaylistOutofmemoryReturn = 2097167, + /// + /// D3D11_MESSAGE_ID_FINISHDISPLAYLIST_INVALID_CALL_RETURN + FinishdisplaylistInvalidCallReturn = 2097168, + /// + /// D3D11_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_INVALIDSTREAM + CreategeometryshaderwithstreamoutputInvalidstream = 2097169, + /// + /// D3D11_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_UNEXPECTEDENTRIES + CreategeometryshaderwithstreamoutputUnexpectedentries = 2097170, + /// + /// D3D11_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_UNEXPECTEDSTRIDES + CreategeometryshaderwithstreamoutputUnexpectedstrides = 2097171, + /// + /// D3D11_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_INVALIDNUMSTRIDES + CreategeometryshaderwithstreamoutputInvalidnumstrides = 2097172, + /// + /// D3D11_MESSAGE_ID_DEVICE_HSSETSHADERRESOURCES_HAZARD + DeviceHssetshaderresourcesHazard = 2097173, + /// + /// D3D11_MESSAGE_ID_DEVICE_HSSETCONSTANTBUFFERS_HAZARD + DeviceHssetconstantbuffersHazard = 2097174, + /// + /// D3D11_MESSAGE_ID_HSSETSHADERRESOURCES_UNBINDDELETINGOBJECT + HssetshaderresourcesUnbinddeletingobject = 2097175, + /// + /// D3D11_MESSAGE_ID_HSSETCONSTANTBUFFERS_UNBINDDELETINGOBJECT + HssetconstantbuffersUnbinddeletingobject = 2097176, + /// + /// D3D11_MESSAGE_ID_CREATEHULLSHADER_INVALIDCALL + CreatehullshaderInvalidcall = 2097177, + /// + /// D3D11_MESSAGE_ID_CREATEHULLSHADER_OUTOFMEMORY + CreatehullshaderOutofmemory = 2097178, + /// + /// D3D11_MESSAGE_ID_CREATEHULLSHADER_INVALIDSHADERBYTECODE + CreatehullshaderInvalidshaderbytecode = 2097179, + /// + /// D3D11_MESSAGE_ID_CREATEHULLSHADER_INVALIDSHADERTYPE + CreatehullshaderInvalidshadertype = 2097180, + /// + /// D3D11_MESSAGE_ID_CREATEHULLSHADER_INVALIDCLASSLINKAGE + CreatehullshaderInvalidclasslinkage = 2097181, + /// + /// D3D11_MESSAGE_ID_DEVICE_HSSETSHADERRESOURCES_VIEWS_EMPTY + DeviceHssetshaderresourcesViewsEmpty = 2097182, + /// + /// D3D11_MESSAGE_ID_HSSETCONSTANTBUFFERS_INVALIDBUFFER + HssetconstantbuffersInvalidbuffer = 2097183, + /// + /// D3D11_MESSAGE_ID_DEVICE_HSSETCONSTANTBUFFERS_BUFFERS_EMPTY + DeviceHssetconstantbuffersBuffersEmpty = 2097184, + /// + /// D3D11_MESSAGE_ID_DEVICE_HSSETSAMPLERS_SAMPLERS_EMPTY + DeviceHssetsamplersSamplersEmpty = 2097185, + /// + /// D3D11_MESSAGE_ID_DEVICE_HSGETSHADERRESOURCES_VIEWS_EMPTY + DeviceHsgetshaderresourcesViewsEmpty = 2097186, + /// + /// D3D11_MESSAGE_ID_DEVICE_HSGETCONSTANTBUFFERS_BUFFERS_EMPTY + DeviceHsgetconstantbuffersBuffersEmpty = 2097187, + /// + /// D3D11_MESSAGE_ID_DEVICE_HSGETSAMPLERS_SAMPLERS_EMPTY + DeviceHsgetsamplersSamplersEmpty = 2097188, + /// + /// D3D11_MESSAGE_ID_DEVICE_DSSETSHADERRESOURCES_HAZARD + DeviceDssetshaderresourcesHazard = 2097189, + /// + /// D3D11_MESSAGE_ID_DEVICE_DSSETCONSTANTBUFFERS_HAZARD + DeviceDssetconstantbuffersHazard = 2097190, + /// + /// D3D11_MESSAGE_ID_DSSETSHADERRESOURCES_UNBINDDELETINGOBJECT + DssetshaderresourcesUnbinddeletingobject = 2097191, + /// + /// D3D11_MESSAGE_ID_DSSETCONSTANTBUFFERS_UNBINDDELETINGOBJECT + DssetconstantbuffersUnbinddeletingobject = 2097192, + /// + /// D3D11_MESSAGE_ID_CREATEDOMAINSHADER_INVALIDCALL + CreatedomainshaderInvalidcall = 2097193, + /// + /// D3D11_MESSAGE_ID_CREATEDOMAINSHADER_OUTOFMEMORY + CreatedomainshaderOutofmemory = 2097194, + /// + /// D3D11_MESSAGE_ID_CREATEDOMAINSHADER_INVALIDSHADERBYTECODE + CreatedomainshaderInvalidshaderbytecode = 2097195, + /// + /// D3D11_MESSAGE_ID_CREATEDOMAINSHADER_INVALIDSHADERTYPE + CreatedomainshaderInvalidshadertype = 2097196, + /// + /// D3D11_MESSAGE_ID_CREATEDOMAINSHADER_INVALIDCLASSLINKAGE + CreatedomainshaderInvalidclasslinkage = 2097197, + /// + /// D3D11_MESSAGE_ID_DEVICE_DSSETSHADERRESOURCES_VIEWS_EMPTY + DeviceDssetshaderresourcesViewsEmpty = 2097198, + /// + /// D3D11_MESSAGE_ID_DSSETCONSTANTBUFFERS_INVALIDBUFFER + DssetconstantbuffersInvalidbuffer = 2097199, + /// + /// D3D11_MESSAGE_ID_DEVICE_DSSETCONSTANTBUFFERS_BUFFERS_EMPTY + DeviceDssetconstantbuffersBuffersEmpty = 2097200, + /// + /// D3D11_MESSAGE_ID_DEVICE_DSSETSAMPLERS_SAMPLERS_EMPTY + DeviceDssetsamplersSamplersEmpty = 2097201, + /// + /// D3D11_MESSAGE_ID_DEVICE_DSGETSHADERRESOURCES_VIEWS_EMPTY + DeviceDsgetshaderresourcesViewsEmpty = 2097202, + /// + /// D3D11_MESSAGE_ID_DEVICE_DSGETCONSTANTBUFFERS_BUFFERS_EMPTY + DeviceDsgetconstantbuffersBuffersEmpty = 2097203, + /// + /// D3D11_MESSAGE_ID_DEVICE_DSGETSAMPLERS_SAMPLERS_EMPTY + DeviceDsgetsamplersSamplersEmpty = 2097204, + /// + /// D3D11_MESSAGE_ID_DEVICE_DRAW_HS_XOR_DS_MISMATCH + DeviceDrawHsXorDsMismatch = 2097205, + /// + /// D3D11_MESSAGE_ID_DEFERRED_CONTEXT_REMOVAL_PROCESS_AT_FAULT + DeferredContextRemovalProcessAtFault = 2097206, + /// + /// D3D11_MESSAGE_ID_DEVICE_DRAWINDIRECT_INVALID_ARG_BUFFER + DeviceDrawindirectInvalidArgBuffer = 2097207, + /// + /// D3D11_MESSAGE_ID_DEVICE_DRAWINDIRECT_OFFSET_UNALIGNED + DeviceDrawindirectOffsetUnaligned = 2097208, + /// + /// D3D11_MESSAGE_ID_DEVICE_DRAWINDIRECT_OFFSET_OVERFLOW + DeviceDrawindirectOffsetOverflow = 2097209, + /// + /// D3D11_MESSAGE_ID_RESOURCE_MAP_INVALIDMAPTYPE + ResourceMapInvalidmaptype = 2097210, + /// + /// D3D11_MESSAGE_ID_RESOURCE_MAP_INVALIDSUBRESOURCE + ResourceMapInvalidsubresource = 2097211, + /// + /// D3D11_MESSAGE_ID_RESOURCE_MAP_INVALIDFLAGS + ResourceMapInvalidflags = 2097212, + /// + /// D3D11_MESSAGE_ID_RESOURCE_MAP_ALREADYMAPPED + ResourceMapAlreadymapped = 2097213, + /// + /// D3D11_MESSAGE_ID_RESOURCE_MAP_DEVICEREMOVED_RETURN + ResourceMapDeviceremovedReturn = 2097214, + /// + /// D3D11_MESSAGE_ID_RESOURCE_MAP_OUTOFMEMORY_RETURN + ResourceMapOutofmemoryReturn = 2097215, + /// + /// D3D11_MESSAGE_ID_RESOURCE_MAP_WITHOUT_INITIAL_DISCARD + ResourceMapWithoutInitialDiscard = 2097216, + /// + /// D3D11_MESSAGE_ID_RESOURCE_UNMAP_INVALIDSUBRESOURCE + ResourceUnmapInvalidsubresource = 2097217, + /// + /// D3D11_MESSAGE_ID_RESOURCE_UNMAP_NOTMAPPED + ResourceUnmapNotmapped = 2097218, + /// + /// D3D11_MESSAGE_ID_DEVICE_DRAW_RASTERIZING_CONTROL_POINTS + DeviceDrawRasterizingControlPoints = 2097219, + /// + /// D3D11_MESSAGE_ID_DEVICE_IASETPRIMITIVETOPOLOGY_TOPOLOGY_UNSUPPORTED + DeviceIasetprimitivetopologyTopologyUnsupported = 2097220, + /// + /// D3D11_MESSAGE_ID_DEVICE_DRAW_HS_DS_SIGNATURE_MISMATCH + DeviceDrawHsDsSignatureMismatch = 2097221, + /// + /// D3D11_MESSAGE_ID_DEVICE_DRAW_HULL_SHADER_INPUT_TOPOLOGY_MISMATCH + DeviceDrawHullShaderInputTopologyMismatch = 2097222, + /// + /// D3D11_MESSAGE_ID_DEVICE_DRAW_HS_DS_CONTROL_POINT_COUNT_MISMATCH + DeviceDrawHsDsControlPointCountMismatch = 2097223, + /// + /// D3D11_MESSAGE_ID_DEVICE_DRAW_HS_DS_TESSELLATOR_DOMAIN_MISMATCH + DeviceDrawHsDsTessellatorDomainMismatch = 2097224, + /// + /// D3D11_MESSAGE_ID_CREATE_CONTEXT + CreateContext = 2097225, + /// + /// D3D11_MESSAGE_ID_LIVE_CONTEXT + LiveContext = 2097226, + /// + /// D3D11_MESSAGE_ID_DESTROY_CONTEXT + DestroyContext = 2097227, + /// + /// D3D11_MESSAGE_ID_CREATE_BUFFER + CreateBuffer = 2097228, + /// + /// D3D11_MESSAGE_ID_LIVE_BUFFER_WIN7 + LiveBufferWin7 = 2097229, + /// + /// D3D11_MESSAGE_ID_DESTROY_BUFFER + DestroyBuffer = 2097230, + /// + /// D3D11_MESSAGE_ID_CREATE_TEXTURE1D + CreateTexture1D = 2097231, + /// + /// D3D11_MESSAGE_ID_LIVE_TEXTURE1D_WIN7 + LiveTexture1DWin7 = 2097232, + /// + /// D3D11_MESSAGE_ID_DESTROY_TEXTURE1D + DestroyTexture1D = 2097233, + /// + /// D3D11_MESSAGE_ID_CREATE_TEXTURE2D + CreateTexture2D = 2097234, + /// + /// D3D11_MESSAGE_ID_LIVE_TEXTURE2D_WIN7 + LiveTexture2DWin7 = 2097235, + /// + /// D3D11_MESSAGE_ID_DESTROY_TEXTURE2D + DestroyTexture2D = 2097236, + /// + /// D3D11_MESSAGE_ID_CREATE_TEXTURE3D + CreateTexture3D = 2097237, + /// + /// D3D11_MESSAGE_ID_LIVE_TEXTURE3D_WIN7 + LiveTexture3DWin7 = 2097238, + /// + /// D3D11_MESSAGE_ID_DESTROY_TEXTURE3D + DestroyTexture3D = 2097239, + /// + /// D3D11_MESSAGE_ID_CREATE_SHADERRESOURCEVIEW + CreateShaderresourceview = 2097240, + /// + /// D3D11_MESSAGE_ID_LIVE_SHADERRESOURCEVIEW_WIN7 + LiveShaderresourceviewWin7 = 2097241, + /// + /// D3D11_MESSAGE_ID_DESTROY_SHADERRESOURCEVIEW + DestroyShaderresourceview = 2097242, + /// + /// D3D11_MESSAGE_ID_CREATE_RENDERTARGETVIEW + CreateRenderTargetView = 2097243, + /// + /// D3D11_MESSAGE_ID_LIVE_RENDERTARGETVIEW_WIN7 + LiveRenderTargetViewWin7 = 2097244, + /// + /// D3D11_MESSAGE_ID_DESTROY_RENDERTARGETVIEW + DestroyRenderTargetView = 2097245, + /// + /// D3D11_MESSAGE_ID_CREATE_DEPTHSTENCILVIEW + CreateDepthStencilView = 2097246, + /// + /// D3D11_MESSAGE_ID_LIVE_DEPTHSTENCILVIEW_WIN7 + LiveDepthStencilViewWin7 = 2097247, + /// + /// D3D11_MESSAGE_ID_DESTROY_DEPTHSTENCILVIEW + DestroyDepthStencilView = 2097248, + /// + /// D3D11_MESSAGE_ID_CREATE_VERTEXSHADER + CreateVertexShader = 2097249, + /// + /// D3D11_MESSAGE_ID_LIVE_VERTEXSHADER_WIN7 + LiveVertexShaderWin7 = 2097250, + /// + /// D3D11_MESSAGE_ID_DESTROY_VERTEXSHADER + DestroyVertexShader = 2097251, + /// + /// D3D11_MESSAGE_ID_CREATE_HULLSHADER + CreateHullshader = 2097252, + /// + /// D3D11_MESSAGE_ID_LIVE_HULLSHADER + LiveHullshader = 2097253, + /// + /// D3D11_MESSAGE_ID_DESTROY_HULLSHADER + DestroyHullshader = 2097254, + /// + /// D3D11_MESSAGE_ID_CREATE_DOMAINSHADER + CreateDomainShader = 2097255, + /// + /// D3D11_MESSAGE_ID_LIVE_DOMAINSHADER + LiveDomainShader = 2097256, + /// + /// D3D11_MESSAGE_ID_DESTROY_DOMAINSHADER + DestroyDomainShader = 2097257, + /// + /// D3D11_MESSAGE_ID_CREATE_GEOMETRYSHADER + CreateGeometryShader = 2097258, + /// + /// D3D11_MESSAGE_ID_LIVE_GEOMETRYSHADER_WIN7 + LiveGeometryShaderWin7 = 2097259, + /// + /// D3D11_MESSAGE_ID_DESTROY_GEOMETRYSHADER + DestroyGeometryShader = 2097260, + /// + /// D3D11_MESSAGE_ID_CREATE_PIXELSHADER + CreatePixelShader = 2097261, + /// + /// D3D11_MESSAGE_ID_LIVE_PIXELSHADER_WIN7 + LivePixelShaderWin7 = 2097262, + /// + /// D3D11_MESSAGE_ID_DESTROY_PIXELSHADER + DestroyPixelShader = 2097263, + /// + /// D3D11_MESSAGE_ID_CREATE_INPUTLAYOUT + CreateInputlayout = 2097264, + /// + /// D3D11_MESSAGE_ID_LIVE_INPUTLAYOUT_WIN7 + LiveInputlayoutWin7 = 2097265, + /// + /// D3D11_MESSAGE_ID_DESTROY_INPUTLAYOUT + DestroyInputlayout = 2097266, + /// + /// D3D11_MESSAGE_ID_CREATE_SAMPLER + CreateSampler = 2097267, + /// + /// D3D11_MESSAGE_ID_LIVE_SAMPLER_WIN7 + LiveSamplerWin7 = 2097268, + /// + /// D3D11_MESSAGE_ID_DESTROY_SAMPLER + DestroySampler = 2097269, + /// + /// D3D11_MESSAGE_ID_CREATE_BLENDSTATE + CreateBlendstate = 2097270, + /// + /// D3D11_MESSAGE_ID_LIVE_BLENDSTATE_WIN7 + LiveBlendstateWin7 = 2097271, + /// + /// D3D11_MESSAGE_ID_DESTROY_BLENDSTATE + DestroyBlendstate = 2097272, + /// + /// D3D11_MESSAGE_ID_CREATE_DEPTHSTENCILSTATE + CreateDepthstencilstate = 2097273, + /// + /// D3D11_MESSAGE_ID_LIVE_DEPTHSTENCILSTATE_WIN7 + LiveDepthstencilstateWin7 = 2097274, + /// + /// D3D11_MESSAGE_ID_DESTROY_DEPTHSTENCILSTATE + DestroyDepthstencilstate = 2097275, + /// + /// D3D11_MESSAGE_ID_CREATE_RASTERIZERSTATE + CreateRasterizerstate = 2097276, + /// + /// D3D11_MESSAGE_ID_LIVE_RASTERIZERSTATE_WIN7 + LiveRasterizerstateWin7 = 2097277, + /// + /// D3D11_MESSAGE_ID_DESTROY_RASTERIZERSTATE + DestroyRasterizerstate = 2097278, + /// + /// D3D11_MESSAGE_ID_CREATE_QUERY + CreateQuery = 2097279, + /// + /// D3D11_MESSAGE_ID_LIVE_QUERY_WIN7 + LiveQueryWin7 = 2097280, + /// + /// D3D11_MESSAGE_ID_DESTROY_QUERY + DestroyQuery = 2097281, + /// + /// D3D11_MESSAGE_ID_CREATE_PREDICATE + CreatePredicate = 2097282, + /// + /// D3D11_MESSAGE_ID_LIVE_PREDICATE_WIN7 + LivePredicateWin7 = 2097283, + /// + /// D3D11_MESSAGE_ID_DESTROY_PREDICATE + DestroyPredicate = 2097284, + /// + /// D3D11_MESSAGE_ID_CREATE_COUNTER + CreateCounter = 2097285, + /// + /// D3D11_MESSAGE_ID_DESTROY_COUNTER + DestroyCounter = 2097286, + /// + /// D3D11_MESSAGE_ID_CREATE_COMMANDLIST + CreateCommandlist = 2097287, + /// + /// D3D11_MESSAGE_ID_LIVE_COMMANDLIST + LiveCommandlist = 2097288, + /// + /// D3D11_MESSAGE_ID_DESTROY_COMMANDLIST + DestroyCommandlist = 2097289, + /// + /// D3D11_MESSAGE_ID_CREATE_CLASSINSTANCE + CreateClassinstance = 2097290, + /// + /// D3D11_MESSAGE_ID_LIVE_CLASSINSTANCE + LiveClassinstance = 2097291, + /// + /// D3D11_MESSAGE_ID_DESTROY_CLASSINSTANCE + DestroyClassinstance = 2097292, + /// + /// D3D11_MESSAGE_ID_CREATE_CLASSLINKAGE + CreateClasslinkage = 2097293, + /// + /// D3D11_MESSAGE_ID_LIVE_CLASSLINKAGE + LiveClasslinkage = 2097294, + /// + /// D3D11_MESSAGE_ID_DESTROY_CLASSLINKAGE + DestroyClasslinkage = 2097295, + /// + /// D3D11_MESSAGE_ID_LIVE_DEVICE_WIN7 + LiveDeviceWin7 = 2097296, + /// + /// D3D11_MESSAGE_ID_LIVE_OBJECT_SUMMARY_WIN7 + LiveObjectSummaryWin7 = 2097297, + /// + /// D3D11_MESSAGE_ID_CREATE_COMPUTESHADER + CreateComputeShader = 2097298, + /// + /// D3D11_MESSAGE_ID_LIVE_COMPUTESHADER + LiveComputeShader = 2097299, + /// + /// D3D11_MESSAGE_ID_DESTROY_COMPUTESHADER + DestroyComputeShader = 2097300, + /// + /// D3D11_MESSAGE_ID_CREATE_UNORDEREDACCESSVIEW + CreateUnorderedaccessview = 2097301, + /// + /// D3D11_MESSAGE_ID_LIVE_UNORDEREDACCESSVIEW + LiveUnorderedaccessview = 2097302, + /// + /// D3D11_MESSAGE_ID_DESTROY_UNORDEREDACCESSVIEW + DestroyUnorderedaccessview = 2097303, + /// + /// D3D11_MESSAGE_ID_DEVICE_SETSHADER_INTERFACES_FEATURELEVEL + DeviceSetshaderInterfacesFeaturelevel = 2097304, + /// + /// D3D11_MESSAGE_ID_DEVICE_SETSHADER_INTERFACE_COUNT_MISMATCH + DeviceSetshaderInterfaceCountMismatch = 2097305, + /// + /// D3D11_MESSAGE_ID_DEVICE_SETSHADER_INVALID_INSTANCE + DeviceSetshaderInvalidInstance = 2097306, + /// + /// D3D11_MESSAGE_ID_DEVICE_SETSHADER_INVALID_INSTANCE_INDEX + DeviceSetshaderInvalidInstanceIndex = 2097307, + /// + /// D3D11_MESSAGE_ID_DEVICE_SETSHADER_INVALID_INSTANCE_TYPE + DeviceSetshaderInvalidInstanceType = 2097308, + /// + /// D3D11_MESSAGE_ID_DEVICE_SETSHADER_INVALID_INSTANCE_DATA + DeviceSetshaderInvalidInstanceData = 2097309, + /// + /// D3D11_MESSAGE_ID_DEVICE_SETSHADER_UNBOUND_INSTANCE_DATA + DeviceSetshaderUnboundInstanceData = 2097310, + /// + /// D3D11_MESSAGE_ID_DEVICE_SETSHADER_INSTANCE_DATA_BINDINGS + DeviceSetshaderInstanceDataBindings = 2097311, + /// + /// D3D11_MESSAGE_ID_DEVICE_CREATESHADER_CLASSLINKAGE_FULL + DeviceCreateshaderClasslinkageFull = 2097312, + /// + /// D3D11_MESSAGE_ID_DEVICE_CHECKFEATURESUPPORT_UNRECOGNIZED_FEATURE + DeviceCheckfeaturesupportUnrecognizedFeature = 2097313, + /// + /// D3D11_MESSAGE_ID_DEVICE_CHECKFEATURESUPPORT_MISMATCHED_DATA_SIZE + DeviceCheckfeaturesupportMismatchedDataSize = 2097314, + /// + /// D3D11_MESSAGE_ID_DEVICE_CHECKFEATURESUPPORT_INVALIDARG_RETURN + DeviceCheckfeaturesupportInvalidargReturn = 2097315, + /// + /// D3D11_MESSAGE_ID_DEVICE_CSSETSHADERRESOURCES_HAZARD + DeviceCssetshaderresourcesHazard = 2097316, + /// + /// D3D11_MESSAGE_ID_DEVICE_CSSETCONSTANTBUFFERS_HAZARD + DeviceCssetconstantbuffersHazard = 2097317, + /// + /// D3D11_MESSAGE_ID_CSSETSHADERRESOURCES_UNBINDDELETINGOBJECT + CssetshaderresourcesUnbinddeletingobject = 2097318, + /// + /// D3D11_MESSAGE_ID_CSSETCONSTANTBUFFERS_UNBINDDELETINGOBJECT + CssetconstantbuffersUnbinddeletingobject = 2097319, + /// + /// D3D11_MESSAGE_ID_CREATECOMPUTESHADER_INVALIDCALL + CreatecomputeshaderInvalidcall = 2097320, + /// + /// D3D11_MESSAGE_ID_CREATECOMPUTESHADER_OUTOFMEMORY + CreatecomputeshaderOutofmemory = 2097321, + /// + /// D3D11_MESSAGE_ID_CREATECOMPUTESHADER_INVALIDSHADERBYTECODE + CreatecomputeshaderInvalidshaderbytecode = 2097322, + /// + /// D3D11_MESSAGE_ID_CREATECOMPUTESHADER_INVALIDSHADERTYPE + CreatecomputeshaderInvalidshadertype = 2097323, + /// + /// D3D11_MESSAGE_ID_CREATECOMPUTESHADER_INVALIDCLASSLINKAGE + CreatecomputeshaderInvalidclasslinkage = 2097324, + /// + /// D3D11_MESSAGE_ID_DEVICE_CSSETSHADERRESOURCES_VIEWS_EMPTY + DeviceCssetshaderresourcesViewsEmpty = 2097325, + /// + /// D3D11_MESSAGE_ID_CSSETCONSTANTBUFFERS_INVALIDBUFFER + CssetconstantbuffersInvalidbuffer = 2097326, + /// + /// D3D11_MESSAGE_ID_DEVICE_CSSETCONSTANTBUFFERS_BUFFERS_EMPTY + DeviceCssetconstantbuffersBuffersEmpty = 2097327, + /// + /// D3D11_MESSAGE_ID_DEVICE_CSSETSAMPLERS_SAMPLERS_EMPTY + DeviceCssetsamplersSamplersEmpty = 2097328, + /// + /// D3D11_MESSAGE_ID_DEVICE_CSGETSHADERRESOURCES_VIEWS_EMPTY + DeviceCsgetshaderresourcesViewsEmpty = 2097329, + /// + /// D3D11_MESSAGE_ID_DEVICE_CSGETCONSTANTBUFFERS_BUFFERS_EMPTY + DeviceCsgetconstantbuffersBuffersEmpty = 2097330, + /// + /// D3D11_MESSAGE_ID_DEVICE_CSGETSAMPLERS_SAMPLERS_EMPTY + DeviceCsgetsamplersSamplersEmpty = 2097331, + /// + /// D3D11_MESSAGE_ID_DEVICE_CREATEVERTEXSHADER_DOUBLEFLOATOPSNOTSUPPORTED + DeviceCreatevertexshaderDoublefloatopsnotsupported = 2097332, + /// + /// D3D11_MESSAGE_ID_DEVICE_CREATEHULLSHADER_DOUBLEFLOATOPSNOTSUPPORTED + DeviceCreatehullshaderDoublefloatopsnotsupported = 2097333, + /// + /// D3D11_MESSAGE_ID_DEVICE_CREATEDOMAINSHADER_DOUBLEFLOATOPSNOTSUPPORTED + DeviceCreatedomainshaderDoublefloatopsnotsupported = 2097334, + /// + /// D3D11_MESSAGE_ID_DEVICE_CREATEGEOMETRYSHADER_DOUBLEFLOATOPSNOTSUPPORTED + DeviceCreategeometryshaderDoublefloatopsnotsupported = 2097335, + /// + /// D3D11_MESSAGE_ID_DEVICE_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_DOUBLEFLOATOPSNOTSUPPORTED + DeviceCreategeometryshaderwithstreamoutputDoublefloatopsnotsupported = 2097336, + /// + /// D3D11_MESSAGE_ID_DEVICE_CREATEPIXELSHADER_DOUBLEFLOATOPSNOTSUPPORTED + DeviceCreatepixelshaderDoublefloatopsnotsupported = 2097337, + /// + /// D3D11_MESSAGE_ID_DEVICE_CREATECOMPUTESHADER_DOUBLEFLOATOPSNOTSUPPORTED + DeviceCreatecomputeshaderDoublefloatopsnotsupported = 2097338, + /// + /// D3D11_MESSAGE_ID_CREATEBUFFER_INVALIDSTRUCTURESTRIDE + CreatebufferInvalidstructurestride = 2097339, + /// + /// D3D11_MESSAGE_ID_CREATESHADERRESOURCEVIEW_INVALIDFLAGS + CreateshaderresourceviewInvalidflags = 2097340, + /// + /// D3D11_MESSAGE_ID_CREATEUNORDEREDACCESSVIEW_INVALIDRESOURCE + CreateunorderedaccessviewInvalidresource = 2097341, + /// + /// D3D11_MESSAGE_ID_CREATEUNORDEREDACCESSVIEW_INVALIDDESC + CreateunorderedaccessviewInvaliddesc = 2097342, + /// + /// D3D11_MESSAGE_ID_CREATEUNORDEREDACCESSVIEW_INVALIDFORMAT + CreateunorderedaccessviewInvalidformat = 2097343, + /// + /// D3D11_MESSAGE_ID_CREATEUNORDEREDACCESSVIEW_INVALIDDIMENSIONS + CreateunorderedaccessviewInvaliddimensions = 2097344, + /// + /// D3D11_MESSAGE_ID_CREATEUNORDEREDACCESSVIEW_UNRECOGNIZEDFORMAT + CreateunorderedaccessviewUnrecognizedformat = 2097345, + /// + /// D3D11_MESSAGE_ID_DEVICE_OMSETRENDERTARGETSANDUNORDEREDACCESSVIEWS_HAZARD + DeviceOmsetrendertargetsandunorderedaccessviewsHazard = 2097346, + /// + /// D3D11_MESSAGE_ID_DEVICE_OMSETRENDERTARGETSANDUNORDEREDACCESSVIEWS_OVERLAPPING_OLD_SLOTS + DeviceOmsetrendertargetsandunorderedaccessviewsOverlappingOldSlots = 2097347, + /// + /// D3D11_MESSAGE_ID_DEVICE_OMSETRENDERTARGETSANDUNORDEREDACCESSVIEWS_NO_OP + DeviceOmsetrendertargetsandunorderedaccessviewsNoOp = 2097348, + /// + /// D3D11_MESSAGE_ID_CSSETUNORDEREDACCESSVIEWS_UNBINDDELETINGOBJECT + CssetunorderedaccessviewsUnbinddeletingobject = 2097349, + /// + /// D3D11_MESSAGE_ID_PSSETUNORDEREDACCESSVIEWS_UNBINDDELETINGOBJECT + PssetunorderedaccessviewsUnbinddeletingobject = 2097350, + /// + /// D3D11_MESSAGE_ID_CREATEUNORDEREDACCESSVIEW_INVALIDARG_RETURN + CreateunorderedaccessviewInvalidargReturn = 2097351, + /// + /// D3D11_MESSAGE_ID_CREATEUNORDEREDACCESSVIEW_OUTOFMEMORY_RETURN + CreateunorderedaccessviewOutofmemoryReturn = 2097352, + /// + /// D3D11_MESSAGE_ID_CREATEUNORDEREDACCESSVIEW_TOOMANYOBJECTS + CreateunorderedaccessviewToomanyobjects = 2097353, + /// + /// D3D11_MESSAGE_ID_DEVICE_CSSETUNORDEREDACCESSVIEWS_HAZARD + DeviceCssetunorderedaccessviewsHazard = 2097354, + /// + /// D3D11_MESSAGE_ID_CLEARUNORDEREDACCESSVIEW_DENORMFLUSH + ClearunorderedaccessviewDenormflush = 2097355, + /// + /// D3D11_MESSAGE_ID_DEVICE_CSSETUNORDEREDACCESSS_VIEWS_EMPTY + DeviceCssetunorderedaccesssViewsEmpty = 2097356, + /// + /// D3D11_MESSAGE_ID_DEVICE_CSGETUNORDEREDACCESSS_VIEWS_EMPTY + DeviceCsgetunorderedaccesssViewsEmpty = 2097357, + /// + /// D3D11_MESSAGE_ID_CREATEUNORDEREDACCESSVIEW_INVALIDFLAGS + CreateunorderedaccessviewInvalidflags = 2097358, + /// + /// D3D11_MESSAGE_ID_CREATESHADERRESESOURCEVIEW_TOOMANYOBJECTS + CreateshaderresesourceviewToomanyobjects = 2097359, + /// + /// D3D11_MESSAGE_ID_DEVICE_DISPATCHINDIRECT_INVALID_ARG_BUFFER + DeviceDispatchindirectInvalidArgBuffer = 2097360, + /// + /// D3D11_MESSAGE_ID_DEVICE_DISPATCHINDIRECT_OFFSET_UNALIGNED + DeviceDispatchindirectOffsetUnaligned = 2097361, + /// + /// D3D11_MESSAGE_ID_DEVICE_DISPATCHINDIRECT_OFFSET_OVERFLOW + DeviceDispatchindirectOffsetOverflow = 2097362, + /// + /// D3D11_MESSAGE_ID_DEVICE_SETRESOURCEMINLOD_INVALIDCONTEXT + DeviceSetresourceminlodInvalidcontext = 2097363, + /// + /// D3D11_MESSAGE_ID_DEVICE_SETRESOURCEMINLOD_INVALIDRESOURCE + DeviceSetresourceminlodInvalidresource = 2097364, + /// + /// D3D11_MESSAGE_ID_DEVICE_SETRESOURCEMINLOD_INVALIDMINLOD + DeviceSetresourceminlodInvalidminlod = 2097365, + /// + /// D3D11_MESSAGE_ID_DEVICE_GETRESOURCEMINLOD_INVALIDCONTEXT + DeviceGetresourceminlodInvalidcontext = 2097366, + /// + /// D3D11_MESSAGE_ID_DEVICE_GETRESOURCEMINLOD_INVALIDRESOURCE + DeviceGetresourceminlodInvalidresource = 2097367, + /// + /// D3D11_MESSAGE_ID_OMSETDEPTHSTENCIL_UNBINDDELETINGOBJECT + OmsetdepthstencilUnbinddeletingobject = 2097368, + /// + /// D3D11_MESSAGE_ID_CLEARDEPTHSTENCILVIEW_DEPTH_READONLY + CleardepthstencilviewDepthReadonly = 2097369, + /// + /// D3D11_MESSAGE_ID_CLEARDEPTHSTENCILVIEW_STENCIL_READONLY + CleardepthstencilviewStencilReadonly = 2097370, + /// + /// D3D11_MESSAGE_ID_CHECKFEATURESUPPORT_FORMAT_DEPRECATED + CheckfeaturesupportFormatDeprecated = 2097371, + /// + /// D3D11_MESSAGE_ID_DEVICE_UNORDEREDACCESSVIEW_RETURN_TYPE_MISMATCH + DeviceUnorderedaccessviewReturnTypeMismatch = 2097372, + /// + /// D3D11_MESSAGE_ID_DEVICE_UNORDEREDACCESSVIEW_NOT_SET + DeviceUnorderedaccessviewNotSet = 2097373, + /// + /// D3D11_MESSAGE_ID_DEVICE_DRAW_UNORDEREDACCESSVIEW_RENDERTARGETVIEW_OVERLAP + DeviceDrawUnorderedaccessviewRenderTargetViewOverlap = 2097374, + /// + /// D3D11_MESSAGE_ID_DEVICE_UNORDEREDACCESSVIEW_DIMENSION_MISMATCH + DeviceUnorderedaccessviewDimensionMismatch = 2097375, + /// + /// D3D11_MESSAGE_ID_DEVICE_UNORDEREDACCESSVIEW_APPEND_UNSUPPORTED + DeviceUnorderedaccessviewAppendUnsupported = 2097376, + /// + /// D3D11_MESSAGE_ID_DEVICE_UNORDEREDACCESSVIEW_ATOMICS_UNSUPPORTED + DeviceUnorderedaccessviewAtomicsUnsupported = 2097377, + /// + /// D3D11_MESSAGE_ID_DEVICE_UNORDEREDACCESSVIEW_STRUCTURE_STRIDE_MISMATCH + DeviceUnorderedaccessviewStructureStrideMismatch = 2097378, + /// + /// D3D11_MESSAGE_ID_DEVICE_UNORDEREDACCESSVIEW_BUFFER_TYPE_MISMATCH + DeviceUnorderedaccessviewBufferTypeMismatch = 2097379, + /// + /// D3D11_MESSAGE_ID_DEVICE_UNORDEREDACCESSVIEW_RAW_UNSUPPORTED + DeviceUnorderedaccessviewRawUnsupported = 2097380, + /// + /// D3D11_MESSAGE_ID_DEVICE_UNORDEREDACCESSVIEW_FORMAT_LD_UNSUPPORTED + DeviceUnorderedaccessviewFormatLdUnsupported = 2097381, + /// + /// D3D11_MESSAGE_ID_DEVICE_UNORDEREDACCESSVIEW_FORMAT_STORE_UNSUPPORTED + DeviceUnorderedaccessviewFormatStoreUnsupported = 2097382, + /// + /// D3D11_MESSAGE_ID_DEVICE_UNORDEREDACCESSVIEW_ATOMIC_ADD_UNSUPPORTED + DeviceUnorderedaccessviewAtomicAddUnsupported = 2097383, + /// + /// D3D11_MESSAGE_ID_DEVICE_UNORDEREDACCESSVIEW_ATOMIC_BITWISE_OPS_UNSUPPORTED + DeviceUnorderedaccessviewAtomicBitwiseOpsUnsupported = 2097384, + /// + /// D3D11_MESSAGE_ID_DEVICE_UNORDEREDACCESSVIEW_ATOMIC_CMPSTORE_CMPEXCHANGE_UNSUPPORTED + DeviceUnorderedaccessviewAtomicCmpstoreCmpexchangeUnsupported = 2097385, + /// + /// D3D11_MESSAGE_ID_DEVICE_UNORDEREDACCESSVIEW_ATOMIC_EXCHANGE_UNSUPPORTED + DeviceUnorderedaccessviewAtomicExchangeUnsupported = 2097386, + /// + /// D3D11_MESSAGE_ID_DEVICE_UNORDEREDACCESSVIEW_ATOMIC_SIGNED_MINMAX_UNSUPPORTED + DeviceUnorderedaccessviewAtomicSignedMinmaxUnsupported = 2097387, + /// + /// D3D11_MESSAGE_ID_DEVICE_UNORDEREDACCESSVIEW_ATOMIC_UNSIGNED_MINMAX_UNSUPPORTED + DeviceUnorderedaccessviewAtomicUnsignedMinmaxUnsupported = 2097388, + /// + /// D3D11_MESSAGE_ID_DEVICE_DISPATCH_BOUND_RESOURCE_MAPPED + DeviceDispatchBoundResourceMapped = 2097389, + /// + /// D3D11_MESSAGE_ID_DEVICE_DISPATCH_THREADGROUPCOUNT_OVERFLOW + DeviceDispatchThreadgroupcountOverflow = 2097390, + /// + /// D3D11_MESSAGE_ID_DEVICE_DISPATCH_THREADGROUPCOUNT_ZERO + DeviceDispatchThreadgroupcountZero = 2097391, + /// + /// D3D11_MESSAGE_ID_DEVICE_SHADERRESOURCEVIEW_STRUCTURE_STRIDE_MISMATCH + DeviceShaderresourceviewStructureStrideMismatch = 2097392, + /// + /// D3D11_MESSAGE_ID_DEVICE_SHADERRESOURCEVIEW_BUFFER_TYPE_MISMATCH + DeviceShaderresourceviewBufferTypeMismatch = 2097393, + /// + /// D3D11_MESSAGE_ID_DEVICE_SHADERRESOURCEVIEW_RAW_UNSUPPORTED + DeviceShaderresourceviewRawUnsupported = 2097394, + /// + /// D3D11_MESSAGE_ID_DEVICE_DISPATCH_UNSUPPORTED + DeviceDispatchUnsupported = 2097395, + /// + /// D3D11_MESSAGE_ID_DEVICE_DISPATCHINDIRECT_UNSUPPORTED + DeviceDispatchindirectUnsupported = 2097396, + /// + /// D3D11_MESSAGE_ID_COPYSTRUCTURECOUNT_INVALIDOFFSET + CopystructurecountInvalidoffset = 2097397, + /// + /// D3D11_MESSAGE_ID_COPYSTRUCTURECOUNT_LARGEOFFSET + CopystructurecountLargeoffset = 2097398, + /// + /// D3D11_MESSAGE_ID_COPYSTRUCTURECOUNT_INVALIDDESTINATIONSTATE + CopystructurecountInvaliddestinationstate = 2097399, + /// + /// D3D11_MESSAGE_ID_COPYSTRUCTURECOUNT_INVALIDSOURCESTATE + CopystructurecountInvalidsourcestate = 2097400, + /// + /// D3D11_MESSAGE_ID_CHECKFORMATSUPPORT_FORMAT_NOT_SUPPORTED + CheckformatsupportFormatNotSupported = 2097401, + /// + /// D3D11_MESSAGE_ID_DEVICE_CSSETUNORDEREDACCESSVIEWS_INVALIDVIEW + DeviceCssetunorderedaccessviewsInvalidview = 2097402, + /// + /// D3D11_MESSAGE_ID_DEVICE_CSSETUNORDEREDACCESSVIEWS_INVALIDOFFSET + DeviceCssetunorderedaccessviewsInvalidoffset = 2097403, + /// + /// D3D11_MESSAGE_ID_DEVICE_CSSETUNORDEREDACCESSVIEWS_TOOMANYVIEWS + DeviceCssetunorderedaccessviewsToomanyviews = 2097404, + /// + /// D3D11_MESSAGE_ID_CLEARUNORDEREDACCESSVIEWFLOAT_INVALIDFORMAT + ClearunorderedaccessviewfloatInvalidformat = 2097405, + /// + /// D3D11_MESSAGE_ID_DEVICE_UNORDEREDACCESSVIEW_COUNTER_UNSUPPORTED + DeviceUnorderedaccessviewCounterUnsupported = 2097406, + /// + /// D3D11_MESSAGE_ID_REF_WARNING + RefWarning = 2097407, + /// + /// D3D11_MESSAGE_ID_DEVICE_DRAW_PIXEL_SHADER_WITHOUT_RTV_OR_DSV + DeviceDrawPixelShaderWithoutRtvOrDsv = 2097408, + /// + /// D3D11_MESSAGE_ID_SHADER_ABORT + ShaderAbort = 2097409, + /// + /// D3D11_MESSAGE_ID_SHADER_MESSAGE + ShaderMessage = 2097410, + /// + /// D3D11_MESSAGE_ID_SHADER_ERROR + ShaderError = 2097411, + /// + /// D3D11_MESSAGE_ID_OFFERRESOURCES_INVALIDRESOURCE + OfferresourcesInvalidresource = 2097412, + /// + /// D3D11_MESSAGE_ID_HSSETSAMPLERS_UNBINDDELETINGOBJECT + HssetsamplersUnbinddeletingobject = 2097413, + /// + /// D3D11_MESSAGE_ID_DSSETSAMPLERS_UNBINDDELETINGOBJECT + DssetsamplersUnbinddeletingobject = 2097414, + /// + /// D3D11_MESSAGE_ID_CSSETSAMPLERS_UNBINDDELETINGOBJECT + CssetsamplersUnbinddeletingobject = 2097415, + /// + /// D3D11_MESSAGE_ID_HSSETSHADER_UNBINDDELETINGOBJECT + HssetshaderUnbinddeletingobject = 2097416, + /// + /// D3D11_MESSAGE_ID_DSSETSHADER_UNBINDDELETINGOBJECT + DssetshaderUnbinddeletingobject = 2097417, + /// + /// D3D11_MESSAGE_ID_CSSETSHADER_UNBINDDELETINGOBJECT + CssetshaderUnbinddeletingobject = 2097418, + /// + /// D3D11_MESSAGE_ID_ENQUEUESETEVENT_INVALIDARG_RETURN + EnqueueseteventInvalidargReturn = 2097419, + /// + /// D3D11_MESSAGE_ID_ENQUEUESETEVENT_OUTOFMEMORY_RETURN + EnqueueseteventOutofmemoryReturn = 2097420, + /// + /// D3D11_MESSAGE_ID_ENQUEUESETEVENT_ACCESSDENIED_RETURN + EnqueueseteventAccessdeniedReturn = 2097421, + /// + /// D3D11_MESSAGE_ID_DEVICE_OMSETRENDERTARGETSANDUNORDEREDACCESSVIEWS_NUMUAVS_INVALIDRANGE + DeviceOmsetrendertargetsandunorderedaccessviewsNumuavsInvalidrange = 2097422, + /// + /// D3D11_MESSAGE_ID_USE_OF_ZERO_REFCOUNT_OBJECT + UseOfZeroRefcountObject = 2097423, + /// + /// D3D11_MESSAGE_ID_CREATE_VIDEODECODER + CreateVideodecoder = 3145729, + /// + /// D3D11_MESSAGE_ID_CREATE_VIDEOPROCESSORENUM + CreateVideoprocessorenum = 3145730, + /// + /// D3D11_MESSAGE_ID_CREATE_VIDEOPROCESSOR + CreateVideoprocessor = 3145731, + /// + /// D3D11_MESSAGE_ID_CREATE_DECODEROUTPUTVIEW + CreateDecoderoutputview = 3145732, + /// + /// D3D11_MESSAGE_ID_CREATE_PROCESSORINPUTVIEW + CreateProcessorinputview = 3145733, + /// + /// D3D11_MESSAGE_ID_CREATE_PROCESSOROUTPUTVIEW + CreateProcessoroutputview = 3145734, + /// + /// D3D11_MESSAGE_ID_CREATE_DEVICECONTEXTSTATE + CreateDevicecontextstate = 3145735, + /// + /// D3D11_MESSAGE_ID_LIVE_VIDEODECODER + LiveVideodecoder = 3145736, + /// + /// D3D11_MESSAGE_ID_LIVE_VIDEOPROCESSORENUM + LiveVideoprocessorenum = 3145737, + /// + /// D3D11_MESSAGE_ID_LIVE_VIDEOPROCESSOR + LiveVideoprocessor = 3145738, + /// + /// D3D11_MESSAGE_ID_LIVE_DECODEROUTPUTVIEW + LiveDecoderoutputview = 3145739, + /// + /// D3D11_MESSAGE_ID_LIVE_PROCESSORINPUTVIEW + LiveProcessorinputview = 3145740, + /// + /// D3D11_MESSAGE_ID_LIVE_PROCESSOROUTPUTVIEW + LiveProcessoroutputview = 3145741, + /// + /// D3D11_MESSAGE_ID_LIVE_DEVICECONTEXTSTATE + LiveDevicecontextstate = 3145742, + /// + /// D3D11_MESSAGE_ID_DESTROY_VIDEODECODER + DestroyVideodecoder = 3145743, + /// + /// D3D11_MESSAGE_ID_DESTROY_VIDEOPROCESSORENUM + DestroyVideoprocessorenum = 3145744, + /// + /// D3D11_MESSAGE_ID_DESTROY_VIDEOPROCESSOR + DestroyVideoprocessor = 3145745, + /// + /// D3D11_MESSAGE_ID_DESTROY_DECODEROUTPUTVIEW + DestroyDecoderoutputview = 3145746, + /// + /// D3D11_MESSAGE_ID_DESTROY_PROCESSORINPUTVIEW + DestroyProcessorinputview = 3145747, + /// + /// D3D11_MESSAGE_ID_DESTROY_PROCESSOROUTPUTVIEW + DestroyProcessoroutputview = 3145748, + /// + /// D3D11_MESSAGE_ID_DESTROY_DEVICECONTEXTSTATE + DestroyDevicecontextstate = 3145749, + /// + /// D3D11_MESSAGE_ID_CREATEDEVICECONTEXTSTATE_INVALIDFLAGS + CreatedevicecontextstateInvalidflags = 3145750, + /// + /// D3D11_MESSAGE_ID_CREATEDEVICECONTEXTSTATE_INVALIDFEATURELEVEL + CreatedevicecontextstateInvalidfeaturelevel = 3145751, + /// + /// D3D11_MESSAGE_ID_CREATEDEVICECONTEXTSTATE_FEATURELEVELS_NOT_SUPPORTED + CreatedevicecontextstateFeaturelevelsNotSupported = 3145752, + /// + /// D3D11_MESSAGE_ID_CREATEDEVICECONTEXTSTATE_INVALIDREFIID + CreatedevicecontextstateInvalidrefiid = 3145753, + /// + /// D3D11_MESSAGE_ID_DEVICE_DISCARDVIEW_INVALIDVIEW + DeviceDiscardviewInvalidview = 3145754, + /// + /// D3D11_MESSAGE_ID_COPYSUBRESOURCEREGION1_INVALIDCOPYFLAGS + Copysubresourceregion1Invalidcopyflags = 3145755, + /// + /// D3D11_MESSAGE_ID_UPDATESUBRESOURCE1_INVALIDCOPYFLAGS + Updatesubresource1Invalidcopyflags = 3145756, + /// + /// D3D11_MESSAGE_ID_CREATERASTERIZERSTATE_INVALIDFORCEDSAMPLECOUNT + CreaterasterizerstateInvalidforcedsamplecount = 3145757, + /// + /// D3D11_MESSAGE_ID_CREATEVIDEODECODER_OUTOFMEMORY_RETURN + CreatevideodecoderOutofmemoryReturn = 3145758, + /// + /// D3D11_MESSAGE_ID_CREATEVIDEODECODER_NULLPARAM + CreatevideodecoderNullparam = 3145759, + /// + /// D3D11_MESSAGE_ID_CREATEVIDEODECODER_INVALIDFORMAT + CreatevideodecoderInvalidformat = 3145760, + /// + /// D3D11_MESSAGE_ID_CREATEVIDEODECODER_ZEROWIDTHHEIGHT + CreatevideodecoderZerowidthheight = 3145761, + /// + /// D3D11_MESSAGE_ID_CREATEVIDEODECODER_DRIVER_INVALIDBUFFERSIZE + CreatevideodecoderDriverInvalidbuffersize = 3145762, + /// + /// D3D11_MESSAGE_ID_CREATEVIDEODECODER_DRIVER_INVALIDBUFFERUSAGE + CreatevideodecoderDriverInvalidbufferusage = 3145763, + /// + /// D3D11_MESSAGE_ID_GETVIDEODECODERPROFILECOUNT_OUTOFMEMORY + GetvideodecoderprofilecountOutofmemory = 3145764, + /// + /// D3D11_MESSAGE_ID_GETVIDEODECODERPROFILE_NULLPARAM + GetvideodecoderprofileNullparam = 3145765, + /// + /// D3D11_MESSAGE_ID_GETVIDEODECODERPROFILE_INVALIDINDEX + GetvideodecoderprofileInvalidindex = 3145766, + /// + /// D3D11_MESSAGE_ID_GETVIDEODECODERPROFILE_OUTOFMEMORY_RETURN + GetvideodecoderprofileOutofmemoryReturn = 3145767, + /// + /// D3D11_MESSAGE_ID_CHECKVIDEODECODERFORMAT_NULLPARAM + CheckvideodecoderformatNullparam = 3145768, + /// + /// D3D11_MESSAGE_ID_CHECKVIDEODECODERFORMAT_OUTOFMEMORY_RETURN + CheckvideodecoderformatOutofmemoryReturn = 3145769, + /// + /// D3D11_MESSAGE_ID_GETVIDEODECODERCONFIGCOUNT_NULLPARAM + GetvideodecoderconfigcountNullparam = 3145770, + /// + /// D3D11_MESSAGE_ID_GETVIDEODECODERCONFIGCOUNT_OUTOFMEMORY_RETURN + GetvideodecoderconfigcountOutofmemoryReturn = 3145771, + /// + /// D3D11_MESSAGE_ID_GETVIDEODECODERCONFIG_NULLPARAM + GetvideodecoderconfigNullparam = 3145772, + /// + /// D3D11_MESSAGE_ID_GETVIDEODECODERCONFIG_INVALIDINDEX + GetvideodecoderconfigInvalidindex = 3145773, + /// + /// D3D11_MESSAGE_ID_GETVIDEODECODERCONFIG_OUTOFMEMORY_RETURN + GetvideodecoderconfigOutofmemoryReturn = 3145774, + /// + /// D3D11_MESSAGE_ID_GETDECODERCREATIONPARAMS_NULLPARAM + GetdecodercreationparamsNullparam = 3145775, + /// + /// D3D11_MESSAGE_ID_GETDECODERDRIVERHANDLE_NULLPARAM + GetdecoderdriverhandleNullparam = 3145776, + /// + /// D3D11_MESSAGE_ID_GETDECODERBUFFER_NULLPARAM + GetdecoderbufferNullparam = 3145777, + /// + /// D3D11_MESSAGE_ID_GETDECODERBUFFER_INVALIDBUFFER + GetdecoderbufferInvalidbuffer = 3145778, + /// + /// D3D11_MESSAGE_ID_GETDECODERBUFFER_INVALIDTYPE + GetdecoderbufferInvalidtype = 3145779, + /// + /// D3D11_MESSAGE_ID_GETDECODERBUFFER_LOCKED + GetdecoderbufferLocked = 3145780, + /// + /// D3D11_MESSAGE_ID_RELEASEDECODERBUFFER_NULLPARAM + ReleasedecoderbufferNullparam = 3145781, + /// + /// D3D11_MESSAGE_ID_RELEASEDECODERBUFFER_INVALIDTYPE + ReleasedecoderbufferInvalidtype = 3145782, + /// + /// D3D11_MESSAGE_ID_RELEASEDECODERBUFFER_NOTLOCKED + ReleasedecoderbufferNotlocked = 3145783, + /// + /// D3D11_MESSAGE_ID_DECODERBEGINFRAME_NULLPARAM + DecoderbeginframeNullparam = 3145784, + /// + /// D3D11_MESSAGE_ID_DECODERBEGINFRAME_HAZARD + DecoderbeginframeHazard = 3145785, + /// + /// D3D11_MESSAGE_ID_DECODERENDFRAME_NULLPARAM + DecoderendframeNullparam = 3145786, + /// + /// D3D11_MESSAGE_ID_SUBMITDECODERBUFFERS_NULLPARAM + SubmitdecoderbuffersNullparam = 3145787, + /// + /// D3D11_MESSAGE_ID_SUBMITDECODERBUFFERS_INVALIDTYPE + SubmitdecoderbuffersInvalidtype = 3145788, + /// + /// D3D11_MESSAGE_ID_DECODEREXTENSION_NULLPARAM + DecoderextensionNullparam = 3145789, + /// + /// D3D11_MESSAGE_ID_DECODEREXTENSION_INVALIDRESOURCE + DecoderextensionInvalidresource = 3145790, + /// + /// D3D11_MESSAGE_ID_CREATEVIDEOPROCESSORENUMERATOR_OUTOFMEMORY_RETURN + CreatevideoprocessorenumeratorOutofmemoryReturn = 3145791, + /// + /// D3D11_MESSAGE_ID_CREATEVIDEOPROCESSORENUMERATOR_NULLPARAM + CreatevideoprocessorenumeratorNullparam = 3145792, + /// + /// D3D11_MESSAGE_ID_CREATEVIDEOPROCESSORENUMERATOR_INVALIDFRAMEFORMAT + CreatevideoprocessorenumeratorInvalidframeformat = 3145793, + /// + /// D3D11_MESSAGE_ID_CREATEVIDEOPROCESSORENUMERATOR_INVALIDUSAGE + CreatevideoprocessorenumeratorInvalidusage = 3145794, + /// + /// D3D11_MESSAGE_ID_CREATEVIDEOPROCESSORENUMERATOR_INVALIDINPUTFRAMERATE + CreatevideoprocessorenumeratorInvalidinputframerate = 3145795, + /// + /// D3D11_MESSAGE_ID_CREATEVIDEOPROCESSORENUMERATOR_INVALIDOUTPUTFRAMERATE + CreatevideoprocessorenumeratorInvalidoutputframerate = 3145796, + /// + /// D3D11_MESSAGE_ID_CREATEVIDEOPROCESSORENUMERATOR_INVALIDWIDTHHEIGHT + CreatevideoprocessorenumeratorInvalidwidthheight = 3145797, + /// + /// D3D11_MESSAGE_ID_GETVIDEOPROCESSORCONTENTDESC_NULLPARAM + GetvideoprocessorcontentdescNullparam = 3145798, + /// + /// D3D11_MESSAGE_ID_CHECKVIDEOPROCESSORFORMAT_NULLPARAM + CheckvideoprocessorformatNullparam = 3145799, + /// + /// D3D11_MESSAGE_ID_GETVIDEOPROCESSORCAPS_NULLPARAM + GetvideoprocessorcapsNullparam = 3145800, + /// + /// D3D11_MESSAGE_ID_GETVIDEOPROCESSORRATECONVERSIONCAPS_NULLPARAM + GetvideoprocessorrateconversioncapsNullparam = 3145801, + /// + /// D3D11_MESSAGE_ID_GETVIDEOPROCESSORRATECONVERSIONCAPS_INVALIDINDEX + GetvideoprocessorrateconversioncapsInvalidindex = 3145802, + /// + /// D3D11_MESSAGE_ID_GETVIDEOPROCESSORCUSTOMRATE_NULLPARAM + GetvideoprocessorcustomrateNullparam = 3145803, + /// + /// D3D11_MESSAGE_ID_GETVIDEOPROCESSORCUSTOMRATE_INVALIDINDEX + GetvideoprocessorcustomrateInvalidindex = 3145804, + /// + /// D3D11_MESSAGE_ID_GETVIDEOPROCESSORFILTERRANGE_NULLPARAM + GetvideoprocessorfilterrangeNullparam = 3145805, + /// + /// D3D11_MESSAGE_ID_GETVIDEOPROCESSORFILTERRANGE_UNSUPPORTED + GetvideoprocessorfilterrangeUnsupported = 3145806, + /// + /// D3D11_MESSAGE_ID_CREATEVIDEOPROCESSOR_OUTOFMEMORY_RETURN + CreatevideoprocessorOutofmemoryReturn = 3145807, + /// + /// D3D11_MESSAGE_ID_CREATEVIDEOPROCESSOR_NULLPARAM + CreatevideoprocessorNullparam = 3145808, + /// + /// D3D11_MESSAGE_ID_VIDEOPROCESSORSETOUTPUTTARGETRECT_NULLPARAM + VideoprocessorsetoutputtargetrectNullparam = 3145809, + /// + /// D3D11_MESSAGE_ID_VIDEOPROCESSORSETOUTPUTBACKGROUNDCOLOR_NULLPARAM + VideoprocessorsetoutputbackgroundcolorNullparam = 3145810, + /// + /// D3D11_MESSAGE_ID_VIDEOPROCESSORSETOUTPUTBACKGROUNDCOLOR_INVALIDALPHA + VideoprocessorsetoutputbackgroundcolorInvalidalpha = 3145811, + /// + /// D3D11_MESSAGE_ID_VIDEOPROCESSORSETOUTPUTCOLORSPACE_NULLPARAM + VideoprocessorsetoutputcolorspaceNullparam = 3145812, + /// + /// D3D11_MESSAGE_ID_VIDEOPROCESSORSETOUTPUTALPHAFILLMODE_NULLPARAM + VideoprocessorsetoutputalphafillmodeNullparam = 3145813, + /// + /// D3D11_MESSAGE_ID_VIDEOPROCESSORSETOUTPUTALPHAFILLMODE_UNSUPPORTED + VideoprocessorsetoutputalphafillmodeUnsupported = 3145814, + /// + /// D3D11_MESSAGE_ID_VIDEOPROCESSORSETOUTPUTALPHAFILLMODE_INVALIDSTREAM + VideoprocessorsetoutputalphafillmodeInvalidstream = 3145815, + /// + /// D3D11_MESSAGE_ID_VIDEOPROCESSORSETOUTPUTALPHAFILLMODE_INVALIDFILLMODE + VideoprocessorsetoutputalphafillmodeInvalidfillmode = 3145816, + /// + /// D3D11_MESSAGE_ID_VIDEOPROCESSORSETOUTPUTCONSTRICTION_NULLPARAM + VideoprocessorsetoutputconstrictionNullparam = 3145817, + /// + /// D3D11_MESSAGE_ID_VIDEOPROCESSORSETOUTPUTSTEREOMODE_NULLPARAM + VideoprocessorsetoutputstereomodeNullparam = 3145818, + /// + /// D3D11_MESSAGE_ID_VIDEOPROCESSORSETOUTPUTSTEREOMODE_UNSUPPORTED + VideoprocessorsetoutputstereomodeUnsupported = 3145819, + /// + /// D3D11_MESSAGE_ID_VIDEOPROCESSORSETOUTPUTEXTENSION_NULLPARAM + VideoprocessorsetoutputextensionNullparam = 3145820, + /// + /// D3D11_MESSAGE_ID_VIDEOPROCESSORGETOUTPUTTARGETRECT_NULLPARAM + VideoprocessorgetoutputtargetrectNullparam = 3145821, + /// + /// D3D11_MESSAGE_ID_VIDEOPROCESSORGETOUTPUTBACKGROUNDCOLOR_NULLPARAM + VideoprocessorgetoutputbackgroundcolorNullparam = 3145822, + /// + /// D3D11_MESSAGE_ID_VIDEOPROCESSORGETOUTPUTCOLORSPACE_NULLPARAM + VideoprocessorgetoutputcolorspaceNullparam = 3145823, + /// + /// D3D11_MESSAGE_ID_VIDEOPROCESSORGETOUTPUTALPHAFILLMODE_NULLPARAM + VideoprocessorgetoutputalphafillmodeNullparam = 3145824, + /// + /// D3D11_MESSAGE_ID_VIDEOPROCESSORGETOUTPUTCONSTRICTION_NULLPARAM + VideoprocessorgetoutputconstrictionNullparam = 3145825, + /// + /// D3D11_MESSAGE_ID_VIDEOPROCESSORSETOUTPUTCONSTRICTION_UNSUPPORTED + VideoprocessorsetoutputconstrictionUnsupported = 3145826, + /// + /// D3D11_MESSAGE_ID_VIDEOPROCESSORSETOUTPUTCONSTRICTION_INVALIDSIZE + VideoprocessorsetoutputconstrictionInvalidsize = 3145827, + /// + /// D3D11_MESSAGE_ID_VIDEOPROCESSORGETOUTPUTSTEREOMODE_NULLPARAM + VideoprocessorgetoutputstereomodeNullparam = 3145828, + /// + /// D3D11_MESSAGE_ID_VIDEOPROCESSORGETOUTPUTEXTENSION_NULLPARAM + VideoprocessorgetoutputextensionNullparam = 3145829, + /// + /// D3D11_MESSAGE_ID_VIDEOPROCESSORSETSTREAMFRAMEFORMAT_NULLPARAM + VideoprocessorsetstreamframeformatNullparam = 3145830, + /// + /// D3D11_MESSAGE_ID_VIDEOPROCESSORSETSTREAMFRAMEFORMAT_INVALIDFORMAT + VideoprocessorsetstreamframeformatInvalidformat = 3145831, + /// + /// D3D11_MESSAGE_ID_VIDEOPROCESSORSETSTREAMFRAMEFORMAT_INVALIDSTREAM + VideoprocessorsetstreamframeformatInvalidstream = 3145832, + /// + /// D3D11_MESSAGE_ID_VIDEOPROCESSORSETSTREAMCOLORSPACE_NULLPARAM + VideoprocessorsetstreamcolorspaceNullparam = 3145833, + /// + /// D3D11_MESSAGE_ID_VIDEOPROCESSORSETSTREAMCOLORSPACE_INVALIDSTREAM + VideoprocessorsetstreamcolorspaceInvalidstream = 3145834, + /// + /// D3D11_MESSAGE_ID_VIDEOPROCESSORSETSTREAMOUTPUTRATE_NULLPARAM + VideoprocessorsetstreamoutputrateNullparam = 3145835, + /// + /// D3D11_MESSAGE_ID_VIDEOPROCESSORSETSTREAMOUTPUTRATE_INVALIDRATE + VideoprocessorsetstreamoutputrateInvalidrate = 3145836, + /// + /// D3D11_MESSAGE_ID_VIDEOPROCESSORSETSTREAMOUTPUTRATE_INVALIDFLAG + VideoprocessorsetstreamoutputrateInvalidflag = 3145837, + /// + /// D3D11_MESSAGE_ID_VIDEOPROCESSORSETSTREAMOUTPUTRATE_INVALIDSTREAM + VideoprocessorsetstreamoutputrateInvalidstream = 3145838, + /// + /// D3D11_MESSAGE_ID_VIDEOPROCESSORSETSTREAMSOURCERECT_NULLPARAM + VideoprocessorsetstreamsourcerectNullparam = 3145839, + /// + /// D3D11_MESSAGE_ID_VIDEOPROCESSORSETSTREAMSOURCERECT_INVALIDSTREAM + VideoprocessorsetstreamsourcerectInvalidstream = 3145840, + /// + /// D3D11_MESSAGE_ID_VIDEOPROCESSORSETSTREAMSOURCERECT_INVALIDRECT + VideoprocessorsetstreamsourcerectInvalidrect = 3145841, + /// + /// D3D11_MESSAGE_ID_VIDEOPROCESSORSETSTREAMDESTRECT_NULLPARAM + VideoprocessorsetstreamdestrectNullparam = 3145842, + /// + /// D3D11_MESSAGE_ID_VIDEOPROCESSORSETSTREAMDESTRECT_INVALIDSTREAM + VideoprocessorsetstreamdestrectInvalidstream = 3145843, + /// + /// D3D11_MESSAGE_ID_VIDEOPROCESSORSETSTREAMDESTRECT_INVALIDRECT + VideoprocessorsetstreamdestrectInvalidrect = 3145844, + /// + /// D3D11_MESSAGE_ID_VIDEOPROCESSORSETSTREAMALPHA_NULLPARAM + VideoprocessorsetstreamalphaNullparam = 3145845, + /// + /// D3D11_MESSAGE_ID_VIDEOPROCESSORSETSTREAMALPHA_INVALIDSTREAM + VideoprocessorsetstreamalphaInvalidstream = 3145846, + /// + /// D3D11_MESSAGE_ID_VIDEOPROCESSORSETSTREAMALPHA_INVALIDALPHA + VideoprocessorsetstreamalphaInvalidalpha = 3145847, + /// + /// D3D11_MESSAGE_ID_VIDEOPROCESSORSETSTREAMPALETTE_NULLPARAM + VideoprocessorsetstreampaletteNullparam = 3145848, + /// + /// D3D11_MESSAGE_ID_VIDEOPROCESSORSETSTREAMPALETTE_INVALIDSTREAM + VideoprocessorsetstreampaletteInvalidstream = 3145849, + /// + /// D3D11_MESSAGE_ID_VIDEOPROCESSORSETSTREAMPALETTE_INVALIDCOUNT + VideoprocessorsetstreampaletteInvalidcount = 3145850, + /// + /// D3D11_MESSAGE_ID_VIDEOPROCESSORSETSTREAMPALETTE_INVALIDALPHA + VideoprocessorsetstreampaletteInvalidalpha = 3145851, + /// + /// D3D11_MESSAGE_ID_VIDEOPROCESSORSETSTREAMPIXELASPECTRATIO_NULLPARAM + VideoprocessorsetstreampixelaspectratioNullparam = 3145852, + /// + /// D3D11_MESSAGE_ID_VIDEOPROCESSORSETSTREAMPIXELASPECTRATIO_INVALIDSTREAM + VideoprocessorsetstreampixelaspectratioInvalidstream = 3145853, + /// + /// D3D11_MESSAGE_ID_VIDEOPROCESSORSETSTREAMPIXELASPECTRATIO_INVALIDRATIO + VideoprocessorsetstreampixelaspectratioInvalidratio = 3145854, + /// + /// D3D11_MESSAGE_ID_VIDEOPROCESSORSETSTREAMLUMAKEY_NULLPARAM + VideoprocessorsetstreamlumakeyNullparam = 3145855, + /// + /// D3D11_MESSAGE_ID_VIDEOPROCESSORSETSTREAMLUMAKEY_INVALIDSTREAM + VideoprocessorsetstreamlumakeyInvalidstream = 3145856, + /// + /// D3D11_MESSAGE_ID_VIDEOPROCESSORSETSTREAMLUMAKEY_INVALIDRANGE + VideoprocessorsetstreamlumakeyInvalidrange = 3145857, + /// + /// D3D11_MESSAGE_ID_VIDEOPROCESSORSETSTREAMLUMAKEY_UNSUPPORTED + VideoprocessorsetstreamlumakeyUnsupported = 3145858, + /// + /// D3D11_MESSAGE_ID_VIDEOPROCESSORSETSTREAMSTEREOFORMAT_NULLPARAM + VideoprocessorsetstreamstereoformatNullparam = 3145859, + /// + /// D3D11_MESSAGE_ID_VIDEOPROCESSORSETSTREAMSTEREOFORMAT_INVALIDSTREAM + VideoprocessorsetstreamstereoformatInvalidstream = 3145860, + /// + /// D3D11_MESSAGE_ID_VIDEOPROCESSORSETSTREAMSTEREOFORMAT_UNSUPPORTED + VideoprocessorsetstreamstereoformatUnsupported = 3145861, + /// + /// D3D11_MESSAGE_ID_VIDEOPROCESSORSETSTREAMSTEREOFORMAT_FLIPUNSUPPORTED + VideoprocessorsetstreamstereoformatFlipunsupported = 3145862, + /// + /// D3D11_MESSAGE_ID_VIDEOPROCESSORSETSTREAMSTEREOFORMAT_MONOOFFSETUNSUPPORTED + VideoprocessorsetstreamstereoformatMonooffsetunsupported = 3145863, + /// + /// D3D11_MESSAGE_ID_VIDEOPROCESSORSETSTREAMSTEREOFORMAT_FORMATUNSUPPORTED + VideoprocessorsetstreamstereoformatFormatunsupported = 3145864, + /// + /// D3D11_MESSAGE_ID_VIDEOPROCESSORSETSTREAMSTEREOFORMAT_INVALIDFORMAT + VideoprocessorsetstreamstereoformatInvalidformat = 3145865, + /// + /// D3D11_MESSAGE_ID_VIDEOPROCESSORSETSTREAMAUTOPROCESSINGMODE_NULLPARAM + VideoprocessorsetstreamautoprocessingmodeNullparam = 3145866, + /// + /// D3D11_MESSAGE_ID_VIDEOPROCESSORSETSTREAMAUTOPROCESSINGMODE_INVALIDSTREAM + VideoprocessorsetstreamautoprocessingmodeInvalidstream = 3145867, + /// + /// D3D11_MESSAGE_ID_VIDEOPROCESSORSETSTREAMFILTER_NULLPARAM + VideoprocessorsetstreamfilterNullparam = 3145868, + /// + /// D3D11_MESSAGE_ID_VIDEOPROCESSORSETSTREAMFILTER_INVALIDSTREAM + VideoprocessorsetstreamfilterInvalidstream = 3145869, + /// + /// D3D11_MESSAGE_ID_VIDEOPROCESSORSETSTREAMFILTER_INVALIDFILTER + VideoprocessorsetstreamfilterInvalidfilter = 3145870, + /// + /// D3D11_MESSAGE_ID_VIDEOPROCESSORSETSTREAMFILTER_UNSUPPORTED + VideoprocessorsetstreamfilterUnsupported = 3145871, + /// + /// D3D11_MESSAGE_ID_VIDEOPROCESSORSETSTREAMFILTER_INVALIDLEVEL + VideoprocessorsetstreamfilterInvalidlevel = 3145872, + /// + /// D3D11_MESSAGE_ID_VIDEOPROCESSORSETSTREAMEXTENSION_NULLPARAM + VideoprocessorsetstreamextensionNullparam = 3145873, + /// + /// D3D11_MESSAGE_ID_VIDEOPROCESSORSETSTREAMEXTENSION_INVALIDSTREAM + VideoprocessorsetstreamextensionInvalidstream = 3145874, + /// + /// D3D11_MESSAGE_ID_VIDEOPROCESSORGETSTREAMFRAMEFORMAT_NULLPARAM + VideoprocessorgetstreamframeformatNullparam = 3145875, + /// + /// D3D11_MESSAGE_ID_VIDEOPROCESSORGETSTREAMCOLORSPACE_NULLPARAM + VideoprocessorgetstreamcolorspaceNullparam = 3145876, + /// + /// D3D11_MESSAGE_ID_VIDEOPROCESSORGETSTREAMOUTPUTRATE_NULLPARAM + VideoprocessorgetstreamoutputrateNullparam = 3145877, + /// + /// D3D11_MESSAGE_ID_VIDEOPROCESSORGETSTREAMSOURCERECT_NULLPARAM + VideoprocessorgetstreamsourcerectNullparam = 3145878, + /// + /// D3D11_MESSAGE_ID_VIDEOPROCESSORGETSTREAMDESTRECT_NULLPARAM + VideoprocessorgetstreamdestrectNullparam = 3145879, + /// + /// D3D11_MESSAGE_ID_VIDEOPROCESSORGETSTREAMALPHA_NULLPARAM + VideoprocessorgetstreamalphaNullparam = 3145880, + /// + /// D3D11_MESSAGE_ID_VIDEOPROCESSORGETSTREAMPALETTE_NULLPARAM + VideoprocessorgetstreampaletteNullparam = 3145881, + /// + /// D3D11_MESSAGE_ID_VIDEOPROCESSORGETSTREAMPIXELASPECTRATIO_NULLPARAM + VideoprocessorgetstreampixelaspectratioNullparam = 3145882, + /// + /// D3D11_MESSAGE_ID_VIDEOPROCESSORGETSTREAMLUMAKEY_NULLPARAM + VideoprocessorgetstreamlumakeyNullparam = 3145883, + /// + /// D3D11_MESSAGE_ID_VIDEOPROCESSORGETSTREAMSTEREOFORMAT_NULLPARAM + VideoprocessorgetstreamstereoformatNullparam = 3145884, + /// + /// D3D11_MESSAGE_ID_VIDEOPROCESSORGETSTREAMAUTOPROCESSINGMODE_NULLPARAM + VideoprocessorgetstreamautoprocessingmodeNullparam = 3145885, + /// + /// D3D11_MESSAGE_ID_VIDEOPROCESSORGETSTREAMFILTER_NULLPARAM + VideoprocessorgetstreamfilterNullparam = 3145886, + /// + /// D3D11_MESSAGE_ID_VIDEOPROCESSORGETSTREAMEXTENSION_NULLPARAM + VideoprocessorgetstreamextensionNullparam = 3145887, + /// + /// D3D11_MESSAGE_ID_VIDEOPROCESSORGETSTREAMEXTENSION_INVALIDSTREAM + VideoprocessorgetstreamextensionInvalidstream = 3145888, + /// + /// D3D11_MESSAGE_ID_VIDEOPROCESSORBLT_NULLPARAM + VideoprocessorbltNullparam = 3145889, + /// + /// D3D11_MESSAGE_ID_VIDEOPROCESSORBLT_INVALIDSTREAMCOUNT + VideoprocessorbltInvalidstreamcount = 3145890, + /// + /// D3D11_MESSAGE_ID_VIDEOPROCESSORBLT_TARGETRECT + VideoprocessorbltTargetrect = 3145891, + /// + /// D3D11_MESSAGE_ID_VIDEOPROCESSORBLT_INVALIDOUTPUT + VideoprocessorbltInvalidoutput = 3145892, + /// + /// D3D11_MESSAGE_ID_VIDEOPROCESSORBLT_INVALIDPASTFRAMES + VideoprocessorbltInvalidpastframes = 3145893, + /// + /// D3D11_MESSAGE_ID_VIDEOPROCESSORBLT_INVALIDFUTUREFRAMES + VideoprocessorbltInvalidfutureframes = 3145894, + /// + /// D3D11_MESSAGE_ID_VIDEOPROCESSORBLT_INVALIDSOURCERECT + VideoprocessorbltInvalidsourcerect = 3145895, + /// + /// D3D11_MESSAGE_ID_VIDEOPROCESSORBLT_INVALIDDESTRECT + VideoprocessorbltInvaliddestrect = 3145896, + /// + /// D3D11_MESSAGE_ID_VIDEOPROCESSORBLT_INVALIDINPUTRESOURCE + VideoprocessorbltInvalidinputresource = 3145897, + /// + /// D3D11_MESSAGE_ID_VIDEOPROCESSORBLT_INVALIDARRAYSIZE + VideoprocessorbltInvalidarraysize = 3145898, + /// + /// D3D11_MESSAGE_ID_VIDEOPROCESSORBLT_INVALIDARRAY + VideoprocessorbltInvalidarray = 3145899, + /// + /// D3D11_MESSAGE_ID_VIDEOPROCESSORBLT_RIGHTEXPECTED + VideoprocessorbltRightexpected = 3145900, + /// + /// D3D11_MESSAGE_ID_VIDEOPROCESSORBLT_RIGHTNOTEXPECTED + VideoprocessorbltRightnotexpected = 3145901, + /// + /// D3D11_MESSAGE_ID_VIDEOPROCESSORBLT_STEREONOTENABLED + VideoprocessorbltStereonotenabled = 3145902, + /// + /// D3D11_MESSAGE_ID_VIDEOPROCESSORBLT_INVALIDRIGHTRESOURCE + VideoprocessorbltInvalidrightresource = 3145903, + /// + /// D3D11_MESSAGE_ID_VIDEOPROCESSORBLT_NOSTEREOSTREAMS + VideoprocessorbltNostereostreams = 3145904, + /// + /// D3D11_MESSAGE_ID_VIDEOPROCESSORBLT_INPUTHAZARD + VideoprocessorbltInputhazard = 3145905, + /// + /// D3D11_MESSAGE_ID_VIDEOPROCESSORBLT_OUTPUTHAZARD + VideoprocessorbltOutputhazard = 3145906, + /// + /// D3D11_MESSAGE_ID_CREATEVIDEODECODEROUTPUTVIEW_OUTOFMEMORY_RETURN + CreatevideodecoderoutputviewOutofmemoryReturn = 3145907, + /// + /// D3D11_MESSAGE_ID_CREATEVIDEODECODEROUTPUTVIEW_NULLPARAM + CreatevideodecoderoutputviewNullparam = 3145908, + /// + /// D3D11_MESSAGE_ID_CREATEVIDEODECODEROUTPUTVIEW_INVALIDTYPE + CreatevideodecoderoutputviewInvalidtype = 3145909, + /// + /// D3D11_MESSAGE_ID_CREATEVIDEODECODEROUTPUTVIEW_INVALIDBIND + CreatevideodecoderoutputviewInvalidbind = 3145910, + /// + /// D3D11_MESSAGE_ID_CREATEVIDEODECODEROUTPUTVIEW_UNSUPPORTEDFORMAT + CreatevideodecoderoutputviewUnsupportedformat = 3145911, + /// + /// D3D11_MESSAGE_ID_CREATEVIDEODECODEROUTPUTVIEW_INVALIDMIP + CreatevideodecoderoutputviewInvalidmip = 3145912, + /// + /// D3D11_MESSAGE_ID_CREATEVIDEODECODEROUTPUTVIEW_UNSUPPORTEMIP + CreatevideodecoderoutputviewUnsupportemip = 3145913, + /// + /// D3D11_MESSAGE_ID_CREATEVIDEODECODEROUTPUTVIEW_INVALIDARRAYSIZE + CreatevideodecoderoutputviewInvalidarraysize = 3145914, + /// + /// D3D11_MESSAGE_ID_CREATEVIDEODECODEROUTPUTVIEW_INVALIDARRAY + CreatevideodecoderoutputviewInvalidarray = 3145915, + /// + /// D3D11_MESSAGE_ID_CREATEVIDEODECODEROUTPUTVIEW_INVALIDDIMENSION + CreatevideodecoderoutputviewInvaliddimension = 3145916, + /// + /// D3D11_MESSAGE_ID_CREATEVIDEOPROCESSORINPUTVIEW_OUTOFMEMORY_RETURN + CreatevideoprocessorinputviewOutofmemoryReturn = 3145917, + /// + /// D3D11_MESSAGE_ID_CREATEVIDEOPROCESSORINPUTVIEW_NULLPARAM + CreatevideoprocessorinputviewNullparam = 3145918, + /// + /// D3D11_MESSAGE_ID_CREATEVIDEOPROCESSORINPUTVIEW_INVALIDTYPE + CreatevideoprocessorinputviewInvalidtype = 3145919, + /// + /// D3D11_MESSAGE_ID_CREATEVIDEOPROCESSORINPUTVIEW_INVALIDBIND + CreatevideoprocessorinputviewInvalidbind = 3145920, + /// + /// D3D11_MESSAGE_ID_CREATEVIDEOPROCESSORINPUTVIEW_INVALIDMISC + CreatevideoprocessorinputviewInvalidmisc = 3145921, + /// + /// D3D11_MESSAGE_ID_CREATEVIDEOPROCESSORINPUTVIEW_INVALIDUSAGE + CreatevideoprocessorinputviewInvalidusage = 3145922, + /// + /// D3D11_MESSAGE_ID_CREATEVIDEOPROCESSORINPUTVIEW_INVALIDFORMAT + CreatevideoprocessorinputviewInvalidformat = 3145923, + /// + /// D3D11_MESSAGE_ID_CREATEVIDEOPROCESSORINPUTVIEW_INVALIDFOURCC + CreatevideoprocessorinputviewInvalidfourcc = 3145924, + /// + /// D3D11_MESSAGE_ID_CREATEVIDEOPROCESSORINPUTVIEW_INVALIDMIP + CreatevideoprocessorinputviewInvalidmip = 3145925, + /// + /// D3D11_MESSAGE_ID_CREATEVIDEOPROCESSORINPUTVIEW_UNSUPPORTEDMIP + CreatevideoprocessorinputviewUnsupportedmip = 3145926, + /// + /// D3D11_MESSAGE_ID_CREATEVIDEOPROCESSORINPUTVIEW_INVALIDARRAYSIZE + CreatevideoprocessorinputviewInvalidarraysize = 3145927, + /// + /// D3D11_MESSAGE_ID_CREATEVIDEOPROCESSORINPUTVIEW_INVALIDARRAY + CreatevideoprocessorinputviewInvalidarray = 3145928, + /// + /// D3D11_MESSAGE_ID_CREATEVIDEOPROCESSORINPUTVIEW_INVALIDDIMENSION + CreatevideoprocessorinputviewInvaliddimension = 3145929, + /// + /// D3D11_MESSAGE_ID_CREATEVIDEOPROCESSOROUTPUTVIEW_OUTOFMEMORY_RETURN + CreatevideoprocessoroutputviewOutofmemoryReturn = 3145930, + /// + /// D3D11_MESSAGE_ID_CREATEVIDEOPROCESSOROUTPUTVIEW_NULLPARAM + CreatevideoprocessoroutputviewNullparam = 3145931, + /// + /// D3D11_MESSAGE_ID_CREATEVIDEOPROCESSOROUTPUTVIEW_INVALIDTYPE + CreatevideoprocessoroutputviewInvalidtype = 3145932, + /// + /// D3D11_MESSAGE_ID_CREATEVIDEOPROCESSOROUTPUTVIEW_INVALIDBIND + CreatevideoprocessoroutputviewInvalidbind = 3145933, + /// + /// D3D11_MESSAGE_ID_CREATEVIDEOPROCESSOROUTPUTVIEW_INVALIDFORMAT + CreatevideoprocessoroutputviewInvalidformat = 3145934, + /// + /// D3D11_MESSAGE_ID_CREATEVIDEOPROCESSOROUTPUTVIEW_INVALIDMIP + CreatevideoprocessoroutputviewInvalidmip = 3145935, + /// + /// D3D11_MESSAGE_ID_CREATEVIDEOPROCESSOROUTPUTVIEW_UNSUPPORTEDMIP + CreatevideoprocessoroutputviewUnsupportedmip = 3145936, + /// + /// D3D11_MESSAGE_ID_CREATEVIDEOPROCESSOROUTPUTVIEW_UNSUPPORTEDARRAY + CreatevideoprocessoroutputviewUnsupportedarray = 3145937, + /// + /// D3D11_MESSAGE_ID_CREATEVIDEOPROCESSOROUTPUTVIEW_INVALIDARRAY + CreatevideoprocessoroutputviewInvalidarray = 3145938, + /// + /// D3D11_MESSAGE_ID_CREATEVIDEOPROCESSOROUTPUTVIEW_INVALIDDIMENSION + CreatevideoprocessoroutputviewInvaliddimension = 3145939, + /// + /// D3D11_MESSAGE_ID_DEVICE_DRAW_INVALID_USE_OF_FORCED_SAMPLE_COUNT + DeviceDrawInvalidUseOfForcedSampleCount = 3145940, + /// + /// D3D11_MESSAGE_ID_CREATEBLENDSTATE_INVALIDLOGICOPS + CreateblendstateInvalidlogicops = 3145941, + /// + /// D3D11_MESSAGE_ID_CREATESHADERRESOURCEVIEW_INVALIDDARRAYWITHDECODER + CreateshaderresourceviewInvaliddarraywithdecoder = 3145942, + /// + /// D3D11_MESSAGE_ID_CREATEUNORDEREDACCESSVIEW_INVALIDDARRAYWITHDECODER + CreateunorderedaccessviewInvaliddarraywithdecoder = 3145943, + /// + /// D3D11_MESSAGE_ID_CREATERENDERTARGETVIEW_INVALIDDARRAYWITHDECODER + CreaterendertargetviewInvaliddarraywithdecoder = 3145944, + /// + /// D3D11_MESSAGE_ID_DEVICE_LOCKEDOUT_INTERFACE + DeviceLockedoutInterface = 3145945, + /// + /// D3D11_MESSAGE_ID_REF_WARNING_ATOMIC_INCONSISTENT + RefWarningAtomicInconsistent = 3145946, + /// + /// D3D11_MESSAGE_ID_REF_WARNING_READING_UNINITIALIZED_RESOURCE + RefWarningReadingUninitializedResource = 3145947, + /// + /// D3D11_MESSAGE_ID_REF_WARNING_RAW_HAZARD + RefWarningRawHazard = 3145948, + /// + /// D3D11_MESSAGE_ID_REF_WARNING_WAR_HAZARD + RefWarningWarHazard = 3145949, + /// + /// D3D11_MESSAGE_ID_REF_WARNING_WAW_HAZARD + RefWarningWawHazard = 3145950, + /// + /// D3D11_MESSAGE_ID_CREATECRYPTOSESSION_NULLPARAM + CreatecryptosessionNullparam = 3145951, + /// + /// D3D11_MESSAGE_ID_CREATECRYPTOSESSION_OUTOFMEMORY_RETURN + CreatecryptosessionOutofmemoryReturn = 3145952, + /// + /// D3D11_MESSAGE_ID_GETCRYPTOTYPE_NULLPARAM + GetcryptotypeNullparam = 3145953, + /// + /// D3D11_MESSAGE_ID_GETDECODERPROFILE_NULLPARAM + GetdecoderprofileNullparam = 3145954, + /// + /// D3D11_MESSAGE_ID_GETCRYPTOSESSIONCERTIFICATESIZE_NULLPARAM + GetcryptosessioncertificatesizeNullparam = 3145955, + /// + /// D3D11_MESSAGE_ID_GETCRYPTOSESSIONCERTIFICATE_NULLPARAM + GetcryptosessioncertificateNullparam = 3145956, + /// + /// D3D11_MESSAGE_ID_GETCRYPTOSESSIONCERTIFICATE_WRONGSIZE + GetcryptosessioncertificateWrongsize = 3145957, + /// + /// D3D11_MESSAGE_ID_GETCRYPTOSESSIONHANDLE_WRONGSIZE + GetcryptosessionhandleWrongsize = 3145958, + /// + /// D3D11_MESSAGE_ID_NEGOTIATECRPYTOSESSIONKEYEXCHANGE_NULLPARAM + NegotiatecrpytosessionkeyexchangeNullparam = 3145959, + /// + /// D3D11_MESSAGE_ID_ENCRYPTIONBLT_UNSUPPORTED + EncryptionbltUnsupported = 3145960, + /// + /// D3D11_MESSAGE_ID_ENCRYPTIONBLT_NULLPARAM + EncryptionbltNullparam = 3145961, + /// + /// D3D11_MESSAGE_ID_ENCRYPTIONBLT_SRC_WRONGDEVICE + EncryptionbltSrcWrongdevice = 3145962, + /// + /// D3D11_MESSAGE_ID_ENCRYPTIONBLT_DST_WRONGDEVICE + EncryptionbltDstWrongdevice = 3145963, + /// + /// D3D11_MESSAGE_ID_ENCRYPTIONBLT_FORMAT_MISMATCH + EncryptionbltFormatMismatch = 3145964, + /// + /// D3D11_MESSAGE_ID_ENCRYPTIONBLT_SIZE_MISMATCH + EncryptionbltSizeMismatch = 3145965, + /// + /// D3D11_MESSAGE_ID_ENCRYPTIONBLT_SRC_MULTISAMPLED + EncryptionbltSrcMultisampled = 3145966, + /// + /// D3D11_MESSAGE_ID_ENCRYPTIONBLT_DST_NOT_STAGING + EncryptionbltDstNotStaging = 3145967, + /// + /// D3D11_MESSAGE_ID_ENCRYPTIONBLT_SRC_MAPPED + EncryptionbltSrcMapped = 3145968, + /// + /// D3D11_MESSAGE_ID_ENCRYPTIONBLT_DST_MAPPED + EncryptionbltDstMapped = 3145969, + /// + /// D3D11_MESSAGE_ID_ENCRYPTIONBLT_SRC_OFFERED + EncryptionbltSrcOffered = 3145970, + /// + /// D3D11_MESSAGE_ID_ENCRYPTIONBLT_DST_OFFERED + EncryptionbltDstOffered = 3145971, + /// + /// D3D11_MESSAGE_ID_ENCRYPTIONBLT_SRC_CONTENT_UNDEFINED + EncryptionbltSrcContentUndefined = 3145972, + /// + /// D3D11_MESSAGE_ID_DECRYPTIONBLT_UNSUPPORTED + DecryptionbltUnsupported = 3145973, + /// + /// D3D11_MESSAGE_ID_DECRYPTIONBLT_NULLPARAM + DecryptionbltNullparam = 3145974, + /// + /// D3D11_MESSAGE_ID_DECRYPTIONBLT_SRC_WRONGDEVICE + DecryptionbltSrcWrongdevice = 3145975, + /// + /// D3D11_MESSAGE_ID_DECRYPTIONBLT_DST_WRONGDEVICE + DecryptionbltDstWrongdevice = 3145976, + /// + /// D3D11_MESSAGE_ID_DECRYPTIONBLT_FORMAT_MISMATCH + DecryptionbltFormatMismatch = 3145977, + /// + /// D3D11_MESSAGE_ID_DECRYPTIONBLT_SIZE_MISMATCH + DecryptionbltSizeMismatch = 3145978, + /// + /// D3D11_MESSAGE_ID_DECRYPTIONBLT_DST_MULTISAMPLED + DecryptionbltDstMultisampled = 3145979, + /// + /// D3D11_MESSAGE_ID_DECRYPTIONBLT_SRC_NOT_STAGING + DecryptionbltSrcNotStaging = 3145980, + /// + /// D3D11_MESSAGE_ID_DECRYPTIONBLT_DST_NOT_RENDER_TARGET + DecryptionbltDstNotRenderTarget = 3145981, + /// + /// D3D11_MESSAGE_ID_DECRYPTIONBLT_SRC_MAPPED + DecryptionbltSrcMapped = 3145982, + /// + /// D3D11_MESSAGE_ID_DECRYPTIONBLT_DST_MAPPED + DecryptionbltDstMapped = 3145983, + /// + /// D3D11_MESSAGE_ID_DECRYPTIONBLT_SRC_OFFERED + DecryptionbltSrcOffered = 3145984, + /// + /// D3D11_MESSAGE_ID_DECRYPTIONBLT_DST_OFFERED + DecryptionbltDstOffered = 3145985, + /// + /// D3D11_MESSAGE_ID_DECRYPTIONBLT_SRC_CONTENT_UNDEFINED + DecryptionbltSrcContentUndefined = 3145986, + /// + /// D3D11_MESSAGE_ID_STARTSESSIONKEYREFRESH_NULLPARAM + StartsessionkeyrefreshNullparam = 3145987, + /// + /// D3D11_MESSAGE_ID_STARTSESSIONKEYREFRESH_INVALIDSIZE + StartsessionkeyrefreshInvalidsize = 3145988, + /// + /// D3D11_MESSAGE_ID_FINISHSESSIONKEYREFRESH_NULLPARAM + FinishsessionkeyrefreshNullparam = 3145989, + /// + /// D3D11_MESSAGE_ID_GETENCRYPTIONBLTKEY_NULLPARAM + GetencryptionbltkeyNullparam = 3145990, + /// + /// D3D11_MESSAGE_ID_GETENCRYPTIONBLTKEY_INVALIDSIZE + GetencryptionbltkeyInvalidsize = 3145991, + /// + /// D3D11_MESSAGE_ID_GETCONTENTPROTECTIONCAPS_NULLPARAM + GetcontentprotectioncapsNullparam = 3145992, + /// + /// D3D11_MESSAGE_ID_CHECKCRYPTOKEYEXCHANGE_NULLPARAM + CheckcryptokeyexchangeNullparam = 3145993, + /// + /// D3D11_MESSAGE_ID_CHECKCRYPTOKEYEXCHANGE_INVALIDINDEX + CheckcryptokeyexchangeInvalidindex = 3145994, + /// + /// D3D11_MESSAGE_ID_CREATEAUTHENTICATEDCHANNEL_NULLPARAM + CreateauthenticatedchannelNullparam = 3145995, + /// + /// D3D11_MESSAGE_ID_CREATEAUTHENTICATEDCHANNEL_UNSUPPORTED + CreateauthenticatedchannelUnsupported = 3145996, + /// + /// D3D11_MESSAGE_ID_CREATEAUTHENTICATEDCHANNEL_INVALIDTYPE + CreateauthenticatedchannelInvalidtype = 3145997, + /// + /// D3D11_MESSAGE_ID_CREATEAUTHENTICATEDCHANNEL_OUTOFMEMORY_RETURN + CreateauthenticatedchannelOutofmemoryReturn = 3145998, + /// + /// D3D11_MESSAGE_ID_GETAUTHENTICATEDCHANNELCERTIFICATESIZE_INVALIDCHANNEL + GetauthenticatedchannelcertificatesizeInvalidchannel = 3145999, + /// + /// D3D11_MESSAGE_ID_GETAUTHENTICATEDCHANNELCERTIFICATESIZE_NULLPARAM + GetauthenticatedchannelcertificatesizeNullparam = 3146000, + /// + /// D3D11_MESSAGE_ID_GETAUTHENTICATEDCHANNELCERTIFICATE_INVALIDCHANNEL + GetauthenticatedchannelcertificateInvalidchannel = 3146001, + /// + /// D3D11_MESSAGE_ID_GETAUTHENTICATEDCHANNELCERTIFICATE_NULLPARAM + GetauthenticatedchannelcertificateNullparam = 3146002, + /// + /// D3D11_MESSAGE_ID_GETAUTHENTICATEDCHANNELCERTIFICATE_WRONGSIZE + GetauthenticatedchannelcertificateWrongsize = 3146003, + /// + /// D3D11_MESSAGE_ID_NEGOTIATEAUTHENTICATEDCHANNELKEYEXCHANGE_INVALIDCHANNEL + NegotiateauthenticatedchannelkeyexchangeInvalidchannel = 3146004, + /// + /// D3D11_MESSAGE_ID_NEGOTIATEAUTHENTICATEDCHANNELKEYEXCHANGE_NULLPARAM + NegotiateauthenticatedchannelkeyexchangeNullparam = 3146005, + /// + /// D3D11_MESSAGE_ID_QUERYAUTHENTICATEDCHANNEL_NULLPARAM + QueryauthenticatedchannelNullparam = 3146006, + /// + /// D3D11_MESSAGE_ID_QUERYAUTHENTICATEDCHANNEL_WRONGCHANNEL + QueryauthenticatedchannelWrongchannel = 3146007, + /// + /// D3D11_MESSAGE_ID_QUERYAUTHENTICATEDCHANNEL_UNSUPPORTEDQUERY + QueryauthenticatedchannelUnsupportedquery = 3146008, + /// + /// D3D11_MESSAGE_ID_QUERYAUTHENTICATEDCHANNEL_WRONGSIZE + QueryauthenticatedchannelWrongsize = 3146009, + /// + /// D3D11_MESSAGE_ID_QUERYAUTHENTICATEDCHANNEL_INVALIDPROCESSINDEX + QueryauthenticatedchannelInvalidprocessindex = 3146010, + /// + /// D3D11_MESSAGE_ID_CONFIGUREAUTHENTICATEDCHANNEL_NULLPARAM + ConfigureauthenticatedchannelNullparam = 3146011, + /// + /// D3D11_MESSAGE_ID_CONFIGUREAUTHENTICATEDCHANNEL_WRONGCHANNEL + ConfigureauthenticatedchannelWrongchannel = 3146012, + /// + /// D3D11_MESSAGE_ID_CONFIGUREAUTHENTICATEDCHANNEL_UNSUPPORTEDCONFIGURE + ConfigureauthenticatedchannelUnsupportedconfigure = 3146013, + /// + /// D3D11_MESSAGE_ID_CONFIGUREAUTHENTICATEDCHANNEL_WRONGSIZE + ConfigureauthenticatedchannelWrongsize = 3146014, + /// + /// D3D11_MESSAGE_ID_CONFIGUREAUTHENTICATEDCHANNEL_INVALIDPROCESSIDTYPE + ConfigureauthenticatedchannelInvalidprocessidtype = 3146015, + /// + /// D3D11_MESSAGE_ID_VSSETCONSTANTBUFFERS_INVALIDBUFFEROFFSETORCOUNT + VssetconstantbuffersInvalidbufferoffsetorcount = 3146016, + /// + /// D3D11_MESSAGE_ID_DSSETCONSTANTBUFFERS_INVALIDBUFFEROFFSETORCOUNT + DssetconstantbuffersInvalidbufferoffsetorcount = 3146017, + /// + /// D3D11_MESSAGE_ID_HSSETCONSTANTBUFFERS_INVALIDBUFFEROFFSETORCOUNT + HssetconstantbuffersInvalidbufferoffsetorcount = 3146018, + /// + /// D3D11_MESSAGE_ID_GSSETCONSTANTBUFFERS_INVALIDBUFFEROFFSETORCOUNT + GssetconstantbuffersInvalidbufferoffsetorcount = 3146019, + /// + /// D3D11_MESSAGE_ID_PSSETCONSTANTBUFFERS_INVALIDBUFFEROFFSETORCOUNT + PssetconstantbuffersInvalidbufferoffsetorcount = 3146020, + /// + /// D3D11_MESSAGE_ID_CSSETCONSTANTBUFFERS_INVALIDBUFFEROFFSETORCOUNT + CssetconstantbuffersInvalidbufferoffsetorcount = 3146021, + /// + /// D3D11_MESSAGE_ID_NEGOTIATECRPYTOSESSIONKEYEXCHANGE_INVALIDSIZE + NegotiatecrpytosessionkeyexchangeInvalidsize = 3146022, + /// + /// D3D11_MESSAGE_ID_NEGOTIATEAUTHENTICATEDCHANNELKEYEXCHANGE_INVALIDSIZE + NegotiateauthenticatedchannelkeyexchangeInvalidsize = 3146023, + /// + /// D3D11_MESSAGE_ID_OFFERRESOURCES_INVALIDPRIORITY + OfferresourcesInvalidpriority = 3146024, + /// + /// D3D11_MESSAGE_ID_GETCRYPTOSESSIONHANDLE_OUTOFMEMORY + GetcryptosessionhandleOutofmemory = 3146025, + /// + /// D3D11_MESSAGE_ID_ACQUIREHANDLEFORCAPTURE_NULLPARAM + AcquirehandleforcaptureNullparam = 3146026, + /// + /// D3D11_MESSAGE_ID_ACQUIREHANDLEFORCAPTURE_INVALIDTYPE + AcquirehandleforcaptureInvalidtype = 3146027, + /// + /// D3D11_MESSAGE_ID_ACQUIREHANDLEFORCAPTURE_INVALIDBIND + AcquirehandleforcaptureInvalidbind = 3146028, + /// + /// D3D11_MESSAGE_ID_ACQUIREHANDLEFORCAPTURE_INVALIDARRAY + AcquirehandleforcaptureInvalidarray = 3146029, + /// + /// D3D11_MESSAGE_ID_VIDEOPROCESSORSETSTREAMROTATION_NULLPARAM + VideoprocessorsetstreamrotationNullparam = 3146030, + /// + /// D3D11_MESSAGE_ID_VIDEOPROCESSORSETSTREAMROTATION_INVALIDSTREAM + VideoprocessorsetstreamrotationInvalidstream = 3146031, + /// + /// D3D11_MESSAGE_ID_VIDEOPROCESSORSETSTREAMROTATION_INVALID + VideoprocessorsetstreamrotationInvalid = 3146032, + /// + /// D3D11_MESSAGE_ID_VIDEOPROCESSORSETSTREAMROTATION_UNSUPPORTED + VideoprocessorsetstreamrotationUnsupported = 3146033, + /// + /// D3D11_MESSAGE_ID_VIDEOPROCESSORGETSTREAMROTATION_NULLPARAM + VideoprocessorgetstreamrotationNullparam = 3146034, + /// + /// D3D11_MESSAGE_ID_DEVICE_CLEARVIEW_INVALIDVIEW + DeviceClearviewInvalidview = 3146035, + /// + /// D3D11_MESSAGE_ID_DEVICE_CREATEVERTEXSHADER_DOUBLEEXTENSIONSNOTSUPPORTED + DeviceCreatevertexshaderDoubleextensionsnotsupported = 3146036, + /// + /// D3D11_MESSAGE_ID_DEVICE_CREATEVERTEXSHADER_SHADEREXTENSIONSNOTSUPPORTED + DeviceCreatevertexshaderShaderextensionsnotsupported = 3146037, + /// + /// D3D11_MESSAGE_ID_DEVICE_CREATEHULLSHADER_DOUBLEEXTENSIONSNOTSUPPORTED + DeviceCreatehullshaderDoubleextensionsnotsupported = 3146038, + /// + /// D3D11_MESSAGE_ID_DEVICE_CREATEHULLSHADER_SHADEREXTENSIONSNOTSUPPORTED + DeviceCreatehullshaderShaderextensionsnotsupported = 3146039, + /// + /// D3D11_MESSAGE_ID_DEVICE_CREATEDOMAINSHADER_DOUBLEEXTENSIONSNOTSUPPORTED + DeviceCreatedomainshaderDoubleextensionsnotsupported = 3146040, + /// + /// D3D11_MESSAGE_ID_DEVICE_CREATEDOMAINSHADER_SHADEREXTENSIONSNOTSUPPORTED + DeviceCreatedomainshaderShaderextensionsnotsupported = 3146041, + /// + /// D3D11_MESSAGE_ID_DEVICE_CREATEGEOMETRYSHADER_DOUBLEEXTENSIONSNOTSUPPORTED + DeviceCreategeometryshaderDoubleextensionsnotsupported = 3146042, + /// + /// D3D11_MESSAGE_ID_DEVICE_CREATEGEOMETRYSHADER_SHADEREXTENSIONSNOTSUPPORTED + DeviceCreategeometryshaderShaderextensionsnotsupported = 3146043, + /// + /// D3D11_MESSAGE_ID_DEVICE_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_DOUBLEEXTENSIONSNOTSUPPORTED + DeviceCreategeometryshaderwithstreamoutputDoubleextensionsnotsupported = 3146044, + /// + /// D3D11_MESSAGE_ID_DEVICE_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_SHADEREXTENSIONSNOTSUPPORTED + DeviceCreategeometryshaderwithstreamoutputShaderextensionsnotsupported = 3146045, + /// + /// D3D11_MESSAGE_ID_DEVICE_CREATEPIXELSHADER_DOUBLEEXTENSIONSNOTSUPPORTED + DeviceCreatepixelshaderDoubleextensionsnotsupported = 3146046, + /// + /// D3D11_MESSAGE_ID_DEVICE_CREATEPIXELSHADER_SHADEREXTENSIONSNOTSUPPORTED + DeviceCreatepixelshaderShaderextensionsnotsupported = 3146047, + /// + /// D3D11_MESSAGE_ID_DEVICE_CREATECOMPUTESHADER_DOUBLEEXTENSIONSNOTSUPPORTED + DeviceCreatecomputeshaderDoubleextensionsnotsupported = 3146048, + /// + /// D3D11_MESSAGE_ID_DEVICE_CREATECOMPUTESHADER_SHADEREXTENSIONSNOTSUPPORTED + DeviceCreatecomputeshaderShaderextensionsnotsupported = 3146049, + /// + /// D3D11_MESSAGE_ID_DEVICE_SHADER_LINKAGE_MINPRECISION + DeviceShaderLinkageMinprecision = 3146050, + /// + /// D3D11_MESSAGE_ID_VIDEOPROCESSORSETSTREAMALPHA_UNSUPPORTED + VideoprocessorsetstreamalphaUnsupported = 3146051, + /// + /// D3D11_MESSAGE_ID_VIDEOPROCESSORSETSTREAMPIXELASPECTRATIO_UNSUPPORTED + VideoprocessorsetstreampixelaspectratioUnsupported = 3146052, + /// + /// D3D11_MESSAGE_ID_DEVICE_CREATEVERTEXSHADER_UAVSNOTSUPPORTED + DeviceCreatevertexshaderUavsnotsupported = 3146053, + /// + /// D3D11_MESSAGE_ID_DEVICE_CREATEHULLSHADER_UAVSNOTSUPPORTED + DeviceCreatehullshaderUavsnotsupported = 3146054, + /// + /// D3D11_MESSAGE_ID_DEVICE_CREATEDOMAINSHADER_UAVSNOTSUPPORTED + DeviceCreatedomainshaderUavsnotsupported = 3146055, + /// + /// D3D11_MESSAGE_ID_DEVICE_CREATEGEOMETRYSHADER_UAVSNOTSUPPORTED + DeviceCreategeometryshaderUavsnotsupported = 3146056, + /// + /// D3D11_MESSAGE_ID_DEVICE_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_UAVSNOTSUPPORTED + DeviceCreategeometryshaderwithstreamoutputUavsnotsupported = 3146057, + /// + /// D3D11_MESSAGE_ID_DEVICE_CREATEPIXELSHADER_UAVSNOTSUPPORTED + DeviceCreatepixelshaderUavsnotsupported = 3146058, + /// + /// D3D11_MESSAGE_ID_DEVICE_CREATECOMPUTESHADER_UAVSNOTSUPPORTED + DeviceCreatecomputeshaderUavsnotsupported = 3146059, + /// + /// D3D11_MESSAGE_ID_DEVICE_OMSETRENDERTARGETSANDUNORDEREDACCESSVIEWS_INVALIDOFFSET + DeviceOmsetrendertargetsandunorderedaccessviewsInvalidoffset = 3146060, + /// + /// D3D11_MESSAGE_ID_DEVICE_OMSETRENDERTARGETSANDUNORDEREDACCESSVIEWS_TOOMANYVIEWS + DeviceOmsetrendertargetsandunorderedaccessviewsToomanyviews = 3146061, + /// + /// D3D11_MESSAGE_ID_DEVICE_CLEARVIEW_NOTSUPPORTED + DeviceClearviewNotsupported = 3146062, + /// + /// D3D11_MESSAGE_ID_SWAPDEVICECONTEXTSTATE_NOTSUPPORTED + SwapdevicecontextstateNotsupported = 3146063, + /// + /// D3D11_MESSAGE_ID_UPDATESUBRESOURCE_PREFERUPDATESUBRESOURCE1 + UpdatesubresourcePreferupdatesubresource1 = 3146064, + /// + /// D3D11_MESSAGE_ID_GETDC_INACCESSIBLE + GetdcInaccessible = 3146065, + /// + /// D3D11_MESSAGE_ID_DEVICE_CLEARVIEW_INVALIDRECT + DeviceClearviewInvalidrect = 3146066, + /// + /// D3D11_MESSAGE_ID_DEVICE_DRAW_SAMPLE_MASK_IGNORED_ON_FL9 + DeviceDrawSampleMaskIgnoredOnFl9 = 3146067, + /// + /// D3D11_MESSAGE_ID_DEVICE_OPEN_SHARED_RESOURCE1_NOT_SUPPORTED + DeviceOpenSharedResource1NotSupported = 3146068, + /// + /// D3D11_MESSAGE_ID_DEVICE_OPEN_SHARED_RESOURCE_BY_NAME_NOT_SUPPORTED + DeviceOpenSharedResourceByNameNotSupported = 3146069, + /// + /// D3D11_MESSAGE_ID_ENQUEUESETEVENT_NOT_SUPPORTED + EnqueueseteventNotSupported = 3146070, + /// + /// D3D11_MESSAGE_ID_OFFERRELEASE_NOT_SUPPORTED + OfferreleaseNotSupported = 3146071, + /// + /// D3D11_MESSAGE_ID_OFFERRESOURCES_INACCESSIBLE + OfferresourcesInaccessible = 3146072, + /// + /// D3D11_MESSAGE_ID_CREATEVIDEOPROCESSORINPUTVIEW_INVALIDMSAA + CreatevideoprocessorinputviewInvalidmsaa = 3146073, + /// + /// D3D11_MESSAGE_ID_CREATEVIDEOPROCESSOROUTPUTVIEW_INVALIDMSAA + CreatevideoprocessoroutputviewInvalidmsaa = 3146074, + /// + /// D3D11_MESSAGE_ID_DEVICE_CLEARVIEW_INVALIDSOURCERECT + DeviceClearviewInvalidsourcerect = 3146075, + /// + /// D3D11_MESSAGE_ID_DEVICE_CLEARVIEW_EMPTYRECT + DeviceClearviewEmptyrect = 3146076, + /// + /// D3D11_MESSAGE_ID_UPDATESUBRESOURCE_EMPTYDESTBOX + UpdatesubresourceEmptydestbox = 3146077, + /// + /// D3D11_MESSAGE_ID_COPYSUBRESOURCEREGION_EMPTYSOURCEBOX + CopysubresourceregionEmptysourcebox = 3146078, + /// + /// D3D11_MESSAGE_ID_DEVICE_DRAW_OM_RENDER_TARGET_DOES_NOT_SUPPORT_LOGIC_OPS + DeviceDrawOmRenderTargetDoesNotSupportLogicOps = 3146079, + /// + /// D3D11_MESSAGE_ID_DEVICE_DRAW_DEPTHSTENCILVIEW_NOT_SET + DeviceDrawDepthStencilViewNotSet = 3146080, + /// + /// D3D11_MESSAGE_ID_DEVICE_DRAW_RENDERTARGETVIEW_NOT_SET + DeviceDrawRenderTargetViewNotSet = 3146081, + /// + /// D3D11_MESSAGE_ID_DEVICE_DRAW_RENDERTARGETVIEW_NOT_SET_DUE_TO_FLIP_PRESENT + DeviceDrawRenderTargetViewNotSetDueToFlipPresent = 3146082, + /// + /// D3D11_MESSAGE_ID_DEVICE_UNORDEREDACCESSVIEW_NOT_SET_DUE_TO_FLIP_PRESENT + DeviceUnorderedaccessviewNotSetDueToFlipPresent = 3146083, + /// + /// D3D11_MESSAGE_ID_GETDATAFORNEWHARDWAREKEY_NULLPARAM + GetdatafornewhardwarekeyNullparam = 3146084, + /// + /// D3D11_MESSAGE_ID_CHECKCRYPTOSESSIONSTATUS_NULLPARAM + CheckcryptosessionstatusNullparam = 3146085, + /// + /// D3D11_MESSAGE_ID_GETCRYPTOSESSIONPRIVATEDATASIZE_NULLPARAM + GetcryptosessionprivatedatasizeNullparam = 3146086, + /// + /// D3D11_MESSAGE_ID_GETVIDEODECODERCAPS_NULLPARAM + GetvideodecodercapsNullparam = 3146087, + /// + /// D3D11_MESSAGE_ID_GETVIDEODECODERCAPS_ZEROWIDTHHEIGHT + GetvideodecodercapsZerowidthheight = 3146088, + /// + /// D3D11_MESSAGE_ID_CHECKVIDEODECODERDOWNSAMPLING_NULLPARAM + CheckvideodecoderdownsamplingNullparam = 3146089, + /// + /// D3D11_MESSAGE_ID_CHECKVIDEODECODERDOWNSAMPLING_INVALIDCOLORSPACE + CheckvideodecoderdownsamplingInvalidcolorspace = 3146090, + /// + /// D3D11_MESSAGE_ID_CHECKVIDEODECODERDOWNSAMPLING_ZEROWIDTHHEIGHT + CheckvideodecoderdownsamplingZerowidthheight = 3146091, + /// + /// D3D11_MESSAGE_ID_VIDEODECODERENABLEDOWNSAMPLING_NULLPARAM + VideodecoderenabledownsamplingNullparam = 3146092, + /// + /// D3D11_MESSAGE_ID_VIDEODECODERENABLEDOWNSAMPLING_UNSUPPORTED + VideodecoderenabledownsamplingUnsupported = 3146093, + /// + /// D3D11_MESSAGE_ID_VIDEODECODERUPDATEDOWNSAMPLING_NULLPARAM + VideodecoderupdatedownsamplingNullparam = 3146094, + /// + /// D3D11_MESSAGE_ID_VIDEODECODERUPDATEDOWNSAMPLING_UNSUPPORTED + VideodecoderupdatedownsamplingUnsupported = 3146095, + /// + /// D3D11_MESSAGE_ID_CHECKVIDEOPROCESSORFORMATCONVERSION_NULLPARAM + CheckvideoprocessorformatconversionNullparam = 3146096, + /// + /// D3D11_MESSAGE_ID_VIDEOPROCESSORSETOUTPUTCOLORSPACE1_NULLPARAM + Videoprocessorsetoutputcolorspace1Nullparam = 3146097, + /// + /// D3D11_MESSAGE_ID_VIDEOPROCESSORGETOUTPUTCOLORSPACE1_NULLPARAM + Videoprocessorgetoutputcolorspace1Nullparam = 3146098, + /// + /// D3D11_MESSAGE_ID_VIDEOPROCESSORSETSTREAMCOLORSPACE1_NULLPARAM + Videoprocessorsetstreamcolorspace1Nullparam = 3146099, + /// + /// D3D11_MESSAGE_ID_VIDEOPROCESSORSETSTREAMCOLORSPACE1_INVALIDSTREAM + Videoprocessorsetstreamcolorspace1Invalidstream = 3146100, + /// + /// D3D11_MESSAGE_ID_VIDEOPROCESSORSETSTREAMMIRROR_NULLPARAM + VideoprocessorsetstreammirrorNullparam = 3146101, + /// + /// D3D11_MESSAGE_ID_VIDEOPROCESSORSETSTREAMMIRROR_INVALIDSTREAM + VideoprocessorsetstreammirrorInvalidstream = 3146102, + /// + /// D3D11_MESSAGE_ID_VIDEOPROCESSORSETSTREAMMIRROR_UNSUPPORTED + VideoprocessorsetstreammirrorUnsupported = 3146103, + /// + /// D3D11_MESSAGE_ID_VIDEOPROCESSORGETSTREAMCOLORSPACE1_NULLPARAM + Videoprocessorgetstreamcolorspace1Nullparam = 3146104, + /// + /// D3D11_MESSAGE_ID_VIDEOPROCESSORGETSTREAMMIRROR_NULLPARAM + VideoprocessorgetstreammirrorNullparam = 3146105, + /// + /// D3D11_MESSAGE_ID_RECOMMENDVIDEODECODERDOWNSAMPLING_NULLPARAM + RecommendvideodecoderdownsamplingNullparam = 3146106, + /// + /// D3D11_MESSAGE_ID_RECOMMENDVIDEODECODERDOWNSAMPLING_INVALIDCOLORSPACE + RecommendvideodecoderdownsamplingInvalidcolorspace = 3146107, + /// + /// D3D11_MESSAGE_ID_RECOMMENDVIDEODECODERDOWNSAMPLING_ZEROWIDTHHEIGHT + RecommendvideodecoderdownsamplingZerowidthheight = 3146108, + /// + /// D3D11_MESSAGE_ID_VIDEOPROCESSORSETOUTPUTSHADERUSAGE_NULLPARAM + VideoprocessorsetoutputshaderusageNullparam = 3146109, + /// + /// D3D11_MESSAGE_ID_VIDEOPROCESSORGETOUTPUTSHADERUSAGE_NULLPARAM + VideoprocessorgetoutputshaderusageNullparam = 3146110, + /// + /// D3D11_MESSAGE_ID_VIDEOPROCESSORGETBEHAVIORHINTS_NULLPARAM + VideoprocessorgetbehaviorhintsNullparam = 3146111, + /// + /// D3D11_MESSAGE_ID_VIDEOPROCESSORGETBEHAVIORHINTS_INVALIDSTREAMCOUNT + VideoprocessorgetbehaviorhintsInvalidstreamcount = 3146112, + /// + /// D3D11_MESSAGE_ID_VIDEOPROCESSORGETBEHAVIORHINTS_TARGETRECT + VideoprocessorgetbehaviorhintsTargetrect = 3146113, + /// + /// D3D11_MESSAGE_ID_VIDEOPROCESSORGETBEHAVIORHINTS_INVALIDSOURCERECT + VideoprocessorgetbehaviorhintsInvalidsourcerect = 3146114, + /// + /// D3D11_MESSAGE_ID_VIDEOPROCESSORGETBEHAVIORHINTS_INVALIDDESTRECT + VideoprocessorgetbehaviorhintsInvaliddestrect = 3146115, + /// + /// D3D11_MESSAGE_ID_GETCRYPTOSESSIONPRIVATEDATASIZE_INVALID_KEY_EXCHANGE_TYPE + GetcryptosessionprivatedatasizeInvalidKeyExchangeType = 3146116, + /// + /// D3D11_MESSAGE_ID_CREATEBUFFER_INVALIDUSAGE + CreatebufferInvalidusage = 3146119, + /// + /// D3D11_MESSAGE_ID_CREATETEXTURE1D_INVALIDUSAGE + Createtexture1dInvalidusage = 3146120, + /// + /// D3D11_MESSAGE_ID_CREATETEXTURE2D_INVALIDUSAGE + Createtexture2dInvalidusage = 3146121, + /// + /// D3D11_MESSAGE_ID_CREATEINPUTLAYOUT_LEVEL9_STEPRATE_NOT_1 + CreateinputlayoutLevel9SteprateNot1 = 3146122, + /// + /// D3D11_MESSAGE_ID_CREATEINPUTLAYOUT_LEVEL9_INSTANCING_NOT_SUPPORTED + CreateinputlayoutLevel9InstancingNotSupported = 3146123, + /// + /// D3D11_MESSAGE_ID_UPDATETILEMAPPINGS_INVALID_PARAMETER + UpdatetilemappingsInvalidParameter = 3146124, + /// + /// D3D11_MESSAGE_ID_COPYTILEMAPPINGS_INVALID_PARAMETER + CopytilemappingsInvalidParameter = 3146125, + /// + /// D3D11_MESSAGE_ID_COPYTILES_INVALID_PARAMETER + CopytilesInvalidParameter = 3146126, + /// + /// D3D11_MESSAGE_ID_UPDATETILES_INVALID_PARAMETER + UpdatetilesInvalidParameter = 3146127, + /// + /// D3D11_MESSAGE_ID_RESIZETILEPOOL_INVALID_PARAMETER + ResizetilepoolInvalidParameter = 3146128, + /// + /// D3D11_MESSAGE_ID_TILEDRESOURCEBARRIER_INVALID_PARAMETER + TiledresourcebarrierInvalidParameter = 3146129, + /// + /// D3D11_MESSAGE_ID_NULL_TILE_MAPPING_ACCESS_WARNING + NullTileMappingAccessWarning = 3146130, + /// + /// D3D11_MESSAGE_ID_NULL_TILE_MAPPING_ACCESS_ERROR + NullTileMappingAccessError = 3146131, + /// + /// D3D11_MESSAGE_ID_DIRTY_TILE_MAPPING_ACCESS + DirtyTileMappingAccess = 3146132, + /// + /// D3D11_MESSAGE_ID_DUPLICATE_TILE_MAPPINGS_IN_COVERED_AREA + DuplicateTileMappingsInCoveredArea = 3146133, + /// + /// D3D11_MESSAGE_ID_TILE_MAPPINGS_IN_COVERED_AREA_DUPLICATED_OUTSIDE + TileMappingsInCoveredAreaDuplicatedOutside = 3146134, + /// + /// D3D11_MESSAGE_ID_TILE_MAPPINGS_SHARED_BETWEEN_INCOMPATIBLE_RESOURCES + TileMappingsSharedBetweenIncompatibleResources = 3146135, + /// + /// D3D11_MESSAGE_ID_TILE_MAPPINGS_SHARED_BETWEEN_INPUT_AND_OUTPUT + TileMappingsSharedBetweenInputAndOutput = 3146136, + /// + /// D3D11_MESSAGE_ID_CHECKMULTISAMPLEQUALITYLEVELS_INVALIDFLAGS + CheckmultisamplequalitylevelsInvalidflags = 3146137, + /// + /// D3D11_MESSAGE_ID_GETRESOURCETILING_NONTILED_RESOURCE + GetresourcetilingNontiledResource = 3146138, + /// + /// D3D11_MESSAGE_ID_RESIZETILEPOOL_SHRINK_WITH_MAPPINGS_STILL_DEFINED_PAST_END + ResizetilepoolShrinkWithMappingsStillDefinedPastEnd = 3146139, + /// + /// D3D11_MESSAGE_ID_NEED_TO_CALL_TILEDRESOURCEBARRIER + NeedToCallTiledresourcebarrier = 3146140, + /// + /// D3D11_MESSAGE_ID_CREATEDEVICE_INVALIDARGS + CreatedeviceInvalidargs = 3146141, + /// + /// D3D11_MESSAGE_ID_CREATEDEVICE_WARNING + CreatedeviceWarning = 3146142, + /// + /// D3D11_MESSAGE_ID_CLEARUNORDEREDACCESSVIEWUINT_HAZARD + ClearunorderedaccessviewuintHazard = 3146143, + /// + /// D3D11_MESSAGE_ID_CLEARUNORDEREDACCESSVIEWFLOAT_HAZARD + ClearunorderedaccessviewfloatHazard = 3146144, + /// + /// D3D11_MESSAGE_ID_TILED_RESOURCE_TIER_1_BUFFER_TEXTURE_MISMATCH + TiledResourceTier1BufferTextureMismatch = 3146145, + /// + /// D3D11_MESSAGE_ID_CREATE_CRYPTOSESSION + CreateCryptosession = 3146146, + /// + /// D3D11_MESSAGE_ID_CREATE_AUTHENTICATEDCHANNEL + CreateAuthenticatedchannel = 3146147, + /// + /// D3D11_MESSAGE_ID_LIVE_CRYPTOSESSION + LiveCryptosession = 3146148, + /// + /// D3D11_MESSAGE_ID_LIVE_AUTHENTICATEDCHANNEL + LiveAuthenticatedchannel = 3146149, + /// + /// D3D11_MESSAGE_ID_DESTROY_CRYPTOSESSION + DestroyCryptosession = 3146150, + /// + /// D3D11_MESSAGE_ID_DESTROY_AUTHENTICATEDCHANNEL + DestroyAuthenticatedchannel = 3146151, + /// + /// D3D11_MESSAGE_ID_CREATERASTERIZERSTATE_INVALID_CONSERVATIVERASTERMODE + CreaterasterizerstateInvalidConservativerastermode = 3146154, + /// + /// D3D11_MESSAGE_ID_DEVICE_DRAW_INVALID_SYSTEMVALUE + DeviceDrawInvalidSystemvalue = 3146155, + /// + /// D3D11_MESSAGE_ID_CREATEQUERYORPREDICATE_INVALIDCONTEXTTYPE + CreatequeryorpredicateInvalidcontexttype = 3146156, + /// + /// D3D11_MESSAGE_ID_CREATEQUERYORPREDICATE_DECODENOTSUPPORTED + CreatequeryorpredicateDecodenotsupported = 3146157, + /// + /// D3D11_MESSAGE_ID_CREATEQUERYORPREDICATE_ENCODENOTSUPPORTED + CreatequeryorpredicateEncodenotsupported = 3146158, + /// + /// D3D11_MESSAGE_ID_CREATESHADERRESOURCEVIEW_INVALIDPLANEINDEX + CreateshaderresourceviewInvalidplaneindex = 3146159, + /// + /// D3D11_MESSAGE_ID_CREATESHADERRESOURCEVIEW_INVALIDVIDEOPLANEINDEX + CreateshaderresourceviewInvalidvideoplaneindex = 3146160, + /// + /// D3D11_MESSAGE_ID_CREATESHADERRESOURCEVIEW_AMBIGUOUSVIDEOPLANEINDEX + CreateshaderresourceviewAmbiguousvideoplaneindex = 3146161, + /// + /// D3D11_MESSAGE_ID_CREATERENDERTARGETVIEW_INVALIDPLANEINDEX + CreaterendertargetviewInvalidplaneindex = 3146162, + /// + /// D3D11_MESSAGE_ID_CREATERENDERTARGETVIEW_INVALIDVIDEOPLANEINDEX + CreaterendertargetviewInvalidvideoplaneindex = 3146163, + /// + /// D3D11_MESSAGE_ID_CREATERENDERTARGETVIEW_AMBIGUOUSVIDEOPLANEINDEX + CreaterendertargetviewAmbiguousvideoplaneindex = 3146164, + /// + /// D3D11_MESSAGE_ID_CREATEUNORDEREDACCESSVIEW_INVALIDPLANEINDEX + CreateunorderedaccessviewInvalidplaneindex = 3146165, + /// + /// D3D11_MESSAGE_ID_CREATEUNORDEREDACCESSVIEW_INVALIDVIDEOPLANEINDEX + CreateunorderedaccessviewInvalidvideoplaneindex = 3146166, + /// + /// D3D11_MESSAGE_ID_CREATEUNORDEREDACCESSVIEW_AMBIGUOUSVIDEOPLANEINDEX + CreateunorderedaccessviewAmbiguousvideoplaneindex = 3146167, + /// + /// D3D11_MESSAGE_ID_JPEGDECODE_INVALIDSCANDATAOFFSET + JpegdecodeInvalidscandataoffset = 3146168, + /// + /// D3D11_MESSAGE_ID_JPEGDECODE_NOTSUPPORTED + JpegdecodeNotsupported = 3146169, + /// + /// D3D11_MESSAGE_ID_JPEGDECODE_DIMENSIONSTOOLARGE + JpegdecodeDimensionstoolarge = 3146170, + /// + /// D3D11_MESSAGE_ID_JPEGDECODE_INVALIDCOMPONENTS + JpegdecodeInvalidcomponents = 3146171, + /// + /// D3D11_MESSAGE_ID_JPEGDECODE_DESTINATIONNOT2D + JpegdecodeDestinationnot2d = 3146172, + /// + /// D3D11_MESSAGE_ID_JPEGDECODE_TILEDRESOURCESUNSUPPORTED + JpegdecodeTiledresourcesunsupported = 3146173, + /// + /// D3D11_MESSAGE_ID_JPEGDECODE_GUARDRECTSUNSUPPORTED + JpegdecodeGuardrectsunsupported = 3146174, + /// + /// D3D11_MESSAGE_ID_JPEGDECODE_FORMATUNSUPPORTED + JpegdecodeFormatunsupported = 3146175, + /// + /// D3D11_MESSAGE_ID_JPEGDECODE_INVALIDSUBRESOURCE + JpegdecodeInvalidsubresource = 3146176, + /// + /// D3D11_MESSAGE_ID_JPEGDECODE_INVALIDMIPLEVEL + JpegdecodeInvalidmiplevel = 3146177, + /// + /// D3D11_MESSAGE_ID_JPEGDECODE_EMPTYDESTBOX + JpegdecodeEmptydestbox = 3146178, + /// + /// D3D11_MESSAGE_ID_JPEGDECODE_DESTBOXNOT2D + JpegdecodeDestboxnot2d = 3146179, + /// + /// D3D11_MESSAGE_ID_JPEGDECODE_DESTBOXNOTSUB + JpegdecodeDestboxnotsub = 3146180, + /// + /// D3D11_MESSAGE_ID_JPEGDECODE_DESTBOXESINTERSECT + JpegdecodeDestboxesintersect = 3146181, + /// + /// D3D11_MESSAGE_ID_JPEGDECODE_XSUBSAMPLEMISMATCH + JpegdecodeXsubsamplemismatch = 3146182, + /// + /// D3D11_MESSAGE_ID_JPEGDECODE_YSUBSAMPLEMISMATCH + JpegdecodeYsubsamplemismatch = 3146183, + /// + /// D3D11_MESSAGE_ID_JPEGDECODE_XSUBSAMPLEODD + JpegdecodeXsubsampleodd = 3146184, + /// + /// D3D11_MESSAGE_ID_JPEGDECODE_YSUBSAMPLEODD + JpegdecodeYsubsampleodd = 3146185, + /// + /// D3D11_MESSAGE_ID_JPEGDECODE_OUTPUTDIMENSIONSTOOLARGE + JpegdecodeOutputdimensionstoolarge = 3146186, + /// + /// D3D11_MESSAGE_ID_JPEGDECODE_NONPOW2SCALEUNSUPPORTED + JpegdecodeNonpow2scaleunsupported = 3146187, + /// + /// D3D11_MESSAGE_ID_JPEGDECODE_FRACTIONALDOWNSCALETOLARGE + JpegdecodeFractionaldownscaletolarge = 3146188, + /// + /// D3D11_MESSAGE_ID_JPEGDECODE_CHROMASIZEMISMATCH + JpegdecodeChromasizemismatch = 3146189, + /// + /// D3D11_MESSAGE_ID_JPEGDECODE_LUMACHROMASIZEMISMATCH + JpegdecodeLumachromasizemismatch = 3146190, + /// + /// D3D11_MESSAGE_ID_JPEGDECODE_INVALIDNUMDESTINATIONS + JpegdecodeInvalidnumdestinations = 3146191, + /// + /// D3D11_MESSAGE_ID_JPEGDECODE_SUBBOXUNSUPPORTED + JpegdecodeSubboxunsupported = 3146192, + /// + /// D3D11_MESSAGE_ID_JPEGDECODE_1DESTUNSUPPORTEDFORMAT + Jpegdecode1destunsupportedformat = 3146193, + /// + /// D3D11_MESSAGE_ID_JPEGDECODE_3DESTUNSUPPORTEDFORMAT + Jpegdecode3destunsupportedformat = 3146194, + /// + /// D3D11_MESSAGE_ID_JPEGDECODE_SCALEUNSUPPORTED + JpegdecodeScaleunsupported = 3146195, + /// + /// D3D11_MESSAGE_ID_JPEGDECODE_INVALIDSOURCESIZE + JpegdecodeInvalidsourcesize = 3146196, + /// + /// D3D11_MESSAGE_ID_JPEGDECODE_INVALIDCOPYFLAGS + JpegdecodeInvalidcopyflags = 3146197, + /// + /// D3D11_MESSAGE_ID_JPEGDECODE_HAZARD + JpegdecodeHazard = 3146198, + /// + /// D3D11_MESSAGE_ID_JPEGDECODE_UNSUPPORTEDSRCBUFFERUSAGE + JpegdecodeUnsupportedsrcbufferusage = 3146199, + /// + /// D3D11_MESSAGE_ID_JPEGDECODE_UNSUPPORTEDSRCBUFFERMISCFLAGS + JpegdecodeUnsupportedsrcbuffermiscflags = 3146200, + /// + /// D3D11_MESSAGE_ID_JPEGDECODE_UNSUPPORTEDDSTTEXTUREUSAGE + JpegdecodeUnsupporteddsttextureusage = 3146201, + /// + /// D3D11_MESSAGE_ID_JPEGDECODE_BACKBUFFERNOTSUPPORTED + JpegdecodeBackbuffernotsupported = 3146202, + /// + /// D3D11_MESSAGE_ID_JPEGDECODE_UNSUPPRTEDCOPYFLAGS + JpegdecodeUnsupprtedcopyflags = 3146203, + /// + /// D3D11_MESSAGE_ID_JPEGENCODE_NOTSUPPORTED + JpegencodeNotsupported = 3146204, + /// + /// D3D11_MESSAGE_ID_JPEGENCODE_INVALIDSCANDATAOFFSET + JpegencodeInvalidscandataoffset = 3146205, + /// + /// D3D11_MESSAGE_ID_JPEGENCODE_INVALIDCOMPONENTS + JpegencodeInvalidcomponents = 3146206, + /// + /// D3D11_MESSAGE_ID_JPEGENCODE_SOURCENOT2D + JpegencodeSourcenot2d = 3146207, + /// + /// D3D11_MESSAGE_ID_JPEGENCODE_TILEDRESOURCESUNSUPPORTED + JpegencodeTiledresourcesunsupported = 3146208, + /// + /// D3D11_MESSAGE_ID_JPEGENCODE_GUARDRECTSUNSUPPORTED + JpegencodeGuardrectsunsupported = 3146209, + /// + /// D3D11_MESSAGE_ID_JPEGENCODE_XSUBSAMPLEMISMATCH + JpegencodeXsubsamplemismatch = 3146210, + /// + /// D3D11_MESSAGE_ID_JPEGENCODE_YSUBSAMPLEMISMATCH + JpegencodeYsubsamplemismatch = 3146211, + /// + /// D3D11_MESSAGE_ID_JPEGENCODE_FORMATUNSUPPORTED + JpegencodeFormatunsupported = 3146212, + /// + /// D3D11_MESSAGE_ID_JPEGENCODE_INVALIDSUBRESOURCE + JpegencodeInvalidsubresource = 3146213, + /// + /// D3D11_MESSAGE_ID_JPEGENCODE_INVALIDMIPLEVEL + JpegencodeInvalidmiplevel = 3146214, + /// + /// D3D11_MESSAGE_ID_JPEGENCODE_DIMENSIONSTOOLARGE + JpegencodeDimensionstoolarge = 3146215, + /// + /// D3D11_MESSAGE_ID_JPEGENCODE_HAZARD + JpegencodeHazard = 3146216, + /// + /// D3D11_MESSAGE_ID_JPEGENCODE_UNSUPPORTEDDSTBUFFERUSAGE + JpegencodeUnsupporteddstbufferusage = 3146217, + /// + /// D3D11_MESSAGE_ID_JPEGENCODE_UNSUPPORTEDDSTBUFFERMISCFLAGS + JpegencodeUnsupporteddstbuffermiscflags = 3146218, + /// + /// D3D11_MESSAGE_ID_JPEGENCODE_UNSUPPORTEDSRCTEXTUREUSAGE + JpegencodeUnsupportedsrctextureusage = 3146219, + /// + /// D3D11_MESSAGE_ID_JPEGENCODE_BACKBUFFERNOTSUPPORTED + JpegencodeBackbuffernotsupported = 3146220, + /// + /// D3D11_MESSAGE_ID_CREATEQUERYORPREDICATE_UNSUPPORTEDCONTEXTTTYPEFORQUERY + CreatequeryorpredicateUnsupportedcontextttypeforquery = 3146221, + /// + /// D3D11_MESSAGE_ID_FLUSH1_INVALIDCONTEXTTYPE + Flush1Invalidcontexttype = 3146222, + /// + /// D3D11_MESSAGE_ID_DEVICE_SETHARDWAREPROTECTION_INVALIDCONTEXT + DeviceSethardwareprotectionInvalidcontext = 3146223, + /// + /// D3D11_MESSAGE_ID_VIDEOPROCESSORSETOUTPUTHDRMETADATA_NULLPARAM + VideoprocessorsetoutputhdrmetadataNullparam = 3146224, + /// + /// D3D11_MESSAGE_ID_VIDEOPROCESSORSETOUTPUTHDRMETADATA_INVALIDSIZE + VideoprocessorsetoutputhdrmetadataInvalidsize = 3146225, + /// + /// D3D11_MESSAGE_ID_VIDEOPROCESSORGETOUTPUTHDRMETADATA_NULLPARAM + VideoprocessorgetoutputhdrmetadataNullparam = 3146226, + /// + /// D3D11_MESSAGE_ID_VIDEOPROCESSORGETOUTPUTHDRMETADATA_INVALIDSIZE + VideoprocessorgetoutputhdrmetadataInvalidsize = 3146227, + /// + /// D3D11_MESSAGE_ID_VIDEOPROCESSORSETSTREAMHDRMETADATA_NULLPARAM + VideoprocessorsetstreamhdrmetadataNullparam = 3146228, + /// + /// D3D11_MESSAGE_ID_VIDEOPROCESSORSETSTREAMHDRMETADATA_INVALIDSTREAM + VideoprocessorsetstreamhdrmetadataInvalidstream = 3146229, + /// + /// D3D11_MESSAGE_ID_VIDEOPROCESSORSETSTREAMHDRMETADATA_INVALIDSIZE + VideoprocessorsetstreamhdrmetadataInvalidsize = 3146230, + /// + /// D3D11_MESSAGE_ID_VIDEOPROCESSORGETSTREAMHDRMETADATA_NULLPARAM + VideoprocessorgetstreamhdrmetadataNullparam = 3146231, + /// + /// D3D11_MESSAGE_ID_VIDEOPROCESSORGETSTREAMHDRMETADATA_INVALIDSTREAM + VideoprocessorgetstreamhdrmetadataInvalidstream = 3146232, + /// + /// D3D11_MESSAGE_ID_VIDEOPROCESSORGETSTREAMHDRMETADATA_INVALIDSIZE + VideoprocessorgetstreamhdrmetadataInvalidsize = 3146233, + /// + /// D3D11_MESSAGE_ID_VIDEOPROCESSORGETSTREAMFRAMEFORMAT_INVALIDSTREAM + VideoprocessorgetstreamframeformatInvalidstream = 3146234, + /// + /// D3D11_MESSAGE_ID_VIDEOPROCESSORGETSTREAMCOLORSPACE_INVALIDSTREAM + VideoprocessorgetstreamcolorspaceInvalidstream = 3146235, + /// + /// D3D11_MESSAGE_ID_VIDEOPROCESSORGETSTREAMOUTPUTRATE_INVALIDSTREAM + VideoprocessorgetstreamoutputrateInvalidstream = 3146236, + /// + /// D3D11_MESSAGE_ID_VIDEOPROCESSORGETSTREAMSOURCERECT_INVALIDSTREAM + VideoprocessorgetstreamsourcerectInvalidstream = 3146237, + /// + /// D3D11_MESSAGE_ID_VIDEOPROCESSORGETSTREAMDESTRECT_INVALIDSTREAM + VideoprocessorgetstreamdestrectInvalidstream = 3146238, + /// + /// D3D11_MESSAGE_ID_VIDEOPROCESSORGETSTREAMALPHA_INVALIDSTREAM + VideoprocessorgetstreamalphaInvalidstream = 3146239, + /// + /// D3D11_MESSAGE_ID_VIDEOPROCESSORGETSTREAMPALETTE_INVALIDSTREAM + VideoprocessorgetstreampaletteInvalidstream = 3146240, + /// + /// D3D11_MESSAGE_ID_VIDEOPROCESSORGETSTREAMPIXELASPECTRATIO_INVALIDSTREAM + VideoprocessorgetstreampixelaspectratioInvalidstream = 3146241, + /// + /// D3D11_MESSAGE_ID_VIDEOPROCESSORGETSTREAMLUMAKEY_INVALIDSTREAM + VideoprocessorgetstreamlumakeyInvalidstream = 3146242, + /// + /// D3D11_MESSAGE_ID_VIDEOPROCESSORGETSTREAMSTEREOFORMAT_INVALIDSTREAM + VideoprocessorgetstreamstereoformatInvalidstream = 3146243, + /// + /// D3D11_MESSAGE_ID_VIDEOPROCESSORGETSTREAMAUTOPROCESSINGMODE_INVALIDSTREAM + VideoprocessorgetstreamautoprocessingmodeInvalidstream = 3146244, + /// + /// D3D11_MESSAGE_ID_VIDEOPROCESSORGETSTREAMFILTER_INVALIDSTREAM + VideoprocessorgetstreamfilterInvalidstream = 3146245, + /// + /// D3D11_MESSAGE_ID_VIDEOPROCESSORGETSTREAMROTATION_INVALIDSTREAM + VideoprocessorgetstreamrotationInvalidstream = 3146246, + /// + /// D3D11_MESSAGE_ID_VIDEOPROCESSORGETSTREAMCOLORSPACE1_INVALIDSTREAM + Videoprocessorgetstreamcolorspace1Invalidstream = 3146247, + /// + /// D3D11_MESSAGE_ID_VIDEOPROCESSORGETSTREAMMIRROR_INVALIDSTREAM + VideoprocessorgetstreammirrorInvalidstream = 3146248, + /// + /// D3D11_MESSAGE_ID_CREATE_FENCE + CreateFence = 3146249, + /// + /// D3D11_MESSAGE_ID_LIVE_FENCE + LiveFence = 3146250, + /// + /// D3D11_MESSAGE_ID_DESTROY_FENCE + DestroyFence = 3146251, + /// + /// D3D11_MESSAGE_ID_CREATE_SYNCHRONIZEDCHANNEL + CreateSynchronizedchannel = 3146252, + /// + /// D3D11_MESSAGE_ID_LIVE_SYNCHRONIZEDCHANNEL + LiveSynchronizedchannel = 3146253, + /// + /// D3D11_MESSAGE_ID_DESTROY_SYNCHRONIZEDCHANNEL + DestroySynchronizedchannel = 3146254, + /// + /// D3D11_MESSAGE_ID_CREATEFENCE_INVALIDFLAGS + CreatefenceInvalidflags = 3146255, + /// + /// D3D11_MESSAGE_ID_NEGOTIATECRYPTOSESSIONKEYEXCHANGEMT_INVALIDKEYEXCHANGETYPE + NegotiatecryptosessionkeyexchangemtInvalidkeyexchangetype = 3146258, + /// + /// D3D11_MESSAGE_ID_NEGOTIATECRYPTOSESSIONKEYEXCHANGEMT_NOT_SUPPORTED + NegotiatecryptosessionkeyexchangemtNotSupported = 3146259, + /// + /// D3D11_MESSAGE_ID_DECODERBEGINFRAME_INVALID_HISTOGRAM_COMPONENT_COUNT + DecoderbeginframeInvalidHistogramComponentCount = 3146260, + /// + /// D3D11_MESSAGE_ID_DECODERBEGINFRAME_INVALID_HISTOGRAM_COMPONENT + DecoderbeginframeInvalidHistogramComponent = 3146261, + /// + /// D3D11_MESSAGE_ID_DECODERBEGINFRAME_INVALID_HISTOGRAM_BUFFER_SIZE + DecoderbeginframeInvalidHistogramBufferSize = 3146262, + /// + /// D3D11_MESSAGE_ID_DECODERBEGINFRAME_INVALID_HISTOGRAM_BUFFER_USAGE + DecoderbeginframeInvalidHistogramBufferUsage = 3146263, + /// + /// D3D11_MESSAGE_ID_DECODERBEGINFRAME_INVALID_HISTOGRAM_BUFFER_MISC_FLAGS + DecoderbeginframeInvalidHistogramBufferMiscFlags = 3146264, + /// + /// D3D11_MESSAGE_ID_DECODERBEGINFRAME_INVALID_HISTOGRAM_BUFFER_OFFSET + DecoderbeginframeInvalidHistogramBufferOffset = 3146265, + /// + /// D3D11_MESSAGE_ID_CREATE_TRACKEDWORKLOAD + CreateTrackedworkload = 3146266, + /// + /// D3D11_MESSAGE_ID_LIVE_TRACKEDWORKLOAD + LiveTrackedworkload = 3146267, + /// + /// D3D11_MESSAGE_ID_DESTROY_TRACKEDWORKLOAD + DestroyTrackedworkload = 3146268, + /// + /// D3D11_MESSAGE_ID_CREATE_TRACKED_WORKLOAD_NULLPARAM + CreateTrackedWorkloadNullparam = 3146269, + /// + /// D3D11_MESSAGE_ID_CREATE_TRACKED_WORKLOAD_INVALID_MAX_INSTANCES + CreateTrackedWorkloadInvalidMaxInstances = 3146270, + /// + /// D3D11_MESSAGE_ID_CREATE_TRACKED_WORKLOAD_INVALID_DEADLINE_TYPE + CreateTrackedWorkloadInvalidDeadlineType = 3146271, + /// + /// D3D11_MESSAGE_ID_CREATE_TRACKED_WORKLOAD_INVALID_ENGINE_TYPE + CreateTrackedWorkloadInvalidEngineType = 3146272, + /// + /// D3D11_MESSAGE_ID_MULTIPLE_TRACKED_WORKLOADS + MultipleTrackedWorkloads = 3146273, + /// + /// D3D11_MESSAGE_ID_MULTIPLE_TRACKED_WORKLOAD_PAIRS + MultipleTrackedWorkloadPairs = 3146274, + /// + /// D3D11_MESSAGE_ID_INCOMPLETE_TRACKED_WORKLOAD_PAIR + IncompleteTrackedWorkloadPair = 3146275, + /// + /// D3D11_MESSAGE_ID_OUT_OF_ORDER_TRACKED_WORKLOAD_PAIR + OutOfOrderTrackedWorkloadPair = 3146276, + /// + /// D3D11_MESSAGE_ID_CANNOT_ADD_TRACKED_WORKLOAD + CannotAddTrackedWorkload = 3146277, + /// + /// D3D11_MESSAGE_ID_TRACKED_WORKLOAD_NOT_SUPPORTED + TrackedWorkloadNotSupported = 3146278, + /// + /// D3D11_MESSAGE_ID_TRACKED_WORKLOAD_ENGINE_TYPE_NOT_FOUND + TrackedWorkloadEngineTypeNotFound = 3146279, + /// + /// D3D11_MESSAGE_ID_NO_TRACKED_WORKLOAD_SLOT_AVAILABLE + NoTrackedWorkloadSlotAvailable = 3146280, + /// + /// D3D11_MESSAGE_ID_END_TRACKED_WORKLOAD_INVALID_ARG + EndTrackedWorkloadInvalidArg = 3146281, + /// + /// D3D11_MESSAGE_ID_TRACKED_WORKLOAD_DISJOINT_FAILURE + TrackedWorkloadDisjointFailure = 3146282, +} + +/// +/// D3D11_COPY_FLAGS +[Flags] +public enum CopyFlags : int +{ + None = 0, + /// + /// D3D11_COPY_NO_OVERWRITE + D3D11_COPY_NO_OVERWRITE = 1, + /// + /// D3D11_COPY_DISCARD + D3D11_COPY_DISCARD = 2, +} + +/// +/// D3D11_LOGIC_OP +public enum LogicOp : int +{ + /// + /// D3D11_LOGIC_OP_CLEAR + Clear = 0, + /// + /// D3D11_LOGIC_OP_SET + Set = 1, + /// + /// D3D11_LOGIC_OP_COPY + Copy = 2, + /// + /// D3D11_LOGIC_OP_COPY_INVERTED + CopyInverted = 3, + /// + /// D3D11_LOGIC_OP_NOOP + Noop = 4, + /// + /// D3D11_LOGIC_OP_INVERT + Invert = 5, + /// + /// D3D11_LOGIC_OP_AND + And = 6, + /// + /// D3D11_LOGIC_OP_NAND + Nand = 7, + /// + /// D3D11_LOGIC_OP_OR + Or = 8, + /// + /// D3D11_LOGIC_OP_NOR + Nor = 9, + /// + /// D3D11_LOGIC_OP_XOR + Xor = 10, + /// + /// D3D11_LOGIC_OP_EQUIV + Equiv = 11, + /// + /// D3D11_LOGIC_OP_AND_REVERSE + AndReverse = 12, + /// + /// D3D11_LOGIC_OP_AND_INVERTED + AndInverted = 13, + /// + /// D3D11_LOGIC_OP_OR_REVERSE + OrReverse = 14, + /// + /// D3D11_LOGIC_OP_OR_INVERTED + OrInverted = 15, +} + +/// +/// D3D11_1_CREATE_DEVICE_CONTEXT_STATE_FLAG +[Flags] +public enum _1CreateDeviceContextStateFlag : int +{ + None = 0, + /// + /// D3D11_1_CREATE_DEVICE_CONTEXT_STATE_SINGLETHREADED + D3D11_1_CREATE_DEVICE_CONTEXT_STATE_SINGLETHREADED = 1, +} + +/// +/// D3D11_VIDEO_DECODER_CAPS +public enum VideoDecoderCaps : int +{ + /// + /// D3D11_VIDEO_DECODER_CAPS_DOWNSAMPLE + Downsample = 1, + /// + /// D3D11_VIDEO_DECODER_CAPS_NON_REAL_TIME + NonRealTime = 2, + /// + /// D3D11_VIDEO_DECODER_CAPS_DOWNSAMPLE_DYNAMIC + DownsampleDynamic = 4, + /// + /// D3D11_VIDEO_DECODER_CAPS_DOWNSAMPLE_REQUIRED + DownsampleRequired = 8, + /// + /// D3D11_VIDEO_DECODER_CAPS_UNSUPPORTED + Unsupported = 16, +} + +/// +/// D3D11_VIDEO_PROCESSOR_BEHAVIOR_HINTS +public enum VideoProcessorBehaviorHints : int +{ + /// + /// D3D11_VIDEO_PROCESSOR_BEHAVIOR_HINT_MULTIPLANE_OVERLAY_ROTATION + D3D11_VIDEO_PROCESSOR_BEHAVIOR_HINT_MULTIPLANE_OVERLAY_ROTATION = 1, + /// + /// D3D11_VIDEO_PROCESSOR_BEHAVIOR_HINT_MULTIPLANE_OVERLAY_RESIZE + D3D11_VIDEO_PROCESSOR_BEHAVIOR_HINT_MULTIPLANE_OVERLAY_RESIZE = 2, + /// + /// D3D11_VIDEO_PROCESSOR_BEHAVIOR_HINT_MULTIPLANE_OVERLAY_COLOR_SPACE_CONVERSION + D3D11_VIDEO_PROCESSOR_BEHAVIOR_HINT_MULTIPLANE_OVERLAY_COLOR_SPACE_CONVERSION = 4, + /// + /// D3D11_VIDEO_PROCESSOR_BEHAVIOR_HINT_TRIPLE_BUFFER_OUTPUT + D3D11_VIDEO_PROCESSOR_BEHAVIOR_HINT_TRIPLE_BUFFER_OUTPUT = 8, +} + +/// +/// D3D11_CRYPTO_SESSION_STATUS +public enum CryptoSessionStatus : int +{ + /// + /// D3D11_CRYPTO_SESSION_STATUS_OK + Ok = 0, + /// + /// D3D11_CRYPTO_SESSION_STATUS_KEY_LOST + KeyLost = 1, + /// + /// D3D11_CRYPTO_SESSION_STATUS_KEY_AND_CONTENT_LOST + KeyAndContentLost = 2, +} + +/// +/// D3D11_TILE_MAPPING_FLAG +[Flags] +public enum TileMappingFlag : int +{ + None = 0, + /// + /// D3D11_TILE_MAPPING_NO_OVERWRITE + D3D11_TILE_MAPPING_NO_OVERWRITE = 1, +} + +/// +/// D3D11_TILE_RANGE_FLAG +[Flags] +public enum TileRangeFlag : int +{ + None = 0, + /// + /// D3D11_TILE_RANGE_NULL + D3D11_TILE_RANGE_NULL = 1, + /// + /// D3D11_TILE_RANGE_SKIP + D3D11_TILE_RANGE_SKIP = 2, + /// + /// D3D11_TILE_RANGE_REUSE_SINGLE_TILE + D3D11_TILE_RANGE_REUSE_SINGLE_TILE = 4, +} + +/// +/// D3D11_CHECK_MULTISAMPLE_QUALITY_LEVELS_FLAG +[Flags] +public enum CheckMultisampleQualityLevelsFlag : int +{ + None = 0, + /// + /// D3D11_CHECK_MULTISAMPLE_QUALITY_LEVELS_TILED_RESOURCE + D3D11_CHECK_MULTISAMPLE_QUALITY_LEVELS_TILED_RESOURCE = 1, +} + +/// +/// D3D11_TILE_COPY_FLAG +[Flags] +public enum TileCopyFlag : int +{ + None = 0, + /// + /// D3D11_TILE_COPY_NO_OVERWRITE + D3D11_TILE_COPY_NO_OVERWRITE = 1, + /// + /// D3D11_TILE_COPY_LINEAR_BUFFER_TO_SWIZZLED_TILED_RESOURCE + D3D11_TILE_COPY_LINEAR_BUFFER_TO_SWIZZLED_TILED_RESOURCE = 2, + /// + /// D3D11_TILE_COPY_SWIZZLED_TILED_RESOURCE_TO_LINEAR_BUFFER + D3D11_TILE_COPY_SWIZZLED_TILED_RESOURCE_TO_LINEAR_BUFFER = 4, +} + +/// +/// D3D11_CONTEXT_TYPE +public enum ContextType : int +{ + /// + /// D3D11_CONTEXT_TYPE_ALL + All = 0, + /// + /// D3D11_CONTEXT_TYPE_3D + _3d = 1, + /// + /// D3D11_CONTEXT_TYPE_COMPUTE + Compute = 2, + /// + /// D3D11_CONTEXT_TYPE_COPY + Copy = 3, + /// + /// D3D11_CONTEXT_TYPE_VIDEO + Video = 4, +} + +/// +/// D3D11_TEXTURE_LAYOUT +public enum TextureLayout : int +{ + /// + /// D3D11_TEXTURE_LAYOUT_UNDEFINED + Undefined = 0, + /// + /// D3D11_TEXTURE_LAYOUT_ROW_MAJOR + RowMajor = 1, + /// + /// D3D11_TEXTURE_LAYOUT_64K_STANDARD_SWIZZLE + _64kStandardSwizzle = 2, +} + +/// +/// D3D11_CONSERVATIVE_RASTERIZATION_MODE +public enum ConservativeRasterizationMode : int +{ + /// + /// D3D11_CONSERVATIVE_RASTERIZATION_MODE_OFF + Off = 0, + /// + /// D3D11_CONSERVATIVE_RASTERIZATION_MODE_ON + On = 1, +} + +/// +/// D3D11_FENCE_FLAG +[Flags] +public enum FenceFlag : uint +{ + /// + /// D3D11_FENCE_FLAG_NONE + None = 0, + /// + /// D3D11_FENCE_FLAG_SHARED + Shared = 2, + /// + /// D3D11_FENCE_FLAG_SHARED_CROSS_ADAPTER + SharedCrossAdapter = 4, + /// + /// D3D11_FENCE_FLAG_NON_MONITORED + NonMonitored = 8, +} + +/// +/// D3D11_FEATURE_VIDEO +public enum FeatureVideo : int +{ + /// + /// D3D11_FEATURE_VIDEO_DECODER_HISTOGRAM + DecoderHistogram = 0, +} + +/// +/// D3D11_VIDEO_DECODER_HISTOGRAM_COMPONENT +public enum VideoDecoderHistogramComponent : int +{ + /// + /// D3D11_VIDEO_DECODER_HISTOGRAM_COMPONENT_Y + Y = 0, + /// + /// D3D11_VIDEO_DECODER_HISTOGRAM_COMPONENT_U + U = 1, + /// + /// D3D11_VIDEO_DECODER_HISTOGRAM_COMPONENT_V + V = 2, + /// + /// D3D11_VIDEO_DECODER_HISTOGRAM_COMPONENT_R + R = 0, + /// + /// D3D11_VIDEO_DECODER_HISTOGRAM_COMPONENT_G + G = 1, + /// + /// D3D11_VIDEO_DECODER_HISTOGRAM_COMPONENT_B + B = 2, + /// + /// D3D11_VIDEO_DECODER_HISTOGRAM_COMPONENT_A + A = 3, +} + +/// +/// D3D11_VIDEO_DECODER_HISTOGRAM_COMPONENT_FLAGS +[Flags] +public enum VideoDecoderHistogramComponentFlags : uint +{ + None = 0, + /// + /// D3D11_VIDEO_DECODER_HISTOGRAM_COMPONENT_FLAG_NONE + D3D11_VIDEO_DECODER_HISTOGRAM_COMPONENT_FLAG_NONE = 0, + /// + /// D3D11_VIDEO_DECODER_HISTOGRAM_COMPONENT_FLAG_Y + D3D11_VIDEO_DECODER_HISTOGRAM_COMPONENT_FLAG_Y = 1, + /// + /// D3D11_VIDEO_DECODER_HISTOGRAM_COMPONENT_FLAG_U + D3D11_VIDEO_DECODER_HISTOGRAM_COMPONENT_FLAG_U = 2, + /// + /// D3D11_VIDEO_DECODER_HISTOGRAM_COMPONENT_FLAG_V + D3D11_VIDEO_DECODER_HISTOGRAM_COMPONENT_FLAG_V = 4, + /// + /// D3D11_VIDEO_DECODER_HISTOGRAM_COMPONENT_FLAG_R + D3D11_VIDEO_DECODER_HISTOGRAM_COMPONENT_FLAG_R = 1, + /// + /// D3D11_VIDEO_DECODER_HISTOGRAM_COMPONENT_FLAG_G + D3D11_VIDEO_DECODER_HISTOGRAM_COMPONENT_FLAG_G = 2, + /// + /// D3D11_VIDEO_DECODER_HISTOGRAM_COMPONENT_FLAG_B + D3D11_VIDEO_DECODER_HISTOGRAM_COMPONENT_FLAG_B = 4, + /// + /// D3D11_VIDEO_DECODER_HISTOGRAM_COMPONENT_FLAG_A + D3D11_VIDEO_DECODER_HISTOGRAM_COMPONENT_FLAG_A = 8, +} + +/// +/// D3D11_CRYPTO_SESSION_KEY_EXCHANGE_FLAGS +[Flags] +public enum CryptoSessionKeyExchangeFlags : uint +{ + None = 0, + /// + /// D3D11_CRYPTO_SESSION_KEY_EXCHANGE_FLAG_NONE + D3D11_CRYPTO_SESSION_KEY_EXCHANGE_FLAG_NONE = 0, +} + +/// +/// D3D11_SHADER_VERSION_TYPE +public enum ShaderVersionType : int +{ + /// + /// D3D11_SHVER_PIXEL_SHADER + D3D11_SHVER_PIXEL_SHADER = 0, + /// + /// D3D11_SHVER_VERTEX_SHADER + D3D11_SHVER_VERTEX_SHADER = 1, + /// + /// D3D11_SHVER_GEOMETRY_SHADER + D3D11_SHVER_GEOMETRY_SHADER = 2, + /// + /// D3D11_SHVER_HULL_SHADER + D3D11_SHVER_HULL_SHADER = 3, + /// + /// D3D11_SHVER_DOMAIN_SHADER + D3D11_SHVER_DOMAIN_SHADER = 4, + /// + /// D3D11_SHVER_COMPUTE_SHADER + D3D11_SHVER_COMPUTE_SHADER = 5, + /// + /// D3D11_SHVER_RESERVED0 + D3D11_SHVER_RESERVED0 = 65520, +} + +/// +/// D3D11_SHADER_TYPE +public enum ShaderType : int +{ + /// + /// D3D11_VERTEX_SHADER + D3D11_VERTEX_SHADER = 1, + /// + /// D3D11_HULL_SHADER + D3D11_HULL_SHADER = 2, + /// + /// D3D11_DOMAIN_SHADER + D3D11_DOMAIN_SHADER = 3, + /// + /// D3D11_GEOMETRY_SHADER + D3D11_GEOMETRY_SHADER = 4, + /// + /// D3D11_PIXEL_SHADER + D3D11_PIXEL_SHADER = 5, + /// + /// D3D11_COMPUTE_SHADER + D3D11_COMPUTE_SHADER = 6, +} + +/// +/// D3D11_TRACE_GS_INPUT_PRIMITIVE +public enum TraceGsInputPrimitive : int +{ + /// + /// D3D11_TRACE_GS_INPUT_PRIMITIVE_UNDEFINED + Undefined = 0, + /// + /// D3D11_TRACE_GS_INPUT_PRIMITIVE_POINT + Point = 1, + /// + /// D3D11_TRACE_GS_INPUT_PRIMITIVE_LINE + Line = 2, + /// + /// D3D11_TRACE_GS_INPUT_PRIMITIVE_TRIANGLE + Triangle = 3, + /// + /// D3D11_TRACE_GS_INPUT_PRIMITIVE_LINE_ADJ + LineAdj = 6, + /// + /// D3D11_TRACE_GS_INPUT_PRIMITIVE_TRIANGLE_ADJ + TriangleAdj = 7, +} + +/// +/// D3D11_TRACE_REGISTER_TYPE +public enum TraceRegisterType : int +{ + /// + /// D3D11_TRACE_OUTPUT_NULL_REGISTER + D3D11_TRACE_OUTPUT_NULL_REGISTER = 0, + /// + /// D3D11_TRACE_INPUT_REGISTER + D3D11_TRACE_INPUT_REGISTER = 1, + /// + /// D3D11_TRACE_INPUT_PRIMITIVE_ID_REGISTER + D3D11_TRACE_INPUT_PRIMITIVE_ID_REGISTER = 2, + /// + /// D3D11_TRACE_IMMEDIATE_CONSTANT_BUFFER + D3D11_TRACE_IMMEDIATE_CONSTANT_BUFFER = 3, + /// + /// D3D11_TRACE_TEMP_REGISTER + D3D11_TRACE_TEMP_REGISTER = 4, + /// + /// D3D11_TRACE_INDEXABLE_TEMP_REGISTER + D3D11_TRACE_INDEXABLE_TEMP_REGISTER = 5, + /// + /// D3D11_TRACE_OUTPUT_REGISTER + D3D11_TRACE_OUTPUT_REGISTER = 6, + /// + /// D3D11_TRACE_OUTPUT_DEPTH_REGISTER + D3D11_TRACE_OUTPUT_DEPTH_REGISTER = 7, + /// + /// D3D11_TRACE_CONSTANT_BUFFER + D3D11_TRACE_CONSTANT_BUFFER = 8, + /// + /// D3D11_TRACE_IMMEDIATE32 + D3D11_TRACE_IMMEDIATE32 = 9, + /// + /// D3D11_TRACE_SAMPLER + D3D11_TRACE_SAMPLER = 10, + /// + /// D3D11_TRACE_RESOURCE + D3D11_TRACE_RESOURCE = 11, + /// + /// D3D11_TRACE_RASTERIZER + D3D11_TRACE_RASTERIZER = 12, + /// + /// D3D11_TRACE_OUTPUT_COVERAGE_MASK + D3D11_TRACE_OUTPUT_COVERAGE_MASK = 13, + /// + /// D3D11_TRACE_STREAM + D3D11_TRACE_STREAM = 14, + /// + /// D3D11_TRACE_THIS_POINTER + D3D11_TRACE_THIS_POINTER = 15, + /// + /// D3D11_TRACE_OUTPUT_CONTROL_POINT_ID_REGISTER + D3D11_TRACE_OUTPUT_CONTROL_POINT_ID_REGISTER = 16, + /// + /// D3D11_TRACE_INPUT_FORK_INSTANCE_ID_REGISTER + D3D11_TRACE_INPUT_FORK_INSTANCE_ID_REGISTER = 17, + /// + /// D3D11_TRACE_INPUT_JOIN_INSTANCE_ID_REGISTER + D3D11_TRACE_INPUT_JOIN_INSTANCE_ID_REGISTER = 18, + /// + /// D3D11_TRACE_INPUT_CONTROL_POINT_REGISTER + D3D11_TRACE_INPUT_CONTROL_POINT_REGISTER = 19, + /// + /// D3D11_TRACE_OUTPUT_CONTROL_POINT_REGISTER + D3D11_TRACE_OUTPUT_CONTROL_POINT_REGISTER = 20, + /// + /// D3D11_TRACE_INPUT_PATCH_CONSTANT_REGISTER + D3D11_TRACE_INPUT_PATCH_CONSTANT_REGISTER = 21, + /// + /// D3D11_TRACE_INPUT_DOMAIN_POINT_REGISTER + D3D11_TRACE_INPUT_DOMAIN_POINT_REGISTER = 22, + /// + /// D3D11_TRACE_UNORDERED_ACCESS_VIEW + D3D11_TRACE_UNORDERED_ACCESS_VIEW = 23, + /// + /// D3D11_TRACE_THREAD_GROUP_SHARED_MEMORY + D3D11_TRACE_THREAD_GROUP_SHARED_MEMORY = 24, + /// + /// D3D11_TRACE_INPUT_THREAD_ID_REGISTER + D3D11_TRACE_INPUT_THREAD_ID_REGISTER = 25, + /// + /// D3D11_TRACE_INPUT_THREAD_GROUP_ID_REGISTER + D3D11_TRACE_INPUT_THREAD_GROUP_ID_REGISTER = 26, + /// + /// D3D11_TRACE_INPUT_THREAD_ID_IN_GROUP_REGISTER + D3D11_TRACE_INPUT_THREAD_ID_IN_GROUP_REGISTER = 27, + /// + /// D3D11_TRACE_INPUT_COVERAGE_MASK_REGISTER + D3D11_TRACE_INPUT_COVERAGE_MASK_REGISTER = 28, + /// + /// D3D11_TRACE_INPUT_THREAD_ID_IN_GROUP_FLATTENED_REGISTER + D3D11_TRACE_INPUT_THREAD_ID_IN_GROUP_FLATTENED_REGISTER = 29, + /// + /// D3D11_TRACE_INPUT_GS_INSTANCE_ID_REGISTER + D3D11_TRACE_INPUT_GS_INSTANCE_ID_REGISTER = 30, + /// + /// D3D11_TRACE_OUTPUT_DEPTH_GREATER_EQUAL_REGISTER + D3D11_TRACE_OUTPUT_DEPTH_GREATER_EQUAL_REGISTER = 31, + /// + /// D3D11_TRACE_OUTPUT_DEPTH_LESS_EQUAL_REGISTER + D3D11_TRACE_OUTPUT_DEPTH_LESS_EQUAL_REGISTER = 32, + /// + /// D3D11_TRACE_IMMEDIATE64 + D3D11_TRACE_IMMEDIATE64 = 33, + /// + /// D3D11_TRACE_INPUT_CYCLE_COUNTER_REGISTER + D3D11_TRACE_INPUT_CYCLE_COUNTER_REGISTER = 34, + /// + /// D3D11_TRACE_INTERFACE_POINTER + D3D11_TRACE_INTERFACE_POINTER = 35, +} + +/// +/// D3DX11_SCAN_DATA_TYPE +public enum D3dx11ScanDataType : int +{ + /// + /// D3DX11_SCAN_DATA_TYPE_FLOAT + Float = 1, + /// + /// D3DX11_SCAN_DATA_TYPE_INT + Int = 2, + /// + /// D3DX11_SCAN_DATA_TYPE_UINT + Uint = 3, +} + +/// +/// D3DX11_SCAN_OPCODE +public enum D3dx11ScanOpcode : int +{ + /// + /// D3DX11_SCAN_OPCODE_ADD + Add = 1, + /// + /// D3DX11_SCAN_OPCODE_MIN + Min = 2, + /// + /// D3DX11_SCAN_OPCODE_MAX + Max = 3, + /// + /// D3DX11_SCAN_OPCODE_MUL + Mul = 4, + /// + /// D3DX11_SCAN_OPCODE_AND + And = 5, + /// + /// D3DX11_SCAN_OPCODE_OR + Or = 6, + /// + /// D3DX11_SCAN_OPCODE_XOR + Xor = 7, +} + +/// +/// D3DX11_SCAN_DIRECTION +public enum D3dx11ScanDirection : int +{ + /// + /// D3DX11_SCAN_DIRECTION_FORWARD + Forward = 1, + /// + /// D3DX11_SCAN_DIRECTION_BACKWARD + Backward = 2, +} + +/// +/// D3DX11_FFT_DATA_TYPE +public enum D3dx11FftDataType : int +{ + /// + /// D3DX11_FFT_DATA_TYPE_REAL + Real = 0, + /// + /// D3DX11_FFT_DATA_TYPE_COMPLEX + Complex = 1, +} + +/// +/// D3DX11_FFT_DIM_MASK +public enum D3dx11FftDimMask : int +{ + /// + /// D3DX11_FFT_DIM_MASK_1D + _1d = 1, + /// + /// D3DX11_FFT_DIM_MASK_2D + _2d = 3, + /// + /// D3DX11_FFT_DIM_MASK_3D + _3d = 7, +} + +/// +/// D3DX11_FFT_CREATE_FLAG +[Flags] +public enum D3dx11FftCreateFlag : int +{ + None = 0, + /// + /// D3DX11_FFT_CREATE_FLAG_NO_PRECOMPUTE_BUFFERS + NoPrecomputeBuffers = 1, +} + +#endregion Enums + +#region Generated Enums +#endregion Generated Enums + +#region Structs +/// +/// D3D11_INPUT_ELEMENT_DESC +public partial struct InputElementDescription +{ + /// + public unsafe byte* SemanticName; + + /// + public uint SemanticIndex; + + /// + public Graphics.Dxgi.Common.Format Format; + + /// + public uint InputSlot; + + /// + public uint AlignedByteOffset; + + /// + public InputClassification InputSlotClass; + + /// + public uint InstanceDataStepRate; +} + +/// +/// D3D11_SO_DECLARATION_ENTRY +public partial struct SoDeclarationEntry +{ + /// + public uint Stream; + + /// + public unsafe byte* SemanticName; + + /// + public uint SemanticIndex; + + /// + public byte StartComponent; + + /// + public byte ComponentCount; + + /// + public byte OutputSlot; +} + +/// +/// D3D11_VIEWPORT +public partial struct Viewport +{ + /// + public float TopLeftX; + + /// + public float TopLeftY; + + /// + public float Width; + + /// + public float Height; + + /// + public float MinDepth; + + /// + public float MaxDepth; +} + +/// +/// D3D11_DRAW_INSTANCED_INDIRECT_ARGS +public partial struct DrawInstancedIndirectArgs +{ + /// + public uint VertexCountPerInstance; + + /// + public uint InstanceCount; + + /// + public uint StartVertexLocation; + + /// + public uint StartInstanceLocation; +} + +/// +/// D3D11_DRAW_INDEXED_INSTANCED_INDIRECT_ARGS +public partial struct DrawIndexedInstancedIndirectArgs +{ + /// + public uint IndexCountPerInstance; + + /// + public uint InstanceCount; + + /// + public uint StartIndexLocation; + + /// + public int BaseVertexLocation; + + /// + public uint StartInstanceLocation; +} + +/// +/// D3D11_BOX +public partial struct Box +{ + /// + public uint left; + + /// + public uint top; + + /// + public uint front; + + /// + public uint right; + + /// + public uint bottom; + + /// + public uint back; +} + +/// +/// D3D11_DEPTH_STENCILOP_DESC +public partial struct DepthStencilopDescription +{ + /// + public StencilOp StencilFailOp; + + /// + public StencilOp StencilDepthFailOp; + + /// + public StencilOp StencilPassOp; + + /// + public ComparisonFunc StencilFunc; +} + +/// +/// D3D11_DEPTH_STENCIL_DESC +public partial struct DepthStencilDescription +{ + /// + public Bool32 DepthEnable; + + /// + public DepthWriteMask DepthWriteMask; + + /// + public ComparisonFunc DepthFunc; + + /// + public Bool32 StencilEnable; + + /// + public byte StencilReadMask; + + /// + public byte StencilWriteMask; + + /// + public DepthStencilopDescription FrontFace; + + /// + public DepthStencilopDescription BackFace; +} + +/// +/// D3D11_RENDER_TARGET_BLEND_DESC +public partial struct RenderTargetBlendDescription +{ + /// + public Bool32 BlendEnable; + + /// + public Blend SrcBlend; + + /// + public Blend DestBlend; + + /// + public BlendOp BlendOp; + + /// + public Blend SrcBlendAlpha; + + /// + public Blend DestBlendAlpha; + + /// + public BlendOp BlendOpAlpha; + + /// + public byte RenderTargetWriteMask; +} + +/// +/// D3D11_BLEND_DESC +public partial struct BlendDescription +{ + /// + public Bool32 AlphaToCoverageEnable; + + /// + public Bool32 IndependentBlendEnable; + + /// + public RenderTarget__FixedBuffer RenderTarget; + + public unsafe struct RenderTarget__FixedBuffer + { + public RenderTargetBlendDescription e0; + public RenderTargetBlendDescription e1; + public RenderTargetBlendDescription e2; + public RenderTargetBlendDescription e3; + public RenderTargetBlendDescription e4; + public RenderTargetBlendDescription e5; + public RenderTargetBlendDescription e6; + public RenderTargetBlendDescription e7; + + [UnscopedRef] + public ref RenderTargetBlendDescription this[int index] + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + return ref AsSpan()[index]; + } + } + + [UnscopedRef] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public Span AsSpan() + { + return MemoryMarshal.CreateSpan(ref e0, 8); + } + } +} + +/// +/// D3D11_RASTERIZER_DESC +public partial struct RasterizerDescription +{ + /// + public FillMode FillMode; + + /// + public CullMode CullMode; + + /// + public Bool32 FrontCounterClockwise; + + /// + public int DepthBias; + + /// + public float DepthBiasClamp; + + /// + public float SlopeScaledDepthBias; + + /// + public Bool32 DepthClipEnable; + + /// + public Bool32 ScissorEnable; + + /// + public Bool32 MultisampleEnable; + + /// + public Bool32 AntialiasedLineEnable; +} + +/// +/// D3D11_SUBRESOURCE_DATA +public partial struct SubresourceData +{ + /// + public unsafe void* pSysMem; + + /// + public uint SysMemPitch; + + /// + public uint SysMemSlicePitch; +} + +/// +/// D3D11_MAPPED_SUBRESOURCE +public partial struct MappedSubresource +{ + /// + public unsafe void* pData; + + /// + public uint RowPitch; + + /// + public uint DepthPitch; +} + +/// +/// D3D11_BUFFER_DESC +public partial struct BufferDescription +{ + /// + public uint ByteWidth; + + /// + public Usage Usage; + + /// + public uint BindFlags; + + /// + public uint CPUAccessFlags; + + /// + public uint MiscFlags; + + /// + public uint StructureByteStride; +} + +/// +/// D3D11_TEXTURE1D_DESC +public partial struct Texture1DDescription +{ + /// + public uint Width; + + /// + public uint MipLevels; + + /// + public uint ArraySize; + + /// + public Graphics.Dxgi.Common.Format Format; + + /// + public Usage Usage; + + /// + public uint BindFlags; + + /// + public uint CPUAccessFlags; + + /// + public uint MiscFlags; +} + +/// +/// D3D11_TEXTURE2D_DESC +public partial struct Texture2DDescription +{ + /// + public uint Width; + + /// + public uint Height; + + /// + public uint MipLevels; + + /// + public uint ArraySize; + + /// + public Graphics.Dxgi.Common.Format Format; + + /// + public Graphics.Dxgi.Common.SampleDescription SampleDesc; + + /// + public Usage Usage; + + /// + public BindFlag BindFlags; + + /// + public CpuAccessFlag CPUAccessFlags; + + /// + public ResourceMiscFlag MiscFlags; +} + +/// +/// D3D11_TEXTURE3D_DESC +public partial struct Texture3DDescription +{ + /// + public uint Width; + + /// + public uint Height; + + /// + public uint Depth; + + /// + public uint MipLevels; + + /// + public Graphics.Dxgi.Common.Format Format; + + /// + public Usage Usage; + + /// + public uint BindFlags; + + /// + public uint CPUAccessFlags; + + /// + public uint MiscFlags; +} + +/// +/// D3D11_BUFFER_SRV +public partial struct BufferSrv +{ + /// + public _Anonymous1_e__Union Anonymous1; + + /// + public _Anonymous2_e__Union Anonymous2; + + public partial struct _Anonymous1_e__Union + { + /// + public uint FirstElement; + + /// + public uint ElementOffset; + } + + public partial struct _Anonymous2_e__Union + { + /// + public uint NumElements; + + /// + public uint ElementWidth; + } + +} + +/// +/// D3D11_BUFFEREX_SRV +public partial struct BufferExtendedSrv +{ + /// + public uint FirstElement; + + /// + public uint NumElements; + + /// + public uint Flags; +} + +/// +/// D3D11_TEX1D_SRV +public partial struct Tex1dSrv +{ + /// + public uint MostDetailedMip; + + /// + public uint MipLevels; +} + +/// +/// D3D11_TEX1D_ARRAY_SRV +public partial struct Tex1dArraySrv +{ + /// + public uint MostDetailedMip; + + /// + public uint MipLevels; + + /// + public uint FirstArraySlice; + + /// + public uint ArraySize; +} + +/// +/// D3D11_TEX2D_SRV +public partial struct Tex2dSrv +{ + /// + public uint MostDetailedMip; + + /// + public uint MipLevels; +} + +/// +/// D3D11_TEX2D_ARRAY_SRV +public partial struct Tex2dArraySrv +{ + /// + public uint MostDetailedMip; + + /// + public uint MipLevels; + + /// + public uint FirstArraySlice; + + /// + public uint ArraySize; +} + +/// +/// D3D11_TEX3D_SRV +public partial struct Tex3dSrv +{ + /// + public uint MostDetailedMip; + + /// + public uint MipLevels; +} + +/// +/// D3D11_TEXCUBE_SRV +public partial struct TexcubeSrv +{ + /// + public uint MostDetailedMip; + + /// + public uint MipLevels; +} + +/// +/// D3D11_TEXCUBE_ARRAY_SRV +public partial struct TexcubeArraySrv +{ + /// + public uint MostDetailedMip; + + /// + public uint MipLevels; + + /// + public uint First2DArrayFace; + + /// + public uint NumCubes; +} + +/// +/// D3D11_TEX2DMS_SRV +public partial struct Tex2dmsSrv +{ + /// + public uint UnusedField_NothingToDefine; +} + +/// +/// D3D11_TEX2DMS_ARRAY_SRV +public partial struct Tex2dmsArraySrv +{ + /// + public uint FirstArraySlice; + + /// + public uint ArraySize; +} + +/// +/// D3D11_SHADER_RESOURCE_VIEW_DESC +public partial struct ShaderResourceViewDescription +{ + /// + public Graphics.Dxgi.Common.Format Format; + + /// + public Graphics.Direct3D.SrvDimension ViewDimension; + + /// + public _Anonymous_e__Union Anonymous; + + public partial struct _Anonymous_e__Union + { + /// + public BufferSrv Buffer; + + /// + public Tex1dSrv Texture1D; + + /// + public Tex1dArraySrv Texture1DArray; + + /// + public Tex2dSrv Texture2D; + + /// + public Tex2dArraySrv Texture2DArray; + + /// + public Tex2dmsSrv Texture2DMS; + + /// + public Tex2dmsArraySrv Texture2DMSArray; + + /// + public Tex3dSrv Texture3D; + + /// + public TexcubeSrv TextureCube; + + /// + public TexcubeArraySrv TextureCubeArray; + + /// + public BufferExtendedSrv BufferEx; + } + +} + +/// +/// D3D11_BUFFER_RTV +public partial struct BufferRtv +{ + /// + public _Anonymous1_e__Union Anonymous1; + + /// + public _Anonymous2_e__Union Anonymous2; + + public partial struct _Anonymous2_e__Union + { + /// + public uint NumElements; + + /// + public uint ElementWidth; + } + + public partial struct _Anonymous1_e__Union + { + /// + public uint FirstElement; + + /// + public uint ElementOffset; + } + +} + +/// +/// D3D11_TEX1D_RTV +public partial struct Tex1dRtv +{ + /// + public uint MipSlice; +} + +/// +/// D3D11_TEX1D_ARRAY_RTV +public partial struct Tex1dArrayRtv +{ + /// + public uint MipSlice; + + /// + public uint FirstArraySlice; + + /// + public uint ArraySize; +} + +/// +/// D3D11_TEX2D_RTV +public partial struct Tex2dRtv +{ + /// + public uint MipSlice; +} + +/// +/// D3D11_TEX2DMS_RTV +public partial struct Tex2dmsRtv +{ + /// + public uint UnusedField_NothingToDefine; +} + +/// +/// D3D11_TEX2D_ARRAY_RTV +public partial struct Tex2dArrayRtv +{ + /// + public uint MipSlice; + + /// + public uint FirstArraySlice; + + /// + public uint ArraySize; +} + +/// +/// D3D11_TEX2DMS_ARRAY_RTV +public partial struct Tex2dmsArrayRtv +{ + /// + public uint FirstArraySlice; + + /// + public uint ArraySize; +} + +/// +/// D3D11_TEX3D_RTV +public partial struct Tex3dRtv +{ + /// + public uint MipSlice; + + /// + public uint FirstWSlice; + + /// + public uint WSize; +} + +/// +/// D3D11_RENDER_TARGET_VIEW_DESC +public partial struct RenderTargetViewDescription +{ + /// + public Graphics.Dxgi.Common.Format Format; + + /// + public RtvDimension ViewDimension; + + /// + public _Anonymous_e__Union Anonymous; + + public partial struct _Anonymous_e__Union + { + /// + public BufferRtv Buffer; + + /// + public Tex1dRtv Texture1D; + + /// + public Tex1dArrayRtv Texture1DArray; + + /// + public Tex2dRtv Texture2D; + + /// + public Tex2dArrayRtv Texture2DArray; + + /// + public Tex2dmsRtv Texture2DMS; + + /// + public Tex2dmsArrayRtv Texture2DMSArray; + + /// + public Tex3dRtv Texture3D; + } + +} + +/// +/// D3D11_TEX1D_DSV +public partial struct Tex1dDsv +{ + /// + public uint MipSlice; +} + +/// +/// D3D11_TEX1D_ARRAY_DSV +public partial struct Tex1dArrayDsv +{ + /// + public uint MipSlice; + + /// + public uint FirstArraySlice; + + /// + public uint ArraySize; +} + +/// +/// D3D11_TEX2D_DSV +public partial struct Tex2dDsv +{ + /// + public uint MipSlice; +} + +/// +/// D3D11_TEX2D_ARRAY_DSV +public partial struct Tex2dArrayDsv +{ + /// + public uint MipSlice; + + /// + public uint FirstArraySlice; + + /// + public uint ArraySize; +} + +/// +/// D3D11_TEX2DMS_DSV +public partial struct Tex2dmsDsv +{ + /// + public uint UnusedField_NothingToDefine; +} + +/// +/// D3D11_TEX2DMS_ARRAY_DSV +public partial struct Tex2dmsArrayDsv +{ + /// + public uint FirstArraySlice; + + /// + public uint ArraySize; +} + +/// +/// D3D11_DEPTH_STENCIL_VIEW_DESC +public partial struct DepthStencilViewDescription +{ + /// + public Graphics.Dxgi.Common.Format Format; + + /// + public DsvDimension ViewDimension; + + /// + public uint Flags; + + /// + public _Anonymous_e__Union Anonymous; + + public partial struct _Anonymous_e__Union + { + /// + public Tex1dDsv Texture1D; + + /// + public Tex1dArrayDsv Texture1DArray; + + /// + public Tex2dDsv Texture2D; + + /// + public Tex2dArrayDsv Texture2DArray; + + /// + public Tex2dmsDsv Texture2DMS; + + /// + public Tex2dmsArrayDsv Texture2DMSArray; + } + +} + +/// +/// D3D11_BUFFER_UAV +public partial struct BufferUav +{ + /// + public uint FirstElement; + + /// + public uint NumElements; + + /// + public uint Flags; +} + +/// +/// D3D11_TEX1D_UAV +public partial struct Tex1dUav +{ + /// + public uint MipSlice; +} + +/// +/// D3D11_TEX1D_ARRAY_UAV +public partial struct Tex1dArrayUav +{ + /// + public uint MipSlice; + + /// + public uint FirstArraySlice; + + /// + public uint ArraySize; +} + +/// +/// D3D11_TEX2D_UAV +public partial struct Tex2dUav +{ + /// + public uint MipSlice; +} + +/// +/// D3D11_TEX2D_ARRAY_UAV +public partial struct Tex2dArrayUav +{ + /// + public uint MipSlice; + + /// + public uint FirstArraySlice; + + /// + public uint ArraySize; +} + +/// +/// D3D11_TEX3D_UAV +public partial struct Tex3dUav +{ + /// + public uint MipSlice; + + /// + public uint FirstWSlice; + + /// + public uint WSize; +} + +/// +/// D3D11_UNORDERED_ACCESS_VIEW_DESC +public partial struct UnorderedAccessViewDescription +{ + /// + public Graphics.Dxgi.Common.Format Format; + + /// + public UavDimension ViewDimension; + + /// + public _Anonymous_e__Union Anonymous; + + public partial struct _Anonymous_e__Union + { + /// + public BufferUav Buffer; + + /// + public Tex1dUav Texture1D; + + /// + public Tex1dArrayUav Texture1DArray; + + /// + public Tex2dUav Texture2D; + + /// + public Tex2dArrayUav Texture2DArray; + + /// + public Tex3dUav Texture3D; + } + +} + +/// +/// D3D11_SAMPLER_DESC +public partial struct SamplerDescription +{ + /// + public Filter Filter; + + /// + public TextureAddressMode AddressU; + + /// + public TextureAddressMode AddressV; + + /// + public TextureAddressMode AddressW; + + /// + public float MipLODBias; + + /// + public uint MaxAnisotropy; + + /// + public ComparisonFunc ComparisonFunc; + + /// + public unsafe fixed float BorderColor[4]; + + /// + public float MinLOD; + + /// + public float MaxLOD; +} + +/// +/// D3D11_QUERY_DESC +public partial struct QueryDescription +{ + /// + public Query Query; + + /// + public uint MiscFlags; +} + +/// +/// D3D11_QUERY_DATA_TIMESTAMP_DISJOINT +public partial struct QueryDataTimestampDisjoint +{ + /// + public ulong Frequency; + + /// + public Bool32 Disjoint; +} + +/// +/// D3D11_QUERY_DATA_PIPELINE_STATISTICS +public partial struct QueryDataPipelineStatistics +{ + /// + public ulong IAVertices; + + /// + public ulong IAPrimitives; + + /// + public ulong VSInvocations; + + /// + public ulong GSInvocations; + + /// + public ulong GSPrimitives; + + /// + public ulong CInvocations; + + /// + public ulong CPrimitives; + + /// + public ulong PSInvocations; + + /// + public ulong HSInvocations; + + /// + public ulong DSInvocations; + + /// + public ulong CSInvocations; +} + +/// +/// D3D11_QUERY_DATA_SO_STATISTICS +public partial struct QueryDataSoStatistics +{ + /// + public ulong NumPrimitivesWritten; + + /// + public ulong PrimitivesStorageNeeded; +} + +/// +/// D3D11_COUNTER_DESC +public partial struct CounterDescription +{ + /// + public Counter Counter; + + /// + public uint MiscFlags; +} + +/// +/// D3D11_COUNTER_INFO +public partial struct CounterInfo +{ + /// + public Counter LastDeviceDependentCounter; + + /// + public uint NumSimultaneousCounters; + + /// + public byte NumDetectableParallelUnits; +} + +/// +/// D3D11_CLASS_INSTANCE_DESC +public partial struct ClassInstanceDescription +{ + /// + public uint InstanceId; + + /// + public uint InstanceIndex; + + /// + public uint TypeId; + + /// + public uint ConstantBuffer; + + /// + public uint BaseConstantBufferOffset; + + /// + public uint BaseTexture; + + /// + public uint BaseSampler; + + /// + public Bool32 Created; +} + +/// +/// D3D11_FEATURE_DATA_THREADING +public partial struct FeatureDataThreading +{ + /// + public Bool32 DriverConcurrentCreates; + + /// + public Bool32 DriverCommandLists; +} + +/// +/// D3D11_FEATURE_DATA_DOUBLES +public partial struct FeatureDataDoubles +{ + /// + public Bool32 DoublePrecisionFloatShaderOps; +} + +/// +/// D3D11_FEATURE_DATA_FORMAT_SUPPORT +public partial struct FeatureDataFormatSupport +{ + /// + public Graphics.Dxgi.Common.Format InFormat; + + /// + public uint OutFormatSupport; +} + +/// +/// D3D11_FEATURE_DATA_FORMAT_SUPPORT2 +public partial struct FeatureDataFormatSupport2 +{ + /// + public Graphics.Dxgi.Common.Format InFormat; + + /// + public uint OutFormatSupport2; +} + +/// +/// D3D11_FEATURE_DATA_D3D10_X_HARDWARE_OPTIONS +public partial struct FeatureDataXHardwareOptions +{ + /// + public Bool32 ComputeShaders_Plus_RawAndStructuredBuffers_Via_Shader_4_x; +} + +/// +/// D3D11_FEATURE_DATA_D3D11_OPTIONS +public partial struct FeatureDataOptions +{ + /// + public Bool32 OutputMergerLogicOp; + + /// + public Bool32 UAVOnlyRenderingForcedSampleCount; + + /// + public Bool32 DiscardAPIsSeenByDriver; + + /// + public Bool32 FlagsForUpdateAndCopySeenByDriver; + + /// + public Bool32 ClearView; + + /// + public Bool32 CopyWithOverlap; + + /// + public Bool32 ConstantBufferPartialUpdate; + + /// + public Bool32 ConstantBufferOffsetting; + + /// + public Bool32 MapNoOverwriteOnDynamicConstantBuffer; + + /// + public Bool32 MapNoOverwriteOnDynamicBufferSRV; + + /// + public Bool32 MultisampleRTVWithForcedSampleCountOne; + + /// + public Bool32 SAD4ShaderInstructions; + + /// + public Bool32 ExtendedDoublesShaderInstructions; + + /// + public Bool32 ExtendedResourceSharing; +} + +/// +/// D3D11_FEATURE_DATA_ARCHITECTURE_INFO +public partial struct FeatureDataArchitectureInfo +{ + /// + public Bool32 TileBasedDeferredRenderer; +} + +/// +/// D3D11_FEATURE_DATA_D3D9_OPTIONS +public partial struct FeatureDataD3d9Options +{ + /// + public Bool32 FullNonPow2TextureSupport; +} + +/// +/// D3D11_FEATURE_DATA_D3D9_SHADOW_SUPPORT +public partial struct FeatureDataD3d9ShadowSupport +{ + /// + public Bool32 SupportsDepthAsTextureWithLessEqualComparisonFilter; +} + +/// +/// D3D11_FEATURE_DATA_SHADER_MIN_PRECISION_SUPPORT +public partial struct FeatureDataShaderMinPrecisionSupport +{ + /// + public uint PixelShaderMinPrecision; + + /// + public uint AllOtherShaderStagesMinPrecision; +} + +/// +/// D3D11_FEATURE_DATA_D3D11_OPTIONS1 +public partial struct FeatureDataOptions1 +{ + /// + public TiledResourcesTier TiledResourcesTier; + + /// + public Bool32 MinMaxFiltering; + + /// + public Bool32 ClearViewAlsoSupportsDepthOnlyFormats; + + /// + public Bool32 MapOnDefaultBuffers; +} + +/// +/// D3D11_FEATURE_DATA_D3D9_SIMPLE_INSTANCING_SUPPORT +public partial struct FeatureDataD3d9SimpleInstancingSupport +{ + /// + public Bool32 SimpleInstancingSupported; +} + +/// +/// D3D11_FEATURE_DATA_MARKER_SUPPORT +public partial struct FeatureDataMarkerSupport +{ + /// + public Bool32 Profile; +} + +/// +/// D3D11_FEATURE_DATA_D3D9_OPTIONS1 +public partial struct FeatureDataD3d9Options1 +{ + /// + public Bool32 FullNonPow2TextureSupported; + + /// + public Bool32 DepthAsTextureWithLessEqualComparisonFilterSupported; + + /// + public Bool32 SimpleInstancingSupported; + + /// + public Bool32 TextureCubeFaceRenderTargetWithNonCubeDepthStencilSupported; +} + +/// +/// D3D11_FEATURE_DATA_D3D11_OPTIONS2 +public partial struct FeatureDataOptions2 +{ + /// + public Bool32 PSSpecifiedStencilRefSupported; + + /// + public Bool32 TypedUAVLoadAdditionalFormats; + + /// + public Bool32 ROVsSupported; + + /// + public ConservativeRasterizationTier ConservativeRasterizationTier; + + /// + public TiledResourcesTier TiledResourcesTier; + + /// + public Bool32 MapOnDefaultTextures; + + /// + public Bool32 StandardSwizzle; + + /// + public Bool32 UnifiedMemoryArchitecture; +} + +/// +/// D3D11_FEATURE_DATA_D3D11_OPTIONS3 +public partial struct FeatureDataOptions3 +{ + /// + public Bool32 VPAndRTArrayIndexFromAnyShaderFeedingRasterizer; +} + +/// +/// D3D11_FEATURE_DATA_GPU_VIRTUAL_ADDRESS_SUPPORT +public partial struct FeatureDataGpuVirtualAddressSupport +{ + /// + public uint MaxGPUVirtualAddressBitsPerResource; + + /// + public uint MaxGPUVirtualAddressBitsPerProcess; +} + +/// +/// D3D11_FEATURE_DATA_SHADER_CACHE +public partial struct FeatureDataShaderCache +{ + /// + public uint SupportFlags; +} + +/// +/// D3D11_FEATURE_DATA_DISPLAYABLE +public partial struct FeatureDataDisplayable +{ + /// + public Bool32 DisplayableTexture; + + /// + public SharedResourceTier SharedResourceTier; +} + +/// +/// D3D11_FEATURE_DATA_D3D11_OPTIONS5 +public partial struct FeatureDataOptions5 +{ + /// + public SharedResourceTier SharedResourceTier; +} + +/// +/// CD3D11_VIDEO_DEFAULT +public partial struct Cd3d11VideoDefault +{ +} + +/// +/// D3D11_VIDEO_DECODER_DESC +public partial struct VideoDecoderDescription +{ + /// + public Guid Guid; + + /// + public uint SampleWidth; + + /// + public uint SampleHeight; + + /// + public Graphics.Dxgi.Common.Format OutputFormat; +} + +/// +/// D3D11_VIDEO_DECODER_CONFIG +public partial struct VideoDecoderConfig +{ + /// + public Guid guidConfigBitstreamEncryption; + + /// + public Guid guidConfigMBcontrolEncryption; + + /// + public Guid guidConfigResidDiffEncryption; + + /// + public uint ConfigBitstreamRaw; + + /// + public uint ConfigMBcontrolRasterOrder; + + /// + public uint ConfigResidDiffHost; + + /// + public uint ConfigSpatialResid8; + + /// + public uint ConfigResid8Subtraction; + + /// + public uint ConfigSpatialHost8or9Clipping; + + /// + public uint ConfigSpatialResidInterleaved; + + /// + public uint ConfigIntraResidUnsigned; + + /// + public uint ConfigResidDiffAccelerator; + + /// + public uint ConfigHostInverseScan; + + /// + public uint ConfigSpecificIDCT; + + /// + public uint Config4GroupedCoefs; + + /// + public ushort ConfigMinRenderTargetBuffCount; + + /// + public ushort ConfigDecoderSpecific; +} + +/// +/// D3D11_AES_CTR_IV +public partial struct AesCtrIv +{ + /// + public ulong IV; + + /// + public ulong Count; +} + +/// +/// D3D11_ENCRYPTED_BLOCK_INFO +public partial struct EncryptedBlockInfo +{ + /// + public uint NumEncryptedBytesAtBeginning; + + /// + public uint NumBytesInSkipPattern; + + /// + public uint NumBytesInEncryptPattern; +} + +/// +/// D3D11_VIDEO_DECODER_BUFFER_DESC +public partial struct VideoDecoderBufferDescription +{ + /// + public VideoDecoderBufferType BufferType; + + /// + public uint BufferIndex; + + /// + public uint DataOffset; + + /// + public uint DataSize; + + /// + public uint FirstMBaddress; + + /// + public uint NumMBsInBuffer; + + /// + public uint Width; + + /// + public uint Height; + + /// + public uint Stride; + + /// + public uint ReservedBits; + + /// + public unsafe void* pIV; + + /// + public uint IVSize; + + /// + public Bool32 PartialEncryption; + + /// + public EncryptedBlockInfo EncryptedBlockInfo; +} + +/// +/// D3D11_VIDEO_DECODER_EXTENSION +public partial struct VideoDecoderExtension +{ + /// + public uint Function; + + /// + public unsafe void* pPrivateInputData; + + /// + public uint PrivateInputDataSize; + + /// + public unsafe void* pPrivateOutputData; + + /// + public uint PrivateOutputDataSize; + + /// + public uint ResourceCount; + + /// + public unsafe ID3D11Resource* ppResourceList; +} + +/// +/// D3D11_VIDEO_PROCESSOR_CAPS +public partial struct VideoProcessorCaps +{ + /// + public uint DeviceCaps; + + /// + public uint FeatureCaps; + + /// + public uint FilterCaps; + + /// + public uint InputFormatCaps; + + /// + public uint AutoStreamCaps; + + /// + public uint StereoCaps; + + /// + public uint RateConversionCapsCount; + + /// + public uint MaxInputStreams; + + /// + public uint MaxStreamStates; +} + +/// +/// D3D11_VIDEO_PROCESSOR_RATE_CONVERSION_CAPS +public partial struct VideoProcessorRateConversionCaps +{ + /// + public uint PastFrames; + + /// + public uint FutureFrames; + + /// + public uint ProcessorCaps; + + /// + public uint ITelecineCaps; + + /// + public uint CustomRateCount; +} + +/// +/// D3D11_VIDEO_CONTENT_PROTECTION_CAPS +public partial struct VideoContentProtectionCaps +{ + /// + public uint Caps; + + /// + public uint KeyExchangeTypeCount; + + /// + public uint BlockAlignmentSize; + + /// + public ulong ProtectedMemorySize; +} + +/// +/// D3D11_VIDEO_PROCESSOR_CUSTOM_RATE +public partial struct VideoProcessorCustomRate +{ + /// + public Graphics.Dxgi.Common.Rational CustomRate; + + /// + public uint OutputFrames; + + /// + public Bool32 InputInterlaced; + + /// + public uint InputFramesOrFields; +} + +/// +/// D3D11_VIDEO_PROCESSOR_FILTER_RANGE +public partial struct VideoProcessorFilterRange +{ + /// + public int Minimum; + + /// + public int Maximum; + + /// + public int Default; + + /// + public float Multiplier; +} + +/// +/// D3D11_VIDEO_PROCESSOR_CONTENT_DESC +public partial struct VideoProcessorContentDescription +{ + /// + public VideoFrameFormat InputFrameFormat; + + /// + public Graphics.Dxgi.Common.Rational InputFrameRate; + + /// + public uint InputWidth; + + /// + public uint InputHeight; + + /// + public Graphics.Dxgi.Common.Rational OutputFrameRate; + + /// + public uint OutputWidth; + + /// + public uint OutputHeight; + + /// + public VideoUsage Usage; +} + +/// +/// D3D11_VIDEO_COLOR_RGBA +public partial struct VideoColorRgba +{ + /// + public float R; + + /// + public float G; + + /// + public float B; + + /// + public float A; +} + +/// +/// D3D11_VIDEO_COLOR_YCbCrA +public partial struct VideoColorYcbcra +{ + /// + public float Y; + + /// + public float Cb; + + /// + public float Cr; + + /// + public float A; +} + +/// +/// D3D11_VIDEO_COLOR +public partial struct VideoColor +{ + /// + public _Anonymous_e__Union Anonymous; + + public partial struct _Anonymous_e__Union + { + /// + public VideoColorYcbcra YCbCr; + + /// + public VideoColorRgba RGBA; + } + +} + +/// +/// D3D11_VIDEO_PROCESSOR_COLOR_SPACE +public partial struct VideoProcessorColorSpace +{ + /// + public uint _bitfield; +} + +/// +/// D3D11_VIDEO_PROCESSOR_STREAM +public partial struct VideoProcessorStream +{ + /// + public Bool32 Enable; + + /// + public uint OutputIndex; + + /// + public uint InputFrameOrField; + + /// + public uint PastFrames; + + /// + public uint FutureFrames; + + /// + public unsafe ID3D11VideoProcessorInputView* ppPastSurfaces; + + /// + public ID3D11VideoProcessorInputView pInputSurface; + + /// + public unsafe ID3D11VideoProcessorInputView* ppFutureSurfaces; + + /// + public unsafe ID3D11VideoProcessorInputView* ppPastSurfacesRight; + + /// + public ID3D11VideoProcessorInputView pInputSurfaceRight; + + /// + public unsafe ID3D11VideoProcessorInputView* ppFutureSurfacesRight; +} + +/// +/// D3D11_OMAC +public partial struct Omac +{ + /// + public unsafe fixed byte OmacF[16]; +} + +/// +/// D3D11_AUTHENTICATED_QUERY_INPUT +public partial struct AuthenticatedQueryInput +{ + /// + public Guid QueryType; + + /// + public IntPtr hChannel; + + /// + public uint SequenceNumber; +} + +/// +/// D3D11_AUTHENTICATED_QUERY_OUTPUT +public partial struct AuthenticatedQueryOutput +{ + /// + public Omac omac; + + /// + public Guid QueryType; + + /// + public IntPtr hChannel; + + /// + public uint SequenceNumber; + + /// + public HResult ReturnCode; +} + +/// +/// D3D11_AUTHENTICATED_QUERY_PROTECTION_OUTPUT +public partial struct AuthenticatedQueryProtectionOutput +{ + /// + public AuthenticatedQueryOutput Output; + + /// + //public D3D11_AUTHENTICATED_PROTECTION_FLAGS ProtectionFlags; +} + +/// +/// D3D11_AUTHENTICATED_QUERY_CHANNEL_TYPE_OUTPUT +public partial struct AuthenticatedQueryChannelTypeOutput +{ + /// + public AuthenticatedQueryOutput Output; + + /// + public AuthenticatedChannelType ChannelType; +} + +/// +/// D3D11_AUTHENTICATED_QUERY_DEVICE_HANDLE_OUTPUT +public partial struct AuthenticatedQueryDeviceHandleOutput +{ + /// + public AuthenticatedQueryOutput Output; + + /// + public IntPtr DeviceHandle; +} + +/// +/// D3D11_AUTHENTICATED_QUERY_CRYPTO_SESSION_INPUT +public partial struct AuthenticatedQueryCryptoSessionInput +{ + /// + public AuthenticatedQueryInput Input; + + /// + public IntPtr DecoderHandle; +} + +/// +/// D3D11_AUTHENTICATED_QUERY_CRYPTO_SESSION_OUTPUT +public partial struct AuthenticatedQueryCryptoSessionOutput +{ + /// + public AuthenticatedQueryOutput Output; + + /// + public IntPtr DecoderHandle; + + /// + public IntPtr CryptoSessionHandle; + + /// + public IntPtr DeviceHandle; +} + +/// +/// D3D11_AUTHENTICATED_QUERY_RESTRICTED_SHARED_RESOURCE_PROCESS_COUNT_OUTPUT +public partial struct AuthenticatedQueryRestrictedSharedResourceProcessCountOutput +{ + /// + public AuthenticatedQueryOutput Output; + + /// + public uint RestrictedSharedResourceProcessCount; +} + +/// +/// D3D11_AUTHENTICATED_QUERY_RESTRICTED_SHARED_RESOURCE_PROCESS_INPUT +public partial struct AuthenticatedQueryRestrictedSharedResourceProcessInput +{ + /// + public AuthenticatedQueryInput Input; + + /// + public uint ProcessIndex; +} + +/// +/// D3D11_AUTHENTICATED_QUERY_RESTRICTED_SHARED_RESOURCE_PROCESS_OUTPUT +public partial struct AuthenticatedQueryRestrictedSharedResourceProcessOutput +{ + /// + public AuthenticatedQueryOutput Output; + + /// + public uint ProcessIndex; + + /// + public AuthenticatedProcessIdentifierType ProcessIdentifier; + + /// + public IntPtr ProcessHandle; +} + +/// +/// D3D11_AUTHENTICATED_QUERY_UNRESTRICTED_PROTECTED_SHARED_RESOURCE_COUNT_OUTPUT +public partial struct AuthenticatedQueryUnrestrictedProtectedSharedResourceCountOutput +{ + /// + public AuthenticatedQueryOutput Output; + + /// + public uint UnrestrictedProtectedSharedResourceCount; +} + +/// +/// D3D11_AUTHENTICATED_QUERY_OUTPUT_ID_COUNT_INPUT +public partial struct AuthenticatedQueryOutputIdCountInput +{ + /// + public AuthenticatedQueryInput Input; + + /// + public IntPtr DeviceHandle; + + /// + public IntPtr CryptoSessionHandle; +} + +/// +/// D3D11_AUTHENTICATED_QUERY_OUTPUT_ID_COUNT_OUTPUT +public partial struct AuthenticatedQueryOutputIdCountOutput +{ + /// + public AuthenticatedQueryOutput Output; + + /// + public IntPtr DeviceHandle; + + /// + public IntPtr CryptoSessionHandle; + + /// + public uint OutputIDCount; +} + +/// +/// D3D11_AUTHENTICATED_QUERY_OUTPUT_ID_INPUT +public partial struct AuthenticatedQueryOutputIdInput +{ + /// + public AuthenticatedQueryInput Input; + + /// + public IntPtr DeviceHandle; + + /// + public IntPtr CryptoSessionHandle; + + /// + public uint OutputIDIndex; +} + +/// +/// D3D11_AUTHENTICATED_QUERY_OUTPUT_ID_OUTPUT +public partial struct AuthenticatedQueryOutputIdOutput +{ + /// + public AuthenticatedQueryOutput Output; + + /// + public IntPtr DeviceHandle; + + /// + public IntPtr CryptoSessionHandle; + + /// + public uint OutputIDIndex; + + /// + public ulong OutputID; +} + +/// +/// D3D11_AUTHENTICATED_QUERY_ACCESSIBILITY_OUTPUT +public partial struct AuthenticatedQueryAccessibilityOutput +{ + /// + public AuthenticatedQueryOutput Output; + + /// + public BusType BusType; + + /// + public Bool32 AccessibleInContiguousBlocks; + + /// + public Bool32 AccessibleInNonContiguousBlocks; +} + +/// +/// D3D11_AUTHENTICATED_QUERY_ACCESSIBILITY_ENCRYPTION_GUID_COUNT_OUTPUT +public partial struct AuthenticatedQueryAccessibilityEncryptionGuidCountOutput +{ + /// + public AuthenticatedQueryOutput Output; + + /// + public uint EncryptionGuidCount; +} + +/// +/// D3D11_AUTHENTICATED_QUERY_ACCESSIBILITY_ENCRYPTION_GUID_INPUT +public partial struct AuthenticatedQueryAccessibilityEncryptionGuidInput +{ + /// + public AuthenticatedQueryInput Input; + + /// + public uint EncryptionGuidIndex; +} + +/// +/// D3D11_AUTHENTICATED_QUERY_ACCESSIBILITY_ENCRYPTION_GUID_OUTPUT +public partial struct AuthenticatedQueryAccessibilityEncryptionGuidOutput +{ + /// + public AuthenticatedQueryOutput Output; + + /// + public uint EncryptionGuidIndex; + + /// + public Guid EncryptionGuid; +} + +/// +/// D3D11_AUTHENTICATED_QUERY_CURRENT_ACCESSIBILITY_ENCRYPTION_OUTPUT +public partial struct AuthenticatedQueryCurrentAccessibilityEncryptionOutput +{ + /// + public AuthenticatedQueryOutput Output; + + /// + public Guid EncryptionGuid; +} + +/// +/// D3D11_AUTHENTICATED_CONFIGURE_INPUT +public partial struct AuthenticatedConfigureInput +{ + /// + public Omac omac; + + /// + public Guid ConfigureType; + + /// + public IntPtr hChannel; + + /// + public uint SequenceNumber; +} + +/// +/// D3D11_AUTHENTICATED_CONFIGURE_OUTPUT +public partial struct AuthenticatedConfigureOutput +{ + /// + public Omac omac; + + /// + public Guid ConfigureType; + + /// + public IntPtr hChannel; + + /// + public uint SequenceNumber; + + /// + public HResult ReturnCode; +} + +/// +/// D3D11_AUTHENTICATED_CONFIGURE_INITIALIZE_INPUT +public partial struct AuthenticatedConfigureInitializeInput +{ + /// + public AuthenticatedConfigureInput Parameters; + + /// + public uint StartSequenceQuery; + + /// + public uint StartSequenceConfigure; +} + +/// +/// D3D11_AUTHENTICATED_CONFIGURE_PROTECTION_INPUT +public partial struct AuthenticatedConfigureProtectionInput +{ + /// + public AuthenticatedConfigureInput Parameters; + + /// + //public D3D11_AUTHENTICATED_PROTECTION_FLAGS Protections; +} + +/// +/// D3D11_AUTHENTICATED_CONFIGURE_CRYPTO_SESSION_INPUT +public partial struct AuthenticatedConfigureCryptoSessionInput +{ + /// + public AuthenticatedConfigureInput Parameters; + + /// + public IntPtr DecoderHandle; + + /// + public IntPtr CryptoSessionHandle; + + /// + public IntPtr DeviceHandle; +} + +/// +/// D3D11_AUTHENTICATED_CONFIGURE_SHARED_RESOURCE_INPUT +public partial struct AuthenticatedConfigureSharedResourceInput +{ + /// + public AuthenticatedConfigureInput Parameters; + + /// + public AuthenticatedProcessIdentifierType ProcessType; + + /// + public IntPtr ProcessHandle; + + /// + public Bool32 AllowAccess; +} + +/// +/// D3D11_AUTHENTICATED_CONFIGURE_ACCESSIBLE_ENCRYPTION_INPUT +public partial struct AuthenticatedConfigureAccessibleEncryptionInput +{ + /// + public AuthenticatedConfigureInput Parameters; + + /// + public Guid EncryptionGuid; +} + +/// +/// D3D11_TEX2D_VDOV +public partial struct Tex2dVdov +{ + /// + public uint ArraySlice; +} + +/// +/// D3D11_VIDEO_DECODER_OUTPUT_VIEW_DESC +public partial struct VideoDecoderOutputViewDescription +{ + /// + public Guid DecodeProfile; + + /// + public VdovDimension ViewDimension; + + /// + public _Anonymous_e__Union Anonymous; + + public partial struct _Anonymous_e__Union + { + /// + public Tex2dVdov Texture2D; + } + +} + +/// +/// D3D11_TEX2D_VPIV +public partial struct Tex2dVpiv +{ + /// + public uint MipSlice; + + /// + public uint ArraySlice; +} + +/// +/// D3D11_VIDEO_PROCESSOR_INPUT_VIEW_DESC +public partial struct VideoProcessorInputViewDescription +{ + /// + public uint FourCC; + + /// + public VpivDimension ViewDimension; + + /// + public _Anonymous_e__Union Anonymous; + + public partial struct _Anonymous_e__Union + { + /// + public Tex2dVpiv Texture2D; + } + +} + +/// +/// D3D11_TEX2D_VPOV +public partial struct Tex2dVpov +{ + /// + public uint MipSlice; +} + +/// +/// D3D11_TEX2D_ARRAY_VPOV +public partial struct Tex2dArrayVpov +{ + /// + public uint MipSlice; + + /// + public uint FirstArraySlice; + + /// + public uint ArraySize; +} + +/// +/// D3D11_VIDEO_PROCESSOR_OUTPUT_VIEW_DESC +public partial struct VideoProcessorOutputViewDescription +{ + /// + public VpovDimension ViewDimension; + + /// + public _Anonymous_e__Union Anonymous; + + public partial struct _Anonymous_e__Union + { + /// + public Tex2dVpov Texture2D; + + /// + public Tex2dArrayVpov Texture2DArray; + } + +} + +/// +/// D3D11_MESSAGE +public partial struct Message +{ + /// + public MessageCategory Category; + + /// + public MessageSeverity Severity; + + /// + public MessageId ID; + + /// + public unsafe byte* pDescription; + + /// + public nuint DescriptionByteLength; +} + +/// +/// D3D11_INFO_QUEUE_FILTER_DESC +public partial struct InfoQueueFilterDescription +{ + /// + public uint NumCategories; + + /// + public unsafe MessageCategory* pCategoryList; + + /// + public uint NumSeverities; + + /// + public unsafe MessageSeverity* pSeverityList; + + /// + public uint NumIDs; + + /// + public unsafe MessageId* pIDList; +} + +/// +/// D3D11_INFO_QUEUE_FILTER +public partial struct InfoQueueFilter +{ + /// + public InfoQueueFilterDescription AllowList; + + /// + public InfoQueueFilterDescription DenyList; +} + +/// +/// D3D11_RENDER_TARGET_BLEND_DESC1 +public partial struct RenderTargetBlendDescription1 +{ + /// + public Bool32 BlendEnable; + + /// + public Bool32 LogicOpEnable; + + /// + public Blend SrcBlend; + + /// + public Blend DestBlend; + + /// + public BlendOp BlendOp; + + /// + public Blend SrcBlendAlpha; + + /// + public Blend DestBlendAlpha; + + /// + public BlendOp BlendOpAlpha; + + /// + public LogicOp LogicOp; + + /// + public byte RenderTargetWriteMask; +} + +/// +/// D3D11_BLEND_DESC1 +public partial struct BlendDescription1 +{ + /// + public Bool32 AlphaToCoverageEnable; + + /// + public Bool32 IndependentBlendEnable; + + /// + public RenderTarget__FixedBuffer RenderTarget; + + public unsafe struct RenderTarget__FixedBuffer + { + public RenderTargetBlendDescription1 e0; + public RenderTargetBlendDescription1 e1; + public RenderTargetBlendDescription1 e2; + public RenderTargetBlendDescription1 e3; + public RenderTargetBlendDescription1 e4; + public RenderTargetBlendDescription1 e5; + public RenderTargetBlendDescription1 e6; + public RenderTargetBlendDescription1 e7; + + [UnscopedRef] + public ref RenderTargetBlendDescription1 this[int index] + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + return ref AsSpan()[index]; + } + } + + [UnscopedRef] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public Span AsSpan() + { + return MemoryMarshal.CreateSpan(ref e0, 8); + } + } +} + +/// +/// D3D11_RASTERIZER_DESC1 +public partial struct RasterizerDescription1 +{ + /// + public FillMode FillMode; + + /// + public CullMode CullMode; + + /// + public Bool32 FrontCounterClockwise; + + /// + public int DepthBias; + + /// + public float DepthBiasClamp; + + /// + public float SlopeScaledDepthBias; + + /// + public Bool32 DepthClipEnable; + + /// + public Bool32 ScissorEnable; + + /// + public Bool32 MultisampleEnable; + + /// + public Bool32 AntialiasedLineEnable; + + /// + public uint ForcedSampleCount; +} + +/// +/// D3D11_VIDEO_DECODER_SUB_SAMPLE_MAPPING_BLOCK +public partial struct VideoDecoderSubSampleMappingBlock +{ + /// + public uint ClearSize; + + /// + public uint EncryptedSize; +} + +/// +/// D3D11_VIDEO_DECODER_BUFFER_DESC1 +public partial struct VideoDecoderBufferDescription1 +{ + /// + public VideoDecoderBufferType BufferType; + + /// + public uint DataOffset; + + /// + public uint DataSize; + + /// + public unsafe void* pIV; + + /// + public uint IVSize; + + /// + public unsafe VideoDecoderSubSampleMappingBlock* pSubSampleMappingBlock; + + /// + public uint SubSampleMappingCount; +} + +/// +/// D3D11_VIDEO_DECODER_BEGIN_FRAME_CRYPTO_SESSION +public partial struct VideoDecoderBeginFrameCryptoSession +{ + /// + public ID3D11CryptoSession pCryptoSession; + + /// + public uint BlobSize; + + /// + public unsafe void* pBlob; + + /// + public unsafe Guid* pKeyInfoId; + + /// + public uint PrivateDataSize; + + /// + public unsafe void* pPrivateData; +} + +/// +/// D3D11_VIDEO_PROCESSOR_STREAM_BEHAVIOR_HINT +public partial struct VideoProcessorStreamBehaviorHint +{ + /// + public Bool32 Enable; + + /// + public uint Width; + + /// + public uint Height; + + /// + public Graphics.Dxgi.Common.Format Format; +} + +/// +/// D3D11_KEY_EXCHANGE_HW_PROTECTION_INPUT_DATA +public partial struct KeyExchangeHWProtectionInputData +{ + /// + public uint PrivateDataSize; + + /// + public uint HWProtectionDataSize; + + /// + public unsafe fixed byte pbInput[4]; +} + +/// +/// D3D11_KEY_EXCHANGE_HW_PROTECTION_OUTPUT_DATA +public partial struct KeyExchangeHWProtectionOutputData +{ + /// + public uint PrivateDataSize; + + /// + public uint MaxHWProtectionDataSize; + + /// + public uint HWProtectionDataSize; + + /// + public ulong TransportTime; + + /// + public ulong ExecutionTime; + + /// + public unsafe fixed byte pbOutput[4]; +} + +/// +/// D3D11_KEY_EXCHANGE_HW_PROTECTION_DATA +public partial struct KeyExchangeHWProtectionData +{ + /// + public uint HWProtectionFunctionID; + + /// + public unsafe KeyExchangeHWProtectionInputData* pInputData; + + /// + public unsafe KeyExchangeHWProtectionOutputData* pOutputData; + + /// + public HResult Status; +} + +/// +/// D3D11_VIDEO_SAMPLE_DESC +public partial struct VideoSampleDescription +{ + /// + public uint Width; + + /// + public uint Height; + + /// + public Graphics.Dxgi.Common.Format Format; + + /// + public Graphics.Dxgi.Common.ColorSpaceType ColorSpace; +} + +/// +/// D3D11_TILED_RESOURCE_COORDINATE +public partial struct TiledResourceCoordinate +{ + /// + public uint X; + + /// + public uint Y; + + /// + public uint Z; + + /// + public uint Subresource; +} + +/// +/// D3D11_TILE_REGION_SIZE +public partial struct TileRegionSize +{ + /// + public uint NumTiles; + + /// + public Bool32 bUseBox; + + /// + public uint Width; + + /// + public ushort Height; + + /// + public ushort Depth; +} + +/// +/// D3D11_SUBRESOURCE_TILING +public partial struct SubresourceTiling +{ + /// + public uint WidthInTiles; + + /// + public ushort HeightInTiles; + + /// + public ushort DepthInTiles; + + /// + public uint StartTileIndexInOverallResource; +} + +/// +/// D3D11_TILE_SHAPE +public partial struct TileShape +{ + /// + public uint WidthInTexels; + + /// + public uint HeightInTexels; + + /// + public uint DepthInTexels; +} + +/// +/// D3D11_PACKED_MIP_DESC +public partial struct PackedMipDescription +{ + /// + public byte NumStandardMips; + + /// + public byte NumPackedMips; + + /// + public uint NumTilesForPackedMips; + + /// + public uint StartTileIndexInOverallResource; +} + +/// +/// D3D11_TEXTURE2D_DESC1 +public partial struct Texture2DDescription1 +{ + /// + public uint Width; + + /// + public uint Height; + + /// + public uint MipLevels; + + /// + public uint ArraySize; + + /// + public Graphics.Dxgi.Common.Format Format; + + /// + public Graphics.Dxgi.Common.SampleDescription SampleDesc; + + /// + public Usage Usage; + + /// + public uint BindFlags; + + /// + public uint CPUAccessFlags; + + /// + public uint MiscFlags; + + /// + public TextureLayout TextureLayout; +} + +/// +/// D3D11_TEXTURE3D_DESC1 +public partial struct Texture3DDescription1 +{ + /// + public uint Width; + + /// + public uint Height; + + /// + public uint Depth; + + /// + public uint MipLevels; + + /// + public Graphics.Dxgi.Common.Format Format; + + /// + public Usage Usage; + + /// + public uint BindFlags; + + /// + public uint CPUAccessFlags; + + /// + public uint MiscFlags; + + /// + public TextureLayout TextureLayout; +} + +/// +/// D3D11_RASTERIZER_DESC2 +public partial struct RasterizerDescription2 +{ + /// + public FillMode FillMode; + + /// + public CullMode CullMode; + + /// + public Bool32 FrontCounterClockwise; + + /// + public int DepthBias; + + /// + public float DepthBiasClamp; + + /// + public float SlopeScaledDepthBias; + + /// + public Bool32 DepthClipEnable; + + /// + public Bool32 ScissorEnable; + + /// + public Bool32 MultisampleEnable; + + /// + public Bool32 AntialiasedLineEnable; + + /// + public uint ForcedSampleCount; + + /// + public ConservativeRasterizationMode ConservativeRaster; +} + +/// +/// D3D11_TEX2D_SRV1 +public partial struct Tex2dSrv1 +{ + /// + public uint MostDetailedMip; + + /// + public uint MipLevels; + + /// + public uint PlaneSlice; +} + +/// +/// D3D11_TEX2D_ARRAY_SRV1 +public partial struct Tex2dArraySrv1 +{ + /// + public uint MostDetailedMip; + + /// + public uint MipLevels; + + /// + public uint FirstArraySlice; + + /// + public uint ArraySize; + + /// + public uint PlaneSlice; +} + +/// +/// D3D11_SHADER_RESOURCE_VIEW_DESC1 +public partial struct ShaderResourceViewDescription1 +{ + /// + public Graphics.Dxgi.Common.Format Format; + + /// + public Graphics.Direct3D.SrvDimension ViewDimension; + + /// + public _Anonymous_e__Union Anonymous; + + public partial struct _Anonymous_e__Union + { + /// + public BufferSrv Buffer; + + /// + public Tex1dSrv Texture1D; + + /// + public Tex1dArraySrv Texture1DArray; + + /// + public Tex2dSrv1 Texture2D; + + /// + public Tex2dArraySrv1 Texture2DArray; + + /// + public Tex2dmsSrv Texture2DMS; + + /// + public Tex2dmsArraySrv Texture2DMSArray; + + /// + public Tex3dSrv Texture3D; + + /// + public TexcubeSrv TextureCube; + + /// + public TexcubeArraySrv TextureCubeArray; + + /// + public BufferExtendedSrv BufferEx; + } + +} + +/// +/// D3D11_TEX2D_RTV1 +public partial struct Tex2dRtv1 +{ + /// + public uint MipSlice; + + /// + public uint PlaneSlice; +} + +/// +/// D3D11_TEX2D_ARRAY_RTV1 +public partial struct Tex2dArrayRtv1 +{ + /// + public uint MipSlice; + + /// + public uint FirstArraySlice; + + /// + public uint ArraySize; + + /// + public uint PlaneSlice; +} + +/// +/// D3D11_RENDER_TARGET_VIEW_DESC1 +public partial struct RenderTargetViewDescription1 +{ + /// + public Graphics.Dxgi.Common.Format Format; + + /// + public RtvDimension ViewDimension; + + /// + public _Anonymous_e__Union Anonymous; + + public partial struct _Anonymous_e__Union + { + /// + public BufferRtv Buffer; + + /// + public Tex1dRtv Texture1D; + + /// + public Tex1dArrayRtv Texture1DArray; + + /// + public Tex2dRtv1 Texture2D; + + /// + public Tex2dArrayRtv1 Texture2DArray; + + /// + public Tex2dmsRtv Texture2DMS; + + /// + public Tex2dmsArrayRtv Texture2DMSArray; + + /// + public Tex3dRtv Texture3D; + } + +} + +/// +/// D3D11_TEX2D_UAV1 +public partial struct Tex2dUav1 +{ + /// + public uint MipSlice; + + /// + public uint PlaneSlice; +} + +/// +/// D3D11_TEX2D_ARRAY_UAV1 +public partial struct Tex2dArrayUav1 +{ + /// + public uint MipSlice; + + /// + public uint FirstArraySlice; + + /// + public uint ArraySize; + + /// + public uint PlaneSlice; +} + +/// +/// D3D11_UNORDERED_ACCESS_VIEW_DESC1 +public partial struct UnorderedAccessViewDescription1 +{ + /// + public Graphics.Dxgi.Common.Format Format; + + /// + public UavDimension ViewDimension; + + /// + public _Anonymous_e__Union Anonymous; + + public partial struct _Anonymous_e__Union + { + /// + public BufferUav Buffer; + + /// + public Tex1dUav Texture1D; + + /// + public Tex1dArrayUav Texture1DArray; + + /// + public Tex2dUav1 Texture2D; + + /// + public Tex2dArrayUav1 Texture2DArray; + + /// + public Tex3dUav Texture3D; + } + +} + +/// +/// D3D11_QUERY_DESC1 +public partial struct QueryDescription1 +{ + /// + public Query Query; + + /// + public uint MiscFlags; + + /// + public ContextType ContextType; +} + +/// +/// D3D11_FEATURE_DATA_VIDEO_DECODER_HISTOGRAM +public partial struct FeatureDataVideoDecoderHistogram +{ + /// + public VideoDecoderDescription DecoderDesc; + + /// + public VideoDecoderHistogramComponentFlags Components; + + /// + public uint BinCount; + + /// + public uint CounterBitDepth; +} + +/// +/// D3D11_VIDEO_DECODER_BUFFER_DESC2 +public partial struct VideoDecoderBufferDescription2 +{ + /// + public VideoDecoderBufferType BufferType; + + /// + public uint DataOffset; + + /// + public uint DataSize; + + /// + public unsafe void* pIV; + + /// + public uint IVSize; + + /// + public unsafe VideoDecoderSubSampleMappingBlock* pSubSampleMappingBlock; + + /// + public uint SubSampleMappingCount; + + /// + public uint cBlocksStripeEncrypted; + + /// + public uint cBlocksStripeClear; +} + +/// +/// D3D11_FEATURE_DATA_D3D11_OPTIONS4 +public partial struct FeatureDataOptions4 +{ + /// + public Bool32 ExtendedNV12SharedTextureSupported; +} + +/// +/// D3D11_SIGNATURE_PARAMETER_DESC +public partial struct SignatureParameterDescription +{ + /// + public unsafe byte* SemanticName; + + /// + public uint SemanticIndex; + + /// + public uint Register; + + /// + public Graphics.Direct3D.Name SystemValueType; + + /// + public Graphics.Direct3D.RegisterComponentType ComponentType; + + /// + public byte Mask; + + /// + public byte ReadWriteMask; + + /// + public uint Stream; + + /// + public Graphics.Direct3D.MinPrecision MinPrecision; +} + +/// +/// D3D11_SHADER_BUFFER_DESC +public partial struct ShaderBufferDescription +{ + /// + public unsafe byte* Name; + + /// + public Graphics.Direct3D.CBufferType Type; + + /// + public uint Variables; + + /// + public uint Size; + + /// + public uint uFlags; +} + +/// +/// D3D11_SHADER_VARIABLE_DESC +public partial struct ShaderVariableDescription +{ + /// + public unsafe byte* Name; + + /// + public uint StartOffset; + + /// + public uint Size; + + /// + public uint uFlags; + + /// + public unsafe void* DefaultValue; + + /// + public uint StartTexture; + + /// + public uint TextureSize; + + /// + public uint StartSampler; + + /// + public uint SamplerSize; +} + +/// +/// D3D11_SHADER_TYPE_DESC +public partial struct ShaderTypeDescription +{ + /// + public Graphics.Direct3D.ShaderVariableClass Class; + + /// + public Graphics.Direct3D.ShaderVariableType Type; + + /// + public uint Rows; + + /// + public uint Columns; + + /// + public uint Elements; + + /// + public uint Members; + + /// + public uint Offset; + + /// + public unsafe byte* Name; +} + +/// +/// D3D11_SHADER_DESC +public partial struct ShaderDescription +{ + /// + public uint Version; + + /// + public unsafe byte* Creator; + + /// + public uint Flags; + + /// + public uint ConstantBuffers; + + /// + public uint BoundResources; + + /// + public uint InputParameters; + + /// + public uint OutputParameters; + + /// + public uint InstructionCount; + + /// + public uint TempRegisterCount; + + /// + public uint TempArrayCount; + + /// + public uint DefCount; + + /// + public uint DclCount; + + /// + public uint TextureNormalInstructions; + + /// + public uint TextureLoadInstructions; + + /// + public uint TextureCompInstructions; + + /// + public uint TextureBiasInstructions; + + /// + public uint TextureGradientInstructions; + + /// + public uint FloatInstructionCount; + + /// + public uint IntInstructionCount; + + /// + public uint UintInstructionCount; + + /// + public uint StaticFlowControlCount; + + /// + public uint DynamicFlowControlCount; + + /// + public uint MacroInstructionCount; + + /// + public uint ArrayInstructionCount; + + /// + public uint CutInstructionCount; + + /// + public uint EmitInstructionCount; + + /// + public Graphics.Direct3D.PrimitiveTopology GSOutputTopology; + + /// + public uint GSMaxOutputVertexCount; + + /// + public Graphics.Direct3D.Primitive InputPrimitive; + + /// + public uint PatchConstantParameters; + + /// + public uint cGSInstanceCount; + + /// + public uint cControlPoints; + + /// + public Graphics.Direct3D.TessellatorOutputPrimitive HSOutputPrimitive; + + /// + public Graphics.Direct3D.TessellatorPartitioning HSPartitioning; + + /// + public Graphics.Direct3D.TessellatorDomain TessellatorDomain; + + /// + public uint cBarrierInstructions; + + /// + public uint cInterlockedInstructions; + + /// + public uint cTextureStoreInstructions; +} + +/// +/// D3D11_SHADER_INPUT_BIND_DESC +public partial struct ShaderInputBindDescription +{ + /// + public unsafe byte* Name; + + /// + public Graphics.Direct3D.ShaderInputType Type; + + /// + public uint BindPoint; + + /// + public uint BindCount; + + /// + public uint uFlags; + + /// + public Graphics.Direct3D.ResourceReturnType ReturnType; + + /// + public Graphics.Direct3D.SrvDimension Dimension; + + /// + public uint NumSamples; +} + +/// +/// D3D11_LIBRARY_DESC +public partial struct LibraryDescription +{ + /// + public unsafe byte* Creator; + + /// + public uint Flags; + + /// + public uint FunctionCount; +} + +/// +/// D3D11_FUNCTION_DESC +public partial struct FunctionDescription +{ + /// + public uint Version; + + /// + public unsafe byte* Creator; + + /// + public uint Flags; + + /// + public uint ConstantBuffers; + + /// + public uint BoundResources; + + /// + public uint InstructionCount; + + /// + public uint TempRegisterCount; + + /// + public uint TempArrayCount; + + /// + public uint DefCount; + + /// + public uint DclCount; + + /// + public uint TextureNormalInstructions; + + /// + public uint TextureLoadInstructions; + + /// + public uint TextureCompInstructions; + + /// + public uint TextureBiasInstructions; + + /// + public uint TextureGradientInstructions; + + /// + public uint FloatInstructionCount; + + /// + public uint IntInstructionCount; + + /// + public uint UintInstructionCount; + + /// + public uint StaticFlowControlCount; + + /// + public uint DynamicFlowControlCount; + + /// + public uint MacroInstructionCount; + + /// + public uint ArrayInstructionCount; + + /// + public uint MovInstructionCount; + + /// + public uint MovcInstructionCount; + + /// + public uint ConversionInstructionCount; + + /// + public uint BitwiseInstructionCount; + + /// + public Graphics.Direct3D.FeatureLevel MinFeatureLevel; + + /// + public ulong RequiredFeatureFlags; + + /// + public unsafe byte* Name; + + /// + public int FunctionParameterCount; + + /// + public Bool32 HasReturn; + + /// + public Bool32 Has10Level9VertexShader; + + /// + public Bool32 Has10Level9PixelShader; +} + +/// +/// D3D11_PARAMETER_DESC +public partial struct ParameterDescription +{ + /// + public unsafe byte* Name; + + /// + public unsafe byte* SemanticName; + + /// + public Graphics.Direct3D.ShaderVariableType Type; + + /// + public Graphics.Direct3D.ShaderVariableClass Class; + + /// + public uint Rows; + + /// + public uint Columns; + + /// + public Graphics.Direct3D.InterpolationMode InterpolationMode; + + /// + public Graphics.Direct3D.ParameterFlags Flags; + + /// + public uint FirstInRegister; + + /// + public uint FirstInComponent; + + /// + public uint FirstOutRegister; + + /// + public uint FirstOutComponent; +} + +/// +/// D3D11_VERTEX_SHADER_TRACE_DESC +public partial struct VertexShaderTraceDescription +{ + /// + public ulong Invocation; +} + +/// +/// D3D11_HULL_SHADER_TRACE_DESC +public partial struct HullShaderTraceDescription +{ + /// + public ulong Invocation; +} + +/// +/// D3D11_DOMAIN_SHADER_TRACE_DESC +public partial struct DomainShaderTraceDescription +{ + /// + public ulong Invocation; +} + +/// +/// D3D11_GEOMETRY_SHADER_TRACE_DESC +public partial struct GeometryShaderTraceDescription +{ + /// + public ulong Invocation; +} + +/// +/// D3D11_PIXEL_SHADER_TRACE_DESC +public partial struct PixelShaderTraceDescription +{ + /// + public ulong Invocation; + + /// + public int X; + + /// + public int Y; + + /// + public ulong SampleMask; +} + +/// +/// D3D11_COMPUTE_SHADER_TRACE_DESC +public partial struct ComputeShaderTraceDescription +{ + /// + public ulong Invocation; + + /// + public unsafe fixed uint ThreadIDInGroup[3]; + + /// + public unsafe fixed uint ThreadGroupID[3]; +} + +/// +/// D3D11_SHADER_TRACE_DESC +public partial struct ShaderTraceDescription +{ + /// + public ShaderType Type; + + /// + public uint Flags; + + /// + public _Anonymous_e__Union Anonymous; + + public partial struct _Anonymous_e__Union + { + /// + public VertexShaderTraceDescription VertexShaderTraceDesc; + + /// + public HullShaderTraceDescription HullShaderTraceDesc; + + /// + public DomainShaderTraceDescription DomainShaderTraceDesc; + + /// + public GeometryShaderTraceDescription GeometryShaderTraceDesc; + + /// + public PixelShaderTraceDescription PixelShaderTraceDesc; + + /// + public ComputeShaderTraceDescription ComputeShaderTraceDesc; + } + +} + +/// +/// D3D11_TRACE_STATS +public partial struct TraceStats +{ + /// + public ShaderTraceDescription TraceDesc; + + /// + public byte NumInvocationsInStamp; + + /// + public byte TargetStampIndex; + + /// + public uint NumTraceSteps; + + /// + public unsafe fixed byte InputMask[32]; + + /// + public unsafe fixed byte OutputMask[32]; + + /// + public ushort NumTemps; + + /// + public ushort MaxIndexableTempIndex; + + /// + public unsafe fixed ushort IndexableTempSize[4096]; + + /// + public ushort ImmediateConstantBufferSize; + + /// + public unsafe fixed uint PixelPosition[8]; + + /// + public unsafe fixed ulong PixelCoverageMask[4]; + + /// + public unsafe fixed ulong PixelDiscardedMask[4]; + + /// + public unsafe fixed ulong PixelCoverageMaskAfterShader[4]; + + /// + public unsafe fixed ulong PixelCoverageMaskAfterA2CSampleMask[4]; + + /// + public unsafe fixed ulong PixelCoverageMaskAfterA2CSampleMaskDepth[4]; + + /// + public unsafe fixed ulong PixelCoverageMaskAfterA2CSampleMaskDepthStencil[4]; + + /// + public Bool32 PSOutputsDepth; + + /// + public Bool32 PSOutputsMask; + + /// + public TraceGsInputPrimitive GSInputPrimitive; + + /// + public Bool32 GSInputsPrimitiveID; + + /// + public unsafe fixed byte HSOutputPatchConstantMask[32]; + + /// + public unsafe fixed byte DSInputPatchConstantMask[32]; +} + +/// +/// D3D11_TRACE_VALUE +public partial struct TraceValue +{ + /// + public unsafe fixed uint Bits[4]; + + /// + public byte ValidMask; +} + +/// +/// D3D11_TRACE_REGISTER +public partial struct TraceRegister +{ + /// + public TraceRegisterType RegType; + + /// + public _Anonymous_e__Union Anonymous; + + /// + public byte OperandIndex; + + /// + public byte Flags; + + public partial struct _Anonymous_e__Union + { + /// + public ushort Index1D; + + /// + public unsafe fixed ushort Index2D[2]; + } + +} + +/// +/// D3D11_TRACE_STEP +public partial struct TraceStep +{ + /// + public uint ID; + + /// + public Bool32 InstructionActive; + + /// + public byte NumRegistersWritten; + + /// + public byte NumRegistersRead; + + /// + public ushort MiscOperations; + + /// + public uint OpcodeType; + + /// + public ulong CurrentGlobalCycle; +} + +/// +/// D3DX11_FFT_DESC +public partial struct D3dx11FftDescription +{ + /// + public uint NumDimensions; + + /// + public unsafe fixed uint ElementLengths[32]; + + /// + public uint DimensionMask; + + /// + public D3dx11FftDataType Type; +} + +/// +/// D3DX11_FFT_BUFFER_INFO +public partial struct D3dx11FftBufferInfo +{ + /// + public uint NumTempBufferSizes; + + /// + public unsafe fixed uint TempBufferFloatSizes[4]; + + /// + public uint NumPrecomputeBufferSizes; + + /// + public unsafe fixed uint PrecomputeBufferFloatSizes[4]; +} + +#endregion Structs + +#region COM Types +/// +/// ID3D11DeviceChild +[Guid("1841e5c8-16b0-489b-bcc8-44cfb0d5deae")] +[NativeTypeName("struct ID3D11DeviceChild : IUnknown")] +[NativeInheritance("IUnknown")] +public unsafe partial struct ID3D11DeviceChild : ID3D11DeviceChild.Interface +{ + public static ref readonly Guid IID_ID3D11DeviceChild + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0xC8, 0xE5, 0x41, 0x18, + 0xB0, 0x16, + 0x9B, 0x48, + 0xBC, + 0xC8, + 0x44, + 0xCF, + 0xB0, + 0xD5, + 0xDE, + 0xAE + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_ID3D11DeviceChild)); + + public void** lpVtbl; + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(0)] + public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(1)] + [return: NativeTypeName("ULONG")] + public uint AddRef() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(2)] + [return: NativeTypeName("ULONG")] + public uint Release() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(3)] + public void GetDevice(ID3D11Device* ppDevice) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[3]))((ID3D11DeviceChild*)Unsafe.AsPointer(ref this), ppDevice); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((ID3D11DeviceChild*)Unsafe.AsPointer(ref this), ppDevice); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public HResult GetPrivateData(Guid* guid, uint* pDataSize, void* pData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[4]))((ID3D11DeviceChild*)Unsafe.AsPointer(ref this), guid, pDataSize, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((ID3D11DeviceChild*)Unsafe.AsPointer(ref this), guid, pDataSize, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(5)] + public HResult SetPrivateData(Guid* guid, uint DataSize, void* pData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[5]))((ID3D11DeviceChild*)Unsafe.AsPointer(ref this), guid, DataSize, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((ID3D11DeviceChild*)Unsafe.AsPointer(ref this), guid, DataSize, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(6)] + public HResult SetPrivateDataInterface(Guid* guid, IUnknown* pData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[6]))((ID3D11DeviceChild*)Unsafe.AsPointer(ref this), guid, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((ID3D11DeviceChild*)Unsafe.AsPointer(ref this), guid, pData); +#endif + } + + public interface Interface : IUnknown.Interface + { + } +} + +/// +/// ID3D11DepthStencilState +[Guid("03823efb-8d8f-4e1c-9aa2-f64bb2cbfdf1")] +[NativeTypeName("struct ID3D11DepthStencilState : ID3D11DeviceChild")] +[NativeInheritance("ID3D11DeviceChild")] +public unsafe partial struct ID3D11DepthStencilState : ID3D11DepthStencilState.Interface +{ + public static ref readonly Guid IID_ID3D11DepthStencilState + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0xFB, 0x3E, 0x82, 0x03, + 0x8F, 0x8D, + 0x1C, 0x4E, + 0x9A, + 0xA2, + 0xF6, + 0x4B, + 0xB2, + 0xCB, + 0xFD, + 0xF1 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_ID3D11DepthStencilState)); + + public void** lpVtbl; + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(0)] + public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(1)] + [return: NativeTypeName("ULONG")] + public uint AddRef() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(2)] + [return: NativeTypeName("ULONG")] + public uint Release() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(3)] + public void GetDevice(ID3D11Device* ppDevice) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[3]))((ID3D11DepthStencilState*)Unsafe.AsPointer(ref this), ppDevice); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((ID3D11DepthStencilState*)Unsafe.AsPointer(ref this), ppDevice); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public HResult GetPrivateData(Guid* guid, uint* pDataSize, void* pData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[4]))((ID3D11DepthStencilState*)Unsafe.AsPointer(ref this), guid, pDataSize, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((ID3D11DepthStencilState*)Unsafe.AsPointer(ref this), guid, pDataSize, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(5)] + public HResult SetPrivateData(Guid* guid, uint DataSize, void* pData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[5]))((ID3D11DepthStencilState*)Unsafe.AsPointer(ref this), guid, DataSize, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((ID3D11DepthStencilState*)Unsafe.AsPointer(ref this), guid, DataSize, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(6)] + public HResult SetPrivateDataInterface(Guid* guid, IUnknown* pData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[6]))((ID3D11DepthStencilState*)Unsafe.AsPointer(ref this), guid, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((ID3D11DepthStencilState*)Unsafe.AsPointer(ref this), guid, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(7)] + public void GetDesc(DepthStencilDescription* pDesc) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[7]))((ID3D11DepthStencilState*)Unsafe.AsPointer(ref this), pDesc); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((ID3D11DepthStencilState*)Unsafe.AsPointer(ref this), pDesc); +#endif + } + + public interface Interface : ID3D11DeviceChild.Interface + { + } +} + +/// +/// ID3D11BlendState +[Guid("75b68faa-347d-4159-8f45-a0640f01cd9a")] +[NativeTypeName("struct ID3D11BlendState : ID3D11DeviceChild")] +[NativeInheritance("ID3D11DeviceChild")] +public unsafe partial struct ID3D11BlendState : ID3D11BlendState.Interface +{ + public static ref readonly Guid IID_ID3D11BlendState + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0xAA, 0x8F, 0xB6, 0x75, + 0x7D, 0x34, + 0x59, 0x41, + 0x8F, + 0x45, + 0xA0, + 0x64, + 0x0F, + 0x01, + 0xCD, + 0x9A + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_ID3D11BlendState)); + + public void** lpVtbl; + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(0)] + public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(1)] + [return: NativeTypeName("ULONG")] + public uint AddRef() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(2)] + [return: NativeTypeName("ULONG")] + public uint Release() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(3)] + public void GetDevice(ID3D11Device* ppDevice) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[3]))((ID3D11BlendState*)Unsafe.AsPointer(ref this), ppDevice); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((ID3D11BlendState*)Unsafe.AsPointer(ref this), ppDevice); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public HResult GetPrivateData(Guid* guid, uint* pDataSize, void* pData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[4]))((ID3D11BlendState*)Unsafe.AsPointer(ref this), guid, pDataSize, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((ID3D11BlendState*)Unsafe.AsPointer(ref this), guid, pDataSize, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(5)] + public HResult SetPrivateData(Guid* guid, uint DataSize, void* pData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[5]))((ID3D11BlendState*)Unsafe.AsPointer(ref this), guid, DataSize, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((ID3D11BlendState*)Unsafe.AsPointer(ref this), guid, DataSize, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(6)] + public HResult SetPrivateDataInterface(Guid* guid, IUnknown* pData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[6]))((ID3D11BlendState*)Unsafe.AsPointer(ref this), guid, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((ID3D11BlendState*)Unsafe.AsPointer(ref this), guid, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(7)] + public void GetDesc(BlendDescription* pDesc) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[7]))((ID3D11BlendState*)Unsafe.AsPointer(ref this), pDesc); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((ID3D11BlendState*)Unsafe.AsPointer(ref this), pDesc); +#endif + } + + public interface Interface : ID3D11DeviceChild.Interface + { + } +} + +/// +/// ID3D11RasterizerState +[Guid("9bb4ab81-ab1a-4d8f-b506-fc04200b6ee7")] +[NativeTypeName("struct ID3D11RasterizerState : ID3D11DeviceChild")] +[NativeInheritance("ID3D11DeviceChild")] +public unsafe partial struct ID3D11RasterizerState : ID3D11RasterizerState.Interface +{ + public static ref readonly Guid IID_ID3D11RasterizerState + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x81, 0xAB, 0xB4, 0x9B, + 0x1A, 0xAB, + 0x8F, 0x4D, + 0xB5, + 0x06, + 0xFC, + 0x04, + 0x20, + 0x0B, + 0x6E, + 0xE7 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_ID3D11RasterizerState)); + + public void** lpVtbl; + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(0)] + public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(1)] + [return: NativeTypeName("ULONG")] + public uint AddRef() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(2)] + [return: NativeTypeName("ULONG")] + public uint Release() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(3)] + public void GetDevice(ID3D11Device* ppDevice) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[3]))((ID3D11RasterizerState*)Unsafe.AsPointer(ref this), ppDevice); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((ID3D11RasterizerState*)Unsafe.AsPointer(ref this), ppDevice); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public HResult GetPrivateData(Guid* guid, uint* pDataSize, void* pData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[4]))((ID3D11RasterizerState*)Unsafe.AsPointer(ref this), guid, pDataSize, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((ID3D11RasterizerState*)Unsafe.AsPointer(ref this), guid, pDataSize, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(5)] + public HResult SetPrivateData(Guid* guid, uint DataSize, void* pData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[5]))((ID3D11RasterizerState*)Unsafe.AsPointer(ref this), guid, DataSize, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((ID3D11RasterizerState*)Unsafe.AsPointer(ref this), guid, DataSize, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(6)] + public HResult SetPrivateDataInterface(Guid* guid, IUnknown* pData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[6]))((ID3D11RasterizerState*)Unsafe.AsPointer(ref this), guid, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((ID3D11RasterizerState*)Unsafe.AsPointer(ref this), guid, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(7)] + public void GetDesc(RasterizerDescription* pDesc) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[7]))((ID3D11RasterizerState*)Unsafe.AsPointer(ref this), pDesc); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((ID3D11RasterizerState*)Unsafe.AsPointer(ref this), pDesc); +#endif + } + + public interface Interface : ID3D11DeviceChild.Interface + { + } +} + +/// +/// ID3D11Resource +[Guid("dc8e63f3-d12b-4952-b47b-5e45026a862d")] +[NativeTypeName("struct ID3D11Resource : ID3D11DeviceChild")] +[NativeInheritance("ID3D11DeviceChild")] +public unsafe partial struct ID3D11Resource : ID3D11Resource.Interface +{ + public static ref readonly Guid IID_ID3D11Resource + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0xF3, 0x63, 0x8E, 0xDC, + 0x2B, 0xD1, + 0x52, 0x49, + 0xB4, + 0x7B, + 0x5E, + 0x45, + 0x02, + 0x6A, + 0x86, + 0x2D + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_ID3D11Resource)); + + public void** lpVtbl; + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(0)] + public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(1)] + [return: NativeTypeName("ULONG")] + public uint AddRef() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(2)] + [return: NativeTypeName("ULONG")] + public uint Release() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(3)] + public void GetDevice(ID3D11Device* ppDevice) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[3]))((ID3D11Resource*)Unsafe.AsPointer(ref this), ppDevice); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((ID3D11Resource*)Unsafe.AsPointer(ref this), ppDevice); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public HResult GetPrivateData(Guid* guid, uint* pDataSize, void* pData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[4]))((ID3D11Resource*)Unsafe.AsPointer(ref this), guid, pDataSize, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((ID3D11Resource*)Unsafe.AsPointer(ref this), guid, pDataSize, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(5)] + public HResult SetPrivateData(Guid* guid, uint DataSize, void* pData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[5]))((ID3D11Resource*)Unsafe.AsPointer(ref this), guid, DataSize, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((ID3D11Resource*)Unsafe.AsPointer(ref this), guid, DataSize, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(6)] + public HResult SetPrivateDataInterface(Guid* guid, IUnknown* pData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[6]))((ID3D11Resource*)Unsafe.AsPointer(ref this), guid, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((ID3D11Resource*)Unsafe.AsPointer(ref this), guid, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(7)] + public void GetType(ResourceDimension* pResourceDimension) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[7]))((ID3D11Resource*)Unsafe.AsPointer(ref this), pResourceDimension); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((ID3D11Resource*)Unsafe.AsPointer(ref this), pResourceDimension); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(8)] + public void SetEvictionPriority(uint EvictionPriority) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[8]))((ID3D11Resource*)Unsafe.AsPointer(ref this), EvictionPriority); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[8]))((ID3D11Resource*)Unsafe.AsPointer(ref this), EvictionPriority); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(9)] + public uint GetEvictionPriority() + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[9]))((ID3D11Resource*)Unsafe.AsPointer(ref this)); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[9]))((ID3D11Resource*)Unsafe.AsPointer(ref this)); +#endif + } + + public interface Interface : ID3D11DeviceChild.Interface + { + } +} + +/// +/// ID3D11Buffer +[Guid("48570b85-d1ee-4fcd-a250-eb350722b037")] +[NativeTypeName("struct ID3D11Buffer : ID3D11Resource")] +[NativeInheritance("ID3D11Resource")] +public unsafe partial struct ID3D11Buffer : ID3D11Buffer.Interface +{ + public static ref readonly Guid IID_ID3D11Buffer + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x85, 0x0B, 0x57, 0x48, + 0xEE, 0xD1, + 0xCD, 0x4F, + 0xA2, + 0x50, + 0xEB, + 0x35, + 0x07, + 0x22, + 0xB0, + 0x37 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_ID3D11Buffer)); + + public void** lpVtbl; + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(0)] + public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(1)] + [return: NativeTypeName("ULONG")] + public uint AddRef() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(2)] + [return: NativeTypeName("ULONG")] + public uint Release() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(3)] + public void GetType(ResourceDimension* pResourceDimension) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[3]))((ID3D11Buffer*)Unsafe.AsPointer(ref this), pResourceDimension); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((ID3D11Buffer*)Unsafe.AsPointer(ref this), pResourceDimension); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public void SetEvictionPriority(uint EvictionPriority) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[4]))((ID3D11Buffer*)Unsafe.AsPointer(ref this), EvictionPriority); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((ID3D11Buffer*)Unsafe.AsPointer(ref this), EvictionPriority); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(5)] + public uint GetEvictionPriority() + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[5]))((ID3D11Buffer*)Unsafe.AsPointer(ref this)); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((ID3D11Buffer*)Unsafe.AsPointer(ref this)); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(6)] + public void GetDevice(ID3D11Device* ppDevice) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[6]))((ID3D11Buffer*)Unsafe.AsPointer(ref this), ppDevice); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((ID3D11Buffer*)Unsafe.AsPointer(ref this), ppDevice); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(7)] + public HResult GetPrivateData(Guid* guid, uint* pDataSize, void* pData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[7]))((ID3D11Buffer*)Unsafe.AsPointer(ref this), guid, pDataSize, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((ID3D11Buffer*)Unsafe.AsPointer(ref this), guid, pDataSize, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(8)] + public HResult SetPrivateData(Guid* guid, uint DataSize, void* pData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[8]))((ID3D11Buffer*)Unsafe.AsPointer(ref this), guid, DataSize, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[8]))((ID3D11Buffer*)Unsafe.AsPointer(ref this), guid, DataSize, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(9)] + public HResult SetPrivateDataInterface(Guid* guid, IUnknown* pData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[9]))((ID3D11Buffer*)Unsafe.AsPointer(ref this), guid, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[9]))((ID3D11Buffer*)Unsafe.AsPointer(ref this), guid, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(10)] + public void GetDesc(BufferDescription* pDesc) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[10]))((ID3D11Buffer*)Unsafe.AsPointer(ref this), pDesc); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[10]))((ID3D11Buffer*)Unsafe.AsPointer(ref this), pDesc); +#endif + } + + public interface Interface : ID3D11Resource.Interface + { + } +} + +/// +/// ID3D11Texture1D +[Guid("f8fb5c27-c6b3-4f75-a4c8-439af2ef564c")] +[NativeTypeName("struct ID3D11Texture1D : ID3D11Resource")] +[NativeInheritance("ID3D11Resource")] +public unsafe partial struct ID3D11Texture1D : ID3D11Texture1D.Interface +{ + public static ref readonly Guid IID_ID3D11Texture1D + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x27, 0x5C, 0xFB, 0xF8, + 0xB3, 0xC6, + 0x75, 0x4F, + 0xA4, + 0xC8, + 0x43, + 0x9A, + 0xF2, + 0xEF, + 0x56, + 0x4C + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_ID3D11Texture1D)); + + public void** lpVtbl; + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(0)] + public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(1)] + [return: NativeTypeName("ULONG")] + public uint AddRef() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(2)] + [return: NativeTypeName("ULONG")] + public uint Release() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(3)] + public void GetType(ResourceDimension* pResourceDimension) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[3]))((ID3D11Texture1D*)Unsafe.AsPointer(ref this), pResourceDimension); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((ID3D11Texture1D*)Unsafe.AsPointer(ref this), pResourceDimension); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public void SetEvictionPriority(uint EvictionPriority) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[4]))((ID3D11Texture1D*)Unsafe.AsPointer(ref this), EvictionPriority); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((ID3D11Texture1D*)Unsafe.AsPointer(ref this), EvictionPriority); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(5)] + public uint GetEvictionPriority() + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[5]))((ID3D11Texture1D*)Unsafe.AsPointer(ref this)); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((ID3D11Texture1D*)Unsafe.AsPointer(ref this)); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(6)] + public void GetDevice(ID3D11Device* ppDevice) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[6]))((ID3D11Texture1D*)Unsafe.AsPointer(ref this), ppDevice); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((ID3D11Texture1D*)Unsafe.AsPointer(ref this), ppDevice); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(7)] + public HResult GetPrivateData(Guid* guid, uint* pDataSize, void* pData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[7]))((ID3D11Texture1D*)Unsafe.AsPointer(ref this), guid, pDataSize, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((ID3D11Texture1D*)Unsafe.AsPointer(ref this), guid, pDataSize, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(8)] + public HResult SetPrivateData(Guid* guid, uint DataSize, void* pData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[8]))((ID3D11Texture1D*)Unsafe.AsPointer(ref this), guid, DataSize, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[8]))((ID3D11Texture1D*)Unsafe.AsPointer(ref this), guid, DataSize, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(9)] + public HResult SetPrivateDataInterface(Guid* guid, IUnknown* pData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[9]))((ID3D11Texture1D*)Unsafe.AsPointer(ref this), guid, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[9]))((ID3D11Texture1D*)Unsafe.AsPointer(ref this), guid, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(10)] + public void GetDesc(Texture1DDescription* pDesc) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[10]))((ID3D11Texture1D*)Unsafe.AsPointer(ref this), pDesc); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[10]))((ID3D11Texture1D*)Unsafe.AsPointer(ref this), pDesc); +#endif + } + + public interface Interface : ID3D11Resource.Interface + { + } +} + +/// +/// ID3D11Texture2D +[Guid("6f15aaf2-d208-4e89-9ab4-489535d34f9c")] +[NativeTypeName("struct ID3D11Texture2D : ID3D11Resource")] +[NativeInheritance("ID3D11Resource")] +public unsafe partial struct ID3D11Texture2D : ID3D11Texture2D.Interface +{ + public static ref readonly Guid IID_ID3D11Texture2D + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0xF2, 0xAA, 0x15, 0x6F, + 0x08, 0xD2, + 0x89, 0x4E, + 0x9A, + 0xB4, + 0x48, + 0x95, + 0x35, + 0xD3, + 0x4F, + 0x9C + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_ID3D11Texture2D)); + + public void** lpVtbl; + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(0)] + public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(1)] + [return: NativeTypeName("ULONG")] + public uint AddRef() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(2)] + [return: NativeTypeName("ULONG")] + public uint Release() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(3)] + public void GetType(ResourceDimension* pResourceDimension) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[3]))((ID3D11Texture2D*)Unsafe.AsPointer(ref this), pResourceDimension); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((ID3D11Texture2D*)Unsafe.AsPointer(ref this), pResourceDimension); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public void SetEvictionPriority(uint EvictionPriority) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[4]))((ID3D11Texture2D*)Unsafe.AsPointer(ref this), EvictionPriority); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((ID3D11Texture2D*)Unsafe.AsPointer(ref this), EvictionPriority); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(5)] + public uint GetEvictionPriority() + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[5]))((ID3D11Texture2D*)Unsafe.AsPointer(ref this)); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((ID3D11Texture2D*)Unsafe.AsPointer(ref this)); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(6)] + public void GetDevice(ID3D11Device* ppDevice) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[6]))((ID3D11Texture2D*)Unsafe.AsPointer(ref this), ppDevice); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((ID3D11Texture2D*)Unsafe.AsPointer(ref this), ppDevice); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(7)] + public HResult GetPrivateData(Guid* guid, uint* pDataSize, void* pData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[7]))((ID3D11Texture2D*)Unsafe.AsPointer(ref this), guid, pDataSize, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((ID3D11Texture2D*)Unsafe.AsPointer(ref this), guid, pDataSize, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(8)] + public HResult SetPrivateData(Guid* guid, uint DataSize, void* pData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[8]))((ID3D11Texture2D*)Unsafe.AsPointer(ref this), guid, DataSize, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[8]))((ID3D11Texture2D*)Unsafe.AsPointer(ref this), guid, DataSize, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(9)] + public HResult SetPrivateDataInterface(Guid* guid, IUnknown* pData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[9]))((ID3D11Texture2D*)Unsafe.AsPointer(ref this), guid, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[9]))((ID3D11Texture2D*)Unsafe.AsPointer(ref this), guid, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(10)] + public void GetDesc(Texture2DDescription* pDesc) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[10]))((ID3D11Texture2D*)Unsafe.AsPointer(ref this), pDesc); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[10]))((ID3D11Texture2D*)Unsafe.AsPointer(ref this), pDesc); +#endif + } + + public interface Interface : ID3D11Resource.Interface + { + } +} + +/// +/// ID3D11Texture3D +[Guid("037e866e-f56d-4357-a8af-9dabbe6e250e")] +[NativeTypeName("struct ID3D11Texture3D : ID3D11Resource")] +[NativeInheritance("ID3D11Resource")] +public unsafe partial struct ID3D11Texture3D : ID3D11Texture3D.Interface +{ + public static ref readonly Guid IID_ID3D11Texture3D + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x6E, 0x86, 0x7E, 0x03, + 0x6D, 0xF5, + 0x57, 0x43, + 0xA8, + 0xAF, + 0x9D, + 0xAB, + 0xBE, + 0x6E, + 0x25, + 0x0E + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_ID3D11Texture3D)); + + public void** lpVtbl; + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(0)] + public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(1)] + [return: NativeTypeName("ULONG")] + public uint AddRef() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(2)] + [return: NativeTypeName("ULONG")] + public uint Release() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(3)] + public void GetType(ResourceDimension* pResourceDimension) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[3]))((ID3D11Texture3D*)Unsafe.AsPointer(ref this), pResourceDimension); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((ID3D11Texture3D*)Unsafe.AsPointer(ref this), pResourceDimension); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public void SetEvictionPriority(uint EvictionPriority) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[4]))((ID3D11Texture3D*)Unsafe.AsPointer(ref this), EvictionPriority); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((ID3D11Texture3D*)Unsafe.AsPointer(ref this), EvictionPriority); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(5)] + public uint GetEvictionPriority() + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[5]))((ID3D11Texture3D*)Unsafe.AsPointer(ref this)); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((ID3D11Texture3D*)Unsafe.AsPointer(ref this)); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(6)] + public void GetDevice(ID3D11Device* ppDevice) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[6]))((ID3D11Texture3D*)Unsafe.AsPointer(ref this), ppDevice); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((ID3D11Texture3D*)Unsafe.AsPointer(ref this), ppDevice); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(7)] + public HResult GetPrivateData(Guid* guid, uint* pDataSize, void* pData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[7]))((ID3D11Texture3D*)Unsafe.AsPointer(ref this), guid, pDataSize, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((ID3D11Texture3D*)Unsafe.AsPointer(ref this), guid, pDataSize, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(8)] + public HResult SetPrivateData(Guid* guid, uint DataSize, void* pData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[8]))((ID3D11Texture3D*)Unsafe.AsPointer(ref this), guid, DataSize, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[8]))((ID3D11Texture3D*)Unsafe.AsPointer(ref this), guid, DataSize, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(9)] + public HResult SetPrivateDataInterface(Guid* guid, IUnknown* pData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[9]))((ID3D11Texture3D*)Unsafe.AsPointer(ref this), guid, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[9]))((ID3D11Texture3D*)Unsafe.AsPointer(ref this), guid, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(10)] + public void GetDesc(Texture3DDescription* pDesc) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[10]))((ID3D11Texture3D*)Unsafe.AsPointer(ref this), pDesc); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[10]))((ID3D11Texture3D*)Unsafe.AsPointer(ref this), pDesc); +#endif + } + + public interface Interface : ID3D11Resource.Interface + { + } +} + +/// +/// ID3D11View +[Guid("839d1216-bb2e-412b-b7f4-a9dbebe08ed1")] +[NativeTypeName("struct ID3D11View : ID3D11DeviceChild")] +[NativeInheritance("ID3D11DeviceChild")] +public unsafe partial struct ID3D11View : ID3D11View.Interface +{ + public static ref readonly Guid IID_ID3D11View + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x16, 0x12, 0x9D, 0x83, + 0x2E, 0xBB, + 0x2B, 0x41, + 0xB7, + 0xF4, + 0xA9, + 0xDB, + 0xEB, + 0xE0, + 0x8E, + 0xD1 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_ID3D11View)); + + public void** lpVtbl; + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(0)] + public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(1)] + [return: NativeTypeName("ULONG")] + public uint AddRef() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(2)] + [return: NativeTypeName("ULONG")] + public uint Release() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(3)] + public void GetDevice(ID3D11Device* ppDevice) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[3]))((ID3D11View*)Unsafe.AsPointer(ref this), ppDevice); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((ID3D11View*)Unsafe.AsPointer(ref this), ppDevice); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public HResult GetPrivateData(Guid* guid, uint* pDataSize, void* pData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[4]))((ID3D11View*)Unsafe.AsPointer(ref this), guid, pDataSize, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((ID3D11View*)Unsafe.AsPointer(ref this), guid, pDataSize, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(5)] + public HResult SetPrivateData(Guid* guid, uint DataSize, void* pData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[5]))((ID3D11View*)Unsafe.AsPointer(ref this), guid, DataSize, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((ID3D11View*)Unsafe.AsPointer(ref this), guid, DataSize, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(6)] + public HResult SetPrivateDataInterface(Guid* guid, IUnknown* pData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[6]))((ID3D11View*)Unsafe.AsPointer(ref this), guid, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((ID3D11View*)Unsafe.AsPointer(ref this), guid, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(7)] + public void GetResource(ID3D11Resource* ppResource) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[7]))((ID3D11View*)Unsafe.AsPointer(ref this), ppResource); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((ID3D11View*)Unsafe.AsPointer(ref this), ppResource); +#endif + } + + public interface Interface : ID3D11DeviceChild.Interface + { + } +} + +/// +/// ID3D11ShaderResourceView +[Guid("b0e06fe0-8192-4e1a-b1ca-36d7414710b2")] +[NativeTypeName("struct ID3D11ShaderResourceView : ID3D11View")] +[NativeInheritance("ID3D11View")] +public unsafe partial struct ID3D11ShaderResourceView : ID3D11ShaderResourceView.Interface +{ + public static ref readonly Guid IID_ID3D11ShaderResourceView + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0xE0, 0x6F, 0xE0, 0xB0, + 0x92, 0x81, + 0x1A, 0x4E, + 0xB1, + 0xCA, + 0x36, + 0xD7, + 0x41, + 0x47, + 0x10, + 0xB2 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_ID3D11ShaderResourceView)); + + public void** lpVtbl; + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(0)] + public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(1)] + [return: NativeTypeName("ULONG")] + public uint AddRef() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(2)] + [return: NativeTypeName("ULONG")] + public uint Release() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(3)] + public void GetResource(ID3D11Resource* ppResource) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[3]))((ID3D11ShaderResourceView*)Unsafe.AsPointer(ref this), ppResource); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((ID3D11ShaderResourceView*)Unsafe.AsPointer(ref this), ppResource); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public void GetDevice(ID3D11Device* ppDevice) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[4]))((ID3D11ShaderResourceView*)Unsafe.AsPointer(ref this), ppDevice); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((ID3D11ShaderResourceView*)Unsafe.AsPointer(ref this), ppDevice); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(5)] + public HResult GetPrivateData(Guid* guid, uint* pDataSize, void* pData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[5]))((ID3D11ShaderResourceView*)Unsafe.AsPointer(ref this), guid, pDataSize, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((ID3D11ShaderResourceView*)Unsafe.AsPointer(ref this), guid, pDataSize, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(6)] + public HResult SetPrivateData(Guid* guid, uint DataSize, void* pData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[6]))((ID3D11ShaderResourceView*)Unsafe.AsPointer(ref this), guid, DataSize, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((ID3D11ShaderResourceView*)Unsafe.AsPointer(ref this), guid, DataSize, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(7)] + public HResult SetPrivateDataInterface(Guid* guid, IUnknown* pData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[7]))((ID3D11ShaderResourceView*)Unsafe.AsPointer(ref this), guid, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((ID3D11ShaderResourceView*)Unsafe.AsPointer(ref this), guid, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(8)] + public void GetDesc(ShaderResourceViewDescription* pDesc) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[8]))((ID3D11ShaderResourceView*)Unsafe.AsPointer(ref this), pDesc); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[8]))((ID3D11ShaderResourceView*)Unsafe.AsPointer(ref this), pDesc); +#endif + } + + public interface Interface : ID3D11View.Interface + { + } +} + +/// +/// ID3D11RenderTargetView +[Guid("dfdba067-0b8d-4865-875b-d7b4516cc164")] +[NativeTypeName("struct ID3D11RenderTargetView : ID3D11View")] +[NativeInheritance("ID3D11View")] +public unsafe partial struct ID3D11RenderTargetView : ID3D11RenderTargetView.Interface +{ + public static ref readonly Guid IID_ID3D11RenderTargetView + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x67, 0xA0, 0xDB, 0xDF, + 0x8D, 0x0B, + 0x65, 0x48, + 0x87, + 0x5B, + 0xD7, + 0xB4, + 0x51, + 0x6C, + 0xC1, + 0x64 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_ID3D11RenderTargetView)); + + public void** lpVtbl; + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(0)] + public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(1)] + [return: NativeTypeName("ULONG")] + public uint AddRef() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(2)] + [return: NativeTypeName("ULONG")] + public uint Release() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(3)] + public void GetResource(ID3D11Resource* ppResource) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[3]))((ID3D11RenderTargetView*)Unsafe.AsPointer(ref this), ppResource); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((ID3D11RenderTargetView*)Unsafe.AsPointer(ref this), ppResource); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public void GetDevice(ID3D11Device* ppDevice) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[4]))((ID3D11RenderTargetView*)Unsafe.AsPointer(ref this), ppDevice); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((ID3D11RenderTargetView*)Unsafe.AsPointer(ref this), ppDevice); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(5)] + public HResult GetPrivateData(Guid* guid, uint* pDataSize, void* pData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[5]))((ID3D11RenderTargetView*)Unsafe.AsPointer(ref this), guid, pDataSize, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((ID3D11RenderTargetView*)Unsafe.AsPointer(ref this), guid, pDataSize, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(6)] + public HResult SetPrivateData(Guid* guid, uint DataSize, void* pData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[6]))((ID3D11RenderTargetView*)Unsafe.AsPointer(ref this), guid, DataSize, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((ID3D11RenderTargetView*)Unsafe.AsPointer(ref this), guid, DataSize, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(7)] + public HResult SetPrivateDataInterface(Guid* guid, IUnknown* pData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[7]))((ID3D11RenderTargetView*)Unsafe.AsPointer(ref this), guid, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((ID3D11RenderTargetView*)Unsafe.AsPointer(ref this), guid, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(8)] + public void GetDesc(RenderTargetViewDescription* pDesc) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[8]))((ID3D11RenderTargetView*)Unsafe.AsPointer(ref this), pDesc); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[8]))((ID3D11RenderTargetView*)Unsafe.AsPointer(ref this), pDesc); +#endif + } + + public interface Interface : ID3D11View.Interface + { + } +} + +/// +/// ID3D11DepthStencilView +[Guid("9fdac92a-1876-48c3-afad-25b94f84a9b6")] +[NativeTypeName("struct ID3D11DepthStencilView : ID3D11View")] +[NativeInheritance("ID3D11View")] +public unsafe partial struct ID3D11DepthStencilView : ID3D11DepthStencilView.Interface +{ + public static ref readonly Guid IID_ID3D11DepthStencilView + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x2A, 0xC9, 0xDA, 0x9F, + 0x76, 0x18, + 0xC3, 0x48, + 0xAF, + 0xAD, + 0x25, + 0xB9, + 0x4F, + 0x84, + 0xA9, + 0xB6 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_ID3D11DepthStencilView)); + + public void** lpVtbl; + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(0)] + public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(1)] + [return: NativeTypeName("ULONG")] + public uint AddRef() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(2)] + [return: NativeTypeName("ULONG")] + public uint Release() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(3)] + public void GetResource(ID3D11Resource* ppResource) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[3]))((ID3D11DepthStencilView*)Unsafe.AsPointer(ref this), ppResource); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((ID3D11DepthStencilView*)Unsafe.AsPointer(ref this), ppResource); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public void GetDevice(ID3D11Device* ppDevice) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[4]))((ID3D11DepthStencilView*)Unsafe.AsPointer(ref this), ppDevice); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((ID3D11DepthStencilView*)Unsafe.AsPointer(ref this), ppDevice); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(5)] + public HResult GetPrivateData(Guid* guid, uint* pDataSize, void* pData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[5]))((ID3D11DepthStencilView*)Unsafe.AsPointer(ref this), guid, pDataSize, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((ID3D11DepthStencilView*)Unsafe.AsPointer(ref this), guid, pDataSize, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(6)] + public HResult SetPrivateData(Guid* guid, uint DataSize, void* pData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[6]))((ID3D11DepthStencilView*)Unsafe.AsPointer(ref this), guid, DataSize, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((ID3D11DepthStencilView*)Unsafe.AsPointer(ref this), guid, DataSize, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(7)] + public HResult SetPrivateDataInterface(Guid* guid, IUnknown* pData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[7]))((ID3D11DepthStencilView*)Unsafe.AsPointer(ref this), guid, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((ID3D11DepthStencilView*)Unsafe.AsPointer(ref this), guid, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(8)] + public void GetDesc(DepthStencilViewDescription* pDesc) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[8]))((ID3D11DepthStencilView*)Unsafe.AsPointer(ref this), pDesc); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[8]))((ID3D11DepthStencilView*)Unsafe.AsPointer(ref this), pDesc); +#endif + } + + public interface Interface : ID3D11View.Interface + { + } +} + +/// +/// ID3D11UnorderedAccessView +[Guid("28acf509-7f5c-48f6-8611-f316010a6380")] +[NativeTypeName("struct ID3D11UnorderedAccessView : ID3D11View")] +[NativeInheritance("ID3D11View")] +public unsafe partial struct ID3D11UnorderedAccessView : ID3D11UnorderedAccessView.Interface +{ + public static ref readonly Guid IID_ID3D11UnorderedAccessView + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x09, 0xF5, 0xAC, 0x28, + 0x5C, 0x7F, + 0xF6, 0x48, + 0x86, + 0x11, + 0xF3, + 0x16, + 0x01, + 0x0A, + 0x63, + 0x80 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_ID3D11UnorderedAccessView)); + + public void** lpVtbl; + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(0)] + public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(1)] + [return: NativeTypeName("ULONG")] + public uint AddRef() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(2)] + [return: NativeTypeName("ULONG")] + public uint Release() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(3)] + public void GetResource(ID3D11Resource* ppResource) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[3]))((ID3D11UnorderedAccessView*)Unsafe.AsPointer(ref this), ppResource); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((ID3D11UnorderedAccessView*)Unsafe.AsPointer(ref this), ppResource); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public void GetDevice(ID3D11Device* ppDevice) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[4]))((ID3D11UnorderedAccessView*)Unsafe.AsPointer(ref this), ppDevice); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((ID3D11UnorderedAccessView*)Unsafe.AsPointer(ref this), ppDevice); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(5)] + public HResult GetPrivateData(Guid* guid, uint* pDataSize, void* pData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[5]))((ID3D11UnorderedAccessView*)Unsafe.AsPointer(ref this), guid, pDataSize, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((ID3D11UnorderedAccessView*)Unsafe.AsPointer(ref this), guid, pDataSize, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(6)] + public HResult SetPrivateData(Guid* guid, uint DataSize, void* pData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[6]))((ID3D11UnorderedAccessView*)Unsafe.AsPointer(ref this), guid, DataSize, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((ID3D11UnorderedAccessView*)Unsafe.AsPointer(ref this), guid, DataSize, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(7)] + public HResult SetPrivateDataInterface(Guid* guid, IUnknown* pData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[7]))((ID3D11UnorderedAccessView*)Unsafe.AsPointer(ref this), guid, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((ID3D11UnorderedAccessView*)Unsafe.AsPointer(ref this), guid, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(8)] + public void GetDesc(UnorderedAccessViewDescription* pDesc) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[8]))((ID3D11UnorderedAccessView*)Unsafe.AsPointer(ref this), pDesc); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[8]))((ID3D11UnorderedAccessView*)Unsafe.AsPointer(ref this), pDesc); +#endif + } + + public interface Interface : ID3D11View.Interface + { + } +} + +/// +/// ID3D11VertexShader +[Guid("3b301d64-d678-4289-8897-22f8928b72f3")] +[NativeTypeName("struct ID3D11VertexShader : ID3D11DeviceChild")] +[NativeInheritance("ID3D11DeviceChild")] +public unsafe partial struct ID3D11VertexShader : ID3D11VertexShader.Interface +{ + public static ref readonly Guid IID_ID3D11VertexShader + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x64, 0x1D, 0x30, 0x3B, + 0x78, 0xD6, + 0x89, 0x42, + 0x88, + 0x97, + 0x22, + 0xF8, + 0x92, + 0x8B, + 0x72, + 0xF3 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_ID3D11VertexShader)); + + public void** lpVtbl; + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(0)] + public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(1)] + [return: NativeTypeName("ULONG")] + public uint AddRef() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(2)] + [return: NativeTypeName("ULONG")] + public uint Release() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(3)] + public void GetDevice(ID3D11Device* ppDevice) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[3]))((ID3D11VertexShader*)Unsafe.AsPointer(ref this), ppDevice); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((ID3D11VertexShader*)Unsafe.AsPointer(ref this), ppDevice); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public HResult GetPrivateData(Guid* guid, uint* pDataSize, void* pData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[4]))((ID3D11VertexShader*)Unsafe.AsPointer(ref this), guid, pDataSize, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((ID3D11VertexShader*)Unsafe.AsPointer(ref this), guid, pDataSize, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(5)] + public HResult SetPrivateData(Guid* guid, uint DataSize, void* pData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[5]))((ID3D11VertexShader*)Unsafe.AsPointer(ref this), guid, DataSize, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((ID3D11VertexShader*)Unsafe.AsPointer(ref this), guid, DataSize, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(6)] + public HResult SetPrivateDataInterface(Guid* guid, IUnknown* pData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[6]))((ID3D11VertexShader*)Unsafe.AsPointer(ref this), guid, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((ID3D11VertexShader*)Unsafe.AsPointer(ref this), guid, pData); +#endif + } + + public interface Interface : ID3D11DeviceChild.Interface + { + } +} + +/// +/// ID3D11HullShader +[Guid("8e5c6061-628a-4c8e-8264-bbe45cb3d5dd")] +[NativeTypeName("struct ID3D11HullShader : ID3D11DeviceChild")] +[NativeInheritance("ID3D11DeviceChild")] +public unsafe partial struct ID3D11HullShader : ID3D11HullShader.Interface +{ + public static ref readonly Guid IID_ID3D11HullShader + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x61, 0x60, 0x5C, 0x8E, + 0x8A, 0x62, + 0x8E, 0x4C, + 0x82, + 0x64, + 0xBB, + 0xE4, + 0x5C, + 0xB3, + 0xD5, + 0xDD + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_ID3D11HullShader)); + + public void** lpVtbl; + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(0)] + public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(1)] + [return: NativeTypeName("ULONG")] + public uint AddRef() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(2)] + [return: NativeTypeName("ULONG")] + public uint Release() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(3)] + public void GetDevice(ID3D11Device* ppDevice) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[3]))((ID3D11HullShader*)Unsafe.AsPointer(ref this), ppDevice); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((ID3D11HullShader*)Unsafe.AsPointer(ref this), ppDevice); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public HResult GetPrivateData(Guid* guid, uint* pDataSize, void* pData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[4]))((ID3D11HullShader*)Unsafe.AsPointer(ref this), guid, pDataSize, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((ID3D11HullShader*)Unsafe.AsPointer(ref this), guid, pDataSize, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(5)] + public HResult SetPrivateData(Guid* guid, uint DataSize, void* pData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[5]))((ID3D11HullShader*)Unsafe.AsPointer(ref this), guid, DataSize, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((ID3D11HullShader*)Unsafe.AsPointer(ref this), guid, DataSize, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(6)] + public HResult SetPrivateDataInterface(Guid* guid, IUnknown* pData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[6]))((ID3D11HullShader*)Unsafe.AsPointer(ref this), guid, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((ID3D11HullShader*)Unsafe.AsPointer(ref this), guid, pData); +#endif + } + + public interface Interface : ID3D11DeviceChild.Interface + { + } +} + +/// +/// ID3D11DomainShader +[Guid("f582c508-0f36-490c-9977-31eece268cfa")] +[NativeTypeName("struct ID3D11DomainShader : ID3D11DeviceChild")] +[NativeInheritance("ID3D11DeviceChild")] +public unsafe partial struct ID3D11DomainShader : ID3D11DomainShader.Interface +{ + public static ref readonly Guid IID_ID3D11DomainShader + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x08, 0xC5, 0x82, 0xF5, + 0x36, 0x0F, + 0x0C, 0x49, + 0x99, + 0x77, + 0x31, + 0xEE, + 0xCE, + 0x26, + 0x8C, + 0xFA + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_ID3D11DomainShader)); + + public void** lpVtbl; + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(0)] + public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(1)] + [return: NativeTypeName("ULONG")] + public uint AddRef() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(2)] + [return: NativeTypeName("ULONG")] + public uint Release() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(3)] + public void GetDevice(ID3D11Device* ppDevice) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[3]))((ID3D11DomainShader*)Unsafe.AsPointer(ref this), ppDevice); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((ID3D11DomainShader*)Unsafe.AsPointer(ref this), ppDevice); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public HResult GetPrivateData(Guid* guid, uint* pDataSize, void* pData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[4]))((ID3D11DomainShader*)Unsafe.AsPointer(ref this), guid, pDataSize, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((ID3D11DomainShader*)Unsafe.AsPointer(ref this), guid, pDataSize, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(5)] + public HResult SetPrivateData(Guid* guid, uint DataSize, void* pData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[5]))((ID3D11DomainShader*)Unsafe.AsPointer(ref this), guid, DataSize, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((ID3D11DomainShader*)Unsafe.AsPointer(ref this), guid, DataSize, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(6)] + public HResult SetPrivateDataInterface(Guid* guid, IUnknown* pData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[6]))((ID3D11DomainShader*)Unsafe.AsPointer(ref this), guid, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((ID3D11DomainShader*)Unsafe.AsPointer(ref this), guid, pData); +#endif + } + + public interface Interface : ID3D11DeviceChild.Interface + { + } +} + +/// +/// ID3D11GeometryShader +[Guid("38325b96-effb-4022-ba02-2e795b70275c")] +[NativeTypeName("struct ID3D11GeometryShader : ID3D11DeviceChild")] +[NativeInheritance("ID3D11DeviceChild")] +public unsafe partial struct ID3D11GeometryShader : ID3D11GeometryShader.Interface +{ + public static ref readonly Guid IID_ID3D11GeometryShader + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x96, 0x5B, 0x32, 0x38, + 0xFB, 0xEF, + 0x22, 0x40, + 0xBA, + 0x02, + 0x2E, + 0x79, + 0x5B, + 0x70, + 0x27, + 0x5C + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_ID3D11GeometryShader)); + + public void** lpVtbl; + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(0)] + public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(1)] + [return: NativeTypeName("ULONG")] + public uint AddRef() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(2)] + [return: NativeTypeName("ULONG")] + public uint Release() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(3)] + public void GetDevice(ID3D11Device* ppDevice) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[3]))((ID3D11GeometryShader*)Unsafe.AsPointer(ref this), ppDevice); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((ID3D11GeometryShader*)Unsafe.AsPointer(ref this), ppDevice); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public HResult GetPrivateData(Guid* guid, uint* pDataSize, void* pData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[4]))((ID3D11GeometryShader*)Unsafe.AsPointer(ref this), guid, pDataSize, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((ID3D11GeometryShader*)Unsafe.AsPointer(ref this), guid, pDataSize, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(5)] + public HResult SetPrivateData(Guid* guid, uint DataSize, void* pData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[5]))((ID3D11GeometryShader*)Unsafe.AsPointer(ref this), guid, DataSize, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((ID3D11GeometryShader*)Unsafe.AsPointer(ref this), guid, DataSize, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(6)] + public HResult SetPrivateDataInterface(Guid* guid, IUnknown* pData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[6]))((ID3D11GeometryShader*)Unsafe.AsPointer(ref this), guid, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((ID3D11GeometryShader*)Unsafe.AsPointer(ref this), guid, pData); +#endif + } + + public interface Interface : ID3D11DeviceChild.Interface + { + } +} + +/// +/// ID3D11PixelShader +[Guid("ea82e40d-51dc-4f33-93d4-db7c9125ae8c")] +[NativeTypeName("struct ID3D11PixelShader : ID3D11DeviceChild")] +[NativeInheritance("ID3D11DeviceChild")] +public unsafe partial struct ID3D11PixelShader : ID3D11PixelShader.Interface +{ + public static ref readonly Guid IID_ID3D11PixelShader + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x0D, 0xE4, 0x82, 0xEA, + 0xDC, 0x51, + 0x33, 0x4F, + 0x93, + 0xD4, + 0xDB, + 0x7C, + 0x91, + 0x25, + 0xAE, + 0x8C + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_ID3D11PixelShader)); + + public void** lpVtbl; + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(0)] + public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(1)] + [return: NativeTypeName("ULONG")] + public uint AddRef() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(2)] + [return: NativeTypeName("ULONG")] + public uint Release() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(3)] + public void GetDevice(ID3D11Device* ppDevice) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[3]))((ID3D11PixelShader*)Unsafe.AsPointer(ref this), ppDevice); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((ID3D11PixelShader*)Unsafe.AsPointer(ref this), ppDevice); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public HResult GetPrivateData(Guid* guid, uint* pDataSize, void* pData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[4]))((ID3D11PixelShader*)Unsafe.AsPointer(ref this), guid, pDataSize, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((ID3D11PixelShader*)Unsafe.AsPointer(ref this), guid, pDataSize, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(5)] + public HResult SetPrivateData(Guid* guid, uint DataSize, void* pData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[5]))((ID3D11PixelShader*)Unsafe.AsPointer(ref this), guid, DataSize, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((ID3D11PixelShader*)Unsafe.AsPointer(ref this), guid, DataSize, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(6)] + public HResult SetPrivateDataInterface(Guid* guid, IUnknown* pData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[6]))((ID3D11PixelShader*)Unsafe.AsPointer(ref this), guid, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((ID3D11PixelShader*)Unsafe.AsPointer(ref this), guid, pData); +#endif + } + + public interface Interface : ID3D11DeviceChild.Interface + { + } +} + +/// +/// ID3D11ComputeShader +[Guid("4f5b196e-c2bd-495e-bd01-1fded38e4969")] +[NativeTypeName("struct ID3D11ComputeShader : ID3D11DeviceChild")] +[NativeInheritance("ID3D11DeviceChild")] +public unsafe partial struct ID3D11ComputeShader : ID3D11ComputeShader.Interface +{ + public static ref readonly Guid IID_ID3D11ComputeShader + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x6E, 0x19, 0x5B, 0x4F, + 0xBD, 0xC2, + 0x5E, 0x49, + 0xBD, + 0x01, + 0x1F, + 0xDE, + 0xD3, + 0x8E, + 0x49, + 0x69 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_ID3D11ComputeShader)); + + public void** lpVtbl; + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(0)] + public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(1)] + [return: NativeTypeName("ULONG")] + public uint AddRef() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(2)] + [return: NativeTypeName("ULONG")] + public uint Release() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(3)] + public void GetDevice(ID3D11Device* ppDevice) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[3]))((ID3D11ComputeShader*)Unsafe.AsPointer(ref this), ppDevice); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((ID3D11ComputeShader*)Unsafe.AsPointer(ref this), ppDevice); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public HResult GetPrivateData(Guid* guid, uint* pDataSize, void* pData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[4]))((ID3D11ComputeShader*)Unsafe.AsPointer(ref this), guid, pDataSize, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((ID3D11ComputeShader*)Unsafe.AsPointer(ref this), guid, pDataSize, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(5)] + public HResult SetPrivateData(Guid* guid, uint DataSize, void* pData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[5]))((ID3D11ComputeShader*)Unsafe.AsPointer(ref this), guid, DataSize, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((ID3D11ComputeShader*)Unsafe.AsPointer(ref this), guid, DataSize, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(6)] + public HResult SetPrivateDataInterface(Guid* guid, IUnknown* pData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[6]))((ID3D11ComputeShader*)Unsafe.AsPointer(ref this), guid, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((ID3D11ComputeShader*)Unsafe.AsPointer(ref this), guid, pData); +#endif + } + + public interface Interface : ID3D11DeviceChild.Interface + { + } +} + +/// +/// ID3D11InputLayout +[Guid("e4819ddc-4cf0-4025-bd26-5de82a3e07b7")] +[NativeTypeName("struct ID3D11InputLayout : ID3D11DeviceChild")] +[NativeInheritance("ID3D11DeviceChild")] +public unsafe partial struct ID3D11InputLayout : ID3D11InputLayout.Interface +{ + public static ref readonly Guid IID_ID3D11InputLayout + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0xDC, 0x9D, 0x81, 0xE4, + 0xF0, 0x4C, + 0x25, 0x40, + 0xBD, + 0x26, + 0x5D, + 0xE8, + 0x2A, + 0x3E, + 0x07, + 0xB7 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_ID3D11InputLayout)); + + public void** lpVtbl; + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(0)] + public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(1)] + [return: NativeTypeName("ULONG")] + public uint AddRef() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(2)] + [return: NativeTypeName("ULONG")] + public uint Release() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(3)] + public void GetDevice(ID3D11Device* ppDevice) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[3]))((ID3D11InputLayout*)Unsafe.AsPointer(ref this), ppDevice); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((ID3D11InputLayout*)Unsafe.AsPointer(ref this), ppDevice); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public HResult GetPrivateData(Guid* guid, uint* pDataSize, void* pData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[4]))((ID3D11InputLayout*)Unsafe.AsPointer(ref this), guid, pDataSize, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((ID3D11InputLayout*)Unsafe.AsPointer(ref this), guid, pDataSize, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(5)] + public HResult SetPrivateData(Guid* guid, uint DataSize, void* pData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[5]))((ID3D11InputLayout*)Unsafe.AsPointer(ref this), guid, DataSize, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((ID3D11InputLayout*)Unsafe.AsPointer(ref this), guid, DataSize, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(6)] + public HResult SetPrivateDataInterface(Guid* guid, IUnknown* pData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[6]))((ID3D11InputLayout*)Unsafe.AsPointer(ref this), guid, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((ID3D11InputLayout*)Unsafe.AsPointer(ref this), guid, pData); +#endif + } + + public interface Interface : ID3D11DeviceChild.Interface + { + } +} + +/// +/// ID3D11SamplerState +[Guid("da6fea51-564c-4487-9810-f0d0f9b4e3a5")] +[NativeTypeName("struct ID3D11SamplerState : ID3D11DeviceChild")] +[NativeInheritance("ID3D11DeviceChild")] +public unsafe partial struct ID3D11SamplerState : ID3D11SamplerState.Interface +{ + public static ref readonly Guid IID_ID3D11SamplerState + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x51, 0xEA, 0x6F, 0xDA, + 0x4C, 0x56, + 0x87, 0x44, + 0x98, + 0x10, + 0xF0, + 0xD0, + 0xF9, + 0xB4, + 0xE3, + 0xA5 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_ID3D11SamplerState)); + + public void** lpVtbl; + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(0)] + public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(1)] + [return: NativeTypeName("ULONG")] + public uint AddRef() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(2)] + [return: NativeTypeName("ULONG")] + public uint Release() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(3)] + public void GetDevice(ID3D11Device* ppDevice) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[3]))((ID3D11SamplerState*)Unsafe.AsPointer(ref this), ppDevice); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((ID3D11SamplerState*)Unsafe.AsPointer(ref this), ppDevice); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public HResult GetPrivateData(Guid* guid, uint* pDataSize, void* pData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[4]))((ID3D11SamplerState*)Unsafe.AsPointer(ref this), guid, pDataSize, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((ID3D11SamplerState*)Unsafe.AsPointer(ref this), guid, pDataSize, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(5)] + public HResult SetPrivateData(Guid* guid, uint DataSize, void* pData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[5]))((ID3D11SamplerState*)Unsafe.AsPointer(ref this), guid, DataSize, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((ID3D11SamplerState*)Unsafe.AsPointer(ref this), guid, DataSize, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(6)] + public HResult SetPrivateDataInterface(Guid* guid, IUnknown* pData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[6]))((ID3D11SamplerState*)Unsafe.AsPointer(ref this), guid, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((ID3D11SamplerState*)Unsafe.AsPointer(ref this), guid, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(7)] + public void GetDesc(SamplerDescription* pDesc) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[7]))((ID3D11SamplerState*)Unsafe.AsPointer(ref this), pDesc); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((ID3D11SamplerState*)Unsafe.AsPointer(ref this), pDesc); +#endif + } + + public interface Interface : ID3D11DeviceChild.Interface + { + } +} + +/// +/// ID3D11Asynchronous +[Guid("4b35d0cd-1e15-4258-9c98-1b1333f6dd3b")] +[NativeTypeName("struct ID3D11Asynchronous : ID3D11DeviceChild")] +[NativeInheritance("ID3D11DeviceChild")] +public unsafe partial struct ID3D11Asynchronous : ID3D11Asynchronous.Interface +{ + public static ref readonly Guid IID_ID3D11Asynchronous + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0xCD, 0xD0, 0x35, 0x4B, + 0x15, 0x1E, + 0x58, 0x42, + 0x9C, + 0x98, + 0x1B, + 0x13, + 0x33, + 0xF6, + 0xDD, + 0x3B + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_ID3D11Asynchronous)); + + public void** lpVtbl; + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(0)] + public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(1)] + [return: NativeTypeName("ULONG")] + public uint AddRef() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(2)] + [return: NativeTypeName("ULONG")] + public uint Release() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(3)] + public void GetDevice(ID3D11Device* ppDevice) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[3]))((ID3D11Asynchronous*)Unsafe.AsPointer(ref this), ppDevice); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((ID3D11Asynchronous*)Unsafe.AsPointer(ref this), ppDevice); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public HResult GetPrivateData(Guid* guid, uint* pDataSize, void* pData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[4]))((ID3D11Asynchronous*)Unsafe.AsPointer(ref this), guid, pDataSize, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((ID3D11Asynchronous*)Unsafe.AsPointer(ref this), guid, pDataSize, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(5)] + public HResult SetPrivateData(Guid* guid, uint DataSize, void* pData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[5]))((ID3D11Asynchronous*)Unsafe.AsPointer(ref this), guid, DataSize, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((ID3D11Asynchronous*)Unsafe.AsPointer(ref this), guid, DataSize, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(6)] + public HResult SetPrivateDataInterface(Guid* guid, IUnknown* pData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[6]))((ID3D11Asynchronous*)Unsafe.AsPointer(ref this), guid, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((ID3D11Asynchronous*)Unsafe.AsPointer(ref this), guid, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(7)] + public uint GetDataSize() + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[7]))((ID3D11Asynchronous*)Unsafe.AsPointer(ref this)); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((ID3D11Asynchronous*)Unsafe.AsPointer(ref this)); +#endif + } + + public interface Interface : ID3D11DeviceChild.Interface + { + } +} + +/// +/// ID3D11Query +[Guid("d6c00747-87b7-425e-b84d-44d108560afd")] +[NativeTypeName("struct ID3D11Query : ID3D11Asynchronous")] +[NativeInheritance("ID3D11Asynchronous")] +public unsafe partial struct ID3D11Query : ID3D11Query.Interface +{ + public static ref readonly Guid IID_ID3D11Query + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x47, 0x07, 0xC0, 0xD6, + 0xB7, 0x87, + 0x5E, 0x42, + 0xB8, + 0x4D, + 0x44, + 0xD1, + 0x08, + 0x56, + 0x0A, + 0xFD + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_ID3D11Query)); + + public void** lpVtbl; + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(0)] + public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(1)] + [return: NativeTypeName("ULONG")] + public uint AddRef() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(2)] + [return: NativeTypeName("ULONG")] + public uint Release() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(3)] + public uint GetDataSize() + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[3]))((ID3D11Query*)Unsafe.AsPointer(ref this)); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((ID3D11Query*)Unsafe.AsPointer(ref this)); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public void GetDevice(ID3D11Device* ppDevice) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[4]))((ID3D11Query*)Unsafe.AsPointer(ref this), ppDevice); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((ID3D11Query*)Unsafe.AsPointer(ref this), ppDevice); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(5)] + public HResult GetPrivateData(Guid* guid, uint* pDataSize, void* pData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[5]))((ID3D11Query*)Unsafe.AsPointer(ref this), guid, pDataSize, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((ID3D11Query*)Unsafe.AsPointer(ref this), guid, pDataSize, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(6)] + public HResult SetPrivateData(Guid* guid, uint DataSize, void* pData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[6]))((ID3D11Query*)Unsafe.AsPointer(ref this), guid, DataSize, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((ID3D11Query*)Unsafe.AsPointer(ref this), guid, DataSize, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(7)] + public HResult SetPrivateDataInterface(Guid* guid, IUnknown* pData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[7]))((ID3D11Query*)Unsafe.AsPointer(ref this), guid, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((ID3D11Query*)Unsafe.AsPointer(ref this), guid, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(8)] + public void GetDesc(QueryDescription* pDesc) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[8]))((ID3D11Query*)Unsafe.AsPointer(ref this), pDesc); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[8]))((ID3D11Query*)Unsafe.AsPointer(ref this), pDesc); +#endif + } + + public interface Interface : ID3D11Asynchronous.Interface + { + } +} + +/// +/// ID3D11Predicate +[Guid("9eb576dd-9f77-4d86-81aa-8bab5fe490e2")] +[NativeTypeName("struct ID3D11Predicate : ID3D11Query")] +[NativeInheritance("ID3D11Query")] +public unsafe partial struct ID3D11Predicate : ID3D11Predicate.Interface +{ + public static ref readonly Guid IID_ID3D11Predicate + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0xDD, 0x76, 0xB5, 0x9E, + 0x77, 0x9F, + 0x86, 0x4D, + 0x81, + 0xAA, + 0x8B, + 0xAB, + 0x5F, + 0xE4, + 0x90, + 0xE2 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_ID3D11Predicate)); + + public void** lpVtbl; + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(0)] + public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(1)] + [return: NativeTypeName("ULONG")] + public uint AddRef() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(2)] + [return: NativeTypeName("ULONG")] + public uint Release() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(3)] + public void GetDesc(QueryDescription* pDesc) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[3]))((ID3D11Predicate*)Unsafe.AsPointer(ref this), pDesc); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((ID3D11Predicate*)Unsafe.AsPointer(ref this), pDesc); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public uint GetDataSize() + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[4]))((ID3D11Predicate*)Unsafe.AsPointer(ref this)); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((ID3D11Predicate*)Unsafe.AsPointer(ref this)); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(5)] + public void GetDevice(ID3D11Device* ppDevice) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[5]))((ID3D11Predicate*)Unsafe.AsPointer(ref this), ppDevice); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((ID3D11Predicate*)Unsafe.AsPointer(ref this), ppDevice); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(6)] + public HResult GetPrivateData(Guid* guid, uint* pDataSize, void* pData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[6]))((ID3D11Predicate*)Unsafe.AsPointer(ref this), guid, pDataSize, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((ID3D11Predicate*)Unsafe.AsPointer(ref this), guid, pDataSize, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(7)] + public HResult SetPrivateData(Guid* guid, uint DataSize, void* pData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[7]))((ID3D11Predicate*)Unsafe.AsPointer(ref this), guid, DataSize, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((ID3D11Predicate*)Unsafe.AsPointer(ref this), guid, DataSize, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(8)] + public HResult SetPrivateDataInterface(Guid* guid, IUnknown* pData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[8]))((ID3D11Predicate*)Unsafe.AsPointer(ref this), guid, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[8]))((ID3D11Predicate*)Unsafe.AsPointer(ref this), guid, pData); +#endif + } + + public interface Interface : ID3D11Query.Interface + { + } +} + +/// +/// ID3D11Counter +[Guid("6e8c49fb-a371-4770-b440-29086022b741")] +[NativeTypeName("struct ID3D11Counter : ID3D11Asynchronous")] +[NativeInheritance("ID3D11Asynchronous")] +public unsafe partial struct ID3D11Counter : ID3D11Counter.Interface +{ + public static ref readonly Guid IID_ID3D11Counter + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0xFB, 0x49, 0x8C, 0x6E, + 0x71, 0xA3, + 0x70, 0x47, + 0xB4, + 0x40, + 0x29, + 0x08, + 0x60, + 0x22, + 0xB7, + 0x41 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_ID3D11Counter)); + + public void** lpVtbl; + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(0)] + public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(1)] + [return: NativeTypeName("ULONG")] + public uint AddRef() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(2)] + [return: NativeTypeName("ULONG")] + public uint Release() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(3)] + public uint GetDataSize() + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[3]))((ID3D11Counter*)Unsafe.AsPointer(ref this)); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((ID3D11Counter*)Unsafe.AsPointer(ref this)); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public void GetDevice(ID3D11Device* ppDevice) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[4]))((ID3D11Counter*)Unsafe.AsPointer(ref this), ppDevice); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((ID3D11Counter*)Unsafe.AsPointer(ref this), ppDevice); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(5)] + public HResult GetPrivateData(Guid* guid, uint* pDataSize, void* pData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[5]))((ID3D11Counter*)Unsafe.AsPointer(ref this), guid, pDataSize, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((ID3D11Counter*)Unsafe.AsPointer(ref this), guid, pDataSize, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(6)] + public HResult SetPrivateData(Guid* guid, uint DataSize, void* pData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[6]))((ID3D11Counter*)Unsafe.AsPointer(ref this), guid, DataSize, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((ID3D11Counter*)Unsafe.AsPointer(ref this), guid, DataSize, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(7)] + public HResult SetPrivateDataInterface(Guid* guid, IUnknown* pData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[7]))((ID3D11Counter*)Unsafe.AsPointer(ref this), guid, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((ID3D11Counter*)Unsafe.AsPointer(ref this), guid, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(8)] + public void GetDesc(CounterDescription* pDesc) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[8]))((ID3D11Counter*)Unsafe.AsPointer(ref this), pDesc); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[8]))((ID3D11Counter*)Unsafe.AsPointer(ref this), pDesc); +#endif + } + + public interface Interface : ID3D11Asynchronous.Interface + { + } +} + +/// +/// ID3D11ClassInstance +[Guid("a6cd7faa-b0b7-4a2f-9436-8662a65797cb")] +[NativeTypeName("struct ID3D11ClassInstance : ID3D11DeviceChild")] +[NativeInheritance("ID3D11DeviceChild")] +public unsafe partial struct ID3D11ClassInstance : ID3D11ClassInstance.Interface +{ + public static ref readonly Guid IID_ID3D11ClassInstance + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0xAA, 0x7F, 0xCD, 0xA6, + 0xB7, 0xB0, + 0x2F, 0x4A, + 0x94, + 0x36, + 0x86, + 0x62, + 0xA6, + 0x57, + 0x97, + 0xCB + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_ID3D11ClassInstance)); + + public void** lpVtbl; + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(0)] + public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(1)] + [return: NativeTypeName("ULONG")] + public uint AddRef() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(2)] + [return: NativeTypeName("ULONG")] + public uint Release() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(3)] + public void GetDevice(ID3D11Device* ppDevice) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[3]))((ID3D11ClassInstance*)Unsafe.AsPointer(ref this), ppDevice); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((ID3D11ClassInstance*)Unsafe.AsPointer(ref this), ppDevice); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public HResult GetPrivateData(Guid* guid, uint* pDataSize, void* pData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[4]))((ID3D11ClassInstance*)Unsafe.AsPointer(ref this), guid, pDataSize, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((ID3D11ClassInstance*)Unsafe.AsPointer(ref this), guid, pDataSize, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(5)] + public HResult SetPrivateData(Guid* guid, uint DataSize, void* pData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[5]))((ID3D11ClassInstance*)Unsafe.AsPointer(ref this), guid, DataSize, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((ID3D11ClassInstance*)Unsafe.AsPointer(ref this), guid, DataSize, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(6)] + public HResult SetPrivateDataInterface(Guid* guid, IUnknown* pData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[6]))((ID3D11ClassInstance*)Unsafe.AsPointer(ref this), guid, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((ID3D11ClassInstance*)Unsafe.AsPointer(ref this), guid, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(7)] + public void GetClassLinkage(ID3D11ClassLinkage* ppLinkage) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[7]))((ID3D11ClassInstance*)Unsafe.AsPointer(ref this), ppLinkage); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((ID3D11ClassInstance*)Unsafe.AsPointer(ref this), ppLinkage); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(8)] + public void GetDesc(ClassInstanceDescription* pDesc) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[8]))((ID3D11ClassInstance*)Unsafe.AsPointer(ref this), pDesc); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[8]))((ID3D11ClassInstance*)Unsafe.AsPointer(ref this), pDesc); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(9)] + public void GetInstanceName(byte* pInstanceName, nuint* pBufferLength) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[9]))((ID3D11ClassInstance*)Unsafe.AsPointer(ref this), pInstanceName, pBufferLength); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[9]))((ID3D11ClassInstance*)Unsafe.AsPointer(ref this), pInstanceName, pBufferLength); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(10)] + public void GetTypeName(byte* pTypeName, nuint* pBufferLength) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[10]))((ID3D11ClassInstance*)Unsafe.AsPointer(ref this), pTypeName, pBufferLength); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[10]))((ID3D11ClassInstance*)Unsafe.AsPointer(ref this), pTypeName, pBufferLength); +#endif + } + + public interface Interface : ID3D11DeviceChild.Interface + { + } +} + +/// +/// ID3D11ClassLinkage +[Guid("ddf57cba-9543-46e4-a12b-f207a0fe7fed")] +[NativeTypeName("struct ID3D11ClassLinkage : ID3D11DeviceChild")] +[NativeInheritance("ID3D11DeviceChild")] +public unsafe partial struct ID3D11ClassLinkage : ID3D11ClassLinkage.Interface +{ + public static ref readonly Guid IID_ID3D11ClassLinkage + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0xBA, 0x7C, 0xF5, 0xDD, + 0x43, 0x95, + 0xE4, 0x46, + 0xA1, + 0x2B, + 0xF2, + 0x07, + 0xA0, + 0xFE, + 0x7F, + 0xED + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_ID3D11ClassLinkage)); + + public void** lpVtbl; + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(0)] + public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(1)] + [return: NativeTypeName("ULONG")] + public uint AddRef() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(2)] + [return: NativeTypeName("ULONG")] + public uint Release() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(3)] + public void GetDevice(ID3D11Device* ppDevice) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[3]))((ID3D11ClassLinkage*)Unsafe.AsPointer(ref this), ppDevice); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((ID3D11ClassLinkage*)Unsafe.AsPointer(ref this), ppDevice); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public HResult GetPrivateData(Guid* guid, uint* pDataSize, void* pData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[4]))((ID3D11ClassLinkage*)Unsafe.AsPointer(ref this), guid, pDataSize, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((ID3D11ClassLinkage*)Unsafe.AsPointer(ref this), guid, pDataSize, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(5)] + public HResult SetPrivateData(Guid* guid, uint DataSize, void* pData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[5]))((ID3D11ClassLinkage*)Unsafe.AsPointer(ref this), guid, DataSize, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((ID3D11ClassLinkage*)Unsafe.AsPointer(ref this), guid, DataSize, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(6)] + public HResult SetPrivateDataInterface(Guid* guid, IUnknown* pData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[6]))((ID3D11ClassLinkage*)Unsafe.AsPointer(ref this), guid, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((ID3D11ClassLinkage*)Unsafe.AsPointer(ref this), guid, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(7)] + public HResult GetClassInstance(byte** pClassInstanceName, uint InstanceIndex, ID3D11ClassInstance** ppInstance) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[7]))((ID3D11ClassLinkage*)Unsafe.AsPointer(ref this), pClassInstanceName, InstanceIndex, ppInstance); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((ID3D11ClassLinkage*)Unsafe.AsPointer(ref this), pClassInstanceName, InstanceIndex, ppInstance); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(8)] + public HResult CreateClassInstance(byte** pClassTypeName, uint ConstantBufferOffset, uint ConstantVectorOffset, uint TextureOffset, uint SamplerOffset, ID3D11ClassInstance** ppInstance) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[8]))((ID3D11ClassLinkage*)Unsafe.AsPointer(ref this), pClassTypeName, ConstantBufferOffset, ConstantVectorOffset, TextureOffset, SamplerOffset, ppInstance); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[8]))((ID3D11ClassLinkage*)Unsafe.AsPointer(ref this), pClassTypeName, ConstantBufferOffset, ConstantVectorOffset, TextureOffset, SamplerOffset, ppInstance); +#endif + } + + public interface Interface : ID3D11DeviceChild.Interface + { + } +} + +/// +/// ID3D11CommandList +[Guid("a24bc4d1-769e-43f7-8013-98ff566c18e2")] +[NativeTypeName("struct ID3D11CommandList : ID3D11DeviceChild")] +[NativeInheritance("ID3D11DeviceChild")] +public unsafe partial struct ID3D11CommandList : ID3D11CommandList.Interface +{ + public static ref readonly Guid IID_ID3D11CommandList + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0xD1, 0xC4, 0x4B, 0xA2, + 0x9E, 0x76, + 0xF7, 0x43, + 0x80, + 0x13, + 0x98, + 0xFF, + 0x56, + 0x6C, + 0x18, + 0xE2 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_ID3D11CommandList)); + + public void** lpVtbl; + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(0)] + public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(1)] + [return: NativeTypeName("ULONG")] + public uint AddRef() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(2)] + [return: NativeTypeName("ULONG")] + public uint Release() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(3)] + public void GetDevice(ID3D11Device* ppDevice) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[3]))((ID3D11CommandList*)Unsafe.AsPointer(ref this), ppDevice); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((ID3D11CommandList*)Unsafe.AsPointer(ref this), ppDevice); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public HResult GetPrivateData(Guid* guid, uint* pDataSize, void* pData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[4]))((ID3D11CommandList*)Unsafe.AsPointer(ref this), guid, pDataSize, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((ID3D11CommandList*)Unsafe.AsPointer(ref this), guid, pDataSize, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(5)] + public HResult SetPrivateData(Guid* guid, uint DataSize, void* pData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[5]))((ID3D11CommandList*)Unsafe.AsPointer(ref this), guid, DataSize, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((ID3D11CommandList*)Unsafe.AsPointer(ref this), guid, DataSize, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(6)] + public HResult SetPrivateDataInterface(Guid* guid, IUnknown* pData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[6]))((ID3D11CommandList*)Unsafe.AsPointer(ref this), guid, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((ID3D11CommandList*)Unsafe.AsPointer(ref this), guid, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(7)] + public uint GetContextFlags() + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[7]))((ID3D11CommandList*)Unsafe.AsPointer(ref this)); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((ID3D11CommandList*)Unsafe.AsPointer(ref this)); +#endif + } + + public interface Interface : ID3D11DeviceChild.Interface + { + } +} + +/// +/// ID3D11DeviceContext +[Guid("c0bfa96c-e089-44fb-8eaf-26f8796190da")] +[NativeTypeName("struct ID3D11DeviceContext : ID3D11DeviceChild")] +[NativeInheritance("ID3D11DeviceChild")] +public unsafe partial struct ID3D11DeviceContext : ID3D11DeviceContext.Interface +{ + public static ref readonly Guid IID_ID3D11DeviceContext + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x6C, 0xA9, 0xBF, 0xC0, + 0x89, 0xE0, + 0xFB, 0x44, + 0x8E, + 0xAF, + 0x26, + 0xF8, + 0x79, + 0x61, + 0x90, + 0xDA + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_ID3D11DeviceContext)); + + public void** lpVtbl; + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(0)] + public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(1)] + [return: NativeTypeName("ULONG")] + public uint AddRef() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(2)] + [return: NativeTypeName("ULONG")] + public uint Release() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(3)] + public void GetDevice(ID3D11Device* ppDevice) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[3]))((ID3D11DeviceContext*)Unsafe.AsPointer(ref this), ppDevice); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((ID3D11DeviceContext*)Unsafe.AsPointer(ref this), ppDevice); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public HResult GetPrivateData(Guid* guid, uint* pDataSize, void* pData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[4]))((ID3D11DeviceContext*)Unsafe.AsPointer(ref this), guid, pDataSize, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((ID3D11DeviceContext*)Unsafe.AsPointer(ref this), guid, pDataSize, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(5)] + public HResult SetPrivateData(Guid* guid, uint DataSize, void* pData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[5]))((ID3D11DeviceContext*)Unsafe.AsPointer(ref this), guid, DataSize, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((ID3D11DeviceContext*)Unsafe.AsPointer(ref this), guid, DataSize, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(6)] + public HResult SetPrivateDataInterface(Guid* guid, IUnknown* pData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[6]))((ID3D11DeviceContext*)Unsafe.AsPointer(ref this), guid, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((ID3D11DeviceContext*)Unsafe.AsPointer(ref this), guid, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(7)] + public void VSSetConstantBuffers(uint StartSlot, uint NumBuffers, ID3D11Buffer* ppConstantBuffers) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[7]))((ID3D11DeviceContext*)Unsafe.AsPointer(ref this), StartSlot, NumBuffers, ppConstantBuffers); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((ID3D11DeviceContext*)Unsafe.AsPointer(ref this), StartSlot, NumBuffers, ppConstantBuffers); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(8)] + public void PSSetShaderResources(uint StartSlot, uint NumViews, ID3D11ShaderResourceView* ppShaderResourceViews) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[8]))((ID3D11DeviceContext*)Unsafe.AsPointer(ref this), StartSlot, NumViews, ppShaderResourceViews); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[8]))((ID3D11DeviceContext*)Unsafe.AsPointer(ref this), StartSlot, NumViews, ppShaderResourceViews); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(9)] + public void PSSetShader(ID3D11PixelShader* pPixelShader, ID3D11ClassInstance* ppClassInstances, uint NumClassInstances) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[9]))((ID3D11DeviceContext*)Unsafe.AsPointer(ref this), pPixelShader, ppClassInstances, NumClassInstances); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[9]))((ID3D11DeviceContext*)Unsafe.AsPointer(ref this), pPixelShader, ppClassInstances, NumClassInstances); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(10)] + public void PSSetSamplers(uint StartSlot, uint NumSamplers, ID3D11SamplerState* ppSamplers) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[10]))((ID3D11DeviceContext*)Unsafe.AsPointer(ref this), StartSlot, NumSamplers, ppSamplers); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[10]))((ID3D11DeviceContext*)Unsafe.AsPointer(ref this), StartSlot, NumSamplers, ppSamplers); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(11)] + public void VSSetShader(ID3D11VertexShader* pVertexShader, ID3D11ClassInstance* ppClassInstances, uint NumClassInstances) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[11]))((ID3D11DeviceContext*)Unsafe.AsPointer(ref this), pVertexShader, ppClassInstances, NumClassInstances); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[11]))((ID3D11DeviceContext*)Unsafe.AsPointer(ref this), pVertexShader, ppClassInstances, NumClassInstances); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(12)] + public void DrawIndexed(uint IndexCount, uint StartIndexLocation, int BaseVertexLocation) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[12]))((ID3D11DeviceContext*)Unsafe.AsPointer(ref this), IndexCount, StartIndexLocation, BaseVertexLocation); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[12]))((ID3D11DeviceContext*)Unsafe.AsPointer(ref this), IndexCount, StartIndexLocation, BaseVertexLocation); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(13)] + public void Draw(uint VertexCount, uint StartVertexLocation) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[13]))((ID3D11DeviceContext*)Unsafe.AsPointer(ref this), VertexCount, StartVertexLocation); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[13]))((ID3D11DeviceContext*)Unsafe.AsPointer(ref this), VertexCount, StartVertexLocation); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(14)] + public HResult Map(ID3D11Resource* pResource, uint Subresource, Map MapType, uint MapFlags, MappedSubresource* pMappedResource) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[14]))((ID3D11DeviceContext*)Unsafe.AsPointer(ref this), pResource, Subresource, MapType, MapFlags, pMappedResource); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[14]))((ID3D11DeviceContext*)Unsafe.AsPointer(ref this), pResource, Subresource, MapType, MapFlags, pMappedResource); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(15)] + public void Unmap(ID3D11Resource* pResource, uint Subresource) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[15]))((ID3D11DeviceContext*)Unsafe.AsPointer(ref this), pResource, Subresource); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[15]))((ID3D11DeviceContext*)Unsafe.AsPointer(ref this), pResource, Subresource); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(16)] + public void PSSetConstantBuffers(uint StartSlot, uint NumBuffers, ID3D11Buffer* ppConstantBuffers) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[16]))((ID3D11DeviceContext*)Unsafe.AsPointer(ref this), StartSlot, NumBuffers, ppConstantBuffers); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[16]))((ID3D11DeviceContext*)Unsafe.AsPointer(ref this), StartSlot, NumBuffers, ppConstantBuffers); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(17)] + public void IASetInputLayout(ID3D11InputLayout* pInputLayout) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[17]))((ID3D11DeviceContext*)Unsafe.AsPointer(ref this), pInputLayout); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[17]))((ID3D11DeviceContext*)Unsafe.AsPointer(ref this), pInputLayout); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(18)] + public void IASetVertexBuffers(uint StartSlot, uint NumBuffers, ID3D11Buffer* ppVertexBuffers, uint* pStrides, uint* pOffsets) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[18]))((ID3D11DeviceContext*)Unsafe.AsPointer(ref this), StartSlot, NumBuffers, ppVertexBuffers, pStrides, pOffsets); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[18]))((ID3D11DeviceContext*)Unsafe.AsPointer(ref this), StartSlot, NumBuffers, ppVertexBuffers, pStrides, pOffsets); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(19)] + public void IASetIndexBuffer(ID3D11Buffer* pIndexBuffer, Graphics.Dxgi.Common.Format Format, uint Offset) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[19]))((ID3D11DeviceContext*)Unsafe.AsPointer(ref this), pIndexBuffer, Format, Offset); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[19]))((ID3D11DeviceContext*)Unsafe.AsPointer(ref this), pIndexBuffer, Format, Offset); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(20)] + public void DrawIndexedInstanced(uint IndexCountPerInstance, uint InstanceCount, uint StartIndexLocation, int BaseVertexLocation, uint StartInstanceLocation) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[20]))((ID3D11DeviceContext*)Unsafe.AsPointer(ref this), IndexCountPerInstance, InstanceCount, StartIndexLocation, BaseVertexLocation, StartInstanceLocation); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[20]))((ID3D11DeviceContext*)Unsafe.AsPointer(ref this), IndexCountPerInstance, InstanceCount, StartIndexLocation, BaseVertexLocation, StartInstanceLocation); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(21)] + public void DrawInstanced(uint VertexCountPerInstance, uint InstanceCount, uint StartVertexLocation, uint StartInstanceLocation) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[21]))((ID3D11DeviceContext*)Unsafe.AsPointer(ref this), VertexCountPerInstance, InstanceCount, StartVertexLocation, StartInstanceLocation); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[21]))((ID3D11DeviceContext*)Unsafe.AsPointer(ref this), VertexCountPerInstance, InstanceCount, StartVertexLocation, StartInstanceLocation); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(22)] + public void GSSetConstantBuffers(uint StartSlot, uint NumBuffers, ID3D11Buffer* ppConstantBuffers) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[22]))((ID3D11DeviceContext*)Unsafe.AsPointer(ref this), StartSlot, NumBuffers, ppConstantBuffers); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[22]))((ID3D11DeviceContext*)Unsafe.AsPointer(ref this), StartSlot, NumBuffers, ppConstantBuffers); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(23)] + public void GSSetShader(ID3D11GeometryShader* pShader, ID3D11ClassInstance* ppClassInstances, uint NumClassInstances) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[23]))((ID3D11DeviceContext*)Unsafe.AsPointer(ref this), pShader, ppClassInstances, NumClassInstances); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[23]))((ID3D11DeviceContext*)Unsafe.AsPointer(ref this), pShader, ppClassInstances, NumClassInstances); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(24)] + public void IASetPrimitiveTopology(Graphics.Direct3D.PrimitiveTopology Topology) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[24]))((ID3D11DeviceContext*)Unsafe.AsPointer(ref this), Topology); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[24]))((ID3D11DeviceContext*)Unsafe.AsPointer(ref this), Topology); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(25)] + public void VSSetShaderResources(uint StartSlot, uint NumViews, ID3D11ShaderResourceView* ppShaderResourceViews) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[25]))((ID3D11DeviceContext*)Unsafe.AsPointer(ref this), StartSlot, NumViews, ppShaderResourceViews); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[25]))((ID3D11DeviceContext*)Unsafe.AsPointer(ref this), StartSlot, NumViews, ppShaderResourceViews); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(26)] + public void VSSetSamplers(uint StartSlot, uint NumSamplers, ID3D11SamplerState* ppSamplers) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[26]))((ID3D11DeviceContext*)Unsafe.AsPointer(ref this), StartSlot, NumSamplers, ppSamplers); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[26]))((ID3D11DeviceContext*)Unsafe.AsPointer(ref this), StartSlot, NumSamplers, ppSamplers); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(27)] + public void Begin(ID3D11Asynchronous* pAsync) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[27]))((ID3D11DeviceContext*)Unsafe.AsPointer(ref this), pAsync); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[27]))((ID3D11DeviceContext*)Unsafe.AsPointer(ref this), pAsync); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(28)] + public void End(ID3D11Asynchronous* pAsync) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[28]))((ID3D11DeviceContext*)Unsafe.AsPointer(ref this), pAsync); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[28]))((ID3D11DeviceContext*)Unsafe.AsPointer(ref this), pAsync); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(29)] + public HResult GetData(ID3D11Asynchronous* pAsync, void* pData, uint DataSize, uint GetDataFlags) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[29]))((ID3D11DeviceContext*)Unsafe.AsPointer(ref this), pAsync, pData, DataSize, GetDataFlags); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[29]))((ID3D11DeviceContext*)Unsafe.AsPointer(ref this), pAsync, pData, DataSize, GetDataFlags); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(30)] + public void SetPredication(ID3D11Predicate* pPredicate, Bool32* PredicateValue) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[30]))((ID3D11DeviceContext*)Unsafe.AsPointer(ref this), pPredicate, PredicateValue); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[30]))((ID3D11DeviceContext*)Unsafe.AsPointer(ref this), pPredicate, PredicateValue); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(31)] + public void GSSetShaderResources(uint StartSlot, uint NumViews, ID3D11ShaderResourceView* ppShaderResourceViews) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[31]))((ID3D11DeviceContext*)Unsafe.AsPointer(ref this), StartSlot, NumViews, ppShaderResourceViews); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[31]))((ID3D11DeviceContext*)Unsafe.AsPointer(ref this), StartSlot, NumViews, ppShaderResourceViews); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(32)] + public void GSSetSamplers(uint StartSlot, uint NumSamplers, ID3D11SamplerState* ppSamplers) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[32]))((ID3D11DeviceContext*)Unsafe.AsPointer(ref this), StartSlot, NumSamplers, ppSamplers); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[32]))((ID3D11DeviceContext*)Unsafe.AsPointer(ref this), StartSlot, NumSamplers, ppSamplers); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(33)] + public void OMSetRenderTargets(uint NumViews, ID3D11RenderTargetView* ppRenderTargetViews, ID3D11DepthStencilView* pDepthStencilView) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[33]))((ID3D11DeviceContext*)Unsafe.AsPointer(ref this), NumViews, ppRenderTargetViews, pDepthStencilView); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[33]))((ID3D11DeviceContext*)Unsafe.AsPointer(ref this), NumViews, ppRenderTargetViews, pDepthStencilView); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(34)] + public void OMSetRenderTargetsAndUnorderedAccessViews(uint NumRTVs, ID3D11RenderTargetView* ppRenderTargetViews, ID3D11DepthStencilView* pDepthStencilView, uint UAVStartSlot, uint NumUAVs, ID3D11UnorderedAccessView* ppUnorderedAccessViews, uint* pUAVInitialCounts) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[34]))((ID3D11DeviceContext*)Unsafe.AsPointer(ref this), NumRTVs, ppRenderTargetViews, pDepthStencilView, UAVStartSlot, NumUAVs, ppUnorderedAccessViews, pUAVInitialCounts); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[34]))((ID3D11DeviceContext*)Unsafe.AsPointer(ref this), NumRTVs, ppRenderTargetViews, pDepthStencilView, UAVStartSlot, NumUAVs, ppUnorderedAccessViews, pUAVInitialCounts); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(35)] + public void OMSetBlendState(ID3D11BlendState* pBlendState, float* BlendFactor, uint SampleMask) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[35]))((ID3D11DeviceContext*)Unsafe.AsPointer(ref this), pBlendState, BlendFactor, SampleMask); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[35]))((ID3D11DeviceContext*)Unsafe.AsPointer(ref this), pBlendState, BlendFactor, SampleMask); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(36)] + public void OMSetDepthStencilState(ID3D11DepthStencilState* pDepthStencilState, uint StencilRef) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[36]))((ID3D11DeviceContext*)Unsafe.AsPointer(ref this), pDepthStencilState, StencilRef); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[36]))((ID3D11DeviceContext*)Unsafe.AsPointer(ref this), pDepthStencilState, StencilRef); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(37)] + public void SOSetTargets(uint NumBuffers, ID3D11Buffer* ppSOTargets, uint* pOffsets) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[37]))((ID3D11DeviceContext*)Unsafe.AsPointer(ref this), NumBuffers, ppSOTargets, pOffsets); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[37]))((ID3D11DeviceContext*)Unsafe.AsPointer(ref this), NumBuffers, ppSOTargets, pOffsets); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(38)] + public void DrawAuto() + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[38]))((ID3D11DeviceContext*)Unsafe.AsPointer(ref this)); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[38]))((ID3D11DeviceContext*)Unsafe.AsPointer(ref this)); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(39)] + public void DrawIndexedInstancedIndirect(ID3D11Buffer* pBufferForArgs, uint AlignedByteOffsetForArgs) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[39]))((ID3D11DeviceContext*)Unsafe.AsPointer(ref this), pBufferForArgs, AlignedByteOffsetForArgs); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[39]))((ID3D11DeviceContext*)Unsafe.AsPointer(ref this), pBufferForArgs, AlignedByteOffsetForArgs); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(40)] + public void DrawInstancedIndirect(ID3D11Buffer* pBufferForArgs, uint AlignedByteOffsetForArgs) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[40]))((ID3D11DeviceContext*)Unsafe.AsPointer(ref this), pBufferForArgs, AlignedByteOffsetForArgs); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[40]))((ID3D11DeviceContext*)Unsafe.AsPointer(ref this), pBufferForArgs, AlignedByteOffsetForArgs); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(41)] + public void Dispatch(uint ThreadGroupCountX, uint ThreadGroupCountY, uint ThreadGroupCountZ) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[41]))((ID3D11DeviceContext*)Unsafe.AsPointer(ref this), ThreadGroupCountX, ThreadGroupCountY, ThreadGroupCountZ); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[41]))((ID3D11DeviceContext*)Unsafe.AsPointer(ref this), ThreadGroupCountX, ThreadGroupCountY, ThreadGroupCountZ); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(42)] + public void DispatchIndirect(ID3D11Buffer* pBufferForArgs, uint AlignedByteOffsetForArgs) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[42]))((ID3D11DeviceContext*)Unsafe.AsPointer(ref this), pBufferForArgs, AlignedByteOffsetForArgs); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[42]))((ID3D11DeviceContext*)Unsafe.AsPointer(ref this), pBufferForArgs, AlignedByteOffsetForArgs); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(43)] + public void RSSetState(ID3D11RasterizerState* pRasterizerState) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[43]))((ID3D11DeviceContext*)Unsafe.AsPointer(ref this), pRasterizerState); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[43]))((ID3D11DeviceContext*)Unsafe.AsPointer(ref this), pRasterizerState); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(44)] + public void RSSetViewports(uint NumViewports, Viewport* pViewports) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[44]))((ID3D11DeviceContext*)Unsafe.AsPointer(ref this), NumViewports, pViewports); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[44]))((ID3D11DeviceContext*)Unsafe.AsPointer(ref this), NumViewports, pViewports); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(45)] + public void RSSetScissorRects(uint NumRects, RawRect* pRects) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[45]))((ID3D11DeviceContext*)Unsafe.AsPointer(ref this), NumRects, pRects); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[45]))((ID3D11DeviceContext*)Unsafe.AsPointer(ref this), NumRects, pRects); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(46)] + public void CopySubresourceRegion(ID3D11Resource* pDstResource, uint DstSubresource, uint DstX, uint DstY, uint DstZ, ID3D11Resource* pSrcResource, uint SrcSubresource, Box* pSrcBox) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[46]))((ID3D11DeviceContext*)Unsafe.AsPointer(ref this), pDstResource, DstSubresource, DstX, DstY, DstZ, pSrcResource, SrcSubresource, pSrcBox); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[46]))((ID3D11DeviceContext*)Unsafe.AsPointer(ref this), pDstResource, DstSubresource, DstX, DstY, DstZ, pSrcResource, SrcSubresource, pSrcBox); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(47)] + public void CopyResource(ID3D11Resource* pDstResource, ID3D11Resource* pSrcResource) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[47]))((ID3D11DeviceContext*)Unsafe.AsPointer(ref this), pDstResource, pSrcResource); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[47]))((ID3D11DeviceContext*)Unsafe.AsPointer(ref this), pDstResource, pSrcResource); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(48)] + public void UpdateSubresource(ID3D11Resource* pDstResource, uint DstSubresource, Box* pDstBox, void* pSrcData, uint SrcRowPitch, uint SrcDepthPitch) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[48]))((ID3D11DeviceContext*)Unsafe.AsPointer(ref this), pDstResource, DstSubresource, pDstBox, pSrcData, SrcRowPitch, SrcDepthPitch); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[48]))((ID3D11DeviceContext*)Unsafe.AsPointer(ref this), pDstResource, DstSubresource, pDstBox, pSrcData, SrcRowPitch, SrcDepthPitch); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(49)] + public void CopyStructureCount(ID3D11Buffer* pDstBuffer, uint DstAlignedByteOffset, ID3D11UnorderedAccessView* pSrcView) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[49]))((ID3D11DeviceContext*)Unsafe.AsPointer(ref this), pDstBuffer, DstAlignedByteOffset, pSrcView); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[49]))((ID3D11DeviceContext*)Unsafe.AsPointer(ref this), pDstBuffer, DstAlignedByteOffset, pSrcView); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(50)] + public void ClearRenderTargetView(ID3D11RenderTargetView* pRenderTargetView, float* ColorRGBA) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[50]))((ID3D11DeviceContext*)Unsafe.AsPointer(ref this), pRenderTargetView, ColorRGBA); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[50]))((ID3D11DeviceContext*)Unsafe.AsPointer(ref this), pRenderTargetView, ColorRGBA); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(51)] + public void ClearUnorderedAccessViewUint(ID3D11UnorderedAccessView* pUnorderedAccessView, uint* Values) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[51]))((ID3D11DeviceContext*)Unsafe.AsPointer(ref this), pUnorderedAccessView, Values); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[51]))((ID3D11DeviceContext*)Unsafe.AsPointer(ref this), pUnorderedAccessView, Values); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(52)] + public void ClearUnorderedAccessViewFloat(ID3D11UnorderedAccessView* pUnorderedAccessView, float* Values) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[52]))((ID3D11DeviceContext*)Unsafe.AsPointer(ref this), pUnorderedAccessView, Values); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[52]))((ID3D11DeviceContext*)Unsafe.AsPointer(ref this), pUnorderedAccessView, Values); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(53)] + public void ClearDepthStencilView(ID3D11DepthStencilView* pDepthStencilView, uint ClearFlags, float Depth, byte Stencil) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[53]))((ID3D11DeviceContext*)Unsafe.AsPointer(ref this), pDepthStencilView, ClearFlags, Depth, Stencil); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[53]))((ID3D11DeviceContext*)Unsafe.AsPointer(ref this), pDepthStencilView, ClearFlags, Depth, Stencil); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(54)] + public void GenerateMips(ID3D11ShaderResourceView* pShaderResourceView) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[54]))((ID3D11DeviceContext*)Unsafe.AsPointer(ref this), pShaderResourceView); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[54]))((ID3D11DeviceContext*)Unsafe.AsPointer(ref this), pShaderResourceView); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(55)] + public void SetResourceMinLOD(ID3D11Resource* pResource, float MinLOD) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[55]))((ID3D11DeviceContext*)Unsafe.AsPointer(ref this), pResource, MinLOD); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[55]))((ID3D11DeviceContext*)Unsafe.AsPointer(ref this), pResource, MinLOD); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(56)] + public float GetResourceMinLOD(ID3D11Resource* pResource) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[56]))((ID3D11DeviceContext*)Unsafe.AsPointer(ref this), pResource); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[56]))((ID3D11DeviceContext*)Unsafe.AsPointer(ref this), pResource); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(57)] + public void ResolveSubresource(ID3D11Resource* pDstResource, uint DstSubresource, ID3D11Resource* pSrcResource, uint SrcSubresource, Graphics.Dxgi.Common.Format Format) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[57]))((ID3D11DeviceContext*)Unsafe.AsPointer(ref this), pDstResource, DstSubresource, pSrcResource, SrcSubresource, Format); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[57]))((ID3D11DeviceContext*)Unsafe.AsPointer(ref this), pDstResource, DstSubresource, pSrcResource, SrcSubresource, Format); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(58)] + public void ExecuteCommandList(ID3D11CommandList* pCommandList, Bool32* RestoreContextState) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[58]))((ID3D11DeviceContext*)Unsafe.AsPointer(ref this), pCommandList, RestoreContextState); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[58]))((ID3D11DeviceContext*)Unsafe.AsPointer(ref this), pCommandList, RestoreContextState); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(59)] + public void HSSetShaderResources(uint StartSlot, uint NumViews, ID3D11ShaderResourceView* ppShaderResourceViews) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[59]))((ID3D11DeviceContext*)Unsafe.AsPointer(ref this), StartSlot, NumViews, ppShaderResourceViews); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[59]))((ID3D11DeviceContext*)Unsafe.AsPointer(ref this), StartSlot, NumViews, ppShaderResourceViews); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(60)] + public void HSSetShader(ID3D11HullShader* pHullShader, ID3D11ClassInstance* ppClassInstances, uint NumClassInstances) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[60]))((ID3D11DeviceContext*)Unsafe.AsPointer(ref this), pHullShader, ppClassInstances, NumClassInstances); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[60]))((ID3D11DeviceContext*)Unsafe.AsPointer(ref this), pHullShader, ppClassInstances, NumClassInstances); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(61)] + public void HSSetSamplers(uint StartSlot, uint NumSamplers, ID3D11SamplerState* ppSamplers) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[61]))((ID3D11DeviceContext*)Unsafe.AsPointer(ref this), StartSlot, NumSamplers, ppSamplers); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[61]))((ID3D11DeviceContext*)Unsafe.AsPointer(ref this), StartSlot, NumSamplers, ppSamplers); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(62)] + public void HSSetConstantBuffers(uint StartSlot, uint NumBuffers, ID3D11Buffer* ppConstantBuffers) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[62]))((ID3D11DeviceContext*)Unsafe.AsPointer(ref this), StartSlot, NumBuffers, ppConstantBuffers); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[62]))((ID3D11DeviceContext*)Unsafe.AsPointer(ref this), StartSlot, NumBuffers, ppConstantBuffers); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(63)] + public void DSSetShaderResources(uint StartSlot, uint NumViews, ID3D11ShaderResourceView* ppShaderResourceViews) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[63]))((ID3D11DeviceContext*)Unsafe.AsPointer(ref this), StartSlot, NumViews, ppShaderResourceViews); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[63]))((ID3D11DeviceContext*)Unsafe.AsPointer(ref this), StartSlot, NumViews, ppShaderResourceViews); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(64)] + public void DSSetShader(ID3D11DomainShader* pDomainShader, ID3D11ClassInstance* ppClassInstances, uint NumClassInstances) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[64]))((ID3D11DeviceContext*)Unsafe.AsPointer(ref this), pDomainShader, ppClassInstances, NumClassInstances); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[64]))((ID3D11DeviceContext*)Unsafe.AsPointer(ref this), pDomainShader, ppClassInstances, NumClassInstances); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(65)] + public void DSSetSamplers(uint StartSlot, uint NumSamplers, ID3D11SamplerState* ppSamplers) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[65]))((ID3D11DeviceContext*)Unsafe.AsPointer(ref this), StartSlot, NumSamplers, ppSamplers); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[65]))((ID3D11DeviceContext*)Unsafe.AsPointer(ref this), StartSlot, NumSamplers, ppSamplers); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(66)] + public void DSSetConstantBuffers(uint StartSlot, uint NumBuffers, ID3D11Buffer* ppConstantBuffers) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[66]))((ID3D11DeviceContext*)Unsafe.AsPointer(ref this), StartSlot, NumBuffers, ppConstantBuffers); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[66]))((ID3D11DeviceContext*)Unsafe.AsPointer(ref this), StartSlot, NumBuffers, ppConstantBuffers); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(67)] + public void CSSetShaderResources(uint StartSlot, uint NumViews, ID3D11ShaderResourceView* ppShaderResourceViews) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[67]))((ID3D11DeviceContext*)Unsafe.AsPointer(ref this), StartSlot, NumViews, ppShaderResourceViews); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[67]))((ID3D11DeviceContext*)Unsafe.AsPointer(ref this), StartSlot, NumViews, ppShaderResourceViews); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(68)] + public void CSSetUnorderedAccessViews(uint StartSlot, uint NumUAVs, ID3D11UnorderedAccessView* ppUnorderedAccessViews, uint* pUAVInitialCounts) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[68]))((ID3D11DeviceContext*)Unsafe.AsPointer(ref this), StartSlot, NumUAVs, ppUnorderedAccessViews, pUAVInitialCounts); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[68]))((ID3D11DeviceContext*)Unsafe.AsPointer(ref this), StartSlot, NumUAVs, ppUnorderedAccessViews, pUAVInitialCounts); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(69)] + public void CSSetShader(ID3D11ComputeShader* pComputeShader, ID3D11ClassInstance* ppClassInstances, uint NumClassInstances) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[69]))((ID3D11DeviceContext*)Unsafe.AsPointer(ref this), pComputeShader, ppClassInstances, NumClassInstances); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[69]))((ID3D11DeviceContext*)Unsafe.AsPointer(ref this), pComputeShader, ppClassInstances, NumClassInstances); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(70)] + public void CSSetSamplers(uint StartSlot, uint NumSamplers, ID3D11SamplerState* ppSamplers) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[70]))((ID3D11DeviceContext*)Unsafe.AsPointer(ref this), StartSlot, NumSamplers, ppSamplers); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[70]))((ID3D11DeviceContext*)Unsafe.AsPointer(ref this), StartSlot, NumSamplers, ppSamplers); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(71)] + public void CSSetConstantBuffers(uint StartSlot, uint NumBuffers, ID3D11Buffer* ppConstantBuffers) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[71]))((ID3D11DeviceContext*)Unsafe.AsPointer(ref this), StartSlot, NumBuffers, ppConstantBuffers); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[71]))((ID3D11DeviceContext*)Unsafe.AsPointer(ref this), StartSlot, NumBuffers, ppConstantBuffers); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(72)] + public void VSGetConstantBuffers(uint StartSlot, uint NumBuffers, ID3D11Buffer* ppConstantBuffers) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[72]))((ID3D11DeviceContext*)Unsafe.AsPointer(ref this), StartSlot, NumBuffers, ppConstantBuffers); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[72]))((ID3D11DeviceContext*)Unsafe.AsPointer(ref this), StartSlot, NumBuffers, ppConstantBuffers); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(73)] + public void PSGetShaderResources(uint StartSlot, uint NumViews, ID3D11ShaderResourceView* ppShaderResourceViews) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[73]))((ID3D11DeviceContext*)Unsafe.AsPointer(ref this), StartSlot, NumViews, ppShaderResourceViews); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[73]))((ID3D11DeviceContext*)Unsafe.AsPointer(ref this), StartSlot, NumViews, ppShaderResourceViews); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(74)] + public void PSGetShader(ID3D11PixelShader* ppPixelShader, ID3D11ClassInstance* ppClassInstances, uint* pNumClassInstances) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[74]))((ID3D11DeviceContext*)Unsafe.AsPointer(ref this), ppPixelShader, ppClassInstances, pNumClassInstances); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[74]))((ID3D11DeviceContext*)Unsafe.AsPointer(ref this), ppPixelShader, ppClassInstances, pNumClassInstances); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(75)] + public void PSGetSamplers(uint StartSlot, uint NumSamplers, ID3D11SamplerState* ppSamplers) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[75]))((ID3D11DeviceContext*)Unsafe.AsPointer(ref this), StartSlot, NumSamplers, ppSamplers); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[75]))((ID3D11DeviceContext*)Unsafe.AsPointer(ref this), StartSlot, NumSamplers, ppSamplers); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(76)] + public void VSGetShader(ID3D11VertexShader* ppVertexShader, ID3D11ClassInstance* ppClassInstances, uint* pNumClassInstances) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[76]))((ID3D11DeviceContext*)Unsafe.AsPointer(ref this), ppVertexShader, ppClassInstances, pNumClassInstances); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[76]))((ID3D11DeviceContext*)Unsafe.AsPointer(ref this), ppVertexShader, ppClassInstances, pNumClassInstances); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(77)] + public void PSGetConstantBuffers(uint StartSlot, uint NumBuffers, ID3D11Buffer* ppConstantBuffers) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[77]))((ID3D11DeviceContext*)Unsafe.AsPointer(ref this), StartSlot, NumBuffers, ppConstantBuffers); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[77]))((ID3D11DeviceContext*)Unsafe.AsPointer(ref this), StartSlot, NumBuffers, ppConstantBuffers); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(78)] + public void IAGetInputLayout(ID3D11InputLayout* ppInputLayout) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[78]))((ID3D11DeviceContext*)Unsafe.AsPointer(ref this), ppInputLayout); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[78]))((ID3D11DeviceContext*)Unsafe.AsPointer(ref this), ppInputLayout); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(79)] + public void IAGetVertexBuffers(uint StartSlot, uint NumBuffers, ID3D11Buffer* ppVertexBuffers, uint* pStrides, uint* pOffsets) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[79]))((ID3D11DeviceContext*)Unsafe.AsPointer(ref this), StartSlot, NumBuffers, ppVertexBuffers, pStrides, pOffsets); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[79]))((ID3D11DeviceContext*)Unsafe.AsPointer(ref this), StartSlot, NumBuffers, ppVertexBuffers, pStrides, pOffsets); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(80)] + public void IAGetIndexBuffer(ID3D11Buffer* pIndexBuffer, Graphics.Dxgi.Common.Format* Format, uint* Offset) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[80]))((ID3D11DeviceContext*)Unsafe.AsPointer(ref this), pIndexBuffer, Format, Offset); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[80]))((ID3D11DeviceContext*)Unsafe.AsPointer(ref this), pIndexBuffer, Format, Offset); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(81)] + public void GSGetConstantBuffers(uint StartSlot, uint NumBuffers, ID3D11Buffer* ppConstantBuffers) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[81]))((ID3D11DeviceContext*)Unsafe.AsPointer(ref this), StartSlot, NumBuffers, ppConstantBuffers); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[81]))((ID3D11DeviceContext*)Unsafe.AsPointer(ref this), StartSlot, NumBuffers, ppConstantBuffers); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(82)] + public void GSGetShader(ID3D11GeometryShader* ppGeometryShader, ID3D11ClassInstance* ppClassInstances, uint* pNumClassInstances) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[82]))((ID3D11DeviceContext*)Unsafe.AsPointer(ref this), ppGeometryShader, ppClassInstances, pNumClassInstances); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[82]))((ID3D11DeviceContext*)Unsafe.AsPointer(ref this), ppGeometryShader, ppClassInstances, pNumClassInstances); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(83)] + public void IAGetPrimitiveTopology(Graphics.Direct3D.PrimitiveTopology* pTopology) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[83]))((ID3D11DeviceContext*)Unsafe.AsPointer(ref this), pTopology); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[83]))((ID3D11DeviceContext*)Unsafe.AsPointer(ref this), pTopology); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(84)] + public void VSGetShaderResources(uint StartSlot, uint NumViews, ID3D11ShaderResourceView* ppShaderResourceViews) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[84]))((ID3D11DeviceContext*)Unsafe.AsPointer(ref this), StartSlot, NumViews, ppShaderResourceViews); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[84]))((ID3D11DeviceContext*)Unsafe.AsPointer(ref this), StartSlot, NumViews, ppShaderResourceViews); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(85)] + public void VSGetSamplers(uint StartSlot, uint NumSamplers, ID3D11SamplerState* ppSamplers) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[85]))((ID3D11DeviceContext*)Unsafe.AsPointer(ref this), StartSlot, NumSamplers, ppSamplers); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[85]))((ID3D11DeviceContext*)Unsafe.AsPointer(ref this), StartSlot, NumSamplers, ppSamplers); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(86)] + public void GetPredication(ID3D11Predicate* ppPredicate, Bool32* pPredicateValue) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[86]))((ID3D11DeviceContext*)Unsafe.AsPointer(ref this), ppPredicate, pPredicateValue); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[86]))((ID3D11DeviceContext*)Unsafe.AsPointer(ref this), ppPredicate, pPredicateValue); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(87)] + public void GSGetShaderResources(uint StartSlot, uint NumViews, ID3D11ShaderResourceView* ppShaderResourceViews) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[87]))((ID3D11DeviceContext*)Unsafe.AsPointer(ref this), StartSlot, NumViews, ppShaderResourceViews); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[87]))((ID3D11DeviceContext*)Unsafe.AsPointer(ref this), StartSlot, NumViews, ppShaderResourceViews); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(88)] + public void GSGetSamplers(uint StartSlot, uint NumSamplers, ID3D11SamplerState* ppSamplers) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[88]))((ID3D11DeviceContext*)Unsafe.AsPointer(ref this), StartSlot, NumSamplers, ppSamplers); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[88]))((ID3D11DeviceContext*)Unsafe.AsPointer(ref this), StartSlot, NumSamplers, ppSamplers); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(89)] + public void OMGetRenderTargets(uint NumViews, ID3D11RenderTargetView* ppRenderTargetViews, ID3D11DepthStencilView* ppDepthStencilView) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[89]))((ID3D11DeviceContext*)Unsafe.AsPointer(ref this), NumViews, ppRenderTargetViews, ppDepthStencilView); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[89]))((ID3D11DeviceContext*)Unsafe.AsPointer(ref this), NumViews, ppRenderTargetViews, ppDepthStencilView); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(90)] + public void OMGetRenderTargetsAndUnorderedAccessViews(uint NumRTVs, ID3D11RenderTargetView* ppRenderTargetViews, ID3D11DepthStencilView* ppDepthStencilView, uint UAVStartSlot, uint NumUAVs, ID3D11UnorderedAccessView* ppUnorderedAccessViews) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[90]))((ID3D11DeviceContext*)Unsafe.AsPointer(ref this), NumRTVs, ppRenderTargetViews, ppDepthStencilView, UAVStartSlot, NumUAVs, ppUnorderedAccessViews); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[90]))((ID3D11DeviceContext*)Unsafe.AsPointer(ref this), NumRTVs, ppRenderTargetViews, ppDepthStencilView, UAVStartSlot, NumUAVs, ppUnorderedAccessViews); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(91)] + public void OMGetBlendState(ID3D11BlendState* ppBlendState, float* BlendFactor, uint* pSampleMask) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[91]))((ID3D11DeviceContext*)Unsafe.AsPointer(ref this), ppBlendState, BlendFactor, pSampleMask); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[91]))((ID3D11DeviceContext*)Unsafe.AsPointer(ref this), ppBlendState, BlendFactor, pSampleMask); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(92)] + public void OMGetDepthStencilState(ID3D11DepthStencilState* ppDepthStencilState, uint* pStencilRef) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[92]))((ID3D11DeviceContext*)Unsafe.AsPointer(ref this), ppDepthStencilState, pStencilRef); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[92]))((ID3D11DeviceContext*)Unsafe.AsPointer(ref this), ppDepthStencilState, pStencilRef); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(93)] + public void SOGetTargets(uint NumBuffers, ID3D11Buffer* ppSOTargets) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[93]))((ID3D11DeviceContext*)Unsafe.AsPointer(ref this), NumBuffers, ppSOTargets); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[93]))((ID3D11DeviceContext*)Unsafe.AsPointer(ref this), NumBuffers, ppSOTargets); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(94)] + public void RSGetState(ID3D11RasterizerState* ppRasterizerState) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[94]))((ID3D11DeviceContext*)Unsafe.AsPointer(ref this), ppRasterizerState); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[94]))((ID3D11DeviceContext*)Unsafe.AsPointer(ref this), ppRasterizerState); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(95)] + public void RSGetViewports(uint* pNumViewports, Viewport* pViewports) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[95]))((ID3D11DeviceContext*)Unsafe.AsPointer(ref this), pNumViewports, pViewports); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[95]))((ID3D11DeviceContext*)Unsafe.AsPointer(ref this), pNumViewports, pViewports); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(96)] + public void RSGetScissorRects(uint* pNumRects, RawRect* pRects) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[96]))((ID3D11DeviceContext*)Unsafe.AsPointer(ref this), pNumRects, pRects); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[96]))((ID3D11DeviceContext*)Unsafe.AsPointer(ref this), pNumRects, pRects); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(97)] + public void HSGetShaderResources(uint StartSlot, uint NumViews, ID3D11ShaderResourceView* ppShaderResourceViews) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[97]))((ID3D11DeviceContext*)Unsafe.AsPointer(ref this), StartSlot, NumViews, ppShaderResourceViews); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[97]))((ID3D11DeviceContext*)Unsafe.AsPointer(ref this), StartSlot, NumViews, ppShaderResourceViews); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(98)] + public void HSGetShader(ID3D11HullShader* ppHullShader, ID3D11ClassInstance* ppClassInstances, uint* pNumClassInstances) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[98]))((ID3D11DeviceContext*)Unsafe.AsPointer(ref this), ppHullShader, ppClassInstances, pNumClassInstances); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[98]))((ID3D11DeviceContext*)Unsafe.AsPointer(ref this), ppHullShader, ppClassInstances, pNumClassInstances); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(99)] + public void HSGetSamplers(uint StartSlot, uint NumSamplers, ID3D11SamplerState* ppSamplers) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[99]))((ID3D11DeviceContext*)Unsafe.AsPointer(ref this), StartSlot, NumSamplers, ppSamplers); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[99]))((ID3D11DeviceContext*)Unsafe.AsPointer(ref this), StartSlot, NumSamplers, ppSamplers); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(100)] + public void HSGetConstantBuffers(uint StartSlot, uint NumBuffers, ID3D11Buffer* ppConstantBuffers) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[100]))((ID3D11DeviceContext*)Unsafe.AsPointer(ref this), StartSlot, NumBuffers, ppConstantBuffers); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[100]))((ID3D11DeviceContext*)Unsafe.AsPointer(ref this), StartSlot, NumBuffers, ppConstantBuffers); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(101)] + public void DSGetShaderResources(uint StartSlot, uint NumViews, ID3D11ShaderResourceView* ppShaderResourceViews) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[101]))((ID3D11DeviceContext*)Unsafe.AsPointer(ref this), StartSlot, NumViews, ppShaderResourceViews); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[101]))((ID3D11DeviceContext*)Unsafe.AsPointer(ref this), StartSlot, NumViews, ppShaderResourceViews); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(102)] + public void DSGetShader(ID3D11DomainShader* ppDomainShader, ID3D11ClassInstance* ppClassInstances, uint* pNumClassInstances) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[102]))((ID3D11DeviceContext*)Unsafe.AsPointer(ref this), ppDomainShader, ppClassInstances, pNumClassInstances); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[102]))((ID3D11DeviceContext*)Unsafe.AsPointer(ref this), ppDomainShader, ppClassInstances, pNumClassInstances); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(103)] + public void DSGetSamplers(uint StartSlot, uint NumSamplers, ID3D11SamplerState* ppSamplers) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[103]))((ID3D11DeviceContext*)Unsafe.AsPointer(ref this), StartSlot, NumSamplers, ppSamplers); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[103]))((ID3D11DeviceContext*)Unsafe.AsPointer(ref this), StartSlot, NumSamplers, ppSamplers); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(104)] + public void DSGetConstantBuffers(uint StartSlot, uint NumBuffers, ID3D11Buffer* ppConstantBuffers) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[104]))((ID3D11DeviceContext*)Unsafe.AsPointer(ref this), StartSlot, NumBuffers, ppConstantBuffers); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[104]))((ID3D11DeviceContext*)Unsafe.AsPointer(ref this), StartSlot, NumBuffers, ppConstantBuffers); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(105)] + public void CSGetShaderResources(uint StartSlot, uint NumViews, ID3D11ShaderResourceView* ppShaderResourceViews) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[105]))((ID3D11DeviceContext*)Unsafe.AsPointer(ref this), StartSlot, NumViews, ppShaderResourceViews); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[105]))((ID3D11DeviceContext*)Unsafe.AsPointer(ref this), StartSlot, NumViews, ppShaderResourceViews); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(106)] + public void CSGetUnorderedAccessViews(uint StartSlot, uint NumUAVs, ID3D11UnorderedAccessView* ppUnorderedAccessViews) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[106]))((ID3D11DeviceContext*)Unsafe.AsPointer(ref this), StartSlot, NumUAVs, ppUnorderedAccessViews); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[106]))((ID3D11DeviceContext*)Unsafe.AsPointer(ref this), StartSlot, NumUAVs, ppUnorderedAccessViews); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(107)] + public void CSGetShader(ID3D11ComputeShader* ppComputeShader, ID3D11ClassInstance* ppClassInstances, uint* pNumClassInstances) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[107]))((ID3D11DeviceContext*)Unsafe.AsPointer(ref this), ppComputeShader, ppClassInstances, pNumClassInstances); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[107]))((ID3D11DeviceContext*)Unsafe.AsPointer(ref this), ppComputeShader, ppClassInstances, pNumClassInstances); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(108)] + public void CSGetSamplers(uint StartSlot, uint NumSamplers, ID3D11SamplerState* ppSamplers) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[108]))((ID3D11DeviceContext*)Unsafe.AsPointer(ref this), StartSlot, NumSamplers, ppSamplers); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[108]))((ID3D11DeviceContext*)Unsafe.AsPointer(ref this), StartSlot, NumSamplers, ppSamplers); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(109)] + public void CSGetConstantBuffers(uint StartSlot, uint NumBuffers, ID3D11Buffer* ppConstantBuffers) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[109]))((ID3D11DeviceContext*)Unsafe.AsPointer(ref this), StartSlot, NumBuffers, ppConstantBuffers); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[109]))((ID3D11DeviceContext*)Unsafe.AsPointer(ref this), StartSlot, NumBuffers, ppConstantBuffers); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(110)] + public void ClearState() + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[110]))((ID3D11DeviceContext*)Unsafe.AsPointer(ref this)); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[110]))((ID3D11DeviceContext*)Unsafe.AsPointer(ref this)); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(111)] + public void Flush() + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[111]))((ID3D11DeviceContext*)Unsafe.AsPointer(ref this)); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[111]))((ID3D11DeviceContext*)Unsafe.AsPointer(ref this)); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(112)] + public Graphics.Direct3D11.DeviceContextType GetType() + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[112]))((ID3D11DeviceContext*)Unsafe.AsPointer(ref this)); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[112]))((ID3D11DeviceContext*)Unsafe.AsPointer(ref this)); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(113)] + public uint GetContextFlags() + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[113]))((ID3D11DeviceContext*)Unsafe.AsPointer(ref this)); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[113]))((ID3D11DeviceContext*)Unsafe.AsPointer(ref this)); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(114)] + public HResult FinishCommandList(Bool32* RestoreDeferredContextState, ID3D11CommandList** ppCommandList) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[114]))((ID3D11DeviceContext*)Unsafe.AsPointer(ref this), RestoreDeferredContextState, ppCommandList); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[114]))((ID3D11DeviceContext*)Unsafe.AsPointer(ref this), RestoreDeferredContextState, ppCommandList); +#endif + } + + public interface Interface : ID3D11DeviceChild.Interface + { + } +} + +/// +/// ID3D11VideoDecoder +[Guid("3c9c5b51-995d-48d1-9b8d-fa5caeded65c")] +[NativeTypeName("struct ID3D11VideoDecoder : ID3D11DeviceChild")] +[NativeInheritance("ID3D11DeviceChild")] +public unsafe partial struct ID3D11VideoDecoder : ID3D11VideoDecoder.Interface +{ + public static ref readonly Guid IID_ID3D11VideoDecoder + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x51, 0x5B, 0x9C, 0x3C, + 0x5D, 0x99, + 0xD1, 0x48, + 0x9B, + 0x8D, + 0xFA, + 0x5C, + 0xAE, + 0xDE, + 0xD6, + 0x5C + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_ID3D11VideoDecoder)); + + public void** lpVtbl; + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(0)] + public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(1)] + [return: NativeTypeName("ULONG")] + public uint AddRef() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(2)] + [return: NativeTypeName("ULONG")] + public uint Release() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(3)] + public void GetDevice(ID3D11Device* ppDevice) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[3]))((ID3D11VideoDecoder*)Unsafe.AsPointer(ref this), ppDevice); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((ID3D11VideoDecoder*)Unsafe.AsPointer(ref this), ppDevice); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public HResult GetPrivateData(Guid* guid, uint* pDataSize, void* pData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[4]))((ID3D11VideoDecoder*)Unsafe.AsPointer(ref this), guid, pDataSize, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((ID3D11VideoDecoder*)Unsafe.AsPointer(ref this), guid, pDataSize, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(5)] + public HResult SetPrivateData(Guid* guid, uint DataSize, void* pData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[5]))((ID3D11VideoDecoder*)Unsafe.AsPointer(ref this), guid, DataSize, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((ID3D11VideoDecoder*)Unsafe.AsPointer(ref this), guid, DataSize, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(6)] + public HResult SetPrivateDataInterface(Guid* guid, IUnknown* pData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[6]))((ID3D11VideoDecoder*)Unsafe.AsPointer(ref this), guid, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((ID3D11VideoDecoder*)Unsafe.AsPointer(ref this), guid, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(7)] + public HResult GetCreationParameters(VideoDecoderDescription* pVideoDesc, VideoDecoderConfig* pConfig) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[7]))((ID3D11VideoDecoder*)Unsafe.AsPointer(ref this), pVideoDesc, pConfig); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((ID3D11VideoDecoder*)Unsafe.AsPointer(ref this), pVideoDesc, pConfig); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(8)] + public HResult GetDriverHandle(IntPtr* pDriverHandle) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[8]))((ID3D11VideoDecoder*)Unsafe.AsPointer(ref this), pDriverHandle); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[8]))((ID3D11VideoDecoder*)Unsafe.AsPointer(ref this), pDriverHandle); +#endif + } + + public interface Interface : ID3D11DeviceChild.Interface + { + } +} + +/// +/// ID3D11VideoProcessorEnumerator +[Guid("31627037-53ab-4200-9061-05faa9ab45f9")] +[NativeTypeName("struct ID3D11VideoProcessorEnumerator : ID3D11DeviceChild")] +[NativeInheritance("ID3D11DeviceChild")] +public unsafe partial struct ID3D11VideoProcessorEnumerator : ID3D11VideoProcessorEnumerator.Interface +{ + public static ref readonly Guid IID_ID3D11VideoProcessorEnumerator + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x37, 0x70, 0x62, 0x31, + 0xAB, 0x53, + 0x00, 0x42, + 0x90, + 0x61, + 0x05, + 0xFA, + 0xA9, + 0xAB, + 0x45, + 0xF9 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_ID3D11VideoProcessorEnumerator)); + + public void** lpVtbl; + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(0)] + public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(1)] + [return: NativeTypeName("ULONG")] + public uint AddRef() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(2)] + [return: NativeTypeName("ULONG")] + public uint Release() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(3)] + public void GetDevice(ID3D11Device* ppDevice) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[3]))((ID3D11VideoProcessorEnumerator*)Unsafe.AsPointer(ref this), ppDevice); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((ID3D11VideoProcessorEnumerator*)Unsafe.AsPointer(ref this), ppDevice); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public HResult GetPrivateData(Guid* guid, uint* pDataSize, void* pData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[4]))((ID3D11VideoProcessorEnumerator*)Unsafe.AsPointer(ref this), guid, pDataSize, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((ID3D11VideoProcessorEnumerator*)Unsafe.AsPointer(ref this), guid, pDataSize, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(5)] + public HResult SetPrivateData(Guid* guid, uint DataSize, void* pData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[5]))((ID3D11VideoProcessorEnumerator*)Unsafe.AsPointer(ref this), guid, DataSize, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((ID3D11VideoProcessorEnumerator*)Unsafe.AsPointer(ref this), guid, DataSize, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(6)] + public HResult SetPrivateDataInterface(Guid* guid, IUnknown* pData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[6]))((ID3D11VideoProcessorEnumerator*)Unsafe.AsPointer(ref this), guid, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((ID3D11VideoProcessorEnumerator*)Unsafe.AsPointer(ref this), guid, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(7)] + public HResult GetVideoProcessorContentDesc(VideoProcessorContentDescription* pContentDesc) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[7]))((ID3D11VideoProcessorEnumerator*)Unsafe.AsPointer(ref this), pContentDesc); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((ID3D11VideoProcessorEnumerator*)Unsafe.AsPointer(ref this), pContentDesc); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(8)] + public HResult CheckVideoProcessorFormat(Graphics.Dxgi.Common.Format Format, uint* pFlags) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[8]))((ID3D11VideoProcessorEnumerator*)Unsafe.AsPointer(ref this), Format, pFlags); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[8]))((ID3D11VideoProcessorEnumerator*)Unsafe.AsPointer(ref this), Format, pFlags); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(9)] + public HResult GetVideoProcessorCaps(VideoProcessorCaps* pCaps) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[9]))((ID3D11VideoProcessorEnumerator*)Unsafe.AsPointer(ref this), pCaps); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[9]))((ID3D11VideoProcessorEnumerator*)Unsafe.AsPointer(ref this), pCaps); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(10)] + public HResult GetVideoProcessorRateConversionCaps(uint TypeIndex, VideoProcessorRateConversionCaps* pCaps) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[10]))((ID3D11VideoProcessorEnumerator*)Unsafe.AsPointer(ref this), TypeIndex, pCaps); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[10]))((ID3D11VideoProcessorEnumerator*)Unsafe.AsPointer(ref this), TypeIndex, pCaps); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(11)] + public HResult GetVideoProcessorCustomRate(uint TypeIndex, uint CustomRateIndex, VideoProcessorCustomRate* pRate) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[11]))((ID3D11VideoProcessorEnumerator*)Unsafe.AsPointer(ref this), TypeIndex, CustomRateIndex, pRate); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[11]))((ID3D11VideoProcessorEnumerator*)Unsafe.AsPointer(ref this), TypeIndex, CustomRateIndex, pRate); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(12)] + public HResult GetVideoProcessorFilterRange(VideoProcessorFilter Filter, VideoProcessorFilterRange* pRange) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[12]))((ID3D11VideoProcessorEnumerator*)Unsafe.AsPointer(ref this), Filter, pRange); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[12]))((ID3D11VideoProcessorEnumerator*)Unsafe.AsPointer(ref this), Filter, pRange); +#endif + } + + public interface Interface : ID3D11DeviceChild.Interface + { + } +} + +/// +/// ID3D11VideoProcessor +[Guid("1d7b0652-185f-41c6-85ce-0c5be3d4ae6c")] +[NativeTypeName("struct ID3D11VideoProcessor : ID3D11DeviceChild")] +[NativeInheritance("ID3D11DeviceChild")] +public unsafe partial struct ID3D11VideoProcessor : ID3D11VideoProcessor.Interface +{ + public static ref readonly Guid IID_ID3D11VideoProcessor + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x52, 0x06, 0x7B, 0x1D, + 0x5F, 0x18, + 0xC6, 0x41, + 0x85, + 0xCE, + 0x0C, + 0x5B, + 0xE3, + 0xD4, + 0xAE, + 0x6C + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_ID3D11VideoProcessor)); + + public void** lpVtbl; + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(0)] + public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(1)] + [return: NativeTypeName("ULONG")] + public uint AddRef() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(2)] + [return: NativeTypeName("ULONG")] + public uint Release() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(3)] + public void GetDevice(ID3D11Device* ppDevice) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[3]))((ID3D11VideoProcessor*)Unsafe.AsPointer(ref this), ppDevice); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((ID3D11VideoProcessor*)Unsafe.AsPointer(ref this), ppDevice); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public HResult GetPrivateData(Guid* guid, uint* pDataSize, void* pData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[4]))((ID3D11VideoProcessor*)Unsafe.AsPointer(ref this), guid, pDataSize, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((ID3D11VideoProcessor*)Unsafe.AsPointer(ref this), guid, pDataSize, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(5)] + public HResult SetPrivateData(Guid* guid, uint DataSize, void* pData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[5]))((ID3D11VideoProcessor*)Unsafe.AsPointer(ref this), guid, DataSize, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((ID3D11VideoProcessor*)Unsafe.AsPointer(ref this), guid, DataSize, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(6)] + public HResult SetPrivateDataInterface(Guid* guid, IUnknown* pData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[6]))((ID3D11VideoProcessor*)Unsafe.AsPointer(ref this), guid, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((ID3D11VideoProcessor*)Unsafe.AsPointer(ref this), guid, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(7)] + public void GetContentDesc(VideoProcessorContentDescription* pDesc) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[7]))((ID3D11VideoProcessor*)Unsafe.AsPointer(ref this), pDesc); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((ID3D11VideoProcessor*)Unsafe.AsPointer(ref this), pDesc); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(8)] + public void GetRateConversionCaps(VideoProcessorRateConversionCaps* pCaps) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[8]))((ID3D11VideoProcessor*)Unsafe.AsPointer(ref this), pCaps); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[8]))((ID3D11VideoProcessor*)Unsafe.AsPointer(ref this), pCaps); +#endif + } + + public interface Interface : ID3D11DeviceChild.Interface + { + } +} + +/// +/// ID3D11AuthenticatedChannel +[Guid("3015a308-dcbd-47aa-a747-192486d14d4a")] +[NativeTypeName("struct ID3D11AuthenticatedChannel : ID3D11DeviceChild")] +[NativeInheritance("ID3D11DeviceChild")] +public unsafe partial struct ID3D11AuthenticatedChannel : ID3D11AuthenticatedChannel.Interface +{ + public static ref readonly Guid IID_ID3D11AuthenticatedChannel + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x08, 0xA3, 0x15, 0x30, + 0xBD, 0xDC, + 0xAA, 0x47, + 0xA7, + 0x47, + 0x19, + 0x24, + 0x86, + 0xD1, + 0x4D, + 0x4A + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_ID3D11AuthenticatedChannel)); + + public void** lpVtbl; + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(0)] + public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(1)] + [return: NativeTypeName("ULONG")] + public uint AddRef() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(2)] + [return: NativeTypeName("ULONG")] + public uint Release() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(3)] + public void GetDevice(ID3D11Device* ppDevice) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[3]))((ID3D11AuthenticatedChannel*)Unsafe.AsPointer(ref this), ppDevice); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((ID3D11AuthenticatedChannel*)Unsafe.AsPointer(ref this), ppDevice); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public HResult GetPrivateData(Guid* guid, uint* pDataSize, void* pData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[4]))((ID3D11AuthenticatedChannel*)Unsafe.AsPointer(ref this), guid, pDataSize, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((ID3D11AuthenticatedChannel*)Unsafe.AsPointer(ref this), guid, pDataSize, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(5)] + public HResult SetPrivateData(Guid* guid, uint DataSize, void* pData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[5]))((ID3D11AuthenticatedChannel*)Unsafe.AsPointer(ref this), guid, DataSize, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((ID3D11AuthenticatedChannel*)Unsafe.AsPointer(ref this), guid, DataSize, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(6)] + public HResult SetPrivateDataInterface(Guid* guid, IUnknown* pData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[6]))((ID3D11AuthenticatedChannel*)Unsafe.AsPointer(ref this), guid, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((ID3D11AuthenticatedChannel*)Unsafe.AsPointer(ref this), guid, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(7)] + public HResult GetCertificateSize(uint* pCertificateSize) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[7]))((ID3D11AuthenticatedChannel*)Unsafe.AsPointer(ref this), pCertificateSize); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((ID3D11AuthenticatedChannel*)Unsafe.AsPointer(ref this), pCertificateSize); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(8)] + public HResult GetCertificate(uint CertificateSize, byte* pCertificate) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[8]))((ID3D11AuthenticatedChannel*)Unsafe.AsPointer(ref this), CertificateSize, pCertificate); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[8]))((ID3D11AuthenticatedChannel*)Unsafe.AsPointer(ref this), CertificateSize, pCertificate); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(9)] + public void GetChannelHandle(IntPtr* pChannelHandle) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[9]))((ID3D11AuthenticatedChannel*)Unsafe.AsPointer(ref this), pChannelHandle); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[9]))((ID3D11AuthenticatedChannel*)Unsafe.AsPointer(ref this), pChannelHandle); +#endif + } + + public interface Interface : ID3D11DeviceChild.Interface + { + } +} + +/// +/// ID3D11CryptoSession +[Guid("9b32f9ad-bdcc-40a6-a39d-d5c865845720")] +[NativeTypeName("struct ID3D11CryptoSession : ID3D11DeviceChild")] +[NativeInheritance("ID3D11DeviceChild")] +public unsafe partial struct ID3D11CryptoSession : ID3D11CryptoSession.Interface +{ + public static ref readonly Guid IID_ID3D11CryptoSession + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0xAD, 0xF9, 0x32, 0x9B, + 0xCC, 0xBD, + 0xA6, 0x40, + 0xA3, + 0x9D, + 0xD5, + 0xC8, + 0x65, + 0x84, + 0x57, + 0x20 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_ID3D11CryptoSession)); + + public void** lpVtbl; + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(0)] + public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(1)] + [return: NativeTypeName("ULONG")] + public uint AddRef() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(2)] + [return: NativeTypeName("ULONG")] + public uint Release() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(3)] + public void GetDevice(ID3D11Device* ppDevice) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[3]))((ID3D11CryptoSession*)Unsafe.AsPointer(ref this), ppDevice); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((ID3D11CryptoSession*)Unsafe.AsPointer(ref this), ppDevice); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public HResult GetPrivateData(Guid* guid, uint* pDataSize, void* pData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[4]))((ID3D11CryptoSession*)Unsafe.AsPointer(ref this), guid, pDataSize, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((ID3D11CryptoSession*)Unsafe.AsPointer(ref this), guid, pDataSize, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(5)] + public HResult SetPrivateData(Guid* guid, uint DataSize, void* pData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[5]))((ID3D11CryptoSession*)Unsafe.AsPointer(ref this), guid, DataSize, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((ID3D11CryptoSession*)Unsafe.AsPointer(ref this), guid, DataSize, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(6)] + public HResult SetPrivateDataInterface(Guid* guid, IUnknown* pData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[6]))((ID3D11CryptoSession*)Unsafe.AsPointer(ref this), guid, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((ID3D11CryptoSession*)Unsafe.AsPointer(ref this), guid, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(7)] + public void GetCryptoType(Guid* pCryptoType) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[7]))((ID3D11CryptoSession*)Unsafe.AsPointer(ref this), pCryptoType); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((ID3D11CryptoSession*)Unsafe.AsPointer(ref this), pCryptoType); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(8)] + public void GetDecoderProfile(Guid* pDecoderProfile) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[8]))((ID3D11CryptoSession*)Unsafe.AsPointer(ref this), pDecoderProfile); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[8]))((ID3D11CryptoSession*)Unsafe.AsPointer(ref this), pDecoderProfile); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(9)] + public HResult GetCertificateSize(uint* pCertificateSize) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[9]))((ID3D11CryptoSession*)Unsafe.AsPointer(ref this), pCertificateSize); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[9]))((ID3D11CryptoSession*)Unsafe.AsPointer(ref this), pCertificateSize); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(10)] + public HResult GetCertificate(uint CertificateSize, byte* pCertificate) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[10]))((ID3D11CryptoSession*)Unsafe.AsPointer(ref this), CertificateSize, pCertificate); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[10]))((ID3D11CryptoSession*)Unsafe.AsPointer(ref this), CertificateSize, pCertificate); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(11)] + public void GetCryptoSessionHandle(IntPtr* pCryptoSessionHandle) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[11]))((ID3D11CryptoSession*)Unsafe.AsPointer(ref this), pCryptoSessionHandle); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[11]))((ID3D11CryptoSession*)Unsafe.AsPointer(ref this), pCryptoSessionHandle); +#endif + } + + public interface Interface : ID3D11DeviceChild.Interface + { + } +} + +/// +/// ID3D11VideoDecoderOutputView +[Guid("c2931aea-2a85-4f20-860f-fba1fd256e18")] +[NativeTypeName("struct ID3D11VideoDecoderOutputView : ID3D11View")] +[NativeInheritance("ID3D11View")] +public unsafe partial struct ID3D11VideoDecoderOutputView : ID3D11VideoDecoderOutputView.Interface +{ + public static ref readonly Guid IID_ID3D11VideoDecoderOutputView + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0xEA, 0x1A, 0x93, 0xC2, + 0x85, 0x2A, + 0x20, 0x4F, + 0x86, + 0x0F, + 0xFB, + 0xA1, + 0xFD, + 0x25, + 0x6E, + 0x18 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_ID3D11VideoDecoderOutputView)); + + public void** lpVtbl; + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(0)] + public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(1)] + [return: NativeTypeName("ULONG")] + public uint AddRef() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(2)] + [return: NativeTypeName("ULONG")] + public uint Release() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(3)] + public void GetResource(ID3D11Resource* ppResource) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[3]))((ID3D11VideoDecoderOutputView*)Unsafe.AsPointer(ref this), ppResource); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((ID3D11VideoDecoderOutputView*)Unsafe.AsPointer(ref this), ppResource); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public void GetDevice(ID3D11Device* ppDevice) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[4]))((ID3D11VideoDecoderOutputView*)Unsafe.AsPointer(ref this), ppDevice); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((ID3D11VideoDecoderOutputView*)Unsafe.AsPointer(ref this), ppDevice); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(5)] + public HResult GetPrivateData(Guid* guid, uint* pDataSize, void* pData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[5]))((ID3D11VideoDecoderOutputView*)Unsafe.AsPointer(ref this), guid, pDataSize, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((ID3D11VideoDecoderOutputView*)Unsafe.AsPointer(ref this), guid, pDataSize, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(6)] + public HResult SetPrivateData(Guid* guid, uint DataSize, void* pData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[6]))((ID3D11VideoDecoderOutputView*)Unsafe.AsPointer(ref this), guid, DataSize, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((ID3D11VideoDecoderOutputView*)Unsafe.AsPointer(ref this), guid, DataSize, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(7)] + public HResult SetPrivateDataInterface(Guid* guid, IUnknown* pData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[7]))((ID3D11VideoDecoderOutputView*)Unsafe.AsPointer(ref this), guid, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((ID3D11VideoDecoderOutputView*)Unsafe.AsPointer(ref this), guid, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(8)] + public void GetDesc(VideoDecoderOutputViewDescription* pDesc) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[8]))((ID3D11VideoDecoderOutputView*)Unsafe.AsPointer(ref this), pDesc); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[8]))((ID3D11VideoDecoderOutputView*)Unsafe.AsPointer(ref this), pDesc); +#endif + } + + public interface Interface : ID3D11View.Interface + { + } +} + +/// +/// ID3D11VideoProcessorInputView +[Guid("11ec5a5f-51dc-4945-ab34-6e8c21300ea5")] +[NativeTypeName("struct ID3D11VideoProcessorInputView : ID3D11View")] +[NativeInheritance("ID3D11View")] +public unsafe partial struct ID3D11VideoProcessorInputView : ID3D11VideoProcessorInputView.Interface +{ + public static ref readonly Guid IID_ID3D11VideoProcessorInputView + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x5F, 0x5A, 0xEC, 0x11, + 0xDC, 0x51, + 0x45, 0x49, + 0xAB, + 0x34, + 0x6E, + 0x8C, + 0x21, + 0x30, + 0x0E, + 0xA5 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_ID3D11VideoProcessorInputView)); + + public void** lpVtbl; + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(0)] + public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(1)] + [return: NativeTypeName("ULONG")] + public uint AddRef() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(2)] + [return: NativeTypeName("ULONG")] + public uint Release() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(3)] + public void GetResource(ID3D11Resource* ppResource) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[3]))((ID3D11VideoProcessorInputView*)Unsafe.AsPointer(ref this), ppResource); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((ID3D11VideoProcessorInputView*)Unsafe.AsPointer(ref this), ppResource); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public void GetDevice(ID3D11Device* ppDevice) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[4]))((ID3D11VideoProcessorInputView*)Unsafe.AsPointer(ref this), ppDevice); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((ID3D11VideoProcessorInputView*)Unsafe.AsPointer(ref this), ppDevice); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(5)] + public HResult GetPrivateData(Guid* guid, uint* pDataSize, void* pData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[5]))((ID3D11VideoProcessorInputView*)Unsafe.AsPointer(ref this), guid, pDataSize, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((ID3D11VideoProcessorInputView*)Unsafe.AsPointer(ref this), guid, pDataSize, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(6)] + public HResult SetPrivateData(Guid* guid, uint DataSize, void* pData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[6]))((ID3D11VideoProcessorInputView*)Unsafe.AsPointer(ref this), guid, DataSize, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((ID3D11VideoProcessorInputView*)Unsafe.AsPointer(ref this), guid, DataSize, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(7)] + public HResult SetPrivateDataInterface(Guid* guid, IUnknown* pData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[7]))((ID3D11VideoProcessorInputView*)Unsafe.AsPointer(ref this), guid, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((ID3D11VideoProcessorInputView*)Unsafe.AsPointer(ref this), guid, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(8)] + public void GetDesc(VideoProcessorInputViewDescription* pDesc) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[8]))((ID3D11VideoProcessorInputView*)Unsafe.AsPointer(ref this), pDesc); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[8]))((ID3D11VideoProcessorInputView*)Unsafe.AsPointer(ref this), pDesc); +#endif + } + + public interface Interface : ID3D11View.Interface + { + } +} + +/// +/// ID3D11VideoProcessorOutputView +[Guid("a048285e-25a9-4527-bd93-d68b68c44254")] +[NativeTypeName("struct ID3D11VideoProcessorOutputView : ID3D11View")] +[NativeInheritance("ID3D11View")] +public unsafe partial struct ID3D11VideoProcessorOutputView : ID3D11VideoProcessorOutputView.Interface +{ + public static ref readonly Guid IID_ID3D11VideoProcessorOutputView + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x5E, 0x28, 0x48, 0xA0, + 0xA9, 0x25, + 0x27, 0x45, + 0xBD, + 0x93, + 0xD6, + 0x8B, + 0x68, + 0xC4, + 0x42, + 0x54 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_ID3D11VideoProcessorOutputView)); + + public void** lpVtbl; + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(0)] + public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(1)] + [return: NativeTypeName("ULONG")] + public uint AddRef() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(2)] + [return: NativeTypeName("ULONG")] + public uint Release() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(3)] + public void GetResource(ID3D11Resource* ppResource) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[3]))((ID3D11VideoProcessorOutputView*)Unsafe.AsPointer(ref this), ppResource); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((ID3D11VideoProcessorOutputView*)Unsafe.AsPointer(ref this), ppResource); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public void GetDevice(ID3D11Device* ppDevice) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[4]))((ID3D11VideoProcessorOutputView*)Unsafe.AsPointer(ref this), ppDevice); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((ID3D11VideoProcessorOutputView*)Unsafe.AsPointer(ref this), ppDevice); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(5)] + public HResult GetPrivateData(Guid* guid, uint* pDataSize, void* pData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[5]))((ID3D11VideoProcessorOutputView*)Unsafe.AsPointer(ref this), guid, pDataSize, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((ID3D11VideoProcessorOutputView*)Unsafe.AsPointer(ref this), guid, pDataSize, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(6)] + public HResult SetPrivateData(Guid* guid, uint DataSize, void* pData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[6]))((ID3D11VideoProcessorOutputView*)Unsafe.AsPointer(ref this), guid, DataSize, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((ID3D11VideoProcessorOutputView*)Unsafe.AsPointer(ref this), guid, DataSize, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(7)] + public HResult SetPrivateDataInterface(Guid* guid, IUnknown* pData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[7]))((ID3D11VideoProcessorOutputView*)Unsafe.AsPointer(ref this), guid, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((ID3D11VideoProcessorOutputView*)Unsafe.AsPointer(ref this), guid, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(8)] + public void GetDesc(VideoProcessorOutputViewDescription* pDesc) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[8]))((ID3D11VideoProcessorOutputView*)Unsafe.AsPointer(ref this), pDesc); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[8]))((ID3D11VideoProcessorOutputView*)Unsafe.AsPointer(ref this), pDesc); +#endif + } + + public interface Interface : ID3D11View.Interface + { + } +} + +/// +/// ID3D11VideoContext +[Guid("61f21c45-3c0e-4a74-9cea-67100d9ad5e4")] +[NativeTypeName("struct ID3D11VideoContext : ID3D11DeviceChild")] +[NativeInheritance("ID3D11DeviceChild")] +public unsafe partial struct ID3D11VideoContext : ID3D11VideoContext.Interface +{ + public static ref readonly Guid IID_ID3D11VideoContext + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x45, 0x1C, 0xF2, 0x61, + 0x0E, 0x3C, + 0x74, 0x4A, + 0x9C, + 0xEA, + 0x67, + 0x10, + 0x0D, + 0x9A, + 0xD5, + 0xE4 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_ID3D11VideoContext)); + + public void** lpVtbl; + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(0)] + public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(1)] + [return: NativeTypeName("ULONG")] + public uint AddRef() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(2)] + [return: NativeTypeName("ULONG")] + public uint Release() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(3)] + public void GetDevice(ID3D11Device* ppDevice) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[3]))((ID3D11VideoContext*)Unsafe.AsPointer(ref this), ppDevice); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((ID3D11VideoContext*)Unsafe.AsPointer(ref this), ppDevice); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public HResult GetPrivateData(Guid* guid, uint* pDataSize, void* pData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[4]))((ID3D11VideoContext*)Unsafe.AsPointer(ref this), guid, pDataSize, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((ID3D11VideoContext*)Unsafe.AsPointer(ref this), guid, pDataSize, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(5)] + public HResult SetPrivateData(Guid* guid, uint DataSize, void* pData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[5]))((ID3D11VideoContext*)Unsafe.AsPointer(ref this), guid, DataSize, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((ID3D11VideoContext*)Unsafe.AsPointer(ref this), guid, DataSize, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(6)] + public HResult SetPrivateDataInterface(Guid* guid, IUnknown* pData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[6]))((ID3D11VideoContext*)Unsafe.AsPointer(ref this), guid, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((ID3D11VideoContext*)Unsafe.AsPointer(ref this), guid, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(7)] + public HResult GetDecoderBuffer(ID3D11VideoDecoder* pDecoder, VideoDecoderBufferType Type, uint* pBufferSize, void** ppBuffer) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[7]))((ID3D11VideoContext*)Unsafe.AsPointer(ref this), pDecoder, Type, pBufferSize, ppBuffer); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((ID3D11VideoContext*)Unsafe.AsPointer(ref this), pDecoder, Type, pBufferSize, ppBuffer); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(8)] + public HResult ReleaseDecoderBuffer(ID3D11VideoDecoder* pDecoder, VideoDecoderBufferType Type) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[8]))((ID3D11VideoContext*)Unsafe.AsPointer(ref this), pDecoder, Type); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[8]))((ID3D11VideoContext*)Unsafe.AsPointer(ref this), pDecoder, Type); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(9)] + public HResult DecoderBeginFrame(ID3D11VideoDecoder* pDecoder, ID3D11VideoDecoderOutputView* pView, uint ContentKeySize, void* pContentKey) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[9]))((ID3D11VideoContext*)Unsafe.AsPointer(ref this), pDecoder, pView, ContentKeySize, pContentKey); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[9]))((ID3D11VideoContext*)Unsafe.AsPointer(ref this), pDecoder, pView, ContentKeySize, pContentKey); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(10)] + public HResult DecoderEndFrame(ID3D11VideoDecoder* pDecoder) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[10]))((ID3D11VideoContext*)Unsafe.AsPointer(ref this), pDecoder); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[10]))((ID3D11VideoContext*)Unsafe.AsPointer(ref this), pDecoder); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(11)] + public HResult SubmitDecoderBuffers(ID3D11VideoDecoder* pDecoder, uint NumBuffers, VideoDecoderBufferDescription* pBufferDesc) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[11]))((ID3D11VideoContext*)Unsafe.AsPointer(ref this), pDecoder, NumBuffers, pBufferDesc); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[11]))((ID3D11VideoContext*)Unsafe.AsPointer(ref this), pDecoder, NumBuffers, pBufferDesc); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(12)] + public int DecoderExtension(ID3D11VideoDecoder* pDecoder, VideoDecoderExtension* pExtensionData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[12]))((ID3D11VideoContext*)Unsafe.AsPointer(ref this), pDecoder, pExtensionData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[12]))((ID3D11VideoContext*)Unsafe.AsPointer(ref this), pDecoder, pExtensionData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(13)] + public void VideoProcessorSetOutputTargetRect(ID3D11VideoProcessor* pVideoProcessor, Bool32* Enable, RawRect* pRect) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[13]))((ID3D11VideoContext*)Unsafe.AsPointer(ref this), pVideoProcessor, Enable, pRect); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[13]))((ID3D11VideoContext*)Unsafe.AsPointer(ref this), pVideoProcessor, Enable, pRect); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(14)] + public void VideoProcessorSetOutputBackgroundColor(ID3D11VideoProcessor* pVideoProcessor, Bool32* YCbCr, VideoColor* pColor) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[14]))((ID3D11VideoContext*)Unsafe.AsPointer(ref this), pVideoProcessor, YCbCr, pColor); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[14]))((ID3D11VideoContext*)Unsafe.AsPointer(ref this), pVideoProcessor, YCbCr, pColor); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(15)] + public void VideoProcessorSetOutputColorSpace(ID3D11VideoProcessor* pVideoProcessor, VideoProcessorColorSpace* pColorSpace) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[15]))((ID3D11VideoContext*)Unsafe.AsPointer(ref this), pVideoProcessor, pColorSpace); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[15]))((ID3D11VideoContext*)Unsafe.AsPointer(ref this), pVideoProcessor, pColorSpace); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(16)] + public void VideoProcessorSetOutputAlphaFillMode(ID3D11VideoProcessor* pVideoProcessor, VideoProcessorAlphaFillMode AlphaFillMode, uint StreamIndex) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[16]))((ID3D11VideoContext*)Unsafe.AsPointer(ref this), pVideoProcessor, AlphaFillMode, StreamIndex); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[16]))((ID3D11VideoContext*)Unsafe.AsPointer(ref this), pVideoProcessor, AlphaFillMode, StreamIndex); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(17)] + public void VideoProcessorSetOutputConstriction(ID3D11VideoProcessor* pVideoProcessor, Bool32* Enable, System.Drawing.Size* Size) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[17]))((ID3D11VideoContext*)Unsafe.AsPointer(ref this), pVideoProcessor, Enable, Size); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[17]))((ID3D11VideoContext*)Unsafe.AsPointer(ref this), pVideoProcessor, Enable, Size); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(18)] + public void VideoProcessorSetOutputStereoMode(ID3D11VideoProcessor* pVideoProcessor, Bool32* Enable) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[18]))((ID3D11VideoContext*)Unsafe.AsPointer(ref this), pVideoProcessor, Enable); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[18]))((ID3D11VideoContext*)Unsafe.AsPointer(ref this), pVideoProcessor, Enable); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(19)] + public int VideoProcessorSetOutputExtension(ID3D11VideoProcessor* pVideoProcessor, Guid* pExtensionGuid, uint DataSize, void* pData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[19]))((ID3D11VideoContext*)Unsafe.AsPointer(ref this), pVideoProcessor, pExtensionGuid, DataSize, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[19]))((ID3D11VideoContext*)Unsafe.AsPointer(ref this), pVideoProcessor, pExtensionGuid, DataSize, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(20)] + public void VideoProcessorGetOutputTargetRect(ID3D11VideoProcessor* pVideoProcessor, Bool32* Enabled, RawRect* pRect) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[20]))((ID3D11VideoContext*)Unsafe.AsPointer(ref this), pVideoProcessor, Enabled, pRect); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[20]))((ID3D11VideoContext*)Unsafe.AsPointer(ref this), pVideoProcessor, Enabled, pRect); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(21)] + public void VideoProcessorGetOutputBackgroundColor(ID3D11VideoProcessor* pVideoProcessor, Bool32* pYCbCr, VideoColor* pColor) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[21]))((ID3D11VideoContext*)Unsafe.AsPointer(ref this), pVideoProcessor, pYCbCr, pColor); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[21]))((ID3D11VideoContext*)Unsafe.AsPointer(ref this), pVideoProcessor, pYCbCr, pColor); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(22)] + public void VideoProcessorGetOutputColorSpace(ID3D11VideoProcessor* pVideoProcessor, VideoProcessorColorSpace* pColorSpace) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[22]))((ID3D11VideoContext*)Unsafe.AsPointer(ref this), pVideoProcessor, pColorSpace); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[22]))((ID3D11VideoContext*)Unsafe.AsPointer(ref this), pVideoProcessor, pColorSpace); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(23)] + public void VideoProcessorGetOutputAlphaFillMode(ID3D11VideoProcessor* pVideoProcessor, VideoProcessorAlphaFillMode* pAlphaFillMode, uint* pStreamIndex) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[23]))((ID3D11VideoContext*)Unsafe.AsPointer(ref this), pVideoProcessor, pAlphaFillMode, pStreamIndex); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[23]))((ID3D11VideoContext*)Unsafe.AsPointer(ref this), pVideoProcessor, pAlphaFillMode, pStreamIndex); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(24)] + public void VideoProcessorGetOutputConstriction(ID3D11VideoProcessor* pVideoProcessor, Bool32* pEnabled, System.Drawing.Size* pSize) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[24]))((ID3D11VideoContext*)Unsafe.AsPointer(ref this), pVideoProcessor, pEnabled, pSize); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[24]))((ID3D11VideoContext*)Unsafe.AsPointer(ref this), pVideoProcessor, pEnabled, pSize); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(25)] + public void VideoProcessorGetOutputStereoMode(ID3D11VideoProcessor* pVideoProcessor, Bool32* pEnabled) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[25]))((ID3D11VideoContext*)Unsafe.AsPointer(ref this), pVideoProcessor, pEnabled); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[25]))((ID3D11VideoContext*)Unsafe.AsPointer(ref this), pVideoProcessor, pEnabled); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(26)] + public int VideoProcessorGetOutputExtension(ID3D11VideoProcessor* pVideoProcessor, Guid* pExtensionGuid, uint DataSize, void* pData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[26]))((ID3D11VideoContext*)Unsafe.AsPointer(ref this), pVideoProcessor, pExtensionGuid, DataSize, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[26]))((ID3D11VideoContext*)Unsafe.AsPointer(ref this), pVideoProcessor, pExtensionGuid, DataSize, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(27)] + public void VideoProcessorSetStreamFrameFormat(ID3D11VideoProcessor* pVideoProcessor, uint StreamIndex, VideoFrameFormat FrameFormat) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[27]))((ID3D11VideoContext*)Unsafe.AsPointer(ref this), pVideoProcessor, StreamIndex, FrameFormat); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[27]))((ID3D11VideoContext*)Unsafe.AsPointer(ref this), pVideoProcessor, StreamIndex, FrameFormat); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(28)] + public void VideoProcessorSetStreamColorSpace(ID3D11VideoProcessor* pVideoProcessor, uint StreamIndex, VideoProcessorColorSpace* pColorSpace) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[28]))((ID3D11VideoContext*)Unsafe.AsPointer(ref this), pVideoProcessor, StreamIndex, pColorSpace); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[28]))((ID3D11VideoContext*)Unsafe.AsPointer(ref this), pVideoProcessor, StreamIndex, pColorSpace); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(29)] + public void VideoProcessorSetStreamOutputRate(ID3D11VideoProcessor* pVideoProcessor, uint StreamIndex, VideoProcessorOutputRate OutputRate, Bool32* RepeatFrame, Graphics.Dxgi.Common.Rational* pCustomRate) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[29]))((ID3D11VideoContext*)Unsafe.AsPointer(ref this), pVideoProcessor, StreamIndex, OutputRate, RepeatFrame, pCustomRate); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[29]))((ID3D11VideoContext*)Unsafe.AsPointer(ref this), pVideoProcessor, StreamIndex, OutputRate, RepeatFrame, pCustomRate); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(30)] + public void VideoProcessorSetStreamSourceRect(ID3D11VideoProcessor* pVideoProcessor, uint StreamIndex, Bool32* Enable, RawRect* pRect) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[30]))((ID3D11VideoContext*)Unsafe.AsPointer(ref this), pVideoProcessor, StreamIndex, Enable, pRect); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[30]))((ID3D11VideoContext*)Unsafe.AsPointer(ref this), pVideoProcessor, StreamIndex, Enable, pRect); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(31)] + public void VideoProcessorSetStreamDestRect(ID3D11VideoProcessor* pVideoProcessor, uint StreamIndex, Bool32* Enable, RawRect* pRect) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[31]))((ID3D11VideoContext*)Unsafe.AsPointer(ref this), pVideoProcessor, StreamIndex, Enable, pRect); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[31]))((ID3D11VideoContext*)Unsafe.AsPointer(ref this), pVideoProcessor, StreamIndex, Enable, pRect); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(32)] + public void VideoProcessorSetStreamAlpha(ID3D11VideoProcessor* pVideoProcessor, uint StreamIndex, Bool32* Enable, float Alpha) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[32]))((ID3D11VideoContext*)Unsafe.AsPointer(ref this), pVideoProcessor, StreamIndex, Enable, Alpha); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[32]))((ID3D11VideoContext*)Unsafe.AsPointer(ref this), pVideoProcessor, StreamIndex, Enable, Alpha); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(33)] + public void VideoProcessorSetStreamPalette(ID3D11VideoProcessor* pVideoProcessor, uint StreamIndex, uint Count, uint* pEntries) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[33]))((ID3D11VideoContext*)Unsafe.AsPointer(ref this), pVideoProcessor, StreamIndex, Count, pEntries); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[33]))((ID3D11VideoContext*)Unsafe.AsPointer(ref this), pVideoProcessor, StreamIndex, Count, pEntries); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(34)] + public void VideoProcessorSetStreamPixelAspectRatio(ID3D11VideoProcessor* pVideoProcessor, uint StreamIndex, Bool32* Enable, Graphics.Dxgi.Common.Rational* pSourceAspectRatio, Graphics.Dxgi.Common.Rational* pDestinationAspectRatio) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[34]))((ID3D11VideoContext*)Unsafe.AsPointer(ref this), pVideoProcessor, StreamIndex, Enable, pSourceAspectRatio, pDestinationAspectRatio); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[34]))((ID3D11VideoContext*)Unsafe.AsPointer(ref this), pVideoProcessor, StreamIndex, Enable, pSourceAspectRatio, pDestinationAspectRatio); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(35)] + public void VideoProcessorSetStreamLumaKey(ID3D11VideoProcessor* pVideoProcessor, uint StreamIndex, Bool32* Enable, float Lower, float Upper) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[35]))((ID3D11VideoContext*)Unsafe.AsPointer(ref this), pVideoProcessor, StreamIndex, Enable, Lower, Upper); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[35]))((ID3D11VideoContext*)Unsafe.AsPointer(ref this), pVideoProcessor, StreamIndex, Enable, Lower, Upper); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(36)] + public void VideoProcessorSetStreamStereoFormat(ID3D11VideoProcessor* pVideoProcessor, uint StreamIndex, Bool32* Enable, VideoProcessorStereoFormat Format, Bool32* LeftViewFrame0, Bool32* BaseViewFrame0, VideoProcessorStereoFlipMode FlipMode, int MonoOffset) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[36]))((ID3D11VideoContext*)Unsafe.AsPointer(ref this), pVideoProcessor, StreamIndex, Enable, Format, LeftViewFrame0, BaseViewFrame0, FlipMode, MonoOffset); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[36]))((ID3D11VideoContext*)Unsafe.AsPointer(ref this), pVideoProcessor, StreamIndex, Enable, Format, LeftViewFrame0, BaseViewFrame0, FlipMode, MonoOffset); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(37)] + public void VideoProcessorSetStreamAutoProcessingMode(ID3D11VideoProcessor* pVideoProcessor, uint StreamIndex, Bool32* Enable) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[37]))((ID3D11VideoContext*)Unsafe.AsPointer(ref this), pVideoProcessor, StreamIndex, Enable); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[37]))((ID3D11VideoContext*)Unsafe.AsPointer(ref this), pVideoProcessor, StreamIndex, Enable); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(38)] + public void VideoProcessorSetStreamFilter(ID3D11VideoProcessor* pVideoProcessor, uint StreamIndex, VideoProcessorFilter Filter, Bool32* Enable, int Level) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[38]))((ID3D11VideoContext*)Unsafe.AsPointer(ref this), pVideoProcessor, StreamIndex, Filter, Enable, Level); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[38]))((ID3D11VideoContext*)Unsafe.AsPointer(ref this), pVideoProcessor, StreamIndex, Filter, Enable, Level); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(39)] + public int VideoProcessorSetStreamExtension(ID3D11VideoProcessor* pVideoProcessor, uint StreamIndex, Guid* pExtensionGuid, uint DataSize, void* pData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[39]))((ID3D11VideoContext*)Unsafe.AsPointer(ref this), pVideoProcessor, StreamIndex, pExtensionGuid, DataSize, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[39]))((ID3D11VideoContext*)Unsafe.AsPointer(ref this), pVideoProcessor, StreamIndex, pExtensionGuid, DataSize, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(40)] + public void VideoProcessorGetStreamFrameFormat(ID3D11VideoProcessor* pVideoProcessor, uint StreamIndex, VideoFrameFormat* pFrameFormat) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[40]))((ID3D11VideoContext*)Unsafe.AsPointer(ref this), pVideoProcessor, StreamIndex, pFrameFormat); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[40]))((ID3D11VideoContext*)Unsafe.AsPointer(ref this), pVideoProcessor, StreamIndex, pFrameFormat); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(41)] + public void VideoProcessorGetStreamColorSpace(ID3D11VideoProcessor* pVideoProcessor, uint StreamIndex, VideoProcessorColorSpace* pColorSpace) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[41]))((ID3D11VideoContext*)Unsafe.AsPointer(ref this), pVideoProcessor, StreamIndex, pColorSpace); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[41]))((ID3D11VideoContext*)Unsafe.AsPointer(ref this), pVideoProcessor, StreamIndex, pColorSpace); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(42)] + public void VideoProcessorGetStreamOutputRate(ID3D11VideoProcessor* pVideoProcessor, uint StreamIndex, VideoProcessorOutputRate* pOutputRate, Bool32* pRepeatFrame, Graphics.Dxgi.Common.Rational* pCustomRate) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[42]))((ID3D11VideoContext*)Unsafe.AsPointer(ref this), pVideoProcessor, StreamIndex, pOutputRate, pRepeatFrame, pCustomRate); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[42]))((ID3D11VideoContext*)Unsafe.AsPointer(ref this), pVideoProcessor, StreamIndex, pOutputRate, pRepeatFrame, pCustomRate); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(43)] + public void VideoProcessorGetStreamSourceRect(ID3D11VideoProcessor* pVideoProcessor, uint StreamIndex, Bool32* pEnabled, RawRect* pRect) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[43]))((ID3D11VideoContext*)Unsafe.AsPointer(ref this), pVideoProcessor, StreamIndex, pEnabled, pRect); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[43]))((ID3D11VideoContext*)Unsafe.AsPointer(ref this), pVideoProcessor, StreamIndex, pEnabled, pRect); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(44)] + public void VideoProcessorGetStreamDestRect(ID3D11VideoProcessor* pVideoProcessor, uint StreamIndex, Bool32* pEnabled, RawRect* pRect) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[44]))((ID3D11VideoContext*)Unsafe.AsPointer(ref this), pVideoProcessor, StreamIndex, pEnabled, pRect); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[44]))((ID3D11VideoContext*)Unsafe.AsPointer(ref this), pVideoProcessor, StreamIndex, pEnabled, pRect); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(45)] + public void VideoProcessorGetStreamAlpha(ID3D11VideoProcessor* pVideoProcessor, uint StreamIndex, Bool32* pEnabled, float* pAlpha) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[45]))((ID3D11VideoContext*)Unsafe.AsPointer(ref this), pVideoProcessor, StreamIndex, pEnabled, pAlpha); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[45]))((ID3D11VideoContext*)Unsafe.AsPointer(ref this), pVideoProcessor, StreamIndex, pEnabled, pAlpha); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(46)] + public void VideoProcessorGetStreamPalette(ID3D11VideoProcessor* pVideoProcessor, uint StreamIndex, uint Count, uint* pEntries) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[46]))((ID3D11VideoContext*)Unsafe.AsPointer(ref this), pVideoProcessor, StreamIndex, Count, pEntries); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[46]))((ID3D11VideoContext*)Unsafe.AsPointer(ref this), pVideoProcessor, StreamIndex, Count, pEntries); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(47)] + public void VideoProcessorGetStreamPixelAspectRatio(ID3D11VideoProcessor* pVideoProcessor, uint StreamIndex, Bool32* pEnabled, Graphics.Dxgi.Common.Rational* pSourceAspectRatio, Graphics.Dxgi.Common.Rational* pDestinationAspectRatio) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[47]))((ID3D11VideoContext*)Unsafe.AsPointer(ref this), pVideoProcessor, StreamIndex, pEnabled, pSourceAspectRatio, pDestinationAspectRatio); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[47]))((ID3D11VideoContext*)Unsafe.AsPointer(ref this), pVideoProcessor, StreamIndex, pEnabled, pSourceAspectRatio, pDestinationAspectRatio); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(48)] + public void VideoProcessorGetStreamLumaKey(ID3D11VideoProcessor* pVideoProcessor, uint StreamIndex, Bool32* pEnabled, float* pLower, float* pUpper) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[48]))((ID3D11VideoContext*)Unsafe.AsPointer(ref this), pVideoProcessor, StreamIndex, pEnabled, pLower, pUpper); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[48]))((ID3D11VideoContext*)Unsafe.AsPointer(ref this), pVideoProcessor, StreamIndex, pEnabled, pLower, pUpper); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(49)] + public void VideoProcessorGetStreamStereoFormat(ID3D11VideoProcessor* pVideoProcessor, uint StreamIndex, Bool32* pEnable, VideoProcessorStereoFormat* pFormat, Bool32* pLeftViewFrame0, Bool32* pBaseViewFrame0, VideoProcessorStereoFlipMode* pFlipMode, int* MonoOffset) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[49]))((ID3D11VideoContext*)Unsafe.AsPointer(ref this), pVideoProcessor, StreamIndex, pEnable, pFormat, pLeftViewFrame0, pBaseViewFrame0, pFlipMode, MonoOffset); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[49]))((ID3D11VideoContext*)Unsafe.AsPointer(ref this), pVideoProcessor, StreamIndex, pEnable, pFormat, pLeftViewFrame0, pBaseViewFrame0, pFlipMode, MonoOffset); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(50)] + public void VideoProcessorGetStreamAutoProcessingMode(ID3D11VideoProcessor* pVideoProcessor, uint StreamIndex, Bool32* pEnabled) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[50]))((ID3D11VideoContext*)Unsafe.AsPointer(ref this), pVideoProcessor, StreamIndex, pEnabled); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[50]))((ID3D11VideoContext*)Unsafe.AsPointer(ref this), pVideoProcessor, StreamIndex, pEnabled); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(51)] + public void VideoProcessorGetStreamFilter(ID3D11VideoProcessor* pVideoProcessor, uint StreamIndex, VideoProcessorFilter Filter, Bool32* pEnabled, int* pLevel) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[51]))((ID3D11VideoContext*)Unsafe.AsPointer(ref this), pVideoProcessor, StreamIndex, Filter, pEnabled, pLevel); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[51]))((ID3D11VideoContext*)Unsafe.AsPointer(ref this), pVideoProcessor, StreamIndex, Filter, pEnabled, pLevel); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(52)] + public int VideoProcessorGetStreamExtension(ID3D11VideoProcessor* pVideoProcessor, uint StreamIndex, Guid* pExtensionGuid, uint DataSize, void* pData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[52]))((ID3D11VideoContext*)Unsafe.AsPointer(ref this), pVideoProcessor, StreamIndex, pExtensionGuid, DataSize, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[52]))((ID3D11VideoContext*)Unsafe.AsPointer(ref this), pVideoProcessor, StreamIndex, pExtensionGuid, DataSize, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(53)] + public HResult VideoProcessorBlt(ID3D11VideoProcessor* pVideoProcessor, ID3D11VideoProcessorOutputView* pView, uint OutputFrame, uint StreamCount, VideoProcessorStream* pStreams) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[53]))((ID3D11VideoContext*)Unsafe.AsPointer(ref this), pVideoProcessor, pView, OutputFrame, StreamCount, pStreams); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[53]))((ID3D11VideoContext*)Unsafe.AsPointer(ref this), pVideoProcessor, pView, OutputFrame, StreamCount, pStreams); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(54)] + public HResult NegotiateCryptoSessionKeyExchange(ID3D11CryptoSession* pCryptoSession, uint DataSize, void* pData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[54]))((ID3D11VideoContext*)Unsafe.AsPointer(ref this), pCryptoSession, DataSize, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[54]))((ID3D11VideoContext*)Unsafe.AsPointer(ref this), pCryptoSession, DataSize, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(55)] + public void EncryptionBlt(ID3D11CryptoSession* pCryptoSession, ID3D11Texture2D* pSrcSurface, ID3D11Texture2D* pDstSurface, uint IVSize, void* pIV) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[55]))((ID3D11VideoContext*)Unsafe.AsPointer(ref this), pCryptoSession, pSrcSurface, pDstSurface, IVSize, pIV); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[55]))((ID3D11VideoContext*)Unsafe.AsPointer(ref this), pCryptoSession, pSrcSurface, pDstSurface, IVSize, pIV); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(56)] + public void DecryptionBlt(ID3D11CryptoSession* pCryptoSession, ID3D11Texture2D* pSrcSurface, ID3D11Texture2D* pDstSurface, EncryptedBlockInfo* pEncryptedBlockInfo, uint ContentKeySize, void* pContentKey, uint IVSize, void* pIV) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[56]))((ID3D11VideoContext*)Unsafe.AsPointer(ref this), pCryptoSession, pSrcSurface, pDstSurface, pEncryptedBlockInfo, ContentKeySize, pContentKey, IVSize, pIV); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[56]))((ID3D11VideoContext*)Unsafe.AsPointer(ref this), pCryptoSession, pSrcSurface, pDstSurface, pEncryptedBlockInfo, ContentKeySize, pContentKey, IVSize, pIV); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(57)] + public void StartSessionKeyRefresh(ID3D11CryptoSession* pCryptoSession, uint RandomNumberSize, void* pRandomNumber) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[57]))((ID3D11VideoContext*)Unsafe.AsPointer(ref this), pCryptoSession, RandomNumberSize, pRandomNumber); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[57]))((ID3D11VideoContext*)Unsafe.AsPointer(ref this), pCryptoSession, RandomNumberSize, pRandomNumber); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(58)] + public void FinishSessionKeyRefresh(ID3D11CryptoSession* pCryptoSession) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[58]))((ID3D11VideoContext*)Unsafe.AsPointer(ref this), pCryptoSession); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[58]))((ID3D11VideoContext*)Unsafe.AsPointer(ref this), pCryptoSession); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(59)] + public HResult GetEncryptionBltKey(ID3D11CryptoSession* pCryptoSession, uint KeySize, void* pReadbackKey) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[59]))((ID3D11VideoContext*)Unsafe.AsPointer(ref this), pCryptoSession, KeySize, pReadbackKey); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[59]))((ID3D11VideoContext*)Unsafe.AsPointer(ref this), pCryptoSession, KeySize, pReadbackKey); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(60)] + public HResult NegotiateAuthenticatedChannelKeyExchange(ID3D11AuthenticatedChannel* pChannel, uint DataSize, void* pData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[60]))((ID3D11VideoContext*)Unsafe.AsPointer(ref this), pChannel, DataSize, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[60]))((ID3D11VideoContext*)Unsafe.AsPointer(ref this), pChannel, DataSize, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(61)] + public HResult QueryAuthenticatedChannel(ID3D11AuthenticatedChannel* pChannel, uint InputSize, void* pInput, uint OutputSize, void* pOutput) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[61]))((ID3D11VideoContext*)Unsafe.AsPointer(ref this), pChannel, InputSize, pInput, OutputSize, pOutput); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[61]))((ID3D11VideoContext*)Unsafe.AsPointer(ref this), pChannel, InputSize, pInput, OutputSize, pOutput); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(62)] + public HResult ConfigureAuthenticatedChannel(ID3D11AuthenticatedChannel* pChannel, uint InputSize, void* pInput, AuthenticatedConfigureOutput* pOutput) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[62]))((ID3D11VideoContext*)Unsafe.AsPointer(ref this), pChannel, InputSize, pInput, pOutput); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[62]))((ID3D11VideoContext*)Unsafe.AsPointer(ref this), pChannel, InputSize, pInput, pOutput); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(63)] + public void VideoProcessorSetStreamRotation(ID3D11VideoProcessor* pVideoProcessor, uint StreamIndex, Bool32* Enable, VideoProcessorRotation Rotation) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[63]))((ID3D11VideoContext*)Unsafe.AsPointer(ref this), pVideoProcessor, StreamIndex, Enable, Rotation); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[63]))((ID3D11VideoContext*)Unsafe.AsPointer(ref this), pVideoProcessor, StreamIndex, Enable, Rotation); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(64)] + public void VideoProcessorGetStreamRotation(ID3D11VideoProcessor* pVideoProcessor, uint StreamIndex, Bool32* pEnable, VideoProcessorRotation* pRotation) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[64]))((ID3D11VideoContext*)Unsafe.AsPointer(ref this), pVideoProcessor, StreamIndex, pEnable, pRotation); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[64]))((ID3D11VideoContext*)Unsafe.AsPointer(ref this), pVideoProcessor, StreamIndex, pEnable, pRotation); +#endif + } + + public interface Interface : ID3D11DeviceChild.Interface + { + } +} + +/// +/// ID3D11VideoDevice +[Guid("10ec4d5b-975a-4689-b9e4-d0aac30fe333")] +[NativeTypeName("struct ID3D11VideoDevice : IUnknown")] +[NativeInheritance("IUnknown")] +public unsafe partial struct ID3D11VideoDevice : ID3D11VideoDevice.Interface +{ + public static ref readonly Guid IID_ID3D11VideoDevice + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x5B, 0x4D, 0xEC, 0x10, + 0x5A, 0x97, + 0x89, 0x46, + 0xB9, + 0xE4, + 0xD0, + 0xAA, + 0xC3, + 0x0F, + 0xE3, + 0x33 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_ID3D11VideoDevice)); + + public void** lpVtbl; + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(0)] + public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(1)] + [return: NativeTypeName("ULONG")] + public uint AddRef() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(2)] + [return: NativeTypeName("ULONG")] + public uint Release() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(3)] + public HResult CreateVideoDecoder(VideoDecoderDescription* pVideoDesc, VideoDecoderConfig* pConfig, ID3D11VideoDecoder** ppDecoder) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[3]))((ID3D11VideoDevice*)Unsafe.AsPointer(ref this), pVideoDesc, pConfig, ppDecoder); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((ID3D11VideoDevice*)Unsafe.AsPointer(ref this), pVideoDesc, pConfig, ppDecoder); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public HResult CreateVideoProcessor(ID3D11VideoProcessorEnumerator* pEnum, uint RateConversionIndex, ID3D11VideoProcessor** ppVideoProcessor) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[4]))((ID3D11VideoDevice*)Unsafe.AsPointer(ref this), pEnum, RateConversionIndex, ppVideoProcessor); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((ID3D11VideoDevice*)Unsafe.AsPointer(ref this), pEnum, RateConversionIndex, ppVideoProcessor); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(5)] + public HResult CreateAuthenticatedChannel(AuthenticatedChannelType ChannelType, ID3D11AuthenticatedChannel** ppAuthenticatedChannel) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[5]))((ID3D11VideoDevice*)Unsafe.AsPointer(ref this), ChannelType, ppAuthenticatedChannel); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((ID3D11VideoDevice*)Unsafe.AsPointer(ref this), ChannelType, ppAuthenticatedChannel); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(6)] + public HResult CreateCryptoSession(Guid* pCryptoType, Guid* pDecoderProfile, Guid* pKeyExchangeType, ID3D11CryptoSession** ppCryptoSession) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[6]))((ID3D11VideoDevice*)Unsafe.AsPointer(ref this), pCryptoType, pDecoderProfile, pKeyExchangeType, ppCryptoSession); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((ID3D11VideoDevice*)Unsafe.AsPointer(ref this), pCryptoType, pDecoderProfile, pKeyExchangeType, ppCryptoSession); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(7)] + public HResult CreateVideoDecoderOutputView(ID3D11Resource* pResource, VideoDecoderOutputViewDescription* pDesc, ID3D11VideoDecoderOutputView** ppVDOVView) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[7]))((ID3D11VideoDevice*)Unsafe.AsPointer(ref this), pResource, pDesc, ppVDOVView); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((ID3D11VideoDevice*)Unsafe.AsPointer(ref this), pResource, pDesc, ppVDOVView); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(8)] + public HResult CreateVideoProcessorInputView(ID3D11Resource* pResource, ID3D11VideoProcessorEnumerator* pEnum, VideoProcessorInputViewDescription* pDesc, ID3D11VideoProcessorInputView** ppVPIView) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[8]))((ID3D11VideoDevice*)Unsafe.AsPointer(ref this), pResource, pEnum, pDesc, ppVPIView); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[8]))((ID3D11VideoDevice*)Unsafe.AsPointer(ref this), pResource, pEnum, pDesc, ppVPIView); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(9)] + public HResult CreateVideoProcessorOutputView(ID3D11Resource* pResource, ID3D11VideoProcessorEnumerator* pEnum, VideoProcessorOutputViewDescription* pDesc, ID3D11VideoProcessorOutputView** ppVPOView) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[9]))((ID3D11VideoDevice*)Unsafe.AsPointer(ref this), pResource, pEnum, pDesc, ppVPOView); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[9]))((ID3D11VideoDevice*)Unsafe.AsPointer(ref this), pResource, pEnum, pDesc, ppVPOView); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(10)] + public HResult CreateVideoProcessorEnumerator(VideoProcessorContentDescription* pDesc, ID3D11VideoProcessorEnumerator** ppEnum) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[10]))((ID3D11VideoDevice*)Unsafe.AsPointer(ref this), pDesc, ppEnum); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[10]))((ID3D11VideoDevice*)Unsafe.AsPointer(ref this), pDesc, ppEnum); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(11)] + public uint GetVideoDecoderProfileCount() + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[11]))((ID3D11VideoDevice*)Unsafe.AsPointer(ref this)); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[11]))((ID3D11VideoDevice*)Unsafe.AsPointer(ref this)); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(12)] + public HResult GetVideoDecoderProfile(uint Index, Guid* pDecoderProfile) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[12]))((ID3D11VideoDevice*)Unsafe.AsPointer(ref this), Index, pDecoderProfile); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[12]))((ID3D11VideoDevice*)Unsafe.AsPointer(ref this), Index, pDecoderProfile); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(13)] + public HResult CheckVideoDecoderFormat(Guid* pDecoderProfile, Graphics.Dxgi.Common.Format Format, Bool32* pSupported) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[13]))((ID3D11VideoDevice*)Unsafe.AsPointer(ref this), pDecoderProfile, Format, pSupported); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[13]))((ID3D11VideoDevice*)Unsafe.AsPointer(ref this), pDecoderProfile, Format, pSupported); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(14)] + public HResult GetVideoDecoderConfigCount(VideoDecoderDescription* pDesc, uint* pCount) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[14]))((ID3D11VideoDevice*)Unsafe.AsPointer(ref this), pDesc, pCount); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[14]))((ID3D11VideoDevice*)Unsafe.AsPointer(ref this), pDesc, pCount); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(15)] + public HResult GetVideoDecoderConfig(VideoDecoderDescription* pDesc, uint Index, VideoDecoderConfig* pConfig) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[15]))((ID3D11VideoDevice*)Unsafe.AsPointer(ref this), pDesc, Index, pConfig); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[15]))((ID3D11VideoDevice*)Unsafe.AsPointer(ref this), pDesc, Index, pConfig); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(16)] + public HResult GetContentProtectionCaps(Guid* pCryptoType, Guid* pDecoderProfile, VideoContentProtectionCaps* pCaps) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[16]))((ID3D11VideoDevice*)Unsafe.AsPointer(ref this), pCryptoType, pDecoderProfile, pCaps); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[16]))((ID3D11VideoDevice*)Unsafe.AsPointer(ref this), pCryptoType, pDecoderProfile, pCaps); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(17)] + public HResult CheckCryptoKeyExchange(Guid* pCryptoType, Guid* pDecoderProfile, uint Index, Guid* pKeyExchangeType) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[17]))((ID3D11VideoDevice*)Unsafe.AsPointer(ref this), pCryptoType, pDecoderProfile, Index, pKeyExchangeType); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[17]))((ID3D11VideoDevice*)Unsafe.AsPointer(ref this), pCryptoType, pDecoderProfile, Index, pKeyExchangeType); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(18)] + public HResult SetPrivateData(Guid* guid, uint DataSize, void* pData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[18]))((ID3D11VideoDevice*)Unsafe.AsPointer(ref this), guid, DataSize, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[18]))((ID3D11VideoDevice*)Unsafe.AsPointer(ref this), guid, DataSize, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(19)] + public HResult SetPrivateDataInterface(Guid* guid, IUnknown* pData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[19]))((ID3D11VideoDevice*)Unsafe.AsPointer(ref this), guid, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[19]))((ID3D11VideoDevice*)Unsafe.AsPointer(ref this), guid, pData); +#endif + } + + public interface Interface : IUnknown.Interface + { + } +} + +/// +/// ID3D11Device +[Guid("db6f6ddb-ac77-4e88-8253-819df9bbf140")] +[NativeTypeName("struct ID3D11Device : IUnknown")] +[NativeInheritance("IUnknown")] +public unsafe partial struct ID3D11Device : ID3D11Device.Interface +{ + public static ref readonly Guid IID_ID3D11Device + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0xDB, 0x6D, 0x6F, 0xDB, + 0x77, 0xAC, + 0x88, 0x4E, + 0x82, + 0x53, + 0x81, + 0x9D, + 0xF9, + 0xBB, + 0xF1, + 0x40 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_ID3D11Device)); + + public void** lpVtbl; + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(0)] + public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(1)] + [return: NativeTypeName("ULONG")] + public uint AddRef() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(2)] + [return: NativeTypeName("ULONG")] + public uint Release() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(3)] + public HResult CreateBuffer(BufferDescription* pDesc, SubresourceData* pInitialData, ID3D11Buffer** ppBuffer) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[3]))((ID3D11Device*)Unsafe.AsPointer(ref this), pDesc, pInitialData, ppBuffer); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((ID3D11Device*)Unsafe.AsPointer(ref this), pDesc, pInitialData, ppBuffer); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public HResult CreateTexture1D(Texture1DDescription* pDesc, SubresourceData* pInitialData, ID3D11Texture1D** ppTexture1D) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[4]))((ID3D11Device*)Unsafe.AsPointer(ref this), pDesc, pInitialData, ppTexture1D); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((ID3D11Device*)Unsafe.AsPointer(ref this), pDesc, pInitialData, ppTexture1D); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(5)] + public HResult CreateTexture2D(Texture2DDescription* pDesc, SubresourceData* pInitialData, ID3D11Texture2D** ppTexture2D) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[5]))((ID3D11Device*)Unsafe.AsPointer(ref this), pDesc, pInitialData, ppTexture2D); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((ID3D11Device*)Unsafe.AsPointer(ref this), pDesc, pInitialData, ppTexture2D); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(6)] + public HResult CreateTexture3D(Texture3DDescription* pDesc, SubresourceData* pInitialData, ID3D11Texture3D** ppTexture3D) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[6]))((ID3D11Device*)Unsafe.AsPointer(ref this), pDesc, pInitialData, ppTexture3D); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((ID3D11Device*)Unsafe.AsPointer(ref this), pDesc, pInitialData, ppTexture3D); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(7)] + public HResult CreateShaderResourceView(ID3D11Resource* pResource, ShaderResourceViewDescription* pDesc, ID3D11ShaderResourceView** ppSRView) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[7]))((ID3D11Device*)Unsafe.AsPointer(ref this), pResource, pDesc, ppSRView); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((ID3D11Device*)Unsafe.AsPointer(ref this), pResource, pDesc, ppSRView); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(8)] + public HResult CreateUnorderedAccessView(ID3D11Resource* pResource, UnorderedAccessViewDescription* pDesc, ID3D11UnorderedAccessView** ppUAView) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[8]))((ID3D11Device*)Unsafe.AsPointer(ref this), pResource, pDesc, ppUAView); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[8]))((ID3D11Device*)Unsafe.AsPointer(ref this), pResource, pDesc, ppUAView); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(9)] + public HResult CreateRenderTargetView(ID3D11Resource* pResource, RenderTargetViewDescription* pDesc, ID3D11RenderTargetView** ppRTView) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[9]))((ID3D11Device*)Unsafe.AsPointer(ref this), pResource, pDesc, ppRTView); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[9]))((ID3D11Device*)Unsafe.AsPointer(ref this), pResource, pDesc, ppRTView); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(10)] + public HResult CreateDepthStencilView(ID3D11Resource* pResource, DepthStencilViewDescription* pDesc, ID3D11DepthStencilView** ppDepthStencilView) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[10]))((ID3D11Device*)Unsafe.AsPointer(ref this), pResource, pDesc, ppDepthStencilView); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[10]))((ID3D11Device*)Unsafe.AsPointer(ref this), pResource, pDesc, ppDepthStencilView); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(11)] + public HResult CreateInputLayout(InputElementDescription* pInputElementDescs, uint NumElements, void* pShaderBytecodeWithInputSignature, nuint BytecodeLength, ID3D11InputLayout** ppInputLayout) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[11]))((ID3D11Device*)Unsafe.AsPointer(ref this), pInputElementDescs, NumElements, pShaderBytecodeWithInputSignature, BytecodeLength, ppInputLayout); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[11]))((ID3D11Device*)Unsafe.AsPointer(ref this), pInputElementDescs, NumElements, pShaderBytecodeWithInputSignature, BytecodeLength, ppInputLayout); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(12)] + public HResult CreateVertexShader(void* pShaderBytecode, nuint BytecodeLength, ID3D11ClassLinkage* pClassLinkage, ID3D11VertexShader** ppVertexShader) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[12]))((ID3D11Device*)Unsafe.AsPointer(ref this), pShaderBytecode, BytecodeLength, pClassLinkage, ppVertexShader); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[12]))((ID3D11Device*)Unsafe.AsPointer(ref this), pShaderBytecode, BytecodeLength, pClassLinkage, ppVertexShader); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(13)] + public HResult CreateGeometryShader(void* pShaderBytecode, nuint BytecodeLength, ID3D11ClassLinkage* pClassLinkage, ID3D11GeometryShader** ppGeometryShader) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[13]))((ID3D11Device*)Unsafe.AsPointer(ref this), pShaderBytecode, BytecodeLength, pClassLinkage, ppGeometryShader); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[13]))((ID3D11Device*)Unsafe.AsPointer(ref this), pShaderBytecode, BytecodeLength, pClassLinkage, ppGeometryShader); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(14)] + public HResult CreateGeometryShaderWithStreamOutput(void* pShaderBytecode, nuint BytecodeLength, SoDeclarationEntry* pSODeclaration, uint NumEntries, uint* pBufferStrides, uint NumStrides, uint RasterizedStream, ID3D11ClassLinkage* pClassLinkage, ID3D11GeometryShader** ppGeometryShader) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[14]))((ID3D11Device*)Unsafe.AsPointer(ref this), pShaderBytecode, BytecodeLength, pSODeclaration, NumEntries, pBufferStrides, NumStrides, RasterizedStream, pClassLinkage, ppGeometryShader); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[14]))((ID3D11Device*)Unsafe.AsPointer(ref this), pShaderBytecode, BytecodeLength, pSODeclaration, NumEntries, pBufferStrides, NumStrides, RasterizedStream, pClassLinkage, ppGeometryShader); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(15)] + public HResult CreatePixelShader(void* pShaderBytecode, nuint BytecodeLength, ID3D11ClassLinkage* pClassLinkage, ID3D11PixelShader** ppPixelShader) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[15]))((ID3D11Device*)Unsafe.AsPointer(ref this), pShaderBytecode, BytecodeLength, pClassLinkage, ppPixelShader); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[15]))((ID3D11Device*)Unsafe.AsPointer(ref this), pShaderBytecode, BytecodeLength, pClassLinkage, ppPixelShader); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(16)] + public HResult CreateHullShader(void* pShaderBytecode, nuint BytecodeLength, ID3D11ClassLinkage* pClassLinkage, ID3D11HullShader** ppHullShader) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[16]))((ID3D11Device*)Unsafe.AsPointer(ref this), pShaderBytecode, BytecodeLength, pClassLinkage, ppHullShader); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[16]))((ID3D11Device*)Unsafe.AsPointer(ref this), pShaderBytecode, BytecodeLength, pClassLinkage, ppHullShader); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(17)] + public HResult CreateDomainShader(void* pShaderBytecode, nuint BytecodeLength, ID3D11ClassLinkage* pClassLinkage, ID3D11DomainShader** ppDomainShader) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[17]))((ID3D11Device*)Unsafe.AsPointer(ref this), pShaderBytecode, BytecodeLength, pClassLinkage, ppDomainShader); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[17]))((ID3D11Device*)Unsafe.AsPointer(ref this), pShaderBytecode, BytecodeLength, pClassLinkage, ppDomainShader); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(18)] + public HResult CreateComputeShader(void* pShaderBytecode, nuint BytecodeLength, ID3D11ClassLinkage* pClassLinkage, ID3D11ComputeShader** ppComputeShader) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[18]))((ID3D11Device*)Unsafe.AsPointer(ref this), pShaderBytecode, BytecodeLength, pClassLinkage, ppComputeShader); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[18]))((ID3D11Device*)Unsafe.AsPointer(ref this), pShaderBytecode, BytecodeLength, pClassLinkage, ppComputeShader); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(19)] + public HResult CreateClassLinkage(ID3D11ClassLinkage** ppLinkage) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[19]))((ID3D11Device*)Unsafe.AsPointer(ref this), ppLinkage); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[19]))((ID3D11Device*)Unsafe.AsPointer(ref this), ppLinkage); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(20)] + public HResult CreateBlendState(BlendDescription* pBlendStateDesc, ID3D11BlendState** ppBlendState) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[20]))((ID3D11Device*)Unsafe.AsPointer(ref this), pBlendStateDesc, ppBlendState); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[20]))((ID3D11Device*)Unsafe.AsPointer(ref this), pBlendStateDesc, ppBlendState); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(21)] + public HResult CreateDepthStencilState(DepthStencilDescription* pDepthStencilDesc, ID3D11DepthStencilState** ppDepthStencilState) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[21]))((ID3D11Device*)Unsafe.AsPointer(ref this), pDepthStencilDesc, ppDepthStencilState); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[21]))((ID3D11Device*)Unsafe.AsPointer(ref this), pDepthStencilDesc, ppDepthStencilState); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(22)] + public HResult CreateRasterizerState(RasterizerDescription* pRasterizerDesc, ID3D11RasterizerState** ppRasterizerState) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[22]))((ID3D11Device*)Unsafe.AsPointer(ref this), pRasterizerDesc, ppRasterizerState); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[22]))((ID3D11Device*)Unsafe.AsPointer(ref this), pRasterizerDesc, ppRasterizerState); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(23)] + public HResult CreateSamplerState(SamplerDescription* pSamplerDesc, ID3D11SamplerState** ppSamplerState) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[23]))((ID3D11Device*)Unsafe.AsPointer(ref this), pSamplerDesc, ppSamplerState); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[23]))((ID3D11Device*)Unsafe.AsPointer(ref this), pSamplerDesc, ppSamplerState); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(24)] + public HResult CreateQuery(QueryDescription* pQueryDesc, ID3D11Query** ppQuery) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[24]))((ID3D11Device*)Unsafe.AsPointer(ref this), pQueryDesc, ppQuery); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[24]))((ID3D11Device*)Unsafe.AsPointer(ref this), pQueryDesc, ppQuery); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(25)] + public HResult CreatePredicate(QueryDescription* pPredicateDesc, ID3D11Predicate** ppPredicate) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[25]))((ID3D11Device*)Unsafe.AsPointer(ref this), pPredicateDesc, ppPredicate); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[25]))((ID3D11Device*)Unsafe.AsPointer(ref this), pPredicateDesc, ppPredicate); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(26)] + public HResult CreateCounter(CounterDescription* pCounterDesc, ID3D11Counter** ppCounter) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[26]))((ID3D11Device*)Unsafe.AsPointer(ref this), pCounterDesc, ppCounter); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[26]))((ID3D11Device*)Unsafe.AsPointer(ref this), pCounterDesc, ppCounter); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(27)] + public HResult CreateDeferredContext(uint ContextFlags, ID3D11DeviceContext** ppDeferredContext) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[27]))((ID3D11Device*)Unsafe.AsPointer(ref this), ContextFlags, ppDeferredContext); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[27]))((ID3D11Device*)Unsafe.AsPointer(ref this), ContextFlags, ppDeferredContext); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(28)] + public HResult OpenSharedResource(IntPtr* hResource, Guid* ReturnedInterface, void** ppResource) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[28]))((ID3D11Device*)Unsafe.AsPointer(ref this), hResource, ReturnedInterface, ppResource); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[28]))((ID3D11Device*)Unsafe.AsPointer(ref this), hResource, ReturnedInterface, ppResource); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(29)] + public HResult CheckFormatSupport(Graphics.Dxgi.Common.Format Format, uint* pFormatSupport) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[29]))((ID3D11Device*)Unsafe.AsPointer(ref this), Format, pFormatSupport); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[29]))((ID3D11Device*)Unsafe.AsPointer(ref this), Format, pFormatSupport); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(30)] + public HResult CheckMultisampleQualityLevels(Graphics.Dxgi.Common.Format Format, uint SampleCount, uint* pNumQualityLevels) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[30]))((ID3D11Device*)Unsafe.AsPointer(ref this), Format, SampleCount, pNumQualityLevels); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[30]))((ID3D11Device*)Unsafe.AsPointer(ref this), Format, SampleCount, pNumQualityLevels); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(31)] + public void CheckCounterInfo(CounterInfo* pCounterInfo) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[31]))((ID3D11Device*)Unsafe.AsPointer(ref this), pCounterInfo); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[31]))((ID3D11Device*)Unsafe.AsPointer(ref this), pCounterInfo); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(32)] + public HResult CheckCounter(CounterDescription* pDesc, CounterType* pType, uint* pActiveCounters, byte* szName, uint* pNameLength, byte* szUnits, uint* pUnitsLength, byte* szDescription, uint* pDescriptionLength) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[32]))((ID3D11Device*)Unsafe.AsPointer(ref this), pDesc, pType, pActiveCounters, szName, pNameLength, szUnits, pUnitsLength, szDescription, pDescriptionLength); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[32]))((ID3D11Device*)Unsafe.AsPointer(ref this), pDesc, pType, pActiveCounters, szName, pNameLength, szUnits, pUnitsLength, szDescription, pDescriptionLength); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(33)] + public HResult CheckFeatureSupport(Feature Feature, void* pFeatureSupportData, uint FeatureSupportDataSize) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[33]))((ID3D11Device*)Unsafe.AsPointer(ref this), Feature, pFeatureSupportData, FeatureSupportDataSize); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[33]))((ID3D11Device*)Unsafe.AsPointer(ref this), Feature, pFeatureSupportData, FeatureSupportDataSize); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(34)] + public HResult GetPrivateData(Guid* guid, uint* pDataSize, void* pData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[34]))((ID3D11Device*)Unsafe.AsPointer(ref this), guid, pDataSize, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[34]))((ID3D11Device*)Unsafe.AsPointer(ref this), guid, pDataSize, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(35)] + public HResult SetPrivateData(Guid* guid, uint DataSize, void* pData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[35]))((ID3D11Device*)Unsafe.AsPointer(ref this), guid, DataSize, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[35]))((ID3D11Device*)Unsafe.AsPointer(ref this), guid, DataSize, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(36)] + public HResult SetPrivateDataInterface(Guid* guid, IUnknown* pData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[36]))((ID3D11Device*)Unsafe.AsPointer(ref this), guid, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[36]))((ID3D11Device*)Unsafe.AsPointer(ref this), guid, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(37)] + public Graphics.Direct3D.FeatureLevel GetFeatureLevel() + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[37]))((ID3D11Device*)Unsafe.AsPointer(ref this)); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[37]))((ID3D11Device*)Unsafe.AsPointer(ref this)); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(38)] + public uint GetCreationFlags() + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[38]))((ID3D11Device*)Unsafe.AsPointer(ref this)); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[38]))((ID3D11Device*)Unsafe.AsPointer(ref this)); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(39)] + public HResult GetDeviceRemovedReason() + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[39]))((ID3D11Device*)Unsafe.AsPointer(ref this)); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[39]))((ID3D11Device*)Unsafe.AsPointer(ref this)); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(40)] + public void GetImmediateContext(ID3D11DeviceContext* ppImmediateContext) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[40]))((ID3D11Device*)Unsafe.AsPointer(ref this), ppImmediateContext); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[40]))((ID3D11Device*)Unsafe.AsPointer(ref this), ppImmediateContext); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(41)] + public HResult SetExceptionMode(uint RaiseFlags) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[41]))((ID3D11Device*)Unsafe.AsPointer(ref this), RaiseFlags); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[41]))((ID3D11Device*)Unsafe.AsPointer(ref this), RaiseFlags); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(42)] + public uint GetExceptionMode() + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[42]))((ID3D11Device*)Unsafe.AsPointer(ref this)); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[42]))((ID3D11Device*)Unsafe.AsPointer(ref this)); +#endif + } + + public interface Interface : IUnknown.Interface + { + } +} + +/// +/// ID3D11Debug +[Guid("79cf2233-7536-4948-9d36-1e4692dc5760")] +[NativeTypeName("struct ID3D11Debug : IUnknown")] +[NativeInheritance("IUnknown")] +public unsafe partial struct ID3D11Debug : ID3D11Debug.Interface +{ + public static ref readonly Guid IID_ID3D11Debug + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x33, 0x22, 0xCF, 0x79, + 0x36, 0x75, + 0x48, 0x49, + 0x9D, + 0x36, + 0x1E, + 0x46, + 0x92, + 0xDC, + 0x57, + 0x60 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_ID3D11Debug)); + + public void** lpVtbl; + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(0)] + public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(1)] + [return: NativeTypeName("ULONG")] + public uint AddRef() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(2)] + [return: NativeTypeName("ULONG")] + public uint Release() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(3)] + public HResult SetFeatureMask(uint Mask) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[3]))((ID3D11Debug*)Unsafe.AsPointer(ref this), Mask); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((ID3D11Debug*)Unsafe.AsPointer(ref this), Mask); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public uint GetFeatureMask() + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[4]))((ID3D11Debug*)Unsafe.AsPointer(ref this)); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((ID3D11Debug*)Unsafe.AsPointer(ref this)); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(5)] + public HResult SetPresentPerRenderOpDelay(uint Milliseconds) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[5]))((ID3D11Debug*)Unsafe.AsPointer(ref this), Milliseconds); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((ID3D11Debug*)Unsafe.AsPointer(ref this), Milliseconds); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(6)] + public uint GetPresentPerRenderOpDelay() + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[6]))((ID3D11Debug*)Unsafe.AsPointer(ref this)); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((ID3D11Debug*)Unsafe.AsPointer(ref this)); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(7)] + public HResult SetSwapChain(Graphics.Dxgi.IDXGISwapChain* pSwapChain) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[7]))((ID3D11Debug*)Unsafe.AsPointer(ref this), pSwapChain); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((ID3D11Debug*)Unsafe.AsPointer(ref this), pSwapChain); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(8)] + public HResult GetSwapChain(Graphics.Dxgi.IDXGISwapChain* ppSwapChain) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[8]))((ID3D11Debug*)Unsafe.AsPointer(ref this), ppSwapChain); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[8]))((ID3D11Debug*)Unsafe.AsPointer(ref this), ppSwapChain); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(9)] + public HResult ValidateContext(ID3D11DeviceContext* pContext) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[9]))((ID3D11Debug*)Unsafe.AsPointer(ref this), pContext); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[9]))((ID3D11Debug*)Unsafe.AsPointer(ref this), pContext); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(10)] + public HResult ReportLiveDeviceObjects(RldoFlags Flags) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[10]))((ID3D11Debug*)Unsafe.AsPointer(ref this), Flags); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[10]))((ID3D11Debug*)Unsafe.AsPointer(ref this), Flags); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(11)] + public HResult ValidateContextForDispatch(ID3D11DeviceContext* pContext) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[11]))((ID3D11Debug*)Unsafe.AsPointer(ref this), pContext); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[11]))((ID3D11Debug*)Unsafe.AsPointer(ref this), pContext); +#endif + } + + public interface Interface : IUnknown.Interface + { + } +} + +/// +/// ID3D11SwitchToRef +[Guid("1ef337e3-58e7-4f83-a692-db221f5ed47e")] +[NativeTypeName("struct ID3D11SwitchToRef : IUnknown")] +[NativeInheritance("IUnknown")] +public unsafe partial struct ID3D11SwitchToRef : ID3D11SwitchToRef.Interface +{ + public static ref readonly Guid IID_ID3D11SwitchToRef + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0xE3, 0x37, 0xF3, 0x1E, + 0xE7, 0x58, + 0x83, 0x4F, + 0xA6, + 0x92, + 0xDB, + 0x22, + 0x1F, + 0x5E, + 0xD4, + 0x7E + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_ID3D11SwitchToRef)); + + public void** lpVtbl; + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(0)] + public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(1)] + [return: NativeTypeName("ULONG")] + public uint AddRef() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(2)] + [return: NativeTypeName("ULONG")] + public uint Release() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(3)] + public Bool32 SetUseRef(Bool32* UseRef) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[3]))((ID3D11SwitchToRef*)Unsafe.AsPointer(ref this), UseRef); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((ID3D11SwitchToRef*)Unsafe.AsPointer(ref this), UseRef); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public Bool32 GetUseRef() + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[4]))((ID3D11SwitchToRef*)Unsafe.AsPointer(ref this)); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((ID3D11SwitchToRef*)Unsafe.AsPointer(ref this)); +#endif + } + + public interface Interface : IUnknown.Interface + { + } +} + +/// +/// ID3D11TracingDevice +[Guid("1911c771-1587-413e-a7e0-fb26c3de0268")] +[NativeTypeName("struct ID3D11TracingDevice : IUnknown")] +[NativeInheritance("IUnknown")] +public unsafe partial struct ID3D11TracingDevice : ID3D11TracingDevice.Interface +{ + public static ref readonly Guid IID_ID3D11TracingDevice + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x71, 0xC7, 0x11, 0x19, + 0x87, 0x15, + 0x3E, 0x41, + 0xA7, + 0xE0, + 0xFB, + 0x26, + 0xC3, + 0xDE, + 0x02, + 0x68 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_ID3D11TracingDevice)); + + public void** lpVtbl; + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(0)] + public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(1)] + [return: NativeTypeName("ULONG")] + public uint AddRef() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(2)] + [return: NativeTypeName("ULONG")] + public uint Release() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(3)] + public HResult SetShaderTrackingOptionsByType(uint ResourceTypeFlags, uint Options) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[3]))((ID3D11TracingDevice*)Unsafe.AsPointer(ref this), ResourceTypeFlags, Options); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((ID3D11TracingDevice*)Unsafe.AsPointer(ref this), ResourceTypeFlags, Options); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public HResult SetShaderTrackingOptions(IUnknown* pShader, uint Options) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[4]))((ID3D11TracingDevice*)Unsafe.AsPointer(ref this), pShader, Options); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((ID3D11TracingDevice*)Unsafe.AsPointer(ref this), pShader, Options); +#endif + } + + public interface Interface : IUnknown.Interface + { + } +} + +/// +/// ID3D11RefTrackingOptions +[Guid("193dacdf-0db2-4c05-a55c-ef06cac56fd9")] +[NativeTypeName("struct ID3D11RefTrackingOptions : IUnknown")] +[NativeInheritance("IUnknown")] +public unsafe partial struct ID3D11RefTrackingOptions : ID3D11RefTrackingOptions.Interface +{ + public static ref readonly Guid IID_ID3D11RefTrackingOptions + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0xDF, 0xAC, 0x3D, 0x19, + 0xB2, 0x0D, + 0x05, 0x4C, + 0xA5, + 0x5C, + 0xEF, + 0x06, + 0xCA, + 0xC5, + 0x6F, + 0xD9 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_ID3D11RefTrackingOptions)); + + public void** lpVtbl; + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(0)] + public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(1)] + [return: NativeTypeName("ULONG")] + public uint AddRef() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(2)] + [return: NativeTypeName("ULONG")] + public uint Release() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(3)] + public HResult SetTrackingOptions(uint uOptions) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[3]))((ID3D11RefTrackingOptions*)Unsafe.AsPointer(ref this), uOptions); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((ID3D11RefTrackingOptions*)Unsafe.AsPointer(ref this), uOptions); +#endif + } + + public interface Interface : IUnknown.Interface + { + } +} + +/// +/// ID3D11RefDefaultTrackingOptions +[Guid("03916615-c644-418c-9bf4-75db5be63ca0")] +[NativeTypeName("struct ID3D11RefDefaultTrackingOptions : IUnknown")] +[NativeInheritance("IUnknown")] +public unsafe partial struct ID3D11RefDefaultTrackingOptions : ID3D11RefDefaultTrackingOptions.Interface +{ + public static ref readonly Guid IID_ID3D11RefDefaultTrackingOptions + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x15, 0x66, 0x91, 0x03, + 0x44, 0xC6, + 0x8C, 0x41, + 0x9B, + 0xF4, + 0x75, + 0xDB, + 0x5B, + 0xE6, + 0x3C, + 0xA0 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_ID3D11RefDefaultTrackingOptions)); + + public void** lpVtbl; + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(0)] + public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(1)] + [return: NativeTypeName("ULONG")] + public uint AddRef() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(2)] + [return: NativeTypeName("ULONG")] + public uint Release() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(3)] + public HResult SetTrackingOptions(uint ResourceTypeFlags, uint Options) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[3]))((ID3D11RefDefaultTrackingOptions*)Unsafe.AsPointer(ref this), ResourceTypeFlags, Options); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((ID3D11RefDefaultTrackingOptions*)Unsafe.AsPointer(ref this), ResourceTypeFlags, Options); +#endif + } + + public interface Interface : IUnknown.Interface + { + } +} + +/// +/// ID3D11InfoQueue +[Guid("6543dbb6-1b48-42f5-ab82-e97ec74326f6")] +[NativeTypeName("struct ID3D11InfoQueue : IUnknown")] +[NativeInheritance("IUnknown")] +public unsafe partial struct ID3D11InfoQueue : ID3D11InfoQueue.Interface +{ + public static ref readonly Guid IID_ID3D11InfoQueue + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0xB6, 0xDB, 0x43, 0x65, + 0x48, 0x1B, + 0xF5, 0x42, + 0xAB, + 0x82, + 0xE9, + 0x7E, + 0xC7, + 0x43, + 0x26, + 0xF6 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_ID3D11InfoQueue)); + + public void** lpVtbl; + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(0)] + public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(1)] + [return: NativeTypeName("ULONG")] + public uint AddRef() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(2)] + [return: NativeTypeName("ULONG")] + public uint Release() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(3)] + public HResult SetMessageCountLimit(ulong MessageCountLimit) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[3]))((ID3D11InfoQueue*)Unsafe.AsPointer(ref this), MessageCountLimit); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((ID3D11InfoQueue*)Unsafe.AsPointer(ref this), MessageCountLimit); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public void ClearStoredMessages() + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[4]))((ID3D11InfoQueue*)Unsafe.AsPointer(ref this)); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((ID3D11InfoQueue*)Unsafe.AsPointer(ref this)); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(5)] + public HResult GetMessage(ulong MessageIndex, Message* pMessage, nuint* pMessageByteLength) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[5]))((ID3D11InfoQueue*)Unsafe.AsPointer(ref this), MessageIndex, pMessage, pMessageByteLength); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((ID3D11InfoQueue*)Unsafe.AsPointer(ref this), MessageIndex, pMessage, pMessageByteLength); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(6)] + public ulong GetNumMessagesAllowedByStorageFilter() + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[6]))((ID3D11InfoQueue*)Unsafe.AsPointer(ref this)); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((ID3D11InfoQueue*)Unsafe.AsPointer(ref this)); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(7)] + public ulong GetNumMessagesDeniedByStorageFilter() + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[7]))((ID3D11InfoQueue*)Unsafe.AsPointer(ref this)); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((ID3D11InfoQueue*)Unsafe.AsPointer(ref this)); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(8)] + public ulong GetNumStoredMessages() + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[8]))((ID3D11InfoQueue*)Unsafe.AsPointer(ref this)); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[8]))((ID3D11InfoQueue*)Unsafe.AsPointer(ref this)); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(9)] + public ulong GetNumStoredMessagesAllowedByRetrievalFilter() + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[9]))((ID3D11InfoQueue*)Unsafe.AsPointer(ref this)); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[9]))((ID3D11InfoQueue*)Unsafe.AsPointer(ref this)); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(10)] + public ulong GetNumMessagesDiscardedByMessageCountLimit() + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[10]))((ID3D11InfoQueue*)Unsafe.AsPointer(ref this)); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[10]))((ID3D11InfoQueue*)Unsafe.AsPointer(ref this)); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(11)] + public ulong GetMessageCountLimit() + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[11]))((ID3D11InfoQueue*)Unsafe.AsPointer(ref this)); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[11]))((ID3D11InfoQueue*)Unsafe.AsPointer(ref this)); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(12)] + public HResult AddStorageFilterEntries(InfoQueueFilter* pFilter) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[12]))((ID3D11InfoQueue*)Unsafe.AsPointer(ref this), pFilter); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[12]))((ID3D11InfoQueue*)Unsafe.AsPointer(ref this), pFilter); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(13)] + public HResult GetStorageFilter(InfoQueueFilter* pFilter, nuint* pFilterByteLength) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[13]))((ID3D11InfoQueue*)Unsafe.AsPointer(ref this), pFilter, pFilterByteLength); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[13]))((ID3D11InfoQueue*)Unsafe.AsPointer(ref this), pFilter, pFilterByteLength); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(14)] + public void ClearStorageFilter() + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[14]))((ID3D11InfoQueue*)Unsafe.AsPointer(ref this)); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[14]))((ID3D11InfoQueue*)Unsafe.AsPointer(ref this)); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(15)] + public HResult PushEmptyStorageFilter() + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[15]))((ID3D11InfoQueue*)Unsafe.AsPointer(ref this)); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[15]))((ID3D11InfoQueue*)Unsafe.AsPointer(ref this)); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(16)] + public HResult PushCopyOfStorageFilter() + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[16]))((ID3D11InfoQueue*)Unsafe.AsPointer(ref this)); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[16]))((ID3D11InfoQueue*)Unsafe.AsPointer(ref this)); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(17)] + public HResult PushStorageFilter(InfoQueueFilter* pFilter) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[17]))((ID3D11InfoQueue*)Unsafe.AsPointer(ref this), pFilter); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[17]))((ID3D11InfoQueue*)Unsafe.AsPointer(ref this), pFilter); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(18)] + public void PopStorageFilter() + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[18]))((ID3D11InfoQueue*)Unsafe.AsPointer(ref this)); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[18]))((ID3D11InfoQueue*)Unsafe.AsPointer(ref this)); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(19)] + public uint GetStorageFilterStackSize() + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[19]))((ID3D11InfoQueue*)Unsafe.AsPointer(ref this)); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[19]))((ID3D11InfoQueue*)Unsafe.AsPointer(ref this)); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(20)] + public HResult AddRetrievalFilterEntries(InfoQueueFilter* pFilter) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[20]))((ID3D11InfoQueue*)Unsafe.AsPointer(ref this), pFilter); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[20]))((ID3D11InfoQueue*)Unsafe.AsPointer(ref this), pFilter); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(21)] + public HResult GetRetrievalFilter(InfoQueueFilter* pFilter, nuint* pFilterByteLength) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[21]))((ID3D11InfoQueue*)Unsafe.AsPointer(ref this), pFilter, pFilterByteLength); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[21]))((ID3D11InfoQueue*)Unsafe.AsPointer(ref this), pFilter, pFilterByteLength); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(22)] + public void ClearRetrievalFilter() + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[22]))((ID3D11InfoQueue*)Unsafe.AsPointer(ref this)); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[22]))((ID3D11InfoQueue*)Unsafe.AsPointer(ref this)); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(23)] + public HResult PushEmptyRetrievalFilter() + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[23]))((ID3D11InfoQueue*)Unsafe.AsPointer(ref this)); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[23]))((ID3D11InfoQueue*)Unsafe.AsPointer(ref this)); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(24)] + public HResult PushCopyOfRetrievalFilter() + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[24]))((ID3D11InfoQueue*)Unsafe.AsPointer(ref this)); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[24]))((ID3D11InfoQueue*)Unsafe.AsPointer(ref this)); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(25)] + public HResult PushRetrievalFilter(InfoQueueFilter* pFilter) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[25]))((ID3D11InfoQueue*)Unsafe.AsPointer(ref this), pFilter); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[25]))((ID3D11InfoQueue*)Unsafe.AsPointer(ref this), pFilter); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(26)] + public void PopRetrievalFilter() + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[26]))((ID3D11InfoQueue*)Unsafe.AsPointer(ref this)); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[26]))((ID3D11InfoQueue*)Unsafe.AsPointer(ref this)); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(27)] + public uint GetRetrievalFilterStackSize() + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[27]))((ID3D11InfoQueue*)Unsafe.AsPointer(ref this)); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[27]))((ID3D11InfoQueue*)Unsafe.AsPointer(ref this)); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(28)] + public HResult AddMessage(MessageCategory Category, MessageSeverity Severity, MessageId ID, byte** pDescription) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[28]))((ID3D11InfoQueue*)Unsafe.AsPointer(ref this), Category, Severity, ID, pDescription); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[28]))((ID3D11InfoQueue*)Unsafe.AsPointer(ref this), Category, Severity, ID, pDescription); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(29)] + public HResult AddApplicationMessage(MessageSeverity Severity, byte** pDescription) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[29]))((ID3D11InfoQueue*)Unsafe.AsPointer(ref this), Severity, pDescription); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[29]))((ID3D11InfoQueue*)Unsafe.AsPointer(ref this), Severity, pDescription); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(30)] + public HResult SetBreakOnCategory(MessageCategory Category, Bool32* bEnable) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[30]))((ID3D11InfoQueue*)Unsafe.AsPointer(ref this), Category, bEnable); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[30]))((ID3D11InfoQueue*)Unsafe.AsPointer(ref this), Category, bEnable); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(31)] + public HResult SetBreakOnSeverity(MessageSeverity Severity, Bool32* bEnable) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[31]))((ID3D11InfoQueue*)Unsafe.AsPointer(ref this), Severity, bEnable); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[31]))((ID3D11InfoQueue*)Unsafe.AsPointer(ref this), Severity, bEnable); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(32)] + public HResult SetBreakOnID(MessageId ID, Bool32* bEnable) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[32]))((ID3D11InfoQueue*)Unsafe.AsPointer(ref this), ID, bEnable); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[32]))((ID3D11InfoQueue*)Unsafe.AsPointer(ref this), ID, bEnable); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(33)] + public Bool32 GetBreakOnCategory(MessageCategory Category) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[33]))((ID3D11InfoQueue*)Unsafe.AsPointer(ref this), Category); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[33]))((ID3D11InfoQueue*)Unsafe.AsPointer(ref this), Category); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(34)] + public Bool32 GetBreakOnSeverity(MessageSeverity Severity) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[34]))((ID3D11InfoQueue*)Unsafe.AsPointer(ref this), Severity); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[34]))((ID3D11InfoQueue*)Unsafe.AsPointer(ref this), Severity); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(35)] + public Bool32 GetBreakOnID(MessageId ID) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[35]))((ID3D11InfoQueue*)Unsafe.AsPointer(ref this), ID); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[35]))((ID3D11InfoQueue*)Unsafe.AsPointer(ref this), ID); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(36)] + public void SetMuteDebugOutput(Bool32* bMute) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[36]))((ID3D11InfoQueue*)Unsafe.AsPointer(ref this), bMute); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[36]))((ID3D11InfoQueue*)Unsafe.AsPointer(ref this), bMute); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(37)] + public Bool32 GetMuteDebugOutput() + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[37]))((ID3D11InfoQueue*)Unsafe.AsPointer(ref this)); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[37]))((ID3D11InfoQueue*)Unsafe.AsPointer(ref this)); +#endif + } + + public interface Interface : IUnknown.Interface + { + } +} + +/// +/// ID3D11BlendState1 +[Guid("cc86fabe-da55-401d-85e7-e3c9de2877e9")] +[NativeTypeName("struct ID3D11BlendState1 : ID3D11BlendState")] +[NativeInheritance("ID3D11BlendState")] +public unsafe partial struct ID3D11BlendState1 : ID3D11BlendState1.Interface +{ + public static ref readonly Guid IID_ID3D11BlendState1 + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0xBE, 0xFA, 0x86, 0xCC, + 0x55, 0xDA, + 0x1D, 0x40, + 0x85, + 0xE7, + 0xE3, + 0xC9, + 0xDE, + 0x28, + 0x77, + 0xE9 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_ID3D11BlendState1)); + + public void** lpVtbl; + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(0)] + public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(1)] + [return: NativeTypeName("ULONG")] + public uint AddRef() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(2)] + [return: NativeTypeName("ULONG")] + public uint Release() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(3)] + public void GetDesc(BlendDescription* pDesc) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[3]))((ID3D11BlendState1*)Unsafe.AsPointer(ref this), pDesc); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((ID3D11BlendState1*)Unsafe.AsPointer(ref this), pDesc); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public void GetDevice(ID3D11Device* ppDevice) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[4]))((ID3D11BlendState1*)Unsafe.AsPointer(ref this), ppDevice); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((ID3D11BlendState1*)Unsafe.AsPointer(ref this), ppDevice); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(5)] + public HResult GetPrivateData(Guid* guid, uint* pDataSize, void* pData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[5]))((ID3D11BlendState1*)Unsafe.AsPointer(ref this), guid, pDataSize, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((ID3D11BlendState1*)Unsafe.AsPointer(ref this), guid, pDataSize, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(6)] + public HResult SetPrivateData(Guid* guid, uint DataSize, void* pData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[6]))((ID3D11BlendState1*)Unsafe.AsPointer(ref this), guid, DataSize, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((ID3D11BlendState1*)Unsafe.AsPointer(ref this), guid, DataSize, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(7)] + public HResult SetPrivateDataInterface(Guid* guid, IUnknown* pData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[7]))((ID3D11BlendState1*)Unsafe.AsPointer(ref this), guid, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((ID3D11BlendState1*)Unsafe.AsPointer(ref this), guid, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(8)] + public void GetDesc1(BlendDescription1* pDesc) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[8]))((ID3D11BlendState1*)Unsafe.AsPointer(ref this), pDesc); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[8]))((ID3D11BlendState1*)Unsafe.AsPointer(ref this), pDesc); +#endif + } + + public interface Interface : ID3D11BlendState.Interface + { + } +} + +/// +/// ID3D11RasterizerState1 +[Guid("1217d7a6-5039-418c-b042-9cbe256afd6e")] +[NativeTypeName("struct ID3D11RasterizerState1 : ID3D11RasterizerState")] +[NativeInheritance("ID3D11RasterizerState")] +public unsafe partial struct ID3D11RasterizerState1 : ID3D11RasterizerState1.Interface +{ + public static ref readonly Guid IID_ID3D11RasterizerState1 + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0xA6, 0xD7, 0x17, 0x12, + 0x39, 0x50, + 0x8C, 0x41, + 0xB0, + 0x42, + 0x9C, + 0xBE, + 0x25, + 0x6A, + 0xFD, + 0x6E + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_ID3D11RasterizerState1)); + + public void** lpVtbl; + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(0)] + public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(1)] + [return: NativeTypeName("ULONG")] + public uint AddRef() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(2)] + [return: NativeTypeName("ULONG")] + public uint Release() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(3)] + public void GetDesc(RasterizerDescription* pDesc) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[3]))((ID3D11RasterizerState1*)Unsafe.AsPointer(ref this), pDesc); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((ID3D11RasterizerState1*)Unsafe.AsPointer(ref this), pDesc); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public void GetDevice(ID3D11Device* ppDevice) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[4]))((ID3D11RasterizerState1*)Unsafe.AsPointer(ref this), ppDevice); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((ID3D11RasterizerState1*)Unsafe.AsPointer(ref this), ppDevice); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(5)] + public HResult GetPrivateData(Guid* guid, uint* pDataSize, void* pData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[5]))((ID3D11RasterizerState1*)Unsafe.AsPointer(ref this), guid, pDataSize, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((ID3D11RasterizerState1*)Unsafe.AsPointer(ref this), guid, pDataSize, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(6)] + public HResult SetPrivateData(Guid* guid, uint DataSize, void* pData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[6]))((ID3D11RasterizerState1*)Unsafe.AsPointer(ref this), guid, DataSize, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((ID3D11RasterizerState1*)Unsafe.AsPointer(ref this), guid, DataSize, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(7)] + public HResult SetPrivateDataInterface(Guid* guid, IUnknown* pData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[7]))((ID3D11RasterizerState1*)Unsafe.AsPointer(ref this), guid, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((ID3D11RasterizerState1*)Unsafe.AsPointer(ref this), guid, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(8)] + public void GetDesc1(RasterizerDescription1* pDesc) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[8]))((ID3D11RasterizerState1*)Unsafe.AsPointer(ref this), pDesc); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[8]))((ID3D11RasterizerState1*)Unsafe.AsPointer(ref this), pDesc); +#endif + } + + public interface Interface : ID3D11RasterizerState.Interface + { + } +} + +/// +/// ID3DDeviceContextState +[Guid("5c1e0d8a-7c23-48f9-8c59-a92958ceff11")] +[NativeTypeName("struct ID3DDeviceContextState : ID3D11DeviceChild")] +[NativeInheritance("ID3D11DeviceChild")] +public unsafe partial struct ID3DDeviceContextState : ID3DDeviceContextState.Interface +{ + public static ref readonly Guid IID_ID3DDeviceContextState + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x8A, 0x0D, 0x1E, 0x5C, + 0x23, 0x7C, + 0xF9, 0x48, + 0x8C, + 0x59, + 0xA9, + 0x29, + 0x58, + 0xCE, + 0xFF, + 0x11 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_ID3DDeviceContextState)); + + public void** lpVtbl; + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(0)] + public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(1)] + [return: NativeTypeName("ULONG")] + public uint AddRef() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(2)] + [return: NativeTypeName("ULONG")] + public uint Release() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(3)] + public void GetDevice(ID3D11Device* ppDevice) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[3]))((ID3DDeviceContextState*)Unsafe.AsPointer(ref this), ppDevice); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((ID3DDeviceContextState*)Unsafe.AsPointer(ref this), ppDevice); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public HResult GetPrivateData(Guid* guid, uint* pDataSize, void* pData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[4]))((ID3DDeviceContextState*)Unsafe.AsPointer(ref this), guid, pDataSize, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((ID3DDeviceContextState*)Unsafe.AsPointer(ref this), guid, pDataSize, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(5)] + public HResult SetPrivateData(Guid* guid, uint DataSize, void* pData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[5]))((ID3DDeviceContextState*)Unsafe.AsPointer(ref this), guid, DataSize, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((ID3DDeviceContextState*)Unsafe.AsPointer(ref this), guid, DataSize, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(6)] + public HResult SetPrivateDataInterface(Guid* guid, IUnknown* pData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[6]))((ID3DDeviceContextState*)Unsafe.AsPointer(ref this), guid, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((ID3DDeviceContextState*)Unsafe.AsPointer(ref this), guid, pData); +#endif + } + + public interface Interface : ID3D11DeviceChild.Interface + { + } +} + +/// +/// ID3D11DeviceContext1 +[Guid("bb2c6faa-b5fb-4082-8e6b-388b8cfa90e1")] +[NativeTypeName("struct ID3D11DeviceContext1 : ID3D11DeviceContext")] +[NativeInheritance("ID3D11DeviceContext")] +public unsafe partial struct ID3D11DeviceContext1 : ID3D11DeviceContext1.Interface +{ + public static ref readonly Guid IID_ID3D11DeviceContext1 + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0xAA, 0x6F, 0x2C, 0xBB, + 0xFB, 0xB5, + 0x82, 0x40, + 0x8E, + 0x6B, + 0x38, + 0x8B, + 0x8C, + 0xFA, + 0x90, + 0xE1 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_ID3D11DeviceContext1)); + + public void** lpVtbl; + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(0)] + public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(1)] + [return: NativeTypeName("ULONG")] + public uint AddRef() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(2)] + [return: NativeTypeName("ULONG")] + public uint Release() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(3)] + public void VSSetConstantBuffers(uint StartSlot, uint NumBuffers, ID3D11Buffer* ppConstantBuffers) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[3]))((ID3D11DeviceContext1*)Unsafe.AsPointer(ref this), StartSlot, NumBuffers, ppConstantBuffers); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((ID3D11DeviceContext1*)Unsafe.AsPointer(ref this), StartSlot, NumBuffers, ppConstantBuffers); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public void PSSetShaderResources(uint StartSlot, uint NumViews, ID3D11ShaderResourceView* ppShaderResourceViews) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[4]))((ID3D11DeviceContext1*)Unsafe.AsPointer(ref this), StartSlot, NumViews, ppShaderResourceViews); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((ID3D11DeviceContext1*)Unsafe.AsPointer(ref this), StartSlot, NumViews, ppShaderResourceViews); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(5)] + public void PSSetShader(ID3D11PixelShader* pPixelShader, ID3D11ClassInstance* ppClassInstances, uint NumClassInstances) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[5]))((ID3D11DeviceContext1*)Unsafe.AsPointer(ref this), pPixelShader, ppClassInstances, NumClassInstances); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((ID3D11DeviceContext1*)Unsafe.AsPointer(ref this), pPixelShader, ppClassInstances, NumClassInstances); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(6)] + public void PSSetSamplers(uint StartSlot, uint NumSamplers, ID3D11SamplerState* ppSamplers) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[6]))((ID3D11DeviceContext1*)Unsafe.AsPointer(ref this), StartSlot, NumSamplers, ppSamplers); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((ID3D11DeviceContext1*)Unsafe.AsPointer(ref this), StartSlot, NumSamplers, ppSamplers); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(7)] + public void VSSetShader(ID3D11VertexShader* pVertexShader, ID3D11ClassInstance* ppClassInstances, uint NumClassInstances) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[7]))((ID3D11DeviceContext1*)Unsafe.AsPointer(ref this), pVertexShader, ppClassInstances, NumClassInstances); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((ID3D11DeviceContext1*)Unsafe.AsPointer(ref this), pVertexShader, ppClassInstances, NumClassInstances); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(8)] + public void DrawIndexed(uint IndexCount, uint StartIndexLocation, int BaseVertexLocation) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[8]))((ID3D11DeviceContext1*)Unsafe.AsPointer(ref this), IndexCount, StartIndexLocation, BaseVertexLocation); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[8]))((ID3D11DeviceContext1*)Unsafe.AsPointer(ref this), IndexCount, StartIndexLocation, BaseVertexLocation); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(9)] + public void Draw(uint VertexCount, uint StartVertexLocation) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[9]))((ID3D11DeviceContext1*)Unsafe.AsPointer(ref this), VertexCount, StartVertexLocation); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[9]))((ID3D11DeviceContext1*)Unsafe.AsPointer(ref this), VertexCount, StartVertexLocation); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(10)] + public HResult Map(ID3D11Resource* pResource, uint Subresource, Map MapType, uint MapFlags, MappedSubresource* pMappedResource) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[10]))((ID3D11DeviceContext1*)Unsafe.AsPointer(ref this), pResource, Subresource, MapType, MapFlags, pMappedResource); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[10]))((ID3D11DeviceContext1*)Unsafe.AsPointer(ref this), pResource, Subresource, MapType, MapFlags, pMappedResource); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(11)] + public void Unmap(ID3D11Resource* pResource, uint Subresource) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[11]))((ID3D11DeviceContext1*)Unsafe.AsPointer(ref this), pResource, Subresource); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[11]))((ID3D11DeviceContext1*)Unsafe.AsPointer(ref this), pResource, Subresource); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(12)] + public void PSSetConstantBuffers(uint StartSlot, uint NumBuffers, ID3D11Buffer* ppConstantBuffers) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[12]))((ID3D11DeviceContext1*)Unsafe.AsPointer(ref this), StartSlot, NumBuffers, ppConstantBuffers); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[12]))((ID3D11DeviceContext1*)Unsafe.AsPointer(ref this), StartSlot, NumBuffers, ppConstantBuffers); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(13)] + public void IASetInputLayout(ID3D11InputLayout* pInputLayout) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[13]))((ID3D11DeviceContext1*)Unsafe.AsPointer(ref this), pInputLayout); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[13]))((ID3D11DeviceContext1*)Unsafe.AsPointer(ref this), pInputLayout); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(14)] + public void IASetVertexBuffers(uint StartSlot, uint NumBuffers, ID3D11Buffer* ppVertexBuffers, uint* pStrides, uint* pOffsets) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[14]))((ID3D11DeviceContext1*)Unsafe.AsPointer(ref this), StartSlot, NumBuffers, ppVertexBuffers, pStrides, pOffsets); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[14]))((ID3D11DeviceContext1*)Unsafe.AsPointer(ref this), StartSlot, NumBuffers, ppVertexBuffers, pStrides, pOffsets); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(15)] + public void IASetIndexBuffer(ID3D11Buffer* pIndexBuffer, Graphics.Dxgi.Common.Format Format, uint Offset) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[15]))((ID3D11DeviceContext1*)Unsafe.AsPointer(ref this), pIndexBuffer, Format, Offset); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[15]))((ID3D11DeviceContext1*)Unsafe.AsPointer(ref this), pIndexBuffer, Format, Offset); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(16)] + public void DrawIndexedInstanced(uint IndexCountPerInstance, uint InstanceCount, uint StartIndexLocation, int BaseVertexLocation, uint StartInstanceLocation) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[16]))((ID3D11DeviceContext1*)Unsafe.AsPointer(ref this), IndexCountPerInstance, InstanceCount, StartIndexLocation, BaseVertexLocation, StartInstanceLocation); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[16]))((ID3D11DeviceContext1*)Unsafe.AsPointer(ref this), IndexCountPerInstance, InstanceCount, StartIndexLocation, BaseVertexLocation, StartInstanceLocation); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(17)] + public void DrawInstanced(uint VertexCountPerInstance, uint InstanceCount, uint StartVertexLocation, uint StartInstanceLocation) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[17]))((ID3D11DeviceContext1*)Unsafe.AsPointer(ref this), VertexCountPerInstance, InstanceCount, StartVertexLocation, StartInstanceLocation); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[17]))((ID3D11DeviceContext1*)Unsafe.AsPointer(ref this), VertexCountPerInstance, InstanceCount, StartVertexLocation, StartInstanceLocation); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(18)] + public void GSSetConstantBuffers(uint StartSlot, uint NumBuffers, ID3D11Buffer* ppConstantBuffers) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[18]))((ID3D11DeviceContext1*)Unsafe.AsPointer(ref this), StartSlot, NumBuffers, ppConstantBuffers); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[18]))((ID3D11DeviceContext1*)Unsafe.AsPointer(ref this), StartSlot, NumBuffers, ppConstantBuffers); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(19)] + public void GSSetShader(ID3D11GeometryShader* pShader, ID3D11ClassInstance* ppClassInstances, uint NumClassInstances) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[19]))((ID3D11DeviceContext1*)Unsafe.AsPointer(ref this), pShader, ppClassInstances, NumClassInstances); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[19]))((ID3D11DeviceContext1*)Unsafe.AsPointer(ref this), pShader, ppClassInstances, NumClassInstances); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(20)] + public void IASetPrimitiveTopology(Graphics.Direct3D.PrimitiveTopology Topology) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[20]))((ID3D11DeviceContext1*)Unsafe.AsPointer(ref this), Topology); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[20]))((ID3D11DeviceContext1*)Unsafe.AsPointer(ref this), Topology); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(21)] + public void VSSetShaderResources(uint StartSlot, uint NumViews, ID3D11ShaderResourceView* ppShaderResourceViews) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[21]))((ID3D11DeviceContext1*)Unsafe.AsPointer(ref this), StartSlot, NumViews, ppShaderResourceViews); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[21]))((ID3D11DeviceContext1*)Unsafe.AsPointer(ref this), StartSlot, NumViews, ppShaderResourceViews); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(22)] + public void VSSetSamplers(uint StartSlot, uint NumSamplers, ID3D11SamplerState* ppSamplers) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[22]))((ID3D11DeviceContext1*)Unsafe.AsPointer(ref this), StartSlot, NumSamplers, ppSamplers); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[22]))((ID3D11DeviceContext1*)Unsafe.AsPointer(ref this), StartSlot, NumSamplers, ppSamplers); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(23)] + public void Begin(ID3D11Asynchronous* pAsync) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[23]))((ID3D11DeviceContext1*)Unsafe.AsPointer(ref this), pAsync); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[23]))((ID3D11DeviceContext1*)Unsafe.AsPointer(ref this), pAsync); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(24)] + public void End(ID3D11Asynchronous* pAsync) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[24]))((ID3D11DeviceContext1*)Unsafe.AsPointer(ref this), pAsync); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[24]))((ID3D11DeviceContext1*)Unsafe.AsPointer(ref this), pAsync); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(25)] + public HResult GetData(ID3D11Asynchronous* pAsync, void* pData, uint DataSize, uint GetDataFlags) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[25]))((ID3D11DeviceContext1*)Unsafe.AsPointer(ref this), pAsync, pData, DataSize, GetDataFlags); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[25]))((ID3D11DeviceContext1*)Unsafe.AsPointer(ref this), pAsync, pData, DataSize, GetDataFlags); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(26)] + public void SetPredication(ID3D11Predicate* pPredicate, Bool32* PredicateValue) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[26]))((ID3D11DeviceContext1*)Unsafe.AsPointer(ref this), pPredicate, PredicateValue); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[26]))((ID3D11DeviceContext1*)Unsafe.AsPointer(ref this), pPredicate, PredicateValue); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(27)] + public void GSSetShaderResources(uint StartSlot, uint NumViews, ID3D11ShaderResourceView* ppShaderResourceViews) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[27]))((ID3D11DeviceContext1*)Unsafe.AsPointer(ref this), StartSlot, NumViews, ppShaderResourceViews); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[27]))((ID3D11DeviceContext1*)Unsafe.AsPointer(ref this), StartSlot, NumViews, ppShaderResourceViews); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(28)] + public void GSSetSamplers(uint StartSlot, uint NumSamplers, ID3D11SamplerState* ppSamplers) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[28]))((ID3D11DeviceContext1*)Unsafe.AsPointer(ref this), StartSlot, NumSamplers, ppSamplers); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[28]))((ID3D11DeviceContext1*)Unsafe.AsPointer(ref this), StartSlot, NumSamplers, ppSamplers); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(29)] + public void OMSetRenderTargets(uint NumViews, ID3D11RenderTargetView* ppRenderTargetViews, ID3D11DepthStencilView* pDepthStencilView) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[29]))((ID3D11DeviceContext1*)Unsafe.AsPointer(ref this), NumViews, ppRenderTargetViews, pDepthStencilView); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[29]))((ID3D11DeviceContext1*)Unsafe.AsPointer(ref this), NumViews, ppRenderTargetViews, pDepthStencilView); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(30)] + public void OMSetRenderTargetsAndUnorderedAccessViews(uint NumRTVs, ID3D11RenderTargetView* ppRenderTargetViews, ID3D11DepthStencilView* pDepthStencilView, uint UAVStartSlot, uint NumUAVs, ID3D11UnorderedAccessView* ppUnorderedAccessViews, uint* pUAVInitialCounts) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[30]))((ID3D11DeviceContext1*)Unsafe.AsPointer(ref this), NumRTVs, ppRenderTargetViews, pDepthStencilView, UAVStartSlot, NumUAVs, ppUnorderedAccessViews, pUAVInitialCounts); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[30]))((ID3D11DeviceContext1*)Unsafe.AsPointer(ref this), NumRTVs, ppRenderTargetViews, pDepthStencilView, UAVStartSlot, NumUAVs, ppUnorderedAccessViews, pUAVInitialCounts); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(31)] + public void OMSetBlendState(ID3D11BlendState* pBlendState, float* BlendFactor, uint SampleMask) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[31]))((ID3D11DeviceContext1*)Unsafe.AsPointer(ref this), pBlendState, BlendFactor, SampleMask); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[31]))((ID3D11DeviceContext1*)Unsafe.AsPointer(ref this), pBlendState, BlendFactor, SampleMask); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(32)] + public void OMSetDepthStencilState(ID3D11DepthStencilState* pDepthStencilState, uint StencilRef) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[32]))((ID3D11DeviceContext1*)Unsafe.AsPointer(ref this), pDepthStencilState, StencilRef); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[32]))((ID3D11DeviceContext1*)Unsafe.AsPointer(ref this), pDepthStencilState, StencilRef); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(33)] + public void SOSetTargets(uint NumBuffers, ID3D11Buffer* ppSOTargets, uint* pOffsets) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[33]))((ID3D11DeviceContext1*)Unsafe.AsPointer(ref this), NumBuffers, ppSOTargets, pOffsets); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[33]))((ID3D11DeviceContext1*)Unsafe.AsPointer(ref this), NumBuffers, ppSOTargets, pOffsets); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(34)] + public void DrawAuto() + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[34]))((ID3D11DeviceContext1*)Unsafe.AsPointer(ref this)); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[34]))((ID3D11DeviceContext1*)Unsafe.AsPointer(ref this)); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(35)] + public void DrawIndexedInstancedIndirect(ID3D11Buffer* pBufferForArgs, uint AlignedByteOffsetForArgs) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[35]))((ID3D11DeviceContext1*)Unsafe.AsPointer(ref this), pBufferForArgs, AlignedByteOffsetForArgs); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[35]))((ID3D11DeviceContext1*)Unsafe.AsPointer(ref this), pBufferForArgs, AlignedByteOffsetForArgs); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(36)] + public void DrawInstancedIndirect(ID3D11Buffer* pBufferForArgs, uint AlignedByteOffsetForArgs) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[36]))((ID3D11DeviceContext1*)Unsafe.AsPointer(ref this), pBufferForArgs, AlignedByteOffsetForArgs); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[36]))((ID3D11DeviceContext1*)Unsafe.AsPointer(ref this), pBufferForArgs, AlignedByteOffsetForArgs); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(37)] + public void Dispatch(uint ThreadGroupCountX, uint ThreadGroupCountY, uint ThreadGroupCountZ) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[37]))((ID3D11DeviceContext1*)Unsafe.AsPointer(ref this), ThreadGroupCountX, ThreadGroupCountY, ThreadGroupCountZ); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[37]))((ID3D11DeviceContext1*)Unsafe.AsPointer(ref this), ThreadGroupCountX, ThreadGroupCountY, ThreadGroupCountZ); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(38)] + public void DispatchIndirect(ID3D11Buffer* pBufferForArgs, uint AlignedByteOffsetForArgs) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[38]))((ID3D11DeviceContext1*)Unsafe.AsPointer(ref this), pBufferForArgs, AlignedByteOffsetForArgs); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[38]))((ID3D11DeviceContext1*)Unsafe.AsPointer(ref this), pBufferForArgs, AlignedByteOffsetForArgs); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(39)] + public void RSSetState(ID3D11RasterizerState* pRasterizerState) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[39]))((ID3D11DeviceContext1*)Unsafe.AsPointer(ref this), pRasterizerState); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[39]))((ID3D11DeviceContext1*)Unsafe.AsPointer(ref this), pRasterizerState); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(40)] + public void RSSetViewports(uint NumViewports, Viewport* pViewports) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[40]))((ID3D11DeviceContext1*)Unsafe.AsPointer(ref this), NumViewports, pViewports); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[40]))((ID3D11DeviceContext1*)Unsafe.AsPointer(ref this), NumViewports, pViewports); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(41)] + public void RSSetScissorRects(uint NumRects, RawRect* pRects) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[41]))((ID3D11DeviceContext1*)Unsafe.AsPointer(ref this), NumRects, pRects); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[41]))((ID3D11DeviceContext1*)Unsafe.AsPointer(ref this), NumRects, pRects); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(42)] + public void CopySubresourceRegion(ID3D11Resource* pDstResource, uint DstSubresource, uint DstX, uint DstY, uint DstZ, ID3D11Resource* pSrcResource, uint SrcSubresource, Box* pSrcBox) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[42]))((ID3D11DeviceContext1*)Unsafe.AsPointer(ref this), pDstResource, DstSubresource, DstX, DstY, DstZ, pSrcResource, SrcSubresource, pSrcBox); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[42]))((ID3D11DeviceContext1*)Unsafe.AsPointer(ref this), pDstResource, DstSubresource, DstX, DstY, DstZ, pSrcResource, SrcSubresource, pSrcBox); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(43)] + public void CopyResource(ID3D11Resource* pDstResource, ID3D11Resource* pSrcResource) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[43]))((ID3D11DeviceContext1*)Unsafe.AsPointer(ref this), pDstResource, pSrcResource); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[43]))((ID3D11DeviceContext1*)Unsafe.AsPointer(ref this), pDstResource, pSrcResource); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(44)] + public void UpdateSubresource(ID3D11Resource* pDstResource, uint DstSubresource, Box* pDstBox, void* pSrcData, uint SrcRowPitch, uint SrcDepthPitch) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[44]))((ID3D11DeviceContext1*)Unsafe.AsPointer(ref this), pDstResource, DstSubresource, pDstBox, pSrcData, SrcRowPitch, SrcDepthPitch); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[44]))((ID3D11DeviceContext1*)Unsafe.AsPointer(ref this), pDstResource, DstSubresource, pDstBox, pSrcData, SrcRowPitch, SrcDepthPitch); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(45)] + public void CopyStructureCount(ID3D11Buffer* pDstBuffer, uint DstAlignedByteOffset, ID3D11UnorderedAccessView* pSrcView) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[45]))((ID3D11DeviceContext1*)Unsafe.AsPointer(ref this), pDstBuffer, DstAlignedByteOffset, pSrcView); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[45]))((ID3D11DeviceContext1*)Unsafe.AsPointer(ref this), pDstBuffer, DstAlignedByteOffset, pSrcView); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(46)] + public void ClearRenderTargetView(ID3D11RenderTargetView* pRenderTargetView, float* ColorRGBA) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[46]))((ID3D11DeviceContext1*)Unsafe.AsPointer(ref this), pRenderTargetView, ColorRGBA); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[46]))((ID3D11DeviceContext1*)Unsafe.AsPointer(ref this), pRenderTargetView, ColorRGBA); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(47)] + public void ClearUnorderedAccessViewUint(ID3D11UnorderedAccessView* pUnorderedAccessView, uint* Values) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[47]))((ID3D11DeviceContext1*)Unsafe.AsPointer(ref this), pUnorderedAccessView, Values); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[47]))((ID3D11DeviceContext1*)Unsafe.AsPointer(ref this), pUnorderedAccessView, Values); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(48)] + public void ClearUnorderedAccessViewFloat(ID3D11UnorderedAccessView* pUnorderedAccessView, float* Values) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[48]))((ID3D11DeviceContext1*)Unsafe.AsPointer(ref this), pUnorderedAccessView, Values); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[48]))((ID3D11DeviceContext1*)Unsafe.AsPointer(ref this), pUnorderedAccessView, Values); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(49)] + public void ClearDepthStencilView(ID3D11DepthStencilView* pDepthStencilView, uint ClearFlags, float Depth, byte Stencil) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[49]))((ID3D11DeviceContext1*)Unsafe.AsPointer(ref this), pDepthStencilView, ClearFlags, Depth, Stencil); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[49]))((ID3D11DeviceContext1*)Unsafe.AsPointer(ref this), pDepthStencilView, ClearFlags, Depth, Stencil); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(50)] + public void GenerateMips(ID3D11ShaderResourceView* pShaderResourceView) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[50]))((ID3D11DeviceContext1*)Unsafe.AsPointer(ref this), pShaderResourceView); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[50]))((ID3D11DeviceContext1*)Unsafe.AsPointer(ref this), pShaderResourceView); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(51)] + public void SetResourceMinLOD(ID3D11Resource* pResource, float MinLOD) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[51]))((ID3D11DeviceContext1*)Unsafe.AsPointer(ref this), pResource, MinLOD); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[51]))((ID3D11DeviceContext1*)Unsafe.AsPointer(ref this), pResource, MinLOD); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(52)] + public float GetResourceMinLOD(ID3D11Resource* pResource) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[52]))((ID3D11DeviceContext1*)Unsafe.AsPointer(ref this), pResource); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[52]))((ID3D11DeviceContext1*)Unsafe.AsPointer(ref this), pResource); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(53)] + public void ResolveSubresource(ID3D11Resource* pDstResource, uint DstSubresource, ID3D11Resource* pSrcResource, uint SrcSubresource, Graphics.Dxgi.Common.Format Format) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[53]))((ID3D11DeviceContext1*)Unsafe.AsPointer(ref this), pDstResource, DstSubresource, pSrcResource, SrcSubresource, Format); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[53]))((ID3D11DeviceContext1*)Unsafe.AsPointer(ref this), pDstResource, DstSubresource, pSrcResource, SrcSubresource, Format); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(54)] + public void ExecuteCommandList(ID3D11CommandList* pCommandList, Bool32* RestoreContextState) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[54]))((ID3D11DeviceContext1*)Unsafe.AsPointer(ref this), pCommandList, RestoreContextState); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[54]))((ID3D11DeviceContext1*)Unsafe.AsPointer(ref this), pCommandList, RestoreContextState); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(55)] + public void HSSetShaderResources(uint StartSlot, uint NumViews, ID3D11ShaderResourceView* ppShaderResourceViews) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[55]))((ID3D11DeviceContext1*)Unsafe.AsPointer(ref this), StartSlot, NumViews, ppShaderResourceViews); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[55]))((ID3D11DeviceContext1*)Unsafe.AsPointer(ref this), StartSlot, NumViews, ppShaderResourceViews); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(56)] + public void HSSetShader(ID3D11HullShader* pHullShader, ID3D11ClassInstance* ppClassInstances, uint NumClassInstances) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[56]))((ID3D11DeviceContext1*)Unsafe.AsPointer(ref this), pHullShader, ppClassInstances, NumClassInstances); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[56]))((ID3D11DeviceContext1*)Unsafe.AsPointer(ref this), pHullShader, ppClassInstances, NumClassInstances); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(57)] + public void HSSetSamplers(uint StartSlot, uint NumSamplers, ID3D11SamplerState* ppSamplers) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[57]))((ID3D11DeviceContext1*)Unsafe.AsPointer(ref this), StartSlot, NumSamplers, ppSamplers); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[57]))((ID3D11DeviceContext1*)Unsafe.AsPointer(ref this), StartSlot, NumSamplers, ppSamplers); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(58)] + public void HSSetConstantBuffers(uint StartSlot, uint NumBuffers, ID3D11Buffer* ppConstantBuffers) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[58]))((ID3D11DeviceContext1*)Unsafe.AsPointer(ref this), StartSlot, NumBuffers, ppConstantBuffers); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[58]))((ID3D11DeviceContext1*)Unsafe.AsPointer(ref this), StartSlot, NumBuffers, ppConstantBuffers); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(59)] + public void DSSetShaderResources(uint StartSlot, uint NumViews, ID3D11ShaderResourceView* ppShaderResourceViews) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[59]))((ID3D11DeviceContext1*)Unsafe.AsPointer(ref this), StartSlot, NumViews, ppShaderResourceViews); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[59]))((ID3D11DeviceContext1*)Unsafe.AsPointer(ref this), StartSlot, NumViews, ppShaderResourceViews); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(60)] + public void DSSetShader(ID3D11DomainShader* pDomainShader, ID3D11ClassInstance* ppClassInstances, uint NumClassInstances) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[60]))((ID3D11DeviceContext1*)Unsafe.AsPointer(ref this), pDomainShader, ppClassInstances, NumClassInstances); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[60]))((ID3D11DeviceContext1*)Unsafe.AsPointer(ref this), pDomainShader, ppClassInstances, NumClassInstances); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(61)] + public void DSSetSamplers(uint StartSlot, uint NumSamplers, ID3D11SamplerState* ppSamplers) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[61]))((ID3D11DeviceContext1*)Unsafe.AsPointer(ref this), StartSlot, NumSamplers, ppSamplers); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[61]))((ID3D11DeviceContext1*)Unsafe.AsPointer(ref this), StartSlot, NumSamplers, ppSamplers); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(62)] + public void DSSetConstantBuffers(uint StartSlot, uint NumBuffers, ID3D11Buffer* ppConstantBuffers) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[62]))((ID3D11DeviceContext1*)Unsafe.AsPointer(ref this), StartSlot, NumBuffers, ppConstantBuffers); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[62]))((ID3D11DeviceContext1*)Unsafe.AsPointer(ref this), StartSlot, NumBuffers, ppConstantBuffers); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(63)] + public void CSSetShaderResources(uint StartSlot, uint NumViews, ID3D11ShaderResourceView* ppShaderResourceViews) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[63]))((ID3D11DeviceContext1*)Unsafe.AsPointer(ref this), StartSlot, NumViews, ppShaderResourceViews); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[63]))((ID3D11DeviceContext1*)Unsafe.AsPointer(ref this), StartSlot, NumViews, ppShaderResourceViews); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(64)] + public void CSSetUnorderedAccessViews(uint StartSlot, uint NumUAVs, ID3D11UnorderedAccessView* ppUnorderedAccessViews, uint* pUAVInitialCounts) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[64]))((ID3D11DeviceContext1*)Unsafe.AsPointer(ref this), StartSlot, NumUAVs, ppUnorderedAccessViews, pUAVInitialCounts); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[64]))((ID3D11DeviceContext1*)Unsafe.AsPointer(ref this), StartSlot, NumUAVs, ppUnorderedAccessViews, pUAVInitialCounts); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(65)] + public void CSSetShader(ID3D11ComputeShader* pComputeShader, ID3D11ClassInstance* ppClassInstances, uint NumClassInstances) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[65]))((ID3D11DeviceContext1*)Unsafe.AsPointer(ref this), pComputeShader, ppClassInstances, NumClassInstances); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[65]))((ID3D11DeviceContext1*)Unsafe.AsPointer(ref this), pComputeShader, ppClassInstances, NumClassInstances); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(66)] + public void CSSetSamplers(uint StartSlot, uint NumSamplers, ID3D11SamplerState* ppSamplers) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[66]))((ID3D11DeviceContext1*)Unsafe.AsPointer(ref this), StartSlot, NumSamplers, ppSamplers); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[66]))((ID3D11DeviceContext1*)Unsafe.AsPointer(ref this), StartSlot, NumSamplers, ppSamplers); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(67)] + public void CSSetConstantBuffers(uint StartSlot, uint NumBuffers, ID3D11Buffer* ppConstantBuffers) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[67]))((ID3D11DeviceContext1*)Unsafe.AsPointer(ref this), StartSlot, NumBuffers, ppConstantBuffers); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[67]))((ID3D11DeviceContext1*)Unsafe.AsPointer(ref this), StartSlot, NumBuffers, ppConstantBuffers); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(68)] + public void VSGetConstantBuffers(uint StartSlot, uint NumBuffers, ID3D11Buffer* ppConstantBuffers) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[68]))((ID3D11DeviceContext1*)Unsafe.AsPointer(ref this), StartSlot, NumBuffers, ppConstantBuffers); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[68]))((ID3D11DeviceContext1*)Unsafe.AsPointer(ref this), StartSlot, NumBuffers, ppConstantBuffers); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(69)] + public void PSGetShaderResources(uint StartSlot, uint NumViews, ID3D11ShaderResourceView* ppShaderResourceViews) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[69]))((ID3D11DeviceContext1*)Unsafe.AsPointer(ref this), StartSlot, NumViews, ppShaderResourceViews); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[69]))((ID3D11DeviceContext1*)Unsafe.AsPointer(ref this), StartSlot, NumViews, ppShaderResourceViews); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(70)] + public void PSGetShader(ID3D11PixelShader* ppPixelShader, ID3D11ClassInstance* ppClassInstances, uint* pNumClassInstances) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[70]))((ID3D11DeviceContext1*)Unsafe.AsPointer(ref this), ppPixelShader, ppClassInstances, pNumClassInstances); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[70]))((ID3D11DeviceContext1*)Unsafe.AsPointer(ref this), ppPixelShader, ppClassInstances, pNumClassInstances); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(71)] + public void PSGetSamplers(uint StartSlot, uint NumSamplers, ID3D11SamplerState* ppSamplers) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[71]))((ID3D11DeviceContext1*)Unsafe.AsPointer(ref this), StartSlot, NumSamplers, ppSamplers); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[71]))((ID3D11DeviceContext1*)Unsafe.AsPointer(ref this), StartSlot, NumSamplers, ppSamplers); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(72)] + public void VSGetShader(ID3D11VertexShader* ppVertexShader, ID3D11ClassInstance* ppClassInstances, uint* pNumClassInstances) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[72]))((ID3D11DeviceContext1*)Unsafe.AsPointer(ref this), ppVertexShader, ppClassInstances, pNumClassInstances); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[72]))((ID3D11DeviceContext1*)Unsafe.AsPointer(ref this), ppVertexShader, ppClassInstances, pNumClassInstances); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(73)] + public void PSGetConstantBuffers(uint StartSlot, uint NumBuffers, ID3D11Buffer* ppConstantBuffers) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[73]))((ID3D11DeviceContext1*)Unsafe.AsPointer(ref this), StartSlot, NumBuffers, ppConstantBuffers); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[73]))((ID3D11DeviceContext1*)Unsafe.AsPointer(ref this), StartSlot, NumBuffers, ppConstantBuffers); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(74)] + public void IAGetInputLayout(ID3D11InputLayout* ppInputLayout) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[74]))((ID3D11DeviceContext1*)Unsafe.AsPointer(ref this), ppInputLayout); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[74]))((ID3D11DeviceContext1*)Unsafe.AsPointer(ref this), ppInputLayout); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(75)] + public void IAGetVertexBuffers(uint StartSlot, uint NumBuffers, ID3D11Buffer* ppVertexBuffers, uint* pStrides, uint* pOffsets) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[75]))((ID3D11DeviceContext1*)Unsafe.AsPointer(ref this), StartSlot, NumBuffers, ppVertexBuffers, pStrides, pOffsets); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[75]))((ID3D11DeviceContext1*)Unsafe.AsPointer(ref this), StartSlot, NumBuffers, ppVertexBuffers, pStrides, pOffsets); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(76)] + public void IAGetIndexBuffer(ID3D11Buffer* pIndexBuffer, Graphics.Dxgi.Common.Format* Format, uint* Offset) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[76]))((ID3D11DeviceContext1*)Unsafe.AsPointer(ref this), pIndexBuffer, Format, Offset); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[76]))((ID3D11DeviceContext1*)Unsafe.AsPointer(ref this), pIndexBuffer, Format, Offset); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(77)] + public void GSGetConstantBuffers(uint StartSlot, uint NumBuffers, ID3D11Buffer* ppConstantBuffers) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[77]))((ID3D11DeviceContext1*)Unsafe.AsPointer(ref this), StartSlot, NumBuffers, ppConstantBuffers); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[77]))((ID3D11DeviceContext1*)Unsafe.AsPointer(ref this), StartSlot, NumBuffers, ppConstantBuffers); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(78)] + public void GSGetShader(ID3D11GeometryShader* ppGeometryShader, ID3D11ClassInstance* ppClassInstances, uint* pNumClassInstances) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[78]))((ID3D11DeviceContext1*)Unsafe.AsPointer(ref this), ppGeometryShader, ppClassInstances, pNumClassInstances); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[78]))((ID3D11DeviceContext1*)Unsafe.AsPointer(ref this), ppGeometryShader, ppClassInstances, pNumClassInstances); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(79)] + public void IAGetPrimitiveTopology(Graphics.Direct3D.PrimitiveTopology* pTopology) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[79]))((ID3D11DeviceContext1*)Unsafe.AsPointer(ref this), pTopology); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[79]))((ID3D11DeviceContext1*)Unsafe.AsPointer(ref this), pTopology); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(80)] + public void VSGetShaderResources(uint StartSlot, uint NumViews, ID3D11ShaderResourceView* ppShaderResourceViews) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[80]))((ID3D11DeviceContext1*)Unsafe.AsPointer(ref this), StartSlot, NumViews, ppShaderResourceViews); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[80]))((ID3D11DeviceContext1*)Unsafe.AsPointer(ref this), StartSlot, NumViews, ppShaderResourceViews); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(81)] + public void VSGetSamplers(uint StartSlot, uint NumSamplers, ID3D11SamplerState* ppSamplers) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[81]))((ID3D11DeviceContext1*)Unsafe.AsPointer(ref this), StartSlot, NumSamplers, ppSamplers); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[81]))((ID3D11DeviceContext1*)Unsafe.AsPointer(ref this), StartSlot, NumSamplers, ppSamplers); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(82)] + public void GetPredication(ID3D11Predicate* ppPredicate, Bool32* pPredicateValue) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[82]))((ID3D11DeviceContext1*)Unsafe.AsPointer(ref this), ppPredicate, pPredicateValue); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[82]))((ID3D11DeviceContext1*)Unsafe.AsPointer(ref this), ppPredicate, pPredicateValue); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(83)] + public void GSGetShaderResources(uint StartSlot, uint NumViews, ID3D11ShaderResourceView* ppShaderResourceViews) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[83]))((ID3D11DeviceContext1*)Unsafe.AsPointer(ref this), StartSlot, NumViews, ppShaderResourceViews); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[83]))((ID3D11DeviceContext1*)Unsafe.AsPointer(ref this), StartSlot, NumViews, ppShaderResourceViews); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(84)] + public void GSGetSamplers(uint StartSlot, uint NumSamplers, ID3D11SamplerState* ppSamplers) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[84]))((ID3D11DeviceContext1*)Unsafe.AsPointer(ref this), StartSlot, NumSamplers, ppSamplers); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[84]))((ID3D11DeviceContext1*)Unsafe.AsPointer(ref this), StartSlot, NumSamplers, ppSamplers); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(85)] + public void OMGetRenderTargets(uint NumViews, ID3D11RenderTargetView* ppRenderTargetViews, ID3D11DepthStencilView* ppDepthStencilView) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[85]))((ID3D11DeviceContext1*)Unsafe.AsPointer(ref this), NumViews, ppRenderTargetViews, ppDepthStencilView); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[85]))((ID3D11DeviceContext1*)Unsafe.AsPointer(ref this), NumViews, ppRenderTargetViews, ppDepthStencilView); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(86)] + public void OMGetRenderTargetsAndUnorderedAccessViews(uint NumRTVs, ID3D11RenderTargetView* ppRenderTargetViews, ID3D11DepthStencilView* ppDepthStencilView, uint UAVStartSlot, uint NumUAVs, ID3D11UnorderedAccessView* ppUnorderedAccessViews) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[86]))((ID3D11DeviceContext1*)Unsafe.AsPointer(ref this), NumRTVs, ppRenderTargetViews, ppDepthStencilView, UAVStartSlot, NumUAVs, ppUnorderedAccessViews); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[86]))((ID3D11DeviceContext1*)Unsafe.AsPointer(ref this), NumRTVs, ppRenderTargetViews, ppDepthStencilView, UAVStartSlot, NumUAVs, ppUnorderedAccessViews); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(87)] + public void OMGetBlendState(ID3D11BlendState* ppBlendState, float* BlendFactor, uint* pSampleMask) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[87]))((ID3D11DeviceContext1*)Unsafe.AsPointer(ref this), ppBlendState, BlendFactor, pSampleMask); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[87]))((ID3D11DeviceContext1*)Unsafe.AsPointer(ref this), ppBlendState, BlendFactor, pSampleMask); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(88)] + public void OMGetDepthStencilState(ID3D11DepthStencilState* ppDepthStencilState, uint* pStencilRef) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[88]))((ID3D11DeviceContext1*)Unsafe.AsPointer(ref this), ppDepthStencilState, pStencilRef); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[88]))((ID3D11DeviceContext1*)Unsafe.AsPointer(ref this), ppDepthStencilState, pStencilRef); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(89)] + public void SOGetTargets(uint NumBuffers, ID3D11Buffer* ppSOTargets) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[89]))((ID3D11DeviceContext1*)Unsafe.AsPointer(ref this), NumBuffers, ppSOTargets); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[89]))((ID3D11DeviceContext1*)Unsafe.AsPointer(ref this), NumBuffers, ppSOTargets); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(90)] + public void RSGetState(ID3D11RasterizerState* ppRasterizerState) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[90]))((ID3D11DeviceContext1*)Unsafe.AsPointer(ref this), ppRasterizerState); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[90]))((ID3D11DeviceContext1*)Unsafe.AsPointer(ref this), ppRasterizerState); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(91)] + public void RSGetViewports(uint* pNumViewports, Viewport* pViewports) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[91]))((ID3D11DeviceContext1*)Unsafe.AsPointer(ref this), pNumViewports, pViewports); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[91]))((ID3D11DeviceContext1*)Unsafe.AsPointer(ref this), pNumViewports, pViewports); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(92)] + public void RSGetScissorRects(uint* pNumRects, RawRect* pRects) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[92]))((ID3D11DeviceContext1*)Unsafe.AsPointer(ref this), pNumRects, pRects); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[92]))((ID3D11DeviceContext1*)Unsafe.AsPointer(ref this), pNumRects, pRects); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(93)] + public void HSGetShaderResources(uint StartSlot, uint NumViews, ID3D11ShaderResourceView* ppShaderResourceViews) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[93]))((ID3D11DeviceContext1*)Unsafe.AsPointer(ref this), StartSlot, NumViews, ppShaderResourceViews); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[93]))((ID3D11DeviceContext1*)Unsafe.AsPointer(ref this), StartSlot, NumViews, ppShaderResourceViews); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(94)] + public void HSGetShader(ID3D11HullShader* ppHullShader, ID3D11ClassInstance* ppClassInstances, uint* pNumClassInstances) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[94]))((ID3D11DeviceContext1*)Unsafe.AsPointer(ref this), ppHullShader, ppClassInstances, pNumClassInstances); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[94]))((ID3D11DeviceContext1*)Unsafe.AsPointer(ref this), ppHullShader, ppClassInstances, pNumClassInstances); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(95)] + public void HSGetSamplers(uint StartSlot, uint NumSamplers, ID3D11SamplerState* ppSamplers) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[95]))((ID3D11DeviceContext1*)Unsafe.AsPointer(ref this), StartSlot, NumSamplers, ppSamplers); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[95]))((ID3D11DeviceContext1*)Unsafe.AsPointer(ref this), StartSlot, NumSamplers, ppSamplers); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(96)] + public void HSGetConstantBuffers(uint StartSlot, uint NumBuffers, ID3D11Buffer* ppConstantBuffers) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[96]))((ID3D11DeviceContext1*)Unsafe.AsPointer(ref this), StartSlot, NumBuffers, ppConstantBuffers); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[96]))((ID3D11DeviceContext1*)Unsafe.AsPointer(ref this), StartSlot, NumBuffers, ppConstantBuffers); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(97)] + public void DSGetShaderResources(uint StartSlot, uint NumViews, ID3D11ShaderResourceView* ppShaderResourceViews) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[97]))((ID3D11DeviceContext1*)Unsafe.AsPointer(ref this), StartSlot, NumViews, ppShaderResourceViews); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[97]))((ID3D11DeviceContext1*)Unsafe.AsPointer(ref this), StartSlot, NumViews, ppShaderResourceViews); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(98)] + public void DSGetShader(ID3D11DomainShader* ppDomainShader, ID3D11ClassInstance* ppClassInstances, uint* pNumClassInstances) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[98]))((ID3D11DeviceContext1*)Unsafe.AsPointer(ref this), ppDomainShader, ppClassInstances, pNumClassInstances); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[98]))((ID3D11DeviceContext1*)Unsafe.AsPointer(ref this), ppDomainShader, ppClassInstances, pNumClassInstances); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(99)] + public void DSGetSamplers(uint StartSlot, uint NumSamplers, ID3D11SamplerState* ppSamplers) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[99]))((ID3D11DeviceContext1*)Unsafe.AsPointer(ref this), StartSlot, NumSamplers, ppSamplers); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[99]))((ID3D11DeviceContext1*)Unsafe.AsPointer(ref this), StartSlot, NumSamplers, ppSamplers); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(100)] + public void DSGetConstantBuffers(uint StartSlot, uint NumBuffers, ID3D11Buffer* ppConstantBuffers) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[100]))((ID3D11DeviceContext1*)Unsafe.AsPointer(ref this), StartSlot, NumBuffers, ppConstantBuffers); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[100]))((ID3D11DeviceContext1*)Unsafe.AsPointer(ref this), StartSlot, NumBuffers, ppConstantBuffers); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(101)] + public void CSGetShaderResources(uint StartSlot, uint NumViews, ID3D11ShaderResourceView* ppShaderResourceViews) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[101]))((ID3D11DeviceContext1*)Unsafe.AsPointer(ref this), StartSlot, NumViews, ppShaderResourceViews); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[101]))((ID3D11DeviceContext1*)Unsafe.AsPointer(ref this), StartSlot, NumViews, ppShaderResourceViews); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(102)] + public void CSGetUnorderedAccessViews(uint StartSlot, uint NumUAVs, ID3D11UnorderedAccessView* ppUnorderedAccessViews) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[102]))((ID3D11DeviceContext1*)Unsafe.AsPointer(ref this), StartSlot, NumUAVs, ppUnorderedAccessViews); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[102]))((ID3D11DeviceContext1*)Unsafe.AsPointer(ref this), StartSlot, NumUAVs, ppUnorderedAccessViews); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(103)] + public void CSGetShader(ID3D11ComputeShader* ppComputeShader, ID3D11ClassInstance* ppClassInstances, uint* pNumClassInstances) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[103]))((ID3D11DeviceContext1*)Unsafe.AsPointer(ref this), ppComputeShader, ppClassInstances, pNumClassInstances); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[103]))((ID3D11DeviceContext1*)Unsafe.AsPointer(ref this), ppComputeShader, ppClassInstances, pNumClassInstances); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(104)] + public void CSGetSamplers(uint StartSlot, uint NumSamplers, ID3D11SamplerState* ppSamplers) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[104]))((ID3D11DeviceContext1*)Unsafe.AsPointer(ref this), StartSlot, NumSamplers, ppSamplers); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[104]))((ID3D11DeviceContext1*)Unsafe.AsPointer(ref this), StartSlot, NumSamplers, ppSamplers); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(105)] + public void CSGetConstantBuffers(uint StartSlot, uint NumBuffers, ID3D11Buffer* ppConstantBuffers) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[105]))((ID3D11DeviceContext1*)Unsafe.AsPointer(ref this), StartSlot, NumBuffers, ppConstantBuffers); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[105]))((ID3D11DeviceContext1*)Unsafe.AsPointer(ref this), StartSlot, NumBuffers, ppConstantBuffers); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(106)] + public void ClearState() + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[106]))((ID3D11DeviceContext1*)Unsafe.AsPointer(ref this)); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[106]))((ID3D11DeviceContext1*)Unsafe.AsPointer(ref this)); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(107)] + public void Flush() + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[107]))((ID3D11DeviceContext1*)Unsafe.AsPointer(ref this)); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[107]))((ID3D11DeviceContext1*)Unsafe.AsPointer(ref this)); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(108)] + public Graphics.Direct3D11.DeviceContextType GetType() + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[108]))((ID3D11DeviceContext1*)Unsafe.AsPointer(ref this)); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[108]))((ID3D11DeviceContext1*)Unsafe.AsPointer(ref this)); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(109)] + public uint GetContextFlags() + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[109]))((ID3D11DeviceContext1*)Unsafe.AsPointer(ref this)); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[109]))((ID3D11DeviceContext1*)Unsafe.AsPointer(ref this)); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(110)] + public HResult FinishCommandList(Bool32* RestoreDeferredContextState, ID3D11CommandList** ppCommandList) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[110]))((ID3D11DeviceContext1*)Unsafe.AsPointer(ref this), RestoreDeferredContextState, ppCommandList); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[110]))((ID3D11DeviceContext1*)Unsafe.AsPointer(ref this), RestoreDeferredContextState, ppCommandList); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(111)] + public void GetDevice(ID3D11Device* ppDevice) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[111]))((ID3D11DeviceContext1*)Unsafe.AsPointer(ref this), ppDevice); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[111]))((ID3D11DeviceContext1*)Unsafe.AsPointer(ref this), ppDevice); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(112)] + public HResult GetPrivateData(Guid* guid, uint* pDataSize, void* pData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[112]))((ID3D11DeviceContext1*)Unsafe.AsPointer(ref this), guid, pDataSize, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[112]))((ID3D11DeviceContext1*)Unsafe.AsPointer(ref this), guid, pDataSize, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(113)] + public HResult SetPrivateData(Guid* guid, uint DataSize, void* pData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[113]))((ID3D11DeviceContext1*)Unsafe.AsPointer(ref this), guid, DataSize, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[113]))((ID3D11DeviceContext1*)Unsafe.AsPointer(ref this), guid, DataSize, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(114)] + public HResult SetPrivateDataInterface(Guid* guid, IUnknown* pData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[114]))((ID3D11DeviceContext1*)Unsafe.AsPointer(ref this), guid, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[114]))((ID3D11DeviceContext1*)Unsafe.AsPointer(ref this), guid, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(115)] + public void CopySubresourceRegion1(ID3D11Resource* pDstResource, uint DstSubresource, uint DstX, uint DstY, uint DstZ, ID3D11Resource* pSrcResource, uint SrcSubresource, Box* pSrcBox, uint CopyFlags) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[115]))((ID3D11DeviceContext1*)Unsafe.AsPointer(ref this), pDstResource, DstSubresource, DstX, DstY, DstZ, pSrcResource, SrcSubresource, pSrcBox, CopyFlags); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[115]))((ID3D11DeviceContext1*)Unsafe.AsPointer(ref this), pDstResource, DstSubresource, DstX, DstY, DstZ, pSrcResource, SrcSubresource, pSrcBox, CopyFlags); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(116)] + public void UpdateSubresource1(ID3D11Resource* pDstResource, uint DstSubresource, Box* pDstBox, void* pSrcData, uint SrcRowPitch, uint SrcDepthPitch, uint CopyFlags) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[116]))((ID3D11DeviceContext1*)Unsafe.AsPointer(ref this), pDstResource, DstSubresource, pDstBox, pSrcData, SrcRowPitch, SrcDepthPitch, CopyFlags); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[116]))((ID3D11DeviceContext1*)Unsafe.AsPointer(ref this), pDstResource, DstSubresource, pDstBox, pSrcData, SrcRowPitch, SrcDepthPitch, CopyFlags); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(117)] + public void DiscardResource(ID3D11Resource* pResource) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[117]))((ID3D11DeviceContext1*)Unsafe.AsPointer(ref this), pResource); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[117]))((ID3D11DeviceContext1*)Unsafe.AsPointer(ref this), pResource); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(118)] + public void DiscardView(ID3D11View* pResourceView) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[118]))((ID3D11DeviceContext1*)Unsafe.AsPointer(ref this), pResourceView); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[118]))((ID3D11DeviceContext1*)Unsafe.AsPointer(ref this), pResourceView); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(119)] + public void VSSetConstantBuffers1(uint StartSlot, uint NumBuffers, ID3D11Buffer* ppConstantBuffers, uint* pFirstConstant, uint* pNumConstants) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[119]))((ID3D11DeviceContext1*)Unsafe.AsPointer(ref this), StartSlot, NumBuffers, ppConstantBuffers, pFirstConstant, pNumConstants); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[119]))((ID3D11DeviceContext1*)Unsafe.AsPointer(ref this), StartSlot, NumBuffers, ppConstantBuffers, pFirstConstant, pNumConstants); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(120)] + public void HSSetConstantBuffers1(uint StartSlot, uint NumBuffers, ID3D11Buffer* ppConstantBuffers, uint* pFirstConstant, uint* pNumConstants) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[120]))((ID3D11DeviceContext1*)Unsafe.AsPointer(ref this), StartSlot, NumBuffers, ppConstantBuffers, pFirstConstant, pNumConstants); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[120]))((ID3D11DeviceContext1*)Unsafe.AsPointer(ref this), StartSlot, NumBuffers, ppConstantBuffers, pFirstConstant, pNumConstants); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(121)] + public void DSSetConstantBuffers1(uint StartSlot, uint NumBuffers, ID3D11Buffer* ppConstantBuffers, uint* pFirstConstant, uint* pNumConstants) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[121]))((ID3D11DeviceContext1*)Unsafe.AsPointer(ref this), StartSlot, NumBuffers, ppConstantBuffers, pFirstConstant, pNumConstants); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[121]))((ID3D11DeviceContext1*)Unsafe.AsPointer(ref this), StartSlot, NumBuffers, ppConstantBuffers, pFirstConstant, pNumConstants); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(122)] + public void GSSetConstantBuffers1(uint StartSlot, uint NumBuffers, ID3D11Buffer* ppConstantBuffers, uint* pFirstConstant, uint* pNumConstants) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[122]))((ID3D11DeviceContext1*)Unsafe.AsPointer(ref this), StartSlot, NumBuffers, ppConstantBuffers, pFirstConstant, pNumConstants); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[122]))((ID3D11DeviceContext1*)Unsafe.AsPointer(ref this), StartSlot, NumBuffers, ppConstantBuffers, pFirstConstant, pNumConstants); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(123)] + public void PSSetConstantBuffers1(uint StartSlot, uint NumBuffers, ID3D11Buffer* ppConstantBuffers, uint* pFirstConstant, uint* pNumConstants) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[123]))((ID3D11DeviceContext1*)Unsafe.AsPointer(ref this), StartSlot, NumBuffers, ppConstantBuffers, pFirstConstant, pNumConstants); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[123]))((ID3D11DeviceContext1*)Unsafe.AsPointer(ref this), StartSlot, NumBuffers, ppConstantBuffers, pFirstConstant, pNumConstants); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(124)] + public void CSSetConstantBuffers1(uint StartSlot, uint NumBuffers, ID3D11Buffer* ppConstantBuffers, uint* pFirstConstant, uint* pNumConstants) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[124]))((ID3D11DeviceContext1*)Unsafe.AsPointer(ref this), StartSlot, NumBuffers, ppConstantBuffers, pFirstConstant, pNumConstants); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[124]))((ID3D11DeviceContext1*)Unsafe.AsPointer(ref this), StartSlot, NumBuffers, ppConstantBuffers, pFirstConstant, pNumConstants); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(125)] + public void VSGetConstantBuffers1(uint StartSlot, uint NumBuffers, ID3D11Buffer* ppConstantBuffers, uint* pFirstConstant, uint* pNumConstants) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[125]))((ID3D11DeviceContext1*)Unsafe.AsPointer(ref this), StartSlot, NumBuffers, ppConstantBuffers, pFirstConstant, pNumConstants); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[125]))((ID3D11DeviceContext1*)Unsafe.AsPointer(ref this), StartSlot, NumBuffers, ppConstantBuffers, pFirstConstant, pNumConstants); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(126)] + public void HSGetConstantBuffers1(uint StartSlot, uint NumBuffers, ID3D11Buffer* ppConstantBuffers, uint* pFirstConstant, uint* pNumConstants) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[126]))((ID3D11DeviceContext1*)Unsafe.AsPointer(ref this), StartSlot, NumBuffers, ppConstantBuffers, pFirstConstant, pNumConstants); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[126]))((ID3D11DeviceContext1*)Unsafe.AsPointer(ref this), StartSlot, NumBuffers, ppConstantBuffers, pFirstConstant, pNumConstants); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(127)] + public void DSGetConstantBuffers1(uint StartSlot, uint NumBuffers, ID3D11Buffer* ppConstantBuffers, uint* pFirstConstant, uint* pNumConstants) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[127]))((ID3D11DeviceContext1*)Unsafe.AsPointer(ref this), StartSlot, NumBuffers, ppConstantBuffers, pFirstConstant, pNumConstants); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[127]))((ID3D11DeviceContext1*)Unsafe.AsPointer(ref this), StartSlot, NumBuffers, ppConstantBuffers, pFirstConstant, pNumConstants); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(128)] + public void GSGetConstantBuffers1(uint StartSlot, uint NumBuffers, ID3D11Buffer* ppConstantBuffers, uint* pFirstConstant, uint* pNumConstants) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[128]))((ID3D11DeviceContext1*)Unsafe.AsPointer(ref this), StartSlot, NumBuffers, ppConstantBuffers, pFirstConstant, pNumConstants); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[128]))((ID3D11DeviceContext1*)Unsafe.AsPointer(ref this), StartSlot, NumBuffers, ppConstantBuffers, pFirstConstant, pNumConstants); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(129)] + public void PSGetConstantBuffers1(uint StartSlot, uint NumBuffers, ID3D11Buffer* ppConstantBuffers, uint* pFirstConstant, uint* pNumConstants) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[129]))((ID3D11DeviceContext1*)Unsafe.AsPointer(ref this), StartSlot, NumBuffers, ppConstantBuffers, pFirstConstant, pNumConstants); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[129]))((ID3D11DeviceContext1*)Unsafe.AsPointer(ref this), StartSlot, NumBuffers, ppConstantBuffers, pFirstConstant, pNumConstants); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(130)] + public void CSGetConstantBuffers1(uint StartSlot, uint NumBuffers, ID3D11Buffer* ppConstantBuffers, uint* pFirstConstant, uint* pNumConstants) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[130]))((ID3D11DeviceContext1*)Unsafe.AsPointer(ref this), StartSlot, NumBuffers, ppConstantBuffers, pFirstConstant, pNumConstants); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[130]))((ID3D11DeviceContext1*)Unsafe.AsPointer(ref this), StartSlot, NumBuffers, ppConstantBuffers, pFirstConstant, pNumConstants); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(131)] + public void SwapDeviceContextState(ID3DDeviceContextState* pState, ID3DDeviceContextState* ppPreviousState) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[131]))((ID3D11DeviceContext1*)Unsafe.AsPointer(ref this), pState, ppPreviousState); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[131]))((ID3D11DeviceContext1*)Unsafe.AsPointer(ref this), pState, ppPreviousState); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(132)] + public void ClearView(ID3D11View* pView, float* Color, RawRect* pRect, uint NumRects) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[132]))((ID3D11DeviceContext1*)Unsafe.AsPointer(ref this), pView, Color, pRect, NumRects); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[132]))((ID3D11DeviceContext1*)Unsafe.AsPointer(ref this), pView, Color, pRect, NumRects); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(133)] + public void DiscardView1(ID3D11View* pResourceView, RawRect* pRects, uint NumRects) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[133]))((ID3D11DeviceContext1*)Unsafe.AsPointer(ref this), pResourceView, pRects, NumRects); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[133]))((ID3D11DeviceContext1*)Unsafe.AsPointer(ref this), pResourceView, pRects, NumRects); +#endif + } + + public interface Interface : ID3D11DeviceContext.Interface + { + } +} + +/// +/// ID3D11VideoContext1 +[Guid("a7f026da-a5f8-4487-a564-15e34357651e")] +[NativeTypeName("struct ID3D11VideoContext1 : ID3D11VideoContext")] +[NativeInheritance("ID3D11VideoContext")] +public unsafe partial struct ID3D11VideoContext1 : ID3D11VideoContext1.Interface +{ + public static ref readonly Guid IID_ID3D11VideoContext1 + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0xDA, 0x26, 0xF0, 0xA7, + 0xF8, 0xA5, + 0x87, 0x44, + 0xA5, + 0x64, + 0x15, + 0xE3, + 0x43, + 0x57, + 0x65, + 0x1E + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_ID3D11VideoContext1)); + + public void** lpVtbl; + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(0)] + public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(1)] + [return: NativeTypeName("ULONG")] + public uint AddRef() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(2)] + [return: NativeTypeName("ULONG")] + public uint Release() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(3)] + public HResult GetDecoderBuffer(ID3D11VideoDecoder* pDecoder, VideoDecoderBufferType Type, uint* pBufferSize, void** ppBuffer) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[3]))((ID3D11VideoContext1*)Unsafe.AsPointer(ref this), pDecoder, Type, pBufferSize, ppBuffer); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((ID3D11VideoContext1*)Unsafe.AsPointer(ref this), pDecoder, Type, pBufferSize, ppBuffer); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public HResult ReleaseDecoderBuffer(ID3D11VideoDecoder* pDecoder, VideoDecoderBufferType Type) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[4]))((ID3D11VideoContext1*)Unsafe.AsPointer(ref this), pDecoder, Type); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((ID3D11VideoContext1*)Unsafe.AsPointer(ref this), pDecoder, Type); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(5)] + public HResult DecoderBeginFrame(ID3D11VideoDecoder* pDecoder, ID3D11VideoDecoderOutputView* pView, uint ContentKeySize, void* pContentKey) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[5]))((ID3D11VideoContext1*)Unsafe.AsPointer(ref this), pDecoder, pView, ContentKeySize, pContentKey); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((ID3D11VideoContext1*)Unsafe.AsPointer(ref this), pDecoder, pView, ContentKeySize, pContentKey); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(6)] + public HResult DecoderEndFrame(ID3D11VideoDecoder* pDecoder) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[6]))((ID3D11VideoContext1*)Unsafe.AsPointer(ref this), pDecoder); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((ID3D11VideoContext1*)Unsafe.AsPointer(ref this), pDecoder); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(7)] + public HResult SubmitDecoderBuffers(ID3D11VideoDecoder* pDecoder, uint NumBuffers, VideoDecoderBufferDescription* pBufferDesc) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[7]))((ID3D11VideoContext1*)Unsafe.AsPointer(ref this), pDecoder, NumBuffers, pBufferDesc); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((ID3D11VideoContext1*)Unsafe.AsPointer(ref this), pDecoder, NumBuffers, pBufferDesc); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(8)] + public int DecoderExtension(ID3D11VideoDecoder* pDecoder, VideoDecoderExtension* pExtensionData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[8]))((ID3D11VideoContext1*)Unsafe.AsPointer(ref this), pDecoder, pExtensionData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[8]))((ID3D11VideoContext1*)Unsafe.AsPointer(ref this), pDecoder, pExtensionData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(9)] + public void VideoProcessorSetOutputTargetRect(ID3D11VideoProcessor* pVideoProcessor, Bool32* Enable, RawRect* pRect) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[9]))((ID3D11VideoContext1*)Unsafe.AsPointer(ref this), pVideoProcessor, Enable, pRect); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[9]))((ID3D11VideoContext1*)Unsafe.AsPointer(ref this), pVideoProcessor, Enable, pRect); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(10)] + public void VideoProcessorSetOutputBackgroundColor(ID3D11VideoProcessor* pVideoProcessor, Bool32* YCbCr, VideoColor* pColor) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[10]))((ID3D11VideoContext1*)Unsafe.AsPointer(ref this), pVideoProcessor, YCbCr, pColor); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[10]))((ID3D11VideoContext1*)Unsafe.AsPointer(ref this), pVideoProcessor, YCbCr, pColor); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(11)] + public void VideoProcessorSetOutputColorSpace(ID3D11VideoProcessor* pVideoProcessor, VideoProcessorColorSpace* pColorSpace) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[11]))((ID3D11VideoContext1*)Unsafe.AsPointer(ref this), pVideoProcessor, pColorSpace); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[11]))((ID3D11VideoContext1*)Unsafe.AsPointer(ref this), pVideoProcessor, pColorSpace); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(12)] + public void VideoProcessorSetOutputAlphaFillMode(ID3D11VideoProcessor* pVideoProcessor, VideoProcessorAlphaFillMode AlphaFillMode, uint StreamIndex) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[12]))((ID3D11VideoContext1*)Unsafe.AsPointer(ref this), pVideoProcessor, AlphaFillMode, StreamIndex); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[12]))((ID3D11VideoContext1*)Unsafe.AsPointer(ref this), pVideoProcessor, AlphaFillMode, StreamIndex); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(13)] + public void VideoProcessorSetOutputConstriction(ID3D11VideoProcessor* pVideoProcessor, Bool32* Enable, System.Drawing.Size* Size) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[13]))((ID3D11VideoContext1*)Unsafe.AsPointer(ref this), pVideoProcessor, Enable, Size); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[13]))((ID3D11VideoContext1*)Unsafe.AsPointer(ref this), pVideoProcessor, Enable, Size); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(14)] + public void VideoProcessorSetOutputStereoMode(ID3D11VideoProcessor* pVideoProcessor, Bool32* Enable) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[14]))((ID3D11VideoContext1*)Unsafe.AsPointer(ref this), pVideoProcessor, Enable); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[14]))((ID3D11VideoContext1*)Unsafe.AsPointer(ref this), pVideoProcessor, Enable); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(15)] + public int VideoProcessorSetOutputExtension(ID3D11VideoProcessor* pVideoProcessor, Guid* pExtensionGuid, uint DataSize, void* pData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[15]))((ID3D11VideoContext1*)Unsafe.AsPointer(ref this), pVideoProcessor, pExtensionGuid, DataSize, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[15]))((ID3D11VideoContext1*)Unsafe.AsPointer(ref this), pVideoProcessor, pExtensionGuid, DataSize, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(16)] + public void VideoProcessorGetOutputTargetRect(ID3D11VideoProcessor* pVideoProcessor, Bool32* Enabled, RawRect* pRect) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[16]))((ID3D11VideoContext1*)Unsafe.AsPointer(ref this), pVideoProcessor, Enabled, pRect); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[16]))((ID3D11VideoContext1*)Unsafe.AsPointer(ref this), pVideoProcessor, Enabled, pRect); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(17)] + public void VideoProcessorGetOutputBackgroundColor(ID3D11VideoProcessor* pVideoProcessor, Bool32* pYCbCr, VideoColor* pColor) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[17]))((ID3D11VideoContext1*)Unsafe.AsPointer(ref this), pVideoProcessor, pYCbCr, pColor); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[17]))((ID3D11VideoContext1*)Unsafe.AsPointer(ref this), pVideoProcessor, pYCbCr, pColor); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(18)] + public void VideoProcessorGetOutputColorSpace(ID3D11VideoProcessor* pVideoProcessor, VideoProcessorColorSpace* pColorSpace) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[18]))((ID3D11VideoContext1*)Unsafe.AsPointer(ref this), pVideoProcessor, pColorSpace); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[18]))((ID3D11VideoContext1*)Unsafe.AsPointer(ref this), pVideoProcessor, pColorSpace); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(19)] + public void VideoProcessorGetOutputAlphaFillMode(ID3D11VideoProcessor* pVideoProcessor, VideoProcessorAlphaFillMode* pAlphaFillMode, uint* pStreamIndex) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[19]))((ID3D11VideoContext1*)Unsafe.AsPointer(ref this), pVideoProcessor, pAlphaFillMode, pStreamIndex); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[19]))((ID3D11VideoContext1*)Unsafe.AsPointer(ref this), pVideoProcessor, pAlphaFillMode, pStreamIndex); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(20)] + public void VideoProcessorGetOutputConstriction(ID3D11VideoProcessor* pVideoProcessor, Bool32* pEnabled, System.Drawing.Size* pSize) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[20]))((ID3D11VideoContext1*)Unsafe.AsPointer(ref this), pVideoProcessor, pEnabled, pSize); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[20]))((ID3D11VideoContext1*)Unsafe.AsPointer(ref this), pVideoProcessor, pEnabled, pSize); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(21)] + public void VideoProcessorGetOutputStereoMode(ID3D11VideoProcessor* pVideoProcessor, Bool32* pEnabled) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[21]))((ID3D11VideoContext1*)Unsafe.AsPointer(ref this), pVideoProcessor, pEnabled); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[21]))((ID3D11VideoContext1*)Unsafe.AsPointer(ref this), pVideoProcessor, pEnabled); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(22)] + public int VideoProcessorGetOutputExtension(ID3D11VideoProcessor* pVideoProcessor, Guid* pExtensionGuid, uint DataSize, void* pData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[22]))((ID3D11VideoContext1*)Unsafe.AsPointer(ref this), pVideoProcessor, pExtensionGuid, DataSize, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[22]))((ID3D11VideoContext1*)Unsafe.AsPointer(ref this), pVideoProcessor, pExtensionGuid, DataSize, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(23)] + public void VideoProcessorSetStreamFrameFormat(ID3D11VideoProcessor* pVideoProcessor, uint StreamIndex, VideoFrameFormat FrameFormat) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[23]))((ID3D11VideoContext1*)Unsafe.AsPointer(ref this), pVideoProcessor, StreamIndex, FrameFormat); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[23]))((ID3D11VideoContext1*)Unsafe.AsPointer(ref this), pVideoProcessor, StreamIndex, FrameFormat); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(24)] + public void VideoProcessorSetStreamColorSpace(ID3D11VideoProcessor* pVideoProcessor, uint StreamIndex, VideoProcessorColorSpace* pColorSpace) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[24]))((ID3D11VideoContext1*)Unsafe.AsPointer(ref this), pVideoProcessor, StreamIndex, pColorSpace); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[24]))((ID3D11VideoContext1*)Unsafe.AsPointer(ref this), pVideoProcessor, StreamIndex, pColorSpace); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(25)] + public void VideoProcessorSetStreamOutputRate(ID3D11VideoProcessor* pVideoProcessor, uint StreamIndex, VideoProcessorOutputRate OutputRate, Bool32* RepeatFrame, Graphics.Dxgi.Common.Rational* pCustomRate) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[25]))((ID3D11VideoContext1*)Unsafe.AsPointer(ref this), pVideoProcessor, StreamIndex, OutputRate, RepeatFrame, pCustomRate); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[25]))((ID3D11VideoContext1*)Unsafe.AsPointer(ref this), pVideoProcessor, StreamIndex, OutputRate, RepeatFrame, pCustomRate); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(26)] + public void VideoProcessorSetStreamSourceRect(ID3D11VideoProcessor* pVideoProcessor, uint StreamIndex, Bool32* Enable, RawRect* pRect) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[26]))((ID3D11VideoContext1*)Unsafe.AsPointer(ref this), pVideoProcessor, StreamIndex, Enable, pRect); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[26]))((ID3D11VideoContext1*)Unsafe.AsPointer(ref this), pVideoProcessor, StreamIndex, Enable, pRect); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(27)] + public void VideoProcessorSetStreamDestRect(ID3D11VideoProcessor* pVideoProcessor, uint StreamIndex, Bool32* Enable, RawRect* pRect) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[27]))((ID3D11VideoContext1*)Unsafe.AsPointer(ref this), pVideoProcessor, StreamIndex, Enable, pRect); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[27]))((ID3D11VideoContext1*)Unsafe.AsPointer(ref this), pVideoProcessor, StreamIndex, Enable, pRect); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(28)] + public void VideoProcessorSetStreamAlpha(ID3D11VideoProcessor* pVideoProcessor, uint StreamIndex, Bool32* Enable, float Alpha) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[28]))((ID3D11VideoContext1*)Unsafe.AsPointer(ref this), pVideoProcessor, StreamIndex, Enable, Alpha); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[28]))((ID3D11VideoContext1*)Unsafe.AsPointer(ref this), pVideoProcessor, StreamIndex, Enable, Alpha); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(29)] + public void VideoProcessorSetStreamPalette(ID3D11VideoProcessor* pVideoProcessor, uint StreamIndex, uint Count, uint* pEntries) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[29]))((ID3D11VideoContext1*)Unsafe.AsPointer(ref this), pVideoProcessor, StreamIndex, Count, pEntries); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[29]))((ID3D11VideoContext1*)Unsafe.AsPointer(ref this), pVideoProcessor, StreamIndex, Count, pEntries); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(30)] + public void VideoProcessorSetStreamPixelAspectRatio(ID3D11VideoProcessor* pVideoProcessor, uint StreamIndex, Bool32* Enable, Graphics.Dxgi.Common.Rational* pSourceAspectRatio, Graphics.Dxgi.Common.Rational* pDestinationAspectRatio) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[30]))((ID3D11VideoContext1*)Unsafe.AsPointer(ref this), pVideoProcessor, StreamIndex, Enable, pSourceAspectRatio, pDestinationAspectRatio); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[30]))((ID3D11VideoContext1*)Unsafe.AsPointer(ref this), pVideoProcessor, StreamIndex, Enable, pSourceAspectRatio, pDestinationAspectRatio); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(31)] + public void VideoProcessorSetStreamLumaKey(ID3D11VideoProcessor* pVideoProcessor, uint StreamIndex, Bool32* Enable, float Lower, float Upper) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[31]))((ID3D11VideoContext1*)Unsafe.AsPointer(ref this), pVideoProcessor, StreamIndex, Enable, Lower, Upper); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[31]))((ID3D11VideoContext1*)Unsafe.AsPointer(ref this), pVideoProcessor, StreamIndex, Enable, Lower, Upper); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(32)] + public void VideoProcessorSetStreamStereoFormat(ID3D11VideoProcessor* pVideoProcessor, uint StreamIndex, Bool32* Enable, VideoProcessorStereoFormat Format, Bool32* LeftViewFrame0, Bool32* BaseViewFrame0, VideoProcessorStereoFlipMode FlipMode, int MonoOffset) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[32]))((ID3D11VideoContext1*)Unsafe.AsPointer(ref this), pVideoProcessor, StreamIndex, Enable, Format, LeftViewFrame0, BaseViewFrame0, FlipMode, MonoOffset); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[32]))((ID3D11VideoContext1*)Unsafe.AsPointer(ref this), pVideoProcessor, StreamIndex, Enable, Format, LeftViewFrame0, BaseViewFrame0, FlipMode, MonoOffset); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(33)] + public void VideoProcessorSetStreamAutoProcessingMode(ID3D11VideoProcessor* pVideoProcessor, uint StreamIndex, Bool32* Enable) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[33]))((ID3D11VideoContext1*)Unsafe.AsPointer(ref this), pVideoProcessor, StreamIndex, Enable); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[33]))((ID3D11VideoContext1*)Unsafe.AsPointer(ref this), pVideoProcessor, StreamIndex, Enable); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(34)] + public void VideoProcessorSetStreamFilter(ID3D11VideoProcessor* pVideoProcessor, uint StreamIndex, VideoProcessorFilter Filter, Bool32* Enable, int Level) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[34]))((ID3D11VideoContext1*)Unsafe.AsPointer(ref this), pVideoProcessor, StreamIndex, Filter, Enable, Level); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[34]))((ID3D11VideoContext1*)Unsafe.AsPointer(ref this), pVideoProcessor, StreamIndex, Filter, Enable, Level); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(35)] + public int VideoProcessorSetStreamExtension(ID3D11VideoProcessor* pVideoProcessor, uint StreamIndex, Guid* pExtensionGuid, uint DataSize, void* pData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[35]))((ID3D11VideoContext1*)Unsafe.AsPointer(ref this), pVideoProcessor, StreamIndex, pExtensionGuid, DataSize, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[35]))((ID3D11VideoContext1*)Unsafe.AsPointer(ref this), pVideoProcessor, StreamIndex, pExtensionGuid, DataSize, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(36)] + public void VideoProcessorGetStreamFrameFormat(ID3D11VideoProcessor* pVideoProcessor, uint StreamIndex, VideoFrameFormat* pFrameFormat) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[36]))((ID3D11VideoContext1*)Unsafe.AsPointer(ref this), pVideoProcessor, StreamIndex, pFrameFormat); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[36]))((ID3D11VideoContext1*)Unsafe.AsPointer(ref this), pVideoProcessor, StreamIndex, pFrameFormat); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(37)] + public void VideoProcessorGetStreamColorSpace(ID3D11VideoProcessor* pVideoProcessor, uint StreamIndex, VideoProcessorColorSpace* pColorSpace) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[37]))((ID3D11VideoContext1*)Unsafe.AsPointer(ref this), pVideoProcessor, StreamIndex, pColorSpace); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[37]))((ID3D11VideoContext1*)Unsafe.AsPointer(ref this), pVideoProcessor, StreamIndex, pColorSpace); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(38)] + public void VideoProcessorGetStreamOutputRate(ID3D11VideoProcessor* pVideoProcessor, uint StreamIndex, VideoProcessorOutputRate* pOutputRate, Bool32* pRepeatFrame, Graphics.Dxgi.Common.Rational* pCustomRate) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[38]))((ID3D11VideoContext1*)Unsafe.AsPointer(ref this), pVideoProcessor, StreamIndex, pOutputRate, pRepeatFrame, pCustomRate); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[38]))((ID3D11VideoContext1*)Unsafe.AsPointer(ref this), pVideoProcessor, StreamIndex, pOutputRate, pRepeatFrame, pCustomRate); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(39)] + public void VideoProcessorGetStreamSourceRect(ID3D11VideoProcessor* pVideoProcessor, uint StreamIndex, Bool32* pEnabled, RawRect* pRect) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[39]))((ID3D11VideoContext1*)Unsafe.AsPointer(ref this), pVideoProcessor, StreamIndex, pEnabled, pRect); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[39]))((ID3D11VideoContext1*)Unsafe.AsPointer(ref this), pVideoProcessor, StreamIndex, pEnabled, pRect); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(40)] + public void VideoProcessorGetStreamDestRect(ID3D11VideoProcessor* pVideoProcessor, uint StreamIndex, Bool32* pEnabled, RawRect* pRect) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[40]))((ID3D11VideoContext1*)Unsafe.AsPointer(ref this), pVideoProcessor, StreamIndex, pEnabled, pRect); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[40]))((ID3D11VideoContext1*)Unsafe.AsPointer(ref this), pVideoProcessor, StreamIndex, pEnabled, pRect); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(41)] + public void VideoProcessorGetStreamAlpha(ID3D11VideoProcessor* pVideoProcessor, uint StreamIndex, Bool32* pEnabled, float* pAlpha) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[41]))((ID3D11VideoContext1*)Unsafe.AsPointer(ref this), pVideoProcessor, StreamIndex, pEnabled, pAlpha); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[41]))((ID3D11VideoContext1*)Unsafe.AsPointer(ref this), pVideoProcessor, StreamIndex, pEnabled, pAlpha); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(42)] + public void VideoProcessorGetStreamPalette(ID3D11VideoProcessor* pVideoProcessor, uint StreamIndex, uint Count, uint* pEntries) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[42]))((ID3D11VideoContext1*)Unsafe.AsPointer(ref this), pVideoProcessor, StreamIndex, Count, pEntries); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[42]))((ID3D11VideoContext1*)Unsafe.AsPointer(ref this), pVideoProcessor, StreamIndex, Count, pEntries); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(43)] + public void VideoProcessorGetStreamPixelAspectRatio(ID3D11VideoProcessor* pVideoProcessor, uint StreamIndex, Bool32* pEnabled, Graphics.Dxgi.Common.Rational* pSourceAspectRatio, Graphics.Dxgi.Common.Rational* pDestinationAspectRatio) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[43]))((ID3D11VideoContext1*)Unsafe.AsPointer(ref this), pVideoProcessor, StreamIndex, pEnabled, pSourceAspectRatio, pDestinationAspectRatio); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[43]))((ID3D11VideoContext1*)Unsafe.AsPointer(ref this), pVideoProcessor, StreamIndex, pEnabled, pSourceAspectRatio, pDestinationAspectRatio); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(44)] + public void VideoProcessorGetStreamLumaKey(ID3D11VideoProcessor* pVideoProcessor, uint StreamIndex, Bool32* pEnabled, float* pLower, float* pUpper) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[44]))((ID3D11VideoContext1*)Unsafe.AsPointer(ref this), pVideoProcessor, StreamIndex, pEnabled, pLower, pUpper); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[44]))((ID3D11VideoContext1*)Unsafe.AsPointer(ref this), pVideoProcessor, StreamIndex, pEnabled, pLower, pUpper); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(45)] + public void VideoProcessorGetStreamStereoFormat(ID3D11VideoProcessor* pVideoProcessor, uint StreamIndex, Bool32* pEnable, VideoProcessorStereoFormat* pFormat, Bool32* pLeftViewFrame0, Bool32* pBaseViewFrame0, VideoProcessorStereoFlipMode* pFlipMode, int* MonoOffset) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[45]))((ID3D11VideoContext1*)Unsafe.AsPointer(ref this), pVideoProcessor, StreamIndex, pEnable, pFormat, pLeftViewFrame0, pBaseViewFrame0, pFlipMode, MonoOffset); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[45]))((ID3D11VideoContext1*)Unsafe.AsPointer(ref this), pVideoProcessor, StreamIndex, pEnable, pFormat, pLeftViewFrame0, pBaseViewFrame0, pFlipMode, MonoOffset); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(46)] + public void VideoProcessorGetStreamAutoProcessingMode(ID3D11VideoProcessor* pVideoProcessor, uint StreamIndex, Bool32* pEnabled) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[46]))((ID3D11VideoContext1*)Unsafe.AsPointer(ref this), pVideoProcessor, StreamIndex, pEnabled); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[46]))((ID3D11VideoContext1*)Unsafe.AsPointer(ref this), pVideoProcessor, StreamIndex, pEnabled); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(47)] + public void VideoProcessorGetStreamFilter(ID3D11VideoProcessor* pVideoProcessor, uint StreamIndex, VideoProcessorFilter Filter, Bool32* pEnabled, int* pLevel) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[47]))((ID3D11VideoContext1*)Unsafe.AsPointer(ref this), pVideoProcessor, StreamIndex, Filter, pEnabled, pLevel); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[47]))((ID3D11VideoContext1*)Unsafe.AsPointer(ref this), pVideoProcessor, StreamIndex, Filter, pEnabled, pLevel); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(48)] + public int VideoProcessorGetStreamExtension(ID3D11VideoProcessor* pVideoProcessor, uint StreamIndex, Guid* pExtensionGuid, uint DataSize, void* pData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[48]))((ID3D11VideoContext1*)Unsafe.AsPointer(ref this), pVideoProcessor, StreamIndex, pExtensionGuid, DataSize, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[48]))((ID3D11VideoContext1*)Unsafe.AsPointer(ref this), pVideoProcessor, StreamIndex, pExtensionGuid, DataSize, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(49)] + public HResult VideoProcessorBlt(ID3D11VideoProcessor* pVideoProcessor, ID3D11VideoProcessorOutputView* pView, uint OutputFrame, uint StreamCount, VideoProcessorStream* pStreams) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[49]))((ID3D11VideoContext1*)Unsafe.AsPointer(ref this), pVideoProcessor, pView, OutputFrame, StreamCount, pStreams); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[49]))((ID3D11VideoContext1*)Unsafe.AsPointer(ref this), pVideoProcessor, pView, OutputFrame, StreamCount, pStreams); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(50)] + public HResult NegotiateCryptoSessionKeyExchange(ID3D11CryptoSession* pCryptoSession, uint DataSize, void* pData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[50]))((ID3D11VideoContext1*)Unsafe.AsPointer(ref this), pCryptoSession, DataSize, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[50]))((ID3D11VideoContext1*)Unsafe.AsPointer(ref this), pCryptoSession, DataSize, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(51)] + public void EncryptionBlt(ID3D11CryptoSession* pCryptoSession, ID3D11Texture2D* pSrcSurface, ID3D11Texture2D* pDstSurface, uint IVSize, void* pIV) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[51]))((ID3D11VideoContext1*)Unsafe.AsPointer(ref this), pCryptoSession, pSrcSurface, pDstSurface, IVSize, pIV); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[51]))((ID3D11VideoContext1*)Unsafe.AsPointer(ref this), pCryptoSession, pSrcSurface, pDstSurface, IVSize, pIV); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(52)] + public void DecryptionBlt(ID3D11CryptoSession* pCryptoSession, ID3D11Texture2D* pSrcSurface, ID3D11Texture2D* pDstSurface, EncryptedBlockInfo* pEncryptedBlockInfo, uint ContentKeySize, void* pContentKey, uint IVSize, void* pIV) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[52]))((ID3D11VideoContext1*)Unsafe.AsPointer(ref this), pCryptoSession, pSrcSurface, pDstSurface, pEncryptedBlockInfo, ContentKeySize, pContentKey, IVSize, pIV); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[52]))((ID3D11VideoContext1*)Unsafe.AsPointer(ref this), pCryptoSession, pSrcSurface, pDstSurface, pEncryptedBlockInfo, ContentKeySize, pContentKey, IVSize, pIV); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(53)] + public void StartSessionKeyRefresh(ID3D11CryptoSession* pCryptoSession, uint RandomNumberSize, void* pRandomNumber) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[53]))((ID3D11VideoContext1*)Unsafe.AsPointer(ref this), pCryptoSession, RandomNumberSize, pRandomNumber); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[53]))((ID3D11VideoContext1*)Unsafe.AsPointer(ref this), pCryptoSession, RandomNumberSize, pRandomNumber); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(54)] + public void FinishSessionKeyRefresh(ID3D11CryptoSession* pCryptoSession) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[54]))((ID3D11VideoContext1*)Unsafe.AsPointer(ref this), pCryptoSession); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[54]))((ID3D11VideoContext1*)Unsafe.AsPointer(ref this), pCryptoSession); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(55)] + public HResult GetEncryptionBltKey(ID3D11CryptoSession* pCryptoSession, uint KeySize, void* pReadbackKey) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[55]))((ID3D11VideoContext1*)Unsafe.AsPointer(ref this), pCryptoSession, KeySize, pReadbackKey); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[55]))((ID3D11VideoContext1*)Unsafe.AsPointer(ref this), pCryptoSession, KeySize, pReadbackKey); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(56)] + public HResult NegotiateAuthenticatedChannelKeyExchange(ID3D11AuthenticatedChannel* pChannel, uint DataSize, void* pData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[56]))((ID3D11VideoContext1*)Unsafe.AsPointer(ref this), pChannel, DataSize, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[56]))((ID3D11VideoContext1*)Unsafe.AsPointer(ref this), pChannel, DataSize, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(57)] + public HResult QueryAuthenticatedChannel(ID3D11AuthenticatedChannel* pChannel, uint InputSize, void* pInput, uint OutputSize, void* pOutput) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[57]))((ID3D11VideoContext1*)Unsafe.AsPointer(ref this), pChannel, InputSize, pInput, OutputSize, pOutput); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[57]))((ID3D11VideoContext1*)Unsafe.AsPointer(ref this), pChannel, InputSize, pInput, OutputSize, pOutput); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(58)] + public HResult ConfigureAuthenticatedChannel(ID3D11AuthenticatedChannel* pChannel, uint InputSize, void* pInput, AuthenticatedConfigureOutput* pOutput) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[58]))((ID3D11VideoContext1*)Unsafe.AsPointer(ref this), pChannel, InputSize, pInput, pOutput); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[58]))((ID3D11VideoContext1*)Unsafe.AsPointer(ref this), pChannel, InputSize, pInput, pOutput); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(59)] + public void VideoProcessorSetStreamRotation(ID3D11VideoProcessor* pVideoProcessor, uint StreamIndex, Bool32* Enable, VideoProcessorRotation Rotation) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[59]))((ID3D11VideoContext1*)Unsafe.AsPointer(ref this), pVideoProcessor, StreamIndex, Enable, Rotation); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[59]))((ID3D11VideoContext1*)Unsafe.AsPointer(ref this), pVideoProcessor, StreamIndex, Enable, Rotation); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(60)] + public void VideoProcessorGetStreamRotation(ID3D11VideoProcessor* pVideoProcessor, uint StreamIndex, Bool32* pEnable, VideoProcessorRotation* pRotation) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[60]))((ID3D11VideoContext1*)Unsafe.AsPointer(ref this), pVideoProcessor, StreamIndex, pEnable, pRotation); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[60]))((ID3D11VideoContext1*)Unsafe.AsPointer(ref this), pVideoProcessor, StreamIndex, pEnable, pRotation); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(61)] + public void GetDevice(ID3D11Device* ppDevice) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[61]))((ID3D11VideoContext1*)Unsafe.AsPointer(ref this), ppDevice); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[61]))((ID3D11VideoContext1*)Unsafe.AsPointer(ref this), ppDevice); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(62)] + public HResult GetPrivateData(Guid* guid, uint* pDataSize, void* pData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[62]))((ID3D11VideoContext1*)Unsafe.AsPointer(ref this), guid, pDataSize, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[62]))((ID3D11VideoContext1*)Unsafe.AsPointer(ref this), guid, pDataSize, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(63)] + public HResult SetPrivateData(Guid* guid, uint DataSize, void* pData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[63]))((ID3D11VideoContext1*)Unsafe.AsPointer(ref this), guid, DataSize, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[63]))((ID3D11VideoContext1*)Unsafe.AsPointer(ref this), guid, DataSize, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(64)] + public HResult SetPrivateDataInterface(Guid* guid, IUnknown* pData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[64]))((ID3D11VideoContext1*)Unsafe.AsPointer(ref this), guid, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[64]))((ID3D11VideoContext1*)Unsafe.AsPointer(ref this), guid, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(65)] + public HResult SubmitDecoderBuffers1(ID3D11VideoDecoder* pDecoder, uint NumBuffers, VideoDecoderBufferDescription1* pBufferDesc) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[65]))((ID3D11VideoContext1*)Unsafe.AsPointer(ref this), pDecoder, NumBuffers, pBufferDesc); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[65]))((ID3D11VideoContext1*)Unsafe.AsPointer(ref this), pDecoder, NumBuffers, pBufferDesc); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(66)] + public HResult GetDataForNewHardwareKey(ID3D11CryptoSession* pCryptoSession, uint PrivateInputSize, void* pPrivatInputData, ulong* pPrivateOutputData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[66]))((ID3D11VideoContext1*)Unsafe.AsPointer(ref this), pCryptoSession, PrivateInputSize, pPrivatInputData, pPrivateOutputData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[66]))((ID3D11VideoContext1*)Unsafe.AsPointer(ref this), pCryptoSession, PrivateInputSize, pPrivatInputData, pPrivateOutputData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(67)] + public HResult CheckCryptoSessionStatus(ID3D11CryptoSession* pCryptoSession, CryptoSessionStatus* pStatus) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[67]))((ID3D11VideoContext1*)Unsafe.AsPointer(ref this), pCryptoSession, pStatus); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[67]))((ID3D11VideoContext1*)Unsafe.AsPointer(ref this), pCryptoSession, pStatus); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(68)] + public HResult DecoderEnableDownsampling(ID3D11VideoDecoder* pDecoder, Graphics.Dxgi.Common.ColorSpaceType InputColorSpace, VideoSampleDescription* pOutputDesc, uint ReferenceFrameCount) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[68]))((ID3D11VideoContext1*)Unsafe.AsPointer(ref this), pDecoder, InputColorSpace, pOutputDesc, ReferenceFrameCount); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[68]))((ID3D11VideoContext1*)Unsafe.AsPointer(ref this), pDecoder, InputColorSpace, pOutputDesc, ReferenceFrameCount); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(69)] + public HResult DecoderUpdateDownsampling(ID3D11VideoDecoder* pDecoder, VideoSampleDescription* pOutputDesc) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[69]))((ID3D11VideoContext1*)Unsafe.AsPointer(ref this), pDecoder, pOutputDesc); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[69]))((ID3D11VideoContext1*)Unsafe.AsPointer(ref this), pDecoder, pOutputDesc); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(70)] + public void VideoProcessorSetOutputColorSpace1(ID3D11VideoProcessor* pVideoProcessor, Graphics.Dxgi.Common.ColorSpaceType ColorSpace) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[70]))((ID3D11VideoContext1*)Unsafe.AsPointer(ref this), pVideoProcessor, ColorSpace); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[70]))((ID3D11VideoContext1*)Unsafe.AsPointer(ref this), pVideoProcessor, ColorSpace); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(71)] + public void VideoProcessorSetOutputShaderUsage(ID3D11VideoProcessor* pVideoProcessor, Bool32* ShaderUsage) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[71]))((ID3D11VideoContext1*)Unsafe.AsPointer(ref this), pVideoProcessor, ShaderUsage); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[71]))((ID3D11VideoContext1*)Unsafe.AsPointer(ref this), pVideoProcessor, ShaderUsage); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(72)] + public void VideoProcessorGetOutputColorSpace1(ID3D11VideoProcessor* pVideoProcessor, Graphics.Dxgi.Common.ColorSpaceType* pColorSpace) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[72]))((ID3D11VideoContext1*)Unsafe.AsPointer(ref this), pVideoProcessor, pColorSpace); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[72]))((ID3D11VideoContext1*)Unsafe.AsPointer(ref this), pVideoProcessor, pColorSpace); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(73)] + public void VideoProcessorGetOutputShaderUsage(ID3D11VideoProcessor* pVideoProcessor, Bool32* pShaderUsage) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[73]))((ID3D11VideoContext1*)Unsafe.AsPointer(ref this), pVideoProcessor, pShaderUsage); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[73]))((ID3D11VideoContext1*)Unsafe.AsPointer(ref this), pVideoProcessor, pShaderUsage); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(74)] + public void VideoProcessorSetStreamColorSpace1(ID3D11VideoProcessor* pVideoProcessor, uint StreamIndex, Graphics.Dxgi.Common.ColorSpaceType ColorSpace) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[74]))((ID3D11VideoContext1*)Unsafe.AsPointer(ref this), pVideoProcessor, StreamIndex, ColorSpace); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[74]))((ID3D11VideoContext1*)Unsafe.AsPointer(ref this), pVideoProcessor, StreamIndex, ColorSpace); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(75)] + public void VideoProcessorSetStreamMirror(ID3D11VideoProcessor* pVideoProcessor, uint StreamIndex, Bool32* Enable, Bool32* FlipHorizontal, Bool32* FlipVertical) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[75]))((ID3D11VideoContext1*)Unsafe.AsPointer(ref this), pVideoProcessor, StreamIndex, Enable, FlipHorizontal, FlipVertical); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[75]))((ID3D11VideoContext1*)Unsafe.AsPointer(ref this), pVideoProcessor, StreamIndex, Enable, FlipHorizontal, FlipVertical); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(76)] + public void VideoProcessorGetStreamColorSpace1(ID3D11VideoProcessor* pVideoProcessor, uint StreamIndex, Graphics.Dxgi.Common.ColorSpaceType* pColorSpace) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[76]))((ID3D11VideoContext1*)Unsafe.AsPointer(ref this), pVideoProcessor, StreamIndex, pColorSpace); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[76]))((ID3D11VideoContext1*)Unsafe.AsPointer(ref this), pVideoProcessor, StreamIndex, pColorSpace); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(77)] + public void VideoProcessorGetStreamMirror(ID3D11VideoProcessor* pVideoProcessor, uint StreamIndex, Bool32* pEnable, Bool32* pFlipHorizontal, Bool32* pFlipVertical) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[77]))((ID3D11VideoContext1*)Unsafe.AsPointer(ref this), pVideoProcessor, StreamIndex, pEnable, pFlipHorizontal, pFlipVertical); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[77]))((ID3D11VideoContext1*)Unsafe.AsPointer(ref this), pVideoProcessor, StreamIndex, pEnable, pFlipHorizontal, pFlipVertical); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(78)] + public HResult VideoProcessorGetBehaviorHints(ID3D11VideoProcessor* pVideoProcessor, uint OutputWidth, uint OutputHeight, Graphics.Dxgi.Common.Format OutputFormat, uint StreamCount, VideoProcessorStreamBehaviorHint* pStreams, uint* pBehaviorHints) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[78]))((ID3D11VideoContext1*)Unsafe.AsPointer(ref this), pVideoProcessor, OutputWidth, OutputHeight, OutputFormat, StreamCount, pStreams, pBehaviorHints); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[78]))((ID3D11VideoContext1*)Unsafe.AsPointer(ref this), pVideoProcessor, OutputWidth, OutputHeight, OutputFormat, StreamCount, pStreams, pBehaviorHints); +#endif + } + + public interface Interface : ID3D11VideoContext.Interface + { + } +} + +/// +/// ID3D11VideoDevice1 +[Guid("29da1d51-1321-4454-804b-f5fc9f861f0f")] +[NativeTypeName("struct ID3D11VideoDevice1 : ID3D11VideoDevice")] +[NativeInheritance("ID3D11VideoDevice")] +public unsafe partial struct ID3D11VideoDevice1 : ID3D11VideoDevice1.Interface +{ + public static ref readonly Guid IID_ID3D11VideoDevice1 + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x51, 0x1D, 0xDA, 0x29, + 0x21, 0x13, + 0x54, 0x44, + 0x80, + 0x4B, + 0xF5, + 0xFC, + 0x9F, + 0x86, + 0x1F, + 0x0F + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_ID3D11VideoDevice1)); + + public void** lpVtbl; + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(0)] + public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(1)] + [return: NativeTypeName("ULONG")] + public uint AddRef() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(2)] + [return: NativeTypeName("ULONG")] + public uint Release() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(3)] + public HResult CreateVideoDecoder(VideoDecoderDescription* pVideoDesc, VideoDecoderConfig* pConfig, ID3D11VideoDecoder** ppDecoder) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[3]))((ID3D11VideoDevice1*)Unsafe.AsPointer(ref this), pVideoDesc, pConfig, ppDecoder); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((ID3D11VideoDevice1*)Unsafe.AsPointer(ref this), pVideoDesc, pConfig, ppDecoder); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public HResult CreateVideoProcessor(ID3D11VideoProcessorEnumerator* pEnum, uint RateConversionIndex, ID3D11VideoProcessor** ppVideoProcessor) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[4]))((ID3D11VideoDevice1*)Unsafe.AsPointer(ref this), pEnum, RateConversionIndex, ppVideoProcessor); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((ID3D11VideoDevice1*)Unsafe.AsPointer(ref this), pEnum, RateConversionIndex, ppVideoProcessor); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(5)] + public HResult CreateAuthenticatedChannel(AuthenticatedChannelType ChannelType, ID3D11AuthenticatedChannel** ppAuthenticatedChannel) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[5]))((ID3D11VideoDevice1*)Unsafe.AsPointer(ref this), ChannelType, ppAuthenticatedChannel); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((ID3D11VideoDevice1*)Unsafe.AsPointer(ref this), ChannelType, ppAuthenticatedChannel); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(6)] + public HResult CreateCryptoSession(Guid* pCryptoType, Guid* pDecoderProfile, Guid* pKeyExchangeType, ID3D11CryptoSession** ppCryptoSession) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[6]))((ID3D11VideoDevice1*)Unsafe.AsPointer(ref this), pCryptoType, pDecoderProfile, pKeyExchangeType, ppCryptoSession); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((ID3D11VideoDevice1*)Unsafe.AsPointer(ref this), pCryptoType, pDecoderProfile, pKeyExchangeType, ppCryptoSession); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(7)] + public HResult CreateVideoDecoderOutputView(ID3D11Resource* pResource, VideoDecoderOutputViewDescription* pDesc, ID3D11VideoDecoderOutputView** ppVDOVView) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[7]))((ID3D11VideoDevice1*)Unsafe.AsPointer(ref this), pResource, pDesc, ppVDOVView); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((ID3D11VideoDevice1*)Unsafe.AsPointer(ref this), pResource, pDesc, ppVDOVView); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(8)] + public HResult CreateVideoProcessorInputView(ID3D11Resource* pResource, ID3D11VideoProcessorEnumerator* pEnum, VideoProcessorInputViewDescription* pDesc, ID3D11VideoProcessorInputView** ppVPIView) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[8]))((ID3D11VideoDevice1*)Unsafe.AsPointer(ref this), pResource, pEnum, pDesc, ppVPIView); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[8]))((ID3D11VideoDevice1*)Unsafe.AsPointer(ref this), pResource, pEnum, pDesc, ppVPIView); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(9)] + public HResult CreateVideoProcessorOutputView(ID3D11Resource* pResource, ID3D11VideoProcessorEnumerator* pEnum, VideoProcessorOutputViewDescription* pDesc, ID3D11VideoProcessorOutputView** ppVPOView) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[9]))((ID3D11VideoDevice1*)Unsafe.AsPointer(ref this), pResource, pEnum, pDesc, ppVPOView); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[9]))((ID3D11VideoDevice1*)Unsafe.AsPointer(ref this), pResource, pEnum, pDesc, ppVPOView); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(10)] + public HResult CreateVideoProcessorEnumerator(VideoProcessorContentDescription* pDesc, ID3D11VideoProcessorEnumerator** ppEnum) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[10]))((ID3D11VideoDevice1*)Unsafe.AsPointer(ref this), pDesc, ppEnum); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[10]))((ID3D11VideoDevice1*)Unsafe.AsPointer(ref this), pDesc, ppEnum); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(11)] + public uint GetVideoDecoderProfileCount() + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[11]))((ID3D11VideoDevice1*)Unsafe.AsPointer(ref this)); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[11]))((ID3D11VideoDevice1*)Unsafe.AsPointer(ref this)); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(12)] + public HResult GetVideoDecoderProfile(uint Index, Guid* pDecoderProfile) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[12]))((ID3D11VideoDevice1*)Unsafe.AsPointer(ref this), Index, pDecoderProfile); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[12]))((ID3D11VideoDevice1*)Unsafe.AsPointer(ref this), Index, pDecoderProfile); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(13)] + public HResult CheckVideoDecoderFormat(Guid* pDecoderProfile, Graphics.Dxgi.Common.Format Format, Bool32* pSupported) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[13]))((ID3D11VideoDevice1*)Unsafe.AsPointer(ref this), pDecoderProfile, Format, pSupported); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[13]))((ID3D11VideoDevice1*)Unsafe.AsPointer(ref this), pDecoderProfile, Format, pSupported); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(14)] + public HResult GetVideoDecoderConfigCount(VideoDecoderDescription* pDesc, uint* pCount) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[14]))((ID3D11VideoDevice1*)Unsafe.AsPointer(ref this), pDesc, pCount); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[14]))((ID3D11VideoDevice1*)Unsafe.AsPointer(ref this), pDesc, pCount); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(15)] + public HResult GetVideoDecoderConfig(VideoDecoderDescription* pDesc, uint Index, VideoDecoderConfig* pConfig) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[15]))((ID3D11VideoDevice1*)Unsafe.AsPointer(ref this), pDesc, Index, pConfig); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[15]))((ID3D11VideoDevice1*)Unsafe.AsPointer(ref this), pDesc, Index, pConfig); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(16)] + public HResult GetContentProtectionCaps(Guid* pCryptoType, Guid* pDecoderProfile, VideoContentProtectionCaps* pCaps) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[16]))((ID3D11VideoDevice1*)Unsafe.AsPointer(ref this), pCryptoType, pDecoderProfile, pCaps); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[16]))((ID3D11VideoDevice1*)Unsafe.AsPointer(ref this), pCryptoType, pDecoderProfile, pCaps); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(17)] + public HResult CheckCryptoKeyExchange(Guid* pCryptoType, Guid* pDecoderProfile, uint Index, Guid* pKeyExchangeType) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[17]))((ID3D11VideoDevice1*)Unsafe.AsPointer(ref this), pCryptoType, pDecoderProfile, Index, pKeyExchangeType); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[17]))((ID3D11VideoDevice1*)Unsafe.AsPointer(ref this), pCryptoType, pDecoderProfile, Index, pKeyExchangeType); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(18)] + public HResult SetPrivateData(Guid* guid, uint DataSize, void* pData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[18]))((ID3D11VideoDevice1*)Unsafe.AsPointer(ref this), guid, DataSize, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[18]))((ID3D11VideoDevice1*)Unsafe.AsPointer(ref this), guid, DataSize, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(19)] + public HResult SetPrivateDataInterface(Guid* guid, IUnknown* pData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[19]))((ID3D11VideoDevice1*)Unsafe.AsPointer(ref this), guid, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[19]))((ID3D11VideoDevice1*)Unsafe.AsPointer(ref this), guid, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(20)] + public HResult GetCryptoSessionPrivateDataSize(Guid* pCryptoType, Guid* pDecoderProfile, Guid* pKeyExchangeType, uint* pPrivateInputSize, uint* pPrivateOutputSize) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[20]))((ID3D11VideoDevice1*)Unsafe.AsPointer(ref this), pCryptoType, pDecoderProfile, pKeyExchangeType, pPrivateInputSize, pPrivateOutputSize); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[20]))((ID3D11VideoDevice1*)Unsafe.AsPointer(ref this), pCryptoType, pDecoderProfile, pKeyExchangeType, pPrivateInputSize, pPrivateOutputSize); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(21)] + public HResult GetVideoDecoderCaps(Guid* pDecoderProfile, uint SampleWidth, uint SampleHeight, Graphics.Dxgi.Common.Rational* pFrameRate, uint BitRate, Guid* pCryptoType, uint* pDecoderCaps) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[21]))((ID3D11VideoDevice1*)Unsafe.AsPointer(ref this), pDecoderProfile, SampleWidth, SampleHeight, pFrameRate, BitRate, pCryptoType, pDecoderCaps); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[21]))((ID3D11VideoDevice1*)Unsafe.AsPointer(ref this), pDecoderProfile, SampleWidth, SampleHeight, pFrameRate, BitRate, pCryptoType, pDecoderCaps); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(22)] + public HResult CheckVideoDecoderDownsampling(VideoDecoderDescription* pInputDesc, Graphics.Dxgi.Common.ColorSpaceType InputColorSpace, VideoDecoderConfig* pInputConfig, Graphics.Dxgi.Common.Rational* pFrameRate, VideoSampleDescription* pOutputDesc, Bool32* pSupported, Bool32* pRealTimeHint) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[22]))((ID3D11VideoDevice1*)Unsafe.AsPointer(ref this), pInputDesc, InputColorSpace, pInputConfig, pFrameRate, pOutputDesc, pSupported, pRealTimeHint); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[22]))((ID3D11VideoDevice1*)Unsafe.AsPointer(ref this), pInputDesc, InputColorSpace, pInputConfig, pFrameRate, pOutputDesc, pSupported, pRealTimeHint); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(23)] + public HResult RecommendVideoDecoderDownsampleParameters(VideoDecoderDescription* pInputDesc, Graphics.Dxgi.Common.ColorSpaceType InputColorSpace, VideoDecoderConfig* pInputConfig, Graphics.Dxgi.Common.Rational* pFrameRate, VideoSampleDescription* pRecommendedOutputDesc) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[23]))((ID3D11VideoDevice1*)Unsafe.AsPointer(ref this), pInputDesc, InputColorSpace, pInputConfig, pFrameRate, pRecommendedOutputDesc); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[23]))((ID3D11VideoDevice1*)Unsafe.AsPointer(ref this), pInputDesc, InputColorSpace, pInputConfig, pFrameRate, pRecommendedOutputDesc); +#endif + } + + public interface Interface : ID3D11VideoDevice.Interface + { + } +} + +/// +/// ID3D11VideoProcessorEnumerator1 +[Guid("465217f2-5568-43cf-b5b9-f61d54531ca1")] +[NativeTypeName("struct ID3D11VideoProcessorEnumerator1 : ID3D11VideoProcessorEnumerator")] +[NativeInheritance("ID3D11VideoProcessorEnumerator")] +public unsafe partial struct ID3D11VideoProcessorEnumerator1 : ID3D11VideoProcessorEnumerator1.Interface +{ + public static ref readonly Guid IID_ID3D11VideoProcessorEnumerator1 + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0xF2, 0x17, 0x52, 0x46, + 0x68, 0x55, + 0xCF, 0x43, + 0xB5, + 0xB9, + 0xF6, + 0x1D, + 0x54, + 0x53, + 0x1C, + 0xA1 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_ID3D11VideoProcessorEnumerator1)); + + public void** lpVtbl; + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(0)] + public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(1)] + [return: NativeTypeName("ULONG")] + public uint AddRef() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(2)] + [return: NativeTypeName("ULONG")] + public uint Release() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(3)] + public HResult GetVideoProcessorContentDesc(VideoProcessorContentDescription* pContentDesc) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[3]))((ID3D11VideoProcessorEnumerator1*)Unsafe.AsPointer(ref this), pContentDesc); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((ID3D11VideoProcessorEnumerator1*)Unsafe.AsPointer(ref this), pContentDesc); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public HResult CheckVideoProcessorFormat(Graphics.Dxgi.Common.Format Format, uint* pFlags) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[4]))((ID3D11VideoProcessorEnumerator1*)Unsafe.AsPointer(ref this), Format, pFlags); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((ID3D11VideoProcessorEnumerator1*)Unsafe.AsPointer(ref this), Format, pFlags); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(5)] + public HResult GetVideoProcessorCaps(VideoProcessorCaps* pCaps) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[5]))((ID3D11VideoProcessorEnumerator1*)Unsafe.AsPointer(ref this), pCaps); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((ID3D11VideoProcessorEnumerator1*)Unsafe.AsPointer(ref this), pCaps); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(6)] + public HResult GetVideoProcessorRateConversionCaps(uint TypeIndex, VideoProcessorRateConversionCaps* pCaps) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[6]))((ID3D11VideoProcessorEnumerator1*)Unsafe.AsPointer(ref this), TypeIndex, pCaps); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((ID3D11VideoProcessorEnumerator1*)Unsafe.AsPointer(ref this), TypeIndex, pCaps); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(7)] + public HResult GetVideoProcessorCustomRate(uint TypeIndex, uint CustomRateIndex, VideoProcessorCustomRate* pRate) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[7]))((ID3D11VideoProcessorEnumerator1*)Unsafe.AsPointer(ref this), TypeIndex, CustomRateIndex, pRate); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((ID3D11VideoProcessorEnumerator1*)Unsafe.AsPointer(ref this), TypeIndex, CustomRateIndex, pRate); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(8)] + public HResult GetVideoProcessorFilterRange(VideoProcessorFilter Filter, VideoProcessorFilterRange* pRange) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[8]))((ID3D11VideoProcessorEnumerator1*)Unsafe.AsPointer(ref this), Filter, pRange); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[8]))((ID3D11VideoProcessorEnumerator1*)Unsafe.AsPointer(ref this), Filter, pRange); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(9)] + public void GetDevice(ID3D11Device* ppDevice) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[9]))((ID3D11VideoProcessorEnumerator1*)Unsafe.AsPointer(ref this), ppDevice); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[9]))((ID3D11VideoProcessorEnumerator1*)Unsafe.AsPointer(ref this), ppDevice); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(10)] + public HResult GetPrivateData(Guid* guid, uint* pDataSize, void* pData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[10]))((ID3D11VideoProcessorEnumerator1*)Unsafe.AsPointer(ref this), guid, pDataSize, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[10]))((ID3D11VideoProcessorEnumerator1*)Unsafe.AsPointer(ref this), guid, pDataSize, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(11)] + public HResult SetPrivateData(Guid* guid, uint DataSize, void* pData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[11]))((ID3D11VideoProcessorEnumerator1*)Unsafe.AsPointer(ref this), guid, DataSize, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[11]))((ID3D11VideoProcessorEnumerator1*)Unsafe.AsPointer(ref this), guid, DataSize, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(12)] + public HResult SetPrivateDataInterface(Guid* guid, IUnknown* pData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[12]))((ID3D11VideoProcessorEnumerator1*)Unsafe.AsPointer(ref this), guid, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[12]))((ID3D11VideoProcessorEnumerator1*)Unsafe.AsPointer(ref this), guid, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(13)] + public HResult CheckVideoProcessorFormatConversion(Graphics.Dxgi.Common.Format InputFormat, Graphics.Dxgi.Common.ColorSpaceType InputColorSpace, Graphics.Dxgi.Common.Format OutputFormat, Graphics.Dxgi.Common.ColorSpaceType OutputColorSpace, Bool32* pSupported) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[13]))((ID3D11VideoProcessorEnumerator1*)Unsafe.AsPointer(ref this), InputFormat, InputColorSpace, OutputFormat, OutputColorSpace, pSupported); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[13]))((ID3D11VideoProcessorEnumerator1*)Unsafe.AsPointer(ref this), InputFormat, InputColorSpace, OutputFormat, OutputColorSpace, pSupported); +#endif + } + + public interface Interface : ID3D11VideoProcessorEnumerator.Interface + { + } +} + +/// +/// ID3D11Device1 +[Guid("a04bfb29-08ef-43d6-a49c-a9bdbdcbe686")] +[NativeTypeName("struct ID3D11Device1 : ID3D11Device")] +[NativeInheritance("ID3D11Device")] +public unsafe partial struct ID3D11Device1 : ID3D11Device1.Interface +{ + public static ref readonly Guid IID_ID3D11Device1 + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x29, 0xFB, 0x4B, 0xA0, + 0xEF, 0x08, + 0xD6, 0x43, + 0xA4, + 0x9C, + 0xA9, + 0xBD, + 0xBD, + 0xCB, + 0xE6, + 0x86 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_ID3D11Device1)); + + public void** lpVtbl; + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(0)] + public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(1)] + [return: NativeTypeName("ULONG")] + public uint AddRef() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(2)] + [return: NativeTypeName("ULONG")] + public uint Release() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(3)] + public HResult CreateBuffer(BufferDescription* pDesc, SubresourceData* pInitialData, ID3D11Buffer** ppBuffer) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[3]))((ID3D11Device1*)Unsafe.AsPointer(ref this), pDesc, pInitialData, ppBuffer); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((ID3D11Device1*)Unsafe.AsPointer(ref this), pDesc, pInitialData, ppBuffer); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public HResult CreateTexture1D(Texture1DDescription* pDesc, SubresourceData* pInitialData, ID3D11Texture1D** ppTexture1D) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[4]))((ID3D11Device1*)Unsafe.AsPointer(ref this), pDesc, pInitialData, ppTexture1D); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((ID3D11Device1*)Unsafe.AsPointer(ref this), pDesc, pInitialData, ppTexture1D); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(5)] + public HResult CreateTexture2D(Texture2DDescription* pDesc, SubresourceData* pInitialData, ID3D11Texture2D** ppTexture2D) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[5]))((ID3D11Device1*)Unsafe.AsPointer(ref this), pDesc, pInitialData, ppTexture2D); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((ID3D11Device1*)Unsafe.AsPointer(ref this), pDesc, pInitialData, ppTexture2D); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(6)] + public HResult CreateTexture3D(Texture3DDescription* pDesc, SubresourceData* pInitialData, ID3D11Texture3D** ppTexture3D) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[6]))((ID3D11Device1*)Unsafe.AsPointer(ref this), pDesc, pInitialData, ppTexture3D); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((ID3D11Device1*)Unsafe.AsPointer(ref this), pDesc, pInitialData, ppTexture3D); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(7)] + public HResult CreateShaderResourceView(ID3D11Resource* pResource, ShaderResourceViewDescription* pDesc, ID3D11ShaderResourceView** ppSRView) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[7]))((ID3D11Device1*)Unsafe.AsPointer(ref this), pResource, pDesc, ppSRView); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((ID3D11Device1*)Unsafe.AsPointer(ref this), pResource, pDesc, ppSRView); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(8)] + public HResult CreateUnorderedAccessView(ID3D11Resource* pResource, UnorderedAccessViewDescription* pDesc, ID3D11UnorderedAccessView** ppUAView) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[8]))((ID3D11Device1*)Unsafe.AsPointer(ref this), pResource, pDesc, ppUAView); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[8]))((ID3D11Device1*)Unsafe.AsPointer(ref this), pResource, pDesc, ppUAView); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(9)] + public HResult CreateRenderTargetView(ID3D11Resource* pResource, RenderTargetViewDescription* pDesc, ID3D11RenderTargetView** ppRTView) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[9]))((ID3D11Device1*)Unsafe.AsPointer(ref this), pResource, pDesc, ppRTView); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[9]))((ID3D11Device1*)Unsafe.AsPointer(ref this), pResource, pDesc, ppRTView); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(10)] + public HResult CreateDepthStencilView(ID3D11Resource* pResource, DepthStencilViewDescription* pDesc, ID3D11DepthStencilView** ppDepthStencilView) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[10]))((ID3D11Device1*)Unsafe.AsPointer(ref this), pResource, pDesc, ppDepthStencilView); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[10]))((ID3D11Device1*)Unsafe.AsPointer(ref this), pResource, pDesc, ppDepthStencilView); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(11)] + public HResult CreateInputLayout(InputElementDescription* pInputElementDescs, uint NumElements, void* pShaderBytecodeWithInputSignature, nuint BytecodeLength, ID3D11InputLayout** ppInputLayout) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[11]))((ID3D11Device1*)Unsafe.AsPointer(ref this), pInputElementDescs, NumElements, pShaderBytecodeWithInputSignature, BytecodeLength, ppInputLayout); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[11]))((ID3D11Device1*)Unsafe.AsPointer(ref this), pInputElementDescs, NumElements, pShaderBytecodeWithInputSignature, BytecodeLength, ppInputLayout); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(12)] + public HResult CreateVertexShader(void* pShaderBytecode, nuint BytecodeLength, ID3D11ClassLinkage* pClassLinkage, ID3D11VertexShader** ppVertexShader) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[12]))((ID3D11Device1*)Unsafe.AsPointer(ref this), pShaderBytecode, BytecodeLength, pClassLinkage, ppVertexShader); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[12]))((ID3D11Device1*)Unsafe.AsPointer(ref this), pShaderBytecode, BytecodeLength, pClassLinkage, ppVertexShader); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(13)] + public HResult CreateGeometryShader(void* pShaderBytecode, nuint BytecodeLength, ID3D11ClassLinkage* pClassLinkage, ID3D11GeometryShader** ppGeometryShader) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[13]))((ID3D11Device1*)Unsafe.AsPointer(ref this), pShaderBytecode, BytecodeLength, pClassLinkage, ppGeometryShader); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[13]))((ID3D11Device1*)Unsafe.AsPointer(ref this), pShaderBytecode, BytecodeLength, pClassLinkage, ppGeometryShader); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(14)] + public HResult CreateGeometryShaderWithStreamOutput(void* pShaderBytecode, nuint BytecodeLength, SoDeclarationEntry* pSODeclaration, uint NumEntries, uint* pBufferStrides, uint NumStrides, uint RasterizedStream, ID3D11ClassLinkage* pClassLinkage, ID3D11GeometryShader** ppGeometryShader) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[14]))((ID3D11Device1*)Unsafe.AsPointer(ref this), pShaderBytecode, BytecodeLength, pSODeclaration, NumEntries, pBufferStrides, NumStrides, RasterizedStream, pClassLinkage, ppGeometryShader); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[14]))((ID3D11Device1*)Unsafe.AsPointer(ref this), pShaderBytecode, BytecodeLength, pSODeclaration, NumEntries, pBufferStrides, NumStrides, RasterizedStream, pClassLinkage, ppGeometryShader); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(15)] + public HResult CreatePixelShader(void* pShaderBytecode, nuint BytecodeLength, ID3D11ClassLinkage* pClassLinkage, ID3D11PixelShader** ppPixelShader) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[15]))((ID3D11Device1*)Unsafe.AsPointer(ref this), pShaderBytecode, BytecodeLength, pClassLinkage, ppPixelShader); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[15]))((ID3D11Device1*)Unsafe.AsPointer(ref this), pShaderBytecode, BytecodeLength, pClassLinkage, ppPixelShader); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(16)] + public HResult CreateHullShader(void* pShaderBytecode, nuint BytecodeLength, ID3D11ClassLinkage* pClassLinkage, ID3D11HullShader** ppHullShader) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[16]))((ID3D11Device1*)Unsafe.AsPointer(ref this), pShaderBytecode, BytecodeLength, pClassLinkage, ppHullShader); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[16]))((ID3D11Device1*)Unsafe.AsPointer(ref this), pShaderBytecode, BytecodeLength, pClassLinkage, ppHullShader); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(17)] + public HResult CreateDomainShader(void* pShaderBytecode, nuint BytecodeLength, ID3D11ClassLinkage* pClassLinkage, ID3D11DomainShader** ppDomainShader) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[17]))((ID3D11Device1*)Unsafe.AsPointer(ref this), pShaderBytecode, BytecodeLength, pClassLinkage, ppDomainShader); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[17]))((ID3D11Device1*)Unsafe.AsPointer(ref this), pShaderBytecode, BytecodeLength, pClassLinkage, ppDomainShader); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(18)] + public HResult CreateComputeShader(void* pShaderBytecode, nuint BytecodeLength, ID3D11ClassLinkage* pClassLinkage, ID3D11ComputeShader** ppComputeShader) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[18]))((ID3D11Device1*)Unsafe.AsPointer(ref this), pShaderBytecode, BytecodeLength, pClassLinkage, ppComputeShader); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[18]))((ID3D11Device1*)Unsafe.AsPointer(ref this), pShaderBytecode, BytecodeLength, pClassLinkage, ppComputeShader); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(19)] + public HResult CreateClassLinkage(ID3D11ClassLinkage** ppLinkage) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[19]))((ID3D11Device1*)Unsafe.AsPointer(ref this), ppLinkage); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[19]))((ID3D11Device1*)Unsafe.AsPointer(ref this), ppLinkage); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(20)] + public HResult CreateBlendState(BlendDescription* pBlendStateDesc, ID3D11BlendState** ppBlendState) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[20]))((ID3D11Device1*)Unsafe.AsPointer(ref this), pBlendStateDesc, ppBlendState); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[20]))((ID3D11Device1*)Unsafe.AsPointer(ref this), pBlendStateDesc, ppBlendState); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(21)] + public HResult CreateDepthStencilState(DepthStencilDescription* pDepthStencilDesc, ID3D11DepthStencilState** ppDepthStencilState) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[21]))((ID3D11Device1*)Unsafe.AsPointer(ref this), pDepthStencilDesc, ppDepthStencilState); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[21]))((ID3D11Device1*)Unsafe.AsPointer(ref this), pDepthStencilDesc, ppDepthStencilState); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(22)] + public HResult CreateRasterizerState(RasterizerDescription* pRasterizerDesc, ID3D11RasterizerState** ppRasterizerState) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[22]))((ID3D11Device1*)Unsafe.AsPointer(ref this), pRasterizerDesc, ppRasterizerState); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[22]))((ID3D11Device1*)Unsafe.AsPointer(ref this), pRasterizerDesc, ppRasterizerState); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(23)] + public HResult CreateSamplerState(SamplerDescription* pSamplerDesc, ID3D11SamplerState** ppSamplerState) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[23]))((ID3D11Device1*)Unsafe.AsPointer(ref this), pSamplerDesc, ppSamplerState); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[23]))((ID3D11Device1*)Unsafe.AsPointer(ref this), pSamplerDesc, ppSamplerState); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(24)] + public HResult CreateQuery(QueryDescription* pQueryDesc, ID3D11Query** ppQuery) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[24]))((ID3D11Device1*)Unsafe.AsPointer(ref this), pQueryDesc, ppQuery); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[24]))((ID3D11Device1*)Unsafe.AsPointer(ref this), pQueryDesc, ppQuery); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(25)] + public HResult CreatePredicate(QueryDescription* pPredicateDesc, ID3D11Predicate** ppPredicate) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[25]))((ID3D11Device1*)Unsafe.AsPointer(ref this), pPredicateDesc, ppPredicate); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[25]))((ID3D11Device1*)Unsafe.AsPointer(ref this), pPredicateDesc, ppPredicate); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(26)] + public HResult CreateCounter(CounterDescription* pCounterDesc, ID3D11Counter** ppCounter) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[26]))((ID3D11Device1*)Unsafe.AsPointer(ref this), pCounterDesc, ppCounter); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[26]))((ID3D11Device1*)Unsafe.AsPointer(ref this), pCounterDesc, ppCounter); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(27)] + public HResult CreateDeferredContext(uint ContextFlags, ID3D11DeviceContext** ppDeferredContext) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[27]))((ID3D11Device1*)Unsafe.AsPointer(ref this), ContextFlags, ppDeferredContext); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[27]))((ID3D11Device1*)Unsafe.AsPointer(ref this), ContextFlags, ppDeferredContext); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(28)] + public HResult OpenSharedResource(IntPtr* hResource, Guid* ReturnedInterface, void** ppResource) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[28]))((ID3D11Device1*)Unsafe.AsPointer(ref this), hResource, ReturnedInterface, ppResource); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[28]))((ID3D11Device1*)Unsafe.AsPointer(ref this), hResource, ReturnedInterface, ppResource); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(29)] + public HResult CheckFormatSupport(Graphics.Dxgi.Common.Format Format, uint* pFormatSupport) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[29]))((ID3D11Device1*)Unsafe.AsPointer(ref this), Format, pFormatSupport); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[29]))((ID3D11Device1*)Unsafe.AsPointer(ref this), Format, pFormatSupport); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(30)] + public HResult CheckMultisampleQualityLevels(Graphics.Dxgi.Common.Format Format, uint SampleCount, uint* pNumQualityLevels) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[30]))((ID3D11Device1*)Unsafe.AsPointer(ref this), Format, SampleCount, pNumQualityLevels); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[30]))((ID3D11Device1*)Unsafe.AsPointer(ref this), Format, SampleCount, pNumQualityLevels); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(31)] + public void CheckCounterInfo(CounterInfo* pCounterInfo) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[31]))((ID3D11Device1*)Unsafe.AsPointer(ref this), pCounterInfo); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[31]))((ID3D11Device1*)Unsafe.AsPointer(ref this), pCounterInfo); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(32)] + public HResult CheckCounter(CounterDescription* pDesc, CounterType* pType, uint* pActiveCounters, byte* szName, uint* pNameLength, byte* szUnits, uint* pUnitsLength, byte* szDescription, uint* pDescriptionLength) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[32]))((ID3D11Device1*)Unsafe.AsPointer(ref this), pDesc, pType, pActiveCounters, szName, pNameLength, szUnits, pUnitsLength, szDescription, pDescriptionLength); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[32]))((ID3D11Device1*)Unsafe.AsPointer(ref this), pDesc, pType, pActiveCounters, szName, pNameLength, szUnits, pUnitsLength, szDescription, pDescriptionLength); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(33)] + public HResult CheckFeatureSupport(Feature Feature, void* pFeatureSupportData, uint FeatureSupportDataSize) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[33]))((ID3D11Device1*)Unsafe.AsPointer(ref this), Feature, pFeatureSupportData, FeatureSupportDataSize); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[33]))((ID3D11Device1*)Unsafe.AsPointer(ref this), Feature, pFeatureSupportData, FeatureSupportDataSize); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(34)] + public HResult GetPrivateData(Guid* guid, uint* pDataSize, void* pData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[34]))((ID3D11Device1*)Unsafe.AsPointer(ref this), guid, pDataSize, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[34]))((ID3D11Device1*)Unsafe.AsPointer(ref this), guid, pDataSize, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(35)] + public HResult SetPrivateData(Guid* guid, uint DataSize, void* pData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[35]))((ID3D11Device1*)Unsafe.AsPointer(ref this), guid, DataSize, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[35]))((ID3D11Device1*)Unsafe.AsPointer(ref this), guid, DataSize, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(36)] + public HResult SetPrivateDataInterface(Guid* guid, IUnknown* pData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[36]))((ID3D11Device1*)Unsafe.AsPointer(ref this), guid, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[36]))((ID3D11Device1*)Unsafe.AsPointer(ref this), guid, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(37)] + public Graphics.Direct3D.FeatureLevel GetFeatureLevel() + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[37]))((ID3D11Device1*)Unsafe.AsPointer(ref this)); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[37]))((ID3D11Device1*)Unsafe.AsPointer(ref this)); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(38)] + public uint GetCreationFlags() + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[38]))((ID3D11Device1*)Unsafe.AsPointer(ref this)); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[38]))((ID3D11Device1*)Unsafe.AsPointer(ref this)); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(39)] + public HResult GetDeviceRemovedReason() + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[39]))((ID3D11Device1*)Unsafe.AsPointer(ref this)); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[39]))((ID3D11Device1*)Unsafe.AsPointer(ref this)); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(40)] + public void GetImmediateContext(ID3D11DeviceContext* ppImmediateContext) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[40]))((ID3D11Device1*)Unsafe.AsPointer(ref this), ppImmediateContext); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[40]))((ID3D11Device1*)Unsafe.AsPointer(ref this), ppImmediateContext); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(41)] + public HResult SetExceptionMode(uint RaiseFlags) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[41]))((ID3D11Device1*)Unsafe.AsPointer(ref this), RaiseFlags); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[41]))((ID3D11Device1*)Unsafe.AsPointer(ref this), RaiseFlags); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(42)] + public uint GetExceptionMode() + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[42]))((ID3D11Device1*)Unsafe.AsPointer(ref this)); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[42]))((ID3D11Device1*)Unsafe.AsPointer(ref this)); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(43)] + public void GetImmediateContext1(ID3D11DeviceContext1* ppImmediateContext) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[43]))((ID3D11Device1*)Unsafe.AsPointer(ref this), ppImmediateContext); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[43]))((ID3D11Device1*)Unsafe.AsPointer(ref this), ppImmediateContext); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(44)] + public HResult CreateDeferredContext1(uint ContextFlags, ID3D11DeviceContext1** ppDeferredContext) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[44]))((ID3D11Device1*)Unsafe.AsPointer(ref this), ContextFlags, ppDeferredContext); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[44]))((ID3D11Device1*)Unsafe.AsPointer(ref this), ContextFlags, ppDeferredContext); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(45)] + public HResult CreateBlendState1(BlendDescription1* pBlendStateDesc, ID3D11BlendState1** ppBlendState) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[45]))((ID3D11Device1*)Unsafe.AsPointer(ref this), pBlendStateDesc, ppBlendState); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[45]))((ID3D11Device1*)Unsafe.AsPointer(ref this), pBlendStateDesc, ppBlendState); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(46)] + public HResult CreateRasterizerState1(RasterizerDescription1* pRasterizerDesc, ID3D11RasterizerState1** ppRasterizerState) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[46]))((ID3D11Device1*)Unsafe.AsPointer(ref this), pRasterizerDesc, ppRasterizerState); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[46]))((ID3D11Device1*)Unsafe.AsPointer(ref this), pRasterizerDesc, ppRasterizerState); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(47)] + public HResult CreateDeviceContextState(uint Flags, Graphics.Direct3D.FeatureLevel* pFeatureLevels, uint FeatureLevels, uint SDKVersion, Guid* EmulatedInterface, Graphics.Direct3D.FeatureLevel* pChosenFeatureLevel, ID3DDeviceContextState* ppContextState) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[47]))((ID3D11Device1*)Unsafe.AsPointer(ref this), Flags, pFeatureLevels, FeatureLevels, SDKVersion, EmulatedInterface, pChosenFeatureLevel, ppContextState); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[47]))((ID3D11Device1*)Unsafe.AsPointer(ref this), Flags, pFeatureLevels, FeatureLevels, SDKVersion, EmulatedInterface, pChosenFeatureLevel, ppContextState); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(48)] + public HResult OpenSharedResource1(IntPtr* hResource, Guid* returnedInterface, void** ppResource) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[48]))((ID3D11Device1*)Unsafe.AsPointer(ref this), hResource, returnedInterface, ppResource); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[48]))((ID3D11Device1*)Unsafe.AsPointer(ref this), hResource, returnedInterface, ppResource); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(49)] + public HResult OpenSharedResourceByName(char** lpName, uint dwDesiredAccess, Guid* returnedInterface, void** ppResource) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[49]))((ID3D11Device1*)Unsafe.AsPointer(ref this), lpName, dwDesiredAccess, returnedInterface, ppResource); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[49]))((ID3D11Device1*)Unsafe.AsPointer(ref this), lpName, dwDesiredAccess, returnedInterface, ppResource); +#endif + } + + public interface Interface : ID3D11Device.Interface + { + } +} + +/// +/// ID3DUserDefinedAnnotation +[Guid("b2daad8b-03d4-4dbf-95eb-32ab4b63d0ab")] +[NativeTypeName("struct ID3DUserDefinedAnnotation : IUnknown")] +[NativeInheritance("IUnknown")] +public unsafe partial struct ID3DUserDefinedAnnotation : ID3DUserDefinedAnnotation.Interface +{ + public static ref readonly Guid IID_ID3DUserDefinedAnnotation + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x8B, 0xAD, 0xDA, 0xB2, + 0xD4, 0x03, + 0xBF, 0x4D, + 0x95, + 0xEB, + 0x32, + 0xAB, + 0x4B, + 0x63, + 0xD0, + 0xAB + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_ID3DUserDefinedAnnotation)); + + public void** lpVtbl; + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(0)] + public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(1)] + [return: NativeTypeName("ULONG")] + public uint AddRef() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(2)] + [return: NativeTypeName("ULONG")] + public uint Release() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(3)] + public int BeginEvent(char** Name) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[3]))((ID3DUserDefinedAnnotation*)Unsafe.AsPointer(ref this), Name); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((ID3DUserDefinedAnnotation*)Unsafe.AsPointer(ref this), Name); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public int EndEvent() + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[4]))((ID3DUserDefinedAnnotation*)Unsafe.AsPointer(ref this)); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((ID3DUserDefinedAnnotation*)Unsafe.AsPointer(ref this)); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(5)] + public void SetMarker(char** Name) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[5]))((ID3DUserDefinedAnnotation*)Unsafe.AsPointer(ref this), Name); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((ID3DUserDefinedAnnotation*)Unsafe.AsPointer(ref this), Name); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(6)] + public Bool32 GetStatus() + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[6]))((ID3DUserDefinedAnnotation*)Unsafe.AsPointer(ref this)); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((ID3DUserDefinedAnnotation*)Unsafe.AsPointer(ref this)); +#endif + } + + public interface Interface : IUnknown.Interface + { + } +} + +/// +/// ID3D11DeviceContext2 +[Guid("420d5b32-b90c-4da4-bef0-359f6a24a83a")] +[NativeTypeName("struct ID3D11DeviceContext2 : ID3D11DeviceContext1")] +[NativeInheritance("ID3D11DeviceContext1")] +public unsafe partial struct ID3D11DeviceContext2 : ID3D11DeviceContext2.Interface +{ + public static ref readonly Guid IID_ID3D11DeviceContext2 + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x32, 0x5B, 0x0D, 0x42, + 0x0C, 0xB9, + 0xA4, 0x4D, + 0xBE, + 0xF0, + 0x35, + 0x9F, + 0x6A, + 0x24, + 0xA8, + 0x3A + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_ID3D11DeviceContext2)); + + public void** lpVtbl; + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(0)] + public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(1)] + [return: NativeTypeName("ULONG")] + public uint AddRef() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(2)] + [return: NativeTypeName("ULONG")] + public uint Release() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(3)] + public void CopySubresourceRegion1(ID3D11Resource* pDstResource, uint DstSubresource, uint DstX, uint DstY, uint DstZ, ID3D11Resource* pSrcResource, uint SrcSubresource, Box* pSrcBox, uint CopyFlags) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[3]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this), pDstResource, DstSubresource, DstX, DstY, DstZ, pSrcResource, SrcSubresource, pSrcBox, CopyFlags); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this), pDstResource, DstSubresource, DstX, DstY, DstZ, pSrcResource, SrcSubresource, pSrcBox, CopyFlags); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public void UpdateSubresource1(ID3D11Resource* pDstResource, uint DstSubresource, Box* pDstBox, void* pSrcData, uint SrcRowPitch, uint SrcDepthPitch, uint CopyFlags) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[4]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this), pDstResource, DstSubresource, pDstBox, pSrcData, SrcRowPitch, SrcDepthPitch, CopyFlags); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this), pDstResource, DstSubresource, pDstBox, pSrcData, SrcRowPitch, SrcDepthPitch, CopyFlags); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(5)] + public void DiscardResource(ID3D11Resource* pResource) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[5]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this), pResource); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this), pResource); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(6)] + public void DiscardView(ID3D11View* pResourceView) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[6]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this), pResourceView); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this), pResourceView); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(7)] + public void VSSetConstantBuffers1(uint StartSlot, uint NumBuffers, ID3D11Buffer* ppConstantBuffers, uint* pFirstConstant, uint* pNumConstants) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[7]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this), StartSlot, NumBuffers, ppConstantBuffers, pFirstConstant, pNumConstants); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this), StartSlot, NumBuffers, ppConstantBuffers, pFirstConstant, pNumConstants); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(8)] + public void HSSetConstantBuffers1(uint StartSlot, uint NumBuffers, ID3D11Buffer* ppConstantBuffers, uint* pFirstConstant, uint* pNumConstants) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[8]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this), StartSlot, NumBuffers, ppConstantBuffers, pFirstConstant, pNumConstants); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[8]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this), StartSlot, NumBuffers, ppConstantBuffers, pFirstConstant, pNumConstants); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(9)] + public void DSSetConstantBuffers1(uint StartSlot, uint NumBuffers, ID3D11Buffer* ppConstantBuffers, uint* pFirstConstant, uint* pNumConstants) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[9]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this), StartSlot, NumBuffers, ppConstantBuffers, pFirstConstant, pNumConstants); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[9]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this), StartSlot, NumBuffers, ppConstantBuffers, pFirstConstant, pNumConstants); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(10)] + public void GSSetConstantBuffers1(uint StartSlot, uint NumBuffers, ID3D11Buffer* ppConstantBuffers, uint* pFirstConstant, uint* pNumConstants) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[10]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this), StartSlot, NumBuffers, ppConstantBuffers, pFirstConstant, pNumConstants); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[10]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this), StartSlot, NumBuffers, ppConstantBuffers, pFirstConstant, pNumConstants); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(11)] + public void PSSetConstantBuffers1(uint StartSlot, uint NumBuffers, ID3D11Buffer* ppConstantBuffers, uint* pFirstConstant, uint* pNumConstants) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[11]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this), StartSlot, NumBuffers, ppConstantBuffers, pFirstConstant, pNumConstants); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[11]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this), StartSlot, NumBuffers, ppConstantBuffers, pFirstConstant, pNumConstants); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(12)] + public void CSSetConstantBuffers1(uint StartSlot, uint NumBuffers, ID3D11Buffer* ppConstantBuffers, uint* pFirstConstant, uint* pNumConstants) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[12]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this), StartSlot, NumBuffers, ppConstantBuffers, pFirstConstant, pNumConstants); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[12]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this), StartSlot, NumBuffers, ppConstantBuffers, pFirstConstant, pNumConstants); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(13)] + public void VSGetConstantBuffers1(uint StartSlot, uint NumBuffers, ID3D11Buffer* ppConstantBuffers, uint* pFirstConstant, uint* pNumConstants) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[13]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this), StartSlot, NumBuffers, ppConstantBuffers, pFirstConstant, pNumConstants); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[13]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this), StartSlot, NumBuffers, ppConstantBuffers, pFirstConstant, pNumConstants); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(14)] + public void HSGetConstantBuffers1(uint StartSlot, uint NumBuffers, ID3D11Buffer* ppConstantBuffers, uint* pFirstConstant, uint* pNumConstants) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[14]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this), StartSlot, NumBuffers, ppConstantBuffers, pFirstConstant, pNumConstants); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[14]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this), StartSlot, NumBuffers, ppConstantBuffers, pFirstConstant, pNumConstants); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(15)] + public void DSGetConstantBuffers1(uint StartSlot, uint NumBuffers, ID3D11Buffer* ppConstantBuffers, uint* pFirstConstant, uint* pNumConstants) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[15]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this), StartSlot, NumBuffers, ppConstantBuffers, pFirstConstant, pNumConstants); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[15]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this), StartSlot, NumBuffers, ppConstantBuffers, pFirstConstant, pNumConstants); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(16)] + public void GSGetConstantBuffers1(uint StartSlot, uint NumBuffers, ID3D11Buffer* ppConstantBuffers, uint* pFirstConstant, uint* pNumConstants) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[16]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this), StartSlot, NumBuffers, ppConstantBuffers, pFirstConstant, pNumConstants); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[16]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this), StartSlot, NumBuffers, ppConstantBuffers, pFirstConstant, pNumConstants); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(17)] + public void PSGetConstantBuffers1(uint StartSlot, uint NumBuffers, ID3D11Buffer* ppConstantBuffers, uint* pFirstConstant, uint* pNumConstants) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[17]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this), StartSlot, NumBuffers, ppConstantBuffers, pFirstConstant, pNumConstants); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[17]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this), StartSlot, NumBuffers, ppConstantBuffers, pFirstConstant, pNumConstants); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(18)] + public void CSGetConstantBuffers1(uint StartSlot, uint NumBuffers, ID3D11Buffer* ppConstantBuffers, uint* pFirstConstant, uint* pNumConstants) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[18]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this), StartSlot, NumBuffers, ppConstantBuffers, pFirstConstant, pNumConstants); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[18]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this), StartSlot, NumBuffers, ppConstantBuffers, pFirstConstant, pNumConstants); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(19)] + public void SwapDeviceContextState(ID3DDeviceContextState* pState, ID3DDeviceContextState* ppPreviousState) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[19]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this), pState, ppPreviousState); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[19]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this), pState, ppPreviousState); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(20)] + public void ClearView(ID3D11View* pView, float* Color, RawRect* pRect, uint NumRects) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[20]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this), pView, Color, pRect, NumRects); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[20]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this), pView, Color, pRect, NumRects); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(21)] + public void DiscardView1(ID3D11View* pResourceView, RawRect* pRects, uint NumRects) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[21]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this), pResourceView, pRects, NumRects); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[21]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this), pResourceView, pRects, NumRects); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(22)] + public void VSSetConstantBuffers(uint StartSlot, uint NumBuffers, ID3D11Buffer* ppConstantBuffers) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[22]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this), StartSlot, NumBuffers, ppConstantBuffers); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[22]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this), StartSlot, NumBuffers, ppConstantBuffers); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(23)] + public void PSSetShaderResources(uint StartSlot, uint NumViews, ID3D11ShaderResourceView* ppShaderResourceViews) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[23]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this), StartSlot, NumViews, ppShaderResourceViews); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[23]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this), StartSlot, NumViews, ppShaderResourceViews); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(24)] + public void PSSetShader(ID3D11PixelShader* pPixelShader, ID3D11ClassInstance* ppClassInstances, uint NumClassInstances) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[24]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this), pPixelShader, ppClassInstances, NumClassInstances); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[24]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this), pPixelShader, ppClassInstances, NumClassInstances); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(25)] + public void PSSetSamplers(uint StartSlot, uint NumSamplers, ID3D11SamplerState* ppSamplers) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[25]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this), StartSlot, NumSamplers, ppSamplers); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[25]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this), StartSlot, NumSamplers, ppSamplers); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(26)] + public void VSSetShader(ID3D11VertexShader* pVertexShader, ID3D11ClassInstance* ppClassInstances, uint NumClassInstances) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[26]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this), pVertexShader, ppClassInstances, NumClassInstances); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[26]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this), pVertexShader, ppClassInstances, NumClassInstances); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(27)] + public void DrawIndexed(uint IndexCount, uint StartIndexLocation, int BaseVertexLocation) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[27]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this), IndexCount, StartIndexLocation, BaseVertexLocation); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[27]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this), IndexCount, StartIndexLocation, BaseVertexLocation); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(28)] + public void Draw(uint VertexCount, uint StartVertexLocation) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[28]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this), VertexCount, StartVertexLocation); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[28]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this), VertexCount, StartVertexLocation); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(29)] + public HResult Map(ID3D11Resource* pResource, uint Subresource, Map MapType, uint MapFlags, MappedSubresource* pMappedResource) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[29]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this), pResource, Subresource, MapType, MapFlags, pMappedResource); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[29]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this), pResource, Subresource, MapType, MapFlags, pMappedResource); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(30)] + public void Unmap(ID3D11Resource* pResource, uint Subresource) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[30]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this), pResource, Subresource); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[30]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this), pResource, Subresource); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(31)] + public void PSSetConstantBuffers(uint StartSlot, uint NumBuffers, ID3D11Buffer* ppConstantBuffers) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[31]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this), StartSlot, NumBuffers, ppConstantBuffers); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[31]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this), StartSlot, NumBuffers, ppConstantBuffers); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(32)] + public void IASetInputLayout(ID3D11InputLayout* pInputLayout) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[32]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this), pInputLayout); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[32]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this), pInputLayout); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(33)] + public void IASetVertexBuffers(uint StartSlot, uint NumBuffers, ID3D11Buffer* ppVertexBuffers, uint* pStrides, uint* pOffsets) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[33]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this), StartSlot, NumBuffers, ppVertexBuffers, pStrides, pOffsets); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[33]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this), StartSlot, NumBuffers, ppVertexBuffers, pStrides, pOffsets); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(34)] + public void IASetIndexBuffer(ID3D11Buffer* pIndexBuffer, Graphics.Dxgi.Common.Format Format, uint Offset) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[34]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this), pIndexBuffer, Format, Offset); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[34]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this), pIndexBuffer, Format, Offset); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(35)] + public void DrawIndexedInstanced(uint IndexCountPerInstance, uint InstanceCount, uint StartIndexLocation, int BaseVertexLocation, uint StartInstanceLocation) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[35]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this), IndexCountPerInstance, InstanceCount, StartIndexLocation, BaseVertexLocation, StartInstanceLocation); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[35]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this), IndexCountPerInstance, InstanceCount, StartIndexLocation, BaseVertexLocation, StartInstanceLocation); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(36)] + public void DrawInstanced(uint VertexCountPerInstance, uint InstanceCount, uint StartVertexLocation, uint StartInstanceLocation) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[36]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this), VertexCountPerInstance, InstanceCount, StartVertexLocation, StartInstanceLocation); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[36]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this), VertexCountPerInstance, InstanceCount, StartVertexLocation, StartInstanceLocation); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(37)] + public void GSSetConstantBuffers(uint StartSlot, uint NumBuffers, ID3D11Buffer* ppConstantBuffers) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[37]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this), StartSlot, NumBuffers, ppConstantBuffers); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[37]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this), StartSlot, NumBuffers, ppConstantBuffers); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(38)] + public void GSSetShader(ID3D11GeometryShader* pShader, ID3D11ClassInstance* ppClassInstances, uint NumClassInstances) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[38]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this), pShader, ppClassInstances, NumClassInstances); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[38]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this), pShader, ppClassInstances, NumClassInstances); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(39)] + public void IASetPrimitiveTopology(Graphics.Direct3D.PrimitiveTopology Topology) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[39]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this), Topology); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[39]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this), Topology); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(40)] + public void VSSetShaderResources(uint StartSlot, uint NumViews, ID3D11ShaderResourceView* ppShaderResourceViews) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[40]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this), StartSlot, NumViews, ppShaderResourceViews); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[40]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this), StartSlot, NumViews, ppShaderResourceViews); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(41)] + public void VSSetSamplers(uint StartSlot, uint NumSamplers, ID3D11SamplerState* ppSamplers) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[41]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this), StartSlot, NumSamplers, ppSamplers); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[41]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this), StartSlot, NumSamplers, ppSamplers); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(42)] + public void Begin(ID3D11Asynchronous* pAsync) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[42]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this), pAsync); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[42]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this), pAsync); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(43)] + public void End(ID3D11Asynchronous* pAsync) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[43]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this), pAsync); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[43]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this), pAsync); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(44)] + public HResult GetData(ID3D11Asynchronous* pAsync, void* pData, uint DataSize, uint GetDataFlags) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[44]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this), pAsync, pData, DataSize, GetDataFlags); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[44]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this), pAsync, pData, DataSize, GetDataFlags); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(45)] + public void SetPredication(ID3D11Predicate* pPredicate, Bool32* PredicateValue) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[45]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this), pPredicate, PredicateValue); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[45]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this), pPredicate, PredicateValue); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(46)] + public void GSSetShaderResources(uint StartSlot, uint NumViews, ID3D11ShaderResourceView* ppShaderResourceViews) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[46]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this), StartSlot, NumViews, ppShaderResourceViews); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[46]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this), StartSlot, NumViews, ppShaderResourceViews); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(47)] + public void GSSetSamplers(uint StartSlot, uint NumSamplers, ID3D11SamplerState* ppSamplers) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[47]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this), StartSlot, NumSamplers, ppSamplers); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[47]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this), StartSlot, NumSamplers, ppSamplers); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(48)] + public void OMSetRenderTargets(uint NumViews, ID3D11RenderTargetView* ppRenderTargetViews, ID3D11DepthStencilView* pDepthStencilView) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[48]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this), NumViews, ppRenderTargetViews, pDepthStencilView); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[48]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this), NumViews, ppRenderTargetViews, pDepthStencilView); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(49)] + public void OMSetRenderTargetsAndUnorderedAccessViews(uint NumRTVs, ID3D11RenderTargetView* ppRenderTargetViews, ID3D11DepthStencilView* pDepthStencilView, uint UAVStartSlot, uint NumUAVs, ID3D11UnorderedAccessView* ppUnorderedAccessViews, uint* pUAVInitialCounts) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[49]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this), NumRTVs, ppRenderTargetViews, pDepthStencilView, UAVStartSlot, NumUAVs, ppUnorderedAccessViews, pUAVInitialCounts); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[49]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this), NumRTVs, ppRenderTargetViews, pDepthStencilView, UAVStartSlot, NumUAVs, ppUnorderedAccessViews, pUAVInitialCounts); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(50)] + public void OMSetBlendState(ID3D11BlendState* pBlendState, float* BlendFactor, uint SampleMask) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[50]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this), pBlendState, BlendFactor, SampleMask); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[50]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this), pBlendState, BlendFactor, SampleMask); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(51)] + public void OMSetDepthStencilState(ID3D11DepthStencilState* pDepthStencilState, uint StencilRef) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[51]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this), pDepthStencilState, StencilRef); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[51]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this), pDepthStencilState, StencilRef); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(52)] + public void SOSetTargets(uint NumBuffers, ID3D11Buffer* ppSOTargets, uint* pOffsets) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[52]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this), NumBuffers, ppSOTargets, pOffsets); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[52]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this), NumBuffers, ppSOTargets, pOffsets); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(53)] + public void DrawAuto() + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[53]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this)); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[53]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this)); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(54)] + public void DrawIndexedInstancedIndirect(ID3D11Buffer* pBufferForArgs, uint AlignedByteOffsetForArgs) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[54]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this), pBufferForArgs, AlignedByteOffsetForArgs); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[54]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this), pBufferForArgs, AlignedByteOffsetForArgs); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(55)] + public void DrawInstancedIndirect(ID3D11Buffer* pBufferForArgs, uint AlignedByteOffsetForArgs) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[55]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this), pBufferForArgs, AlignedByteOffsetForArgs); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[55]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this), pBufferForArgs, AlignedByteOffsetForArgs); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(56)] + public void Dispatch(uint ThreadGroupCountX, uint ThreadGroupCountY, uint ThreadGroupCountZ) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[56]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this), ThreadGroupCountX, ThreadGroupCountY, ThreadGroupCountZ); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[56]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this), ThreadGroupCountX, ThreadGroupCountY, ThreadGroupCountZ); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(57)] + public void DispatchIndirect(ID3D11Buffer* pBufferForArgs, uint AlignedByteOffsetForArgs) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[57]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this), pBufferForArgs, AlignedByteOffsetForArgs); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[57]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this), pBufferForArgs, AlignedByteOffsetForArgs); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(58)] + public void RSSetState(ID3D11RasterizerState* pRasterizerState) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[58]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this), pRasterizerState); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[58]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this), pRasterizerState); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(59)] + public void RSSetViewports(uint NumViewports, Viewport* pViewports) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[59]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this), NumViewports, pViewports); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[59]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this), NumViewports, pViewports); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(60)] + public void RSSetScissorRects(uint NumRects, RawRect* pRects) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[60]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this), NumRects, pRects); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[60]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this), NumRects, pRects); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(61)] + public void CopySubresourceRegion(ID3D11Resource* pDstResource, uint DstSubresource, uint DstX, uint DstY, uint DstZ, ID3D11Resource* pSrcResource, uint SrcSubresource, Box* pSrcBox) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[61]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this), pDstResource, DstSubresource, DstX, DstY, DstZ, pSrcResource, SrcSubresource, pSrcBox); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[61]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this), pDstResource, DstSubresource, DstX, DstY, DstZ, pSrcResource, SrcSubresource, pSrcBox); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(62)] + public void CopyResource(ID3D11Resource* pDstResource, ID3D11Resource* pSrcResource) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[62]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this), pDstResource, pSrcResource); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[62]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this), pDstResource, pSrcResource); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(63)] + public void UpdateSubresource(ID3D11Resource* pDstResource, uint DstSubresource, Box* pDstBox, void* pSrcData, uint SrcRowPitch, uint SrcDepthPitch) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[63]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this), pDstResource, DstSubresource, pDstBox, pSrcData, SrcRowPitch, SrcDepthPitch); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[63]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this), pDstResource, DstSubresource, pDstBox, pSrcData, SrcRowPitch, SrcDepthPitch); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(64)] + public void CopyStructureCount(ID3D11Buffer* pDstBuffer, uint DstAlignedByteOffset, ID3D11UnorderedAccessView* pSrcView) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[64]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this), pDstBuffer, DstAlignedByteOffset, pSrcView); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[64]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this), pDstBuffer, DstAlignedByteOffset, pSrcView); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(65)] + public void ClearRenderTargetView(ID3D11RenderTargetView* pRenderTargetView, float* ColorRGBA) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[65]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this), pRenderTargetView, ColorRGBA); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[65]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this), pRenderTargetView, ColorRGBA); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(66)] + public void ClearUnorderedAccessViewUint(ID3D11UnorderedAccessView* pUnorderedAccessView, uint* Values) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[66]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this), pUnorderedAccessView, Values); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[66]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this), pUnorderedAccessView, Values); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(67)] + public void ClearUnorderedAccessViewFloat(ID3D11UnorderedAccessView* pUnorderedAccessView, float* Values) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[67]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this), pUnorderedAccessView, Values); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[67]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this), pUnorderedAccessView, Values); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(68)] + public void ClearDepthStencilView(ID3D11DepthStencilView* pDepthStencilView, uint ClearFlags, float Depth, byte Stencil) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[68]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this), pDepthStencilView, ClearFlags, Depth, Stencil); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[68]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this), pDepthStencilView, ClearFlags, Depth, Stencil); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(69)] + public void GenerateMips(ID3D11ShaderResourceView* pShaderResourceView) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[69]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this), pShaderResourceView); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[69]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this), pShaderResourceView); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(70)] + public void SetResourceMinLOD(ID3D11Resource* pResource, float MinLOD) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[70]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this), pResource, MinLOD); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[70]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this), pResource, MinLOD); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(71)] + public float GetResourceMinLOD(ID3D11Resource* pResource) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[71]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this), pResource); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[71]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this), pResource); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(72)] + public void ResolveSubresource(ID3D11Resource* pDstResource, uint DstSubresource, ID3D11Resource* pSrcResource, uint SrcSubresource, Graphics.Dxgi.Common.Format Format) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[72]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this), pDstResource, DstSubresource, pSrcResource, SrcSubresource, Format); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[72]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this), pDstResource, DstSubresource, pSrcResource, SrcSubresource, Format); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(73)] + public void ExecuteCommandList(ID3D11CommandList* pCommandList, Bool32* RestoreContextState) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[73]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this), pCommandList, RestoreContextState); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[73]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this), pCommandList, RestoreContextState); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(74)] + public void HSSetShaderResources(uint StartSlot, uint NumViews, ID3D11ShaderResourceView* ppShaderResourceViews) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[74]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this), StartSlot, NumViews, ppShaderResourceViews); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[74]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this), StartSlot, NumViews, ppShaderResourceViews); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(75)] + public void HSSetShader(ID3D11HullShader* pHullShader, ID3D11ClassInstance* ppClassInstances, uint NumClassInstances) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[75]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this), pHullShader, ppClassInstances, NumClassInstances); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[75]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this), pHullShader, ppClassInstances, NumClassInstances); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(76)] + public void HSSetSamplers(uint StartSlot, uint NumSamplers, ID3D11SamplerState* ppSamplers) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[76]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this), StartSlot, NumSamplers, ppSamplers); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[76]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this), StartSlot, NumSamplers, ppSamplers); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(77)] + public void HSSetConstantBuffers(uint StartSlot, uint NumBuffers, ID3D11Buffer* ppConstantBuffers) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[77]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this), StartSlot, NumBuffers, ppConstantBuffers); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[77]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this), StartSlot, NumBuffers, ppConstantBuffers); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(78)] + public void DSSetShaderResources(uint StartSlot, uint NumViews, ID3D11ShaderResourceView* ppShaderResourceViews) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[78]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this), StartSlot, NumViews, ppShaderResourceViews); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[78]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this), StartSlot, NumViews, ppShaderResourceViews); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(79)] + public void DSSetShader(ID3D11DomainShader* pDomainShader, ID3D11ClassInstance* ppClassInstances, uint NumClassInstances) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[79]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this), pDomainShader, ppClassInstances, NumClassInstances); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[79]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this), pDomainShader, ppClassInstances, NumClassInstances); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(80)] + public void DSSetSamplers(uint StartSlot, uint NumSamplers, ID3D11SamplerState* ppSamplers) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[80]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this), StartSlot, NumSamplers, ppSamplers); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[80]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this), StartSlot, NumSamplers, ppSamplers); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(81)] + public void DSSetConstantBuffers(uint StartSlot, uint NumBuffers, ID3D11Buffer* ppConstantBuffers) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[81]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this), StartSlot, NumBuffers, ppConstantBuffers); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[81]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this), StartSlot, NumBuffers, ppConstantBuffers); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(82)] + public void CSSetShaderResources(uint StartSlot, uint NumViews, ID3D11ShaderResourceView* ppShaderResourceViews) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[82]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this), StartSlot, NumViews, ppShaderResourceViews); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[82]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this), StartSlot, NumViews, ppShaderResourceViews); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(83)] + public void CSSetUnorderedAccessViews(uint StartSlot, uint NumUAVs, ID3D11UnorderedAccessView* ppUnorderedAccessViews, uint* pUAVInitialCounts) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[83]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this), StartSlot, NumUAVs, ppUnorderedAccessViews, pUAVInitialCounts); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[83]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this), StartSlot, NumUAVs, ppUnorderedAccessViews, pUAVInitialCounts); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(84)] + public void CSSetShader(ID3D11ComputeShader* pComputeShader, ID3D11ClassInstance* ppClassInstances, uint NumClassInstances) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[84]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this), pComputeShader, ppClassInstances, NumClassInstances); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[84]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this), pComputeShader, ppClassInstances, NumClassInstances); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(85)] + public void CSSetSamplers(uint StartSlot, uint NumSamplers, ID3D11SamplerState* ppSamplers) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[85]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this), StartSlot, NumSamplers, ppSamplers); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[85]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this), StartSlot, NumSamplers, ppSamplers); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(86)] + public void CSSetConstantBuffers(uint StartSlot, uint NumBuffers, ID3D11Buffer* ppConstantBuffers) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[86]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this), StartSlot, NumBuffers, ppConstantBuffers); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[86]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this), StartSlot, NumBuffers, ppConstantBuffers); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(87)] + public void VSGetConstantBuffers(uint StartSlot, uint NumBuffers, ID3D11Buffer* ppConstantBuffers) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[87]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this), StartSlot, NumBuffers, ppConstantBuffers); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[87]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this), StartSlot, NumBuffers, ppConstantBuffers); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(88)] + public void PSGetShaderResources(uint StartSlot, uint NumViews, ID3D11ShaderResourceView* ppShaderResourceViews) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[88]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this), StartSlot, NumViews, ppShaderResourceViews); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[88]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this), StartSlot, NumViews, ppShaderResourceViews); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(89)] + public void PSGetShader(ID3D11PixelShader* ppPixelShader, ID3D11ClassInstance* ppClassInstances, uint* pNumClassInstances) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[89]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this), ppPixelShader, ppClassInstances, pNumClassInstances); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[89]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this), ppPixelShader, ppClassInstances, pNumClassInstances); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(90)] + public void PSGetSamplers(uint StartSlot, uint NumSamplers, ID3D11SamplerState* ppSamplers) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[90]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this), StartSlot, NumSamplers, ppSamplers); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[90]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this), StartSlot, NumSamplers, ppSamplers); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(91)] + public void VSGetShader(ID3D11VertexShader* ppVertexShader, ID3D11ClassInstance* ppClassInstances, uint* pNumClassInstances) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[91]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this), ppVertexShader, ppClassInstances, pNumClassInstances); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[91]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this), ppVertexShader, ppClassInstances, pNumClassInstances); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(92)] + public void PSGetConstantBuffers(uint StartSlot, uint NumBuffers, ID3D11Buffer* ppConstantBuffers) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[92]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this), StartSlot, NumBuffers, ppConstantBuffers); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[92]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this), StartSlot, NumBuffers, ppConstantBuffers); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(93)] + public void IAGetInputLayout(ID3D11InputLayout* ppInputLayout) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[93]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this), ppInputLayout); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[93]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this), ppInputLayout); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(94)] + public void IAGetVertexBuffers(uint StartSlot, uint NumBuffers, ID3D11Buffer* ppVertexBuffers, uint* pStrides, uint* pOffsets) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[94]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this), StartSlot, NumBuffers, ppVertexBuffers, pStrides, pOffsets); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[94]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this), StartSlot, NumBuffers, ppVertexBuffers, pStrides, pOffsets); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(95)] + public void IAGetIndexBuffer(ID3D11Buffer* pIndexBuffer, Graphics.Dxgi.Common.Format* Format, uint* Offset) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[95]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this), pIndexBuffer, Format, Offset); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[95]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this), pIndexBuffer, Format, Offset); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(96)] + public void GSGetConstantBuffers(uint StartSlot, uint NumBuffers, ID3D11Buffer* ppConstantBuffers) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[96]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this), StartSlot, NumBuffers, ppConstantBuffers); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[96]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this), StartSlot, NumBuffers, ppConstantBuffers); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(97)] + public void GSGetShader(ID3D11GeometryShader* ppGeometryShader, ID3D11ClassInstance* ppClassInstances, uint* pNumClassInstances) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[97]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this), ppGeometryShader, ppClassInstances, pNumClassInstances); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[97]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this), ppGeometryShader, ppClassInstances, pNumClassInstances); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(98)] + public void IAGetPrimitiveTopology(Graphics.Direct3D.PrimitiveTopology* pTopology) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[98]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this), pTopology); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[98]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this), pTopology); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(99)] + public void VSGetShaderResources(uint StartSlot, uint NumViews, ID3D11ShaderResourceView* ppShaderResourceViews) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[99]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this), StartSlot, NumViews, ppShaderResourceViews); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[99]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this), StartSlot, NumViews, ppShaderResourceViews); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(100)] + public void VSGetSamplers(uint StartSlot, uint NumSamplers, ID3D11SamplerState* ppSamplers) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[100]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this), StartSlot, NumSamplers, ppSamplers); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[100]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this), StartSlot, NumSamplers, ppSamplers); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(101)] + public void GetPredication(ID3D11Predicate* ppPredicate, Bool32* pPredicateValue) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[101]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this), ppPredicate, pPredicateValue); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[101]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this), ppPredicate, pPredicateValue); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(102)] + public void GSGetShaderResources(uint StartSlot, uint NumViews, ID3D11ShaderResourceView* ppShaderResourceViews) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[102]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this), StartSlot, NumViews, ppShaderResourceViews); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[102]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this), StartSlot, NumViews, ppShaderResourceViews); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(103)] + public void GSGetSamplers(uint StartSlot, uint NumSamplers, ID3D11SamplerState* ppSamplers) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[103]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this), StartSlot, NumSamplers, ppSamplers); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[103]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this), StartSlot, NumSamplers, ppSamplers); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(104)] + public void OMGetRenderTargets(uint NumViews, ID3D11RenderTargetView* ppRenderTargetViews, ID3D11DepthStencilView* ppDepthStencilView) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[104]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this), NumViews, ppRenderTargetViews, ppDepthStencilView); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[104]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this), NumViews, ppRenderTargetViews, ppDepthStencilView); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(105)] + public void OMGetRenderTargetsAndUnorderedAccessViews(uint NumRTVs, ID3D11RenderTargetView* ppRenderTargetViews, ID3D11DepthStencilView* ppDepthStencilView, uint UAVStartSlot, uint NumUAVs, ID3D11UnorderedAccessView* ppUnorderedAccessViews) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[105]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this), NumRTVs, ppRenderTargetViews, ppDepthStencilView, UAVStartSlot, NumUAVs, ppUnorderedAccessViews); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[105]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this), NumRTVs, ppRenderTargetViews, ppDepthStencilView, UAVStartSlot, NumUAVs, ppUnorderedAccessViews); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(106)] + public void OMGetBlendState(ID3D11BlendState* ppBlendState, float* BlendFactor, uint* pSampleMask) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[106]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this), ppBlendState, BlendFactor, pSampleMask); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[106]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this), ppBlendState, BlendFactor, pSampleMask); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(107)] + public void OMGetDepthStencilState(ID3D11DepthStencilState* ppDepthStencilState, uint* pStencilRef) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[107]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this), ppDepthStencilState, pStencilRef); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[107]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this), ppDepthStencilState, pStencilRef); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(108)] + public void SOGetTargets(uint NumBuffers, ID3D11Buffer* ppSOTargets) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[108]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this), NumBuffers, ppSOTargets); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[108]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this), NumBuffers, ppSOTargets); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(109)] + public void RSGetState(ID3D11RasterizerState* ppRasterizerState) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[109]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this), ppRasterizerState); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[109]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this), ppRasterizerState); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(110)] + public void RSGetViewports(uint* pNumViewports, Viewport* pViewports) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[110]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this), pNumViewports, pViewports); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[110]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this), pNumViewports, pViewports); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(111)] + public void RSGetScissorRects(uint* pNumRects, RawRect* pRects) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[111]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this), pNumRects, pRects); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[111]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this), pNumRects, pRects); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(112)] + public void HSGetShaderResources(uint StartSlot, uint NumViews, ID3D11ShaderResourceView* ppShaderResourceViews) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[112]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this), StartSlot, NumViews, ppShaderResourceViews); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[112]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this), StartSlot, NumViews, ppShaderResourceViews); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(113)] + public void HSGetShader(ID3D11HullShader* ppHullShader, ID3D11ClassInstance* ppClassInstances, uint* pNumClassInstances) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[113]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this), ppHullShader, ppClassInstances, pNumClassInstances); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[113]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this), ppHullShader, ppClassInstances, pNumClassInstances); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(114)] + public void HSGetSamplers(uint StartSlot, uint NumSamplers, ID3D11SamplerState* ppSamplers) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[114]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this), StartSlot, NumSamplers, ppSamplers); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[114]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this), StartSlot, NumSamplers, ppSamplers); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(115)] + public void HSGetConstantBuffers(uint StartSlot, uint NumBuffers, ID3D11Buffer* ppConstantBuffers) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[115]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this), StartSlot, NumBuffers, ppConstantBuffers); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[115]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this), StartSlot, NumBuffers, ppConstantBuffers); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(116)] + public void DSGetShaderResources(uint StartSlot, uint NumViews, ID3D11ShaderResourceView* ppShaderResourceViews) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[116]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this), StartSlot, NumViews, ppShaderResourceViews); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[116]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this), StartSlot, NumViews, ppShaderResourceViews); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(117)] + public void DSGetShader(ID3D11DomainShader* ppDomainShader, ID3D11ClassInstance* ppClassInstances, uint* pNumClassInstances) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[117]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this), ppDomainShader, ppClassInstances, pNumClassInstances); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[117]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this), ppDomainShader, ppClassInstances, pNumClassInstances); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(118)] + public void DSGetSamplers(uint StartSlot, uint NumSamplers, ID3D11SamplerState* ppSamplers) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[118]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this), StartSlot, NumSamplers, ppSamplers); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[118]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this), StartSlot, NumSamplers, ppSamplers); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(119)] + public void DSGetConstantBuffers(uint StartSlot, uint NumBuffers, ID3D11Buffer* ppConstantBuffers) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[119]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this), StartSlot, NumBuffers, ppConstantBuffers); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[119]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this), StartSlot, NumBuffers, ppConstantBuffers); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(120)] + public void CSGetShaderResources(uint StartSlot, uint NumViews, ID3D11ShaderResourceView* ppShaderResourceViews) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[120]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this), StartSlot, NumViews, ppShaderResourceViews); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[120]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this), StartSlot, NumViews, ppShaderResourceViews); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(121)] + public void CSGetUnorderedAccessViews(uint StartSlot, uint NumUAVs, ID3D11UnorderedAccessView* ppUnorderedAccessViews) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[121]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this), StartSlot, NumUAVs, ppUnorderedAccessViews); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[121]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this), StartSlot, NumUAVs, ppUnorderedAccessViews); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(122)] + public void CSGetShader(ID3D11ComputeShader* ppComputeShader, ID3D11ClassInstance* ppClassInstances, uint* pNumClassInstances) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[122]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this), ppComputeShader, ppClassInstances, pNumClassInstances); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[122]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this), ppComputeShader, ppClassInstances, pNumClassInstances); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(123)] + public void CSGetSamplers(uint StartSlot, uint NumSamplers, ID3D11SamplerState* ppSamplers) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[123]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this), StartSlot, NumSamplers, ppSamplers); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[123]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this), StartSlot, NumSamplers, ppSamplers); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(124)] + public void CSGetConstantBuffers(uint StartSlot, uint NumBuffers, ID3D11Buffer* ppConstantBuffers) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[124]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this), StartSlot, NumBuffers, ppConstantBuffers); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[124]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this), StartSlot, NumBuffers, ppConstantBuffers); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(125)] + public void ClearState() + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[125]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this)); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[125]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this)); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(126)] + public void Flush() + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[126]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this)); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[126]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this)); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(127)] + public Graphics.Direct3D11.DeviceContextType GetType() + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[127]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this)); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[127]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this)); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(128)] + public uint GetContextFlags() + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[128]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this)); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[128]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this)); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(129)] + public HResult FinishCommandList(Bool32* RestoreDeferredContextState, ID3D11CommandList** ppCommandList) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[129]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this), RestoreDeferredContextState, ppCommandList); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[129]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this), RestoreDeferredContextState, ppCommandList); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(130)] + public void GetDevice(ID3D11Device* ppDevice) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[130]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this), ppDevice); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[130]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this), ppDevice); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(131)] + public HResult GetPrivateData(Guid* guid, uint* pDataSize, void* pData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[131]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this), guid, pDataSize, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[131]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this), guid, pDataSize, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(132)] + public HResult SetPrivateData(Guid* guid, uint DataSize, void* pData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[132]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this), guid, DataSize, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[132]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this), guid, DataSize, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(133)] + public HResult SetPrivateDataInterface(Guid* guid, IUnknown* pData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[133]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this), guid, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[133]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this), guid, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(134)] + public HResult UpdateTileMappings(ID3D11Resource* pTiledResource, uint NumTiledResourceRegions, TiledResourceCoordinate* pTiledResourceRegionStartCoordinates, TileRegionSize* pTiledResourceRegionSizes, ID3D11Buffer* pTilePool, uint NumRanges, uint* pRangeFlags, uint* pTilePoolStartOffsets, uint* pRangeTileCounts, uint Flags) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[134]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this), pTiledResource, NumTiledResourceRegions, pTiledResourceRegionStartCoordinates, pTiledResourceRegionSizes, pTilePool, NumRanges, pRangeFlags, pTilePoolStartOffsets, pRangeTileCounts, Flags); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[134]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this), pTiledResource, NumTiledResourceRegions, pTiledResourceRegionStartCoordinates, pTiledResourceRegionSizes, pTilePool, NumRanges, pRangeFlags, pTilePoolStartOffsets, pRangeTileCounts, Flags); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(135)] + public HResult CopyTileMappings(ID3D11Resource* pDestTiledResource, TiledResourceCoordinate* pDestRegionStartCoordinate, ID3D11Resource* pSourceTiledResource, TiledResourceCoordinate* pSourceRegionStartCoordinate, TileRegionSize* pTileRegionSize, uint Flags) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[135]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this), pDestTiledResource, pDestRegionStartCoordinate, pSourceTiledResource, pSourceRegionStartCoordinate, pTileRegionSize, Flags); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[135]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this), pDestTiledResource, pDestRegionStartCoordinate, pSourceTiledResource, pSourceRegionStartCoordinate, pTileRegionSize, Flags); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(136)] + public void CopyTiles(ID3D11Resource* pTiledResource, TiledResourceCoordinate* pTileRegionStartCoordinate, TileRegionSize* pTileRegionSize, ID3D11Buffer* pBuffer, ulong BufferStartOffsetInBytes, uint Flags) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[136]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this), pTiledResource, pTileRegionStartCoordinate, pTileRegionSize, pBuffer, BufferStartOffsetInBytes, Flags); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[136]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this), pTiledResource, pTileRegionStartCoordinate, pTileRegionSize, pBuffer, BufferStartOffsetInBytes, Flags); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(137)] + public void UpdateTiles(ID3D11Resource* pDestTiledResource, TiledResourceCoordinate* pDestTileRegionStartCoordinate, TileRegionSize* pDestTileRegionSize, void* pSourceTileData, uint Flags) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[137]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this), pDestTiledResource, pDestTileRegionStartCoordinate, pDestTileRegionSize, pSourceTileData, Flags); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[137]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this), pDestTiledResource, pDestTileRegionStartCoordinate, pDestTileRegionSize, pSourceTileData, Flags); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(138)] + public HResult ResizeTilePool(ID3D11Buffer* pTilePool, ulong NewSizeInBytes) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[138]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this), pTilePool, NewSizeInBytes); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[138]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this), pTilePool, NewSizeInBytes); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(139)] + public void TiledResourceBarrier(ID3D11DeviceChild* pTiledResourceOrViewAccessBeforeBarrier, ID3D11DeviceChild* pTiledResourceOrViewAccessAfterBarrier) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[139]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this), pTiledResourceOrViewAccessBeforeBarrier, pTiledResourceOrViewAccessAfterBarrier); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[139]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this), pTiledResourceOrViewAccessBeforeBarrier, pTiledResourceOrViewAccessAfterBarrier); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(140)] + public Bool32 IsAnnotationEnabled() + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[140]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this)); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[140]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this)); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(141)] + public void SetMarkerInt(char** pLabel, int Data) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[141]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this), pLabel, Data); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[141]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this), pLabel, Data); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(142)] + public void BeginEventInt(char** pLabel, int Data) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[142]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this), pLabel, Data); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[142]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this), pLabel, Data); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(143)] + public void EndEvent() + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[143]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this)); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[143]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this)); +#endif + } + + public interface Interface : ID3D11DeviceContext1.Interface + { + } +} + +/// +/// ID3D11Device2 +[Guid("9d06dffa-d1e5-4d07-83a8-1bb123f2f841")] +[NativeTypeName("struct ID3D11Device2 : ID3D11Device1")] +[NativeInheritance("ID3D11Device1")] +public unsafe partial struct ID3D11Device2 : ID3D11Device2.Interface +{ + public static ref readonly Guid IID_ID3D11Device2 + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0xFA, 0xDF, 0x06, 0x9D, + 0xE5, 0xD1, + 0x07, 0x4D, + 0x83, + 0xA8, + 0x1B, + 0xB1, + 0x23, + 0xF2, + 0xF8, + 0x41 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_ID3D11Device2)); + + public void** lpVtbl; + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(0)] + public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(1)] + [return: NativeTypeName("ULONG")] + public uint AddRef() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(2)] + [return: NativeTypeName("ULONG")] + public uint Release() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(3)] + public void GetImmediateContext1(ID3D11DeviceContext1* ppImmediateContext) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[3]))((ID3D11Device2*)Unsafe.AsPointer(ref this), ppImmediateContext); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((ID3D11Device2*)Unsafe.AsPointer(ref this), ppImmediateContext); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public HResult CreateDeferredContext1(uint ContextFlags, ID3D11DeviceContext1** ppDeferredContext) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[4]))((ID3D11Device2*)Unsafe.AsPointer(ref this), ContextFlags, ppDeferredContext); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((ID3D11Device2*)Unsafe.AsPointer(ref this), ContextFlags, ppDeferredContext); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(5)] + public HResult CreateBlendState1(BlendDescription1* pBlendStateDesc, ID3D11BlendState1** ppBlendState) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[5]))((ID3D11Device2*)Unsafe.AsPointer(ref this), pBlendStateDesc, ppBlendState); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((ID3D11Device2*)Unsafe.AsPointer(ref this), pBlendStateDesc, ppBlendState); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(6)] + public HResult CreateRasterizerState1(RasterizerDescription1* pRasterizerDesc, ID3D11RasterizerState1** ppRasterizerState) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[6]))((ID3D11Device2*)Unsafe.AsPointer(ref this), pRasterizerDesc, ppRasterizerState); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((ID3D11Device2*)Unsafe.AsPointer(ref this), pRasterizerDesc, ppRasterizerState); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(7)] + public HResult CreateDeviceContextState(uint Flags, Graphics.Direct3D.FeatureLevel* pFeatureLevels, uint FeatureLevels, uint SDKVersion, Guid* EmulatedInterface, Graphics.Direct3D.FeatureLevel* pChosenFeatureLevel, ID3DDeviceContextState* ppContextState) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[7]))((ID3D11Device2*)Unsafe.AsPointer(ref this), Flags, pFeatureLevels, FeatureLevels, SDKVersion, EmulatedInterface, pChosenFeatureLevel, ppContextState); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((ID3D11Device2*)Unsafe.AsPointer(ref this), Flags, pFeatureLevels, FeatureLevels, SDKVersion, EmulatedInterface, pChosenFeatureLevel, ppContextState); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(8)] + public HResult OpenSharedResource1(IntPtr* hResource, Guid* returnedInterface, void** ppResource) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[8]))((ID3D11Device2*)Unsafe.AsPointer(ref this), hResource, returnedInterface, ppResource); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[8]))((ID3D11Device2*)Unsafe.AsPointer(ref this), hResource, returnedInterface, ppResource); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(9)] + public HResult OpenSharedResourceByName(char** lpName, uint dwDesiredAccess, Guid* returnedInterface, void** ppResource) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[9]))((ID3D11Device2*)Unsafe.AsPointer(ref this), lpName, dwDesiredAccess, returnedInterface, ppResource); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[9]))((ID3D11Device2*)Unsafe.AsPointer(ref this), lpName, dwDesiredAccess, returnedInterface, ppResource); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(10)] + public HResult CreateBuffer(BufferDescription* pDesc, SubresourceData* pInitialData, ID3D11Buffer** ppBuffer) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[10]))((ID3D11Device2*)Unsafe.AsPointer(ref this), pDesc, pInitialData, ppBuffer); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[10]))((ID3D11Device2*)Unsafe.AsPointer(ref this), pDesc, pInitialData, ppBuffer); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(11)] + public HResult CreateTexture1D(Texture1DDescription* pDesc, SubresourceData* pInitialData, ID3D11Texture1D** ppTexture1D) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[11]))((ID3D11Device2*)Unsafe.AsPointer(ref this), pDesc, pInitialData, ppTexture1D); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[11]))((ID3D11Device2*)Unsafe.AsPointer(ref this), pDesc, pInitialData, ppTexture1D); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(12)] + public HResult CreateTexture2D(Texture2DDescription* pDesc, SubresourceData* pInitialData, ID3D11Texture2D** ppTexture2D) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[12]))((ID3D11Device2*)Unsafe.AsPointer(ref this), pDesc, pInitialData, ppTexture2D); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[12]))((ID3D11Device2*)Unsafe.AsPointer(ref this), pDesc, pInitialData, ppTexture2D); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(13)] + public HResult CreateTexture3D(Texture3DDescription* pDesc, SubresourceData* pInitialData, ID3D11Texture3D** ppTexture3D) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[13]))((ID3D11Device2*)Unsafe.AsPointer(ref this), pDesc, pInitialData, ppTexture3D); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[13]))((ID3D11Device2*)Unsafe.AsPointer(ref this), pDesc, pInitialData, ppTexture3D); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(14)] + public HResult CreateShaderResourceView(ID3D11Resource* pResource, ShaderResourceViewDescription* pDesc, ID3D11ShaderResourceView** ppSRView) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[14]))((ID3D11Device2*)Unsafe.AsPointer(ref this), pResource, pDesc, ppSRView); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[14]))((ID3D11Device2*)Unsafe.AsPointer(ref this), pResource, pDesc, ppSRView); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(15)] + public HResult CreateUnorderedAccessView(ID3D11Resource* pResource, UnorderedAccessViewDescription* pDesc, ID3D11UnorderedAccessView** ppUAView) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[15]))((ID3D11Device2*)Unsafe.AsPointer(ref this), pResource, pDesc, ppUAView); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[15]))((ID3D11Device2*)Unsafe.AsPointer(ref this), pResource, pDesc, ppUAView); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(16)] + public HResult CreateRenderTargetView(ID3D11Resource* pResource, RenderTargetViewDescription* pDesc, ID3D11RenderTargetView** ppRTView) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[16]))((ID3D11Device2*)Unsafe.AsPointer(ref this), pResource, pDesc, ppRTView); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[16]))((ID3D11Device2*)Unsafe.AsPointer(ref this), pResource, pDesc, ppRTView); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(17)] + public HResult CreateDepthStencilView(ID3D11Resource* pResource, DepthStencilViewDescription* pDesc, ID3D11DepthStencilView** ppDepthStencilView) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[17]))((ID3D11Device2*)Unsafe.AsPointer(ref this), pResource, pDesc, ppDepthStencilView); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[17]))((ID3D11Device2*)Unsafe.AsPointer(ref this), pResource, pDesc, ppDepthStencilView); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(18)] + public HResult CreateInputLayout(InputElementDescription* pInputElementDescs, uint NumElements, void* pShaderBytecodeWithInputSignature, nuint BytecodeLength, ID3D11InputLayout** ppInputLayout) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[18]))((ID3D11Device2*)Unsafe.AsPointer(ref this), pInputElementDescs, NumElements, pShaderBytecodeWithInputSignature, BytecodeLength, ppInputLayout); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[18]))((ID3D11Device2*)Unsafe.AsPointer(ref this), pInputElementDescs, NumElements, pShaderBytecodeWithInputSignature, BytecodeLength, ppInputLayout); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(19)] + public HResult CreateVertexShader(void* pShaderBytecode, nuint BytecodeLength, ID3D11ClassLinkage* pClassLinkage, ID3D11VertexShader** ppVertexShader) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[19]))((ID3D11Device2*)Unsafe.AsPointer(ref this), pShaderBytecode, BytecodeLength, pClassLinkage, ppVertexShader); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[19]))((ID3D11Device2*)Unsafe.AsPointer(ref this), pShaderBytecode, BytecodeLength, pClassLinkage, ppVertexShader); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(20)] + public HResult CreateGeometryShader(void* pShaderBytecode, nuint BytecodeLength, ID3D11ClassLinkage* pClassLinkage, ID3D11GeometryShader** ppGeometryShader) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[20]))((ID3D11Device2*)Unsafe.AsPointer(ref this), pShaderBytecode, BytecodeLength, pClassLinkage, ppGeometryShader); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[20]))((ID3D11Device2*)Unsafe.AsPointer(ref this), pShaderBytecode, BytecodeLength, pClassLinkage, ppGeometryShader); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(21)] + public HResult CreateGeometryShaderWithStreamOutput(void* pShaderBytecode, nuint BytecodeLength, SoDeclarationEntry* pSODeclaration, uint NumEntries, uint* pBufferStrides, uint NumStrides, uint RasterizedStream, ID3D11ClassLinkage* pClassLinkage, ID3D11GeometryShader** ppGeometryShader) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[21]))((ID3D11Device2*)Unsafe.AsPointer(ref this), pShaderBytecode, BytecodeLength, pSODeclaration, NumEntries, pBufferStrides, NumStrides, RasterizedStream, pClassLinkage, ppGeometryShader); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[21]))((ID3D11Device2*)Unsafe.AsPointer(ref this), pShaderBytecode, BytecodeLength, pSODeclaration, NumEntries, pBufferStrides, NumStrides, RasterizedStream, pClassLinkage, ppGeometryShader); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(22)] + public HResult CreatePixelShader(void* pShaderBytecode, nuint BytecodeLength, ID3D11ClassLinkage* pClassLinkage, ID3D11PixelShader** ppPixelShader) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[22]))((ID3D11Device2*)Unsafe.AsPointer(ref this), pShaderBytecode, BytecodeLength, pClassLinkage, ppPixelShader); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[22]))((ID3D11Device2*)Unsafe.AsPointer(ref this), pShaderBytecode, BytecodeLength, pClassLinkage, ppPixelShader); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(23)] + public HResult CreateHullShader(void* pShaderBytecode, nuint BytecodeLength, ID3D11ClassLinkage* pClassLinkage, ID3D11HullShader** ppHullShader) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[23]))((ID3D11Device2*)Unsafe.AsPointer(ref this), pShaderBytecode, BytecodeLength, pClassLinkage, ppHullShader); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[23]))((ID3D11Device2*)Unsafe.AsPointer(ref this), pShaderBytecode, BytecodeLength, pClassLinkage, ppHullShader); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(24)] + public HResult CreateDomainShader(void* pShaderBytecode, nuint BytecodeLength, ID3D11ClassLinkage* pClassLinkage, ID3D11DomainShader** ppDomainShader) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[24]))((ID3D11Device2*)Unsafe.AsPointer(ref this), pShaderBytecode, BytecodeLength, pClassLinkage, ppDomainShader); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[24]))((ID3D11Device2*)Unsafe.AsPointer(ref this), pShaderBytecode, BytecodeLength, pClassLinkage, ppDomainShader); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(25)] + public HResult CreateComputeShader(void* pShaderBytecode, nuint BytecodeLength, ID3D11ClassLinkage* pClassLinkage, ID3D11ComputeShader** ppComputeShader) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[25]))((ID3D11Device2*)Unsafe.AsPointer(ref this), pShaderBytecode, BytecodeLength, pClassLinkage, ppComputeShader); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[25]))((ID3D11Device2*)Unsafe.AsPointer(ref this), pShaderBytecode, BytecodeLength, pClassLinkage, ppComputeShader); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(26)] + public HResult CreateClassLinkage(ID3D11ClassLinkage** ppLinkage) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[26]))((ID3D11Device2*)Unsafe.AsPointer(ref this), ppLinkage); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[26]))((ID3D11Device2*)Unsafe.AsPointer(ref this), ppLinkage); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(27)] + public HResult CreateBlendState(BlendDescription* pBlendStateDesc, ID3D11BlendState** ppBlendState) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[27]))((ID3D11Device2*)Unsafe.AsPointer(ref this), pBlendStateDesc, ppBlendState); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[27]))((ID3D11Device2*)Unsafe.AsPointer(ref this), pBlendStateDesc, ppBlendState); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(28)] + public HResult CreateDepthStencilState(DepthStencilDescription* pDepthStencilDesc, ID3D11DepthStencilState** ppDepthStencilState) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[28]))((ID3D11Device2*)Unsafe.AsPointer(ref this), pDepthStencilDesc, ppDepthStencilState); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[28]))((ID3D11Device2*)Unsafe.AsPointer(ref this), pDepthStencilDesc, ppDepthStencilState); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(29)] + public HResult CreateRasterizerState(RasterizerDescription* pRasterizerDesc, ID3D11RasterizerState** ppRasterizerState) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[29]))((ID3D11Device2*)Unsafe.AsPointer(ref this), pRasterizerDesc, ppRasterizerState); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[29]))((ID3D11Device2*)Unsafe.AsPointer(ref this), pRasterizerDesc, ppRasterizerState); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(30)] + public HResult CreateSamplerState(SamplerDescription* pSamplerDesc, ID3D11SamplerState** ppSamplerState) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[30]))((ID3D11Device2*)Unsafe.AsPointer(ref this), pSamplerDesc, ppSamplerState); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[30]))((ID3D11Device2*)Unsafe.AsPointer(ref this), pSamplerDesc, ppSamplerState); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(31)] + public HResult CreateQuery(QueryDescription* pQueryDesc, ID3D11Query** ppQuery) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[31]))((ID3D11Device2*)Unsafe.AsPointer(ref this), pQueryDesc, ppQuery); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[31]))((ID3D11Device2*)Unsafe.AsPointer(ref this), pQueryDesc, ppQuery); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(32)] + public HResult CreatePredicate(QueryDescription* pPredicateDesc, ID3D11Predicate** ppPredicate) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[32]))((ID3D11Device2*)Unsafe.AsPointer(ref this), pPredicateDesc, ppPredicate); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[32]))((ID3D11Device2*)Unsafe.AsPointer(ref this), pPredicateDesc, ppPredicate); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(33)] + public HResult CreateCounter(CounterDescription* pCounterDesc, ID3D11Counter** ppCounter) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[33]))((ID3D11Device2*)Unsafe.AsPointer(ref this), pCounterDesc, ppCounter); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[33]))((ID3D11Device2*)Unsafe.AsPointer(ref this), pCounterDesc, ppCounter); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(34)] + public HResult CreateDeferredContext(uint ContextFlags, ID3D11DeviceContext** ppDeferredContext) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[34]))((ID3D11Device2*)Unsafe.AsPointer(ref this), ContextFlags, ppDeferredContext); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[34]))((ID3D11Device2*)Unsafe.AsPointer(ref this), ContextFlags, ppDeferredContext); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(35)] + public HResult OpenSharedResource(IntPtr* hResource, Guid* ReturnedInterface, void** ppResource) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[35]))((ID3D11Device2*)Unsafe.AsPointer(ref this), hResource, ReturnedInterface, ppResource); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[35]))((ID3D11Device2*)Unsafe.AsPointer(ref this), hResource, ReturnedInterface, ppResource); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(36)] + public HResult CheckFormatSupport(Graphics.Dxgi.Common.Format Format, uint* pFormatSupport) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[36]))((ID3D11Device2*)Unsafe.AsPointer(ref this), Format, pFormatSupport); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[36]))((ID3D11Device2*)Unsafe.AsPointer(ref this), Format, pFormatSupport); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(37)] + public HResult CheckMultisampleQualityLevels(Graphics.Dxgi.Common.Format Format, uint SampleCount, uint* pNumQualityLevels) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[37]))((ID3D11Device2*)Unsafe.AsPointer(ref this), Format, SampleCount, pNumQualityLevels); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[37]))((ID3D11Device2*)Unsafe.AsPointer(ref this), Format, SampleCount, pNumQualityLevels); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(38)] + public void CheckCounterInfo(CounterInfo* pCounterInfo) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[38]))((ID3D11Device2*)Unsafe.AsPointer(ref this), pCounterInfo); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[38]))((ID3D11Device2*)Unsafe.AsPointer(ref this), pCounterInfo); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(39)] + public HResult CheckCounter(CounterDescription* pDesc, CounterType* pType, uint* pActiveCounters, byte* szName, uint* pNameLength, byte* szUnits, uint* pUnitsLength, byte* szDescription, uint* pDescriptionLength) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[39]))((ID3D11Device2*)Unsafe.AsPointer(ref this), pDesc, pType, pActiveCounters, szName, pNameLength, szUnits, pUnitsLength, szDescription, pDescriptionLength); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[39]))((ID3D11Device2*)Unsafe.AsPointer(ref this), pDesc, pType, pActiveCounters, szName, pNameLength, szUnits, pUnitsLength, szDescription, pDescriptionLength); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(40)] + public HResult CheckFeatureSupport(Feature Feature, void* pFeatureSupportData, uint FeatureSupportDataSize) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[40]))((ID3D11Device2*)Unsafe.AsPointer(ref this), Feature, pFeatureSupportData, FeatureSupportDataSize); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[40]))((ID3D11Device2*)Unsafe.AsPointer(ref this), Feature, pFeatureSupportData, FeatureSupportDataSize); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(41)] + public HResult GetPrivateData(Guid* guid, uint* pDataSize, void* pData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[41]))((ID3D11Device2*)Unsafe.AsPointer(ref this), guid, pDataSize, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[41]))((ID3D11Device2*)Unsafe.AsPointer(ref this), guid, pDataSize, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(42)] + public HResult SetPrivateData(Guid* guid, uint DataSize, void* pData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[42]))((ID3D11Device2*)Unsafe.AsPointer(ref this), guid, DataSize, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[42]))((ID3D11Device2*)Unsafe.AsPointer(ref this), guid, DataSize, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(43)] + public HResult SetPrivateDataInterface(Guid* guid, IUnknown* pData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[43]))((ID3D11Device2*)Unsafe.AsPointer(ref this), guid, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[43]))((ID3D11Device2*)Unsafe.AsPointer(ref this), guid, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(44)] + public Graphics.Direct3D.FeatureLevel GetFeatureLevel() + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[44]))((ID3D11Device2*)Unsafe.AsPointer(ref this)); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[44]))((ID3D11Device2*)Unsafe.AsPointer(ref this)); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(45)] + public uint GetCreationFlags() + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[45]))((ID3D11Device2*)Unsafe.AsPointer(ref this)); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[45]))((ID3D11Device2*)Unsafe.AsPointer(ref this)); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(46)] + public HResult GetDeviceRemovedReason() + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[46]))((ID3D11Device2*)Unsafe.AsPointer(ref this)); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[46]))((ID3D11Device2*)Unsafe.AsPointer(ref this)); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(47)] + public void GetImmediateContext(ID3D11DeviceContext* ppImmediateContext) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[47]))((ID3D11Device2*)Unsafe.AsPointer(ref this), ppImmediateContext); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[47]))((ID3D11Device2*)Unsafe.AsPointer(ref this), ppImmediateContext); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(48)] + public HResult SetExceptionMode(uint RaiseFlags) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[48]))((ID3D11Device2*)Unsafe.AsPointer(ref this), RaiseFlags); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[48]))((ID3D11Device2*)Unsafe.AsPointer(ref this), RaiseFlags); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(49)] + public uint GetExceptionMode() + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[49]))((ID3D11Device2*)Unsafe.AsPointer(ref this)); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[49]))((ID3D11Device2*)Unsafe.AsPointer(ref this)); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(50)] + public void GetImmediateContext2(ID3D11DeviceContext2* ppImmediateContext) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[50]))((ID3D11Device2*)Unsafe.AsPointer(ref this), ppImmediateContext); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[50]))((ID3D11Device2*)Unsafe.AsPointer(ref this), ppImmediateContext); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(51)] + public HResult CreateDeferredContext2(uint ContextFlags, ID3D11DeviceContext2** ppDeferredContext) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[51]))((ID3D11Device2*)Unsafe.AsPointer(ref this), ContextFlags, ppDeferredContext); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[51]))((ID3D11Device2*)Unsafe.AsPointer(ref this), ContextFlags, ppDeferredContext); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(52)] + public void GetResourceTiling(ID3D11Resource* pTiledResource, uint* pNumTilesForEntireResource, PackedMipDescription* pPackedMipDesc, TileShape* pStandardTileShapeForNonPackedMips, uint* pNumSubresourceTilings, uint FirstSubresourceTilingToGet, SubresourceTiling* pSubresourceTilingsForNonPackedMips) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[52]))((ID3D11Device2*)Unsafe.AsPointer(ref this), pTiledResource, pNumTilesForEntireResource, pPackedMipDesc, pStandardTileShapeForNonPackedMips, pNumSubresourceTilings, FirstSubresourceTilingToGet, pSubresourceTilingsForNonPackedMips); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[52]))((ID3D11Device2*)Unsafe.AsPointer(ref this), pTiledResource, pNumTilesForEntireResource, pPackedMipDesc, pStandardTileShapeForNonPackedMips, pNumSubresourceTilings, FirstSubresourceTilingToGet, pSubresourceTilingsForNonPackedMips); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(53)] + public HResult CheckMultisampleQualityLevels1(Graphics.Dxgi.Common.Format Format, uint SampleCount, uint Flags, uint* pNumQualityLevels) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[53]))((ID3D11Device2*)Unsafe.AsPointer(ref this), Format, SampleCount, Flags, pNumQualityLevels); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[53]))((ID3D11Device2*)Unsafe.AsPointer(ref this), Format, SampleCount, Flags, pNumQualityLevels); +#endif + } + + public interface Interface : ID3D11Device1.Interface + { + } +} + +/// +/// ID3D11Texture2D1 +[Guid("51218251-1e33-4617-9ccb-4d3a4367e7bb")] +[NativeTypeName("struct ID3D11Texture2D1 : ID3D11Texture2D")] +[NativeInheritance("ID3D11Texture2D")] +public unsafe partial struct ID3D11Texture2D1 : ID3D11Texture2D1.Interface +{ + public static ref readonly Guid IID_ID3D11Texture2D1 + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x51, 0x82, 0x21, 0x51, + 0x33, 0x1E, + 0x17, 0x46, + 0x9C, + 0xCB, + 0x4D, + 0x3A, + 0x43, + 0x67, + 0xE7, + 0xBB + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_ID3D11Texture2D1)); + + public void** lpVtbl; + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(0)] + public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(1)] + [return: NativeTypeName("ULONG")] + public uint AddRef() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(2)] + [return: NativeTypeName("ULONG")] + public uint Release() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(3)] + public void GetDesc(Texture2DDescription* pDesc) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[3]))((ID3D11Texture2D1*)Unsafe.AsPointer(ref this), pDesc); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((ID3D11Texture2D1*)Unsafe.AsPointer(ref this), pDesc); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public void GetType(ResourceDimension* pResourceDimension) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[4]))((ID3D11Texture2D1*)Unsafe.AsPointer(ref this), pResourceDimension); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((ID3D11Texture2D1*)Unsafe.AsPointer(ref this), pResourceDimension); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(5)] + public void SetEvictionPriority(uint EvictionPriority) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[5]))((ID3D11Texture2D1*)Unsafe.AsPointer(ref this), EvictionPriority); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((ID3D11Texture2D1*)Unsafe.AsPointer(ref this), EvictionPriority); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(6)] + public uint GetEvictionPriority() + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[6]))((ID3D11Texture2D1*)Unsafe.AsPointer(ref this)); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((ID3D11Texture2D1*)Unsafe.AsPointer(ref this)); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(7)] + public void GetDevice(ID3D11Device* ppDevice) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[7]))((ID3D11Texture2D1*)Unsafe.AsPointer(ref this), ppDevice); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((ID3D11Texture2D1*)Unsafe.AsPointer(ref this), ppDevice); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(8)] + public HResult GetPrivateData(Guid* guid, uint* pDataSize, void* pData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[8]))((ID3D11Texture2D1*)Unsafe.AsPointer(ref this), guid, pDataSize, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[8]))((ID3D11Texture2D1*)Unsafe.AsPointer(ref this), guid, pDataSize, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(9)] + public HResult SetPrivateData(Guid* guid, uint DataSize, void* pData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[9]))((ID3D11Texture2D1*)Unsafe.AsPointer(ref this), guid, DataSize, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[9]))((ID3D11Texture2D1*)Unsafe.AsPointer(ref this), guid, DataSize, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(10)] + public HResult SetPrivateDataInterface(Guid* guid, IUnknown* pData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[10]))((ID3D11Texture2D1*)Unsafe.AsPointer(ref this), guid, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[10]))((ID3D11Texture2D1*)Unsafe.AsPointer(ref this), guid, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(11)] + public void GetDesc1(Texture2DDescription1* pDesc) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[11]))((ID3D11Texture2D1*)Unsafe.AsPointer(ref this), pDesc); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[11]))((ID3D11Texture2D1*)Unsafe.AsPointer(ref this), pDesc); +#endif + } + + public interface Interface : ID3D11Texture2D.Interface + { + } +} + +/// +/// ID3D11Texture3D1 +[Guid("0c711683-2853-4846-9bb0-f3e60639e46a")] +[NativeTypeName("struct ID3D11Texture3D1 : ID3D11Texture3D")] +[NativeInheritance("ID3D11Texture3D")] +public unsafe partial struct ID3D11Texture3D1 : ID3D11Texture3D1.Interface +{ + public static ref readonly Guid IID_ID3D11Texture3D1 + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x83, 0x16, 0x71, 0x0C, + 0x53, 0x28, + 0x46, 0x48, + 0x9B, + 0xB0, + 0xF3, + 0xE6, + 0x06, + 0x39, + 0xE4, + 0x6A + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_ID3D11Texture3D1)); + + public void** lpVtbl; + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(0)] + public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(1)] + [return: NativeTypeName("ULONG")] + public uint AddRef() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(2)] + [return: NativeTypeName("ULONG")] + public uint Release() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(3)] + public void GetDesc(Texture3DDescription* pDesc) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[3]))((ID3D11Texture3D1*)Unsafe.AsPointer(ref this), pDesc); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((ID3D11Texture3D1*)Unsafe.AsPointer(ref this), pDesc); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public void GetType(ResourceDimension* pResourceDimension) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[4]))((ID3D11Texture3D1*)Unsafe.AsPointer(ref this), pResourceDimension); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((ID3D11Texture3D1*)Unsafe.AsPointer(ref this), pResourceDimension); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(5)] + public void SetEvictionPriority(uint EvictionPriority) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[5]))((ID3D11Texture3D1*)Unsafe.AsPointer(ref this), EvictionPriority); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((ID3D11Texture3D1*)Unsafe.AsPointer(ref this), EvictionPriority); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(6)] + public uint GetEvictionPriority() + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[6]))((ID3D11Texture3D1*)Unsafe.AsPointer(ref this)); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((ID3D11Texture3D1*)Unsafe.AsPointer(ref this)); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(7)] + public void GetDevice(ID3D11Device* ppDevice) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[7]))((ID3D11Texture3D1*)Unsafe.AsPointer(ref this), ppDevice); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((ID3D11Texture3D1*)Unsafe.AsPointer(ref this), ppDevice); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(8)] + public HResult GetPrivateData(Guid* guid, uint* pDataSize, void* pData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[8]))((ID3D11Texture3D1*)Unsafe.AsPointer(ref this), guid, pDataSize, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[8]))((ID3D11Texture3D1*)Unsafe.AsPointer(ref this), guid, pDataSize, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(9)] + public HResult SetPrivateData(Guid* guid, uint DataSize, void* pData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[9]))((ID3D11Texture3D1*)Unsafe.AsPointer(ref this), guid, DataSize, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[9]))((ID3D11Texture3D1*)Unsafe.AsPointer(ref this), guid, DataSize, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(10)] + public HResult SetPrivateDataInterface(Guid* guid, IUnknown* pData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[10]))((ID3D11Texture3D1*)Unsafe.AsPointer(ref this), guid, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[10]))((ID3D11Texture3D1*)Unsafe.AsPointer(ref this), guid, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(11)] + public void GetDesc1(Texture3DDescription1* pDesc) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[11]))((ID3D11Texture3D1*)Unsafe.AsPointer(ref this), pDesc); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[11]))((ID3D11Texture3D1*)Unsafe.AsPointer(ref this), pDesc); +#endif + } + + public interface Interface : ID3D11Texture3D.Interface + { + } +} + +/// +/// ID3D11RasterizerState2 +[Guid("6fbd02fb-209f-46c4-b059-2ed15586a6ac")] +[NativeTypeName("struct ID3D11RasterizerState2 : ID3D11RasterizerState1")] +[NativeInheritance("ID3D11RasterizerState1")] +public unsafe partial struct ID3D11RasterizerState2 : ID3D11RasterizerState2.Interface +{ + public static ref readonly Guid IID_ID3D11RasterizerState2 + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0xFB, 0x02, 0xBD, 0x6F, + 0x9F, 0x20, + 0xC4, 0x46, + 0xB0, + 0x59, + 0x2E, + 0xD1, + 0x55, + 0x86, + 0xA6, + 0xAC + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_ID3D11RasterizerState2)); + + public void** lpVtbl; + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(0)] + public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(1)] + [return: NativeTypeName("ULONG")] + public uint AddRef() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(2)] + [return: NativeTypeName("ULONG")] + public uint Release() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(3)] + public void GetDesc1(RasterizerDescription1* pDesc) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[3]))((ID3D11RasterizerState2*)Unsafe.AsPointer(ref this), pDesc); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((ID3D11RasterizerState2*)Unsafe.AsPointer(ref this), pDesc); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public void GetDesc(RasterizerDescription* pDesc) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[4]))((ID3D11RasterizerState2*)Unsafe.AsPointer(ref this), pDesc); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((ID3D11RasterizerState2*)Unsafe.AsPointer(ref this), pDesc); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(5)] + public void GetDevice(ID3D11Device* ppDevice) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[5]))((ID3D11RasterizerState2*)Unsafe.AsPointer(ref this), ppDevice); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((ID3D11RasterizerState2*)Unsafe.AsPointer(ref this), ppDevice); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(6)] + public HResult GetPrivateData(Guid* guid, uint* pDataSize, void* pData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[6]))((ID3D11RasterizerState2*)Unsafe.AsPointer(ref this), guid, pDataSize, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((ID3D11RasterizerState2*)Unsafe.AsPointer(ref this), guid, pDataSize, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(7)] + public HResult SetPrivateData(Guid* guid, uint DataSize, void* pData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[7]))((ID3D11RasterizerState2*)Unsafe.AsPointer(ref this), guid, DataSize, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((ID3D11RasterizerState2*)Unsafe.AsPointer(ref this), guid, DataSize, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(8)] + public HResult SetPrivateDataInterface(Guid* guid, IUnknown* pData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[8]))((ID3D11RasterizerState2*)Unsafe.AsPointer(ref this), guid, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[8]))((ID3D11RasterizerState2*)Unsafe.AsPointer(ref this), guid, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(9)] + public void GetDesc2(RasterizerDescription2* pDesc) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[9]))((ID3D11RasterizerState2*)Unsafe.AsPointer(ref this), pDesc); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[9]))((ID3D11RasterizerState2*)Unsafe.AsPointer(ref this), pDesc); +#endif + } + + public interface Interface : ID3D11RasterizerState1.Interface + { + } +} + +/// +/// ID3D11ShaderResourceView1 +[Guid("91308b87-9040-411d-8c67-c39253ce3802")] +[NativeTypeName("struct ID3D11ShaderResourceView1 : ID3D11ShaderResourceView")] +[NativeInheritance("ID3D11ShaderResourceView")] +public unsafe partial struct ID3D11ShaderResourceView1 : ID3D11ShaderResourceView1.Interface +{ + public static ref readonly Guid IID_ID3D11ShaderResourceView1 + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x87, 0x8B, 0x30, 0x91, + 0x40, 0x90, + 0x1D, 0x41, + 0x8C, + 0x67, + 0xC3, + 0x92, + 0x53, + 0xCE, + 0x38, + 0x02 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_ID3D11ShaderResourceView1)); + + public void** lpVtbl; + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(0)] + public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(1)] + [return: NativeTypeName("ULONG")] + public uint AddRef() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(2)] + [return: NativeTypeName("ULONG")] + public uint Release() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(3)] + public void GetDesc(ShaderResourceViewDescription* pDesc) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[3]))((ID3D11ShaderResourceView1*)Unsafe.AsPointer(ref this), pDesc); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((ID3D11ShaderResourceView1*)Unsafe.AsPointer(ref this), pDesc); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public void GetResource(ID3D11Resource* ppResource) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[4]))((ID3D11ShaderResourceView1*)Unsafe.AsPointer(ref this), ppResource); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((ID3D11ShaderResourceView1*)Unsafe.AsPointer(ref this), ppResource); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(5)] + public void GetDevice(ID3D11Device* ppDevice) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[5]))((ID3D11ShaderResourceView1*)Unsafe.AsPointer(ref this), ppDevice); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((ID3D11ShaderResourceView1*)Unsafe.AsPointer(ref this), ppDevice); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(6)] + public HResult GetPrivateData(Guid* guid, uint* pDataSize, void* pData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[6]))((ID3D11ShaderResourceView1*)Unsafe.AsPointer(ref this), guid, pDataSize, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((ID3D11ShaderResourceView1*)Unsafe.AsPointer(ref this), guid, pDataSize, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(7)] + public HResult SetPrivateData(Guid* guid, uint DataSize, void* pData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[7]))((ID3D11ShaderResourceView1*)Unsafe.AsPointer(ref this), guid, DataSize, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((ID3D11ShaderResourceView1*)Unsafe.AsPointer(ref this), guid, DataSize, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(8)] + public HResult SetPrivateDataInterface(Guid* guid, IUnknown* pData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[8]))((ID3D11ShaderResourceView1*)Unsafe.AsPointer(ref this), guid, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[8]))((ID3D11ShaderResourceView1*)Unsafe.AsPointer(ref this), guid, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(9)] + public void GetDesc1(ShaderResourceViewDescription1* pDesc1) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[9]))((ID3D11ShaderResourceView1*)Unsafe.AsPointer(ref this), pDesc1); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[9]))((ID3D11ShaderResourceView1*)Unsafe.AsPointer(ref this), pDesc1); +#endif + } + + public interface Interface : ID3D11ShaderResourceView.Interface + { + } +} + +/// +/// ID3D11RenderTargetView1 +[Guid("ffbe2e23-f011-418a-ac56-5ceed7c5b94b")] +[NativeTypeName("struct ID3D11RenderTargetView1 : ID3D11RenderTargetView")] +[NativeInheritance("ID3D11RenderTargetView")] +public unsafe partial struct ID3D11RenderTargetView1 : ID3D11RenderTargetView1.Interface +{ + public static ref readonly Guid IID_ID3D11RenderTargetView1 + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x23, 0x2E, 0xBE, 0xFF, + 0x11, 0xF0, + 0x8A, 0x41, + 0xAC, + 0x56, + 0x5C, + 0xEE, + 0xD7, + 0xC5, + 0xB9, + 0x4B + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_ID3D11RenderTargetView1)); + + public void** lpVtbl; + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(0)] + public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(1)] + [return: NativeTypeName("ULONG")] + public uint AddRef() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(2)] + [return: NativeTypeName("ULONG")] + public uint Release() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(3)] + public void GetDesc(RenderTargetViewDescription* pDesc) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[3]))((ID3D11RenderTargetView1*)Unsafe.AsPointer(ref this), pDesc); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((ID3D11RenderTargetView1*)Unsafe.AsPointer(ref this), pDesc); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public void GetResource(ID3D11Resource* ppResource) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[4]))((ID3D11RenderTargetView1*)Unsafe.AsPointer(ref this), ppResource); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((ID3D11RenderTargetView1*)Unsafe.AsPointer(ref this), ppResource); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(5)] + public void GetDevice(ID3D11Device* ppDevice) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[5]))((ID3D11RenderTargetView1*)Unsafe.AsPointer(ref this), ppDevice); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((ID3D11RenderTargetView1*)Unsafe.AsPointer(ref this), ppDevice); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(6)] + public HResult GetPrivateData(Guid* guid, uint* pDataSize, void* pData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[6]))((ID3D11RenderTargetView1*)Unsafe.AsPointer(ref this), guid, pDataSize, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((ID3D11RenderTargetView1*)Unsafe.AsPointer(ref this), guid, pDataSize, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(7)] + public HResult SetPrivateData(Guid* guid, uint DataSize, void* pData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[7]))((ID3D11RenderTargetView1*)Unsafe.AsPointer(ref this), guid, DataSize, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((ID3D11RenderTargetView1*)Unsafe.AsPointer(ref this), guid, DataSize, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(8)] + public HResult SetPrivateDataInterface(Guid* guid, IUnknown* pData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[8]))((ID3D11RenderTargetView1*)Unsafe.AsPointer(ref this), guid, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[8]))((ID3D11RenderTargetView1*)Unsafe.AsPointer(ref this), guid, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(9)] + public void GetDesc1(RenderTargetViewDescription1* pDesc1) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[9]))((ID3D11RenderTargetView1*)Unsafe.AsPointer(ref this), pDesc1); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[9]))((ID3D11RenderTargetView1*)Unsafe.AsPointer(ref this), pDesc1); +#endif + } + + public interface Interface : ID3D11RenderTargetView.Interface + { + } +} + +/// +/// ID3D11UnorderedAccessView1 +[Guid("7b3b6153-a886-4544-ab37-6537c8500403")] +[NativeTypeName("struct ID3D11UnorderedAccessView1 : ID3D11UnorderedAccessView")] +[NativeInheritance("ID3D11UnorderedAccessView")] +public unsafe partial struct ID3D11UnorderedAccessView1 : ID3D11UnorderedAccessView1.Interface +{ + public static ref readonly Guid IID_ID3D11UnorderedAccessView1 + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x53, 0x61, 0x3B, 0x7B, + 0x86, 0xA8, + 0x44, 0x45, + 0xAB, + 0x37, + 0x65, + 0x37, + 0xC8, + 0x50, + 0x04, + 0x03 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_ID3D11UnorderedAccessView1)); + + public void** lpVtbl; + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(0)] + public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(1)] + [return: NativeTypeName("ULONG")] + public uint AddRef() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(2)] + [return: NativeTypeName("ULONG")] + public uint Release() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(3)] + public void GetDesc(UnorderedAccessViewDescription* pDesc) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[3]))((ID3D11UnorderedAccessView1*)Unsafe.AsPointer(ref this), pDesc); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((ID3D11UnorderedAccessView1*)Unsafe.AsPointer(ref this), pDesc); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public void GetResource(ID3D11Resource* ppResource) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[4]))((ID3D11UnorderedAccessView1*)Unsafe.AsPointer(ref this), ppResource); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((ID3D11UnorderedAccessView1*)Unsafe.AsPointer(ref this), ppResource); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(5)] + public void GetDevice(ID3D11Device* ppDevice) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[5]))((ID3D11UnorderedAccessView1*)Unsafe.AsPointer(ref this), ppDevice); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((ID3D11UnorderedAccessView1*)Unsafe.AsPointer(ref this), ppDevice); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(6)] + public HResult GetPrivateData(Guid* guid, uint* pDataSize, void* pData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[6]))((ID3D11UnorderedAccessView1*)Unsafe.AsPointer(ref this), guid, pDataSize, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((ID3D11UnorderedAccessView1*)Unsafe.AsPointer(ref this), guid, pDataSize, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(7)] + public HResult SetPrivateData(Guid* guid, uint DataSize, void* pData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[7]))((ID3D11UnorderedAccessView1*)Unsafe.AsPointer(ref this), guid, DataSize, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((ID3D11UnorderedAccessView1*)Unsafe.AsPointer(ref this), guid, DataSize, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(8)] + public HResult SetPrivateDataInterface(Guid* guid, IUnknown* pData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[8]))((ID3D11UnorderedAccessView1*)Unsafe.AsPointer(ref this), guid, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[8]))((ID3D11UnorderedAccessView1*)Unsafe.AsPointer(ref this), guid, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(9)] + public void GetDesc1(UnorderedAccessViewDescription1* pDesc1) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[9]))((ID3D11UnorderedAccessView1*)Unsafe.AsPointer(ref this), pDesc1); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[9]))((ID3D11UnorderedAccessView1*)Unsafe.AsPointer(ref this), pDesc1); +#endif + } + + public interface Interface : ID3D11UnorderedAccessView.Interface + { + } +} + +/// +/// ID3D11Query1 +[Guid("631b4766-36dc-461d-8db6-c47e13e60916")] +[NativeTypeName("struct ID3D11Query1 : ID3D11Query")] +[NativeInheritance("ID3D11Query")] +public unsafe partial struct ID3D11Query1 : ID3D11Query1.Interface +{ + public static ref readonly Guid IID_ID3D11Query1 + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x66, 0x47, 0x1B, 0x63, + 0xDC, 0x36, + 0x1D, 0x46, + 0x8D, + 0xB6, + 0xC4, + 0x7E, + 0x13, + 0xE6, + 0x09, + 0x16 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_ID3D11Query1)); + + public void** lpVtbl; + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(0)] + public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(1)] + [return: NativeTypeName("ULONG")] + public uint AddRef() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(2)] + [return: NativeTypeName("ULONG")] + public uint Release() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(3)] + public void GetDesc(QueryDescription* pDesc) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[3]))((ID3D11Query1*)Unsafe.AsPointer(ref this), pDesc); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((ID3D11Query1*)Unsafe.AsPointer(ref this), pDesc); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public uint GetDataSize() + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[4]))((ID3D11Query1*)Unsafe.AsPointer(ref this)); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((ID3D11Query1*)Unsafe.AsPointer(ref this)); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(5)] + public void GetDevice(ID3D11Device* ppDevice) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[5]))((ID3D11Query1*)Unsafe.AsPointer(ref this), ppDevice); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((ID3D11Query1*)Unsafe.AsPointer(ref this), ppDevice); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(6)] + public HResult GetPrivateData(Guid* guid, uint* pDataSize, void* pData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[6]))((ID3D11Query1*)Unsafe.AsPointer(ref this), guid, pDataSize, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((ID3D11Query1*)Unsafe.AsPointer(ref this), guid, pDataSize, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(7)] + public HResult SetPrivateData(Guid* guid, uint DataSize, void* pData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[7]))((ID3D11Query1*)Unsafe.AsPointer(ref this), guid, DataSize, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((ID3D11Query1*)Unsafe.AsPointer(ref this), guid, DataSize, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(8)] + public HResult SetPrivateDataInterface(Guid* guid, IUnknown* pData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[8]))((ID3D11Query1*)Unsafe.AsPointer(ref this), guid, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[8]))((ID3D11Query1*)Unsafe.AsPointer(ref this), guid, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(9)] + public void GetDesc1(QueryDescription1* pDesc1) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[9]))((ID3D11Query1*)Unsafe.AsPointer(ref this), pDesc1); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[9]))((ID3D11Query1*)Unsafe.AsPointer(ref this), pDesc1); +#endif + } + + public interface Interface : ID3D11Query.Interface + { + } +} + +/// +/// ID3D11DeviceContext3 +[Guid("b4e3c01d-e79e-4637-91b2-510e9f4c9b8f")] +[NativeTypeName("struct ID3D11DeviceContext3 : ID3D11DeviceContext2")] +[NativeInheritance("ID3D11DeviceContext2")] +public unsafe partial struct ID3D11DeviceContext3 : ID3D11DeviceContext3.Interface +{ + public static ref readonly Guid IID_ID3D11DeviceContext3 + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x1D, 0xC0, 0xE3, 0xB4, + 0x9E, 0xE7, + 0x37, 0x46, + 0x91, + 0xB2, + 0x51, + 0x0E, + 0x9F, + 0x4C, + 0x9B, + 0x8F + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_ID3D11DeviceContext3)); + + public void** lpVtbl; + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(0)] + public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(1)] + [return: NativeTypeName("ULONG")] + public uint AddRef() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(2)] + [return: NativeTypeName("ULONG")] + public uint Release() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(3)] + public HResult UpdateTileMappings(ID3D11Resource* pTiledResource, uint NumTiledResourceRegions, TiledResourceCoordinate* pTiledResourceRegionStartCoordinates, TileRegionSize* pTiledResourceRegionSizes, ID3D11Buffer* pTilePool, uint NumRanges, uint* pRangeFlags, uint* pTilePoolStartOffsets, uint* pRangeTileCounts, uint Flags) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[3]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this), pTiledResource, NumTiledResourceRegions, pTiledResourceRegionStartCoordinates, pTiledResourceRegionSizes, pTilePool, NumRanges, pRangeFlags, pTilePoolStartOffsets, pRangeTileCounts, Flags); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this), pTiledResource, NumTiledResourceRegions, pTiledResourceRegionStartCoordinates, pTiledResourceRegionSizes, pTilePool, NumRanges, pRangeFlags, pTilePoolStartOffsets, pRangeTileCounts, Flags); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public HResult CopyTileMappings(ID3D11Resource* pDestTiledResource, TiledResourceCoordinate* pDestRegionStartCoordinate, ID3D11Resource* pSourceTiledResource, TiledResourceCoordinate* pSourceRegionStartCoordinate, TileRegionSize* pTileRegionSize, uint Flags) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[4]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this), pDestTiledResource, pDestRegionStartCoordinate, pSourceTiledResource, pSourceRegionStartCoordinate, pTileRegionSize, Flags); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this), pDestTiledResource, pDestRegionStartCoordinate, pSourceTiledResource, pSourceRegionStartCoordinate, pTileRegionSize, Flags); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(5)] + public void CopyTiles(ID3D11Resource* pTiledResource, TiledResourceCoordinate* pTileRegionStartCoordinate, TileRegionSize* pTileRegionSize, ID3D11Buffer* pBuffer, ulong BufferStartOffsetInBytes, uint Flags) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[5]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this), pTiledResource, pTileRegionStartCoordinate, pTileRegionSize, pBuffer, BufferStartOffsetInBytes, Flags); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this), pTiledResource, pTileRegionStartCoordinate, pTileRegionSize, pBuffer, BufferStartOffsetInBytes, Flags); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(6)] + public void UpdateTiles(ID3D11Resource* pDestTiledResource, TiledResourceCoordinate* pDestTileRegionStartCoordinate, TileRegionSize* pDestTileRegionSize, void* pSourceTileData, uint Flags) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[6]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this), pDestTiledResource, pDestTileRegionStartCoordinate, pDestTileRegionSize, pSourceTileData, Flags); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this), pDestTiledResource, pDestTileRegionStartCoordinate, pDestTileRegionSize, pSourceTileData, Flags); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(7)] + public HResult ResizeTilePool(ID3D11Buffer* pTilePool, ulong NewSizeInBytes) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[7]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this), pTilePool, NewSizeInBytes); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this), pTilePool, NewSizeInBytes); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(8)] + public void TiledResourceBarrier(ID3D11DeviceChild* pTiledResourceOrViewAccessBeforeBarrier, ID3D11DeviceChild* pTiledResourceOrViewAccessAfterBarrier) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[8]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this), pTiledResourceOrViewAccessBeforeBarrier, pTiledResourceOrViewAccessAfterBarrier); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[8]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this), pTiledResourceOrViewAccessBeforeBarrier, pTiledResourceOrViewAccessAfterBarrier); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(9)] + public Bool32 IsAnnotationEnabled() + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[9]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this)); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[9]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this)); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(10)] + public void SetMarkerInt(char** pLabel, int Data) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[10]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this), pLabel, Data); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[10]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this), pLabel, Data); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(11)] + public void BeginEventInt(char** pLabel, int Data) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[11]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this), pLabel, Data); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[11]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this), pLabel, Data); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(12)] + public void EndEvent() + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[12]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this)); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[12]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this)); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(13)] + public void CopySubresourceRegion1(ID3D11Resource* pDstResource, uint DstSubresource, uint DstX, uint DstY, uint DstZ, ID3D11Resource* pSrcResource, uint SrcSubresource, Box* pSrcBox, uint CopyFlags) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[13]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this), pDstResource, DstSubresource, DstX, DstY, DstZ, pSrcResource, SrcSubresource, pSrcBox, CopyFlags); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[13]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this), pDstResource, DstSubresource, DstX, DstY, DstZ, pSrcResource, SrcSubresource, pSrcBox, CopyFlags); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(14)] + public void UpdateSubresource1(ID3D11Resource* pDstResource, uint DstSubresource, Box* pDstBox, void* pSrcData, uint SrcRowPitch, uint SrcDepthPitch, uint CopyFlags) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[14]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this), pDstResource, DstSubresource, pDstBox, pSrcData, SrcRowPitch, SrcDepthPitch, CopyFlags); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[14]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this), pDstResource, DstSubresource, pDstBox, pSrcData, SrcRowPitch, SrcDepthPitch, CopyFlags); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(15)] + public void DiscardResource(ID3D11Resource* pResource) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[15]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this), pResource); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[15]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this), pResource); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(16)] + public void DiscardView(ID3D11View* pResourceView) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[16]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this), pResourceView); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[16]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this), pResourceView); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(17)] + public void VSSetConstantBuffers1(uint StartSlot, uint NumBuffers, ID3D11Buffer* ppConstantBuffers, uint* pFirstConstant, uint* pNumConstants) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[17]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this), StartSlot, NumBuffers, ppConstantBuffers, pFirstConstant, pNumConstants); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[17]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this), StartSlot, NumBuffers, ppConstantBuffers, pFirstConstant, pNumConstants); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(18)] + public void HSSetConstantBuffers1(uint StartSlot, uint NumBuffers, ID3D11Buffer* ppConstantBuffers, uint* pFirstConstant, uint* pNumConstants) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[18]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this), StartSlot, NumBuffers, ppConstantBuffers, pFirstConstant, pNumConstants); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[18]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this), StartSlot, NumBuffers, ppConstantBuffers, pFirstConstant, pNumConstants); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(19)] + public void DSSetConstantBuffers1(uint StartSlot, uint NumBuffers, ID3D11Buffer* ppConstantBuffers, uint* pFirstConstant, uint* pNumConstants) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[19]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this), StartSlot, NumBuffers, ppConstantBuffers, pFirstConstant, pNumConstants); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[19]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this), StartSlot, NumBuffers, ppConstantBuffers, pFirstConstant, pNumConstants); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(20)] + public void GSSetConstantBuffers1(uint StartSlot, uint NumBuffers, ID3D11Buffer* ppConstantBuffers, uint* pFirstConstant, uint* pNumConstants) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[20]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this), StartSlot, NumBuffers, ppConstantBuffers, pFirstConstant, pNumConstants); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[20]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this), StartSlot, NumBuffers, ppConstantBuffers, pFirstConstant, pNumConstants); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(21)] + public void PSSetConstantBuffers1(uint StartSlot, uint NumBuffers, ID3D11Buffer* ppConstantBuffers, uint* pFirstConstant, uint* pNumConstants) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[21]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this), StartSlot, NumBuffers, ppConstantBuffers, pFirstConstant, pNumConstants); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[21]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this), StartSlot, NumBuffers, ppConstantBuffers, pFirstConstant, pNumConstants); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(22)] + public void CSSetConstantBuffers1(uint StartSlot, uint NumBuffers, ID3D11Buffer* ppConstantBuffers, uint* pFirstConstant, uint* pNumConstants) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[22]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this), StartSlot, NumBuffers, ppConstantBuffers, pFirstConstant, pNumConstants); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[22]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this), StartSlot, NumBuffers, ppConstantBuffers, pFirstConstant, pNumConstants); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(23)] + public void VSGetConstantBuffers1(uint StartSlot, uint NumBuffers, ID3D11Buffer* ppConstantBuffers, uint* pFirstConstant, uint* pNumConstants) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[23]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this), StartSlot, NumBuffers, ppConstantBuffers, pFirstConstant, pNumConstants); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[23]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this), StartSlot, NumBuffers, ppConstantBuffers, pFirstConstant, pNumConstants); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(24)] + public void HSGetConstantBuffers1(uint StartSlot, uint NumBuffers, ID3D11Buffer* ppConstantBuffers, uint* pFirstConstant, uint* pNumConstants) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[24]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this), StartSlot, NumBuffers, ppConstantBuffers, pFirstConstant, pNumConstants); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[24]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this), StartSlot, NumBuffers, ppConstantBuffers, pFirstConstant, pNumConstants); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(25)] + public void DSGetConstantBuffers1(uint StartSlot, uint NumBuffers, ID3D11Buffer* ppConstantBuffers, uint* pFirstConstant, uint* pNumConstants) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[25]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this), StartSlot, NumBuffers, ppConstantBuffers, pFirstConstant, pNumConstants); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[25]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this), StartSlot, NumBuffers, ppConstantBuffers, pFirstConstant, pNumConstants); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(26)] + public void GSGetConstantBuffers1(uint StartSlot, uint NumBuffers, ID3D11Buffer* ppConstantBuffers, uint* pFirstConstant, uint* pNumConstants) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[26]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this), StartSlot, NumBuffers, ppConstantBuffers, pFirstConstant, pNumConstants); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[26]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this), StartSlot, NumBuffers, ppConstantBuffers, pFirstConstant, pNumConstants); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(27)] + public void PSGetConstantBuffers1(uint StartSlot, uint NumBuffers, ID3D11Buffer* ppConstantBuffers, uint* pFirstConstant, uint* pNumConstants) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[27]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this), StartSlot, NumBuffers, ppConstantBuffers, pFirstConstant, pNumConstants); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[27]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this), StartSlot, NumBuffers, ppConstantBuffers, pFirstConstant, pNumConstants); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(28)] + public void CSGetConstantBuffers1(uint StartSlot, uint NumBuffers, ID3D11Buffer* ppConstantBuffers, uint* pFirstConstant, uint* pNumConstants) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[28]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this), StartSlot, NumBuffers, ppConstantBuffers, pFirstConstant, pNumConstants); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[28]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this), StartSlot, NumBuffers, ppConstantBuffers, pFirstConstant, pNumConstants); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(29)] + public void SwapDeviceContextState(ID3DDeviceContextState* pState, ID3DDeviceContextState* ppPreviousState) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[29]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this), pState, ppPreviousState); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[29]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this), pState, ppPreviousState); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(30)] + public void ClearView(ID3D11View* pView, float* Color, RawRect* pRect, uint NumRects) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[30]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this), pView, Color, pRect, NumRects); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[30]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this), pView, Color, pRect, NumRects); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(31)] + public void DiscardView1(ID3D11View* pResourceView, RawRect* pRects, uint NumRects) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[31]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this), pResourceView, pRects, NumRects); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[31]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this), pResourceView, pRects, NumRects); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(32)] + public void VSSetConstantBuffers(uint StartSlot, uint NumBuffers, ID3D11Buffer* ppConstantBuffers) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[32]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this), StartSlot, NumBuffers, ppConstantBuffers); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[32]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this), StartSlot, NumBuffers, ppConstantBuffers); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(33)] + public void PSSetShaderResources(uint StartSlot, uint NumViews, ID3D11ShaderResourceView* ppShaderResourceViews) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[33]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this), StartSlot, NumViews, ppShaderResourceViews); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[33]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this), StartSlot, NumViews, ppShaderResourceViews); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(34)] + public void PSSetShader(ID3D11PixelShader* pPixelShader, ID3D11ClassInstance* ppClassInstances, uint NumClassInstances) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[34]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this), pPixelShader, ppClassInstances, NumClassInstances); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[34]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this), pPixelShader, ppClassInstances, NumClassInstances); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(35)] + public void PSSetSamplers(uint StartSlot, uint NumSamplers, ID3D11SamplerState* ppSamplers) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[35]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this), StartSlot, NumSamplers, ppSamplers); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[35]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this), StartSlot, NumSamplers, ppSamplers); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(36)] + public void VSSetShader(ID3D11VertexShader* pVertexShader, ID3D11ClassInstance* ppClassInstances, uint NumClassInstances) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[36]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this), pVertexShader, ppClassInstances, NumClassInstances); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[36]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this), pVertexShader, ppClassInstances, NumClassInstances); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(37)] + public void DrawIndexed(uint IndexCount, uint StartIndexLocation, int BaseVertexLocation) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[37]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this), IndexCount, StartIndexLocation, BaseVertexLocation); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[37]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this), IndexCount, StartIndexLocation, BaseVertexLocation); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(38)] + public void Draw(uint VertexCount, uint StartVertexLocation) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[38]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this), VertexCount, StartVertexLocation); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[38]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this), VertexCount, StartVertexLocation); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(39)] + public HResult Map(ID3D11Resource* pResource, uint Subresource, Map MapType, uint MapFlags, MappedSubresource* pMappedResource) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[39]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this), pResource, Subresource, MapType, MapFlags, pMappedResource); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[39]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this), pResource, Subresource, MapType, MapFlags, pMappedResource); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(40)] + public void Unmap(ID3D11Resource* pResource, uint Subresource) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[40]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this), pResource, Subresource); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[40]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this), pResource, Subresource); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(41)] + public void PSSetConstantBuffers(uint StartSlot, uint NumBuffers, ID3D11Buffer* ppConstantBuffers) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[41]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this), StartSlot, NumBuffers, ppConstantBuffers); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[41]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this), StartSlot, NumBuffers, ppConstantBuffers); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(42)] + public void IASetInputLayout(ID3D11InputLayout* pInputLayout) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[42]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this), pInputLayout); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[42]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this), pInputLayout); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(43)] + public void IASetVertexBuffers(uint StartSlot, uint NumBuffers, ID3D11Buffer* ppVertexBuffers, uint* pStrides, uint* pOffsets) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[43]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this), StartSlot, NumBuffers, ppVertexBuffers, pStrides, pOffsets); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[43]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this), StartSlot, NumBuffers, ppVertexBuffers, pStrides, pOffsets); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(44)] + public void IASetIndexBuffer(ID3D11Buffer* pIndexBuffer, Graphics.Dxgi.Common.Format Format, uint Offset) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[44]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this), pIndexBuffer, Format, Offset); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[44]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this), pIndexBuffer, Format, Offset); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(45)] + public void DrawIndexedInstanced(uint IndexCountPerInstance, uint InstanceCount, uint StartIndexLocation, int BaseVertexLocation, uint StartInstanceLocation) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[45]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this), IndexCountPerInstance, InstanceCount, StartIndexLocation, BaseVertexLocation, StartInstanceLocation); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[45]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this), IndexCountPerInstance, InstanceCount, StartIndexLocation, BaseVertexLocation, StartInstanceLocation); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(46)] + public void DrawInstanced(uint VertexCountPerInstance, uint InstanceCount, uint StartVertexLocation, uint StartInstanceLocation) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[46]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this), VertexCountPerInstance, InstanceCount, StartVertexLocation, StartInstanceLocation); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[46]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this), VertexCountPerInstance, InstanceCount, StartVertexLocation, StartInstanceLocation); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(47)] + public void GSSetConstantBuffers(uint StartSlot, uint NumBuffers, ID3D11Buffer* ppConstantBuffers) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[47]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this), StartSlot, NumBuffers, ppConstantBuffers); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[47]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this), StartSlot, NumBuffers, ppConstantBuffers); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(48)] + public void GSSetShader(ID3D11GeometryShader* pShader, ID3D11ClassInstance* ppClassInstances, uint NumClassInstances) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[48]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this), pShader, ppClassInstances, NumClassInstances); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[48]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this), pShader, ppClassInstances, NumClassInstances); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(49)] + public void IASetPrimitiveTopology(Graphics.Direct3D.PrimitiveTopology Topology) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[49]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this), Topology); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[49]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this), Topology); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(50)] + public void VSSetShaderResources(uint StartSlot, uint NumViews, ID3D11ShaderResourceView* ppShaderResourceViews) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[50]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this), StartSlot, NumViews, ppShaderResourceViews); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[50]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this), StartSlot, NumViews, ppShaderResourceViews); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(51)] + public void VSSetSamplers(uint StartSlot, uint NumSamplers, ID3D11SamplerState* ppSamplers) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[51]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this), StartSlot, NumSamplers, ppSamplers); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[51]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this), StartSlot, NumSamplers, ppSamplers); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(52)] + public void Begin(ID3D11Asynchronous* pAsync) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[52]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this), pAsync); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[52]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this), pAsync); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(53)] + public void End(ID3D11Asynchronous* pAsync) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[53]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this), pAsync); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[53]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this), pAsync); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(54)] + public HResult GetData(ID3D11Asynchronous* pAsync, void* pData, uint DataSize, uint GetDataFlags) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[54]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this), pAsync, pData, DataSize, GetDataFlags); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[54]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this), pAsync, pData, DataSize, GetDataFlags); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(55)] + public void SetPredication(ID3D11Predicate* pPredicate, Bool32* PredicateValue) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[55]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this), pPredicate, PredicateValue); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[55]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this), pPredicate, PredicateValue); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(56)] + public void GSSetShaderResources(uint StartSlot, uint NumViews, ID3D11ShaderResourceView* ppShaderResourceViews) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[56]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this), StartSlot, NumViews, ppShaderResourceViews); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[56]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this), StartSlot, NumViews, ppShaderResourceViews); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(57)] + public void GSSetSamplers(uint StartSlot, uint NumSamplers, ID3D11SamplerState* ppSamplers) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[57]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this), StartSlot, NumSamplers, ppSamplers); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[57]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this), StartSlot, NumSamplers, ppSamplers); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(58)] + public void OMSetRenderTargets(uint NumViews, ID3D11RenderTargetView* ppRenderTargetViews, ID3D11DepthStencilView* pDepthStencilView) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[58]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this), NumViews, ppRenderTargetViews, pDepthStencilView); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[58]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this), NumViews, ppRenderTargetViews, pDepthStencilView); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(59)] + public void OMSetRenderTargetsAndUnorderedAccessViews(uint NumRTVs, ID3D11RenderTargetView* ppRenderTargetViews, ID3D11DepthStencilView* pDepthStencilView, uint UAVStartSlot, uint NumUAVs, ID3D11UnorderedAccessView* ppUnorderedAccessViews, uint* pUAVInitialCounts) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[59]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this), NumRTVs, ppRenderTargetViews, pDepthStencilView, UAVStartSlot, NumUAVs, ppUnorderedAccessViews, pUAVInitialCounts); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[59]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this), NumRTVs, ppRenderTargetViews, pDepthStencilView, UAVStartSlot, NumUAVs, ppUnorderedAccessViews, pUAVInitialCounts); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(60)] + public void OMSetBlendState(ID3D11BlendState* pBlendState, float* BlendFactor, uint SampleMask) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[60]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this), pBlendState, BlendFactor, SampleMask); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[60]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this), pBlendState, BlendFactor, SampleMask); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(61)] + public void OMSetDepthStencilState(ID3D11DepthStencilState* pDepthStencilState, uint StencilRef) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[61]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this), pDepthStencilState, StencilRef); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[61]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this), pDepthStencilState, StencilRef); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(62)] + public void SOSetTargets(uint NumBuffers, ID3D11Buffer* ppSOTargets, uint* pOffsets) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[62]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this), NumBuffers, ppSOTargets, pOffsets); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[62]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this), NumBuffers, ppSOTargets, pOffsets); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(63)] + public void DrawAuto() + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[63]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this)); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[63]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this)); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(64)] + public void DrawIndexedInstancedIndirect(ID3D11Buffer* pBufferForArgs, uint AlignedByteOffsetForArgs) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[64]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this), pBufferForArgs, AlignedByteOffsetForArgs); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[64]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this), pBufferForArgs, AlignedByteOffsetForArgs); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(65)] + public void DrawInstancedIndirect(ID3D11Buffer* pBufferForArgs, uint AlignedByteOffsetForArgs) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[65]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this), pBufferForArgs, AlignedByteOffsetForArgs); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[65]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this), pBufferForArgs, AlignedByteOffsetForArgs); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(66)] + public void Dispatch(uint ThreadGroupCountX, uint ThreadGroupCountY, uint ThreadGroupCountZ) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[66]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this), ThreadGroupCountX, ThreadGroupCountY, ThreadGroupCountZ); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[66]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this), ThreadGroupCountX, ThreadGroupCountY, ThreadGroupCountZ); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(67)] + public void DispatchIndirect(ID3D11Buffer* pBufferForArgs, uint AlignedByteOffsetForArgs) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[67]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this), pBufferForArgs, AlignedByteOffsetForArgs); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[67]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this), pBufferForArgs, AlignedByteOffsetForArgs); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(68)] + public void RSSetState(ID3D11RasterizerState* pRasterizerState) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[68]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this), pRasterizerState); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[68]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this), pRasterizerState); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(69)] + public void RSSetViewports(uint NumViewports, Viewport* pViewports) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[69]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this), NumViewports, pViewports); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[69]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this), NumViewports, pViewports); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(70)] + public void RSSetScissorRects(uint NumRects, RawRect* pRects) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[70]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this), NumRects, pRects); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[70]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this), NumRects, pRects); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(71)] + public void CopySubresourceRegion(ID3D11Resource* pDstResource, uint DstSubresource, uint DstX, uint DstY, uint DstZ, ID3D11Resource* pSrcResource, uint SrcSubresource, Box* pSrcBox) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[71]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this), pDstResource, DstSubresource, DstX, DstY, DstZ, pSrcResource, SrcSubresource, pSrcBox); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[71]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this), pDstResource, DstSubresource, DstX, DstY, DstZ, pSrcResource, SrcSubresource, pSrcBox); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(72)] + public void CopyResource(ID3D11Resource* pDstResource, ID3D11Resource* pSrcResource) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[72]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this), pDstResource, pSrcResource); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[72]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this), pDstResource, pSrcResource); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(73)] + public void UpdateSubresource(ID3D11Resource* pDstResource, uint DstSubresource, Box* pDstBox, void* pSrcData, uint SrcRowPitch, uint SrcDepthPitch) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[73]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this), pDstResource, DstSubresource, pDstBox, pSrcData, SrcRowPitch, SrcDepthPitch); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[73]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this), pDstResource, DstSubresource, pDstBox, pSrcData, SrcRowPitch, SrcDepthPitch); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(74)] + public void CopyStructureCount(ID3D11Buffer* pDstBuffer, uint DstAlignedByteOffset, ID3D11UnorderedAccessView* pSrcView) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[74]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this), pDstBuffer, DstAlignedByteOffset, pSrcView); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[74]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this), pDstBuffer, DstAlignedByteOffset, pSrcView); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(75)] + public void ClearRenderTargetView(ID3D11RenderTargetView* pRenderTargetView, float* ColorRGBA) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[75]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this), pRenderTargetView, ColorRGBA); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[75]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this), pRenderTargetView, ColorRGBA); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(76)] + public void ClearUnorderedAccessViewUint(ID3D11UnorderedAccessView* pUnorderedAccessView, uint* Values) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[76]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this), pUnorderedAccessView, Values); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[76]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this), pUnorderedAccessView, Values); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(77)] + public void ClearUnorderedAccessViewFloat(ID3D11UnorderedAccessView* pUnorderedAccessView, float* Values) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[77]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this), pUnorderedAccessView, Values); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[77]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this), pUnorderedAccessView, Values); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(78)] + public void ClearDepthStencilView(ID3D11DepthStencilView* pDepthStencilView, uint ClearFlags, float Depth, byte Stencil) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[78]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this), pDepthStencilView, ClearFlags, Depth, Stencil); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[78]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this), pDepthStencilView, ClearFlags, Depth, Stencil); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(79)] + public void GenerateMips(ID3D11ShaderResourceView* pShaderResourceView) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[79]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this), pShaderResourceView); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[79]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this), pShaderResourceView); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(80)] + public void SetResourceMinLOD(ID3D11Resource* pResource, float MinLOD) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[80]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this), pResource, MinLOD); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[80]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this), pResource, MinLOD); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(81)] + public float GetResourceMinLOD(ID3D11Resource* pResource) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[81]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this), pResource); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[81]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this), pResource); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(82)] + public void ResolveSubresource(ID3D11Resource* pDstResource, uint DstSubresource, ID3D11Resource* pSrcResource, uint SrcSubresource, Graphics.Dxgi.Common.Format Format) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[82]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this), pDstResource, DstSubresource, pSrcResource, SrcSubresource, Format); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[82]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this), pDstResource, DstSubresource, pSrcResource, SrcSubresource, Format); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(83)] + public void ExecuteCommandList(ID3D11CommandList* pCommandList, Bool32* RestoreContextState) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[83]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this), pCommandList, RestoreContextState); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[83]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this), pCommandList, RestoreContextState); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(84)] + public void HSSetShaderResources(uint StartSlot, uint NumViews, ID3D11ShaderResourceView* ppShaderResourceViews) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[84]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this), StartSlot, NumViews, ppShaderResourceViews); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[84]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this), StartSlot, NumViews, ppShaderResourceViews); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(85)] + public void HSSetShader(ID3D11HullShader* pHullShader, ID3D11ClassInstance* ppClassInstances, uint NumClassInstances) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[85]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this), pHullShader, ppClassInstances, NumClassInstances); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[85]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this), pHullShader, ppClassInstances, NumClassInstances); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(86)] + public void HSSetSamplers(uint StartSlot, uint NumSamplers, ID3D11SamplerState* ppSamplers) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[86]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this), StartSlot, NumSamplers, ppSamplers); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[86]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this), StartSlot, NumSamplers, ppSamplers); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(87)] + public void HSSetConstantBuffers(uint StartSlot, uint NumBuffers, ID3D11Buffer* ppConstantBuffers) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[87]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this), StartSlot, NumBuffers, ppConstantBuffers); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[87]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this), StartSlot, NumBuffers, ppConstantBuffers); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(88)] + public void DSSetShaderResources(uint StartSlot, uint NumViews, ID3D11ShaderResourceView* ppShaderResourceViews) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[88]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this), StartSlot, NumViews, ppShaderResourceViews); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[88]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this), StartSlot, NumViews, ppShaderResourceViews); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(89)] + public void DSSetShader(ID3D11DomainShader* pDomainShader, ID3D11ClassInstance* ppClassInstances, uint NumClassInstances) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[89]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this), pDomainShader, ppClassInstances, NumClassInstances); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[89]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this), pDomainShader, ppClassInstances, NumClassInstances); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(90)] + public void DSSetSamplers(uint StartSlot, uint NumSamplers, ID3D11SamplerState* ppSamplers) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[90]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this), StartSlot, NumSamplers, ppSamplers); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[90]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this), StartSlot, NumSamplers, ppSamplers); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(91)] + public void DSSetConstantBuffers(uint StartSlot, uint NumBuffers, ID3D11Buffer* ppConstantBuffers) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[91]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this), StartSlot, NumBuffers, ppConstantBuffers); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[91]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this), StartSlot, NumBuffers, ppConstantBuffers); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(92)] + public void CSSetShaderResources(uint StartSlot, uint NumViews, ID3D11ShaderResourceView* ppShaderResourceViews) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[92]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this), StartSlot, NumViews, ppShaderResourceViews); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[92]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this), StartSlot, NumViews, ppShaderResourceViews); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(93)] + public void CSSetUnorderedAccessViews(uint StartSlot, uint NumUAVs, ID3D11UnorderedAccessView* ppUnorderedAccessViews, uint* pUAVInitialCounts) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[93]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this), StartSlot, NumUAVs, ppUnorderedAccessViews, pUAVInitialCounts); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[93]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this), StartSlot, NumUAVs, ppUnorderedAccessViews, pUAVInitialCounts); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(94)] + public void CSSetShader(ID3D11ComputeShader* pComputeShader, ID3D11ClassInstance* ppClassInstances, uint NumClassInstances) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[94]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this), pComputeShader, ppClassInstances, NumClassInstances); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[94]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this), pComputeShader, ppClassInstances, NumClassInstances); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(95)] + public void CSSetSamplers(uint StartSlot, uint NumSamplers, ID3D11SamplerState* ppSamplers) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[95]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this), StartSlot, NumSamplers, ppSamplers); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[95]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this), StartSlot, NumSamplers, ppSamplers); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(96)] + public void CSSetConstantBuffers(uint StartSlot, uint NumBuffers, ID3D11Buffer* ppConstantBuffers) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[96]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this), StartSlot, NumBuffers, ppConstantBuffers); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[96]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this), StartSlot, NumBuffers, ppConstantBuffers); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(97)] + public void VSGetConstantBuffers(uint StartSlot, uint NumBuffers, ID3D11Buffer* ppConstantBuffers) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[97]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this), StartSlot, NumBuffers, ppConstantBuffers); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[97]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this), StartSlot, NumBuffers, ppConstantBuffers); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(98)] + public void PSGetShaderResources(uint StartSlot, uint NumViews, ID3D11ShaderResourceView* ppShaderResourceViews) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[98]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this), StartSlot, NumViews, ppShaderResourceViews); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[98]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this), StartSlot, NumViews, ppShaderResourceViews); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(99)] + public void PSGetShader(ID3D11PixelShader* ppPixelShader, ID3D11ClassInstance* ppClassInstances, uint* pNumClassInstances) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[99]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this), ppPixelShader, ppClassInstances, pNumClassInstances); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[99]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this), ppPixelShader, ppClassInstances, pNumClassInstances); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(100)] + public void PSGetSamplers(uint StartSlot, uint NumSamplers, ID3D11SamplerState* ppSamplers) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[100]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this), StartSlot, NumSamplers, ppSamplers); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[100]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this), StartSlot, NumSamplers, ppSamplers); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(101)] + public void VSGetShader(ID3D11VertexShader* ppVertexShader, ID3D11ClassInstance* ppClassInstances, uint* pNumClassInstances) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[101]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this), ppVertexShader, ppClassInstances, pNumClassInstances); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[101]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this), ppVertexShader, ppClassInstances, pNumClassInstances); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(102)] + public void PSGetConstantBuffers(uint StartSlot, uint NumBuffers, ID3D11Buffer* ppConstantBuffers) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[102]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this), StartSlot, NumBuffers, ppConstantBuffers); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[102]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this), StartSlot, NumBuffers, ppConstantBuffers); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(103)] + public void IAGetInputLayout(ID3D11InputLayout* ppInputLayout) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[103]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this), ppInputLayout); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[103]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this), ppInputLayout); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(104)] + public void IAGetVertexBuffers(uint StartSlot, uint NumBuffers, ID3D11Buffer* ppVertexBuffers, uint* pStrides, uint* pOffsets) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[104]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this), StartSlot, NumBuffers, ppVertexBuffers, pStrides, pOffsets); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[104]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this), StartSlot, NumBuffers, ppVertexBuffers, pStrides, pOffsets); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(105)] + public void IAGetIndexBuffer(ID3D11Buffer* pIndexBuffer, Graphics.Dxgi.Common.Format* Format, uint* Offset) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[105]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this), pIndexBuffer, Format, Offset); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[105]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this), pIndexBuffer, Format, Offset); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(106)] + public void GSGetConstantBuffers(uint StartSlot, uint NumBuffers, ID3D11Buffer* ppConstantBuffers) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[106]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this), StartSlot, NumBuffers, ppConstantBuffers); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[106]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this), StartSlot, NumBuffers, ppConstantBuffers); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(107)] + public void GSGetShader(ID3D11GeometryShader* ppGeometryShader, ID3D11ClassInstance* ppClassInstances, uint* pNumClassInstances) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[107]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this), ppGeometryShader, ppClassInstances, pNumClassInstances); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[107]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this), ppGeometryShader, ppClassInstances, pNumClassInstances); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(108)] + public void IAGetPrimitiveTopology(Graphics.Direct3D.PrimitiveTopology* pTopology) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[108]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this), pTopology); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[108]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this), pTopology); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(109)] + public void VSGetShaderResources(uint StartSlot, uint NumViews, ID3D11ShaderResourceView* ppShaderResourceViews) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[109]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this), StartSlot, NumViews, ppShaderResourceViews); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[109]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this), StartSlot, NumViews, ppShaderResourceViews); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(110)] + public void VSGetSamplers(uint StartSlot, uint NumSamplers, ID3D11SamplerState* ppSamplers) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[110]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this), StartSlot, NumSamplers, ppSamplers); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[110]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this), StartSlot, NumSamplers, ppSamplers); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(111)] + public void GetPredication(ID3D11Predicate* ppPredicate, Bool32* pPredicateValue) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[111]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this), ppPredicate, pPredicateValue); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[111]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this), ppPredicate, pPredicateValue); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(112)] + public void GSGetShaderResources(uint StartSlot, uint NumViews, ID3D11ShaderResourceView* ppShaderResourceViews) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[112]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this), StartSlot, NumViews, ppShaderResourceViews); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[112]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this), StartSlot, NumViews, ppShaderResourceViews); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(113)] + public void GSGetSamplers(uint StartSlot, uint NumSamplers, ID3D11SamplerState* ppSamplers) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[113]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this), StartSlot, NumSamplers, ppSamplers); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[113]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this), StartSlot, NumSamplers, ppSamplers); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(114)] + public void OMGetRenderTargets(uint NumViews, ID3D11RenderTargetView* ppRenderTargetViews, ID3D11DepthStencilView* ppDepthStencilView) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[114]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this), NumViews, ppRenderTargetViews, ppDepthStencilView); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[114]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this), NumViews, ppRenderTargetViews, ppDepthStencilView); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(115)] + public void OMGetRenderTargetsAndUnorderedAccessViews(uint NumRTVs, ID3D11RenderTargetView* ppRenderTargetViews, ID3D11DepthStencilView* ppDepthStencilView, uint UAVStartSlot, uint NumUAVs, ID3D11UnorderedAccessView* ppUnorderedAccessViews) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[115]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this), NumRTVs, ppRenderTargetViews, ppDepthStencilView, UAVStartSlot, NumUAVs, ppUnorderedAccessViews); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[115]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this), NumRTVs, ppRenderTargetViews, ppDepthStencilView, UAVStartSlot, NumUAVs, ppUnorderedAccessViews); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(116)] + public void OMGetBlendState(ID3D11BlendState* ppBlendState, float* BlendFactor, uint* pSampleMask) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[116]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this), ppBlendState, BlendFactor, pSampleMask); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[116]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this), ppBlendState, BlendFactor, pSampleMask); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(117)] + public void OMGetDepthStencilState(ID3D11DepthStencilState* ppDepthStencilState, uint* pStencilRef) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[117]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this), ppDepthStencilState, pStencilRef); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[117]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this), ppDepthStencilState, pStencilRef); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(118)] + public void SOGetTargets(uint NumBuffers, ID3D11Buffer* ppSOTargets) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[118]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this), NumBuffers, ppSOTargets); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[118]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this), NumBuffers, ppSOTargets); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(119)] + public void RSGetState(ID3D11RasterizerState* ppRasterizerState) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[119]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this), ppRasterizerState); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[119]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this), ppRasterizerState); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(120)] + public void RSGetViewports(uint* pNumViewports, Viewport* pViewports) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[120]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this), pNumViewports, pViewports); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[120]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this), pNumViewports, pViewports); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(121)] + public void RSGetScissorRects(uint* pNumRects, RawRect* pRects) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[121]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this), pNumRects, pRects); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[121]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this), pNumRects, pRects); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(122)] + public void HSGetShaderResources(uint StartSlot, uint NumViews, ID3D11ShaderResourceView* ppShaderResourceViews) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[122]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this), StartSlot, NumViews, ppShaderResourceViews); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[122]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this), StartSlot, NumViews, ppShaderResourceViews); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(123)] + public void HSGetShader(ID3D11HullShader* ppHullShader, ID3D11ClassInstance* ppClassInstances, uint* pNumClassInstances) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[123]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this), ppHullShader, ppClassInstances, pNumClassInstances); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[123]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this), ppHullShader, ppClassInstances, pNumClassInstances); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(124)] + public void HSGetSamplers(uint StartSlot, uint NumSamplers, ID3D11SamplerState* ppSamplers) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[124]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this), StartSlot, NumSamplers, ppSamplers); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[124]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this), StartSlot, NumSamplers, ppSamplers); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(125)] + public void HSGetConstantBuffers(uint StartSlot, uint NumBuffers, ID3D11Buffer* ppConstantBuffers) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[125]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this), StartSlot, NumBuffers, ppConstantBuffers); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[125]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this), StartSlot, NumBuffers, ppConstantBuffers); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(126)] + public void DSGetShaderResources(uint StartSlot, uint NumViews, ID3D11ShaderResourceView* ppShaderResourceViews) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[126]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this), StartSlot, NumViews, ppShaderResourceViews); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[126]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this), StartSlot, NumViews, ppShaderResourceViews); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(127)] + public void DSGetShader(ID3D11DomainShader* ppDomainShader, ID3D11ClassInstance* ppClassInstances, uint* pNumClassInstances) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[127]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this), ppDomainShader, ppClassInstances, pNumClassInstances); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[127]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this), ppDomainShader, ppClassInstances, pNumClassInstances); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(128)] + public void DSGetSamplers(uint StartSlot, uint NumSamplers, ID3D11SamplerState* ppSamplers) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[128]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this), StartSlot, NumSamplers, ppSamplers); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[128]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this), StartSlot, NumSamplers, ppSamplers); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(129)] + public void DSGetConstantBuffers(uint StartSlot, uint NumBuffers, ID3D11Buffer* ppConstantBuffers) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[129]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this), StartSlot, NumBuffers, ppConstantBuffers); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[129]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this), StartSlot, NumBuffers, ppConstantBuffers); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(130)] + public void CSGetShaderResources(uint StartSlot, uint NumViews, ID3D11ShaderResourceView* ppShaderResourceViews) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[130]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this), StartSlot, NumViews, ppShaderResourceViews); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[130]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this), StartSlot, NumViews, ppShaderResourceViews); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(131)] + public void CSGetUnorderedAccessViews(uint StartSlot, uint NumUAVs, ID3D11UnorderedAccessView* ppUnorderedAccessViews) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[131]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this), StartSlot, NumUAVs, ppUnorderedAccessViews); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[131]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this), StartSlot, NumUAVs, ppUnorderedAccessViews); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(132)] + public void CSGetShader(ID3D11ComputeShader* ppComputeShader, ID3D11ClassInstance* ppClassInstances, uint* pNumClassInstances) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[132]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this), ppComputeShader, ppClassInstances, pNumClassInstances); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[132]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this), ppComputeShader, ppClassInstances, pNumClassInstances); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(133)] + public void CSGetSamplers(uint StartSlot, uint NumSamplers, ID3D11SamplerState* ppSamplers) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[133]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this), StartSlot, NumSamplers, ppSamplers); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[133]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this), StartSlot, NumSamplers, ppSamplers); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(134)] + public void CSGetConstantBuffers(uint StartSlot, uint NumBuffers, ID3D11Buffer* ppConstantBuffers) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[134]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this), StartSlot, NumBuffers, ppConstantBuffers); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[134]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this), StartSlot, NumBuffers, ppConstantBuffers); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(135)] + public void ClearState() + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[135]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this)); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[135]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this)); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(136)] + public void Flush() + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[136]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this)); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[136]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this)); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(137)] + public Graphics.Direct3D11.DeviceContextType GetType() + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[137]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this)); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[137]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this)); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(138)] + public uint GetContextFlags() + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[138]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this)); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[138]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this)); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(139)] + public HResult FinishCommandList(Bool32* RestoreDeferredContextState, ID3D11CommandList** ppCommandList) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[139]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this), RestoreDeferredContextState, ppCommandList); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[139]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this), RestoreDeferredContextState, ppCommandList); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(140)] + public void GetDevice(ID3D11Device* ppDevice) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[140]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this), ppDevice); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[140]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this), ppDevice); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(141)] + public HResult GetPrivateData(Guid* guid, uint* pDataSize, void* pData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[141]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this), guid, pDataSize, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[141]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this), guid, pDataSize, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(142)] + public HResult SetPrivateData(Guid* guid, uint DataSize, void* pData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[142]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this), guid, DataSize, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[142]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this), guid, DataSize, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(143)] + public HResult SetPrivateDataInterface(Guid* guid, IUnknown* pData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[143]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this), guid, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[143]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this), guid, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(144)] + public void Flush1(ContextType ContextType, IntPtr* hEvent) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[144]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this), ContextType, hEvent); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[144]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this), ContextType, hEvent); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(145)] + public void SetHardwareProtectionState(Bool32* HwProtectionEnable) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[145]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this), HwProtectionEnable); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[145]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this), HwProtectionEnable); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(146)] + public void GetHardwareProtectionState(Bool32* pHwProtectionEnable) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[146]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this), pHwProtectionEnable); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[146]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this), pHwProtectionEnable); +#endif + } + + public interface Interface : ID3D11DeviceContext2.Interface + { + } +} + +/// +/// ID3D11Fence +[Guid("affde9d1-1df7-4bb7-8a34-0f46251dab80")] +[NativeTypeName("struct ID3D11Fence : ID3D11DeviceChild")] +[NativeInheritance("ID3D11DeviceChild")] +public unsafe partial struct ID3D11Fence : ID3D11Fence.Interface +{ + public static ref readonly Guid IID_ID3D11Fence + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0xD1, 0xE9, 0xFD, 0xAF, + 0xF7, 0x1D, + 0xB7, 0x4B, + 0x8A, + 0x34, + 0x0F, + 0x46, + 0x25, + 0x1D, + 0xAB, + 0x80 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_ID3D11Fence)); + + public void** lpVtbl; + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(0)] + public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(1)] + [return: NativeTypeName("ULONG")] + public uint AddRef() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(2)] + [return: NativeTypeName("ULONG")] + public uint Release() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(3)] + public void GetDevice(ID3D11Device* ppDevice) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[3]))((ID3D11Fence*)Unsafe.AsPointer(ref this), ppDevice); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((ID3D11Fence*)Unsafe.AsPointer(ref this), ppDevice); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public HResult GetPrivateData(Guid* guid, uint* pDataSize, void* pData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[4]))((ID3D11Fence*)Unsafe.AsPointer(ref this), guid, pDataSize, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((ID3D11Fence*)Unsafe.AsPointer(ref this), guid, pDataSize, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(5)] + public HResult SetPrivateData(Guid* guid, uint DataSize, void* pData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[5]))((ID3D11Fence*)Unsafe.AsPointer(ref this), guid, DataSize, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((ID3D11Fence*)Unsafe.AsPointer(ref this), guid, DataSize, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(6)] + public HResult SetPrivateDataInterface(Guid* guid, IUnknown* pData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[6]))((ID3D11Fence*)Unsafe.AsPointer(ref this), guid, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((ID3D11Fence*)Unsafe.AsPointer(ref this), guid, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(7)] + public HResult CreateSharedHandle(Security.SECURITY_ATTRIBUTES* pAttributes, uint dwAccess, char** lpName, IntPtr* pHandle) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[7]))((ID3D11Fence*)Unsafe.AsPointer(ref this), pAttributes, dwAccess, lpName, pHandle); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((ID3D11Fence*)Unsafe.AsPointer(ref this), pAttributes, dwAccess, lpName, pHandle); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(8)] + public ulong GetCompletedValue() + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[8]))((ID3D11Fence*)Unsafe.AsPointer(ref this)); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[8]))((ID3D11Fence*)Unsafe.AsPointer(ref this)); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(9)] + public HResult SetEventOnCompletion(ulong Value, IntPtr* hEvent) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[9]))((ID3D11Fence*)Unsafe.AsPointer(ref this), Value, hEvent); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[9]))((ID3D11Fence*)Unsafe.AsPointer(ref this), Value, hEvent); +#endif + } + + public interface Interface : ID3D11DeviceChild.Interface + { + } +} + +/// +/// ID3D11DeviceContext4 +[Guid("917600da-f58c-4c33-98d8-3e15b390fa24")] +[NativeTypeName("struct ID3D11DeviceContext4 : ID3D11DeviceContext3")] +[NativeInheritance("ID3D11DeviceContext3")] +public unsafe partial struct ID3D11DeviceContext4 : ID3D11DeviceContext4.Interface +{ + public static ref readonly Guid IID_ID3D11DeviceContext4 + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0xDA, 0x00, 0x76, 0x91, + 0x8C, 0xF5, + 0x33, 0x4C, + 0x98, + 0xD8, + 0x3E, + 0x15, + 0xB3, + 0x90, + 0xFA, + 0x24 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_ID3D11DeviceContext4)); + + public void** lpVtbl; + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(0)] + public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(1)] + [return: NativeTypeName("ULONG")] + public uint AddRef() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(2)] + [return: NativeTypeName("ULONG")] + public uint Release() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(3)] + public void Flush1(ContextType ContextType, IntPtr* hEvent) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[3]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this), ContextType, hEvent); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this), ContextType, hEvent); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public void SetHardwareProtectionState(Bool32* HwProtectionEnable) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[4]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this), HwProtectionEnable); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this), HwProtectionEnable); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(5)] + public void GetHardwareProtectionState(Bool32* pHwProtectionEnable) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[5]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this), pHwProtectionEnable); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this), pHwProtectionEnable); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(6)] + public HResult UpdateTileMappings(ID3D11Resource* pTiledResource, uint NumTiledResourceRegions, TiledResourceCoordinate* pTiledResourceRegionStartCoordinates, TileRegionSize* pTiledResourceRegionSizes, ID3D11Buffer* pTilePool, uint NumRanges, uint* pRangeFlags, uint* pTilePoolStartOffsets, uint* pRangeTileCounts, uint Flags) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[6]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this), pTiledResource, NumTiledResourceRegions, pTiledResourceRegionStartCoordinates, pTiledResourceRegionSizes, pTilePool, NumRanges, pRangeFlags, pTilePoolStartOffsets, pRangeTileCounts, Flags); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this), pTiledResource, NumTiledResourceRegions, pTiledResourceRegionStartCoordinates, pTiledResourceRegionSizes, pTilePool, NumRanges, pRangeFlags, pTilePoolStartOffsets, pRangeTileCounts, Flags); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(7)] + public HResult CopyTileMappings(ID3D11Resource* pDestTiledResource, TiledResourceCoordinate* pDestRegionStartCoordinate, ID3D11Resource* pSourceTiledResource, TiledResourceCoordinate* pSourceRegionStartCoordinate, TileRegionSize* pTileRegionSize, uint Flags) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[7]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this), pDestTiledResource, pDestRegionStartCoordinate, pSourceTiledResource, pSourceRegionStartCoordinate, pTileRegionSize, Flags); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this), pDestTiledResource, pDestRegionStartCoordinate, pSourceTiledResource, pSourceRegionStartCoordinate, pTileRegionSize, Flags); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(8)] + public void CopyTiles(ID3D11Resource* pTiledResource, TiledResourceCoordinate* pTileRegionStartCoordinate, TileRegionSize* pTileRegionSize, ID3D11Buffer* pBuffer, ulong BufferStartOffsetInBytes, uint Flags) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[8]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this), pTiledResource, pTileRegionStartCoordinate, pTileRegionSize, pBuffer, BufferStartOffsetInBytes, Flags); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[8]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this), pTiledResource, pTileRegionStartCoordinate, pTileRegionSize, pBuffer, BufferStartOffsetInBytes, Flags); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(9)] + public void UpdateTiles(ID3D11Resource* pDestTiledResource, TiledResourceCoordinate* pDestTileRegionStartCoordinate, TileRegionSize* pDestTileRegionSize, void* pSourceTileData, uint Flags) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[9]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this), pDestTiledResource, pDestTileRegionStartCoordinate, pDestTileRegionSize, pSourceTileData, Flags); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[9]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this), pDestTiledResource, pDestTileRegionStartCoordinate, pDestTileRegionSize, pSourceTileData, Flags); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(10)] + public HResult ResizeTilePool(ID3D11Buffer* pTilePool, ulong NewSizeInBytes) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[10]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this), pTilePool, NewSizeInBytes); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[10]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this), pTilePool, NewSizeInBytes); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(11)] + public void TiledResourceBarrier(ID3D11DeviceChild* pTiledResourceOrViewAccessBeforeBarrier, ID3D11DeviceChild* pTiledResourceOrViewAccessAfterBarrier) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[11]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this), pTiledResourceOrViewAccessBeforeBarrier, pTiledResourceOrViewAccessAfterBarrier); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[11]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this), pTiledResourceOrViewAccessBeforeBarrier, pTiledResourceOrViewAccessAfterBarrier); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(12)] + public Bool32 IsAnnotationEnabled() + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[12]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this)); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[12]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this)); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(13)] + public void SetMarkerInt(char** pLabel, int Data) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[13]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this), pLabel, Data); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[13]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this), pLabel, Data); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(14)] + public void BeginEventInt(char** pLabel, int Data) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[14]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this), pLabel, Data); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[14]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this), pLabel, Data); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(15)] + public void EndEvent() + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[15]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this)); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[15]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this)); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(16)] + public void CopySubresourceRegion1(ID3D11Resource* pDstResource, uint DstSubresource, uint DstX, uint DstY, uint DstZ, ID3D11Resource* pSrcResource, uint SrcSubresource, Box* pSrcBox, uint CopyFlags) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[16]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this), pDstResource, DstSubresource, DstX, DstY, DstZ, pSrcResource, SrcSubresource, pSrcBox, CopyFlags); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[16]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this), pDstResource, DstSubresource, DstX, DstY, DstZ, pSrcResource, SrcSubresource, pSrcBox, CopyFlags); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(17)] + public void UpdateSubresource1(ID3D11Resource* pDstResource, uint DstSubresource, Box* pDstBox, void* pSrcData, uint SrcRowPitch, uint SrcDepthPitch, uint CopyFlags) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[17]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this), pDstResource, DstSubresource, pDstBox, pSrcData, SrcRowPitch, SrcDepthPitch, CopyFlags); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[17]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this), pDstResource, DstSubresource, pDstBox, pSrcData, SrcRowPitch, SrcDepthPitch, CopyFlags); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(18)] + public void DiscardResource(ID3D11Resource* pResource) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[18]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this), pResource); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[18]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this), pResource); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(19)] + public void DiscardView(ID3D11View* pResourceView) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[19]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this), pResourceView); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[19]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this), pResourceView); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(20)] + public void VSSetConstantBuffers1(uint StartSlot, uint NumBuffers, ID3D11Buffer* ppConstantBuffers, uint* pFirstConstant, uint* pNumConstants) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[20]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this), StartSlot, NumBuffers, ppConstantBuffers, pFirstConstant, pNumConstants); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[20]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this), StartSlot, NumBuffers, ppConstantBuffers, pFirstConstant, pNumConstants); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(21)] + public void HSSetConstantBuffers1(uint StartSlot, uint NumBuffers, ID3D11Buffer* ppConstantBuffers, uint* pFirstConstant, uint* pNumConstants) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[21]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this), StartSlot, NumBuffers, ppConstantBuffers, pFirstConstant, pNumConstants); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[21]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this), StartSlot, NumBuffers, ppConstantBuffers, pFirstConstant, pNumConstants); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(22)] + public void DSSetConstantBuffers1(uint StartSlot, uint NumBuffers, ID3D11Buffer* ppConstantBuffers, uint* pFirstConstant, uint* pNumConstants) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[22]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this), StartSlot, NumBuffers, ppConstantBuffers, pFirstConstant, pNumConstants); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[22]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this), StartSlot, NumBuffers, ppConstantBuffers, pFirstConstant, pNumConstants); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(23)] + public void GSSetConstantBuffers1(uint StartSlot, uint NumBuffers, ID3D11Buffer* ppConstantBuffers, uint* pFirstConstant, uint* pNumConstants) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[23]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this), StartSlot, NumBuffers, ppConstantBuffers, pFirstConstant, pNumConstants); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[23]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this), StartSlot, NumBuffers, ppConstantBuffers, pFirstConstant, pNumConstants); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(24)] + public void PSSetConstantBuffers1(uint StartSlot, uint NumBuffers, ID3D11Buffer* ppConstantBuffers, uint* pFirstConstant, uint* pNumConstants) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[24]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this), StartSlot, NumBuffers, ppConstantBuffers, pFirstConstant, pNumConstants); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[24]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this), StartSlot, NumBuffers, ppConstantBuffers, pFirstConstant, pNumConstants); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(25)] + public void CSSetConstantBuffers1(uint StartSlot, uint NumBuffers, ID3D11Buffer* ppConstantBuffers, uint* pFirstConstant, uint* pNumConstants) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[25]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this), StartSlot, NumBuffers, ppConstantBuffers, pFirstConstant, pNumConstants); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[25]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this), StartSlot, NumBuffers, ppConstantBuffers, pFirstConstant, pNumConstants); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(26)] + public void VSGetConstantBuffers1(uint StartSlot, uint NumBuffers, ID3D11Buffer* ppConstantBuffers, uint* pFirstConstant, uint* pNumConstants) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[26]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this), StartSlot, NumBuffers, ppConstantBuffers, pFirstConstant, pNumConstants); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[26]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this), StartSlot, NumBuffers, ppConstantBuffers, pFirstConstant, pNumConstants); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(27)] + public void HSGetConstantBuffers1(uint StartSlot, uint NumBuffers, ID3D11Buffer* ppConstantBuffers, uint* pFirstConstant, uint* pNumConstants) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[27]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this), StartSlot, NumBuffers, ppConstantBuffers, pFirstConstant, pNumConstants); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[27]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this), StartSlot, NumBuffers, ppConstantBuffers, pFirstConstant, pNumConstants); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(28)] + public void DSGetConstantBuffers1(uint StartSlot, uint NumBuffers, ID3D11Buffer* ppConstantBuffers, uint* pFirstConstant, uint* pNumConstants) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[28]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this), StartSlot, NumBuffers, ppConstantBuffers, pFirstConstant, pNumConstants); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[28]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this), StartSlot, NumBuffers, ppConstantBuffers, pFirstConstant, pNumConstants); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(29)] + public void GSGetConstantBuffers1(uint StartSlot, uint NumBuffers, ID3D11Buffer* ppConstantBuffers, uint* pFirstConstant, uint* pNumConstants) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[29]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this), StartSlot, NumBuffers, ppConstantBuffers, pFirstConstant, pNumConstants); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[29]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this), StartSlot, NumBuffers, ppConstantBuffers, pFirstConstant, pNumConstants); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(30)] + public void PSGetConstantBuffers1(uint StartSlot, uint NumBuffers, ID3D11Buffer* ppConstantBuffers, uint* pFirstConstant, uint* pNumConstants) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[30]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this), StartSlot, NumBuffers, ppConstantBuffers, pFirstConstant, pNumConstants); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[30]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this), StartSlot, NumBuffers, ppConstantBuffers, pFirstConstant, pNumConstants); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(31)] + public void CSGetConstantBuffers1(uint StartSlot, uint NumBuffers, ID3D11Buffer* ppConstantBuffers, uint* pFirstConstant, uint* pNumConstants) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[31]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this), StartSlot, NumBuffers, ppConstantBuffers, pFirstConstant, pNumConstants); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[31]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this), StartSlot, NumBuffers, ppConstantBuffers, pFirstConstant, pNumConstants); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(32)] + public void SwapDeviceContextState(ID3DDeviceContextState* pState, ID3DDeviceContextState* ppPreviousState) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[32]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this), pState, ppPreviousState); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[32]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this), pState, ppPreviousState); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(33)] + public void ClearView(ID3D11View* pView, float* Color, RawRect* pRect, uint NumRects) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[33]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this), pView, Color, pRect, NumRects); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[33]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this), pView, Color, pRect, NumRects); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(34)] + public void DiscardView1(ID3D11View* pResourceView, RawRect* pRects, uint NumRects) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[34]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this), pResourceView, pRects, NumRects); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[34]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this), pResourceView, pRects, NumRects); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(35)] + public void VSSetConstantBuffers(uint StartSlot, uint NumBuffers, ID3D11Buffer* ppConstantBuffers) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[35]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this), StartSlot, NumBuffers, ppConstantBuffers); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[35]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this), StartSlot, NumBuffers, ppConstantBuffers); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(36)] + public void PSSetShaderResources(uint StartSlot, uint NumViews, ID3D11ShaderResourceView* ppShaderResourceViews) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[36]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this), StartSlot, NumViews, ppShaderResourceViews); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[36]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this), StartSlot, NumViews, ppShaderResourceViews); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(37)] + public void PSSetShader(ID3D11PixelShader* pPixelShader, ID3D11ClassInstance* ppClassInstances, uint NumClassInstances) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[37]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this), pPixelShader, ppClassInstances, NumClassInstances); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[37]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this), pPixelShader, ppClassInstances, NumClassInstances); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(38)] + public void PSSetSamplers(uint StartSlot, uint NumSamplers, ID3D11SamplerState* ppSamplers) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[38]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this), StartSlot, NumSamplers, ppSamplers); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[38]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this), StartSlot, NumSamplers, ppSamplers); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(39)] + public void VSSetShader(ID3D11VertexShader* pVertexShader, ID3D11ClassInstance* ppClassInstances, uint NumClassInstances) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[39]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this), pVertexShader, ppClassInstances, NumClassInstances); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[39]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this), pVertexShader, ppClassInstances, NumClassInstances); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(40)] + public void DrawIndexed(uint IndexCount, uint StartIndexLocation, int BaseVertexLocation) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[40]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this), IndexCount, StartIndexLocation, BaseVertexLocation); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[40]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this), IndexCount, StartIndexLocation, BaseVertexLocation); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(41)] + public void Draw(uint VertexCount, uint StartVertexLocation) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[41]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this), VertexCount, StartVertexLocation); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[41]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this), VertexCount, StartVertexLocation); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(42)] + public HResult Map(ID3D11Resource* pResource, uint Subresource, Map MapType, uint MapFlags, MappedSubresource* pMappedResource) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[42]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this), pResource, Subresource, MapType, MapFlags, pMappedResource); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[42]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this), pResource, Subresource, MapType, MapFlags, pMappedResource); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(43)] + public void Unmap(ID3D11Resource* pResource, uint Subresource) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[43]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this), pResource, Subresource); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[43]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this), pResource, Subresource); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(44)] + public void PSSetConstantBuffers(uint StartSlot, uint NumBuffers, ID3D11Buffer* ppConstantBuffers) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[44]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this), StartSlot, NumBuffers, ppConstantBuffers); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[44]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this), StartSlot, NumBuffers, ppConstantBuffers); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(45)] + public void IASetInputLayout(ID3D11InputLayout* pInputLayout) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[45]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this), pInputLayout); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[45]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this), pInputLayout); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(46)] + public void IASetVertexBuffers(uint StartSlot, uint NumBuffers, ID3D11Buffer* ppVertexBuffers, uint* pStrides, uint* pOffsets) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[46]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this), StartSlot, NumBuffers, ppVertexBuffers, pStrides, pOffsets); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[46]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this), StartSlot, NumBuffers, ppVertexBuffers, pStrides, pOffsets); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(47)] + public void IASetIndexBuffer(ID3D11Buffer* pIndexBuffer, Graphics.Dxgi.Common.Format Format, uint Offset) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[47]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this), pIndexBuffer, Format, Offset); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[47]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this), pIndexBuffer, Format, Offset); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(48)] + public void DrawIndexedInstanced(uint IndexCountPerInstance, uint InstanceCount, uint StartIndexLocation, int BaseVertexLocation, uint StartInstanceLocation) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[48]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this), IndexCountPerInstance, InstanceCount, StartIndexLocation, BaseVertexLocation, StartInstanceLocation); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[48]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this), IndexCountPerInstance, InstanceCount, StartIndexLocation, BaseVertexLocation, StartInstanceLocation); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(49)] + public void DrawInstanced(uint VertexCountPerInstance, uint InstanceCount, uint StartVertexLocation, uint StartInstanceLocation) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[49]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this), VertexCountPerInstance, InstanceCount, StartVertexLocation, StartInstanceLocation); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[49]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this), VertexCountPerInstance, InstanceCount, StartVertexLocation, StartInstanceLocation); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(50)] + public void GSSetConstantBuffers(uint StartSlot, uint NumBuffers, ID3D11Buffer* ppConstantBuffers) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[50]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this), StartSlot, NumBuffers, ppConstantBuffers); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[50]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this), StartSlot, NumBuffers, ppConstantBuffers); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(51)] + public void GSSetShader(ID3D11GeometryShader* pShader, ID3D11ClassInstance* ppClassInstances, uint NumClassInstances) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[51]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this), pShader, ppClassInstances, NumClassInstances); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[51]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this), pShader, ppClassInstances, NumClassInstances); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(52)] + public void IASetPrimitiveTopology(Graphics.Direct3D.PrimitiveTopology Topology) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[52]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this), Topology); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[52]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this), Topology); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(53)] + public void VSSetShaderResources(uint StartSlot, uint NumViews, ID3D11ShaderResourceView* ppShaderResourceViews) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[53]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this), StartSlot, NumViews, ppShaderResourceViews); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[53]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this), StartSlot, NumViews, ppShaderResourceViews); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(54)] + public void VSSetSamplers(uint StartSlot, uint NumSamplers, ID3D11SamplerState* ppSamplers) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[54]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this), StartSlot, NumSamplers, ppSamplers); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[54]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this), StartSlot, NumSamplers, ppSamplers); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(55)] + public void Begin(ID3D11Asynchronous* pAsync) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[55]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this), pAsync); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[55]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this), pAsync); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(56)] + public void End(ID3D11Asynchronous* pAsync) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[56]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this), pAsync); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[56]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this), pAsync); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(57)] + public HResult GetData(ID3D11Asynchronous* pAsync, void* pData, uint DataSize, uint GetDataFlags) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[57]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this), pAsync, pData, DataSize, GetDataFlags); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[57]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this), pAsync, pData, DataSize, GetDataFlags); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(58)] + public void SetPredication(ID3D11Predicate* pPredicate, Bool32* PredicateValue) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[58]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this), pPredicate, PredicateValue); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[58]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this), pPredicate, PredicateValue); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(59)] + public void GSSetShaderResources(uint StartSlot, uint NumViews, ID3D11ShaderResourceView* ppShaderResourceViews) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[59]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this), StartSlot, NumViews, ppShaderResourceViews); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[59]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this), StartSlot, NumViews, ppShaderResourceViews); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(60)] + public void GSSetSamplers(uint StartSlot, uint NumSamplers, ID3D11SamplerState* ppSamplers) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[60]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this), StartSlot, NumSamplers, ppSamplers); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[60]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this), StartSlot, NumSamplers, ppSamplers); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(61)] + public void OMSetRenderTargets(uint NumViews, ID3D11RenderTargetView* ppRenderTargetViews, ID3D11DepthStencilView* pDepthStencilView) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[61]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this), NumViews, ppRenderTargetViews, pDepthStencilView); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[61]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this), NumViews, ppRenderTargetViews, pDepthStencilView); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(62)] + public void OMSetRenderTargetsAndUnorderedAccessViews(uint NumRTVs, ID3D11RenderTargetView* ppRenderTargetViews, ID3D11DepthStencilView* pDepthStencilView, uint UAVStartSlot, uint NumUAVs, ID3D11UnorderedAccessView* ppUnorderedAccessViews, uint* pUAVInitialCounts) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[62]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this), NumRTVs, ppRenderTargetViews, pDepthStencilView, UAVStartSlot, NumUAVs, ppUnorderedAccessViews, pUAVInitialCounts); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[62]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this), NumRTVs, ppRenderTargetViews, pDepthStencilView, UAVStartSlot, NumUAVs, ppUnorderedAccessViews, pUAVInitialCounts); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(63)] + public void OMSetBlendState(ID3D11BlendState* pBlendState, float* BlendFactor, uint SampleMask) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[63]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this), pBlendState, BlendFactor, SampleMask); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[63]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this), pBlendState, BlendFactor, SampleMask); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(64)] + public void OMSetDepthStencilState(ID3D11DepthStencilState* pDepthStencilState, uint StencilRef) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[64]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this), pDepthStencilState, StencilRef); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[64]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this), pDepthStencilState, StencilRef); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(65)] + public void SOSetTargets(uint NumBuffers, ID3D11Buffer* ppSOTargets, uint* pOffsets) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[65]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this), NumBuffers, ppSOTargets, pOffsets); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[65]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this), NumBuffers, ppSOTargets, pOffsets); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(66)] + public void DrawAuto() + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[66]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this)); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[66]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this)); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(67)] + public void DrawIndexedInstancedIndirect(ID3D11Buffer* pBufferForArgs, uint AlignedByteOffsetForArgs) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[67]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this), pBufferForArgs, AlignedByteOffsetForArgs); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[67]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this), pBufferForArgs, AlignedByteOffsetForArgs); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(68)] + public void DrawInstancedIndirect(ID3D11Buffer* pBufferForArgs, uint AlignedByteOffsetForArgs) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[68]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this), pBufferForArgs, AlignedByteOffsetForArgs); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[68]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this), pBufferForArgs, AlignedByteOffsetForArgs); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(69)] + public void Dispatch(uint ThreadGroupCountX, uint ThreadGroupCountY, uint ThreadGroupCountZ) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[69]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this), ThreadGroupCountX, ThreadGroupCountY, ThreadGroupCountZ); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[69]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this), ThreadGroupCountX, ThreadGroupCountY, ThreadGroupCountZ); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(70)] + public void DispatchIndirect(ID3D11Buffer* pBufferForArgs, uint AlignedByteOffsetForArgs) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[70]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this), pBufferForArgs, AlignedByteOffsetForArgs); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[70]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this), pBufferForArgs, AlignedByteOffsetForArgs); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(71)] + public void RSSetState(ID3D11RasterizerState* pRasterizerState) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[71]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this), pRasterizerState); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[71]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this), pRasterizerState); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(72)] + public void RSSetViewports(uint NumViewports, Viewport* pViewports) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[72]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this), NumViewports, pViewports); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[72]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this), NumViewports, pViewports); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(73)] + public void RSSetScissorRects(uint NumRects, RawRect* pRects) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[73]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this), NumRects, pRects); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[73]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this), NumRects, pRects); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(74)] + public void CopySubresourceRegion(ID3D11Resource* pDstResource, uint DstSubresource, uint DstX, uint DstY, uint DstZ, ID3D11Resource* pSrcResource, uint SrcSubresource, Box* pSrcBox) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[74]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this), pDstResource, DstSubresource, DstX, DstY, DstZ, pSrcResource, SrcSubresource, pSrcBox); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[74]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this), pDstResource, DstSubresource, DstX, DstY, DstZ, pSrcResource, SrcSubresource, pSrcBox); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(75)] + public void CopyResource(ID3D11Resource* pDstResource, ID3D11Resource* pSrcResource) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[75]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this), pDstResource, pSrcResource); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[75]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this), pDstResource, pSrcResource); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(76)] + public void UpdateSubresource(ID3D11Resource* pDstResource, uint DstSubresource, Box* pDstBox, void* pSrcData, uint SrcRowPitch, uint SrcDepthPitch) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[76]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this), pDstResource, DstSubresource, pDstBox, pSrcData, SrcRowPitch, SrcDepthPitch); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[76]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this), pDstResource, DstSubresource, pDstBox, pSrcData, SrcRowPitch, SrcDepthPitch); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(77)] + public void CopyStructureCount(ID3D11Buffer* pDstBuffer, uint DstAlignedByteOffset, ID3D11UnorderedAccessView* pSrcView) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[77]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this), pDstBuffer, DstAlignedByteOffset, pSrcView); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[77]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this), pDstBuffer, DstAlignedByteOffset, pSrcView); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(78)] + public void ClearRenderTargetView(ID3D11RenderTargetView* pRenderTargetView, float* ColorRGBA) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[78]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this), pRenderTargetView, ColorRGBA); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[78]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this), pRenderTargetView, ColorRGBA); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(79)] + public void ClearUnorderedAccessViewUint(ID3D11UnorderedAccessView* pUnorderedAccessView, uint* Values) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[79]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this), pUnorderedAccessView, Values); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[79]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this), pUnorderedAccessView, Values); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(80)] + public void ClearUnorderedAccessViewFloat(ID3D11UnorderedAccessView* pUnorderedAccessView, float* Values) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[80]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this), pUnorderedAccessView, Values); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[80]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this), pUnorderedAccessView, Values); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(81)] + public void ClearDepthStencilView(ID3D11DepthStencilView* pDepthStencilView, uint ClearFlags, float Depth, byte Stencil) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[81]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this), pDepthStencilView, ClearFlags, Depth, Stencil); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[81]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this), pDepthStencilView, ClearFlags, Depth, Stencil); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(82)] + public void GenerateMips(ID3D11ShaderResourceView* pShaderResourceView) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[82]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this), pShaderResourceView); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[82]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this), pShaderResourceView); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(83)] + public void SetResourceMinLOD(ID3D11Resource* pResource, float MinLOD) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[83]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this), pResource, MinLOD); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[83]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this), pResource, MinLOD); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(84)] + public float GetResourceMinLOD(ID3D11Resource* pResource) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[84]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this), pResource); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[84]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this), pResource); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(85)] + public void ResolveSubresource(ID3D11Resource* pDstResource, uint DstSubresource, ID3D11Resource* pSrcResource, uint SrcSubresource, Graphics.Dxgi.Common.Format Format) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[85]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this), pDstResource, DstSubresource, pSrcResource, SrcSubresource, Format); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[85]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this), pDstResource, DstSubresource, pSrcResource, SrcSubresource, Format); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(86)] + public void ExecuteCommandList(ID3D11CommandList* pCommandList, Bool32* RestoreContextState) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[86]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this), pCommandList, RestoreContextState); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[86]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this), pCommandList, RestoreContextState); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(87)] + public void HSSetShaderResources(uint StartSlot, uint NumViews, ID3D11ShaderResourceView* ppShaderResourceViews) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[87]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this), StartSlot, NumViews, ppShaderResourceViews); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[87]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this), StartSlot, NumViews, ppShaderResourceViews); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(88)] + public void HSSetShader(ID3D11HullShader* pHullShader, ID3D11ClassInstance* ppClassInstances, uint NumClassInstances) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[88]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this), pHullShader, ppClassInstances, NumClassInstances); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[88]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this), pHullShader, ppClassInstances, NumClassInstances); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(89)] + public void HSSetSamplers(uint StartSlot, uint NumSamplers, ID3D11SamplerState* ppSamplers) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[89]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this), StartSlot, NumSamplers, ppSamplers); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[89]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this), StartSlot, NumSamplers, ppSamplers); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(90)] + public void HSSetConstantBuffers(uint StartSlot, uint NumBuffers, ID3D11Buffer* ppConstantBuffers) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[90]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this), StartSlot, NumBuffers, ppConstantBuffers); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[90]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this), StartSlot, NumBuffers, ppConstantBuffers); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(91)] + public void DSSetShaderResources(uint StartSlot, uint NumViews, ID3D11ShaderResourceView* ppShaderResourceViews) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[91]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this), StartSlot, NumViews, ppShaderResourceViews); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[91]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this), StartSlot, NumViews, ppShaderResourceViews); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(92)] + public void DSSetShader(ID3D11DomainShader* pDomainShader, ID3D11ClassInstance* ppClassInstances, uint NumClassInstances) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[92]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this), pDomainShader, ppClassInstances, NumClassInstances); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[92]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this), pDomainShader, ppClassInstances, NumClassInstances); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(93)] + public void DSSetSamplers(uint StartSlot, uint NumSamplers, ID3D11SamplerState* ppSamplers) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[93]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this), StartSlot, NumSamplers, ppSamplers); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[93]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this), StartSlot, NumSamplers, ppSamplers); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(94)] + public void DSSetConstantBuffers(uint StartSlot, uint NumBuffers, ID3D11Buffer* ppConstantBuffers) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[94]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this), StartSlot, NumBuffers, ppConstantBuffers); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[94]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this), StartSlot, NumBuffers, ppConstantBuffers); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(95)] + public void CSSetShaderResources(uint StartSlot, uint NumViews, ID3D11ShaderResourceView* ppShaderResourceViews) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[95]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this), StartSlot, NumViews, ppShaderResourceViews); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[95]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this), StartSlot, NumViews, ppShaderResourceViews); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(96)] + public void CSSetUnorderedAccessViews(uint StartSlot, uint NumUAVs, ID3D11UnorderedAccessView* ppUnorderedAccessViews, uint* pUAVInitialCounts) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[96]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this), StartSlot, NumUAVs, ppUnorderedAccessViews, pUAVInitialCounts); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[96]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this), StartSlot, NumUAVs, ppUnorderedAccessViews, pUAVInitialCounts); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(97)] + public void CSSetShader(ID3D11ComputeShader* pComputeShader, ID3D11ClassInstance* ppClassInstances, uint NumClassInstances) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[97]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this), pComputeShader, ppClassInstances, NumClassInstances); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[97]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this), pComputeShader, ppClassInstances, NumClassInstances); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(98)] + public void CSSetSamplers(uint StartSlot, uint NumSamplers, ID3D11SamplerState* ppSamplers) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[98]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this), StartSlot, NumSamplers, ppSamplers); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[98]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this), StartSlot, NumSamplers, ppSamplers); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(99)] + public void CSSetConstantBuffers(uint StartSlot, uint NumBuffers, ID3D11Buffer* ppConstantBuffers) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[99]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this), StartSlot, NumBuffers, ppConstantBuffers); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[99]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this), StartSlot, NumBuffers, ppConstantBuffers); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(100)] + public void VSGetConstantBuffers(uint StartSlot, uint NumBuffers, ID3D11Buffer* ppConstantBuffers) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[100]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this), StartSlot, NumBuffers, ppConstantBuffers); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[100]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this), StartSlot, NumBuffers, ppConstantBuffers); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(101)] + public void PSGetShaderResources(uint StartSlot, uint NumViews, ID3D11ShaderResourceView* ppShaderResourceViews) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[101]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this), StartSlot, NumViews, ppShaderResourceViews); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[101]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this), StartSlot, NumViews, ppShaderResourceViews); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(102)] + public void PSGetShader(ID3D11PixelShader* ppPixelShader, ID3D11ClassInstance* ppClassInstances, uint* pNumClassInstances) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[102]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this), ppPixelShader, ppClassInstances, pNumClassInstances); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[102]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this), ppPixelShader, ppClassInstances, pNumClassInstances); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(103)] + public void PSGetSamplers(uint StartSlot, uint NumSamplers, ID3D11SamplerState* ppSamplers) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[103]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this), StartSlot, NumSamplers, ppSamplers); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[103]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this), StartSlot, NumSamplers, ppSamplers); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(104)] + public void VSGetShader(ID3D11VertexShader* ppVertexShader, ID3D11ClassInstance* ppClassInstances, uint* pNumClassInstances) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[104]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this), ppVertexShader, ppClassInstances, pNumClassInstances); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[104]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this), ppVertexShader, ppClassInstances, pNumClassInstances); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(105)] + public void PSGetConstantBuffers(uint StartSlot, uint NumBuffers, ID3D11Buffer* ppConstantBuffers) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[105]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this), StartSlot, NumBuffers, ppConstantBuffers); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[105]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this), StartSlot, NumBuffers, ppConstantBuffers); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(106)] + public void IAGetInputLayout(ID3D11InputLayout* ppInputLayout) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[106]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this), ppInputLayout); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[106]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this), ppInputLayout); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(107)] + public void IAGetVertexBuffers(uint StartSlot, uint NumBuffers, ID3D11Buffer* ppVertexBuffers, uint* pStrides, uint* pOffsets) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[107]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this), StartSlot, NumBuffers, ppVertexBuffers, pStrides, pOffsets); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[107]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this), StartSlot, NumBuffers, ppVertexBuffers, pStrides, pOffsets); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(108)] + public void IAGetIndexBuffer(ID3D11Buffer* pIndexBuffer, Graphics.Dxgi.Common.Format* Format, uint* Offset) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[108]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this), pIndexBuffer, Format, Offset); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[108]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this), pIndexBuffer, Format, Offset); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(109)] + public void GSGetConstantBuffers(uint StartSlot, uint NumBuffers, ID3D11Buffer* ppConstantBuffers) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[109]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this), StartSlot, NumBuffers, ppConstantBuffers); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[109]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this), StartSlot, NumBuffers, ppConstantBuffers); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(110)] + public void GSGetShader(ID3D11GeometryShader* ppGeometryShader, ID3D11ClassInstance* ppClassInstances, uint* pNumClassInstances) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[110]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this), ppGeometryShader, ppClassInstances, pNumClassInstances); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[110]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this), ppGeometryShader, ppClassInstances, pNumClassInstances); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(111)] + public void IAGetPrimitiveTopology(Graphics.Direct3D.PrimitiveTopology* pTopology) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[111]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this), pTopology); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[111]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this), pTopology); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(112)] + public void VSGetShaderResources(uint StartSlot, uint NumViews, ID3D11ShaderResourceView* ppShaderResourceViews) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[112]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this), StartSlot, NumViews, ppShaderResourceViews); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[112]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this), StartSlot, NumViews, ppShaderResourceViews); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(113)] + public void VSGetSamplers(uint StartSlot, uint NumSamplers, ID3D11SamplerState* ppSamplers) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[113]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this), StartSlot, NumSamplers, ppSamplers); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[113]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this), StartSlot, NumSamplers, ppSamplers); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(114)] + public void GetPredication(ID3D11Predicate* ppPredicate, Bool32* pPredicateValue) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[114]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this), ppPredicate, pPredicateValue); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[114]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this), ppPredicate, pPredicateValue); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(115)] + public void GSGetShaderResources(uint StartSlot, uint NumViews, ID3D11ShaderResourceView* ppShaderResourceViews) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[115]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this), StartSlot, NumViews, ppShaderResourceViews); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[115]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this), StartSlot, NumViews, ppShaderResourceViews); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(116)] + public void GSGetSamplers(uint StartSlot, uint NumSamplers, ID3D11SamplerState* ppSamplers) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[116]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this), StartSlot, NumSamplers, ppSamplers); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[116]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this), StartSlot, NumSamplers, ppSamplers); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(117)] + public void OMGetRenderTargets(uint NumViews, ID3D11RenderTargetView* ppRenderTargetViews, ID3D11DepthStencilView* ppDepthStencilView) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[117]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this), NumViews, ppRenderTargetViews, ppDepthStencilView); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[117]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this), NumViews, ppRenderTargetViews, ppDepthStencilView); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(118)] + public void OMGetRenderTargetsAndUnorderedAccessViews(uint NumRTVs, ID3D11RenderTargetView* ppRenderTargetViews, ID3D11DepthStencilView* ppDepthStencilView, uint UAVStartSlot, uint NumUAVs, ID3D11UnorderedAccessView* ppUnorderedAccessViews) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[118]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this), NumRTVs, ppRenderTargetViews, ppDepthStencilView, UAVStartSlot, NumUAVs, ppUnorderedAccessViews); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[118]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this), NumRTVs, ppRenderTargetViews, ppDepthStencilView, UAVStartSlot, NumUAVs, ppUnorderedAccessViews); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(119)] + public void OMGetBlendState(ID3D11BlendState* ppBlendState, float* BlendFactor, uint* pSampleMask) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[119]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this), ppBlendState, BlendFactor, pSampleMask); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[119]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this), ppBlendState, BlendFactor, pSampleMask); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(120)] + public void OMGetDepthStencilState(ID3D11DepthStencilState* ppDepthStencilState, uint* pStencilRef) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[120]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this), ppDepthStencilState, pStencilRef); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[120]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this), ppDepthStencilState, pStencilRef); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(121)] + public void SOGetTargets(uint NumBuffers, ID3D11Buffer* ppSOTargets) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[121]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this), NumBuffers, ppSOTargets); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[121]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this), NumBuffers, ppSOTargets); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(122)] + public void RSGetState(ID3D11RasterizerState* ppRasterizerState) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[122]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this), ppRasterizerState); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[122]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this), ppRasterizerState); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(123)] + public void RSGetViewports(uint* pNumViewports, Viewport* pViewports) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[123]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this), pNumViewports, pViewports); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[123]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this), pNumViewports, pViewports); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(124)] + public void RSGetScissorRects(uint* pNumRects, RawRect* pRects) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[124]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this), pNumRects, pRects); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[124]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this), pNumRects, pRects); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(125)] + public void HSGetShaderResources(uint StartSlot, uint NumViews, ID3D11ShaderResourceView* ppShaderResourceViews) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[125]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this), StartSlot, NumViews, ppShaderResourceViews); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[125]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this), StartSlot, NumViews, ppShaderResourceViews); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(126)] + public void HSGetShader(ID3D11HullShader* ppHullShader, ID3D11ClassInstance* ppClassInstances, uint* pNumClassInstances) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[126]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this), ppHullShader, ppClassInstances, pNumClassInstances); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[126]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this), ppHullShader, ppClassInstances, pNumClassInstances); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(127)] + public void HSGetSamplers(uint StartSlot, uint NumSamplers, ID3D11SamplerState* ppSamplers) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[127]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this), StartSlot, NumSamplers, ppSamplers); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[127]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this), StartSlot, NumSamplers, ppSamplers); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(128)] + public void HSGetConstantBuffers(uint StartSlot, uint NumBuffers, ID3D11Buffer* ppConstantBuffers) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[128]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this), StartSlot, NumBuffers, ppConstantBuffers); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[128]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this), StartSlot, NumBuffers, ppConstantBuffers); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(129)] + public void DSGetShaderResources(uint StartSlot, uint NumViews, ID3D11ShaderResourceView* ppShaderResourceViews) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[129]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this), StartSlot, NumViews, ppShaderResourceViews); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[129]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this), StartSlot, NumViews, ppShaderResourceViews); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(130)] + public void DSGetShader(ID3D11DomainShader* ppDomainShader, ID3D11ClassInstance* ppClassInstances, uint* pNumClassInstances) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[130]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this), ppDomainShader, ppClassInstances, pNumClassInstances); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[130]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this), ppDomainShader, ppClassInstances, pNumClassInstances); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(131)] + public void DSGetSamplers(uint StartSlot, uint NumSamplers, ID3D11SamplerState* ppSamplers) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[131]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this), StartSlot, NumSamplers, ppSamplers); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[131]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this), StartSlot, NumSamplers, ppSamplers); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(132)] + public void DSGetConstantBuffers(uint StartSlot, uint NumBuffers, ID3D11Buffer* ppConstantBuffers) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[132]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this), StartSlot, NumBuffers, ppConstantBuffers); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[132]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this), StartSlot, NumBuffers, ppConstantBuffers); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(133)] + public void CSGetShaderResources(uint StartSlot, uint NumViews, ID3D11ShaderResourceView* ppShaderResourceViews) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[133]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this), StartSlot, NumViews, ppShaderResourceViews); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[133]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this), StartSlot, NumViews, ppShaderResourceViews); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(134)] + public void CSGetUnorderedAccessViews(uint StartSlot, uint NumUAVs, ID3D11UnorderedAccessView* ppUnorderedAccessViews) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[134]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this), StartSlot, NumUAVs, ppUnorderedAccessViews); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[134]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this), StartSlot, NumUAVs, ppUnorderedAccessViews); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(135)] + public void CSGetShader(ID3D11ComputeShader* ppComputeShader, ID3D11ClassInstance* ppClassInstances, uint* pNumClassInstances) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[135]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this), ppComputeShader, ppClassInstances, pNumClassInstances); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[135]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this), ppComputeShader, ppClassInstances, pNumClassInstances); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(136)] + public void CSGetSamplers(uint StartSlot, uint NumSamplers, ID3D11SamplerState* ppSamplers) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[136]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this), StartSlot, NumSamplers, ppSamplers); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[136]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this), StartSlot, NumSamplers, ppSamplers); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(137)] + public void CSGetConstantBuffers(uint StartSlot, uint NumBuffers, ID3D11Buffer* ppConstantBuffers) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[137]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this), StartSlot, NumBuffers, ppConstantBuffers); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[137]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this), StartSlot, NumBuffers, ppConstantBuffers); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(138)] + public void ClearState() + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[138]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this)); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[138]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this)); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(139)] + public void Flush() + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[139]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this)); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[139]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this)); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(140)] + public Graphics.Direct3D11.DeviceContextType GetType() + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[140]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this)); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[140]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this)); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(141)] + public uint GetContextFlags() + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[141]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this)); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[141]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this)); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(142)] + public HResult FinishCommandList(Bool32* RestoreDeferredContextState, ID3D11CommandList** ppCommandList) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[142]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this), RestoreDeferredContextState, ppCommandList); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[142]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this), RestoreDeferredContextState, ppCommandList); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(143)] + public void GetDevice(ID3D11Device* ppDevice) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[143]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this), ppDevice); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[143]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this), ppDevice); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(144)] + public HResult GetPrivateData(Guid* guid, uint* pDataSize, void* pData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[144]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this), guid, pDataSize, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[144]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this), guid, pDataSize, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(145)] + public HResult SetPrivateData(Guid* guid, uint DataSize, void* pData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[145]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this), guid, DataSize, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[145]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this), guid, DataSize, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(146)] + public HResult SetPrivateDataInterface(Guid* guid, IUnknown* pData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[146]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this), guid, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[146]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this), guid, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(147)] + public HResult Signal(ID3D11Fence* pFence, ulong Value) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[147]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this), pFence, Value); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[147]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this), pFence, Value); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(148)] + public HResult Wait(ID3D11Fence* pFence, ulong Value) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[148]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this), pFence, Value); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[148]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this), pFence, Value); +#endif + } + + public interface Interface : ID3D11DeviceContext3.Interface + { + } +} + +/// +/// ID3D11Device3 +[Guid("a05c8c37-d2c6-4732-b3a0-9ce0b0dc9ae6")] +[NativeTypeName("struct ID3D11Device3 : ID3D11Device2")] +[NativeInheritance("ID3D11Device2")] +public unsafe partial struct ID3D11Device3 : ID3D11Device3.Interface +{ + public static ref readonly Guid IID_ID3D11Device3 + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x37, 0x8C, 0x5C, 0xA0, + 0xC6, 0xD2, + 0x32, 0x47, + 0xB3, + 0xA0, + 0x9C, + 0xE0, + 0xB0, + 0xDC, + 0x9A, + 0xE6 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_ID3D11Device3)); + + public void** lpVtbl; + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(0)] + public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(1)] + [return: NativeTypeName("ULONG")] + public uint AddRef() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(2)] + [return: NativeTypeName("ULONG")] + public uint Release() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(3)] + public void GetImmediateContext2(ID3D11DeviceContext2* ppImmediateContext) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[3]))((ID3D11Device3*)Unsafe.AsPointer(ref this), ppImmediateContext); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((ID3D11Device3*)Unsafe.AsPointer(ref this), ppImmediateContext); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public HResult CreateDeferredContext2(uint ContextFlags, ID3D11DeviceContext2** ppDeferredContext) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[4]))((ID3D11Device3*)Unsafe.AsPointer(ref this), ContextFlags, ppDeferredContext); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((ID3D11Device3*)Unsafe.AsPointer(ref this), ContextFlags, ppDeferredContext); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(5)] + public void GetResourceTiling(ID3D11Resource* pTiledResource, uint* pNumTilesForEntireResource, PackedMipDescription* pPackedMipDesc, TileShape* pStandardTileShapeForNonPackedMips, uint* pNumSubresourceTilings, uint FirstSubresourceTilingToGet, SubresourceTiling* pSubresourceTilingsForNonPackedMips) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[5]))((ID3D11Device3*)Unsafe.AsPointer(ref this), pTiledResource, pNumTilesForEntireResource, pPackedMipDesc, pStandardTileShapeForNonPackedMips, pNumSubresourceTilings, FirstSubresourceTilingToGet, pSubresourceTilingsForNonPackedMips); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((ID3D11Device3*)Unsafe.AsPointer(ref this), pTiledResource, pNumTilesForEntireResource, pPackedMipDesc, pStandardTileShapeForNonPackedMips, pNumSubresourceTilings, FirstSubresourceTilingToGet, pSubresourceTilingsForNonPackedMips); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(6)] + public HResult CheckMultisampleQualityLevels1(Graphics.Dxgi.Common.Format Format, uint SampleCount, uint Flags, uint* pNumQualityLevels) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[6]))((ID3D11Device3*)Unsafe.AsPointer(ref this), Format, SampleCount, Flags, pNumQualityLevels); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((ID3D11Device3*)Unsafe.AsPointer(ref this), Format, SampleCount, Flags, pNumQualityLevels); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(7)] + public void GetImmediateContext1(ID3D11DeviceContext1* ppImmediateContext) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[7]))((ID3D11Device3*)Unsafe.AsPointer(ref this), ppImmediateContext); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((ID3D11Device3*)Unsafe.AsPointer(ref this), ppImmediateContext); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(8)] + public HResult CreateDeferredContext1(uint ContextFlags, ID3D11DeviceContext1** ppDeferredContext) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[8]))((ID3D11Device3*)Unsafe.AsPointer(ref this), ContextFlags, ppDeferredContext); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[8]))((ID3D11Device3*)Unsafe.AsPointer(ref this), ContextFlags, ppDeferredContext); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(9)] + public HResult CreateBlendState1(BlendDescription1* pBlendStateDesc, ID3D11BlendState1** ppBlendState) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[9]))((ID3D11Device3*)Unsafe.AsPointer(ref this), pBlendStateDesc, ppBlendState); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[9]))((ID3D11Device3*)Unsafe.AsPointer(ref this), pBlendStateDesc, ppBlendState); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(10)] + public HResult CreateRasterizerState1(RasterizerDescription1* pRasterizerDesc, ID3D11RasterizerState1** ppRasterizerState) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[10]))((ID3D11Device3*)Unsafe.AsPointer(ref this), pRasterizerDesc, ppRasterizerState); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[10]))((ID3D11Device3*)Unsafe.AsPointer(ref this), pRasterizerDesc, ppRasterizerState); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(11)] + public HResult CreateDeviceContextState(uint Flags, Graphics.Direct3D.FeatureLevel* pFeatureLevels, uint FeatureLevels, uint SDKVersion, Guid* EmulatedInterface, Graphics.Direct3D.FeatureLevel* pChosenFeatureLevel, ID3DDeviceContextState* ppContextState) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[11]))((ID3D11Device3*)Unsafe.AsPointer(ref this), Flags, pFeatureLevels, FeatureLevels, SDKVersion, EmulatedInterface, pChosenFeatureLevel, ppContextState); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[11]))((ID3D11Device3*)Unsafe.AsPointer(ref this), Flags, pFeatureLevels, FeatureLevels, SDKVersion, EmulatedInterface, pChosenFeatureLevel, ppContextState); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(12)] + public HResult OpenSharedResource1(IntPtr* hResource, Guid* returnedInterface, void** ppResource) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[12]))((ID3D11Device3*)Unsafe.AsPointer(ref this), hResource, returnedInterface, ppResource); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[12]))((ID3D11Device3*)Unsafe.AsPointer(ref this), hResource, returnedInterface, ppResource); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(13)] + public HResult OpenSharedResourceByName(char** lpName, uint dwDesiredAccess, Guid* returnedInterface, void** ppResource) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[13]))((ID3D11Device3*)Unsafe.AsPointer(ref this), lpName, dwDesiredAccess, returnedInterface, ppResource); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[13]))((ID3D11Device3*)Unsafe.AsPointer(ref this), lpName, dwDesiredAccess, returnedInterface, ppResource); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(14)] + public HResult CreateBuffer(BufferDescription* pDesc, SubresourceData* pInitialData, ID3D11Buffer** ppBuffer) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[14]))((ID3D11Device3*)Unsafe.AsPointer(ref this), pDesc, pInitialData, ppBuffer); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[14]))((ID3D11Device3*)Unsafe.AsPointer(ref this), pDesc, pInitialData, ppBuffer); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(15)] + public HResult CreateTexture1D(Texture1DDescription* pDesc, SubresourceData* pInitialData, ID3D11Texture1D** ppTexture1D) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[15]))((ID3D11Device3*)Unsafe.AsPointer(ref this), pDesc, pInitialData, ppTexture1D); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[15]))((ID3D11Device3*)Unsafe.AsPointer(ref this), pDesc, pInitialData, ppTexture1D); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(16)] + public HResult CreateTexture2D(Texture2DDescription* pDesc, SubresourceData* pInitialData, ID3D11Texture2D** ppTexture2D) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[16]))((ID3D11Device3*)Unsafe.AsPointer(ref this), pDesc, pInitialData, ppTexture2D); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[16]))((ID3D11Device3*)Unsafe.AsPointer(ref this), pDesc, pInitialData, ppTexture2D); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(17)] + public HResult CreateTexture3D(Texture3DDescription* pDesc, SubresourceData* pInitialData, ID3D11Texture3D** ppTexture3D) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[17]))((ID3D11Device3*)Unsafe.AsPointer(ref this), pDesc, pInitialData, ppTexture3D); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[17]))((ID3D11Device3*)Unsafe.AsPointer(ref this), pDesc, pInitialData, ppTexture3D); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(18)] + public HResult CreateShaderResourceView(ID3D11Resource* pResource, ShaderResourceViewDescription* pDesc, ID3D11ShaderResourceView** ppSRView) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[18]))((ID3D11Device3*)Unsafe.AsPointer(ref this), pResource, pDesc, ppSRView); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[18]))((ID3D11Device3*)Unsafe.AsPointer(ref this), pResource, pDesc, ppSRView); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(19)] + public HResult CreateUnorderedAccessView(ID3D11Resource* pResource, UnorderedAccessViewDescription* pDesc, ID3D11UnorderedAccessView** ppUAView) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[19]))((ID3D11Device3*)Unsafe.AsPointer(ref this), pResource, pDesc, ppUAView); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[19]))((ID3D11Device3*)Unsafe.AsPointer(ref this), pResource, pDesc, ppUAView); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(20)] + public HResult CreateRenderTargetView(ID3D11Resource* pResource, RenderTargetViewDescription* pDesc, ID3D11RenderTargetView** ppRTView) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[20]))((ID3D11Device3*)Unsafe.AsPointer(ref this), pResource, pDesc, ppRTView); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[20]))((ID3D11Device3*)Unsafe.AsPointer(ref this), pResource, pDesc, ppRTView); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(21)] + public HResult CreateDepthStencilView(ID3D11Resource* pResource, DepthStencilViewDescription* pDesc, ID3D11DepthStencilView** ppDepthStencilView) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[21]))((ID3D11Device3*)Unsafe.AsPointer(ref this), pResource, pDesc, ppDepthStencilView); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[21]))((ID3D11Device3*)Unsafe.AsPointer(ref this), pResource, pDesc, ppDepthStencilView); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(22)] + public HResult CreateInputLayout(InputElementDescription* pInputElementDescs, uint NumElements, void* pShaderBytecodeWithInputSignature, nuint BytecodeLength, ID3D11InputLayout** ppInputLayout) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[22]))((ID3D11Device3*)Unsafe.AsPointer(ref this), pInputElementDescs, NumElements, pShaderBytecodeWithInputSignature, BytecodeLength, ppInputLayout); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[22]))((ID3D11Device3*)Unsafe.AsPointer(ref this), pInputElementDescs, NumElements, pShaderBytecodeWithInputSignature, BytecodeLength, ppInputLayout); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(23)] + public HResult CreateVertexShader(void* pShaderBytecode, nuint BytecodeLength, ID3D11ClassLinkage* pClassLinkage, ID3D11VertexShader** ppVertexShader) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[23]))((ID3D11Device3*)Unsafe.AsPointer(ref this), pShaderBytecode, BytecodeLength, pClassLinkage, ppVertexShader); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[23]))((ID3D11Device3*)Unsafe.AsPointer(ref this), pShaderBytecode, BytecodeLength, pClassLinkage, ppVertexShader); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(24)] + public HResult CreateGeometryShader(void* pShaderBytecode, nuint BytecodeLength, ID3D11ClassLinkage* pClassLinkage, ID3D11GeometryShader** ppGeometryShader) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[24]))((ID3D11Device3*)Unsafe.AsPointer(ref this), pShaderBytecode, BytecodeLength, pClassLinkage, ppGeometryShader); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[24]))((ID3D11Device3*)Unsafe.AsPointer(ref this), pShaderBytecode, BytecodeLength, pClassLinkage, ppGeometryShader); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(25)] + public HResult CreateGeometryShaderWithStreamOutput(void* pShaderBytecode, nuint BytecodeLength, SoDeclarationEntry* pSODeclaration, uint NumEntries, uint* pBufferStrides, uint NumStrides, uint RasterizedStream, ID3D11ClassLinkage* pClassLinkage, ID3D11GeometryShader** ppGeometryShader) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[25]))((ID3D11Device3*)Unsafe.AsPointer(ref this), pShaderBytecode, BytecodeLength, pSODeclaration, NumEntries, pBufferStrides, NumStrides, RasterizedStream, pClassLinkage, ppGeometryShader); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[25]))((ID3D11Device3*)Unsafe.AsPointer(ref this), pShaderBytecode, BytecodeLength, pSODeclaration, NumEntries, pBufferStrides, NumStrides, RasterizedStream, pClassLinkage, ppGeometryShader); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(26)] + public HResult CreatePixelShader(void* pShaderBytecode, nuint BytecodeLength, ID3D11ClassLinkage* pClassLinkage, ID3D11PixelShader** ppPixelShader) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[26]))((ID3D11Device3*)Unsafe.AsPointer(ref this), pShaderBytecode, BytecodeLength, pClassLinkage, ppPixelShader); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[26]))((ID3D11Device3*)Unsafe.AsPointer(ref this), pShaderBytecode, BytecodeLength, pClassLinkage, ppPixelShader); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(27)] + public HResult CreateHullShader(void* pShaderBytecode, nuint BytecodeLength, ID3D11ClassLinkage* pClassLinkage, ID3D11HullShader** ppHullShader) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[27]))((ID3D11Device3*)Unsafe.AsPointer(ref this), pShaderBytecode, BytecodeLength, pClassLinkage, ppHullShader); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[27]))((ID3D11Device3*)Unsafe.AsPointer(ref this), pShaderBytecode, BytecodeLength, pClassLinkage, ppHullShader); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(28)] + public HResult CreateDomainShader(void* pShaderBytecode, nuint BytecodeLength, ID3D11ClassLinkage* pClassLinkage, ID3D11DomainShader** ppDomainShader) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[28]))((ID3D11Device3*)Unsafe.AsPointer(ref this), pShaderBytecode, BytecodeLength, pClassLinkage, ppDomainShader); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[28]))((ID3D11Device3*)Unsafe.AsPointer(ref this), pShaderBytecode, BytecodeLength, pClassLinkage, ppDomainShader); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(29)] + public HResult CreateComputeShader(void* pShaderBytecode, nuint BytecodeLength, ID3D11ClassLinkage* pClassLinkage, ID3D11ComputeShader** ppComputeShader) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[29]))((ID3D11Device3*)Unsafe.AsPointer(ref this), pShaderBytecode, BytecodeLength, pClassLinkage, ppComputeShader); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[29]))((ID3D11Device3*)Unsafe.AsPointer(ref this), pShaderBytecode, BytecodeLength, pClassLinkage, ppComputeShader); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(30)] + public HResult CreateClassLinkage(ID3D11ClassLinkage** ppLinkage) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[30]))((ID3D11Device3*)Unsafe.AsPointer(ref this), ppLinkage); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[30]))((ID3D11Device3*)Unsafe.AsPointer(ref this), ppLinkage); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(31)] + public HResult CreateBlendState(BlendDescription* pBlendStateDesc, ID3D11BlendState** ppBlendState) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[31]))((ID3D11Device3*)Unsafe.AsPointer(ref this), pBlendStateDesc, ppBlendState); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[31]))((ID3D11Device3*)Unsafe.AsPointer(ref this), pBlendStateDesc, ppBlendState); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(32)] + public HResult CreateDepthStencilState(DepthStencilDescription* pDepthStencilDesc, ID3D11DepthStencilState** ppDepthStencilState) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[32]))((ID3D11Device3*)Unsafe.AsPointer(ref this), pDepthStencilDesc, ppDepthStencilState); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[32]))((ID3D11Device3*)Unsafe.AsPointer(ref this), pDepthStencilDesc, ppDepthStencilState); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(33)] + public HResult CreateRasterizerState(RasterizerDescription* pRasterizerDesc, ID3D11RasterizerState** ppRasterizerState) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[33]))((ID3D11Device3*)Unsafe.AsPointer(ref this), pRasterizerDesc, ppRasterizerState); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[33]))((ID3D11Device3*)Unsafe.AsPointer(ref this), pRasterizerDesc, ppRasterizerState); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(34)] + public HResult CreateSamplerState(SamplerDescription* pSamplerDesc, ID3D11SamplerState** ppSamplerState) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[34]))((ID3D11Device3*)Unsafe.AsPointer(ref this), pSamplerDesc, ppSamplerState); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[34]))((ID3D11Device3*)Unsafe.AsPointer(ref this), pSamplerDesc, ppSamplerState); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(35)] + public HResult CreateQuery(QueryDescription* pQueryDesc, ID3D11Query** ppQuery) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[35]))((ID3D11Device3*)Unsafe.AsPointer(ref this), pQueryDesc, ppQuery); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[35]))((ID3D11Device3*)Unsafe.AsPointer(ref this), pQueryDesc, ppQuery); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(36)] + public HResult CreatePredicate(QueryDescription* pPredicateDesc, ID3D11Predicate** ppPredicate) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[36]))((ID3D11Device3*)Unsafe.AsPointer(ref this), pPredicateDesc, ppPredicate); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[36]))((ID3D11Device3*)Unsafe.AsPointer(ref this), pPredicateDesc, ppPredicate); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(37)] + public HResult CreateCounter(CounterDescription* pCounterDesc, ID3D11Counter** ppCounter) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[37]))((ID3D11Device3*)Unsafe.AsPointer(ref this), pCounterDesc, ppCounter); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[37]))((ID3D11Device3*)Unsafe.AsPointer(ref this), pCounterDesc, ppCounter); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(38)] + public HResult CreateDeferredContext(uint ContextFlags, ID3D11DeviceContext** ppDeferredContext) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[38]))((ID3D11Device3*)Unsafe.AsPointer(ref this), ContextFlags, ppDeferredContext); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[38]))((ID3D11Device3*)Unsafe.AsPointer(ref this), ContextFlags, ppDeferredContext); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(39)] + public HResult OpenSharedResource(IntPtr* hResource, Guid* ReturnedInterface, void** ppResource) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[39]))((ID3D11Device3*)Unsafe.AsPointer(ref this), hResource, ReturnedInterface, ppResource); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[39]))((ID3D11Device3*)Unsafe.AsPointer(ref this), hResource, ReturnedInterface, ppResource); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(40)] + public HResult CheckFormatSupport(Graphics.Dxgi.Common.Format Format, uint* pFormatSupport) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[40]))((ID3D11Device3*)Unsafe.AsPointer(ref this), Format, pFormatSupport); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[40]))((ID3D11Device3*)Unsafe.AsPointer(ref this), Format, pFormatSupport); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(41)] + public HResult CheckMultisampleQualityLevels(Graphics.Dxgi.Common.Format Format, uint SampleCount, uint* pNumQualityLevels) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[41]))((ID3D11Device3*)Unsafe.AsPointer(ref this), Format, SampleCount, pNumQualityLevels); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[41]))((ID3D11Device3*)Unsafe.AsPointer(ref this), Format, SampleCount, pNumQualityLevels); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(42)] + public void CheckCounterInfo(CounterInfo* pCounterInfo) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[42]))((ID3D11Device3*)Unsafe.AsPointer(ref this), pCounterInfo); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[42]))((ID3D11Device3*)Unsafe.AsPointer(ref this), pCounterInfo); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(43)] + public HResult CheckCounter(CounterDescription* pDesc, CounterType* pType, uint* pActiveCounters, byte* szName, uint* pNameLength, byte* szUnits, uint* pUnitsLength, byte* szDescription, uint* pDescriptionLength) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[43]))((ID3D11Device3*)Unsafe.AsPointer(ref this), pDesc, pType, pActiveCounters, szName, pNameLength, szUnits, pUnitsLength, szDescription, pDescriptionLength); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[43]))((ID3D11Device3*)Unsafe.AsPointer(ref this), pDesc, pType, pActiveCounters, szName, pNameLength, szUnits, pUnitsLength, szDescription, pDescriptionLength); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(44)] + public HResult CheckFeatureSupport(Feature Feature, void* pFeatureSupportData, uint FeatureSupportDataSize) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[44]))((ID3D11Device3*)Unsafe.AsPointer(ref this), Feature, pFeatureSupportData, FeatureSupportDataSize); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[44]))((ID3D11Device3*)Unsafe.AsPointer(ref this), Feature, pFeatureSupportData, FeatureSupportDataSize); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(45)] + public HResult GetPrivateData(Guid* guid, uint* pDataSize, void* pData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[45]))((ID3D11Device3*)Unsafe.AsPointer(ref this), guid, pDataSize, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[45]))((ID3D11Device3*)Unsafe.AsPointer(ref this), guid, pDataSize, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(46)] + public HResult SetPrivateData(Guid* guid, uint DataSize, void* pData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[46]))((ID3D11Device3*)Unsafe.AsPointer(ref this), guid, DataSize, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[46]))((ID3D11Device3*)Unsafe.AsPointer(ref this), guid, DataSize, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(47)] + public HResult SetPrivateDataInterface(Guid* guid, IUnknown* pData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[47]))((ID3D11Device3*)Unsafe.AsPointer(ref this), guid, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[47]))((ID3D11Device3*)Unsafe.AsPointer(ref this), guid, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(48)] + public Graphics.Direct3D.FeatureLevel GetFeatureLevel() + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[48]))((ID3D11Device3*)Unsafe.AsPointer(ref this)); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[48]))((ID3D11Device3*)Unsafe.AsPointer(ref this)); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(49)] + public uint GetCreationFlags() + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[49]))((ID3D11Device3*)Unsafe.AsPointer(ref this)); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[49]))((ID3D11Device3*)Unsafe.AsPointer(ref this)); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(50)] + public HResult GetDeviceRemovedReason() + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[50]))((ID3D11Device3*)Unsafe.AsPointer(ref this)); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[50]))((ID3D11Device3*)Unsafe.AsPointer(ref this)); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(51)] + public void GetImmediateContext(ID3D11DeviceContext* ppImmediateContext) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[51]))((ID3D11Device3*)Unsafe.AsPointer(ref this), ppImmediateContext); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[51]))((ID3D11Device3*)Unsafe.AsPointer(ref this), ppImmediateContext); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(52)] + public HResult SetExceptionMode(uint RaiseFlags) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[52]))((ID3D11Device3*)Unsafe.AsPointer(ref this), RaiseFlags); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[52]))((ID3D11Device3*)Unsafe.AsPointer(ref this), RaiseFlags); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(53)] + public uint GetExceptionMode() + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[53]))((ID3D11Device3*)Unsafe.AsPointer(ref this)); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[53]))((ID3D11Device3*)Unsafe.AsPointer(ref this)); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(54)] + public HResult CreateTexture2D1(Texture2DDescription1* pDesc1, SubresourceData* pInitialData, ID3D11Texture2D1** ppTexture2D) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[54]))((ID3D11Device3*)Unsafe.AsPointer(ref this), pDesc1, pInitialData, ppTexture2D); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[54]))((ID3D11Device3*)Unsafe.AsPointer(ref this), pDesc1, pInitialData, ppTexture2D); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(55)] + public HResult CreateTexture3D1(Texture3DDescription1* pDesc1, SubresourceData* pInitialData, ID3D11Texture3D1** ppTexture3D) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[55]))((ID3D11Device3*)Unsafe.AsPointer(ref this), pDesc1, pInitialData, ppTexture3D); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[55]))((ID3D11Device3*)Unsafe.AsPointer(ref this), pDesc1, pInitialData, ppTexture3D); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(56)] + public HResult CreateRasterizerState2(RasterizerDescription2* pRasterizerDesc, ID3D11RasterizerState2** ppRasterizerState) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[56]))((ID3D11Device3*)Unsafe.AsPointer(ref this), pRasterizerDesc, ppRasterizerState); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[56]))((ID3D11Device3*)Unsafe.AsPointer(ref this), pRasterizerDesc, ppRasterizerState); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(57)] + public HResult CreateShaderResourceView1(ID3D11Resource* pResource, ShaderResourceViewDescription1* pDesc1, ID3D11ShaderResourceView1** ppSRView1) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[57]))((ID3D11Device3*)Unsafe.AsPointer(ref this), pResource, pDesc1, ppSRView1); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[57]))((ID3D11Device3*)Unsafe.AsPointer(ref this), pResource, pDesc1, ppSRView1); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(58)] + public HResult CreateUnorderedAccessView1(ID3D11Resource* pResource, UnorderedAccessViewDescription1* pDesc1, ID3D11UnorderedAccessView1** ppUAView1) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[58]))((ID3D11Device3*)Unsafe.AsPointer(ref this), pResource, pDesc1, ppUAView1); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[58]))((ID3D11Device3*)Unsafe.AsPointer(ref this), pResource, pDesc1, ppUAView1); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(59)] + public HResult CreateRenderTargetView1(ID3D11Resource* pResource, RenderTargetViewDescription1* pDesc1, ID3D11RenderTargetView1** ppRTView1) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[59]))((ID3D11Device3*)Unsafe.AsPointer(ref this), pResource, pDesc1, ppRTView1); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[59]))((ID3D11Device3*)Unsafe.AsPointer(ref this), pResource, pDesc1, ppRTView1); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(60)] + public HResult CreateQuery1(QueryDescription1* pQueryDesc1, ID3D11Query1** ppQuery1) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[60]))((ID3D11Device3*)Unsafe.AsPointer(ref this), pQueryDesc1, ppQuery1); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[60]))((ID3D11Device3*)Unsafe.AsPointer(ref this), pQueryDesc1, ppQuery1); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(61)] + public void GetImmediateContext3(ID3D11DeviceContext3* ppImmediateContext) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[61]))((ID3D11Device3*)Unsafe.AsPointer(ref this), ppImmediateContext); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[61]))((ID3D11Device3*)Unsafe.AsPointer(ref this), ppImmediateContext); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(62)] + public HResult CreateDeferredContext3(uint ContextFlags, ID3D11DeviceContext3** ppDeferredContext) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[62]))((ID3D11Device3*)Unsafe.AsPointer(ref this), ContextFlags, ppDeferredContext); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[62]))((ID3D11Device3*)Unsafe.AsPointer(ref this), ContextFlags, ppDeferredContext); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(63)] + public void WriteToSubresource(ID3D11Resource* pDstResource, uint DstSubresource, Box* pDstBox, void* pSrcData, uint SrcRowPitch, uint SrcDepthPitch) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[63]))((ID3D11Device3*)Unsafe.AsPointer(ref this), pDstResource, DstSubresource, pDstBox, pSrcData, SrcRowPitch, SrcDepthPitch); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[63]))((ID3D11Device3*)Unsafe.AsPointer(ref this), pDstResource, DstSubresource, pDstBox, pSrcData, SrcRowPitch, SrcDepthPitch); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(64)] + public void ReadFromSubresource(void* pDstData, uint DstRowPitch, uint DstDepthPitch, ID3D11Resource* pSrcResource, uint SrcSubresource, Box* pSrcBox) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[64]))((ID3D11Device3*)Unsafe.AsPointer(ref this), pDstData, DstRowPitch, DstDepthPitch, pSrcResource, SrcSubresource, pSrcBox); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[64]))((ID3D11Device3*)Unsafe.AsPointer(ref this), pDstData, DstRowPitch, DstDepthPitch, pSrcResource, SrcSubresource, pSrcBox); +#endif + } + + public interface Interface : ID3D11Device2.Interface + { + } +} + +/// +/// ID3D11Device4 +[Guid("8992ab71-02e6-4b8d-ba48-b056dcda42c4")] +[NativeTypeName("struct ID3D11Device4 : ID3D11Device3")] +[NativeInheritance("ID3D11Device3")] +public unsafe partial struct ID3D11Device4 : ID3D11Device4.Interface +{ + public static ref readonly Guid IID_ID3D11Device4 + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x71, 0xAB, 0x92, 0x89, + 0xE6, 0x02, + 0x8D, 0x4B, + 0xBA, + 0x48, + 0xB0, + 0x56, + 0xDC, + 0xDA, + 0x42, + 0xC4 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_ID3D11Device4)); + + public void** lpVtbl; + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(0)] + public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(1)] + [return: NativeTypeName("ULONG")] + public uint AddRef() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(2)] + [return: NativeTypeName("ULONG")] + public uint Release() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(3)] + public HResult CreateTexture2D1(Texture2DDescription1* pDesc1, SubresourceData* pInitialData, ID3D11Texture2D1** ppTexture2D) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[3]))((ID3D11Device4*)Unsafe.AsPointer(ref this), pDesc1, pInitialData, ppTexture2D); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((ID3D11Device4*)Unsafe.AsPointer(ref this), pDesc1, pInitialData, ppTexture2D); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public HResult CreateTexture3D1(Texture3DDescription1* pDesc1, SubresourceData* pInitialData, ID3D11Texture3D1** ppTexture3D) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[4]))((ID3D11Device4*)Unsafe.AsPointer(ref this), pDesc1, pInitialData, ppTexture3D); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((ID3D11Device4*)Unsafe.AsPointer(ref this), pDesc1, pInitialData, ppTexture3D); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(5)] + public HResult CreateRasterizerState2(RasterizerDescription2* pRasterizerDesc, ID3D11RasterizerState2** ppRasterizerState) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[5]))((ID3D11Device4*)Unsafe.AsPointer(ref this), pRasterizerDesc, ppRasterizerState); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((ID3D11Device4*)Unsafe.AsPointer(ref this), pRasterizerDesc, ppRasterizerState); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(6)] + public HResult CreateShaderResourceView1(ID3D11Resource* pResource, ShaderResourceViewDescription1* pDesc1, ID3D11ShaderResourceView1** ppSRView1) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[6]))((ID3D11Device4*)Unsafe.AsPointer(ref this), pResource, pDesc1, ppSRView1); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((ID3D11Device4*)Unsafe.AsPointer(ref this), pResource, pDesc1, ppSRView1); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(7)] + public HResult CreateUnorderedAccessView1(ID3D11Resource* pResource, UnorderedAccessViewDescription1* pDesc1, ID3D11UnorderedAccessView1** ppUAView1) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[7]))((ID3D11Device4*)Unsafe.AsPointer(ref this), pResource, pDesc1, ppUAView1); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((ID3D11Device4*)Unsafe.AsPointer(ref this), pResource, pDesc1, ppUAView1); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(8)] + public HResult CreateRenderTargetView1(ID3D11Resource* pResource, RenderTargetViewDescription1* pDesc1, ID3D11RenderTargetView1** ppRTView1) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[8]))((ID3D11Device4*)Unsafe.AsPointer(ref this), pResource, pDesc1, ppRTView1); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[8]))((ID3D11Device4*)Unsafe.AsPointer(ref this), pResource, pDesc1, ppRTView1); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(9)] + public HResult CreateQuery1(QueryDescription1* pQueryDesc1, ID3D11Query1** ppQuery1) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[9]))((ID3D11Device4*)Unsafe.AsPointer(ref this), pQueryDesc1, ppQuery1); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[9]))((ID3D11Device4*)Unsafe.AsPointer(ref this), pQueryDesc1, ppQuery1); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(10)] + public void GetImmediateContext3(ID3D11DeviceContext3* ppImmediateContext) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[10]))((ID3D11Device4*)Unsafe.AsPointer(ref this), ppImmediateContext); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[10]))((ID3D11Device4*)Unsafe.AsPointer(ref this), ppImmediateContext); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(11)] + public HResult CreateDeferredContext3(uint ContextFlags, ID3D11DeviceContext3** ppDeferredContext) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[11]))((ID3D11Device4*)Unsafe.AsPointer(ref this), ContextFlags, ppDeferredContext); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[11]))((ID3D11Device4*)Unsafe.AsPointer(ref this), ContextFlags, ppDeferredContext); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(12)] + public void WriteToSubresource(ID3D11Resource* pDstResource, uint DstSubresource, Box* pDstBox, void* pSrcData, uint SrcRowPitch, uint SrcDepthPitch) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[12]))((ID3D11Device4*)Unsafe.AsPointer(ref this), pDstResource, DstSubresource, pDstBox, pSrcData, SrcRowPitch, SrcDepthPitch); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[12]))((ID3D11Device4*)Unsafe.AsPointer(ref this), pDstResource, DstSubresource, pDstBox, pSrcData, SrcRowPitch, SrcDepthPitch); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(13)] + public void ReadFromSubresource(void* pDstData, uint DstRowPitch, uint DstDepthPitch, ID3D11Resource* pSrcResource, uint SrcSubresource, Box* pSrcBox) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[13]))((ID3D11Device4*)Unsafe.AsPointer(ref this), pDstData, DstRowPitch, DstDepthPitch, pSrcResource, SrcSubresource, pSrcBox); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[13]))((ID3D11Device4*)Unsafe.AsPointer(ref this), pDstData, DstRowPitch, DstDepthPitch, pSrcResource, SrcSubresource, pSrcBox); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(14)] + public void GetImmediateContext2(ID3D11DeviceContext2* ppImmediateContext) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[14]))((ID3D11Device4*)Unsafe.AsPointer(ref this), ppImmediateContext); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[14]))((ID3D11Device4*)Unsafe.AsPointer(ref this), ppImmediateContext); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(15)] + public HResult CreateDeferredContext2(uint ContextFlags, ID3D11DeviceContext2** ppDeferredContext) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[15]))((ID3D11Device4*)Unsafe.AsPointer(ref this), ContextFlags, ppDeferredContext); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[15]))((ID3D11Device4*)Unsafe.AsPointer(ref this), ContextFlags, ppDeferredContext); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(16)] + public void GetResourceTiling(ID3D11Resource* pTiledResource, uint* pNumTilesForEntireResource, PackedMipDescription* pPackedMipDesc, TileShape* pStandardTileShapeForNonPackedMips, uint* pNumSubresourceTilings, uint FirstSubresourceTilingToGet, SubresourceTiling* pSubresourceTilingsForNonPackedMips) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[16]))((ID3D11Device4*)Unsafe.AsPointer(ref this), pTiledResource, pNumTilesForEntireResource, pPackedMipDesc, pStandardTileShapeForNonPackedMips, pNumSubresourceTilings, FirstSubresourceTilingToGet, pSubresourceTilingsForNonPackedMips); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[16]))((ID3D11Device4*)Unsafe.AsPointer(ref this), pTiledResource, pNumTilesForEntireResource, pPackedMipDesc, pStandardTileShapeForNonPackedMips, pNumSubresourceTilings, FirstSubresourceTilingToGet, pSubresourceTilingsForNonPackedMips); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(17)] + public HResult CheckMultisampleQualityLevels1(Graphics.Dxgi.Common.Format Format, uint SampleCount, uint Flags, uint* pNumQualityLevels) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[17]))((ID3D11Device4*)Unsafe.AsPointer(ref this), Format, SampleCount, Flags, pNumQualityLevels); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[17]))((ID3D11Device4*)Unsafe.AsPointer(ref this), Format, SampleCount, Flags, pNumQualityLevels); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(18)] + public void GetImmediateContext1(ID3D11DeviceContext1* ppImmediateContext) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[18]))((ID3D11Device4*)Unsafe.AsPointer(ref this), ppImmediateContext); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[18]))((ID3D11Device4*)Unsafe.AsPointer(ref this), ppImmediateContext); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(19)] + public HResult CreateDeferredContext1(uint ContextFlags, ID3D11DeviceContext1** ppDeferredContext) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[19]))((ID3D11Device4*)Unsafe.AsPointer(ref this), ContextFlags, ppDeferredContext); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[19]))((ID3D11Device4*)Unsafe.AsPointer(ref this), ContextFlags, ppDeferredContext); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(20)] + public HResult CreateBlendState1(BlendDescription1* pBlendStateDesc, ID3D11BlendState1** ppBlendState) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[20]))((ID3D11Device4*)Unsafe.AsPointer(ref this), pBlendStateDesc, ppBlendState); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[20]))((ID3D11Device4*)Unsafe.AsPointer(ref this), pBlendStateDesc, ppBlendState); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(21)] + public HResult CreateRasterizerState1(RasterizerDescription1* pRasterizerDesc, ID3D11RasterizerState1** ppRasterizerState) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[21]))((ID3D11Device4*)Unsafe.AsPointer(ref this), pRasterizerDesc, ppRasterizerState); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[21]))((ID3D11Device4*)Unsafe.AsPointer(ref this), pRasterizerDesc, ppRasterizerState); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(22)] + public HResult CreateDeviceContextState(uint Flags, Graphics.Direct3D.FeatureLevel* pFeatureLevels, uint FeatureLevels, uint SDKVersion, Guid* EmulatedInterface, Graphics.Direct3D.FeatureLevel* pChosenFeatureLevel, ID3DDeviceContextState* ppContextState) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[22]))((ID3D11Device4*)Unsafe.AsPointer(ref this), Flags, pFeatureLevels, FeatureLevels, SDKVersion, EmulatedInterface, pChosenFeatureLevel, ppContextState); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[22]))((ID3D11Device4*)Unsafe.AsPointer(ref this), Flags, pFeatureLevels, FeatureLevels, SDKVersion, EmulatedInterface, pChosenFeatureLevel, ppContextState); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(23)] + public HResult OpenSharedResource1(IntPtr* hResource, Guid* returnedInterface, void** ppResource) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[23]))((ID3D11Device4*)Unsafe.AsPointer(ref this), hResource, returnedInterface, ppResource); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[23]))((ID3D11Device4*)Unsafe.AsPointer(ref this), hResource, returnedInterface, ppResource); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(24)] + public HResult OpenSharedResourceByName(char** lpName, uint dwDesiredAccess, Guid* returnedInterface, void** ppResource) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[24]))((ID3D11Device4*)Unsafe.AsPointer(ref this), lpName, dwDesiredAccess, returnedInterface, ppResource); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[24]))((ID3D11Device4*)Unsafe.AsPointer(ref this), lpName, dwDesiredAccess, returnedInterface, ppResource); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(25)] + public HResult CreateBuffer(BufferDescription* pDesc, SubresourceData* pInitialData, ID3D11Buffer** ppBuffer) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[25]))((ID3D11Device4*)Unsafe.AsPointer(ref this), pDesc, pInitialData, ppBuffer); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[25]))((ID3D11Device4*)Unsafe.AsPointer(ref this), pDesc, pInitialData, ppBuffer); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(26)] + public HResult CreateTexture1D(Texture1DDescription* pDesc, SubresourceData* pInitialData, ID3D11Texture1D** ppTexture1D) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[26]))((ID3D11Device4*)Unsafe.AsPointer(ref this), pDesc, pInitialData, ppTexture1D); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[26]))((ID3D11Device4*)Unsafe.AsPointer(ref this), pDesc, pInitialData, ppTexture1D); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(27)] + public HResult CreateTexture2D(Texture2DDescription* pDesc, SubresourceData* pInitialData, ID3D11Texture2D** ppTexture2D) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[27]))((ID3D11Device4*)Unsafe.AsPointer(ref this), pDesc, pInitialData, ppTexture2D); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[27]))((ID3D11Device4*)Unsafe.AsPointer(ref this), pDesc, pInitialData, ppTexture2D); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(28)] + public HResult CreateTexture3D(Texture3DDescription* pDesc, SubresourceData* pInitialData, ID3D11Texture3D** ppTexture3D) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[28]))((ID3D11Device4*)Unsafe.AsPointer(ref this), pDesc, pInitialData, ppTexture3D); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[28]))((ID3D11Device4*)Unsafe.AsPointer(ref this), pDesc, pInitialData, ppTexture3D); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(29)] + public HResult CreateShaderResourceView(ID3D11Resource* pResource, ShaderResourceViewDescription* pDesc, ID3D11ShaderResourceView** ppSRView) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[29]))((ID3D11Device4*)Unsafe.AsPointer(ref this), pResource, pDesc, ppSRView); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[29]))((ID3D11Device4*)Unsafe.AsPointer(ref this), pResource, pDesc, ppSRView); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(30)] + public HResult CreateUnorderedAccessView(ID3D11Resource* pResource, UnorderedAccessViewDescription* pDesc, ID3D11UnorderedAccessView** ppUAView) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[30]))((ID3D11Device4*)Unsafe.AsPointer(ref this), pResource, pDesc, ppUAView); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[30]))((ID3D11Device4*)Unsafe.AsPointer(ref this), pResource, pDesc, ppUAView); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(31)] + public HResult CreateRenderTargetView(ID3D11Resource* pResource, RenderTargetViewDescription* pDesc, ID3D11RenderTargetView** ppRTView) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[31]))((ID3D11Device4*)Unsafe.AsPointer(ref this), pResource, pDesc, ppRTView); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[31]))((ID3D11Device4*)Unsafe.AsPointer(ref this), pResource, pDesc, ppRTView); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(32)] + public HResult CreateDepthStencilView(ID3D11Resource* pResource, DepthStencilViewDescription* pDesc, ID3D11DepthStencilView** ppDepthStencilView) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[32]))((ID3D11Device4*)Unsafe.AsPointer(ref this), pResource, pDesc, ppDepthStencilView); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[32]))((ID3D11Device4*)Unsafe.AsPointer(ref this), pResource, pDesc, ppDepthStencilView); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(33)] + public HResult CreateInputLayout(InputElementDescription* pInputElementDescs, uint NumElements, void* pShaderBytecodeWithInputSignature, nuint BytecodeLength, ID3D11InputLayout** ppInputLayout) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[33]))((ID3D11Device4*)Unsafe.AsPointer(ref this), pInputElementDescs, NumElements, pShaderBytecodeWithInputSignature, BytecodeLength, ppInputLayout); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[33]))((ID3D11Device4*)Unsafe.AsPointer(ref this), pInputElementDescs, NumElements, pShaderBytecodeWithInputSignature, BytecodeLength, ppInputLayout); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(34)] + public HResult CreateVertexShader(void* pShaderBytecode, nuint BytecodeLength, ID3D11ClassLinkage* pClassLinkage, ID3D11VertexShader** ppVertexShader) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[34]))((ID3D11Device4*)Unsafe.AsPointer(ref this), pShaderBytecode, BytecodeLength, pClassLinkage, ppVertexShader); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[34]))((ID3D11Device4*)Unsafe.AsPointer(ref this), pShaderBytecode, BytecodeLength, pClassLinkage, ppVertexShader); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(35)] + public HResult CreateGeometryShader(void* pShaderBytecode, nuint BytecodeLength, ID3D11ClassLinkage* pClassLinkage, ID3D11GeometryShader** ppGeometryShader) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[35]))((ID3D11Device4*)Unsafe.AsPointer(ref this), pShaderBytecode, BytecodeLength, pClassLinkage, ppGeometryShader); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[35]))((ID3D11Device4*)Unsafe.AsPointer(ref this), pShaderBytecode, BytecodeLength, pClassLinkage, ppGeometryShader); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(36)] + public HResult CreateGeometryShaderWithStreamOutput(void* pShaderBytecode, nuint BytecodeLength, SoDeclarationEntry* pSODeclaration, uint NumEntries, uint* pBufferStrides, uint NumStrides, uint RasterizedStream, ID3D11ClassLinkage* pClassLinkage, ID3D11GeometryShader** ppGeometryShader) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[36]))((ID3D11Device4*)Unsafe.AsPointer(ref this), pShaderBytecode, BytecodeLength, pSODeclaration, NumEntries, pBufferStrides, NumStrides, RasterizedStream, pClassLinkage, ppGeometryShader); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[36]))((ID3D11Device4*)Unsafe.AsPointer(ref this), pShaderBytecode, BytecodeLength, pSODeclaration, NumEntries, pBufferStrides, NumStrides, RasterizedStream, pClassLinkage, ppGeometryShader); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(37)] + public HResult CreatePixelShader(void* pShaderBytecode, nuint BytecodeLength, ID3D11ClassLinkage* pClassLinkage, ID3D11PixelShader** ppPixelShader) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[37]))((ID3D11Device4*)Unsafe.AsPointer(ref this), pShaderBytecode, BytecodeLength, pClassLinkage, ppPixelShader); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[37]))((ID3D11Device4*)Unsafe.AsPointer(ref this), pShaderBytecode, BytecodeLength, pClassLinkage, ppPixelShader); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(38)] + public HResult CreateHullShader(void* pShaderBytecode, nuint BytecodeLength, ID3D11ClassLinkage* pClassLinkage, ID3D11HullShader** ppHullShader) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[38]))((ID3D11Device4*)Unsafe.AsPointer(ref this), pShaderBytecode, BytecodeLength, pClassLinkage, ppHullShader); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[38]))((ID3D11Device4*)Unsafe.AsPointer(ref this), pShaderBytecode, BytecodeLength, pClassLinkage, ppHullShader); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(39)] + public HResult CreateDomainShader(void* pShaderBytecode, nuint BytecodeLength, ID3D11ClassLinkage* pClassLinkage, ID3D11DomainShader** ppDomainShader) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[39]))((ID3D11Device4*)Unsafe.AsPointer(ref this), pShaderBytecode, BytecodeLength, pClassLinkage, ppDomainShader); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[39]))((ID3D11Device4*)Unsafe.AsPointer(ref this), pShaderBytecode, BytecodeLength, pClassLinkage, ppDomainShader); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(40)] + public HResult CreateComputeShader(void* pShaderBytecode, nuint BytecodeLength, ID3D11ClassLinkage* pClassLinkage, ID3D11ComputeShader** ppComputeShader) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[40]))((ID3D11Device4*)Unsafe.AsPointer(ref this), pShaderBytecode, BytecodeLength, pClassLinkage, ppComputeShader); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[40]))((ID3D11Device4*)Unsafe.AsPointer(ref this), pShaderBytecode, BytecodeLength, pClassLinkage, ppComputeShader); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(41)] + public HResult CreateClassLinkage(ID3D11ClassLinkage** ppLinkage) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[41]))((ID3D11Device4*)Unsafe.AsPointer(ref this), ppLinkage); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[41]))((ID3D11Device4*)Unsafe.AsPointer(ref this), ppLinkage); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(42)] + public HResult CreateBlendState(BlendDescription* pBlendStateDesc, ID3D11BlendState** ppBlendState) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[42]))((ID3D11Device4*)Unsafe.AsPointer(ref this), pBlendStateDesc, ppBlendState); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[42]))((ID3D11Device4*)Unsafe.AsPointer(ref this), pBlendStateDesc, ppBlendState); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(43)] + public HResult CreateDepthStencilState(DepthStencilDescription* pDepthStencilDesc, ID3D11DepthStencilState** ppDepthStencilState) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[43]))((ID3D11Device4*)Unsafe.AsPointer(ref this), pDepthStencilDesc, ppDepthStencilState); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[43]))((ID3D11Device4*)Unsafe.AsPointer(ref this), pDepthStencilDesc, ppDepthStencilState); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(44)] + public HResult CreateRasterizerState(RasterizerDescription* pRasterizerDesc, ID3D11RasterizerState** ppRasterizerState) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[44]))((ID3D11Device4*)Unsafe.AsPointer(ref this), pRasterizerDesc, ppRasterizerState); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[44]))((ID3D11Device4*)Unsafe.AsPointer(ref this), pRasterizerDesc, ppRasterizerState); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(45)] + public HResult CreateSamplerState(SamplerDescription* pSamplerDesc, ID3D11SamplerState** ppSamplerState) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[45]))((ID3D11Device4*)Unsafe.AsPointer(ref this), pSamplerDesc, ppSamplerState); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[45]))((ID3D11Device4*)Unsafe.AsPointer(ref this), pSamplerDesc, ppSamplerState); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(46)] + public HResult CreateQuery(QueryDescription* pQueryDesc, ID3D11Query** ppQuery) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[46]))((ID3D11Device4*)Unsafe.AsPointer(ref this), pQueryDesc, ppQuery); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[46]))((ID3D11Device4*)Unsafe.AsPointer(ref this), pQueryDesc, ppQuery); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(47)] + public HResult CreatePredicate(QueryDescription* pPredicateDesc, ID3D11Predicate** ppPredicate) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[47]))((ID3D11Device4*)Unsafe.AsPointer(ref this), pPredicateDesc, ppPredicate); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[47]))((ID3D11Device4*)Unsafe.AsPointer(ref this), pPredicateDesc, ppPredicate); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(48)] + public HResult CreateCounter(CounterDescription* pCounterDesc, ID3D11Counter** ppCounter) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[48]))((ID3D11Device4*)Unsafe.AsPointer(ref this), pCounterDesc, ppCounter); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[48]))((ID3D11Device4*)Unsafe.AsPointer(ref this), pCounterDesc, ppCounter); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(49)] + public HResult CreateDeferredContext(uint ContextFlags, ID3D11DeviceContext** ppDeferredContext) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[49]))((ID3D11Device4*)Unsafe.AsPointer(ref this), ContextFlags, ppDeferredContext); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[49]))((ID3D11Device4*)Unsafe.AsPointer(ref this), ContextFlags, ppDeferredContext); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(50)] + public HResult OpenSharedResource(IntPtr* hResource, Guid* ReturnedInterface, void** ppResource) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[50]))((ID3D11Device4*)Unsafe.AsPointer(ref this), hResource, ReturnedInterface, ppResource); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[50]))((ID3D11Device4*)Unsafe.AsPointer(ref this), hResource, ReturnedInterface, ppResource); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(51)] + public HResult CheckFormatSupport(Graphics.Dxgi.Common.Format Format, uint* pFormatSupport) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[51]))((ID3D11Device4*)Unsafe.AsPointer(ref this), Format, pFormatSupport); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[51]))((ID3D11Device4*)Unsafe.AsPointer(ref this), Format, pFormatSupport); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(52)] + public HResult CheckMultisampleQualityLevels(Graphics.Dxgi.Common.Format Format, uint SampleCount, uint* pNumQualityLevels) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[52]))((ID3D11Device4*)Unsafe.AsPointer(ref this), Format, SampleCount, pNumQualityLevels); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[52]))((ID3D11Device4*)Unsafe.AsPointer(ref this), Format, SampleCount, pNumQualityLevels); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(53)] + public void CheckCounterInfo(CounterInfo* pCounterInfo) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[53]))((ID3D11Device4*)Unsafe.AsPointer(ref this), pCounterInfo); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[53]))((ID3D11Device4*)Unsafe.AsPointer(ref this), pCounterInfo); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(54)] + public HResult CheckCounter(CounterDescription* pDesc, CounterType* pType, uint* pActiveCounters, byte* szName, uint* pNameLength, byte* szUnits, uint* pUnitsLength, byte* szDescription, uint* pDescriptionLength) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[54]))((ID3D11Device4*)Unsafe.AsPointer(ref this), pDesc, pType, pActiveCounters, szName, pNameLength, szUnits, pUnitsLength, szDescription, pDescriptionLength); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[54]))((ID3D11Device4*)Unsafe.AsPointer(ref this), pDesc, pType, pActiveCounters, szName, pNameLength, szUnits, pUnitsLength, szDescription, pDescriptionLength); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(55)] + public HResult CheckFeatureSupport(Feature Feature, void* pFeatureSupportData, uint FeatureSupportDataSize) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[55]))((ID3D11Device4*)Unsafe.AsPointer(ref this), Feature, pFeatureSupportData, FeatureSupportDataSize); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[55]))((ID3D11Device4*)Unsafe.AsPointer(ref this), Feature, pFeatureSupportData, FeatureSupportDataSize); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(56)] + public HResult GetPrivateData(Guid* guid, uint* pDataSize, void* pData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[56]))((ID3D11Device4*)Unsafe.AsPointer(ref this), guid, pDataSize, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[56]))((ID3D11Device4*)Unsafe.AsPointer(ref this), guid, pDataSize, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(57)] + public HResult SetPrivateData(Guid* guid, uint DataSize, void* pData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[57]))((ID3D11Device4*)Unsafe.AsPointer(ref this), guid, DataSize, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[57]))((ID3D11Device4*)Unsafe.AsPointer(ref this), guid, DataSize, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(58)] + public HResult SetPrivateDataInterface(Guid* guid, IUnknown* pData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[58]))((ID3D11Device4*)Unsafe.AsPointer(ref this), guid, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[58]))((ID3D11Device4*)Unsafe.AsPointer(ref this), guid, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(59)] + public Graphics.Direct3D.FeatureLevel GetFeatureLevel() + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[59]))((ID3D11Device4*)Unsafe.AsPointer(ref this)); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[59]))((ID3D11Device4*)Unsafe.AsPointer(ref this)); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(60)] + public uint GetCreationFlags() + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[60]))((ID3D11Device4*)Unsafe.AsPointer(ref this)); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[60]))((ID3D11Device4*)Unsafe.AsPointer(ref this)); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(61)] + public HResult GetDeviceRemovedReason() + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[61]))((ID3D11Device4*)Unsafe.AsPointer(ref this)); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[61]))((ID3D11Device4*)Unsafe.AsPointer(ref this)); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(62)] + public void GetImmediateContext(ID3D11DeviceContext* ppImmediateContext) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[62]))((ID3D11Device4*)Unsafe.AsPointer(ref this), ppImmediateContext); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[62]))((ID3D11Device4*)Unsafe.AsPointer(ref this), ppImmediateContext); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(63)] + public HResult SetExceptionMode(uint RaiseFlags) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[63]))((ID3D11Device4*)Unsafe.AsPointer(ref this), RaiseFlags); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[63]))((ID3D11Device4*)Unsafe.AsPointer(ref this), RaiseFlags); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(64)] + public uint GetExceptionMode() + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[64]))((ID3D11Device4*)Unsafe.AsPointer(ref this)); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[64]))((ID3D11Device4*)Unsafe.AsPointer(ref this)); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(65)] + public HResult RegisterDeviceRemovedEvent(IntPtr* hEvent, uint* pdwCookie) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[65]))((ID3D11Device4*)Unsafe.AsPointer(ref this), hEvent, pdwCookie); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[65]))((ID3D11Device4*)Unsafe.AsPointer(ref this), hEvent, pdwCookie); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(66)] + public void UnregisterDeviceRemoved(uint dwCookie) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[66]))((ID3D11Device4*)Unsafe.AsPointer(ref this), dwCookie); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[66]))((ID3D11Device4*)Unsafe.AsPointer(ref this), dwCookie); +#endif + } + + public interface Interface : ID3D11Device3.Interface + { + } +} + +/// +/// ID3D11Device5 +[Guid("8ffde202-a0e7-45df-9e01-e837801b5ea0")] +[NativeTypeName("struct ID3D11Device5 : ID3D11Device4")] +[NativeInheritance("ID3D11Device4")] +public unsafe partial struct ID3D11Device5 : ID3D11Device5.Interface +{ + public static ref readonly Guid IID_ID3D11Device5 + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x02, 0xE2, 0xFD, 0x8F, + 0xE7, 0xA0, + 0xDF, 0x45, + 0x9E, + 0x01, + 0xE8, + 0x37, + 0x80, + 0x1B, + 0x5E, + 0xA0 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_ID3D11Device5)); + + public void** lpVtbl; + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(0)] + public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(1)] + [return: NativeTypeName("ULONG")] + public uint AddRef() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(2)] + [return: NativeTypeName("ULONG")] + public uint Release() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(3)] + public HResult RegisterDeviceRemovedEvent(IntPtr* hEvent, uint* pdwCookie) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[3]))((ID3D11Device5*)Unsafe.AsPointer(ref this), hEvent, pdwCookie); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((ID3D11Device5*)Unsafe.AsPointer(ref this), hEvent, pdwCookie); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public void UnregisterDeviceRemoved(uint dwCookie) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[4]))((ID3D11Device5*)Unsafe.AsPointer(ref this), dwCookie); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((ID3D11Device5*)Unsafe.AsPointer(ref this), dwCookie); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(5)] + public HResult CreateTexture2D1(Texture2DDescription1* pDesc1, SubresourceData* pInitialData, ID3D11Texture2D1** ppTexture2D) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[5]))((ID3D11Device5*)Unsafe.AsPointer(ref this), pDesc1, pInitialData, ppTexture2D); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((ID3D11Device5*)Unsafe.AsPointer(ref this), pDesc1, pInitialData, ppTexture2D); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(6)] + public HResult CreateTexture3D1(Texture3DDescription1* pDesc1, SubresourceData* pInitialData, ID3D11Texture3D1** ppTexture3D) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[6]))((ID3D11Device5*)Unsafe.AsPointer(ref this), pDesc1, pInitialData, ppTexture3D); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((ID3D11Device5*)Unsafe.AsPointer(ref this), pDesc1, pInitialData, ppTexture3D); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(7)] + public HResult CreateRasterizerState2(RasterizerDescription2* pRasterizerDesc, ID3D11RasterizerState2** ppRasterizerState) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[7]))((ID3D11Device5*)Unsafe.AsPointer(ref this), pRasterizerDesc, ppRasterizerState); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((ID3D11Device5*)Unsafe.AsPointer(ref this), pRasterizerDesc, ppRasterizerState); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(8)] + public HResult CreateShaderResourceView1(ID3D11Resource* pResource, ShaderResourceViewDescription1* pDesc1, ID3D11ShaderResourceView1** ppSRView1) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[8]))((ID3D11Device5*)Unsafe.AsPointer(ref this), pResource, pDesc1, ppSRView1); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[8]))((ID3D11Device5*)Unsafe.AsPointer(ref this), pResource, pDesc1, ppSRView1); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(9)] + public HResult CreateUnorderedAccessView1(ID3D11Resource* pResource, UnorderedAccessViewDescription1* pDesc1, ID3D11UnorderedAccessView1** ppUAView1) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[9]))((ID3D11Device5*)Unsafe.AsPointer(ref this), pResource, pDesc1, ppUAView1); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[9]))((ID3D11Device5*)Unsafe.AsPointer(ref this), pResource, pDesc1, ppUAView1); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(10)] + public HResult CreateRenderTargetView1(ID3D11Resource* pResource, RenderTargetViewDescription1* pDesc1, ID3D11RenderTargetView1** ppRTView1) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[10]))((ID3D11Device5*)Unsafe.AsPointer(ref this), pResource, pDesc1, ppRTView1); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[10]))((ID3D11Device5*)Unsafe.AsPointer(ref this), pResource, pDesc1, ppRTView1); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(11)] + public HResult CreateQuery1(QueryDescription1* pQueryDesc1, ID3D11Query1** ppQuery1) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[11]))((ID3D11Device5*)Unsafe.AsPointer(ref this), pQueryDesc1, ppQuery1); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[11]))((ID3D11Device5*)Unsafe.AsPointer(ref this), pQueryDesc1, ppQuery1); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(12)] + public void GetImmediateContext3(ID3D11DeviceContext3* ppImmediateContext) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[12]))((ID3D11Device5*)Unsafe.AsPointer(ref this), ppImmediateContext); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[12]))((ID3D11Device5*)Unsafe.AsPointer(ref this), ppImmediateContext); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(13)] + public HResult CreateDeferredContext3(uint ContextFlags, ID3D11DeviceContext3** ppDeferredContext) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[13]))((ID3D11Device5*)Unsafe.AsPointer(ref this), ContextFlags, ppDeferredContext); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[13]))((ID3D11Device5*)Unsafe.AsPointer(ref this), ContextFlags, ppDeferredContext); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(14)] + public void WriteToSubresource(ID3D11Resource* pDstResource, uint DstSubresource, Box* pDstBox, void* pSrcData, uint SrcRowPitch, uint SrcDepthPitch) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[14]))((ID3D11Device5*)Unsafe.AsPointer(ref this), pDstResource, DstSubresource, pDstBox, pSrcData, SrcRowPitch, SrcDepthPitch); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[14]))((ID3D11Device5*)Unsafe.AsPointer(ref this), pDstResource, DstSubresource, pDstBox, pSrcData, SrcRowPitch, SrcDepthPitch); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(15)] + public void ReadFromSubresource(void* pDstData, uint DstRowPitch, uint DstDepthPitch, ID3D11Resource* pSrcResource, uint SrcSubresource, Box* pSrcBox) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[15]))((ID3D11Device5*)Unsafe.AsPointer(ref this), pDstData, DstRowPitch, DstDepthPitch, pSrcResource, SrcSubresource, pSrcBox); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[15]))((ID3D11Device5*)Unsafe.AsPointer(ref this), pDstData, DstRowPitch, DstDepthPitch, pSrcResource, SrcSubresource, pSrcBox); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(16)] + public void GetImmediateContext2(ID3D11DeviceContext2* ppImmediateContext) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[16]))((ID3D11Device5*)Unsafe.AsPointer(ref this), ppImmediateContext); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[16]))((ID3D11Device5*)Unsafe.AsPointer(ref this), ppImmediateContext); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(17)] + public HResult CreateDeferredContext2(uint ContextFlags, ID3D11DeviceContext2** ppDeferredContext) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[17]))((ID3D11Device5*)Unsafe.AsPointer(ref this), ContextFlags, ppDeferredContext); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[17]))((ID3D11Device5*)Unsafe.AsPointer(ref this), ContextFlags, ppDeferredContext); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(18)] + public void GetResourceTiling(ID3D11Resource* pTiledResource, uint* pNumTilesForEntireResource, PackedMipDescription* pPackedMipDesc, TileShape* pStandardTileShapeForNonPackedMips, uint* pNumSubresourceTilings, uint FirstSubresourceTilingToGet, SubresourceTiling* pSubresourceTilingsForNonPackedMips) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[18]))((ID3D11Device5*)Unsafe.AsPointer(ref this), pTiledResource, pNumTilesForEntireResource, pPackedMipDesc, pStandardTileShapeForNonPackedMips, pNumSubresourceTilings, FirstSubresourceTilingToGet, pSubresourceTilingsForNonPackedMips); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[18]))((ID3D11Device5*)Unsafe.AsPointer(ref this), pTiledResource, pNumTilesForEntireResource, pPackedMipDesc, pStandardTileShapeForNonPackedMips, pNumSubresourceTilings, FirstSubresourceTilingToGet, pSubresourceTilingsForNonPackedMips); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(19)] + public HResult CheckMultisampleQualityLevels1(Graphics.Dxgi.Common.Format Format, uint SampleCount, uint Flags, uint* pNumQualityLevels) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[19]))((ID3D11Device5*)Unsafe.AsPointer(ref this), Format, SampleCount, Flags, pNumQualityLevels); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[19]))((ID3D11Device5*)Unsafe.AsPointer(ref this), Format, SampleCount, Flags, pNumQualityLevels); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(20)] + public void GetImmediateContext1(ID3D11DeviceContext1* ppImmediateContext) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[20]))((ID3D11Device5*)Unsafe.AsPointer(ref this), ppImmediateContext); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[20]))((ID3D11Device5*)Unsafe.AsPointer(ref this), ppImmediateContext); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(21)] + public HResult CreateDeferredContext1(uint ContextFlags, ID3D11DeviceContext1** ppDeferredContext) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[21]))((ID3D11Device5*)Unsafe.AsPointer(ref this), ContextFlags, ppDeferredContext); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[21]))((ID3D11Device5*)Unsafe.AsPointer(ref this), ContextFlags, ppDeferredContext); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(22)] + public HResult CreateBlendState1(BlendDescription1* pBlendStateDesc, ID3D11BlendState1** ppBlendState) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[22]))((ID3D11Device5*)Unsafe.AsPointer(ref this), pBlendStateDesc, ppBlendState); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[22]))((ID3D11Device5*)Unsafe.AsPointer(ref this), pBlendStateDesc, ppBlendState); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(23)] + public HResult CreateRasterizerState1(RasterizerDescription1* pRasterizerDesc, ID3D11RasterizerState1** ppRasterizerState) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[23]))((ID3D11Device5*)Unsafe.AsPointer(ref this), pRasterizerDesc, ppRasterizerState); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[23]))((ID3D11Device5*)Unsafe.AsPointer(ref this), pRasterizerDesc, ppRasterizerState); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(24)] + public HResult CreateDeviceContextState(uint Flags, Graphics.Direct3D.FeatureLevel* pFeatureLevels, uint FeatureLevels, uint SDKVersion, Guid* EmulatedInterface, Graphics.Direct3D.FeatureLevel* pChosenFeatureLevel, ID3DDeviceContextState* ppContextState) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[24]))((ID3D11Device5*)Unsafe.AsPointer(ref this), Flags, pFeatureLevels, FeatureLevels, SDKVersion, EmulatedInterface, pChosenFeatureLevel, ppContextState); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[24]))((ID3D11Device5*)Unsafe.AsPointer(ref this), Flags, pFeatureLevels, FeatureLevels, SDKVersion, EmulatedInterface, pChosenFeatureLevel, ppContextState); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(25)] + public HResult OpenSharedResource1(IntPtr* hResource, Guid* returnedInterface, void** ppResource) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[25]))((ID3D11Device5*)Unsafe.AsPointer(ref this), hResource, returnedInterface, ppResource); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[25]))((ID3D11Device5*)Unsafe.AsPointer(ref this), hResource, returnedInterface, ppResource); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(26)] + public HResult OpenSharedResourceByName(char** lpName, uint dwDesiredAccess, Guid* returnedInterface, void** ppResource) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[26]))((ID3D11Device5*)Unsafe.AsPointer(ref this), lpName, dwDesiredAccess, returnedInterface, ppResource); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[26]))((ID3D11Device5*)Unsafe.AsPointer(ref this), lpName, dwDesiredAccess, returnedInterface, ppResource); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(27)] + public HResult CreateBuffer(BufferDescription* pDesc, SubresourceData* pInitialData, ID3D11Buffer** ppBuffer) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[27]))((ID3D11Device5*)Unsafe.AsPointer(ref this), pDesc, pInitialData, ppBuffer); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[27]))((ID3D11Device5*)Unsafe.AsPointer(ref this), pDesc, pInitialData, ppBuffer); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(28)] + public HResult CreateTexture1D(Texture1DDescription* pDesc, SubresourceData* pInitialData, ID3D11Texture1D** ppTexture1D) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[28]))((ID3D11Device5*)Unsafe.AsPointer(ref this), pDesc, pInitialData, ppTexture1D); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[28]))((ID3D11Device5*)Unsafe.AsPointer(ref this), pDesc, pInitialData, ppTexture1D); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(29)] + public HResult CreateTexture2D(Texture2DDescription* pDesc, SubresourceData* pInitialData, ID3D11Texture2D** ppTexture2D) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[29]))((ID3D11Device5*)Unsafe.AsPointer(ref this), pDesc, pInitialData, ppTexture2D); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[29]))((ID3D11Device5*)Unsafe.AsPointer(ref this), pDesc, pInitialData, ppTexture2D); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(30)] + public HResult CreateTexture3D(Texture3DDescription* pDesc, SubresourceData* pInitialData, ID3D11Texture3D** ppTexture3D) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[30]))((ID3D11Device5*)Unsafe.AsPointer(ref this), pDesc, pInitialData, ppTexture3D); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[30]))((ID3D11Device5*)Unsafe.AsPointer(ref this), pDesc, pInitialData, ppTexture3D); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(31)] + public HResult CreateShaderResourceView(ID3D11Resource* pResource, ShaderResourceViewDescription* pDesc, ID3D11ShaderResourceView** ppSRView) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[31]))((ID3D11Device5*)Unsafe.AsPointer(ref this), pResource, pDesc, ppSRView); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[31]))((ID3D11Device5*)Unsafe.AsPointer(ref this), pResource, pDesc, ppSRView); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(32)] + public HResult CreateUnorderedAccessView(ID3D11Resource* pResource, UnorderedAccessViewDescription* pDesc, ID3D11UnorderedAccessView** ppUAView) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[32]))((ID3D11Device5*)Unsafe.AsPointer(ref this), pResource, pDesc, ppUAView); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[32]))((ID3D11Device5*)Unsafe.AsPointer(ref this), pResource, pDesc, ppUAView); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(33)] + public HResult CreateRenderTargetView(ID3D11Resource* pResource, RenderTargetViewDescription* pDesc, ID3D11RenderTargetView** ppRTView) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[33]))((ID3D11Device5*)Unsafe.AsPointer(ref this), pResource, pDesc, ppRTView); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[33]))((ID3D11Device5*)Unsafe.AsPointer(ref this), pResource, pDesc, ppRTView); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(34)] + public HResult CreateDepthStencilView(ID3D11Resource* pResource, DepthStencilViewDescription* pDesc, ID3D11DepthStencilView** ppDepthStencilView) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[34]))((ID3D11Device5*)Unsafe.AsPointer(ref this), pResource, pDesc, ppDepthStencilView); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[34]))((ID3D11Device5*)Unsafe.AsPointer(ref this), pResource, pDesc, ppDepthStencilView); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(35)] + public HResult CreateInputLayout(InputElementDescription* pInputElementDescs, uint NumElements, void* pShaderBytecodeWithInputSignature, nuint BytecodeLength, ID3D11InputLayout** ppInputLayout) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[35]))((ID3D11Device5*)Unsafe.AsPointer(ref this), pInputElementDescs, NumElements, pShaderBytecodeWithInputSignature, BytecodeLength, ppInputLayout); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[35]))((ID3D11Device5*)Unsafe.AsPointer(ref this), pInputElementDescs, NumElements, pShaderBytecodeWithInputSignature, BytecodeLength, ppInputLayout); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(36)] + public HResult CreateVertexShader(void* pShaderBytecode, nuint BytecodeLength, ID3D11ClassLinkage* pClassLinkage, ID3D11VertexShader** ppVertexShader) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[36]))((ID3D11Device5*)Unsafe.AsPointer(ref this), pShaderBytecode, BytecodeLength, pClassLinkage, ppVertexShader); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[36]))((ID3D11Device5*)Unsafe.AsPointer(ref this), pShaderBytecode, BytecodeLength, pClassLinkage, ppVertexShader); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(37)] + public HResult CreateGeometryShader(void* pShaderBytecode, nuint BytecodeLength, ID3D11ClassLinkage* pClassLinkage, ID3D11GeometryShader** ppGeometryShader) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[37]))((ID3D11Device5*)Unsafe.AsPointer(ref this), pShaderBytecode, BytecodeLength, pClassLinkage, ppGeometryShader); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[37]))((ID3D11Device5*)Unsafe.AsPointer(ref this), pShaderBytecode, BytecodeLength, pClassLinkage, ppGeometryShader); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(38)] + public HResult CreateGeometryShaderWithStreamOutput(void* pShaderBytecode, nuint BytecodeLength, SoDeclarationEntry* pSODeclaration, uint NumEntries, uint* pBufferStrides, uint NumStrides, uint RasterizedStream, ID3D11ClassLinkage* pClassLinkage, ID3D11GeometryShader** ppGeometryShader) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[38]))((ID3D11Device5*)Unsafe.AsPointer(ref this), pShaderBytecode, BytecodeLength, pSODeclaration, NumEntries, pBufferStrides, NumStrides, RasterizedStream, pClassLinkage, ppGeometryShader); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[38]))((ID3D11Device5*)Unsafe.AsPointer(ref this), pShaderBytecode, BytecodeLength, pSODeclaration, NumEntries, pBufferStrides, NumStrides, RasterizedStream, pClassLinkage, ppGeometryShader); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(39)] + public HResult CreatePixelShader(void* pShaderBytecode, nuint BytecodeLength, ID3D11ClassLinkage* pClassLinkage, ID3D11PixelShader** ppPixelShader) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[39]))((ID3D11Device5*)Unsafe.AsPointer(ref this), pShaderBytecode, BytecodeLength, pClassLinkage, ppPixelShader); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[39]))((ID3D11Device5*)Unsafe.AsPointer(ref this), pShaderBytecode, BytecodeLength, pClassLinkage, ppPixelShader); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(40)] + public HResult CreateHullShader(void* pShaderBytecode, nuint BytecodeLength, ID3D11ClassLinkage* pClassLinkage, ID3D11HullShader** ppHullShader) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[40]))((ID3D11Device5*)Unsafe.AsPointer(ref this), pShaderBytecode, BytecodeLength, pClassLinkage, ppHullShader); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[40]))((ID3D11Device5*)Unsafe.AsPointer(ref this), pShaderBytecode, BytecodeLength, pClassLinkage, ppHullShader); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(41)] + public HResult CreateDomainShader(void* pShaderBytecode, nuint BytecodeLength, ID3D11ClassLinkage* pClassLinkage, ID3D11DomainShader** ppDomainShader) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[41]))((ID3D11Device5*)Unsafe.AsPointer(ref this), pShaderBytecode, BytecodeLength, pClassLinkage, ppDomainShader); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[41]))((ID3D11Device5*)Unsafe.AsPointer(ref this), pShaderBytecode, BytecodeLength, pClassLinkage, ppDomainShader); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(42)] + public HResult CreateComputeShader(void* pShaderBytecode, nuint BytecodeLength, ID3D11ClassLinkage* pClassLinkage, ID3D11ComputeShader** ppComputeShader) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[42]))((ID3D11Device5*)Unsafe.AsPointer(ref this), pShaderBytecode, BytecodeLength, pClassLinkage, ppComputeShader); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[42]))((ID3D11Device5*)Unsafe.AsPointer(ref this), pShaderBytecode, BytecodeLength, pClassLinkage, ppComputeShader); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(43)] + public HResult CreateClassLinkage(ID3D11ClassLinkage** ppLinkage) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[43]))((ID3D11Device5*)Unsafe.AsPointer(ref this), ppLinkage); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[43]))((ID3D11Device5*)Unsafe.AsPointer(ref this), ppLinkage); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(44)] + public HResult CreateBlendState(BlendDescription* pBlendStateDesc, ID3D11BlendState** ppBlendState) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[44]))((ID3D11Device5*)Unsafe.AsPointer(ref this), pBlendStateDesc, ppBlendState); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[44]))((ID3D11Device5*)Unsafe.AsPointer(ref this), pBlendStateDesc, ppBlendState); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(45)] + public HResult CreateDepthStencilState(DepthStencilDescription* pDepthStencilDesc, ID3D11DepthStencilState** ppDepthStencilState) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[45]))((ID3D11Device5*)Unsafe.AsPointer(ref this), pDepthStencilDesc, ppDepthStencilState); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[45]))((ID3D11Device5*)Unsafe.AsPointer(ref this), pDepthStencilDesc, ppDepthStencilState); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(46)] + public HResult CreateRasterizerState(RasterizerDescription* pRasterizerDesc, ID3D11RasterizerState** ppRasterizerState) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[46]))((ID3D11Device5*)Unsafe.AsPointer(ref this), pRasterizerDesc, ppRasterizerState); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[46]))((ID3D11Device5*)Unsafe.AsPointer(ref this), pRasterizerDesc, ppRasterizerState); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(47)] + public HResult CreateSamplerState(SamplerDescription* pSamplerDesc, ID3D11SamplerState** ppSamplerState) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[47]))((ID3D11Device5*)Unsafe.AsPointer(ref this), pSamplerDesc, ppSamplerState); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[47]))((ID3D11Device5*)Unsafe.AsPointer(ref this), pSamplerDesc, ppSamplerState); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(48)] + public HResult CreateQuery(QueryDescription* pQueryDesc, ID3D11Query** ppQuery) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[48]))((ID3D11Device5*)Unsafe.AsPointer(ref this), pQueryDesc, ppQuery); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[48]))((ID3D11Device5*)Unsafe.AsPointer(ref this), pQueryDesc, ppQuery); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(49)] + public HResult CreatePredicate(QueryDescription* pPredicateDesc, ID3D11Predicate** ppPredicate) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[49]))((ID3D11Device5*)Unsafe.AsPointer(ref this), pPredicateDesc, ppPredicate); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[49]))((ID3D11Device5*)Unsafe.AsPointer(ref this), pPredicateDesc, ppPredicate); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(50)] + public HResult CreateCounter(CounterDescription* pCounterDesc, ID3D11Counter** ppCounter) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[50]))((ID3D11Device5*)Unsafe.AsPointer(ref this), pCounterDesc, ppCounter); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[50]))((ID3D11Device5*)Unsafe.AsPointer(ref this), pCounterDesc, ppCounter); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(51)] + public HResult CreateDeferredContext(uint ContextFlags, ID3D11DeviceContext** ppDeferredContext) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[51]))((ID3D11Device5*)Unsafe.AsPointer(ref this), ContextFlags, ppDeferredContext); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[51]))((ID3D11Device5*)Unsafe.AsPointer(ref this), ContextFlags, ppDeferredContext); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(52)] + public HResult OpenSharedResource(IntPtr* hResource, Guid* ReturnedInterface, void** ppResource) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[52]))((ID3D11Device5*)Unsafe.AsPointer(ref this), hResource, ReturnedInterface, ppResource); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[52]))((ID3D11Device5*)Unsafe.AsPointer(ref this), hResource, ReturnedInterface, ppResource); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(53)] + public HResult CheckFormatSupport(Graphics.Dxgi.Common.Format Format, uint* pFormatSupport) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[53]))((ID3D11Device5*)Unsafe.AsPointer(ref this), Format, pFormatSupport); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[53]))((ID3D11Device5*)Unsafe.AsPointer(ref this), Format, pFormatSupport); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(54)] + public HResult CheckMultisampleQualityLevels(Graphics.Dxgi.Common.Format Format, uint SampleCount, uint* pNumQualityLevels) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[54]))((ID3D11Device5*)Unsafe.AsPointer(ref this), Format, SampleCount, pNumQualityLevels); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[54]))((ID3D11Device5*)Unsafe.AsPointer(ref this), Format, SampleCount, pNumQualityLevels); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(55)] + public void CheckCounterInfo(CounterInfo* pCounterInfo) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[55]))((ID3D11Device5*)Unsafe.AsPointer(ref this), pCounterInfo); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[55]))((ID3D11Device5*)Unsafe.AsPointer(ref this), pCounterInfo); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(56)] + public HResult CheckCounter(CounterDescription* pDesc, CounterType* pType, uint* pActiveCounters, byte* szName, uint* pNameLength, byte* szUnits, uint* pUnitsLength, byte* szDescription, uint* pDescriptionLength) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[56]))((ID3D11Device5*)Unsafe.AsPointer(ref this), pDesc, pType, pActiveCounters, szName, pNameLength, szUnits, pUnitsLength, szDescription, pDescriptionLength); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[56]))((ID3D11Device5*)Unsafe.AsPointer(ref this), pDesc, pType, pActiveCounters, szName, pNameLength, szUnits, pUnitsLength, szDescription, pDescriptionLength); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(57)] + public HResult CheckFeatureSupport(Feature Feature, void* pFeatureSupportData, uint FeatureSupportDataSize) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[57]))((ID3D11Device5*)Unsafe.AsPointer(ref this), Feature, pFeatureSupportData, FeatureSupportDataSize); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[57]))((ID3D11Device5*)Unsafe.AsPointer(ref this), Feature, pFeatureSupportData, FeatureSupportDataSize); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(58)] + public HResult GetPrivateData(Guid* guid, uint* pDataSize, void* pData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[58]))((ID3D11Device5*)Unsafe.AsPointer(ref this), guid, pDataSize, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[58]))((ID3D11Device5*)Unsafe.AsPointer(ref this), guid, pDataSize, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(59)] + public HResult SetPrivateData(Guid* guid, uint DataSize, void* pData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[59]))((ID3D11Device5*)Unsafe.AsPointer(ref this), guid, DataSize, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[59]))((ID3D11Device5*)Unsafe.AsPointer(ref this), guid, DataSize, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(60)] + public HResult SetPrivateDataInterface(Guid* guid, IUnknown* pData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[60]))((ID3D11Device5*)Unsafe.AsPointer(ref this), guid, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[60]))((ID3D11Device5*)Unsafe.AsPointer(ref this), guid, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(61)] + public Graphics.Direct3D.FeatureLevel GetFeatureLevel() + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[61]))((ID3D11Device5*)Unsafe.AsPointer(ref this)); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[61]))((ID3D11Device5*)Unsafe.AsPointer(ref this)); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(62)] + public uint GetCreationFlags() + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[62]))((ID3D11Device5*)Unsafe.AsPointer(ref this)); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[62]))((ID3D11Device5*)Unsafe.AsPointer(ref this)); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(63)] + public HResult GetDeviceRemovedReason() + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[63]))((ID3D11Device5*)Unsafe.AsPointer(ref this)); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[63]))((ID3D11Device5*)Unsafe.AsPointer(ref this)); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(64)] + public void GetImmediateContext(ID3D11DeviceContext* ppImmediateContext) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[64]))((ID3D11Device5*)Unsafe.AsPointer(ref this), ppImmediateContext); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[64]))((ID3D11Device5*)Unsafe.AsPointer(ref this), ppImmediateContext); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(65)] + public HResult SetExceptionMode(uint RaiseFlags) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[65]))((ID3D11Device5*)Unsafe.AsPointer(ref this), RaiseFlags); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[65]))((ID3D11Device5*)Unsafe.AsPointer(ref this), RaiseFlags); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(66)] + public uint GetExceptionMode() + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[66]))((ID3D11Device5*)Unsafe.AsPointer(ref this)); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[66]))((ID3D11Device5*)Unsafe.AsPointer(ref this)); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(67)] + public HResult OpenSharedFence(IntPtr* hFence, Guid* ReturnedInterface, void** ppFence) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[67]))((ID3D11Device5*)Unsafe.AsPointer(ref this), hFence, ReturnedInterface, ppFence); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[67]))((ID3D11Device5*)Unsafe.AsPointer(ref this), hFence, ReturnedInterface, ppFence); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(68)] + public HResult CreateFence(ulong InitialValue, FenceFlag Flags, Guid* ReturnedInterface, void** ppFence) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[68]))((ID3D11Device5*)Unsafe.AsPointer(ref this), InitialValue, Flags, ReturnedInterface, ppFence); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[68]))((ID3D11Device5*)Unsafe.AsPointer(ref this), InitialValue, Flags, ReturnedInterface, ppFence); +#endif + } + + public interface Interface : ID3D11Device4.Interface + { + } +} + +/// +/// ID3D11Multithread +[Guid("9b7e4e00-342c-4106-a19f-4f2704f689f0")] +[NativeTypeName("struct ID3D11Multithread : IUnknown")] +[NativeInheritance("IUnknown")] +public unsafe partial struct ID3D11Multithread : ID3D11Multithread.Interface +{ + public static ref readonly Guid IID_ID3D11Multithread + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x00, 0x4E, 0x7E, 0x9B, + 0x2C, 0x34, + 0x06, 0x41, + 0xA1, + 0x9F, + 0x4F, + 0x27, + 0x04, + 0xF6, + 0x89, + 0xF0 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_ID3D11Multithread)); + + public void** lpVtbl; + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(0)] + public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(1)] + [return: NativeTypeName("ULONG")] + public uint AddRef() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(2)] + [return: NativeTypeName("ULONG")] + public uint Release() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(3)] + public void Enter() + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[3]))((ID3D11Multithread*)Unsafe.AsPointer(ref this)); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((ID3D11Multithread*)Unsafe.AsPointer(ref this)); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public void Leave() + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[4]))((ID3D11Multithread*)Unsafe.AsPointer(ref this)); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((ID3D11Multithread*)Unsafe.AsPointer(ref this)); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(5)] + public Bool32 SetMultithreadProtected(Bool32* bMTProtect) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[5]))((ID3D11Multithread*)Unsafe.AsPointer(ref this), bMTProtect); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((ID3D11Multithread*)Unsafe.AsPointer(ref this), bMTProtect); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(6)] + public Bool32 GetMultithreadProtected() + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[6]))((ID3D11Multithread*)Unsafe.AsPointer(ref this)); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((ID3D11Multithread*)Unsafe.AsPointer(ref this)); +#endif + } + + public interface Interface : IUnknown.Interface + { + } +} + +/// +/// ID3D11VideoContext2 +[Guid("c4e7374c-6243-4d1b-ae87-52b4f740e261")] +[NativeTypeName("struct ID3D11VideoContext2 : ID3D11VideoContext1")] +[NativeInheritance("ID3D11VideoContext1")] +public unsafe partial struct ID3D11VideoContext2 : ID3D11VideoContext2.Interface +{ + public static ref readonly Guid IID_ID3D11VideoContext2 + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x4C, 0x37, 0xE7, 0xC4, + 0x43, 0x62, + 0x1B, 0x4D, + 0xAE, + 0x87, + 0x52, + 0xB4, + 0xF7, + 0x40, + 0xE2, + 0x61 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_ID3D11VideoContext2)); + + public void** lpVtbl; + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(0)] + public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(1)] + [return: NativeTypeName("ULONG")] + public uint AddRef() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(2)] + [return: NativeTypeName("ULONG")] + public uint Release() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(3)] + public HResult SubmitDecoderBuffers1(ID3D11VideoDecoder* pDecoder, uint NumBuffers, VideoDecoderBufferDescription1* pBufferDesc) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[3]))((ID3D11VideoContext2*)Unsafe.AsPointer(ref this), pDecoder, NumBuffers, pBufferDesc); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((ID3D11VideoContext2*)Unsafe.AsPointer(ref this), pDecoder, NumBuffers, pBufferDesc); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public HResult GetDataForNewHardwareKey(ID3D11CryptoSession* pCryptoSession, uint PrivateInputSize, void* pPrivatInputData, ulong* pPrivateOutputData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[4]))((ID3D11VideoContext2*)Unsafe.AsPointer(ref this), pCryptoSession, PrivateInputSize, pPrivatInputData, pPrivateOutputData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((ID3D11VideoContext2*)Unsafe.AsPointer(ref this), pCryptoSession, PrivateInputSize, pPrivatInputData, pPrivateOutputData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(5)] + public HResult CheckCryptoSessionStatus(ID3D11CryptoSession* pCryptoSession, CryptoSessionStatus* pStatus) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[5]))((ID3D11VideoContext2*)Unsafe.AsPointer(ref this), pCryptoSession, pStatus); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((ID3D11VideoContext2*)Unsafe.AsPointer(ref this), pCryptoSession, pStatus); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(6)] + public HResult DecoderEnableDownsampling(ID3D11VideoDecoder* pDecoder, Graphics.Dxgi.Common.ColorSpaceType InputColorSpace, VideoSampleDescription* pOutputDesc, uint ReferenceFrameCount) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[6]))((ID3D11VideoContext2*)Unsafe.AsPointer(ref this), pDecoder, InputColorSpace, pOutputDesc, ReferenceFrameCount); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((ID3D11VideoContext2*)Unsafe.AsPointer(ref this), pDecoder, InputColorSpace, pOutputDesc, ReferenceFrameCount); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(7)] + public HResult DecoderUpdateDownsampling(ID3D11VideoDecoder* pDecoder, VideoSampleDescription* pOutputDesc) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[7]))((ID3D11VideoContext2*)Unsafe.AsPointer(ref this), pDecoder, pOutputDesc); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((ID3D11VideoContext2*)Unsafe.AsPointer(ref this), pDecoder, pOutputDesc); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(8)] + public void VideoProcessorSetOutputColorSpace1(ID3D11VideoProcessor* pVideoProcessor, Graphics.Dxgi.Common.ColorSpaceType ColorSpace) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[8]))((ID3D11VideoContext2*)Unsafe.AsPointer(ref this), pVideoProcessor, ColorSpace); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[8]))((ID3D11VideoContext2*)Unsafe.AsPointer(ref this), pVideoProcessor, ColorSpace); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(9)] + public void VideoProcessorSetOutputShaderUsage(ID3D11VideoProcessor* pVideoProcessor, Bool32* ShaderUsage) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[9]))((ID3D11VideoContext2*)Unsafe.AsPointer(ref this), pVideoProcessor, ShaderUsage); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[9]))((ID3D11VideoContext2*)Unsafe.AsPointer(ref this), pVideoProcessor, ShaderUsage); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(10)] + public void VideoProcessorGetOutputColorSpace1(ID3D11VideoProcessor* pVideoProcessor, Graphics.Dxgi.Common.ColorSpaceType* pColorSpace) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[10]))((ID3D11VideoContext2*)Unsafe.AsPointer(ref this), pVideoProcessor, pColorSpace); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[10]))((ID3D11VideoContext2*)Unsafe.AsPointer(ref this), pVideoProcessor, pColorSpace); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(11)] + public void VideoProcessorGetOutputShaderUsage(ID3D11VideoProcessor* pVideoProcessor, Bool32* pShaderUsage) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[11]))((ID3D11VideoContext2*)Unsafe.AsPointer(ref this), pVideoProcessor, pShaderUsage); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[11]))((ID3D11VideoContext2*)Unsafe.AsPointer(ref this), pVideoProcessor, pShaderUsage); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(12)] + public void VideoProcessorSetStreamColorSpace1(ID3D11VideoProcessor* pVideoProcessor, uint StreamIndex, Graphics.Dxgi.Common.ColorSpaceType ColorSpace) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[12]))((ID3D11VideoContext2*)Unsafe.AsPointer(ref this), pVideoProcessor, StreamIndex, ColorSpace); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[12]))((ID3D11VideoContext2*)Unsafe.AsPointer(ref this), pVideoProcessor, StreamIndex, ColorSpace); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(13)] + public void VideoProcessorSetStreamMirror(ID3D11VideoProcessor* pVideoProcessor, uint StreamIndex, Bool32* Enable, Bool32* FlipHorizontal, Bool32* FlipVertical) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[13]))((ID3D11VideoContext2*)Unsafe.AsPointer(ref this), pVideoProcessor, StreamIndex, Enable, FlipHorizontal, FlipVertical); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[13]))((ID3D11VideoContext2*)Unsafe.AsPointer(ref this), pVideoProcessor, StreamIndex, Enable, FlipHorizontal, FlipVertical); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(14)] + public void VideoProcessorGetStreamColorSpace1(ID3D11VideoProcessor* pVideoProcessor, uint StreamIndex, Graphics.Dxgi.Common.ColorSpaceType* pColorSpace) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[14]))((ID3D11VideoContext2*)Unsafe.AsPointer(ref this), pVideoProcessor, StreamIndex, pColorSpace); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[14]))((ID3D11VideoContext2*)Unsafe.AsPointer(ref this), pVideoProcessor, StreamIndex, pColorSpace); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(15)] + public void VideoProcessorGetStreamMirror(ID3D11VideoProcessor* pVideoProcessor, uint StreamIndex, Bool32* pEnable, Bool32* pFlipHorizontal, Bool32* pFlipVertical) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[15]))((ID3D11VideoContext2*)Unsafe.AsPointer(ref this), pVideoProcessor, StreamIndex, pEnable, pFlipHorizontal, pFlipVertical); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[15]))((ID3D11VideoContext2*)Unsafe.AsPointer(ref this), pVideoProcessor, StreamIndex, pEnable, pFlipHorizontal, pFlipVertical); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(16)] + public HResult VideoProcessorGetBehaviorHints(ID3D11VideoProcessor* pVideoProcessor, uint OutputWidth, uint OutputHeight, Graphics.Dxgi.Common.Format OutputFormat, uint StreamCount, VideoProcessorStreamBehaviorHint* pStreams, uint* pBehaviorHints) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[16]))((ID3D11VideoContext2*)Unsafe.AsPointer(ref this), pVideoProcessor, OutputWidth, OutputHeight, OutputFormat, StreamCount, pStreams, pBehaviorHints); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[16]))((ID3D11VideoContext2*)Unsafe.AsPointer(ref this), pVideoProcessor, OutputWidth, OutputHeight, OutputFormat, StreamCount, pStreams, pBehaviorHints); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(17)] + public HResult GetDecoderBuffer(ID3D11VideoDecoder* pDecoder, VideoDecoderBufferType Type, uint* pBufferSize, void** ppBuffer) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[17]))((ID3D11VideoContext2*)Unsafe.AsPointer(ref this), pDecoder, Type, pBufferSize, ppBuffer); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[17]))((ID3D11VideoContext2*)Unsafe.AsPointer(ref this), pDecoder, Type, pBufferSize, ppBuffer); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(18)] + public HResult ReleaseDecoderBuffer(ID3D11VideoDecoder* pDecoder, VideoDecoderBufferType Type) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[18]))((ID3D11VideoContext2*)Unsafe.AsPointer(ref this), pDecoder, Type); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[18]))((ID3D11VideoContext2*)Unsafe.AsPointer(ref this), pDecoder, Type); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(19)] + public HResult DecoderBeginFrame(ID3D11VideoDecoder* pDecoder, ID3D11VideoDecoderOutputView* pView, uint ContentKeySize, void* pContentKey) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[19]))((ID3D11VideoContext2*)Unsafe.AsPointer(ref this), pDecoder, pView, ContentKeySize, pContentKey); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[19]))((ID3D11VideoContext2*)Unsafe.AsPointer(ref this), pDecoder, pView, ContentKeySize, pContentKey); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(20)] + public HResult DecoderEndFrame(ID3D11VideoDecoder* pDecoder) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[20]))((ID3D11VideoContext2*)Unsafe.AsPointer(ref this), pDecoder); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[20]))((ID3D11VideoContext2*)Unsafe.AsPointer(ref this), pDecoder); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(21)] + public HResult SubmitDecoderBuffers(ID3D11VideoDecoder* pDecoder, uint NumBuffers, VideoDecoderBufferDescription* pBufferDesc) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[21]))((ID3D11VideoContext2*)Unsafe.AsPointer(ref this), pDecoder, NumBuffers, pBufferDesc); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[21]))((ID3D11VideoContext2*)Unsafe.AsPointer(ref this), pDecoder, NumBuffers, pBufferDesc); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(22)] + public int DecoderExtension(ID3D11VideoDecoder* pDecoder, VideoDecoderExtension* pExtensionData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[22]))((ID3D11VideoContext2*)Unsafe.AsPointer(ref this), pDecoder, pExtensionData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[22]))((ID3D11VideoContext2*)Unsafe.AsPointer(ref this), pDecoder, pExtensionData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(23)] + public void VideoProcessorSetOutputTargetRect(ID3D11VideoProcessor* pVideoProcessor, Bool32* Enable, RawRect* pRect) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[23]))((ID3D11VideoContext2*)Unsafe.AsPointer(ref this), pVideoProcessor, Enable, pRect); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[23]))((ID3D11VideoContext2*)Unsafe.AsPointer(ref this), pVideoProcessor, Enable, pRect); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(24)] + public void VideoProcessorSetOutputBackgroundColor(ID3D11VideoProcessor* pVideoProcessor, Bool32* YCbCr, VideoColor* pColor) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[24]))((ID3D11VideoContext2*)Unsafe.AsPointer(ref this), pVideoProcessor, YCbCr, pColor); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[24]))((ID3D11VideoContext2*)Unsafe.AsPointer(ref this), pVideoProcessor, YCbCr, pColor); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(25)] + public void VideoProcessorSetOutputColorSpace(ID3D11VideoProcessor* pVideoProcessor, VideoProcessorColorSpace* pColorSpace) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[25]))((ID3D11VideoContext2*)Unsafe.AsPointer(ref this), pVideoProcessor, pColorSpace); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[25]))((ID3D11VideoContext2*)Unsafe.AsPointer(ref this), pVideoProcessor, pColorSpace); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(26)] + public void VideoProcessorSetOutputAlphaFillMode(ID3D11VideoProcessor* pVideoProcessor, VideoProcessorAlphaFillMode AlphaFillMode, uint StreamIndex) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[26]))((ID3D11VideoContext2*)Unsafe.AsPointer(ref this), pVideoProcessor, AlphaFillMode, StreamIndex); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[26]))((ID3D11VideoContext2*)Unsafe.AsPointer(ref this), pVideoProcessor, AlphaFillMode, StreamIndex); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(27)] + public void VideoProcessorSetOutputConstriction(ID3D11VideoProcessor* pVideoProcessor, Bool32* Enable, System.Drawing.Size* Size) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[27]))((ID3D11VideoContext2*)Unsafe.AsPointer(ref this), pVideoProcessor, Enable, Size); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[27]))((ID3D11VideoContext2*)Unsafe.AsPointer(ref this), pVideoProcessor, Enable, Size); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(28)] + public void VideoProcessorSetOutputStereoMode(ID3D11VideoProcessor* pVideoProcessor, Bool32* Enable) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[28]))((ID3D11VideoContext2*)Unsafe.AsPointer(ref this), pVideoProcessor, Enable); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[28]))((ID3D11VideoContext2*)Unsafe.AsPointer(ref this), pVideoProcessor, Enable); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(29)] + public int VideoProcessorSetOutputExtension(ID3D11VideoProcessor* pVideoProcessor, Guid* pExtensionGuid, uint DataSize, void* pData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[29]))((ID3D11VideoContext2*)Unsafe.AsPointer(ref this), pVideoProcessor, pExtensionGuid, DataSize, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[29]))((ID3D11VideoContext2*)Unsafe.AsPointer(ref this), pVideoProcessor, pExtensionGuid, DataSize, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(30)] + public void VideoProcessorGetOutputTargetRect(ID3D11VideoProcessor* pVideoProcessor, Bool32* Enabled, RawRect* pRect) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[30]))((ID3D11VideoContext2*)Unsafe.AsPointer(ref this), pVideoProcessor, Enabled, pRect); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[30]))((ID3D11VideoContext2*)Unsafe.AsPointer(ref this), pVideoProcessor, Enabled, pRect); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(31)] + public void VideoProcessorGetOutputBackgroundColor(ID3D11VideoProcessor* pVideoProcessor, Bool32* pYCbCr, VideoColor* pColor) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[31]))((ID3D11VideoContext2*)Unsafe.AsPointer(ref this), pVideoProcessor, pYCbCr, pColor); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[31]))((ID3D11VideoContext2*)Unsafe.AsPointer(ref this), pVideoProcessor, pYCbCr, pColor); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(32)] + public void VideoProcessorGetOutputColorSpace(ID3D11VideoProcessor* pVideoProcessor, VideoProcessorColorSpace* pColorSpace) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[32]))((ID3D11VideoContext2*)Unsafe.AsPointer(ref this), pVideoProcessor, pColorSpace); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[32]))((ID3D11VideoContext2*)Unsafe.AsPointer(ref this), pVideoProcessor, pColorSpace); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(33)] + public void VideoProcessorGetOutputAlphaFillMode(ID3D11VideoProcessor* pVideoProcessor, VideoProcessorAlphaFillMode* pAlphaFillMode, uint* pStreamIndex) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[33]))((ID3D11VideoContext2*)Unsafe.AsPointer(ref this), pVideoProcessor, pAlphaFillMode, pStreamIndex); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[33]))((ID3D11VideoContext2*)Unsafe.AsPointer(ref this), pVideoProcessor, pAlphaFillMode, pStreamIndex); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(34)] + public void VideoProcessorGetOutputConstriction(ID3D11VideoProcessor* pVideoProcessor, Bool32* pEnabled, System.Drawing.Size* pSize) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[34]))((ID3D11VideoContext2*)Unsafe.AsPointer(ref this), pVideoProcessor, pEnabled, pSize); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[34]))((ID3D11VideoContext2*)Unsafe.AsPointer(ref this), pVideoProcessor, pEnabled, pSize); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(35)] + public void VideoProcessorGetOutputStereoMode(ID3D11VideoProcessor* pVideoProcessor, Bool32* pEnabled) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[35]))((ID3D11VideoContext2*)Unsafe.AsPointer(ref this), pVideoProcessor, pEnabled); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[35]))((ID3D11VideoContext2*)Unsafe.AsPointer(ref this), pVideoProcessor, pEnabled); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(36)] + public int VideoProcessorGetOutputExtension(ID3D11VideoProcessor* pVideoProcessor, Guid* pExtensionGuid, uint DataSize, void* pData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[36]))((ID3D11VideoContext2*)Unsafe.AsPointer(ref this), pVideoProcessor, pExtensionGuid, DataSize, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[36]))((ID3D11VideoContext2*)Unsafe.AsPointer(ref this), pVideoProcessor, pExtensionGuid, DataSize, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(37)] + public void VideoProcessorSetStreamFrameFormat(ID3D11VideoProcessor* pVideoProcessor, uint StreamIndex, VideoFrameFormat FrameFormat) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[37]))((ID3D11VideoContext2*)Unsafe.AsPointer(ref this), pVideoProcessor, StreamIndex, FrameFormat); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[37]))((ID3D11VideoContext2*)Unsafe.AsPointer(ref this), pVideoProcessor, StreamIndex, FrameFormat); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(38)] + public void VideoProcessorSetStreamColorSpace(ID3D11VideoProcessor* pVideoProcessor, uint StreamIndex, VideoProcessorColorSpace* pColorSpace) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[38]))((ID3D11VideoContext2*)Unsafe.AsPointer(ref this), pVideoProcessor, StreamIndex, pColorSpace); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[38]))((ID3D11VideoContext2*)Unsafe.AsPointer(ref this), pVideoProcessor, StreamIndex, pColorSpace); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(39)] + public void VideoProcessorSetStreamOutputRate(ID3D11VideoProcessor* pVideoProcessor, uint StreamIndex, VideoProcessorOutputRate OutputRate, Bool32* RepeatFrame, Graphics.Dxgi.Common.Rational* pCustomRate) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[39]))((ID3D11VideoContext2*)Unsafe.AsPointer(ref this), pVideoProcessor, StreamIndex, OutputRate, RepeatFrame, pCustomRate); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[39]))((ID3D11VideoContext2*)Unsafe.AsPointer(ref this), pVideoProcessor, StreamIndex, OutputRate, RepeatFrame, pCustomRate); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(40)] + public void VideoProcessorSetStreamSourceRect(ID3D11VideoProcessor* pVideoProcessor, uint StreamIndex, Bool32* Enable, RawRect* pRect) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[40]))((ID3D11VideoContext2*)Unsafe.AsPointer(ref this), pVideoProcessor, StreamIndex, Enable, pRect); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[40]))((ID3D11VideoContext2*)Unsafe.AsPointer(ref this), pVideoProcessor, StreamIndex, Enable, pRect); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(41)] + public void VideoProcessorSetStreamDestRect(ID3D11VideoProcessor* pVideoProcessor, uint StreamIndex, Bool32* Enable, RawRect* pRect) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[41]))((ID3D11VideoContext2*)Unsafe.AsPointer(ref this), pVideoProcessor, StreamIndex, Enable, pRect); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[41]))((ID3D11VideoContext2*)Unsafe.AsPointer(ref this), pVideoProcessor, StreamIndex, Enable, pRect); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(42)] + public void VideoProcessorSetStreamAlpha(ID3D11VideoProcessor* pVideoProcessor, uint StreamIndex, Bool32* Enable, float Alpha) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[42]))((ID3D11VideoContext2*)Unsafe.AsPointer(ref this), pVideoProcessor, StreamIndex, Enable, Alpha); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[42]))((ID3D11VideoContext2*)Unsafe.AsPointer(ref this), pVideoProcessor, StreamIndex, Enable, Alpha); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(43)] + public void VideoProcessorSetStreamPalette(ID3D11VideoProcessor* pVideoProcessor, uint StreamIndex, uint Count, uint* pEntries) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[43]))((ID3D11VideoContext2*)Unsafe.AsPointer(ref this), pVideoProcessor, StreamIndex, Count, pEntries); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[43]))((ID3D11VideoContext2*)Unsafe.AsPointer(ref this), pVideoProcessor, StreamIndex, Count, pEntries); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(44)] + public void VideoProcessorSetStreamPixelAspectRatio(ID3D11VideoProcessor* pVideoProcessor, uint StreamIndex, Bool32* Enable, Graphics.Dxgi.Common.Rational* pSourceAspectRatio, Graphics.Dxgi.Common.Rational* pDestinationAspectRatio) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[44]))((ID3D11VideoContext2*)Unsafe.AsPointer(ref this), pVideoProcessor, StreamIndex, Enable, pSourceAspectRatio, pDestinationAspectRatio); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[44]))((ID3D11VideoContext2*)Unsafe.AsPointer(ref this), pVideoProcessor, StreamIndex, Enable, pSourceAspectRatio, pDestinationAspectRatio); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(45)] + public void VideoProcessorSetStreamLumaKey(ID3D11VideoProcessor* pVideoProcessor, uint StreamIndex, Bool32* Enable, float Lower, float Upper) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[45]))((ID3D11VideoContext2*)Unsafe.AsPointer(ref this), pVideoProcessor, StreamIndex, Enable, Lower, Upper); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[45]))((ID3D11VideoContext2*)Unsafe.AsPointer(ref this), pVideoProcessor, StreamIndex, Enable, Lower, Upper); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(46)] + public void VideoProcessorSetStreamStereoFormat(ID3D11VideoProcessor* pVideoProcessor, uint StreamIndex, Bool32* Enable, VideoProcessorStereoFormat Format, Bool32* LeftViewFrame0, Bool32* BaseViewFrame0, VideoProcessorStereoFlipMode FlipMode, int MonoOffset) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[46]))((ID3D11VideoContext2*)Unsafe.AsPointer(ref this), pVideoProcessor, StreamIndex, Enable, Format, LeftViewFrame0, BaseViewFrame0, FlipMode, MonoOffset); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[46]))((ID3D11VideoContext2*)Unsafe.AsPointer(ref this), pVideoProcessor, StreamIndex, Enable, Format, LeftViewFrame0, BaseViewFrame0, FlipMode, MonoOffset); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(47)] + public void VideoProcessorSetStreamAutoProcessingMode(ID3D11VideoProcessor* pVideoProcessor, uint StreamIndex, Bool32* Enable) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[47]))((ID3D11VideoContext2*)Unsafe.AsPointer(ref this), pVideoProcessor, StreamIndex, Enable); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[47]))((ID3D11VideoContext2*)Unsafe.AsPointer(ref this), pVideoProcessor, StreamIndex, Enable); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(48)] + public void VideoProcessorSetStreamFilter(ID3D11VideoProcessor* pVideoProcessor, uint StreamIndex, VideoProcessorFilter Filter, Bool32* Enable, int Level) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[48]))((ID3D11VideoContext2*)Unsafe.AsPointer(ref this), pVideoProcessor, StreamIndex, Filter, Enable, Level); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[48]))((ID3D11VideoContext2*)Unsafe.AsPointer(ref this), pVideoProcessor, StreamIndex, Filter, Enable, Level); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(49)] + public int VideoProcessorSetStreamExtension(ID3D11VideoProcessor* pVideoProcessor, uint StreamIndex, Guid* pExtensionGuid, uint DataSize, void* pData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[49]))((ID3D11VideoContext2*)Unsafe.AsPointer(ref this), pVideoProcessor, StreamIndex, pExtensionGuid, DataSize, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[49]))((ID3D11VideoContext2*)Unsafe.AsPointer(ref this), pVideoProcessor, StreamIndex, pExtensionGuid, DataSize, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(50)] + public void VideoProcessorGetStreamFrameFormat(ID3D11VideoProcessor* pVideoProcessor, uint StreamIndex, VideoFrameFormat* pFrameFormat) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[50]))((ID3D11VideoContext2*)Unsafe.AsPointer(ref this), pVideoProcessor, StreamIndex, pFrameFormat); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[50]))((ID3D11VideoContext2*)Unsafe.AsPointer(ref this), pVideoProcessor, StreamIndex, pFrameFormat); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(51)] + public void VideoProcessorGetStreamColorSpace(ID3D11VideoProcessor* pVideoProcessor, uint StreamIndex, VideoProcessorColorSpace* pColorSpace) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[51]))((ID3D11VideoContext2*)Unsafe.AsPointer(ref this), pVideoProcessor, StreamIndex, pColorSpace); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[51]))((ID3D11VideoContext2*)Unsafe.AsPointer(ref this), pVideoProcessor, StreamIndex, pColorSpace); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(52)] + public void VideoProcessorGetStreamOutputRate(ID3D11VideoProcessor* pVideoProcessor, uint StreamIndex, VideoProcessorOutputRate* pOutputRate, Bool32* pRepeatFrame, Graphics.Dxgi.Common.Rational* pCustomRate) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[52]))((ID3D11VideoContext2*)Unsafe.AsPointer(ref this), pVideoProcessor, StreamIndex, pOutputRate, pRepeatFrame, pCustomRate); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[52]))((ID3D11VideoContext2*)Unsafe.AsPointer(ref this), pVideoProcessor, StreamIndex, pOutputRate, pRepeatFrame, pCustomRate); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(53)] + public void VideoProcessorGetStreamSourceRect(ID3D11VideoProcessor* pVideoProcessor, uint StreamIndex, Bool32* pEnabled, RawRect* pRect) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[53]))((ID3D11VideoContext2*)Unsafe.AsPointer(ref this), pVideoProcessor, StreamIndex, pEnabled, pRect); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[53]))((ID3D11VideoContext2*)Unsafe.AsPointer(ref this), pVideoProcessor, StreamIndex, pEnabled, pRect); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(54)] + public void VideoProcessorGetStreamDestRect(ID3D11VideoProcessor* pVideoProcessor, uint StreamIndex, Bool32* pEnabled, RawRect* pRect) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[54]))((ID3D11VideoContext2*)Unsafe.AsPointer(ref this), pVideoProcessor, StreamIndex, pEnabled, pRect); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[54]))((ID3D11VideoContext2*)Unsafe.AsPointer(ref this), pVideoProcessor, StreamIndex, pEnabled, pRect); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(55)] + public void VideoProcessorGetStreamAlpha(ID3D11VideoProcessor* pVideoProcessor, uint StreamIndex, Bool32* pEnabled, float* pAlpha) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[55]))((ID3D11VideoContext2*)Unsafe.AsPointer(ref this), pVideoProcessor, StreamIndex, pEnabled, pAlpha); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[55]))((ID3D11VideoContext2*)Unsafe.AsPointer(ref this), pVideoProcessor, StreamIndex, pEnabled, pAlpha); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(56)] + public void VideoProcessorGetStreamPalette(ID3D11VideoProcessor* pVideoProcessor, uint StreamIndex, uint Count, uint* pEntries) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[56]))((ID3D11VideoContext2*)Unsafe.AsPointer(ref this), pVideoProcessor, StreamIndex, Count, pEntries); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[56]))((ID3D11VideoContext2*)Unsafe.AsPointer(ref this), pVideoProcessor, StreamIndex, Count, pEntries); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(57)] + public void VideoProcessorGetStreamPixelAspectRatio(ID3D11VideoProcessor* pVideoProcessor, uint StreamIndex, Bool32* pEnabled, Graphics.Dxgi.Common.Rational* pSourceAspectRatio, Graphics.Dxgi.Common.Rational* pDestinationAspectRatio) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[57]))((ID3D11VideoContext2*)Unsafe.AsPointer(ref this), pVideoProcessor, StreamIndex, pEnabled, pSourceAspectRatio, pDestinationAspectRatio); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[57]))((ID3D11VideoContext2*)Unsafe.AsPointer(ref this), pVideoProcessor, StreamIndex, pEnabled, pSourceAspectRatio, pDestinationAspectRatio); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(58)] + public void VideoProcessorGetStreamLumaKey(ID3D11VideoProcessor* pVideoProcessor, uint StreamIndex, Bool32* pEnabled, float* pLower, float* pUpper) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[58]))((ID3D11VideoContext2*)Unsafe.AsPointer(ref this), pVideoProcessor, StreamIndex, pEnabled, pLower, pUpper); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[58]))((ID3D11VideoContext2*)Unsafe.AsPointer(ref this), pVideoProcessor, StreamIndex, pEnabled, pLower, pUpper); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(59)] + public void VideoProcessorGetStreamStereoFormat(ID3D11VideoProcessor* pVideoProcessor, uint StreamIndex, Bool32* pEnable, VideoProcessorStereoFormat* pFormat, Bool32* pLeftViewFrame0, Bool32* pBaseViewFrame0, VideoProcessorStereoFlipMode* pFlipMode, int* MonoOffset) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[59]))((ID3D11VideoContext2*)Unsafe.AsPointer(ref this), pVideoProcessor, StreamIndex, pEnable, pFormat, pLeftViewFrame0, pBaseViewFrame0, pFlipMode, MonoOffset); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[59]))((ID3D11VideoContext2*)Unsafe.AsPointer(ref this), pVideoProcessor, StreamIndex, pEnable, pFormat, pLeftViewFrame0, pBaseViewFrame0, pFlipMode, MonoOffset); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(60)] + public void VideoProcessorGetStreamAutoProcessingMode(ID3D11VideoProcessor* pVideoProcessor, uint StreamIndex, Bool32* pEnabled) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[60]))((ID3D11VideoContext2*)Unsafe.AsPointer(ref this), pVideoProcessor, StreamIndex, pEnabled); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[60]))((ID3D11VideoContext2*)Unsafe.AsPointer(ref this), pVideoProcessor, StreamIndex, pEnabled); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(61)] + public void VideoProcessorGetStreamFilter(ID3D11VideoProcessor* pVideoProcessor, uint StreamIndex, VideoProcessorFilter Filter, Bool32* pEnabled, int* pLevel) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[61]))((ID3D11VideoContext2*)Unsafe.AsPointer(ref this), pVideoProcessor, StreamIndex, Filter, pEnabled, pLevel); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[61]))((ID3D11VideoContext2*)Unsafe.AsPointer(ref this), pVideoProcessor, StreamIndex, Filter, pEnabled, pLevel); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(62)] + public int VideoProcessorGetStreamExtension(ID3D11VideoProcessor* pVideoProcessor, uint StreamIndex, Guid* pExtensionGuid, uint DataSize, void* pData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[62]))((ID3D11VideoContext2*)Unsafe.AsPointer(ref this), pVideoProcessor, StreamIndex, pExtensionGuid, DataSize, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[62]))((ID3D11VideoContext2*)Unsafe.AsPointer(ref this), pVideoProcessor, StreamIndex, pExtensionGuid, DataSize, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(63)] + public HResult VideoProcessorBlt(ID3D11VideoProcessor* pVideoProcessor, ID3D11VideoProcessorOutputView* pView, uint OutputFrame, uint StreamCount, VideoProcessorStream* pStreams) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[63]))((ID3D11VideoContext2*)Unsafe.AsPointer(ref this), pVideoProcessor, pView, OutputFrame, StreamCount, pStreams); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[63]))((ID3D11VideoContext2*)Unsafe.AsPointer(ref this), pVideoProcessor, pView, OutputFrame, StreamCount, pStreams); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(64)] + public HResult NegotiateCryptoSessionKeyExchange(ID3D11CryptoSession* pCryptoSession, uint DataSize, void* pData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[64]))((ID3D11VideoContext2*)Unsafe.AsPointer(ref this), pCryptoSession, DataSize, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[64]))((ID3D11VideoContext2*)Unsafe.AsPointer(ref this), pCryptoSession, DataSize, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(65)] + public void EncryptionBlt(ID3D11CryptoSession* pCryptoSession, ID3D11Texture2D* pSrcSurface, ID3D11Texture2D* pDstSurface, uint IVSize, void* pIV) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[65]))((ID3D11VideoContext2*)Unsafe.AsPointer(ref this), pCryptoSession, pSrcSurface, pDstSurface, IVSize, pIV); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[65]))((ID3D11VideoContext2*)Unsafe.AsPointer(ref this), pCryptoSession, pSrcSurface, pDstSurface, IVSize, pIV); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(66)] + public void DecryptionBlt(ID3D11CryptoSession* pCryptoSession, ID3D11Texture2D* pSrcSurface, ID3D11Texture2D* pDstSurface, EncryptedBlockInfo* pEncryptedBlockInfo, uint ContentKeySize, void* pContentKey, uint IVSize, void* pIV) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[66]))((ID3D11VideoContext2*)Unsafe.AsPointer(ref this), pCryptoSession, pSrcSurface, pDstSurface, pEncryptedBlockInfo, ContentKeySize, pContentKey, IVSize, pIV); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[66]))((ID3D11VideoContext2*)Unsafe.AsPointer(ref this), pCryptoSession, pSrcSurface, pDstSurface, pEncryptedBlockInfo, ContentKeySize, pContentKey, IVSize, pIV); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(67)] + public void StartSessionKeyRefresh(ID3D11CryptoSession* pCryptoSession, uint RandomNumberSize, void* pRandomNumber) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[67]))((ID3D11VideoContext2*)Unsafe.AsPointer(ref this), pCryptoSession, RandomNumberSize, pRandomNumber); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[67]))((ID3D11VideoContext2*)Unsafe.AsPointer(ref this), pCryptoSession, RandomNumberSize, pRandomNumber); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(68)] + public void FinishSessionKeyRefresh(ID3D11CryptoSession* pCryptoSession) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[68]))((ID3D11VideoContext2*)Unsafe.AsPointer(ref this), pCryptoSession); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[68]))((ID3D11VideoContext2*)Unsafe.AsPointer(ref this), pCryptoSession); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(69)] + public HResult GetEncryptionBltKey(ID3D11CryptoSession* pCryptoSession, uint KeySize, void* pReadbackKey) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[69]))((ID3D11VideoContext2*)Unsafe.AsPointer(ref this), pCryptoSession, KeySize, pReadbackKey); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[69]))((ID3D11VideoContext2*)Unsafe.AsPointer(ref this), pCryptoSession, KeySize, pReadbackKey); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(70)] + public HResult NegotiateAuthenticatedChannelKeyExchange(ID3D11AuthenticatedChannel* pChannel, uint DataSize, void* pData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[70]))((ID3D11VideoContext2*)Unsafe.AsPointer(ref this), pChannel, DataSize, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[70]))((ID3D11VideoContext2*)Unsafe.AsPointer(ref this), pChannel, DataSize, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(71)] + public HResult QueryAuthenticatedChannel(ID3D11AuthenticatedChannel* pChannel, uint InputSize, void* pInput, uint OutputSize, void* pOutput) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[71]))((ID3D11VideoContext2*)Unsafe.AsPointer(ref this), pChannel, InputSize, pInput, OutputSize, pOutput); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[71]))((ID3D11VideoContext2*)Unsafe.AsPointer(ref this), pChannel, InputSize, pInput, OutputSize, pOutput); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(72)] + public HResult ConfigureAuthenticatedChannel(ID3D11AuthenticatedChannel* pChannel, uint InputSize, void* pInput, AuthenticatedConfigureOutput* pOutput) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[72]))((ID3D11VideoContext2*)Unsafe.AsPointer(ref this), pChannel, InputSize, pInput, pOutput); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[72]))((ID3D11VideoContext2*)Unsafe.AsPointer(ref this), pChannel, InputSize, pInput, pOutput); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(73)] + public void VideoProcessorSetStreamRotation(ID3D11VideoProcessor* pVideoProcessor, uint StreamIndex, Bool32* Enable, VideoProcessorRotation Rotation) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[73]))((ID3D11VideoContext2*)Unsafe.AsPointer(ref this), pVideoProcessor, StreamIndex, Enable, Rotation); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[73]))((ID3D11VideoContext2*)Unsafe.AsPointer(ref this), pVideoProcessor, StreamIndex, Enable, Rotation); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(74)] + public void VideoProcessorGetStreamRotation(ID3D11VideoProcessor* pVideoProcessor, uint StreamIndex, Bool32* pEnable, VideoProcessorRotation* pRotation) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[74]))((ID3D11VideoContext2*)Unsafe.AsPointer(ref this), pVideoProcessor, StreamIndex, pEnable, pRotation); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[74]))((ID3D11VideoContext2*)Unsafe.AsPointer(ref this), pVideoProcessor, StreamIndex, pEnable, pRotation); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(75)] + public void GetDevice(ID3D11Device* ppDevice) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[75]))((ID3D11VideoContext2*)Unsafe.AsPointer(ref this), ppDevice); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[75]))((ID3D11VideoContext2*)Unsafe.AsPointer(ref this), ppDevice); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(76)] + public HResult GetPrivateData(Guid* guid, uint* pDataSize, void* pData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[76]))((ID3D11VideoContext2*)Unsafe.AsPointer(ref this), guid, pDataSize, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[76]))((ID3D11VideoContext2*)Unsafe.AsPointer(ref this), guid, pDataSize, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(77)] + public HResult SetPrivateData(Guid* guid, uint DataSize, void* pData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[77]))((ID3D11VideoContext2*)Unsafe.AsPointer(ref this), guid, DataSize, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[77]))((ID3D11VideoContext2*)Unsafe.AsPointer(ref this), guid, DataSize, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(78)] + public HResult SetPrivateDataInterface(Guid* guid, IUnknown* pData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[78]))((ID3D11VideoContext2*)Unsafe.AsPointer(ref this), guid, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[78]))((ID3D11VideoContext2*)Unsafe.AsPointer(ref this), guid, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(79)] + public void VideoProcessorSetOutputHDRMetaData(ID3D11VideoProcessor* pVideoProcessor, Graphics.Dxgi.HdrMetadataType Type, uint Size, void* pHDRMetaData) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[79]))((ID3D11VideoContext2*)Unsafe.AsPointer(ref this), pVideoProcessor, Type, Size, pHDRMetaData); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[79]))((ID3D11VideoContext2*)Unsafe.AsPointer(ref this), pVideoProcessor, Type, Size, pHDRMetaData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(80)] + public void VideoProcessorGetOutputHDRMetaData(ID3D11VideoProcessor* pVideoProcessor, Graphics.Dxgi.HdrMetadataType* pType, uint Size, void* pMetaData) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[80]))((ID3D11VideoContext2*)Unsafe.AsPointer(ref this), pVideoProcessor, pType, Size, pMetaData); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[80]))((ID3D11VideoContext2*)Unsafe.AsPointer(ref this), pVideoProcessor, pType, Size, pMetaData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(81)] + public void VideoProcessorSetStreamHDRMetaData(ID3D11VideoProcessor* pVideoProcessor, uint StreamIndex, Graphics.Dxgi.HdrMetadataType Type, uint Size, void* pHDRMetaData) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[81]))((ID3D11VideoContext2*)Unsafe.AsPointer(ref this), pVideoProcessor, StreamIndex, Type, Size, pHDRMetaData); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[81]))((ID3D11VideoContext2*)Unsafe.AsPointer(ref this), pVideoProcessor, StreamIndex, Type, Size, pHDRMetaData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(82)] + public void VideoProcessorGetStreamHDRMetaData(ID3D11VideoProcessor* pVideoProcessor, uint StreamIndex, Graphics.Dxgi.HdrMetadataType* pType, uint Size, void* pMetaData) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[82]))((ID3D11VideoContext2*)Unsafe.AsPointer(ref this), pVideoProcessor, StreamIndex, pType, Size, pMetaData); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[82]))((ID3D11VideoContext2*)Unsafe.AsPointer(ref this), pVideoProcessor, StreamIndex, pType, Size, pMetaData); +#endif + } + + public interface Interface : ID3D11VideoContext1.Interface + { + } +} + +/// +/// ID3D11VideoDevice2 +[Guid("59c0cb01-35f0-4a70-8f67-87905c906a53")] +[NativeTypeName("struct ID3D11VideoDevice2 : ID3D11VideoDevice1")] +[NativeInheritance("ID3D11VideoDevice1")] +public unsafe partial struct ID3D11VideoDevice2 : ID3D11VideoDevice2.Interface +{ + public static ref readonly Guid IID_ID3D11VideoDevice2 + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x01, 0xCB, 0xC0, 0x59, + 0xF0, 0x35, + 0x70, 0x4A, + 0x8F, + 0x67, + 0x87, + 0x90, + 0x5C, + 0x90, + 0x6A, + 0x53 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_ID3D11VideoDevice2)); + + public void** lpVtbl; + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(0)] + public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(1)] + [return: NativeTypeName("ULONG")] + public uint AddRef() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(2)] + [return: NativeTypeName("ULONG")] + public uint Release() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(3)] + public HResult GetCryptoSessionPrivateDataSize(Guid* pCryptoType, Guid* pDecoderProfile, Guid* pKeyExchangeType, uint* pPrivateInputSize, uint* pPrivateOutputSize) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[3]))((ID3D11VideoDevice2*)Unsafe.AsPointer(ref this), pCryptoType, pDecoderProfile, pKeyExchangeType, pPrivateInputSize, pPrivateOutputSize); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((ID3D11VideoDevice2*)Unsafe.AsPointer(ref this), pCryptoType, pDecoderProfile, pKeyExchangeType, pPrivateInputSize, pPrivateOutputSize); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public HResult GetVideoDecoderCaps(Guid* pDecoderProfile, uint SampleWidth, uint SampleHeight, Graphics.Dxgi.Common.Rational* pFrameRate, uint BitRate, Guid* pCryptoType, uint* pDecoderCaps) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[4]))((ID3D11VideoDevice2*)Unsafe.AsPointer(ref this), pDecoderProfile, SampleWidth, SampleHeight, pFrameRate, BitRate, pCryptoType, pDecoderCaps); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((ID3D11VideoDevice2*)Unsafe.AsPointer(ref this), pDecoderProfile, SampleWidth, SampleHeight, pFrameRate, BitRate, pCryptoType, pDecoderCaps); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(5)] + public HResult CheckVideoDecoderDownsampling(VideoDecoderDescription* pInputDesc, Graphics.Dxgi.Common.ColorSpaceType InputColorSpace, VideoDecoderConfig* pInputConfig, Graphics.Dxgi.Common.Rational* pFrameRate, VideoSampleDescription* pOutputDesc, Bool32* pSupported, Bool32* pRealTimeHint) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[5]))((ID3D11VideoDevice2*)Unsafe.AsPointer(ref this), pInputDesc, InputColorSpace, pInputConfig, pFrameRate, pOutputDesc, pSupported, pRealTimeHint); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((ID3D11VideoDevice2*)Unsafe.AsPointer(ref this), pInputDesc, InputColorSpace, pInputConfig, pFrameRate, pOutputDesc, pSupported, pRealTimeHint); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(6)] + public HResult RecommendVideoDecoderDownsampleParameters(VideoDecoderDescription* pInputDesc, Graphics.Dxgi.Common.ColorSpaceType InputColorSpace, VideoDecoderConfig* pInputConfig, Graphics.Dxgi.Common.Rational* pFrameRate, VideoSampleDescription* pRecommendedOutputDesc) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[6]))((ID3D11VideoDevice2*)Unsafe.AsPointer(ref this), pInputDesc, InputColorSpace, pInputConfig, pFrameRate, pRecommendedOutputDesc); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((ID3D11VideoDevice2*)Unsafe.AsPointer(ref this), pInputDesc, InputColorSpace, pInputConfig, pFrameRate, pRecommendedOutputDesc); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(7)] + public HResult CreateVideoDecoder(VideoDecoderDescription* pVideoDesc, VideoDecoderConfig* pConfig, ID3D11VideoDecoder** ppDecoder) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[7]))((ID3D11VideoDevice2*)Unsafe.AsPointer(ref this), pVideoDesc, pConfig, ppDecoder); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((ID3D11VideoDevice2*)Unsafe.AsPointer(ref this), pVideoDesc, pConfig, ppDecoder); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(8)] + public HResult CreateVideoProcessor(ID3D11VideoProcessorEnumerator* pEnum, uint RateConversionIndex, ID3D11VideoProcessor** ppVideoProcessor) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[8]))((ID3D11VideoDevice2*)Unsafe.AsPointer(ref this), pEnum, RateConversionIndex, ppVideoProcessor); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[8]))((ID3D11VideoDevice2*)Unsafe.AsPointer(ref this), pEnum, RateConversionIndex, ppVideoProcessor); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(9)] + public HResult CreateAuthenticatedChannel(AuthenticatedChannelType ChannelType, ID3D11AuthenticatedChannel** ppAuthenticatedChannel) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[9]))((ID3D11VideoDevice2*)Unsafe.AsPointer(ref this), ChannelType, ppAuthenticatedChannel); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[9]))((ID3D11VideoDevice2*)Unsafe.AsPointer(ref this), ChannelType, ppAuthenticatedChannel); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(10)] + public HResult CreateCryptoSession(Guid* pCryptoType, Guid* pDecoderProfile, Guid* pKeyExchangeType, ID3D11CryptoSession** ppCryptoSession) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[10]))((ID3D11VideoDevice2*)Unsafe.AsPointer(ref this), pCryptoType, pDecoderProfile, pKeyExchangeType, ppCryptoSession); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[10]))((ID3D11VideoDevice2*)Unsafe.AsPointer(ref this), pCryptoType, pDecoderProfile, pKeyExchangeType, ppCryptoSession); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(11)] + public HResult CreateVideoDecoderOutputView(ID3D11Resource* pResource, VideoDecoderOutputViewDescription* pDesc, ID3D11VideoDecoderOutputView** ppVDOVView) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[11]))((ID3D11VideoDevice2*)Unsafe.AsPointer(ref this), pResource, pDesc, ppVDOVView); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[11]))((ID3D11VideoDevice2*)Unsafe.AsPointer(ref this), pResource, pDesc, ppVDOVView); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(12)] + public HResult CreateVideoProcessorInputView(ID3D11Resource* pResource, ID3D11VideoProcessorEnumerator* pEnum, VideoProcessorInputViewDescription* pDesc, ID3D11VideoProcessorInputView** ppVPIView) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[12]))((ID3D11VideoDevice2*)Unsafe.AsPointer(ref this), pResource, pEnum, pDesc, ppVPIView); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[12]))((ID3D11VideoDevice2*)Unsafe.AsPointer(ref this), pResource, pEnum, pDesc, ppVPIView); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(13)] + public HResult CreateVideoProcessorOutputView(ID3D11Resource* pResource, ID3D11VideoProcessorEnumerator* pEnum, VideoProcessorOutputViewDescription* pDesc, ID3D11VideoProcessorOutputView** ppVPOView) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[13]))((ID3D11VideoDevice2*)Unsafe.AsPointer(ref this), pResource, pEnum, pDesc, ppVPOView); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[13]))((ID3D11VideoDevice2*)Unsafe.AsPointer(ref this), pResource, pEnum, pDesc, ppVPOView); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(14)] + public HResult CreateVideoProcessorEnumerator(VideoProcessorContentDescription* pDesc, ID3D11VideoProcessorEnumerator** ppEnum) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[14]))((ID3D11VideoDevice2*)Unsafe.AsPointer(ref this), pDesc, ppEnum); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[14]))((ID3D11VideoDevice2*)Unsafe.AsPointer(ref this), pDesc, ppEnum); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(15)] + public uint GetVideoDecoderProfileCount() + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[15]))((ID3D11VideoDevice2*)Unsafe.AsPointer(ref this)); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[15]))((ID3D11VideoDevice2*)Unsafe.AsPointer(ref this)); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(16)] + public HResult GetVideoDecoderProfile(uint Index, Guid* pDecoderProfile) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[16]))((ID3D11VideoDevice2*)Unsafe.AsPointer(ref this), Index, pDecoderProfile); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[16]))((ID3D11VideoDevice2*)Unsafe.AsPointer(ref this), Index, pDecoderProfile); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(17)] + public HResult CheckVideoDecoderFormat(Guid* pDecoderProfile, Graphics.Dxgi.Common.Format Format, Bool32* pSupported) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[17]))((ID3D11VideoDevice2*)Unsafe.AsPointer(ref this), pDecoderProfile, Format, pSupported); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[17]))((ID3D11VideoDevice2*)Unsafe.AsPointer(ref this), pDecoderProfile, Format, pSupported); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(18)] + public HResult GetVideoDecoderConfigCount(VideoDecoderDescription* pDesc, uint* pCount) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[18]))((ID3D11VideoDevice2*)Unsafe.AsPointer(ref this), pDesc, pCount); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[18]))((ID3D11VideoDevice2*)Unsafe.AsPointer(ref this), pDesc, pCount); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(19)] + public HResult GetVideoDecoderConfig(VideoDecoderDescription* pDesc, uint Index, VideoDecoderConfig* pConfig) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[19]))((ID3D11VideoDevice2*)Unsafe.AsPointer(ref this), pDesc, Index, pConfig); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[19]))((ID3D11VideoDevice2*)Unsafe.AsPointer(ref this), pDesc, Index, pConfig); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(20)] + public HResult GetContentProtectionCaps(Guid* pCryptoType, Guid* pDecoderProfile, VideoContentProtectionCaps* pCaps) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[20]))((ID3D11VideoDevice2*)Unsafe.AsPointer(ref this), pCryptoType, pDecoderProfile, pCaps); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[20]))((ID3D11VideoDevice2*)Unsafe.AsPointer(ref this), pCryptoType, pDecoderProfile, pCaps); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(21)] + public HResult CheckCryptoKeyExchange(Guid* pCryptoType, Guid* pDecoderProfile, uint Index, Guid* pKeyExchangeType) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[21]))((ID3D11VideoDevice2*)Unsafe.AsPointer(ref this), pCryptoType, pDecoderProfile, Index, pKeyExchangeType); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[21]))((ID3D11VideoDevice2*)Unsafe.AsPointer(ref this), pCryptoType, pDecoderProfile, Index, pKeyExchangeType); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(22)] + public HResult SetPrivateData(Guid* guid, uint DataSize, void* pData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[22]))((ID3D11VideoDevice2*)Unsafe.AsPointer(ref this), guid, DataSize, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[22]))((ID3D11VideoDevice2*)Unsafe.AsPointer(ref this), guid, DataSize, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(23)] + public HResult SetPrivateDataInterface(Guid* guid, IUnknown* pData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[23]))((ID3D11VideoDevice2*)Unsafe.AsPointer(ref this), guid, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[23]))((ID3D11VideoDevice2*)Unsafe.AsPointer(ref this), guid, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(24)] + public HResult CheckFeatureSupport(FeatureVideo Feature, void* pFeatureSupportData, uint FeatureSupportDataSize) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[24]))((ID3D11VideoDevice2*)Unsafe.AsPointer(ref this), Feature, pFeatureSupportData, FeatureSupportDataSize); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[24]))((ID3D11VideoDevice2*)Unsafe.AsPointer(ref this), Feature, pFeatureSupportData, FeatureSupportDataSize); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(25)] + public HResult NegotiateCryptoSessionKeyExchangeMT(ID3D11CryptoSession* pCryptoSession, CryptoSessionKeyExchangeFlags flags, uint DataSize, void* pData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[25]))((ID3D11VideoDevice2*)Unsafe.AsPointer(ref this), pCryptoSession, flags, DataSize, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[25]))((ID3D11VideoDevice2*)Unsafe.AsPointer(ref this), pCryptoSession, flags, DataSize, pData); +#endif + } + + public interface Interface : ID3D11VideoDevice1.Interface + { + } +} + +/// +/// ID3D11VideoContext3 +[Guid("a9e2faa0-cb39-418f-a0b7-d8aad4de672e")] +[NativeTypeName("struct ID3D11VideoContext3 : ID3D11VideoContext2")] +[NativeInheritance("ID3D11VideoContext2")] +public unsafe partial struct ID3D11VideoContext3 : ID3D11VideoContext3.Interface +{ + public static ref readonly Guid IID_ID3D11VideoContext3 + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0xA0, 0xFA, 0xE2, 0xA9, + 0x39, 0xCB, + 0x8F, 0x41, + 0xA0, + 0xB7, + 0xD8, + 0xAA, + 0xD4, + 0xDE, + 0x67, + 0x2E + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_ID3D11VideoContext3)); + + public void** lpVtbl; + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(0)] + public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(1)] + [return: NativeTypeName("ULONG")] + public uint AddRef() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(2)] + [return: NativeTypeName("ULONG")] + public uint Release() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(3)] + public void VideoProcessorSetOutputHDRMetaData(ID3D11VideoProcessor* pVideoProcessor, Graphics.Dxgi.HdrMetadataType Type, uint Size, void* pHDRMetaData) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[3]))((ID3D11VideoContext3*)Unsafe.AsPointer(ref this), pVideoProcessor, Type, Size, pHDRMetaData); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((ID3D11VideoContext3*)Unsafe.AsPointer(ref this), pVideoProcessor, Type, Size, pHDRMetaData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public void VideoProcessorGetOutputHDRMetaData(ID3D11VideoProcessor* pVideoProcessor, Graphics.Dxgi.HdrMetadataType* pType, uint Size, void* pMetaData) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[4]))((ID3D11VideoContext3*)Unsafe.AsPointer(ref this), pVideoProcessor, pType, Size, pMetaData); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((ID3D11VideoContext3*)Unsafe.AsPointer(ref this), pVideoProcessor, pType, Size, pMetaData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(5)] + public void VideoProcessorSetStreamHDRMetaData(ID3D11VideoProcessor* pVideoProcessor, uint StreamIndex, Graphics.Dxgi.HdrMetadataType Type, uint Size, void* pHDRMetaData) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[5]))((ID3D11VideoContext3*)Unsafe.AsPointer(ref this), pVideoProcessor, StreamIndex, Type, Size, pHDRMetaData); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((ID3D11VideoContext3*)Unsafe.AsPointer(ref this), pVideoProcessor, StreamIndex, Type, Size, pHDRMetaData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(6)] + public void VideoProcessorGetStreamHDRMetaData(ID3D11VideoProcessor* pVideoProcessor, uint StreamIndex, Graphics.Dxgi.HdrMetadataType* pType, uint Size, void* pMetaData) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[6]))((ID3D11VideoContext3*)Unsafe.AsPointer(ref this), pVideoProcessor, StreamIndex, pType, Size, pMetaData); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((ID3D11VideoContext3*)Unsafe.AsPointer(ref this), pVideoProcessor, StreamIndex, pType, Size, pMetaData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(7)] + public HResult SubmitDecoderBuffers1(ID3D11VideoDecoder* pDecoder, uint NumBuffers, VideoDecoderBufferDescription1* pBufferDesc) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[7]))((ID3D11VideoContext3*)Unsafe.AsPointer(ref this), pDecoder, NumBuffers, pBufferDesc); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((ID3D11VideoContext3*)Unsafe.AsPointer(ref this), pDecoder, NumBuffers, pBufferDesc); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(8)] + public HResult GetDataForNewHardwareKey(ID3D11CryptoSession* pCryptoSession, uint PrivateInputSize, void* pPrivatInputData, ulong* pPrivateOutputData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[8]))((ID3D11VideoContext3*)Unsafe.AsPointer(ref this), pCryptoSession, PrivateInputSize, pPrivatInputData, pPrivateOutputData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[8]))((ID3D11VideoContext3*)Unsafe.AsPointer(ref this), pCryptoSession, PrivateInputSize, pPrivatInputData, pPrivateOutputData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(9)] + public HResult CheckCryptoSessionStatus(ID3D11CryptoSession* pCryptoSession, CryptoSessionStatus* pStatus) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[9]))((ID3D11VideoContext3*)Unsafe.AsPointer(ref this), pCryptoSession, pStatus); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[9]))((ID3D11VideoContext3*)Unsafe.AsPointer(ref this), pCryptoSession, pStatus); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(10)] + public HResult DecoderEnableDownsampling(ID3D11VideoDecoder* pDecoder, Graphics.Dxgi.Common.ColorSpaceType InputColorSpace, VideoSampleDescription* pOutputDesc, uint ReferenceFrameCount) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[10]))((ID3D11VideoContext3*)Unsafe.AsPointer(ref this), pDecoder, InputColorSpace, pOutputDesc, ReferenceFrameCount); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[10]))((ID3D11VideoContext3*)Unsafe.AsPointer(ref this), pDecoder, InputColorSpace, pOutputDesc, ReferenceFrameCount); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(11)] + public HResult DecoderUpdateDownsampling(ID3D11VideoDecoder* pDecoder, VideoSampleDescription* pOutputDesc) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[11]))((ID3D11VideoContext3*)Unsafe.AsPointer(ref this), pDecoder, pOutputDesc); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[11]))((ID3D11VideoContext3*)Unsafe.AsPointer(ref this), pDecoder, pOutputDesc); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(12)] + public void VideoProcessorSetOutputColorSpace1(ID3D11VideoProcessor* pVideoProcessor, Graphics.Dxgi.Common.ColorSpaceType ColorSpace) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[12]))((ID3D11VideoContext3*)Unsafe.AsPointer(ref this), pVideoProcessor, ColorSpace); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[12]))((ID3D11VideoContext3*)Unsafe.AsPointer(ref this), pVideoProcessor, ColorSpace); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(13)] + public void VideoProcessorSetOutputShaderUsage(ID3D11VideoProcessor* pVideoProcessor, Bool32* ShaderUsage) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[13]))((ID3D11VideoContext3*)Unsafe.AsPointer(ref this), pVideoProcessor, ShaderUsage); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[13]))((ID3D11VideoContext3*)Unsafe.AsPointer(ref this), pVideoProcessor, ShaderUsage); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(14)] + public void VideoProcessorGetOutputColorSpace1(ID3D11VideoProcessor* pVideoProcessor, Graphics.Dxgi.Common.ColorSpaceType* pColorSpace) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[14]))((ID3D11VideoContext3*)Unsafe.AsPointer(ref this), pVideoProcessor, pColorSpace); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[14]))((ID3D11VideoContext3*)Unsafe.AsPointer(ref this), pVideoProcessor, pColorSpace); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(15)] + public void VideoProcessorGetOutputShaderUsage(ID3D11VideoProcessor* pVideoProcessor, Bool32* pShaderUsage) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[15]))((ID3D11VideoContext3*)Unsafe.AsPointer(ref this), pVideoProcessor, pShaderUsage); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[15]))((ID3D11VideoContext3*)Unsafe.AsPointer(ref this), pVideoProcessor, pShaderUsage); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(16)] + public void VideoProcessorSetStreamColorSpace1(ID3D11VideoProcessor* pVideoProcessor, uint StreamIndex, Graphics.Dxgi.Common.ColorSpaceType ColorSpace) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[16]))((ID3D11VideoContext3*)Unsafe.AsPointer(ref this), pVideoProcessor, StreamIndex, ColorSpace); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[16]))((ID3D11VideoContext3*)Unsafe.AsPointer(ref this), pVideoProcessor, StreamIndex, ColorSpace); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(17)] + public void VideoProcessorSetStreamMirror(ID3D11VideoProcessor* pVideoProcessor, uint StreamIndex, Bool32* Enable, Bool32* FlipHorizontal, Bool32* FlipVertical) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[17]))((ID3D11VideoContext3*)Unsafe.AsPointer(ref this), pVideoProcessor, StreamIndex, Enable, FlipHorizontal, FlipVertical); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[17]))((ID3D11VideoContext3*)Unsafe.AsPointer(ref this), pVideoProcessor, StreamIndex, Enable, FlipHorizontal, FlipVertical); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(18)] + public void VideoProcessorGetStreamColorSpace1(ID3D11VideoProcessor* pVideoProcessor, uint StreamIndex, Graphics.Dxgi.Common.ColorSpaceType* pColorSpace) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[18]))((ID3D11VideoContext3*)Unsafe.AsPointer(ref this), pVideoProcessor, StreamIndex, pColorSpace); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[18]))((ID3D11VideoContext3*)Unsafe.AsPointer(ref this), pVideoProcessor, StreamIndex, pColorSpace); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(19)] + public void VideoProcessorGetStreamMirror(ID3D11VideoProcessor* pVideoProcessor, uint StreamIndex, Bool32* pEnable, Bool32* pFlipHorizontal, Bool32* pFlipVertical) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[19]))((ID3D11VideoContext3*)Unsafe.AsPointer(ref this), pVideoProcessor, StreamIndex, pEnable, pFlipHorizontal, pFlipVertical); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[19]))((ID3D11VideoContext3*)Unsafe.AsPointer(ref this), pVideoProcessor, StreamIndex, pEnable, pFlipHorizontal, pFlipVertical); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(20)] + public HResult VideoProcessorGetBehaviorHints(ID3D11VideoProcessor* pVideoProcessor, uint OutputWidth, uint OutputHeight, Graphics.Dxgi.Common.Format OutputFormat, uint StreamCount, VideoProcessorStreamBehaviorHint* pStreams, uint* pBehaviorHints) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[20]))((ID3D11VideoContext3*)Unsafe.AsPointer(ref this), pVideoProcessor, OutputWidth, OutputHeight, OutputFormat, StreamCount, pStreams, pBehaviorHints); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[20]))((ID3D11VideoContext3*)Unsafe.AsPointer(ref this), pVideoProcessor, OutputWidth, OutputHeight, OutputFormat, StreamCount, pStreams, pBehaviorHints); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(21)] + public HResult GetDecoderBuffer(ID3D11VideoDecoder* pDecoder, VideoDecoderBufferType Type, uint* pBufferSize, void** ppBuffer) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[21]))((ID3D11VideoContext3*)Unsafe.AsPointer(ref this), pDecoder, Type, pBufferSize, ppBuffer); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[21]))((ID3D11VideoContext3*)Unsafe.AsPointer(ref this), pDecoder, Type, pBufferSize, ppBuffer); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(22)] + public HResult ReleaseDecoderBuffer(ID3D11VideoDecoder* pDecoder, VideoDecoderBufferType Type) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[22]))((ID3D11VideoContext3*)Unsafe.AsPointer(ref this), pDecoder, Type); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[22]))((ID3D11VideoContext3*)Unsafe.AsPointer(ref this), pDecoder, Type); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(23)] + public HResult DecoderBeginFrame(ID3D11VideoDecoder* pDecoder, ID3D11VideoDecoderOutputView* pView, uint ContentKeySize, void* pContentKey) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[23]))((ID3D11VideoContext3*)Unsafe.AsPointer(ref this), pDecoder, pView, ContentKeySize, pContentKey); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[23]))((ID3D11VideoContext3*)Unsafe.AsPointer(ref this), pDecoder, pView, ContentKeySize, pContentKey); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(24)] + public HResult DecoderEndFrame(ID3D11VideoDecoder* pDecoder) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[24]))((ID3D11VideoContext3*)Unsafe.AsPointer(ref this), pDecoder); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[24]))((ID3D11VideoContext3*)Unsafe.AsPointer(ref this), pDecoder); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(25)] + public HResult SubmitDecoderBuffers(ID3D11VideoDecoder* pDecoder, uint NumBuffers, VideoDecoderBufferDescription* pBufferDesc) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[25]))((ID3D11VideoContext3*)Unsafe.AsPointer(ref this), pDecoder, NumBuffers, pBufferDesc); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[25]))((ID3D11VideoContext3*)Unsafe.AsPointer(ref this), pDecoder, NumBuffers, pBufferDesc); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(26)] + public int DecoderExtension(ID3D11VideoDecoder* pDecoder, VideoDecoderExtension* pExtensionData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[26]))((ID3D11VideoContext3*)Unsafe.AsPointer(ref this), pDecoder, pExtensionData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[26]))((ID3D11VideoContext3*)Unsafe.AsPointer(ref this), pDecoder, pExtensionData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(27)] + public void VideoProcessorSetOutputTargetRect(ID3D11VideoProcessor* pVideoProcessor, Bool32* Enable, RawRect* pRect) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[27]))((ID3D11VideoContext3*)Unsafe.AsPointer(ref this), pVideoProcessor, Enable, pRect); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[27]))((ID3D11VideoContext3*)Unsafe.AsPointer(ref this), pVideoProcessor, Enable, pRect); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(28)] + public void VideoProcessorSetOutputBackgroundColor(ID3D11VideoProcessor* pVideoProcessor, Bool32* YCbCr, VideoColor* pColor) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[28]))((ID3D11VideoContext3*)Unsafe.AsPointer(ref this), pVideoProcessor, YCbCr, pColor); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[28]))((ID3D11VideoContext3*)Unsafe.AsPointer(ref this), pVideoProcessor, YCbCr, pColor); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(29)] + public void VideoProcessorSetOutputColorSpace(ID3D11VideoProcessor* pVideoProcessor, VideoProcessorColorSpace* pColorSpace) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[29]))((ID3D11VideoContext3*)Unsafe.AsPointer(ref this), pVideoProcessor, pColorSpace); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[29]))((ID3D11VideoContext3*)Unsafe.AsPointer(ref this), pVideoProcessor, pColorSpace); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(30)] + public void VideoProcessorSetOutputAlphaFillMode(ID3D11VideoProcessor* pVideoProcessor, VideoProcessorAlphaFillMode AlphaFillMode, uint StreamIndex) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[30]))((ID3D11VideoContext3*)Unsafe.AsPointer(ref this), pVideoProcessor, AlphaFillMode, StreamIndex); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[30]))((ID3D11VideoContext3*)Unsafe.AsPointer(ref this), pVideoProcessor, AlphaFillMode, StreamIndex); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(31)] + public void VideoProcessorSetOutputConstriction(ID3D11VideoProcessor* pVideoProcessor, Bool32* Enable, System.Drawing.Size* Size) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[31]))((ID3D11VideoContext3*)Unsafe.AsPointer(ref this), pVideoProcessor, Enable, Size); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[31]))((ID3D11VideoContext3*)Unsafe.AsPointer(ref this), pVideoProcessor, Enable, Size); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(32)] + public void VideoProcessorSetOutputStereoMode(ID3D11VideoProcessor* pVideoProcessor, Bool32* Enable) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[32]))((ID3D11VideoContext3*)Unsafe.AsPointer(ref this), pVideoProcessor, Enable); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[32]))((ID3D11VideoContext3*)Unsafe.AsPointer(ref this), pVideoProcessor, Enable); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(33)] + public int VideoProcessorSetOutputExtension(ID3D11VideoProcessor* pVideoProcessor, Guid* pExtensionGuid, uint DataSize, void* pData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[33]))((ID3D11VideoContext3*)Unsafe.AsPointer(ref this), pVideoProcessor, pExtensionGuid, DataSize, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[33]))((ID3D11VideoContext3*)Unsafe.AsPointer(ref this), pVideoProcessor, pExtensionGuid, DataSize, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(34)] + public void VideoProcessorGetOutputTargetRect(ID3D11VideoProcessor* pVideoProcessor, Bool32* Enabled, RawRect* pRect) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[34]))((ID3D11VideoContext3*)Unsafe.AsPointer(ref this), pVideoProcessor, Enabled, pRect); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[34]))((ID3D11VideoContext3*)Unsafe.AsPointer(ref this), pVideoProcessor, Enabled, pRect); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(35)] + public void VideoProcessorGetOutputBackgroundColor(ID3D11VideoProcessor* pVideoProcessor, Bool32* pYCbCr, VideoColor* pColor) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[35]))((ID3D11VideoContext3*)Unsafe.AsPointer(ref this), pVideoProcessor, pYCbCr, pColor); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[35]))((ID3D11VideoContext3*)Unsafe.AsPointer(ref this), pVideoProcessor, pYCbCr, pColor); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(36)] + public void VideoProcessorGetOutputColorSpace(ID3D11VideoProcessor* pVideoProcessor, VideoProcessorColorSpace* pColorSpace) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[36]))((ID3D11VideoContext3*)Unsafe.AsPointer(ref this), pVideoProcessor, pColorSpace); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[36]))((ID3D11VideoContext3*)Unsafe.AsPointer(ref this), pVideoProcessor, pColorSpace); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(37)] + public void VideoProcessorGetOutputAlphaFillMode(ID3D11VideoProcessor* pVideoProcessor, VideoProcessorAlphaFillMode* pAlphaFillMode, uint* pStreamIndex) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[37]))((ID3D11VideoContext3*)Unsafe.AsPointer(ref this), pVideoProcessor, pAlphaFillMode, pStreamIndex); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[37]))((ID3D11VideoContext3*)Unsafe.AsPointer(ref this), pVideoProcessor, pAlphaFillMode, pStreamIndex); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(38)] + public void VideoProcessorGetOutputConstriction(ID3D11VideoProcessor* pVideoProcessor, Bool32* pEnabled, System.Drawing.Size* pSize) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[38]))((ID3D11VideoContext3*)Unsafe.AsPointer(ref this), pVideoProcessor, pEnabled, pSize); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[38]))((ID3D11VideoContext3*)Unsafe.AsPointer(ref this), pVideoProcessor, pEnabled, pSize); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(39)] + public void VideoProcessorGetOutputStereoMode(ID3D11VideoProcessor* pVideoProcessor, Bool32* pEnabled) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[39]))((ID3D11VideoContext3*)Unsafe.AsPointer(ref this), pVideoProcessor, pEnabled); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[39]))((ID3D11VideoContext3*)Unsafe.AsPointer(ref this), pVideoProcessor, pEnabled); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(40)] + public int VideoProcessorGetOutputExtension(ID3D11VideoProcessor* pVideoProcessor, Guid* pExtensionGuid, uint DataSize, void* pData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[40]))((ID3D11VideoContext3*)Unsafe.AsPointer(ref this), pVideoProcessor, pExtensionGuid, DataSize, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[40]))((ID3D11VideoContext3*)Unsafe.AsPointer(ref this), pVideoProcessor, pExtensionGuid, DataSize, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(41)] + public void VideoProcessorSetStreamFrameFormat(ID3D11VideoProcessor* pVideoProcessor, uint StreamIndex, VideoFrameFormat FrameFormat) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[41]))((ID3D11VideoContext3*)Unsafe.AsPointer(ref this), pVideoProcessor, StreamIndex, FrameFormat); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[41]))((ID3D11VideoContext3*)Unsafe.AsPointer(ref this), pVideoProcessor, StreamIndex, FrameFormat); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(42)] + public void VideoProcessorSetStreamColorSpace(ID3D11VideoProcessor* pVideoProcessor, uint StreamIndex, VideoProcessorColorSpace* pColorSpace) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[42]))((ID3D11VideoContext3*)Unsafe.AsPointer(ref this), pVideoProcessor, StreamIndex, pColorSpace); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[42]))((ID3D11VideoContext3*)Unsafe.AsPointer(ref this), pVideoProcessor, StreamIndex, pColorSpace); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(43)] + public void VideoProcessorSetStreamOutputRate(ID3D11VideoProcessor* pVideoProcessor, uint StreamIndex, VideoProcessorOutputRate OutputRate, Bool32* RepeatFrame, Graphics.Dxgi.Common.Rational* pCustomRate) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[43]))((ID3D11VideoContext3*)Unsafe.AsPointer(ref this), pVideoProcessor, StreamIndex, OutputRate, RepeatFrame, pCustomRate); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[43]))((ID3D11VideoContext3*)Unsafe.AsPointer(ref this), pVideoProcessor, StreamIndex, OutputRate, RepeatFrame, pCustomRate); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(44)] + public void VideoProcessorSetStreamSourceRect(ID3D11VideoProcessor* pVideoProcessor, uint StreamIndex, Bool32* Enable, RawRect* pRect) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[44]))((ID3D11VideoContext3*)Unsafe.AsPointer(ref this), pVideoProcessor, StreamIndex, Enable, pRect); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[44]))((ID3D11VideoContext3*)Unsafe.AsPointer(ref this), pVideoProcessor, StreamIndex, Enable, pRect); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(45)] + public void VideoProcessorSetStreamDestRect(ID3D11VideoProcessor* pVideoProcessor, uint StreamIndex, Bool32* Enable, RawRect* pRect) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[45]))((ID3D11VideoContext3*)Unsafe.AsPointer(ref this), pVideoProcessor, StreamIndex, Enable, pRect); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[45]))((ID3D11VideoContext3*)Unsafe.AsPointer(ref this), pVideoProcessor, StreamIndex, Enable, pRect); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(46)] + public void VideoProcessorSetStreamAlpha(ID3D11VideoProcessor* pVideoProcessor, uint StreamIndex, Bool32* Enable, float Alpha) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[46]))((ID3D11VideoContext3*)Unsafe.AsPointer(ref this), pVideoProcessor, StreamIndex, Enable, Alpha); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[46]))((ID3D11VideoContext3*)Unsafe.AsPointer(ref this), pVideoProcessor, StreamIndex, Enable, Alpha); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(47)] + public void VideoProcessorSetStreamPalette(ID3D11VideoProcessor* pVideoProcessor, uint StreamIndex, uint Count, uint* pEntries) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[47]))((ID3D11VideoContext3*)Unsafe.AsPointer(ref this), pVideoProcessor, StreamIndex, Count, pEntries); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[47]))((ID3D11VideoContext3*)Unsafe.AsPointer(ref this), pVideoProcessor, StreamIndex, Count, pEntries); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(48)] + public void VideoProcessorSetStreamPixelAspectRatio(ID3D11VideoProcessor* pVideoProcessor, uint StreamIndex, Bool32* Enable, Graphics.Dxgi.Common.Rational* pSourceAspectRatio, Graphics.Dxgi.Common.Rational* pDestinationAspectRatio) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[48]))((ID3D11VideoContext3*)Unsafe.AsPointer(ref this), pVideoProcessor, StreamIndex, Enable, pSourceAspectRatio, pDestinationAspectRatio); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[48]))((ID3D11VideoContext3*)Unsafe.AsPointer(ref this), pVideoProcessor, StreamIndex, Enable, pSourceAspectRatio, pDestinationAspectRatio); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(49)] + public void VideoProcessorSetStreamLumaKey(ID3D11VideoProcessor* pVideoProcessor, uint StreamIndex, Bool32* Enable, float Lower, float Upper) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[49]))((ID3D11VideoContext3*)Unsafe.AsPointer(ref this), pVideoProcessor, StreamIndex, Enable, Lower, Upper); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[49]))((ID3D11VideoContext3*)Unsafe.AsPointer(ref this), pVideoProcessor, StreamIndex, Enable, Lower, Upper); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(50)] + public void VideoProcessorSetStreamStereoFormat(ID3D11VideoProcessor* pVideoProcessor, uint StreamIndex, Bool32* Enable, VideoProcessorStereoFormat Format, Bool32* LeftViewFrame0, Bool32* BaseViewFrame0, VideoProcessorStereoFlipMode FlipMode, int MonoOffset) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[50]))((ID3D11VideoContext3*)Unsafe.AsPointer(ref this), pVideoProcessor, StreamIndex, Enable, Format, LeftViewFrame0, BaseViewFrame0, FlipMode, MonoOffset); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[50]))((ID3D11VideoContext3*)Unsafe.AsPointer(ref this), pVideoProcessor, StreamIndex, Enable, Format, LeftViewFrame0, BaseViewFrame0, FlipMode, MonoOffset); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(51)] + public void VideoProcessorSetStreamAutoProcessingMode(ID3D11VideoProcessor* pVideoProcessor, uint StreamIndex, Bool32* Enable) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[51]))((ID3D11VideoContext3*)Unsafe.AsPointer(ref this), pVideoProcessor, StreamIndex, Enable); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[51]))((ID3D11VideoContext3*)Unsafe.AsPointer(ref this), pVideoProcessor, StreamIndex, Enable); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(52)] + public void VideoProcessorSetStreamFilter(ID3D11VideoProcessor* pVideoProcessor, uint StreamIndex, VideoProcessorFilter Filter, Bool32* Enable, int Level) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[52]))((ID3D11VideoContext3*)Unsafe.AsPointer(ref this), pVideoProcessor, StreamIndex, Filter, Enable, Level); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[52]))((ID3D11VideoContext3*)Unsafe.AsPointer(ref this), pVideoProcessor, StreamIndex, Filter, Enable, Level); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(53)] + public int VideoProcessorSetStreamExtension(ID3D11VideoProcessor* pVideoProcessor, uint StreamIndex, Guid* pExtensionGuid, uint DataSize, void* pData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[53]))((ID3D11VideoContext3*)Unsafe.AsPointer(ref this), pVideoProcessor, StreamIndex, pExtensionGuid, DataSize, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[53]))((ID3D11VideoContext3*)Unsafe.AsPointer(ref this), pVideoProcessor, StreamIndex, pExtensionGuid, DataSize, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(54)] + public void VideoProcessorGetStreamFrameFormat(ID3D11VideoProcessor* pVideoProcessor, uint StreamIndex, VideoFrameFormat* pFrameFormat) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[54]))((ID3D11VideoContext3*)Unsafe.AsPointer(ref this), pVideoProcessor, StreamIndex, pFrameFormat); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[54]))((ID3D11VideoContext3*)Unsafe.AsPointer(ref this), pVideoProcessor, StreamIndex, pFrameFormat); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(55)] + public void VideoProcessorGetStreamColorSpace(ID3D11VideoProcessor* pVideoProcessor, uint StreamIndex, VideoProcessorColorSpace* pColorSpace) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[55]))((ID3D11VideoContext3*)Unsafe.AsPointer(ref this), pVideoProcessor, StreamIndex, pColorSpace); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[55]))((ID3D11VideoContext3*)Unsafe.AsPointer(ref this), pVideoProcessor, StreamIndex, pColorSpace); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(56)] + public void VideoProcessorGetStreamOutputRate(ID3D11VideoProcessor* pVideoProcessor, uint StreamIndex, VideoProcessorOutputRate* pOutputRate, Bool32* pRepeatFrame, Graphics.Dxgi.Common.Rational* pCustomRate) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[56]))((ID3D11VideoContext3*)Unsafe.AsPointer(ref this), pVideoProcessor, StreamIndex, pOutputRate, pRepeatFrame, pCustomRate); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[56]))((ID3D11VideoContext3*)Unsafe.AsPointer(ref this), pVideoProcessor, StreamIndex, pOutputRate, pRepeatFrame, pCustomRate); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(57)] + public void VideoProcessorGetStreamSourceRect(ID3D11VideoProcessor* pVideoProcessor, uint StreamIndex, Bool32* pEnabled, RawRect* pRect) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[57]))((ID3D11VideoContext3*)Unsafe.AsPointer(ref this), pVideoProcessor, StreamIndex, pEnabled, pRect); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[57]))((ID3D11VideoContext3*)Unsafe.AsPointer(ref this), pVideoProcessor, StreamIndex, pEnabled, pRect); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(58)] + public void VideoProcessorGetStreamDestRect(ID3D11VideoProcessor* pVideoProcessor, uint StreamIndex, Bool32* pEnabled, RawRect* pRect) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[58]))((ID3D11VideoContext3*)Unsafe.AsPointer(ref this), pVideoProcessor, StreamIndex, pEnabled, pRect); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[58]))((ID3D11VideoContext3*)Unsafe.AsPointer(ref this), pVideoProcessor, StreamIndex, pEnabled, pRect); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(59)] + public void VideoProcessorGetStreamAlpha(ID3D11VideoProcessor* pVideoProcessor, uint StreamIndex, Bool32* pEnabled, float* pAlpha) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[59]))((ID3D11VideoContext3*)Unsafe.AsPointer(ref this), pVideoProcessor, StreamIndex, pEnabled, pAlpha); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[59]))((ID3D11VideoContext3*)Unsafe.AsPointer(ref this), pVideoProcessor, StreamIndex, pEnabled, pAlpha); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(60)] + public void VideoProcessorGetStreamPalette(ID3D11VideoProcessor* pVideoProcessor, uint StreamIndex, uint Count, uint* pEntries) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[60]))((ID3D11VideoContext3*)Unsafe.AsPointer(ref this), pVideoProcessor, StreamIndex, Count, pEntries); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[60]))((ID3D11VideoContext3*)Unsafe.AsPointer(ref this), pVideoProcessor, StreamIndex, Count, pEntries); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(61)] + public void VideoProcessorGetStreamPixelAspectRatio(ID3D11VideoProcessor* pVideoProcessor, uint StreamIndex, Bool32* pEnabled, Graphics.Dxgi.Common.Rational* pSourceAspectRatio, Graphics.Dxgi.Common.Rational* pDestinationAspectRatio) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[61]))((ID3D11VideoContext3*)Unsafe.AsPointer(ref this), pVideoProcessor, StreamIndex, pEnabled, pSourceAspectRatio, pDestinationAspectRatio); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[61]))((ID3D11VideoContext3*)Unsafe.AsPointer(ref this), pVideoProcessor, StreamIndex, pEnabled, pSourceAspectRatio, pDestinationAspectRatio); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(62)] + public void VideoProcessorGetStreamLumaKey(ID3D11VideoProcessor* pVideoProcessor, uint StreamIndex, Bool32* pEnabled, float* pLower, float* pUpper) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[62]))((ID3D11VideoContext3*)Unsafe.AsPointer(ref this), pVideoProcessor, StreamIndex, pEnabled, pLower, pUpper); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[62]))((ID3D11VideoContext3*)Unsafe.AsPointer(ref this), pVideoProcessor, StreamIndex, pEnabled, pLower, pUpper); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(63)] + public void VideoProcessorGetStreamStereoFormat(ID3D11VideoProcessor* pVideoProcessor, uint StreamIndex, Bool32* pEnable, VideoProcessorStereoFormat* pFormat, Bool32* pLeftViewFrame0, Bool32* pBaseViewFrame0, VideoProcessorStereoFlipMode* pFlipMode, int* MonoOffset) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[63]))((ID3D11VideoContext3*)Unsafe.AsPointer(ref this), pVideoProcessor, StreamIndex, pEnable, pFormat, pLeftViewFrame0, pBaseViewFrame0, pFlipMode, MonoOffset); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[63]))((ID3D11VideoContext3*)Unsafe.AsPointer(ref this), pVideoProcessor, StreamIndex, pEnable, pFormat, pLeftViewFrame0, pBaseViewFrame0, pFlipMode, MonoOffset); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(64)] + public void VideoProcessorGetStreamAutoProcessingMode(ID3D11VideoProcessor* pVideoProcessor, uint StreamIndex, Bool32* pEnabled) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[64]))((ID3D11VideoContext3*)Unsafe.AsPointer(ref this), pVideoProcessor, StreamIndex, pEnabled); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[64]))((ID3D11VideoContext3*)Unsafe.AsPointer(ref this), pVideoProcessor, StreamIndex, pEnabled); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(65)] + public void VideoProcessorGetStreamFilter(ID3D11VideoProcessor* pVideoProcessor, uint StreamIndex, VideoProcessorFilter Filter, Bool32* pEnabled, int* pLevel) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[65]))((ID3D11VideoContext3*)Unsafe.AsPointer(ref this), pVideoProcessor, StreamIndex, Filter, pEnabled, pLevel); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[65]))((ID3D11VideoContext3*)Unsafe.AsPointer(ref this), pVideoProcessor, StreamIndex, Filter, pEnabled, pLevel); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(66)] + public int VideoProcessorGetStreamExtension(ID3D11VideoProcessor* pVideoProcessor, uint StreamIndex, Guid* pExtensionGuid, uint DataSize, void* pData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[66]))((ID3D11VideoContext3*)Unsafe.AsPointer(ref this), pVideoProcessor, StreamIndex, pExtensionGuid, DataSize, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[66]))((ID3D11VideoContext3*)Unsafe.AsPointer(ref this), pVideoProcessor, StreamIndex, pExtensionGuid, DataSize, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(67)] + public HResult VideoProcessorBlt(ID3D11VideoProcessor* pVideoProcessor, ID3D11VideoProcessorOutputView* pView, uint OutputFrame, uint StreamCount, VideoProcessorStream* pStreams) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[67]))((ID3D11VideoContext3*)Unsafe.AsPointer(ref this), pVideoProcessor, pView, OutputFrame, StreamCount, pStreams); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[67]))((ID3D11VideoContext3*)Unsafe.AsPointer(ref this), pVideoProcessor, pView, OutputFrame, StreamCount, pStreams); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(68)] + public HResult NegotiateCryptoSessionKeyExchange(ID3D11CryptoSession* pCryptoSession, uint DataSize, void* pData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[68]))((ID3D11VideoContext3*)Unsafe.AsPointer(ref this), pCryptoSession, DataSize, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[68]))((ID3D11VideoContext3*)Unsafe.AsPointer(ref this), pCryptoSession, DataSize, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(69)] + public void EncryptionBlt(ID3D11CryptoSession* pCryptoSession, ID3D11Texture2D* pSrcSurface, ID3D11Texture2D* pDstSurface, uint IVSize, void* pIV) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[69]))((ID3D11VideoContext3*)Unsafe.AsPointer(ref this), pCryptoSession, pSrcSurface, pDstSurface, IVSize, pIV); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[69]))((ID3D11VideoContext3*)Unsafe.AsPointer(ref this), pCryptoSession, pSrcSurface, pDstSurface, IVSize, pIV); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(70)] + public void DecryptionBlt(ID3D11CryptoSession* pCryptoSession, ID3D11Texture2D* pSrcSurface, ID3D11Texture2D* pDstSurface, EncryptedBlockInfo* pEncryptedBlockInfo, uint ContentKeySize, void* pContentKey, uint IVSize, void* pIV) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[70]))((ID3D11VideoContext3*)Unsafe.AsPointer(ref this), pCryptoSession, pSrcSurface, pDstSurface, pEncryptedBlockInfo, ContentKeySize, pContentKey, IVSize, pIV); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[70]))((ID3D11VideoContext3*)Unsafe.AsPointer(ref this), pCryptoSession, pSrcSurface, pDstSurface, pEncryptedBlockInfo, ContentKeySize, pContentKey, IVSize, pIV); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(71)] + public void StartSessionKeyRefresh(ID3D11CryptoSession* pCryptoSession, uint RandomNumberSize, void* pRandomNumber) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[71]))((ID3D11VideoContext3*)Unsafe.AsPointer(ref this), pCryptoSession, RandomNumberSize, pRandomNumber); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[71]))((ID3D11VideoContext3*)Unsafe.AsPointer(ref this), pCryptoSession, RandomNumberSize, pRandomNumber); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(72)] + public void FinishSessionKeyRefresh(ID3D11CryptoSession* pCryptoSession) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[72]))((ID3D11VideoContext3*)Unsafe.AsPointer(ref this), pCryptoSession); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[72]))((ID3D11VideoContext3*)Unsafe.AsPointer(ref this), pCryptoSession); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(73)] + public HResult GetEncryptionBltKey(ID3D11CryptoSession* pCryptoSession, uint KeySize, void* pReadbackKey) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[73]))((ID3D11VideoContext3*)Unsafe.AsPointer(ref this), pCryptoSession, KeySize, pReadbackKey); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[73]))((ID3D11VideoContext3*)Unsafe.AsPointer(ref this), pCryptoSession, KeySize, pReadbackKey); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(74)] + public HResult NegotiateAuthenticatedChannelKeyExchange(ID3D11AuthenticatedChannel* pChannel, uint DataSize, void* pData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[74]))((ID3D11VideoContext3*)Unsafe.AsPointer(ref this), pChannel, DataSize, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[74]))((ID3D11VideoContext3*)Unsafe.AsPointer(ref this), pChannel, DataSize, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(75)] + public HResult QueryAuthenticatedChannel(ID3D11AuthenticatedChannel* pChannel, uint InputSize, void* pInput, uint OutputSize, void* pOutput) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[75]))((ID3D11VideoContext3*)Unsafe.AsPointer(ref this), pChannel, InputSize, pInput, OutputSize, pOutput); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[75]))((ID3D11VideoContext3*)Unsafe.AsPointer(ref this), pChannel, InputSize, pInput, OutputSize, pOutput); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(76)] + public HResult ConfigureAuthenticatedChannel(ID3D11AuthenticatedChannel* pChannel, uint InputSize, void* pInput, AuthenticatedConfigureOutput* pOutput) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[76]))((ID3D11VideoContext3*)Unsafe.AsPointer(ref this), pChannel, InputSize, pInput, pOutput); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[76]))((ID3D11VideoContext3*)Unsafe.AsPointer(ref this), pChannel, InputSize, pInput, pOutput); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(77)] + public void VideoProcessorSetStreamRotation(ID3D11VideoProcessor* pVideoProcessor, uint StreamIndex, Bool32* Enable, VideoProcessorRotation Rotation) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[77]))((ID3D11VideoContext3*)Unsafe.AsPointer(ref this), pVideoProcessor, StreamIndex, Enable, Rotation); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[77]))((ID3D11VideoContext3*)Unsafe.AsPointer(ref this), pVideoProcessor, StreamIndex, Enable, Rotation); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(78)] + public void VideoProcessorGetStreamRotation(ID3D11VideoProcessor* pVideoProcessor, uint StreamIndex, Bool32* pEnable, VideoProcessorRotation* pRotation) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[78]))((ID3D11VideoContext3*)Unsafe.AsPointer(ref this), pVideoProcessor, StreamIndex, pEnable, pRotation); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[78]))((ID3D11VideoContext3*)Unsafe.AsPointer(ref this), pVideoProcessor, StreamIndex, pEnable, pRotation); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(79)] + public void GetDevice(ID3D11Device* ppDevice) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[79]))((ID3D11VideoContext3*)Unsafe.AsPointer(ref this), ppDevice); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[79]))((ID3D11VideoContext3*)Unsafe.AsPointer(ref this), ppDevice); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(80)] + public HResult GetPrivateData(Guid* guid, uint* pDataSize, void* pData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[80]))((ID3D11VideoContext3*)Unsafe.AsPointer(ref this), guid, pDataSize, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[80]))((ID3D11VideoContext3*)Unsafe.AsPointer(ref this), guid, pDataSize, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(81)] + public HResult SetPrivateData(Guid* guid, uint DataSize, void* pData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[81]))((ID3D11VideoContext3*)Unsafe.AsPointer(ref this), guid, DataSize, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[81]))((ID3D11VideoContext3*)Unsafe.AsPointer(ref this), guid, DataSize, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(82)] + public HResult SetPrivateDataInterface(Guid* guid, IUnknown* pData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[82]))((ID3D11VideoContext3*)Unsafe.AsPointer(ref this), guid, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[82]))((ID3D11VideoContext3*)Unsafe.AsPointer(ref this), guid, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(83)] + public HResult DecoderBeginFrame1(ID3D11VideoDecoder* pDecoder, ID3D11VideoDecoderOutputView* pView, uint ContentKeySize, void* pContentKey, uint NumComponentHistograms, uint* pHistogramOffsets, ID3D11Buffer* ppHistogramBuffers) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[83]))((ID3D11VideoContext3*)Unsafe.AsPointer(ref this), pDecoder, pView, ContentKeySize, pContentKey, NumComponentHistograms, pHistogramOffsets, ppHistogramBuffers); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[83]))((ID3D11VideoContext3*)Unsafe.AsPointer(ref this), pDecoder, pView, ContentKeySize, pContentKey, NumComponentHistograms, pHistogramOffsets, ppHistogramBuffers); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(84)] + public HResult SubmitDecoderBuffers2(ID3D11VideoDecoder* pDecoder, uint NumBuffers, VideoDecoderBufferDescription2* pBufferDesc) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[84]))((ID3D11VideoContext3*)Unsafe.AsPointer(ref this), pDecoder, NumBuffers, pBufferDesc); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[84]))((ID3D11VideoContext3*)Unsafe.AsPointer(ref this), pDecoder, NumBuffers, pBufferDesc); +#endif + } + + public interface Interface : ID3D11VideoContext2.Interface + { + } +} + +/// +/// ID3D11ShaderReflectionType +[Guid("6e6ffa6a-9bae-4613-a51e-91652d508c21")] +public unsafe partial struct ID3D11ShaderReflectionType : ID3D11ShaderReflectionType.Interface +{ + public static ref readonly Guid IID_ID3D11ShaderReflectionType + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x6A, 0xFA, 0x6F, 0x6E, + 0xAE, 0x9B, + 0x13, 0x46, + 0xA5, + 0x1E, + 0x91, + 0x65, + 0x2D, + 0x50, + 0x8C, + 0x21 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_ID3D11ShaderReflectionType)); + + public void** lpVtbl; + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(0)] + public HResult GetDesc(ShaderTypeDescription* pDesc) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[0]))((ID3D11ShaderReflectionType*)Unsafe.AsPointer(ref this), pDesc); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[0]))((ID3D11ShaderReflectionType*)Unsafe.AsPointer(ref this), pDesc); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(1)] + public Graphics.Direct3D11.ID3D11ShaderReflectionType GetMemberTypeByIndex(uint Index) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[1]))((ID3D11ShaderReflectionType*)Unsafe.AsPointer(ref this), Index); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[1]))((ID3D11ShaderReflectionType*)Unsafe.AsPointer(ref this), Index); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(2)] + public Graphics.Direct3D11.ID3D11ShaderReflectionType GetMemberTypeByName(byte** Name) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[2]))((ID3D11ShaderReflectionType*)Unsafe.AsPointer(ref this), Name); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[2]))((ID3D11ShaderReflectionType*)Unsafe.AsPointer(ref this), Name); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(3)] + public byte* GetMemberTypeName(uint Index) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[3]))((ID3D11ShaderReflectionType*)Unsafe.AsPointer(ref this), Index); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((ID3D11ShaderReflectionType*)Unsafe.AsPointer(ref this), Index); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public HResult IsEqual(ID3D11ShaderReflectionType* pType) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[4]))((ID3D11ShaderReflectionType*)Unsafe.AsPointer(ref this), pType); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((ID3D11ShaderReflectionType*)Unsafe.AsPointer(ref this), pType); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(5)] + public Graphics.Direct3D11.ID3D11ShaderReflectionType GetSubType() + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[5]))((ID3D11ShaderReflectionType*)Unsafe.AsPointer(ref this)); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((ID3D11ShaderReflectionType*)Unsafe.AsPointer(ref this)); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(6)] + public Graphics.Direct3D11.ID3D11ShaderReflectionType GetBaseClass() + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[6]))((ID3D11ShaderReflectionType*)Unsafe.AsPointer(ref this)); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((ID3D11ShaderReflectionType*)Unsafe.AsPointer(ref this)); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(7)] + public uint GetNumInterfaces() + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[7]))((ID3D11ShaderReflectionType*)Unsafe.AsPointer(ref this)); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((ID3D11ShaderReflectionType*)Unsafe.AsPointer(ref this)); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(8)] + public Graphics.Direct3D11.ID3D11ShaderReflectionType GetInterfaceByIndex(uint uIndex) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[8]))((ID3D11ShaderReflectionType*)Unsafe.AsPointer(ref this), uIndex); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[8]))((ID3D11ShaderReflectionType*)Unsafe.AsPointer(ref this), uIndex); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(9)] + public HResult IsOfType(ID3D11ShaderReflectionType* pType) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[9]))((ID3D11ShaderReflectionType*)Unsafe.AsPointer(ref this), pType); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[9]))((ID3D11ShaderReflectionType*)Unsafe.AsPointer(ref this), pType); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(10)] + public HResult ImplementsInterface(ID3D11ShaderReflectionType* pBase) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[10]))((ID3D11ShaderReflectionType*)Unsafe.AsPointer(ref this), pBase); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[10]))((ID3D11ShaderReflectionType*)Unsafe.AsPointer(ref this), pBase); +#endif + } + + public interface Interface + { + } +} + +/// +/// ID3D11ShaderReflectionVariable +[Guid("51f23923-f3e5-4bd1-91cb-606177d8db4c")] +public unsafe partial struct ID3D11ShaderReflectionVariable : ID3D11ShaderReflectionVariable.Interface +{ + public static ref readonly Guid IID_ID3D11ShaderReflectionVariable + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x23, 0x39, 0xF2, 0x51, + 0xE5, 0xF3, + 0xD1, 0x4B, + 0x91, + 0xCB, + 0x60, + 0x61, + 0x77, + 0xD8, + 0xDB, + 0x4C + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_ID3D11ShaderReflectionVariable)); + + public void** lpVtbl; + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(0)] + public HResult GetDesc(ShaderVariableDescription* pDesc) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[0]))((ID3D11ShaderReflectionVariable*)Unsafe.AsPointer(ref this), pDesc); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[0]))((ID3D11ShaderReflectionVariable*)Unsafe.AsPointer(ref this), pDesc); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(1)] + public Graphics.Direct3D11.ID3D11ShaderReflectionType GetType() + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[1]))((ID3D11ShaderReflectionVariable*)Unsafe.AsPointer(ref this)); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[1]))((ID3D11ShaderReflectionVariable*)Unsafe.AsPointer(ref this)); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(2)] + public Graphics.Direct3D11.ID3D11ShaderReflectionConstantBuffer GetBuffer() + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[2]))((ID3D11ShaderReflectionVariable*)Unsafe.AsPointer(ref this)); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[2]))((ID3D11ShaderReflectionVariable*)Unsafe.AsPointer(ref this)); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(3)] + public uint GetInterfaceSlot(uint uArrayIndex) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[3]))((ID3D11ShaderReflectionVariable*)Unsafe.AsPointer(ref this), uArrayIndex); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((ID3D11ShaderReflectionVariable*)Unsafe.AsPointer(ref this), uArrayIndex); +#endif + } + + public interface Interface + { + } +} + +/// +/// ID3D11ShaderReflectionConstantBuffer +[Guid("eb62d63d-93dd-4318-8ae8-c6f83ad371b8")] +public unsafe partial struct ID3D11ShaderReflectionConstantBuffer : ID3D11ShaderReflectionConstantBuffer.Interface +{ + public static ref readonly Guid IID_ID3D11ShaderReflectionConstantBuffer + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x3D, 0xD6, 0x62, 0xEB, + 0xDD, 0x93, + 0x18, 0x43, + 0x8A, + 0xE8, + 0xC6, + 0xF8, + 0x3A, + 0xD3, + 0x71, + 0xB8 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_ID3D11ShaderReflectionConstantBuffer)); + + public void** lpVtbl; + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(0)] + public HResult GetDesc(ShaderBufferDescription* pDesc) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[0]))((ID3D11ShaderReflectionConstantBuffer*)Unsafe.AsPointer(ref this), pDesc); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[0]))((ID3D11ShaderReflectionConstantBuffer*)Unsafe.AsPointer(ref this), pDesc); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(1)] + public Graphics.Direct3D11.ID3D11ShaderReflectionVariable GetVariableByIndex(uint Index) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[1]))((ID3D11ShaderReflectionConstantBuffer*)Unsafe.AsPointer(ref this), Index); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[1]))((ID3D11ShaderReflectionConstantBuffer*)Unsafe.AsPointer(ref this), Index); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(2)] + public Graphics.Direct3D11.ID3D11ShaderReflectionVariable GetVariableByName(byte** Name) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[2]))((ID3D11ShaderReflectionConstantBuffer*)Unsafe.AsPointer(ref this), Name); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[2]))((ID3D11ShaderReflectionConstantBuffer*)Unsafe.AsPointer(ref this), Name); +#endif + } + + public interface Interface + { + } +} + +/// +/// ID3D11ShaderReflection +[Guid("8d536ca1-0cca-4956-a837-786963755584")] +[NativeTypeName("struct ID3D11ShaderReflection : IUnknown")] +[NativeInheritance("IUnknown")] +public unsafe partial struct ID3D11ShaderReflection : ID3D11ShaderReflection.Interface +{ + public static ref readonly Guid IID_ID3D11ShaderReflection + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0xA1, 0x6C, 0x53, 0x8D, + 0xCA, 0x0C, + 0x56, 0x49, + 0xA8, + 0x37, + 0x78, + 0x69, + 0x63, + 0x75, + 0x55, + 0x84 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_ID3D11ShaderReflection)); + + public void** lpVtbl; + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(0)] + public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(1)] + [return: NativeTypeName("ULONG")] + public uint AddRef() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(2)] + [return: NativeTypeName("ULONG")] + public uint Release() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(3)] + public HResult GetDesc(ShaderDescription* pDesc) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[3]))((ID3D11ShaderReflection*)Unsafe.AsPointer(ref this), pDesc); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((ID3D11ShaderReflection*)Unsafe.AsPointer(ref this), pDesc); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public Graphics.Direct3D11.ID3D11ShaderReflectionConstantBuffer GetConstantBufferByIndex(uint Index) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[4]))((ID3D11ShaderReflection*)Unsafe.AsPointer(ref this), Index); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((ID3D11ShaderReflection*)Unsafe.AsPointer(ref this), Index); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(5)] + public Graphics.Direct3D11.ID3D11ShaderReflectionConstantBuffer GetConstantBufferByName(byte** Name) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[5]))((ID3D11ShaderReflection*)Unsafe.AsPointer(ref this), Name); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((ID3D11ShaderReflection*)Unsafe.AsPointer(ref this), Name); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(6)] + public HResult GetResourceBindingDesc(uint ResourceIndex, ShaderInputBindDescription* pDesc) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[6]))((ID3D11ShaderReflection*)Unsafe.AsPointer(ref this), ResourceIndex, pDesc); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((ID3D11ShaderReflection*)Unsafe.AsPointer(ref this), ResourceIndex, pDesc); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(7)] + public HResult GetInputParameterDesc(uint ParameterIndex, SignatureParameterDescription* pDesc) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[7]))((ID3D11ShaderReflection*)Unsafe.AsPointer(ref this), ParameterIndex, pDesc); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((ID3D11ShaderReflection*)Unsafe.AsPointer(ref this), ParameterIndex, pDesc); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(8)] + public HResult GetOutputParameterDesc(uint ParameterIndex, SignatureParameterDescription* pDesc) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[8]))((ID3D11ShaderReflection*)Unsafe.AsPointer(ref this), ParameterIndex, pDesc); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[8]))((ID3D11ShaderReflection*)Unsafe.AsPointer(ref this), ParameterIndex, pDesc); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(9)] + public HResult GetPatchConstantParameterDesc(uint ParameterIndex, SignatureParameterDescription* pDesc) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[9]))((ID3D11ShaderReflection*)Unsafe.AsPointer(ref this), ParameterIndex, pDesc); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[9]))((ID3D11ShaderReflection*)Unsafe.AsPointer(ref this), ParameterIndex, pDesc); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(10)] + public Graphics.Direct3D11.ID3D11ShaderReflectionVariable GetVariableByName(byte** Name) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[10]))((ID3D11ShaderReflection*)Unsafe.AsPointer(ref this), Name); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[10]))((ID3D11ShaderReflection*)Unsafe.AsPointer(ref this), Name); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(11)] + public HResult GetResourceBindingDescByName(byte** Name, ShaderInputBindDescription* pDesc) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[11]))((ID3D11ShaderReflection*)Unsafe.AsPointer(ref this), Name, pDesc); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[11]))((ID3D11ShaderReflection*)Unsafe.AsPointer(ref this), Name, pDesc); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(12)] + public uint GetMovInstructionCount() + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[12]))((ID3D11ShaderReflection*)Unsafe.AsPointer(ref this)); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[12]))((ID3D11ShaderReflection*)Unsafe.AsPointer(ref this)); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(13)] + public uint GetMovcInstructionCount() + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[13]))((ID3D11ShaderReflection*)Unsafe.AsPointer(ref this)); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[13]))((ID3D11ShaderReflection*)Unsafe.AsPointer(ref this)); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(14)] + public uint GetConversionInstructionCount() + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[14]))((ID3D11ShaderReflection*)Unsafe.AsPointer(ref this)); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[14]))((ID3D11ShaderReflection*)Unsafe.AsPointer(ref this)); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(15)] + public uint GetBitwiseInstructionCount() + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[15]))((ID3D11ShaderReflection*)Unsafe.AsPointer(ref this)); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[15]))((ID3D11ShaderReflection*)Unsafe.AsPointer(ref this)); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(16)] + public Graphics.Direct3D.Primitive GetGSInputPrimitive() + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[16]))((ID3D11ShaderReflection*)Unsafe.AsPointer(ref this)); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[16]))((ID3D11ShaderReflection*)Unsafe.AsPointer(ref this)); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(17)] + public Bool32 IsSampleFrequencyShader() + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[17]))((ID3D11ShaderReflection*)Unsafe.AsPointer(ref this)); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[17]))((ID3D11ShaderReflection*)Unsafe.AsPointer(ref this)); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(18)] + public uint GetNumInterfaceSlots() + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[18]))((ID3D11ShaderReflection*)Unsafe.AsPointer(ref this)); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[18]))((ID3D11ShaderReflection*)Unsafe.AsPointer(ref this)); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(19)] + public HResult GetMinFeatureLevel(Graphics.Direct3D.FeatureLevel* pLevel) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[19]))((ID3D11ShaderReflection*)Unsafe.AsPointer(ref this), pLevel); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[19]))((ID3D11ShaderReflection*)Unsafe.AsPointer(ref this), pLevel); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(20)] + public uint GetThreadGroupSize(uint* pSizeX, uint* pSizeY, uint* pSizeZ) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[20]))((ID3D11ShaderReflection*)Unsafe.AsPointer(ref this), pSizeX, pSizeY, pSizeZ); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[20]))((ID3D11ShaderReflection*)Unsafe.AsPointer(ref this), pSizeX, pSizeY, pSizeZ); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(21)] + public ulong GetRequiresFlags() + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[21]))((ID3D11ShaderReflection*)Unsafe.AsPointer(ref this)); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[21]))((ID3D11ShaderReflection*)Unsafe.AsPointer(ref this)); +#endif + } + + public interface Interface : IUnknown.Interface + { + } +} + +/// +/// ID3D11LibraryReflection +[Guid("54384f1b-5b3e-4bb7-ae01-60ba3097cbb6")] +[NativeTypeName("struct ID3D11LibraryReflection : IUnknown")] +[NativeInheritance("IUnknown")] +public unsafe partial struct ID3D11LibraryReflection : ID3D11LibraryReflection.Interface +{ + public static ref readonly Guid IID_ID3D11LibraryReflection + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x1B, 0x4F, 0x38, 0x54, + 0x3E, 0x5B, + 0xB7, 0x4B, + 0xAE, + 0x01, + 0x60, + 0xBA, + 0x30, + 0x97, + 0xCB, + 0xB6 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_ID3D11LibraryReflection)); + + public void** lpVtbl; + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(0)] + public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(1)] + [return: NativeTypeName("ULONG")] + public uint AddRef() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(2)] + [return: NativeTypeName("ULONG")] + public uint Release() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(3)] + public HResult GetDesc(LibraryDescription* pDesc) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[3]))((ID3D11LibraryReflection*)Unsafe.AsPointer(ref this), pDesc); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((ID3D11LibraryReflection*)Unsafe.AsPointer(ref this), pDesc); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public Graphics.Direct3D11.ID3D11FunctionReflection GetFunctionByIndex(int FunctionIndex) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[4]))((ID3D11LibraryReflection*)Unsafe.AsPointer(ref this), FunctionIndex); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((ID3D11LibraryReflection*)Unsafe.AsPointer(ref this), FunctionIndex); +#endif + } + + public interface Interface : IUnknown.Interface + { + } +} + +/// +/// ID3D11FunctionReflection +[Guid("207bcecb-d683-4a06-a8a3-9b149b9f73a4")] +public unsafe partial struct ID3D11FunctionReflection : ID3D11FunctionReflection.Interface +{ + public static ref readonly Guid IID_ID3D11FunctionReflection + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0xCB, 0xCE, 0x7B, 0x20, + 0x83, 0xD6, + 0x06, 0x4A, + 0xA8, + 0xA3, + 0x9B, + 0x14, + 0x9B, + 0x9F, + 0x73, + 0xA4 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_ID3D11FunctionReflection)); + + public void** lpVtbl; + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(0)] + public HResult GetDesc(FunctionDescription* pDesc) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[0]))((ID3D11FunctionReflection*)Unsafe.AsPointer(ref this), pDesc); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[0]))((ID3D11FunctionReflection*)Unsafe.AsPointer(ref this), pDesc); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(1)] + public Graphics.Direct3D11.ID3D11ShaderReflectionConstantBuffer GetConstantBufferByIndex(uint BufferIndex) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[1]))((ID3D11FunctionReflection*)Unsafe.AsPointer(ref this), BufferIndex); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[1]))((ID3D11FunctionReflection*)Unsafe.AsPointer(ref this), BufferIndex); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(2)] + public Graphics.Direct3D11.ID3D11ShaderReflectionConstantBuffer GetConstantBufferByName(byte** Name) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[2]))((ID3D11FunctionReflection*)Unsafe.AsPointer(ref this), Name); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[2]))((ID3D11FunctionReflection*)Unsafe.AsPointer(ref this), Name); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(3)] + public HResult GetResourceBindingDesc(uint ResourceIndex, ShaderInputBindDescription* pDesc) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[3]))((ID3D11FunctionReflection*)Unsafe.AsPointer(ref this), ResourceIndex, pDesc); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((ID3D11FunctionReflection*)Unsafe.AsPointer(ref this), ResourceIndex, pDesc); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public Graphics.Direct3D11.ID3D11ShaderReflectionVariable GetVariableByName(byte** Name) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[4]))((ID3D11FunctionReflection*)Unsafe.AsPointer(ref this), Name); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((ID3D11FunctionReflection*)Unsafe.AsPointer(ref this), Name); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(5)] + public HResult GetResourceBindingDescByName(byte** Name, ShaderInputBindDescription* pDesc) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[5]))((ID3D11FunctionReflection*)Unsafe.AsPointer(ref this), Name, pDesc); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((ID3D11FunctionReflection*)Unsafe.AsPointer(ref this), Name, pDesc); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(6)] + public Graphics.Direct3D11.ID3D11FunctionParameterReflection GetFunctionParameter(int ParameterIndex) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[6]))((ID3D11FunctionReflection*)Unsafe.AsPointer(ref this), ParameterIndex); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((ID3D11FunctionReflection*)Unsafe.AsPointer(ref this), ParameterIndex); +#endif + } + + public interface Interface + { + } +} + +/// +/// ID3D11FunctionParameterReflection +[Guid("42757488-334f-47fe-982e-1a65d08cc462")] +public unsafe partial struct ID3D11FunctionParameterReflection : ID3D11FunctionParameterReflection.Interface +{ + public static ref readonly Guid IID_ID3D11FunctionParameterReflection + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x88, 0x74, 0x75, 0x42, + 0x4F, 0x33, + 0xFE, 0x47, + 0x98, + 0x2E, + 0x1A, + 0x65, + 0xD0, + 0x8C, + 0xC4, + 0x62 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_ID3D11FunctionParameterReflection)); + + public void** lpVtbl; + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(0)] + public HResult GetDesc(ParameterDescription* pDesc) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[0]))((ID3D11FunctionParameterReflection*)Unsafe.AsPointer(ref this), pDesc); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[0]))((ID3D11FunctionParameterReflection*)Unsafe.AsPointer(ref this), pDesc); +#endif + } + + public interface Interface + { + } +} + +/// +/// ID3D11ModuleInstance +[Guid("469e07f7-045a-48d5-aa12-68a478cdf75d")] +[NativeTypeName("struct ID3D11ModuleInstance : IUnknown")] +[NativeInheritance("IUnknown")] +public unsafe partial struct ID3D11ModuleInstance : ID3D11ModuleInstance.Interface +{ + public static ref readonly Guid IID_ID3D11ModuleInstance + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0xF7, 0x07, 0x9E, 0x46, + 0x5A, 0x04, + 0xD5, 0x48, + 0xAA, + 0x12, + 0x68, + 0xA4, + 0x78, + 0xCD, + 0xF7, + 0x5D + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_ID3D11ModuleInstance)); + + public void** lpVtbl; + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(0)] + public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(1)] + [return: NativeTypeName("ULONG")] + public uint AddRef() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(2)] + [return: NativeTypeName("ULONG")] + public uint Release() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(3)] + public HResult BindConstantBuffer(uint uSrcSlot, uint uDstSlot, uint cbDstOffset) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[3]))((ID3D11ModuleInstance*)Unsafe.AsPointer(ref this), uSrcSlot, uDstSlot, cbDstOffset); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((ID3D11ModuleInstance*)Unsafe.AsPointer(ref this), uSrcSlot, uDstSlot, cbDstOffset); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public HResult BindConstantBufferByName(byte** pName, uint uDstSlot, uint cbDstOffset) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[4]))((ID3D11ModuleInstance*)Unsafe.AsPointer(ref this), pName, uDstSlot, cbDstOffset); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((ID3D11ModuleInstance*)Unsafe.AsPointer(ref this), pName, uDstSlot, cbDstOffset); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(5)] + public HResult BindResource(uint uSrcSlot, uint uDstSlot, uint uCount) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[5]))((ID3D11ModuleInstance*)Unsafe.AsPointer(ref this), uSrcSlot, uDstSlot, uCount); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((ID3D11ModuleInstance*)Unsafe.AsPointer(ref this), uSrcSlot, uDstSlot, uCount); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(6)] + public HResult BindResourceByName(byte** pName, uint uDstSlot, uint uCount) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[6]))((ID3D11ModuleInstance*)Unsafe.AsPointer(ref this), pName, uDstSlot, uCount); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((ID3D11ModuleInstance*)Unsafe.AsPointer(ref this), pName, uDstSlot, uCount); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(7)] + public HResult BindSampler(uint uSrcSlot, uint uDstSlot, uint uCount) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[7]))((ID3D11ModuleInstance*)Unsafe.AsPointer(ref this), uSrcSlot, uDstSlot, uCount); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((ID3D11ModuleInstance*)Unsafe.AsPointer(ref this), uSrcSlot, uDstSlot, uCount); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(8)] + public HResult BindSamplerByName(byte** pName, uint uDstSlot, uint uCount) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[8]))((ID3D11ModuleInstance*)Unsafe.AsPointer(ref this), pName, uDstSlot, uCount); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[8]))((ID3D11ModuleInstance*)Unsafe.AsPointer(ref this), pName, uDstSlot, uCount); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(9)] + public HResult BindUnorderedAccessView(uint uSrcSlot, uint uDstSlot, uint uCount) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[9]))((ID3D11ModuleInstance*)Unsafe.AsPointer(ref this), uSrcSlot, uDstSlot, uCount); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[9]))((ID3D11ModuleInstance*)Unsafe.AsPointer(ref this), uSrcSlot, uDstSlot, uCount); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(10)] + public HResult BindUnorderedAccessViewByName(byte** pName, uint uDstSlot, uint uCount) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[10]))((ID3D11ModuleInstance*)Unsafe.AsPointer(ref this), pName, uDstSlot, uCount); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[10]))((ID3D11ModuleInstance*)Unsafe.AsPointer(ref this), pName, uDstSlot, uCount); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(11)] + public HResult BindResourceAsUnorderedAccessView(uint uSrcSrvSlot, uint uDstUavSlot, uint uCount) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[11]))((ID3D11ModuleInstance*)Unsafe.AsPointer(ref this), uSrcSrvSlot, uDstUavSlot, uCount); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[11]))((ID3D11ModuleInstance*)Unsafe.AsPointer(ref this), uSrcSrvSlot, uDstUavSlot, uCount); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(12)] + public HResult BindResourceAsUnorderedAccessViewByName(byte** pSrvName, uint uDstUavSlot, uint uCount) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[12]))((ID3D11ModuleInstance*)Unsafe.AsPointer(ref this), pSrvName, uDstUavSlot, uCount); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[12]))((ID3D11ModuleInstance*)Unsafe.AsPointer(ref this), pSrvName, uDstUavSlot, uCount); +#endif + } + + public interface Interface : IUnknown.Interface + { + } +} + +/// +/// ID3D11Module +[Guid("cac701ee-80fc-4122-8242-10b39c8cec34")] +[NativeTypeName("struct ID3D11Module : IUnknown")] +[NativeInheritance("IUnknown")] +public unsafe partial struct ID3D11Module : ID3D11Module.Interface +{ + public static ref readonly Guid IID_ID3D11Module + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0xEE, 0x01, 0xC7, 0xCA, + 0xFC, 0x80, + 0x22, 0x41, + 0x82, + 0x42, + 0x10, + 0xB3, + 0x9C, + 0x8C, + 0xEC, + 0x34 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_ID3D11Module)); + + public void** lpVtbl; + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(0)] + public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(1)] + [return: NativeTypeName("ULONG")] + public uint AddRef() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(2)] + [return: NativeTypeName("ULONG")] + public uint Release() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(3)] + public HResult CreateInstance(byte** pNamespace, ID3D11ModuleInstance** ppModuleInstance) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[3]))((ID3D11Module*)Unsafe.AsPointer(ref this), pNamespace, ppModuleInstance); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((ID3D11Module*)Unsafe.AsPointer(ref this), pNamespace, ppModuleInstance); +#endif + } + + public interface Interface : IUnknown.Interface + { + } +} + +/// +/// ID3D11Linker +[Guid("59a6cd0e-e10d-4c1f-88c0-63aba1daf30e")] +[NativeTypeName("struct ID3D11Linker : IUnknown")] +[NativeInheritance("IUnknown")] +public unsafe partial struct ID3D11Linker : ID3D11Linker.Interface +{ + public static ref readonly Guid IID_ID3D11Linker + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x0E, 0xCD, 0xA6, 0x59, + 0x0D, 0xE1, + 0x1F, 0x4C, + 0x88, + 0xC0, + 0x63, + 0xAB, + 0xA1, + 0xDA, + 0xF3, + 0x0E + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_ID3D11Linker)); + + public void** lpVtbl; + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(0)] + public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(1)] + [return: NativeTypeName("ULONG")] + public uint AddRef() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(2)] + [return: NativeTypeName("ULONG")] + public uint Release() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(3)] + public HResult Link(ID3D11ModuleInstance* pEntry, byte** pEntryName, byte** pTargetName, uint uFlags, Graphics.Direct3D.ID3DBlob** ppShaderBlob, Graphics.Direct3D.ID3DBlob* ppErrorBuffer) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[3]))((ID3D11Linker*)Unsafe.AsPointer(ref this), pEntry, pEntryName, pTargetName, uFlags, ppShaderBlob, ppErrorBuffer); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((ID3D11Linker*)Unsafe.AsPointer(ref this), pEntry, pEntryName, pTargetName, uFlags, ppShaderBlob, ppErrorBuffer); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public HResult UseLibrary(ID3D11ModuleInstance* pLibraryMI) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[4]))((ID3D11Linker*)Unsafe.AsPointer(ref this), pLibraryMI); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((ID3D11Linker*)Unsafe.AsPointer(ref this), pLibraryMI); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(5)] + public HResult AddClipPlaneFromCBuffer(uint uCBufferSlot, uint uCBufferEntry) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[5]))((ID3D11Linker*)Unsafe.AsPointer(ref this), uCBufferSlot, uCBufferEntry); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((ID3D11Linker*)Unsafe.AsPointer(ref this), uCBufferSlot, uCBufferEntry); +#endif + } + + public interface Interface : IUnknown.Interface + { + } +} + +/// +/// ID3D11LinkingNode +[Guid("d80dd70c-8d2f-4751-94a1-03c79b3556db")] +[NativeTypeName("struct ID3D11LinkingNode : IUnknown")] +[NativeInheritance("IUnknown")] +public unsafe partial struct ID3D11LinkingNode : ID3D11LinkingNode.Interface +{ + public static ref readonly Guid IID_ID3D11LinkingNode + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x0C, 0xD7, 0x0D, 0xD8, + 0x2F, 0x8D, + 0x51, 0x47, + 0x94, + 0xA1, + 0x03, + 0xC7, + 0x9B, + 0x35, + 0x56, + 0xDB + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_ID3D11LinkingNode)); + + public void** lpVtbl; + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(0)] + public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(1)] + [return: NativeTypeName("ULONG")] + public uint AddRef() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(2)] + [return: NativeTypeName("ULONG")] + public uint Release() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + public interface Interface : IUnknown.Interface + { + } +} + +/// +/// ID3D11FunctionLinkingGraph +[Guid("54133220-1ce8-43d3-8236-9855c5ceecff")] +[NativeTypeName("struct ID3D11FunctionLinkingGraph : IUnknown")] +[NativeInheritance("IUnknown")] +public unsafe partial struct ID3D11FunctionLinkingGraph : ID3D11FunctionLinkingGraph.Interface +{ + public static ref readonly Guid IID_ID3D11FunctionLinkingGraph + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x20, 0x32, 0x13, 0x54, + 0xE8, 0x1C, + 0xD3, 0x43, + 0x82, + 0x36, + 0x98, + 0x55, + 0xC5, + 0xCE, + 0xEC, + 0xFF + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_ID3D11FunctionLinkingGraph)); + + public void** lpVtbl; + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(0)] + public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(1)] + [return: NativeTypeName("ULONG")] + public uint AddRef() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(2)] + [return: NativeTypeName("ULONG")] + public uint Release() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(3)] + public HResult CreateModuleInstance(ID3D11ModuleInstance** ppModuleInstance, Graphics.Direct3D.ID3DBlob* ppErrorBuffer) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[3]))((ID3D11FunctionLinkingGraph*)Unsafe.AsPointer(ref this), ppModuleInstance, ppErrorBuffer); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((ID3D11FunctionLinkingGraph*)Unsafe.AsPointer(ref this), ppModuleInstance, ppErrorBuffer); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public HResult SetInputSignature(ParameterDescription* pInputParameters, uint cInputParameters, ID3D11LinkingNode** ppInputNode) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[4]))((ID3D11FunctionLinkingGraph*)Unsafe.AsPointer(ref this), pInputParameters, cInputParameters, ppInputNode); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((ID3D11FunctionLinkingGraph*)Unsafe.AsPointer(ref this), pInputParameters, cInputParameters, ppInputNode); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(5)] + public HResult SetOutputSignature(ParameterDescription* pOutputParameters, uint cOutputParameters, ID3D11LinkingNode** ppOutputNode) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[5]))((ID3D11FunctionLinkingGraph*)Unsafe.AsPointer(ref this), pOutputParameters, cOutputParameters, ppOutputNode); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((ID3D11FunctionLinkingGraph*)Unsafe.AsPointer(ref this), pOutputParameters, cOutputParameters, ppOutputNode); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(6)] + public HResult CallFunction(byte** pModuleInstanceNamespace, ID3D11Module* pModuleWithFunctionPrototype, byte** pFunctionName, ID3D11LinkingNode** ppCallNode) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[6]))((ID3D11FunctionLinkingGraph*)Unsafe.AsPointer(ref this), pModuleInstanceNamespace, pModuleWithFunctionPrototype, pFunctionName, ppCallNode); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((ID3D11FunctionLinkingGraph*)Unsafe.AsPointer(ref this), pModuleInstanceNamespace, pModuleWithFunctionPrototype, pFunctionName, ppCallNode); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(7)] + public HResult PassValue(ID3D11LinkingNode* pSrcNode, int SrcParameterIndex, ID3D11LinkingNode* pDstNode, int DstParameterIndex) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[7]))((ID3D11FunctionLinkingGraph*)Unsafe.AsPointer(ref this), pSrcNode, SrcParameterIndex, pDstNode, DstParameterIndex); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((ID3D11FunctionLinkingGraph*)Unsafe.AsPointer(ref this), pSrcNode, SrcParameterIndex, pDstNode, DstParameterIndex); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(8)] + public HResult PassValueWithSwizzle(ID3D11LinkingNode* pSrcNode, int SrcParameterIndex, byte** pSrcSwizzle, ID3D11LinkingNode* pDstNode, int DstParameterIndex, byte** pDstSwizzle) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[8]))((ID3D11FunctionLinkingGraph*)Unsafe.AsPointer(ref this), pSrcNode, SrcParameterIndex, pSrcSwizzle, pDstNode, DstParameterIndex, pDstSwizzle); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[8]))((ID3D11FunctionLinkingGraph*)Unsafe.AsPointer(ref this), pSrcNode, SrcParameterIndex, pSrcSwizzle, pDstNode, DstParameterIndex, pDstSwizzle); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(9)] + public HResult GetLastError(Graphics.Direct3D.ID3DBlob* ppErrorBuffer) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[9]))((ID3D11FunctionLinkingGraph*)Unsafe.AsPointer(ref this), ppErrorBuffer); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[9]))((ID3D11FunctionLinkingGraph*)Unsafe.AsPointer(ref this), ppErrorBuffer); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(10)] + public HResult GenerateHlsl(uint uFlags, Graphics.Direct3D.ID3DBlob** ppBuffer) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[10]))((ID3D11FunctionLinkingGraph*)Unsafe.AsPointer(ref this), uFlags, ppBuffer); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[10]))((ID3D11FunctionLinkingGraph*)Unsafe.AsPointer(ref this), uFlags, ppBuffer); +#endif + } + + public interface Interface : IUnknown.Interface + { + } +} + +/// +/// ID3D11ShaderTrace +[Guid("36b013e6-2811-4845-baa7-d623fe0df104")] +[NativeTypeName("struct ID3D11ShaderTrace : IUnknown")] +[NativeInheritance("IUnknown")] +public unsafe partial struct ID3D11ShaderTrace : ID3D11ShaderTrace.Interface +{ + public static ref readonly Guid IID_ID3D11ShaderTrace + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0xE6, 0x13, 0xB0, 0x36, + 0x11, 0x28, + 0x45, 0x48, + 0xBA, + 0xA7, + 0xD6, + 0x23, + 0xFE, + 0x0D, + 0xF1, + 0x04 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_ID3D11ShaderTrace)); + + public void** lpVtbl; + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(0)] + public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(1)] + [return: NativeTypeName("ULONG")] + public uint AddRef() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(2)] + [return: NativeTypeName("ULONG")] + public uint Release() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(3)] + public HResult TraceReady(ulong* pTestCount) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[3]))((ID3D11ShaderTrace*)Unsafe.AsPointer(ref this), pTestCount); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((ID3D11ShaderTrace*)Unsafe.AsPointer(ref this), pTestCount); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public void ResetTrace() + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[4]))((ID3D11ShaderTrace*)Unsafe.AsPointer(ref this)); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((ID3D11ShaderTrace*)Unsafe.AsPointer(ref this)); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(5)] + public HResult GetTraceStats(TraceStats* pTraceStats) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[5]))((ID3D11ShaderTrace*)Unsafe.AsPointer(ref this), pTraceStats); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((ID3D11ShaderTrace*)Unsafe.AsPointer(ref this), pTraceStats); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(6)] + public HResult PSSelectStamp(uint stampIndex) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[6]))((ID3D11ShaderTrace*)Unsafe.AsPointer(ref this), stampIndex); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((ID3D11ShaderTrace*)Unsafe.AsPointer(ref this), stampIndex); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(7)] + public HResult GetInitialRegisterContents(TraceRegister* pRegister, TraceValue* pValue) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[7]))((ID3D11ShaderTrace*)Unsafe.AsPointer(ref this), pRegister, pValue); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((ID3D11ShaderTrace*)Unsafe.AsPointer(ref this), pRegister, pValue); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(8)] + public HResult GetStep(uint stepIndex, TraceStep* pTraceStep) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[8]))((ID3D11ShaderTrace*)Unsafe.AsPointer(ref this), stepIndex, pTraceStep); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[8]))((ID3D11ShaderTrace*)Unsafe.AsPointer(ref this), stepIndex, pTraceStep); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(9)] + public HResult GetWrittenRegister(uint stepIndex, uint writtenRegisterIndex, TraceRegister* pRegister, TraceValue* pValue) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[9]))((ID3D11ShaderTrace*)Unsafe.AsPointer(ref this), stepIndex, writtenRegisterIndex, pRegister, pValue); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[9]))((ID3D11ShaderTrace*)Unsafe.AsPointer(ref this), stepIndex, writtenRegisterIndex, pRegister, pValue); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(10)] + public HResult GetReadRegister(uint stepIndex, uint readRegisterIndex, TraceRegister* pRegister, TraceValue* pValue) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[10]))((ID3D11ShaderTrace*)Unsafe.AsPointer(ref this), stepIndex, readRegisterIndex, pRegister, pValue); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[10]))((ID3D11ShaderTrace*)Unsafe.AsPointer(ref this), stepIndex, readRegisterIndex, pRegister, pValue); +#endif + } + + public interface Interface : IUnknown.Interface + { + } +} + +/// +/// ID3D11ShaderTraceFactory +[Guid("1fbad429-66ab-41cc-9617-667ac10e4459")] +[NativeTypeName("struct ID3D11ShaderTraceFactory : IUnknown")] +[NativeInheritance("IUnknown")] +public unsafe partial struct ID3D11ShaderTraceFactory : ID3D11ShaderTraceFactory.Interface +{ + public static ref readonly Guid IID_ID3D11ShaderTraceFactory + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x29, 0xD4, 0xBA, 0x1F, + 0xAB, 0x66, + 0xCC, 0x41, + 0x96, + 0x17, + 0x66, + 0x7A, + 0xC1, + 0x0E, + 0x44, + 0x59 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_ID3D11ShaderTraceFactory)); + + public void** lpVtbl; + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(0)] + public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(1)] + [return: NativeTypeName("ULONG")] + public uint AddRef() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(2)] + [return: NativeTypeName("ULONG")] + public uint Release() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(3)] + public HResult CreateShaderTrace(IUnknown* pShader, ShaderTraceDescription* pTraceDesc, ID3D11ShaderTrace** ppShaderTrace) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[3]))((ID3D11ShaderTraceFactory*)Unsafe.AsPointer(ref this), pShader, pTraceDesc, ppShaderTrace); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((ID3D11ShaderTraceFactory*)Unsafe.AsPointer(ref this), pShader, pTraceDesc, ppShaderTrace); +#endif + } + + public interface Interface : IUnknown.Interface + { + } +} + +/// +/// ID3DX11Scan +[Guid("5089b68f-e71d-4d38-be8e-f363b95a9405")] +[NativeTypeName("struct ID3DX11Scan : IUnknown")] +[NativeInheritance("IUnknown")] +public unsafe partial struct ID3DX11Scan : ID3DX11Scan.Interface +{ + public static ref readonly Guid IID_ID3DX11Scan + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x8F, 0xB6, 0x89, 0x50, + 0x1D, 0xE7, + 0x38, 0x4D, + 0xBE, + 0x8E, + 0xF3, + 0x63, + 0xB9, + 0x5A, + 0x94, + 0x05 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_ID3DX11Scan)); + + public void** lpVtbl; + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(0)] + public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(1)] + [return: NativeTypeName("ULONG")] + public uint AddRef() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(2)] + [return: NativeTypeName("ULONG")] + public uint Release() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(3)] + public HResult SetScanDirection(D3dx11ScanDirection Direction) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[3]))((ID3DX11Scan*)Unsafe.AsPointer(ref this), Direction); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((ID3DX11Scan*)Unsafe.AsPointer(ref this), Direction); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public HResult Scan(D3dx11ScanDataType ElementType, D3dx11ScanOpcode OpCode, uint ElementScanSize, ID3D11UnorderedAccessView* pSrc, ID3D11UnorderedAccessView* pDst) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[4]))((ID3DX11Scan*)Unsafe.AsPointer(ref this), ElementType, OpCode, ElementScanSize, pSrc, pDst); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((ID3DX11Scan*)Unsafe.AsPointer(ref this), ElementType, OpCode, ElementScanSize, pSrc, pDst); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(5)] + public HResult Multiscan(D3dx11ScanDataType ElementType, D3dx11ScanOpcode OpCode, uint ElementScanSize, uint ElementScanPitch, uint ScanCount, ID3D11UnorderedAccessView* pSrc, ID3D11UnorderedAccessView* pDst) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[5]))((ID3DX11Scan*)Unsafe.AsPointer(ref this), ElementType, OpCode, ElementScanSize, ElementScanPitch, ScanCount, pSrc, pDst); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((ID3DX11Scan*)Unsafe.AsPointer(ref this), ElementType, OpCode, ElementScanSize, ElementScanPitch, ScanCount, pSrc, pDst); +#endif + } + + public interface Interface : IUnknown.Interface + { + } +} + +/// +/// ID3DX11SegmentedScan +[Guid("a915128c-d954-4c79-bfe1-64db923194d6")] +[NativeTypeName("struct ID3DX11SegmentedScan : IUnknown")] +[NativeInheritance("IUnknown")] +public unsafe partial struct ID3DX11SegmentedScan : ID3DX11SegmentedScan.Interface +{ + public static ref readonly Guid IID_ID3DX11SegmentedScan + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x8C, 0x12, 0x15, 0xA9, + 0x54, 0xD9, + 0x79, 0x4C, + 0xBF, + 0xE1, + 0x64, + 0xDB, + 0x92, + 0x31, + 0x94, + 0xD6 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_ID3DX11SegmentedScan)); + + public void** lpVtbl; + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(0)] + public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(1)] + [return: NativeTypeName("ULONG")] + public uint AddRef() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(2)] + [return: NativeTypeName("ULONG")] + public uint Release() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(3)] + public HResult SetScanDirection(D3dx11ScanDirection Direction) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[3]))((ID3DX11SegmentedScan*)Unsafe.AsPointer(ref this), Direction); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((ID3DX11SegmentedScan*)Unsafe.AsPointer(ref this), Direction); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public HResult SegScan(D3dx11ScanDataType ElementType, D3dx11ScanOpcode OpCode, uint ElementScanSize, ID3D11UnorderedAccessView* pSrc, ID3D11UnorderedAccessView* pSrcElementFlags, ID3D11UnorderedAccessView* pDst) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[4]))((ID3DX11SegmentedScan*)Unsafe.AsPointer(ref this), ElementType, OpCode, ElementScanSize, pSrc, pSrcElementFlags, pDst); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((ID3DX11SegmentedScan*)Unsafe.AsPointer(ref this), ElementType, OpCode, ElementScanSize, pSrc, pSrcElementFlags, pDst); +#endif + } + + public interface Interface : IUnknown.Interface + { + } +} + +/// +/// ID3DX11FFT +[Guid("b3f7a938-4c93-4310-a675-b30d6de50553")] +[NativeTypeName("struct ID3DX11FFT : IUnknown")] +[NativeInheritance("IUnknown")] +public unsafe partial struct ID3DX11FFT : ID3DX11FFT.Interface +{ + public static ref readonly Guid IID_ID3DX11FFT + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x38, 0xA9, 0xF7, 0xB3, + 0x93, 0x4C, + 0x10, 0x43, + 0xA6, + 0x75, + 0xB3, + 0x0D, + 0x6D, + 0xE5, + 0x05, + 0x53 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_ID3DX11FFT)); + + public void** lpVtbl; + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(0)] + public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(1)] + [return: NativeTypeName("ULONG")] + public uint AddRef() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(2)] + [return: NativeTypeName("ULONG")] + public uint Release() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(3)] + public HResult SetForwardScale(float ForwardScale) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[3]))((ID3DX11FFT*)Unsafe.AsPointer(ref this), ForwardScale); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((ID3DX11FFT*)Unsafe.AsPointer(ref this), ForwardScale); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public float GetForwardScale() + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[4]))((ID3DX11FFT*)Unsafe.AsPointer(ref this)); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((ID3DX11FFT*)Unsafe.AsPointer(ref this)); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(5)] + public HResult SetInverseScale(float InverseScale) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[5]))((ID3DX11FFT*)Unsafe.AsPointer(ref this), InverseScale); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((ID3DX11FFT*)Unsafe.AsPointer(ref this), InverseScale); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(6)] + public float GetInverseScale() + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[6]))((ID3DX11FFT*)Unsafe.AsPointer(ref this)); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((ID3DX11FFT*)Unsafe.AsPointer(ref this)); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(7)] + public HResult AttachBuffersAndPrecompute(uint NumTempBuffers, ID3D11UnorderedAccessView* ppTempBuffers, uint NumPrecomputeBuffers, ID3D11UnorderedAccessView* ppPrecomputeBufferSizes) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[7]))((ID3DX11FFT*)Unsafe.AsPointer(ref this), NumTempBuffers, ppTempBuffers, NumPrecomputeBuffers, ppPrecomputeBufferSizes); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((ID3DX11FFT*)Unsafe.AsPointer(ref this), NumTempBuffers, ppTempBuffers, NumPrecomputeBuffers, ppPrecomputeBufferSizes); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(8)] + public HResult ForwardTransform(ID3D11UnorderedAccessView* pInputBuffer, ID3D11UnorderedAccessView* ppOutputBuffer) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[8]))((ID3DX11FFT*)Unsafe.AsPointer(ref this), pInputBuffer, ppOutputBuffer); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[8]))((ID3DX11FFT*)Unsafe.AsPointer(ref this), pInputBuffer, ppOutputBuffer); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(9)] + public HResult InverseTransform(ID3D11UnorderedAccessView* pInputBuffer, ID3D11UnorderedAccessView* ppOutputBuffer) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[9]))((ID3DX11FFT*)Unsafe.AsPointer(ref this), pInputBuffer, ppOutputBuffer); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[9]))((ID3DX11FFT*)Unsafe.AsPointer(ref this), pInputBuffer, ppOutputBuffer); +#endif + } + + public interface Interface : IUnknown.Interface + { + } +} + +#endregion Com Types diff --git a/src/Vortice.Win32/Generated/Graphics/Dxgi.Common.cs b/src/Vortice.Win32/Generated/Graphics/Dxgi.Common.cs index d26e7c8..539fd6d 100644 --- a/src/Vortice.Win32/Generated/Graphics/Dxgi.Common.cs +++ b/src/Vortice.Win32/Generated/Graphics/Dxgi.Common.cs @@ -580,7 +580,6 @@ public partial struct Rational /// public uint Denominator; - } /// @@ -592,7 +591,6 @@ public partial struct SampleDescription /// public uint Quality; - } /// @@ -607,7 +605,6 @@ public partial struct Rgb /// public float Blue; - } /// @@ -1668,7 +1665,6 @@ public partial struct GammaControl return MemoryMarshal.CreateSpan(ref e0, 1025); } } - } /// @@ -1689,7 +1685,6 @@ public partial struct GammaControlCapabilities /// public unsafe fixed float ControlPointPositions[1025]; - } /// @@ -1713,7 +1708,6 @@ public partial struct ModeDescription /// public ModeScaling Scaling; - } /// @@ -1725,7 +1719,6 @@ public partial struct JpegDcHuffmanTable /// public unsafe fixed byte CodeValues[12]; - } /// @@ -1737,7 +1730,6 @@ public partial struct JpegAcHuffmanTable /// public unsafe fixed byte CodeValues[162]; - } /// @@ -1746,7 +1738,6 @@ public partial struct JpegQuantizationTable { /// public unsafe fixed byte Elements[64]; - } #endregion Structs diff --git a/src/Vortice.Win32/Generated/Graphics/Dxgi.cs b/src/Vortice.Win32/Generated/Graphics/Dxgi.cs index 9ec8477..f7efa91 100644 --- a/src/Vortice.Win32/Generated/Graphics/Dxgi.cs +++ b/src/Vortice.Win32/Generated/Graphics/Dxgi.cs @@ -307,8 +307,10 @@ public enum FramePresentationMode : int /// /// DXGI_OVERLAY_SUPPORT_FLAG +[Flags] public enum OverlaySupportFlag : int { + None = 0, /// /// DXGI_OVERLAY_SUPPORT_FLAG_DIRECT Direct = 1, @@ -319,8 +321,10 @@ public enum OverlaySupportFlag : int /// /// DXGI_SWAP_CHAIN_COLOR_SPACE_SUPPORT_FLAG +[Flags] public enum SwapChainColorSpaceSupportFlag : int { + None = 0, /// /// DXGI_SWAP_CHAIN_COLOR_SPACE_SUPPORT_FLAG_PRESENT Present = 1, @@ -331,8 +335,10 @@ public enum SwapChainColorSpaceSupportFlag : int /// /// DXGI_OVERLAY_COLOR_SPACE_SUPPORT_FLAG +[Flags] public enum OverlayColorSpaceSupportFlag : int { + None = 0, /// /// DXGI_OVERLAY_COLOR_SPACE_SUPPORT_FLAG_PRESENT Present = 1, @@ -352,8 +358,10 @@ public enum MemorySegmentGroup : int /// /// DXGI_OUTDUPL_FLAG +[Flags] public enum OutduplFlag : int { + None = 0, /// /// DXGI_OUTDUPL_COMPOSITED_UI_CAPTURE_ONLY CompositedUICaptureOnly = 1, @@ -1658,7 +1666,6 @@ public partial struct Rgba /// public float a; - } /// @@ -1679,7 +1686,6 @@ public partial struct FrameStatistics /// public LargeInterger SyncGPUTime; - } /// @@ -1691,7 +1697,6 @@ public partial struct MappedRect /// public unsafe byte* pBits; - } /// @@ -1724,7 +1729,6 @@ public partial struct AdapterDescription /// public Luid AdapterLuid; - } /// @@ -1745,7 +1749,6 @@ public partial struct OutputDescription /// public IntPtr Monitor; - } /// @@ -1754,7 +1757,6 @@ public partial struct SharedResource { /// public IntPtr Handle; - } /// @@ -1772,7 +1774,6 @@ public partial struct SurfaceDescription /// public Common.SampleDescription SampleDesc; - } /// @@ -1802,7 +1803,6 @@ public partial struct SwapChainDescription /// public SwapChainFlags Flags; - } /// @@ -1838,7 +1838,6 @@ public partial struct AdapterDescription1 /// public AdapterFlags Flags; - } /// @@ -1850,7 +1849,6 @@ public partial struct DisplayColorSpace /// public unsafe fixed float WhitePoints[32]; - } /// @@ -1862,7 +1860,6 @@ public partial struct OutduplMoveRect /// public RawRect DestinationRect; - } /// @@ -1877,7 +1874,6 @@ public partial struct OutduplDescription /// public Bool32 DesktopImageInSystemMemory; - } /// @@ -1889,7 +1885,6 @@ public partial struct OutduplPointerPosition /// public Bool32 Visible; - } /// @@ -1910,7 +1905,6 @@ public partial struct OutduplPointerShapeInfo /// public System.Drawing.Point HotSpot; - } /// @@ -1940,7 +1934,6 @@ public partial struct OutduplFrameInfo /// public uint PointerShapeBufferSize; - } /// @@ -1967,7 +1960,6 @@ public partial struct ModeDescription1 /// public Bool32 Stereo; - } /// @@ -2006,7 +1998,6 @@ public partial struct SwapChainDescription1 /// public SwapChainFlags Flags; - } /// @@ -2024,7 +2015,6 @@ public partial struct SwapChainFullscreenDescription /// public Bool32 Windowed; - } /// @@ -2042,7 +2032,6 @@ public partial struct PresentParameters /// public unsafe System.Drawing.Point* pScrollOffset; - } /// @@ -2084,7 +2073,6 @@ public partial struct AdapterDescription2 /// public ComputePreemptionGranularity ComputePreemptionGranularity; - } /// @@ -2108,7 +2096,6 @@ public partial struct Matrix3x2F /// public float _32; - } /// @@ -2117,7 +2104,6 @@ public partial struct DecodeSwapChainDescription { /// public uint Flags; - } /// @@ -2144,7 +2130,6 @@ public partial struct FrameStatisticsMedia /// public uint ApprovedPresentDuration; - } /// @@ -2162,7 +2147,6 @@ public partial struct QueryVideoMemoryInfo /// public ulong CurrentReservation; - } /// @@ -2192,7 +2176,6 @@ public partial struct HdrMetadataHdr10 /// public ushort MaxFrameAverageLightLevel; - } /// @@ -2201,7 +2184,6 @@ public partial struct HdrMetadataHdr10plus { /// public unsafe fixed byte Data[72]; - } /// @@ -2243,7 +2225,6 @@ public partial struct AdapterDescription3 /// public ComputePreemptionGranularity ComputePreemptionGranularity; - } /// @@ -2291,7 +2272,6 @@ public partial struct OutputDescription1 /// public float MaxFullFrameLuminance; - } /// @@ -2315,7 +2295,6 @@ public partial struct InfoQueueMessage /// public nuint DescriptionByteLength; - } /// @@ -2339,7 +2318,6 @@ public partial struct InfoQueueFilterDescription /// public unsafe int* pIDList; - } /// @@ -2351,7 +2329,6 @@ public partial struct InfoQueueFilter /// public InfoQueueFilterDescription DenyList; - } #endregion Structs