diff --git a/src/Generator/ApiData.cs b/src/Generator/ApiData.cs index ed9312d..ad25df8 100644 --- a/src/Generator/ApiData.cs +++ b/src/Generator/ApiData.cs @@ -18,6 +18,7 @@ public class ApiDataType public string Name { get; set; } public string TargetKind { get; set; } public string Api { get; set; } + public string[] Parents { get; set; } // Kind == Array public ApiDataArrayShape Shape { get; set; } diff --git a/src/Generator/Program.cs b/src/Generator/Program.cs index d299c8f..3b75753 100644 --- a/src/Generator/Program.cs +++ b/src/Generator/Program.cs @@ -15,7 +15,8 @@ public static class Program "Graphics.Dxgi.Common.json", "Graphics.Dxgi.json", "Graphics.Direct3D.json", - "Graphics.Direct3D11.json" + "Graphics.Direct3D11.json", + "Graphics.Direct3D12.json", }; private static readonly Dictionary s_csNameMappings = new() @@ -196,6 +197,7 @@ public static class Program "D3D", "D3D10", "D3D11", + "D3D12", }; private static readonly HashSet s_ignoredParts = new(StringComparer.OrdinalIgnoreCase) @@ -771,6 +773,10 @@ public static class Program { fieldValueName = "Buffer"; } + else if (structType.Name == "D3D12_NODE_MASK") + { + fieldValueName = "Mask"; + } string fieldTypeName = GetTypeName(field.Type); @@ -814,7 +820,9 @@ public static class Program using (writer.PushBlock($"public unsafe struct {fieldValueName}__FixedBuffer")) { - for (int i = 0; i < field.Type.Shape.Size; i++) + int arraySize = field.Type.Shape != null ? field.Type.Shape.Size : 1; + + for (int i = 0; i < arraySize; i++) { writer.WriteLine($"public {fieldTypeName} e{i};"); } @@ -835,7 +843,7 @@ public static class Program writer.WriteLine("[MethodImpl(MethodImplOptions.AggressiveInlining)]"); using (writer.PushBlock($"public Span<{fieldTypeName}> AsSpan()")) { - writer.WriteLine($"return MemoryMarshal.CreateSpan(ref e0, {field.Type.Shape.Size});"); + writer.WriteLine($"return MemoryMarshal.CreateSpan(ref e0, {arraySize});"); } } } @@ -877,6 +885,8 @@ public static class Program { ApiStructField parentMemberAccess = structType.Fields.First(item => item.Type.Name == nestedTypeToGenerate.Name); string fieldTypeName = GetTypeName(field.Type); + fieldTypeName = NormalizeTypeName(writer.Api, fieldTypeName); + string fieldName = GetPrettyFieldName(field.Name, structPrefix); writer.WriteLine("[UnscopedRef]"); @@ -895,7 +905,18 @@ public static class Program } else { - using (writer.PushBlock($"public ref {fieldTypeName} {fieldName}")) + if (fieldName == "pGeometryDescs") + { + + } + + string unsafePrefix = string.Empty; + if (fieldTypeName.EndsWith("*")) + { + unsafePrefix += "unsafe "; + } + + using (writer.PushBlock($"public {unsafePrefix}ref {fieldTypeName} {fieldName}")) { writer.WriteLine("[MethodImpl(MethodImplOptions.AggressiveInlining)]"); using (writer.PushBlock("get")) @@ -903,7 +924,15 @@ public static class Program writer.WriteLineUndindented("#if NET7_0_OR_GREATER"); writer.WriteLine($"return ref {parentMemberAccess.Name}.{fieldName};"); writer.WriteLineUndindented("#else"); - writer.WriteLine($"return ref MemoryMarshal.GetReference(MemoryMarshal.CreateSpan(ref {parentMemberAccess.Name}.{fieldName}, 1));"); + if (fieldTypeName.EndsWith("*")) + { + writer.WriteLine($"return ref MemoryMarshal.GetReference(MemoryMarshal.CreateSpan(ref this, 1)).{parentMemberAccess.Name}.{fieldName};"); + } + else + { + writer.WriteLine($"return ref MemoryMarshal.GetReference(MemoryMarshal.CreateSpan(ref {parentMemberAccess.Name}.{fieldName}, 1));"); + } + writer.WriteLineUndindented("#endif"); } } @@ -1277,15 +1306,21 @@ public static class Program { sb.Append(partRemap!); } - else if (part.StartsWith("DESC", StringComparison.OrdinalIgnoreCase)) + else if (part == "DESC") { sb.Append("Description"); - string numericPart = part.Replace("DESC", string.Empty); - if (string.IsNullOrEmpty(numericPart) == false && - int.TryParse(numericPart, out int numericValue)) - { - sb.Append(numericValue); - } + } + else if (part == "DESC1") + { + sb.Append("Description1"); + } + else if (part == "DESC2") + { + sb.Append("Description2"); + } + else if (part == "DESC3") + { + sb.Append("Description3"); } else { @@ -1487,7 +1522,14 @@ public static class Program { if (dataType.Kind == "ApiRef") { - string typeName = GetTypeName($"{dataType.Api}.{dataType.Name}"); + string apiName = dataType.Api; + if (dataType.Parents?.Length > 0) + { + apiName += "."; + apiName += string.Join(".", dataType.Parents); + } + + string typeName = GetTypeName($"{apiName}.{dataType.Name}"); return asPointer ? typeName + "*" : typeName; } else if (dataType.Kind == "Array") diff --git a/src/Vortice.Win32/ComPtr.cs b/src/Vortice.Win32/ComPtr.cs index e7ad658..fd8e522 100644 --- a/src/Vortice.Win32/ComPtr.cs +++ b/src/Vortice.Win32/ComPtr.cs @@ -241,6 +241,17 @@ public unsafe struct ComPtr : IDisposable return (T**)Unsafe.AsPointer(ref Unsafe.AsRef(in this)); } + /// + /// Gets the address of the current instance as a raw double pointer. + /// + /// The raw pointer to the input instance. + /// This method is only valid when the current instance is on the stack or pinned. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public unsafe void** GetVoidAddressOf() + { + return (void**)Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + } + /// Gets the address of the current instance as a raw double pointer. /// The raw pointer to the current instance. [MethodImpl(MethodImplOptions.AggressiveInlining)] diff --git a/src/Vortice.Win32/Generated/Direct3D11.xml b/src/Vortice.Win32/Generated/Direct3D11.xml index 63e051e..5c0cae2 100644 --- a/src/Vortice.Win32/Generated/Direct3D11.xml +++ b/src/Vortice.Win32/Generated/Direct3D11.xml @@ -11394,7 +11394,7 @@ Microsoft Docs: - + A pointer to one of the enumerated values in D3D_FEATURE_LEVEL, which represents the minimum feature level. @@ -13721,7 +13721,7 @@ Retrieves the initial contents of the specified input register. - + Microsoft Docs: diff --git a/src/Vortice.Win32/Generated/Direct3D12.xml b/src/Vortice.Win32/Generated/Direct3D12.xml new file mode 100644 index 0000000..261fbdf --- /dev/null +++ b/src/Vortice.Win32/Generated/Direct3D12.xml @@ -0,0 +1,12643 @@ + + + + + Provides runtime access to Device Removed Extended Data (DRED) data. + Microsoft Docs: + + + + + Gets the current value of the fence. + Microsoft Docs: + + + + + Describes the access to resource(s) that is requested by an application at the transition into a render pass. + Microsoft Docs: + + + + A D3D12_RENDER_PASS_BEGINNING_ACCESS_TYPE. The type of access being requested. + + + A D3D12_RENDER_PASS_BEGINNING_ACCESS_CLEAR_PARAMETERS. Appropriate when Type is D3D12_RENDER_PASS_BEGINNING_ACCESS_TYPE_CLEAR. The clear value to which resource(s) should be cleared. + + + + Specifies texture layout options. + Microsoft Docs: + + + + Indicates that the layout is unknown, and is likely adapter-dependent. + During creation, the driver chooses the most efficient layout based on other resource properties, especially resource size and flags. + Prefer this choice unless certain functionality is required from another texture layout. + + +Zero-copy texture upload optimizations exist for UMA architectures; see ID3D12Resource::WriteToSubresource. + + + Indicates that data for the texture is stored in row-major order (sometimes called "pitch-linear order"). + + +This texture layout locates consecutive texels of a row contiguously in memory, before the texels of the next row. + Similarly, consecutive texels of a particular depth or array slice are contiguous in memory before the texels of the next depth or array slice. + Padding may exist between rows and between depth or array slices to align collections of data. + A stride is the distance in memory between rows, depth, or array slices; and it includes any padding. + + +This texture layout enables sharing of the texture data between multiple adapters, when other layouts aren't available. + + +Many restrictions apply, because this layout is generally not efficient for extensive usage: + + +
    +
  • The locality of nearby texels is not rotationally invariant. +
    • +
  • Only the following texture properties are supported: + +
    • +
  • The texture must be created on a heap with D3D12_HEAP_FLAG_SHARED_CROSS_ADAPTER. +
    • +
+Buffers are created with D3D12_TEXTURE_LAYOUT_ROW_MAJOR, because row-major texture data can be located in them without creating a texture object. + This is commonly used for uploading or reading back texture data, especially for discrete/NUMA adapters. + However, D3D12_TEXTURE_LAYOUT_ROW_MAJOR can also be used when marshaling texture data between GPUs or adapters. + For examples of usage with ID3D12GraphicsCommandList::CopyTextureRegion, see some of the following topics: + + + + + + Indicates that the layout within 64KB tiles and tail mip packing is up to the driver. + No standard swizzle pattern. + + +This texture layout is arranged into contiguous 64KB regions, also known as tiles, containing near equilateral amount of consecutive number of texels along each dimension. + Tiles are arranged in row-major order. + While there is no padding between tiles, there are typically unused texels within the last tile in each dimension. + The layout of texels within the tile is undefined. + Each subresource immediately follows where the previous subresource end, and the subresource order follows the same sequence as subresource ordinals. + However, tail mip packing is adapter-specific. + For more details, see tiled resource tier and ID3D12Device::GetResourceTiling. + + +This texture layout enables partially resident or sparse texture scenarios when used together with virtual memory page mapping functionality. + This texture layout must be used together with ID3D12Device::CreateReservedResourceto enable the usage of ID3D12CommandQueue::UpdateTileMappings. + + +Some restrictions apply to textures with this layout: + + + + + + Indicates that a default texture uses the standardized swizzle pattern. + + +This texture layout is arranged the same way that D3D12_TEXTURE_LAYOUT_64KB_UNDEFINED_SWIZZLE is, except that the layout of texels within the tile is defined. + Tail mip packing is adapter-specific. + + +This texture layout enables optimizations when marshaling data between multiple adapters or between the CPU and GPU. + The amount of copying can be reduced when multiple components understand the texture memory layout. + This layout is generally more efficient for extensive usage than row-major layout, due to the rotationally invariant locality of neighboring texels. + This layout can typically only be used with adapters that support standard swizzle, but exceptions exist for cross-adapter shared heaps. + + +The restrictions for this layout are that the following aren't supported: + + + + + + + Represents Device Removed Extended Data (DRED) auto-breadcrumb data as a node in a linked list. + Microsoft Docs: + + + + A pointer to the ANSI debug name of the outstanding command list (if any). + + + A pointer to the wide debug name of the outstanding command list (if any). + + + A pointer to the ANSI debug name of the outstanding command queue (if any). + + + A pointer to the wide debug name of the outstanding command queue (if any). + + + A pointer to the [ID3D12GraphicsCommandList interface](nn-d3d12-id3d12graphicscommandlist.md) representing the outstanding command list at the time of execution. + + + A pointer to the [ID3D12CommandQueue interface](nn-d3d12-id3d12commandqueue.md) representing the outstanding command queue. + + + A UINT32 containing the count of D3D12_AUTO_BREADCRUMB_OP values in the array pointed to by pCommandHistory. + + + A pointer to a constant UINT32 containing the index (within the array pointed to by pCommandHistory) of the last render/compute operation that was completed by the GPU while executing the associated command list. + + + A pointer to a constant array of D3D12_AUTO_BREADCRUMB_OP values representing all of the render/compute operations recorded into the associated command list. + + + A pointer to a constant D3D12_AUTO_BREADCRUMB_NODE representing the next auto-breadcrumb node in the list, or nullptr if this is the last node. + + + + Sets the stream output buffer views. + Microsoft Docs: + Index into the device's zero-based array to begin setting stream output buffers. + The number of entries in the pViews array. + Specifies an array of D3D12_STREAM_OUTPUT_BUFFER_VIEW structures. + + + + + Sets a group of constants in the graphics root signature. + Microsoft Docs: + The slot number for binding. + The number of constants to set in the root signature. + The source data for the group of constants to set. + The offset, in 32-bit values, to set the first constant of the group in the root signature. + + + + + Checks whether a resource, or subresource, is in a specified state, or not. + Microsoft Docs: + Specifies the ID3D12Resource to check. + The index of the subresource to check. This can be set to an index, or D3D12_RESOURCE_BARRIER_ALL_SUBRESOURCES. + Specifies the state to check for. This can be one or more D3D12_RESOURCE_STATES flags Or'ed together. + + + + + Creates a command list. + Microsoft Docs: + For single-GPU operation, set this to zero. If there are multiple GPU nodes, then set a bit to identify the node (the device's physical adapter) for which to create the command list. Each bit in the mask corresponds to a single node. Only one bit must be set. Also see [Multi-adapter systems](/windows/win32/direct3d12/multi-engine). + Specifies the type of command list to create. + A pointer to the command allocator object from which the device creates command lists. + An optional pointer to the pipeline state object that contains the initial pipeline state for the command list. If it is nulltpr, then the runtime sets a dummy initial pipeline state, so that drivers don't have to deal with undefined state. The overhead for this is low, particularly for a command list, for which the overall cost of recording the command list likely dwarfs the cost of a single initial state setting. So there's little cost in not setting the initial pipeline state parameter, if doing so is inconvenient. + +For bundles, on the other hand, it might make more sense to try to set the initial state parameter (since bundles are likely smaller overall, and can be reused frequently). + A reference to the globally unique identifier (GUID) of the command list interface to return in ppCommandList. + A pointer to a memory block that receives a pointer to the ID3D12CommandList or ID3D12GraphicsCommandList interface for the command list. + + + + + Describes the size of a tiled region. + Microsoft Docs: + + + + The number of tiles in the tiled region. + + + Specifies whether the runtime uses the Width, Height, and Depth members to define the region. + + +If TRUE, the runtime uses the Width, Height, and Depth members to define the region. In this case, NumTiles should be equal to Width * Height * Depth. + +If FALSE, the runtime ignores the Width, Height, and Depth members and uses the NumTiles member to traverse tiles in the resource linearly across x, then y, then z (as applicable) and then spills over mipmaps/arrays in subresource order. For example, use this technique to map an entire resource at once. + + +Regardless of whether you specify TRUE or FALSE for UseBox, you use a D3D12_TILED_RESOURCE_COORDINATE structure to specify the starting location for the region within the resource as a separate parameter outside of this structure by using x, y, and z coordinates. + + +When the region includes mipmaps that are packed with nonstandard tiling, UseBox must be FALSE because tile dimensions are not standard and the app only knows a count of how many tiles are consumed by the packed area, which is per array slice. The corresponding (separate) starting location parameter uses x to offset into the flat range of tiles in this case, and y and z coordinates must each be 0. + + + The width of the tiled region, in tiles. Used for buffer and 1D, 2D, and 3D textures. + + + The height of the tiled region, in tiles. Used for 2D and 3D textures. + + + The depth of the tiled region, in tiles. Used for 3D textures or arrays. For arrays, used for advancing in depth jumps to next slice of same mipmap size, which isn't contiguous in the subresource counting space if there are multiple mipmaps. + + + + Specifies the features that a video processor can support. + Microsoft Docs: + + + + No features are supported. + + + The video processor can set alpha values on the output pixels. The alpha fill mode is used in D3D12_VIDEO_PROCESS_OUTPUT_STREAM_DESC. D3D12_VIDEO_PROCESS_ALPHA_FILL_MODE_OPAQUE must be always supported. The background, destination, and source stream modes are only supported when the driver reports D3D12_VIDEO_PROCESS_FEATURE_FLAG_ALPHA_FILL. + + + The video processor can perform luma keying. Luma keying is configured via the D3D12_VIDEO_PROCESS_LUMA_KEY member of the D3D12_VIDEO_PROCESS_INPUT_STREAM_ARGUMENTS structure. For more information see D3D12_VIDEO_PROCESS_LUMA_KEY. + + + The video processor can support 3D stereo video. For more information, see D3D12_VIDEO_FRAME_STEREO_FORMAT. + +All drivers setting this capability must support the following stereo formats: D3D12_VIDEO_PROCESS_STEREO_FORMAT_HORIZONTAL, D3D12_VIDEO_PROCESS_STEREO_FORMAT_VERTICAL, and D3D12_VIDEO_PROCESS_STEREO_FORMAT_SEPARATE. + + + The driver can rotate the input data either 90, 180, or 270 degrees clockwise as part of the video processing operation. + + + The driver can flip the input data horizontally or vertically, together or separately with a video rotation operation. + + + Alpha blending and a planar alpha may be set in the AlphaBlending member of the D3D12_VIDEO_PROCESS_INPUT_STREAM_ARGUMENTS structure. For more information see D3D12_VIDEO_PROCESS_ALPHA_BLENDING. + + + The driver supports changing the pixel aspect ratio. If the driver does not report this capability, then the SourceAspectRatio and DestinationAspectRatio members of D3D12_VIDEO_PROCESS_INPUT_STREAM_ARGUMENTS structure must indicate a 1:1 aspect ratio. + + + + Creates a pipeline state object from a pipeline state stream description. + Microsoft Docs: + The address of a D3D12_PIPELINE_STATE_STREAM_DESC structure that describes the pipeline state. + The globally unique identifier (GUID) for the pipeline state interface (ID3D12PipelineState). + +The REFIID, or GUID, of the interface to the pipeline state can be obtained by using the __uuidof() macro. For example, __uuidof(ID3D12PipelineState) will get the GUID of the interface to a pipeline state. + SAL: _COM_Outptr_ + +A pointer to a memory block that receives a pointer to the ID3D12PipelineState interface for the pipeline state object. + +The pipeline state object is an immutable state object. It contains no methods. + + + + + Pop a storage filter from the top of the storage-filter stack. + Microsoft Docs: + + + + + Set the maximum number of messages that can be added to the message queue. + Microsoft Docs: + Maximum number of messages that can be added to the message queue. -1 means no limit. + +When the number of messages in the message queue has reached the maximum limit, new messages coming in will push old messages out. + + + + + Describes an instance of a raytracing acceleration structure used in GPU memory during the acceleration structure build process. + Microsoft Docs: + + + + A 3x4 transform matrix in row-major layout representing the instance-to-world transformation. Implementations transform rays, as opposed to transforming all of the geometry or AABBs. + +> [!NOTE] +> The layout of Transform is a transpose of how affine matrices are typically stored in memory. Instead of four 3-vectors, Transform is laid out as three 4-vectors. + + + An arbitrary 24-bit value that can be accessed using the InstanceID intrinsic function in supported shader types. + + + An 8-bit mask assigned to the instance, which can be used to include/reject groups of instances on a per-ray basis. If the value is zero, then the instance will never be included, so typically this should be set to some non-zero value. For more information see, the InstanceInclusionMask parameter to the TraceRay function. + + + An arbitrary 24-bit value representing per-instance contribution to add into shader table indexing to select the hit group to use. + + + An 8-bit mask representing flags from D3D12_RAYTRACING_INSTANCE_FLAGS to apply to the instance. + + + Address of the bottom-level acceleration structure that is being instanced. The address must be aligned to 256 bytes, defined as D3D12_RAYTRACING_ACCELERATION_STRUCTURE_BYTE_ALIGNMENT. Any existing acceleration structure passed in here would already have been required to be placed with such alignment. + +The memory pointed to must be in state D3D12_RESOURCE_STATE_RAYTRACING_ACCELERATION_STRUCTURE. + + + + Specifies how the pipeline interprets geometry or hull shader input primitives. + Microsoft Docs: + + + + The shader has not been initialized with an input primitive type. + + + Interpret the input primitive as a point. + + + Interpret the input primitive as a line. + + + Interpret the input primitive as a triangle. + + + Interpret the input primitive as a control point patch. + + + + Defines the layout in memory of a stereo 3D video frame. + Microsoft Docs: + + + + No stereo format is specified. + + + The sample does not contain stereo data. If the stereo format is not specified, this value is the default. + + + Frame 0 and frame 1 are packed side-by-side, as shown in the following diagram. + +![Horizontal stereo format showing the frame 0 pixels on the left of a grid of pixels and the frame 1 pixels on the right](./images/stereo_format_horizontal.png) + + + Frame 0 and frame 1 are packed top-to-bottom, as shown in the following diagram. + +![Vertical stereo format showing the frame 0 pixels on the top of a grid of pixels and the frame 1 pixels on the bottom](./images/stereo_format_horizontal.png) + + + Frame 0 and frame 1 are placed in separate resources + + + + Provides data for calls to ID3D12VideoDevice::CheckFeatureSupport when the feature specified is D3D12_FEATURE_VIDEO_MOTION_ESTIMATOR_PROTECTED_RESOURCES. Retrieves the protected resources support for video motion estimation. + Microsoft Docs: + + + + In multi-adapter operation, identifies the physical adapter of the device this operation applies to. + + + A member of the D3D12_VIDEO_PROTECTED_RESOURCE_SUPPORT_FLAGS enumeration specifying support for protected resources. + + + + Defines constants that specify the data type of a parameter to a meta command. + Microsoft Docs: + + + + Specifies that the parameter is of type FLOAT. + + + Specifies that the parameter is of type UINT64. + + + Specifies that the parameter is a GPU virtual address. + + + Specifies that the parameter is a CPU descriptor handle to a heap containing either constant buffer views, shader resource views, or unordered access views. + + + Specifies that the parameter is a GPU descriptor handle to a heap containing either constant buffer views, shader resource views, or unordered access views. + + + + Describes a portion of a texture for the purpose of texture copies. + Microsoft Docs: + + + + Specifies the resource which will be used for the copy operation.
 
When Type is D3D12_TEXTURE_COPY_TYPE_PLACED_FOOTPRINT, pResource must point to a buffer resource.
 
When Type is D3D12_TEXTURE_COPY_TYPE_SUBRESOURCE_INDEX, pResource must point to a texture resource. + + + Specifies which type of resource location this is: a subresource of a texture, or a description of a texture layout which can be applied to a buffer. + This D3D12_TEXTURE_COPY_TYPE enum indicates which union member to use. + + + Specifies a texture layout, with offset, dimensions, and pitches, for the hardware to understand how to treat a section of a buffer resource as a multi-dimensional texture. + To fill-in the correct data for a CopyTextureRegion call, + see D3D12_PLACED_SUBRESOURCE_FOOTPRINT. + + + Specifies the index of the subresource of an arrayed, mip-mapped, or planar texture should be used for the copy operation. + + + + Atomically copies a primary data element of type UINT64 from one resource to another, along with optional dependent resources. + Microsoft Docs: + SAL: _In_ + +The resource that the UINT64 primary data element is copied into. + An offset into the destination resource buffer that specifies where the primary data element is copied into, in bytes. This offset combined with the base address of the resource buffer must result in a memory address that's naturally aligned for UINT64 values. + SAL: _In_ + +The resource that the UINT64 primary data element is copied from. This data is typically an address, index, or other handle that shader code can use to locate the most-recent version of latency-sensitive information. + An offset into the source resource buffer that specifies where the primary data element is copied from, in bytes. This offset combined with the base address of the resource buffer must result in a memory address that's naturally aligned for UINT64 values. + The number of dependent resources. + SAL: _In_reads_(Dependencies) + +An array of resources that contain the dependent elements of the data payload. + SAL: _In_reads_(Dependencies) + +An array of subresource ranges that specify the dependent elements of the data payload. These elements are completely updated before the primary data element is itself atomically copied. This ensures that the entire operation is logically atomic; that is, the primary data element never refers to an incomplete data payload. + + + + + Starts a query running. + Microsoft Docs: + Specifies the ID3D12QueryHeap containing the query. + Specifies one member of D3D12_QUERY_TYPE. + Specifies the index of the query within the query heap. + + + + + Not intended to be called directly.  Use the PIX event runtime to insert events into a command queue. + Microsoft Docs: + Internal. + Internal. + Internal. + + + + + Used to determine which kinds of command lists are capable of supporting various operations. + Microsoft Docs: + + + + Specifies that no command list supports the operation in question. + + + Specifies that direct command lists can support the operation in question. + + + Specifies that command list bundles can support the operation in question. + + + Specifies that compute command lists can support the operation in question. + + + Specifies that copy command lists can support the operation in question. + + + Specifies that video-decode command lists can support the operation in question. + + + Specifies that video-processing command lists can support the operation is question. + + + + Defines constants that specify the state of a resource regarding how the resource is being used. + Microsoft Docs: + + + + Your application should transition to this state only for accessing a resource across different graphics engine types. + +Specifically, a resource must be in the COMMON state before being used on a COPY queue (when previous used on DIRECT/COMPUTE), and before being used on DIRECT/COMPUTE (when previously used on COPY). This restriction does not exist when accessing data between DIRECT and COMPUTE queues. + +The COMMON state can be used for all usages on a Copy queue using the implicit state transitions. For more info, in Multi-engine synchronization, find "common". + +Additionally, textures must be in the COMMON state for CPU access to be legal, assuming the texture was created in a CPU-visible heap in the first place. + + + A subresource must be in this state when it is accessed by the GPU as a vertex buffer or constant buffer. This is a read-only state. + + + A subresource must be in this state when it is accessed by the 3D pipeline as an index buffer. This is a read-only state. + + + The resource is used as a render target. A subresource must be in this state when it is rendered to or when it is cleared with ID3D12GraphicsCommandList::ClearRenderTargetView. + +This is a write-only state. To read from a render target as a shader resource the resource must be in either D3D12_RESOURCE_STATE_NON_PIXEL_SHADER_RESOURCE or D3D12_RESOURCE_STATE_PIXEL_SHADER_RESOURCE. + + + The resource is used for unordered access. A subresource must be in this state when it is accessed by the GPU via an unordered access view. A subresource must also be in this state when it is cleared with ID3D12GraphicsCommandList::ClearUnorderedAccessViewInt or ID3D12GraphicsCommandList::ClearUnorderedAccessViewFloat. This is a read/write state. + + + D3D12_RESOURCE_STATE_DEPTH_WRITE is a state that is mutually exclusive with other states. You should use it for ID3D12GraphicsCommandList::ClearDepthStencilView when the flags (see D3D12_CLEAR_FLAGS) indicate a given subresource should be cleared (otherwise the subresource state doesn't matter), or when using it in a writable depth stencil view (see D3D12_DSV_FLAGS) when the PSO has depth write enabled (see D3D12_DEPTH_STENCIL_DESC). + + + DEPTH_READ is a state which can be combined with other states. It should be used when the subresource is in a read-only depth stencil view, or when the DepthEnable parameter of D3D12_DEPTH_STENCIL_DESC is false. It can be combined with other read states (for example, D3D12_RESOURCE_STATE_PIXEL_SHADER_RESOURCE), such that the resource can be used for the depth or stencil test, and accessed by a shader within the same draw call. Using it when depth will be written by a draw call or clear command is invalid. + + + The resource is used with a shader other than the pixel shader. A subresource must be in this state before being read by any stage (except for the pixel shader stage) via a shader resource view. You can still use the resource in a pixel shader with this flag as long as it also has the flag D3D12_RESOURCE_STATE_PIXEL_SHADER_RESOURCE set. This is a read-only state. + + + The resource is used with a pixel shader. A subresource must be in this state before being read by the pixel shader via a shader resource view. This is a read-only state. + + + The resource is used with stream output. A subresource must be in this state when it is accessed by the 3D pipeline as a stream-out target. This is a write-only state. + + + The resource is used as an indirect argument. + Subresources must be in this state when they are used as the argument buffer passed to the indirect drawing method ID3D12GraphicsCommandList::ExecuteIndirect. + This is a read-only state. + + + The resource is used as the destination in a copy operation. + Subresources must be in this state when they are used as the destination of copy operation, or a blt operation. + This is a write-only state. + + + The resource is used as the source in a copy operation. + Subresources must be in this state when they are used as the source of copy operation, or a blt operation. + This is a read-only state. + + + The resource is used as the destination in a resolve operation. + + + The resource is used as the source in a resolve operation. + + + When a buffer is created with this as its initial state, it indicates that the resource is a raytracing acceleration structure, for use in ID3D12GraphicsCommandList4::BuildRaytracingAccelerationStructure, ID3D12GraphicsCommandList4::CopyRaytracingAccelerationStructure, or ID3D12Device::CreateShaderResourceView for the D3D12_SRV_DIMENSION_RAYTRACING_ACCELERATION_STRUCTURE dimension. + + + Starting with Windows 10, version 1903 (10.0; Build 18362), indicates that the resource is a screen-space shading-rate image for variable-rate shading (VRS). For more info, see Variable-rate shading (VRS). + + + D3D12_RESOURCE_STATE_GENERIC_READ is a logically OR'd combination of other read-state bits. This is the required starting state for an upload heap. Your application should generally avoid transitioning to D3D12_RESOURCE_STATE_GENERIC_READ when possible, since that can result in premature cache flushes, or resource layout changes (for example, compress/decompress), causing unnecessary pipeline stalls. You should instead transition resources only to the actually-used states. + + + Synonymous with D3D12_RESOURCE_STATE_COMMON. + + + The resource is used for Predication. + + + The resource is used as a source in a decode operation. Examples include reading the compressed bitstream and reading from decode references, + + + The resource is used as a destination in the decode operation. This state is used for decode output and histograms. + + + The resource is used to read video data during video processing; that is, the resource is used as the source in a processing operation such as video encoding (compression). + + + The resource is used to write video data during video processing; that is, the resource is used as the destination in a processing operation such as video encoding (compression). + + + The resource is used as the source in an encode operation. This state is used for the input and reference of motion estimation. + + + This resource is used as the destination in an encode operation. This state is used for the destination texture of a resolve motion vector heap operation. + + + + Get the size of the storage-filter stack in bytes. + Microsoft Docs: + + + + + Specifies how to copy a tile. + Microsoft Docs: + + + + No tile-copy flags are specified. + + + Indicates that the GPU isn't currently referencing any of the + portions of destination memory being written. + + + Indicates that the ID3D12GraphicsCommandList::CopyTiles operation involves copying a linear buffer to a swizzled tiled resource. This means to copy tile data from the + specified buffer location, reading tiles sequentially, + to the specified tile region (in x,y,z order if the region is a box), swizzling to optimal hardware memory layout as needed. + In this ID3D12GraphicsCommandList::CopyTiles call, you specify the source data with the pBuffer parameter and the destination with the pTiledResource parameter. + + + Indicates that the ID3D12GraphicsCommandList::CopyTiles operation involves copying a swizzled tiled resource to a linear buffer. This means to copy tile data from the tile region, reading tiles sequentially (in x,y,z order if the region is a box), + to the specified buffer location, deswizzling to linear memory layout as needed. + In this ID3D12GraphicsCommandList::CopyTiles call, you specify the source data with the pTiledResource parameter and the destination with the pBuffer parameter. + + + + Sets all the elements in a unordered access view to the specified float values. + Microsoft Docs: + A D3D12_GPU_DESCRIPTOR_HANDLE that references an initialized descriptor for the unordered-access view (UAV) that is to be cleared. This descriptor must be in a shader-visible descriptor heap, which must be set on the command list via SetDescriptorHeaps. + A D3D12_CPU_DESCRIPTOR_HANDLE in a non-shader visible descriptor heap that references an initialized descriptor for the unordered-access view (UAV) that is to be cleared. + +> [!IMPORTANT] +> This descriptor must not be in a shader-visible descriptor heap. This is to allow drivers thath implement the clear as fixed-function hardware (rather than via a dispatch) to efficiently read from the descriptor, as shader-visible heaps may be created in WRITE_BACK memory (similar to D3D12_HEAP_TYPE_UPLOAD heap types), and CPU reads from this type of memory are prohibitively slow. + A pointer to the ID3D12Resource interface that represents the unordered-access-view (UAV) resource to clear. + A 4-component array that containing the values to fill the unordered-access-view resource with. + The number of rectangles in the array that the pRects parameter specifies. + An array of D3D12_RECT structures for the rectangles in the resource view to clear. If NULL, ClearUnorderedAccessViewFloat clears the entire resource view. + + + + + Specifies the shaders that can access the contents of a given root signature slot. + Microsoft Docs: + + + + Specifies that all shader stages can access whatever is bound at the root signature slot. + + + Specifies that the vertex shader stage can access whatever is bound at the root signature slot. + + + Specifies that the hull shader stage can access whatever is bound at the root signature slot. + + + Specifies that the domain shader stage can access whatever is bound at the root signature slot. + + + Specifies that the geometry shader stage can access whatever is bound at the root signature slot. + + + Specifies that the pixel shader stage can access whatever is bound at the root signature slot. + + + Specifies that the amplification shader stage can access whatever is bound at the root signature slot. + + + Specifies that the mesh shader stage can access whatever is bound at the root signature slot. + + + + Adds support for video extension commands. + Microsoft Docs: + + + + + This method enables or disables GPU-Based Validation (GBV) before creating a device with the debug layer enabled. + Microsoft Docs: + TRUE to enable GPU-Based Validation, otherwise FALSE. + + + + + Associates a name with the device object. This name is for use in debug diagnostics and tools. + Microsoft Docs: + A NULL-terminated UNICODE string that contains the name to associate with the device object. + + + + + Get the size of the retrieval-filter stack in bytes. + Microsoft Docs: + + + + + Creates both a resource and an implicit heap, such that the heap is big enough to contain the entire resource, and the resource is mapped to the heap. + Microsoft Docs: + A pointer to a D3D12_HEAP_PROPERTIES structure that provides properties for the resource's heap. + Heap options, as a bitwise-OR'd combination of D3D12_HEAP_FLAGS enumeration constants. + A pointer to a D3D12_RESOURCE_DESC structure that describes the resource. + The initial state of the resource, as a bitwise-OR'd combination of D3D12_RESOURCE_STATES enumeration constants. + +When you create a resource together with a D3D12_HEAP_TYPE_UPLOAD heap, you must set InitialResourceState to D3D12_RESOURCE_STATE_GENERIC_READ. + +When you create a resource together with a D3D12_HEAP_TYPE_READBACK heap, you must set InitialResourceState to D3D12_RESOURCE_STATE_COPY_DEST. + Specifies a D3D12_CLEAR_VALUE structure that describes the default value for a clear color. + +pOptimizedClearValue specifies a value for which clear operations are most optimal. When the created resource is a texture with either the D3D12_RESOURCE_FLAG_ALLOW_RENDER_TARGET or D3D12_RESOURCE_FLAG_ALLOW_DEPTH_STENCIL flags, you should choose the value with which the clear operation will most commonly be called. You can call the clear operation with other values, but those operations won't be as efficient as when the value matches the one passed in to resource creation. + +When you use D3D12_RESOURCE_DIMENSION_BUFFER, you must set pOptimizedClearValue to nullptr. + A reference to the globally unique identifier (GUID) of the resource interface to return in ppvResource. + +While riidResource is most commonly the GUID of ID3D12Resource, it may be the GUID of any interface. If the resource object doesn't support the interface for this GUID, then creation fails with E_NOINTERFACE. + An optional pointer to a memory block that receives the requested interface pointer to the created resource object. + +ppvResource can be nullptr, to enable capability testing. When ppvResource is nullptr, no object is created, and S_FALSE is returned when pDesc is valid. + + + + + Indicates the level of support that the adapter provides for variable-rate shading (VRS), and indicates whether or not background processing is supported. + Microsoft Docs: + + + + Indicates whether 2x4, 4x2, and 4x4 coarse pixel sizes are supported for single-sampled rendering; and whether coarse pixel size 2x4 is supported for 2x MSAA. true if those sizes are supported, otherwise false. + + + Indicates whether the per-provoking-vertex (also known as per-primitive) rate can be used with more than one viewport. If so, then, in that case, that rate can be used when SV_ViewportIndex is written to. true if that rate can be used with more than one viewport, otherwise false. + + + Indicates the shading rate tier. + + + Indicates the tile size of the screen-space image as a UINT. + + + Indicates whether or not background processing is supported. true if background processing is supported, otherwise false. For more info, see the [Direct3D 12 background processing spec](https://microsoft.github.io/DirectX-Specs/d3d/BackgroundProcessing.html). + + + + Describes a unordered-access 2D texture resource. + Microsoft Docs: + + + + The mipmap slice index. + + + The index (plane slice number) of the plane to use in the texture. + + + + Defines constants that specify a version of Device Removed Extended Data (DRED), as used by the D3D12_VERSIONED_DEVICE_REMOVED_EXTENDED_DATA structure. + Microsoft Docs: + + + + Specifies DRED version 1.0. + + + Specifies DRED version 1.1. + + + + Describes the input-buffer data for the input-assembler stage. + Microsoft Docs: + + + + An array of D3D12_INPUT_ELEMENT_DESC structures that describe the data types of the input-assembler stage. + + + The number of input-data types in the array of input elements that the pInputElementDescs member points to. + + + + Describes heap properties. + Microsoft Docs: + + + + A D3D12_HEAP_TYPE-typed value that specifies the type of heap. + + + A D3D12_CPU_PAGE_PROPERTY-typed value that specifies the CPU-page properties for the heap. + + + A D3D12_MEMORY_POOL-typed value that specifies the memory pool for the heap. + + + For multi-adapter operation, this indicates the node where the resource should be created. + +Exactly one bit of this UINT must be set. See Multi-adapter systems. + +Passing zero is equivalent to passing one, in order to simplify the usage of single-GPU adapters. + + + For multi-adapter operation, this indicates the set of nodes where the resource is visible. + +VisibleNodeMask must have the same bit set that is set in CreationNodeMask. VisibleNodeMask can also have additional bits set for cross-node resources, but doing so can potentially reduce performance for resource accesses, so you should do so only when needed. + +Passing zero is equivalent to passing one, in order to simplify the usage of single-GPU adapters. + + + + Specifies the fill mode to use when rendering triangles. + Microsoft Docs: + + + + Draw lines connecting the vertices. Adjacent vertices are not drawn. + + + Fill the triangles formed by the vertices. Adjacent vertices are not drawn. + + + + Describes a set of Axis-aligned bounding boxes that are used in the D3D12_BUILD_RAYTRACING_ACCELERATION_STRUCTURE_INPUTS structure to provide input data to a raytracing acceleration structure build operation. + Microsoft Docs: + + + + The number of AABBs pointed to in the contiguous array at AABBs. + + + the GPU memory location where an array of AABB descriptions is to be found, including the data stride between AABBs. The address and stride must each be aligned to 8 bytes, defined as The address must be aligned to 16 bytes, defined as D3D12_RAYTRACING_AABB_BYTE_ALIGNMENT. The stride can be 0. + + + + Gets a shader description. + Microsoft Docs: + A shader description, as a pointer to a D3D12_SHADER_DESC structure. + + + + + A shader-reflection interface accesses shader information. + Microsoft Docs: + + + + + Remove a retrieval filter from the top of the retrieval-filter stack. + Microsoft Docs: + + + + + Enables or disables dependent command queue synchronization when using a Direct3D 12 device with the debug layer enabled. + Microsoft Docs: + TRUE to enable Dependent Command Queue Synchronization, otherwise FALSE. + + + + + Identifies the type of resource to view as a render target. + Microsoft Docs: + + + + Do not use this value, as it will cause ID3D12Device::CreateRenderTargetView to fail. + + + The resource will be accessed as a buffer. + + + The resource will be accessed as a 1D texture. + + + The resource will be accessed as an array of 1D textures. + + + The resource will be accessed as a 2D texture. + + + The resource will be accessed as an array of 2D textures. + + + The resource will be accessed as a 2D texture with multisampling. + + + The resource will be accessed as an array of 2D textures with multisampling. + + + The resource will be accessed as a 3D texture. + + + + Specifies transform parameters for video processing. + Microsoft Docs: + + + + Specifies the source rectangle of the transform. This is the portion of the input surface that is blitted to the destination surface. The source rectangle is given in pixel coordinates, relative to the input surface. + + + Specifies the destination rectangle of the transform. This is the portion of the output surface that receives the blit for this stream. The destination rectangle is given in pixel coordinates, relative to the output surface. + + + The rotation and flip operation to apply to the source. Source and Destination rectangles are specified in post orientation coordinates. + + + + Creates a root signature layout. + Microsoft Docs: + For single GPU operation, set this to zero. If there are multiple GPU nodes, set bits to identify the nodes (the device's physical adapters) to which the root signature is to apply. + Each bit in the mask corresponds to a single node. + Refer to Multi-adapter systems. + A pointer to the source data for the serialized signature. + The size, in bytes, of the block of memory that pBlobWithRootSignature points to. + The globally unique identifier (GUID) for the root signature interface. See Remarks. + An input parameter. + A pointer to a memory block that receives a pointer to the root signature. + + + + + Set the current pipeline stack size. + Microsoft Docs: + Stack size in bytes to use during pipeline execution for each shader thread. There can be many thousands of threads in flight at once on the GPU. + +If the value is greater than 0xffffffff (the maximum value of a 32-bit UINT) the runtime will drop the call, and the debug layer will print an error, as this is likely the result of summing up invalid stack sizes returned from GetShaderStackSize called with invalid parameters, which return 0xffffffff. In this case, the previously set stack size, or the default, remains. + + + + + Retrieves the properties of the resource heap, for placed and committed resources. + Microsoft Docs: + Pointer to a D3D12_HEAP_PROPERTIES structure, that on successful completion of the method will contain the resource heap properties. + Specifies a D3D12_HEAP_FLAGS variable, that on successful completion of the method will contain any miscellaneous heap flags. + + + + + Describes info about the feature levels supported by the current graphics driver. + Microsoft Docs: + + + + The number of feature levels in the array at pFeatureLevelsRequested. + + + A pointer to an array of D3D_FEATURE_LEVELs that the application is requesting for the driver and hardware to evaluate. + + + The maximum feature level that the driver and hardware support. + + + + Describes the subresources from an array of 1D textures to use in a depth-stencil view. + Microsoft Docs: + + + + The index of the first mipmap level to use. + + + The index of the first texture to use in an array of textures. + + + Number of textures to use. + + + + Defines the combination of a pixel format and color space for a resource content description. + Microsoft Docs: + + + + A value from the DXGI_FORMAT enumeration, specifying the DXGI format of the data. + + + A value from the DXGI_COLOR_SPACE_TYPE enumeration, specifying the color space of the data. + + + + Creates a compute pipeline state object. + Microsoft Docs: + A pointer to a D3D12_COMPUTE_PIPELINE_STATE_DESC structure that describes compute pipeline state. + The globally unique identifier (GUID) for the pipeline state interface (ID3D12PipelineState). + The REFIID, or GUID, of the interface to the pipeline state can be obtained by using the __uuidof() macro. + For example, __uuidof(ID3D12PipelineState) will get the GUID of the interface to a pipeline state. + A pointer to a memory block that receives a pointer to the ID3D12PipelineState interface for the pipeline state object. + The pipeline state object is an immutable state object. It contains no methods. + + + + + Discards a resource. + Microsoft Docs: + A pointer to the ID3D12Resource interface for the resource to discard. + A pointer to a D3D12_DISCARD_REGION structure that describes details for the discard-resource operation. + + + + + Gets the base class of a class. + Microsoft Docs: + + + + + Describes the subresources from an array of 1D textures to use in a shader-resource view. + Microsoft Docs: + + + + Index of the most detailed mipmap level to use; this number is between 0 and MipLevels (from the original Texture1D for which ID3D12Device::CreateShaderResourceView creates a view) -1. + + + The maximum number of mipmap levels for the view of the texture. See the remarks in D3D12_TEX1D_SRV. + +Set to -1 to indicate all the mipmap levels from MostDetailedMip on down to least detailed. + + + The index of the first texture to use in an array of textures. + + + Number of textures in the array. + + + A value to clamp sample LOD values to. For example, if you specify 2.0f for the clamp value, you ensure that no individual sample accesses a mip level less than 2.0f. + + + + Set a message severity level to break on when a message with that severity level passes through the storage filter. + Microsoft Docs: + A message severity level to break on. + Turns this breaking condition on or off (true for on, false for off). + + + + + Represents a Direct3D 12 video decoder heap. + Microsoft Docs: + + + + + Represents the decode parameters for a frame. + Microsoft Docs: + + + + A member of the D3D12_VIDEO_DECODE_ARGUMENT_TYPE enumeration specifying the type of argument. + + + The size of the data in pArgument, in bytes. + + + A pointer to the argument data. + + + + Describes a ID3D12VideoDecoder. + Microsoft Docs: + + + + The node mask specifying the physical adapter on which the video processor will be used. For single GPU operation, set this to zero. If there are multiple GPU nodes, set a bit to identify the node, i.e. the device's physical adapter, to which the command queue applies. Each bit in the mask corresponds to a single node. Only 1 bit may be set. + + + A D3D12_VIDEO_DECODE_CONFIGURATION structure specifying the configuration of the video decoder. + + + + Retrieves a description of the protected resource session. + Microsoft Docs: + + + + + A heap is an abstraction of contiguous memory allocation, used to manage physical memory. This heap can be used with ID3D12Resource objects to support placed resources or reserved resources. + Microsoft Docs: + + + + + Represents a GPU virtual address and indexing stride. + Microsoft Docs: + + + + The beginning of the virtual address range. + + + Defines indexing stride, such as for vertices. Only the bottom 32 bits are used. The field is 64 bits to make alignment of containing structures consistent everywhere. + + + + Creates a cached pipeline library. + Microsoft Docs: + If the input library blob is empty, then the initial content of the library is empty. If the input library blob is not empty, then it is validated for integrity, parsed, and the pointer is stored. The pointer provided as input to this method must remain valid for the lifetime of the object returned. For efficiency reasons, the data is not copied. + Specifies the length of pLibraryBlob in bytes. + Specifies a unique REFIID for the ID3D12PipelineLibrary object. Typically set this and the following parameter with the macro IID_PPV_ARGS(&library), where Library is the name of the object. + Returns a pointer to the created library. + + + + + Indicates the level of support for heap serialization. + Microsoft Docs: + + + + An input field, indicating the adapter index to query. + + + An output field, indicating the tier of heap serialization support. + + + + Specifies the type of query heap to create. + Microsoft Docs: + + + + This returns a binary 0/1 result: 0 indicates that no samples passed depth and stencil testing, 1 indicates that at least one sample passed depth and stencil testing. This enables occlusion queries to not interfere with any GPU performance optimization associated with depth/stencil testing. + + + Indicates that the heap is for high-performance timing data. + + + Indicates the heap is to contain pipeline data. Refer to D3D12_QUERY_DATA_PIPELINE_STATISTICS. + + + Indicates the heap is to contain stream output data. Refer to D3D12_QUERY_DATA_SO_STATISTICS. + + + Indicates the heap is to contain video decode statistics data. Refer to D3D12_QUERY_DATA_VIDEO_DECODE_STATISTICS. + +Video decode statistics can only be queried from video decode command lists (D3D12_COMMAND_LIST_TYPE_VIDEO_DECODE). See D3D12_QUERY_TYPE_DECODE_STATISTICS for more details. + + + Indicates the heap is to contain timestamp queries emitted exclusively by copy command lists. Copy queue timestamps can only be queried from a copy command list, and a copy command list can not emit to a regular timestamp query Heap. + +Support for this query heap type is not universal. You must use CheckFeatureSupport with D3D12_FEATURE_D3D12_OPTIONS3 to determine whether the adapter supports copy queue timestamp queries. + + + + Not intended to be called directly.  Use the PIX event runtime to insert events into a command list. + Microsoft Docs: + Internal. + Internal. + Internal. + + + + + Modifies the D3D12 optional device-wide Debug Layer settings. + Microsoft Docs: + Specifies a D3D12_DEBUG_DEVICE_PARAMETER_TYPE value that indicates which debug parameter data to get. + Debug parameter data to set. + Size in bytes of the data pointed to by pData. + + + + + Details the adapter's support for prioritization of different command queue types. + Microsoft Docs: + + + + SAL: _In_ + +The type of the command list you're interested in. + + + SAL: _In_ + +The priority level you're interested in. + + + SAL: _Out_ + +On return, contains true if the specfied command list type supports the specified priority level; otherwise, false. + + + + Specifies debug message IDs for setting up an info-queue filter (see D3D12_INFO_QUEUE_FILTER); use these messages to allow or deny message categories to pass through the storage and retrieval filters. + Microsoft Docs: + + + + + Retrieves the requested PSO from the library. The pipeline stream description is matched against the library database and remembered in order to prevent duplication of PSO contents. + Microsoft Docs: + SAL: _In_ + +The unique name of the PSO. + SAL: _In_ + +Describes the required PSO using a D3D12_PIPELINE_STATE_STREAM_DESC structure. This description is matched against the library database and stored in order to prevent duplication of PSO contents. + Specifies a REFIID for the ID3D12PipelineStateState object. + +Applications should typically set this argument and the following argument, ppPipelineState, by using the macro IID_PPV_ARGS(&PSO1), where PSO1 is the name of the object. + SAL: _COM_Outptr_ + +Specifies the pointer that will reference the PSO after the function successfully returns. + + + + + Retrieves the list of supported formats. + Microsoft Docs: + + + + For single GPU operation, set this to zero. If there are multiple GPU nodes, set a bit to identify the node (the device's physical adapter) to which the command queue applies. Each bit in the mask corresponds to a single node. Only 1 bit may be set. + + + A D3D12\_VIDEO\_DECODE\_CONFIGURATION structure describing the decode configuration for the list of formats. + + + The number of formats to retrieve. This number must match the value returned from a call [ID3D12VideoDevice::CheckFeatureSupport](nf-d3d12video-id3d12videodevice-checkfeaturesupport.md) when the feature specified is D3D12\_FEATURE\_VIDEO\_DECODE\_FORMAT\_COUNT. + + + A list of DXGI_FORMAT structures representing the supported formats. + + + + Specifies the decoding tier of a hardware video decoder, which determines the required format of application-defined textures and buffers. + Microsoft Docs: + + + + Video decoding is not supported. + + + In tier 1, the hardware decoder requires that the application allocate reference textures as a texture array. This is to accomodate hardware requirements that the textures be "close" in address space because the hardware doesn't support a full size pointer for each individual picture buffer. Instead it has one pointer and a more limited bit offset. For more information on texture arrays, see [Introduction To Textures in Direct3D 11](/windows/win32/direct3d11/overviews-direct3d-11-resources-textures-intro). + +If the decoder hardware requires a unique memory layout that is not supported for operations on other engines or different video operations, the decoder may set the D3D12_VIDEO_DECODE_CONFIGURATION_FLAG_REFERENCE_ONLY_ALLOCATIONS_REQUIRED configuration flag in the D3D12_FEATURE_DATA_VIDEO_DECODE_SUPPORT structure when queried for profile support. This flag indicates that the application must allocate references with the D3D12_RESOURCE_FLAG_VIDEO_DECODE_REFERENCE_ONLY flag. The application should use the D3D12_VIDEO_DECODE_CONVERSION_ARGUMENTS structure to set a reference-only output if the output is needed as a future reference frame. The output frame passed to ID3D12VideoCommandList::DecodeFrame is a D3D12 resource that can be consumed by other portions of the pipeline and must not have the D3D12_RESOURCE_FLAG_VIDEO_DECODE_REFERENCE_ONLY flag. + + + In decode tier 2, textures can be referenced as a texture array or as an array of separate texture 2D resources (each resource having array size of 1). This is more flexible for the caller and is important in scenarios where the resolution changes frequently such as in streaming video, because a texture array can only be allocated and deallocated as an single unit, but separate texture 2D resources can be allocated and deallocated individually. + +If decode hardware requires a unique tiling format that is not supported for operations on other engines or different video operations, the decoder may set the D3D12_VIDEO_DECODE_CONFIGURATION_FLAG_REFERENCE_ONLY_ALLOCATIONS_REQUIRED configuration flag in the D3D12_FEATURE_DATA_VIDEO_DECODE_SUPPORT structure when queried for profile support. This flag indicates that the application must allocate references with the D3D12_RESOURCE_FLAG_VIDEO_DECODE_REFERENCE_ONLY flag. The application should use the D3D12_VIDEO_DECODE_CONVERSION_ARGUMENTS structure to set a reference only output if the output is needed as a future reference frame. The output frame passed to ID3D12VideoCommandList::DecodeFrame is a D3D12 resource that can be consumed by other portions of the pipeline and must not have the D3D12_RESOURCE_FLAG_VIDEO_DECODE_REFERENCE_ONLY flag. + + + This field is reserved. + + + + Describes a shader. + Microsoft Docs: + + + + The Shader version, as an encoded UINT that corresponds to a shader model, such as "ps_5_0". + Version describes the program type, a major version number, and a minor version number. + The program type is a D3D12_SHADER_VERSION_TYPE enumeration constant. + Version is decoded in the following way: + + +
    +
  • Program type = (Version & 0xFFFF0000) >> 16
    • +
  • Major version = (Version & 0x000000F0) >> 4
    • +
  • Minor version = (Version & 0x0000000F)
    • +
 + + + The name of the originator of the shader. + + + Shader compilation/parse flags. + + + The number of shader-constant buffers. + + + The number of resource (textures and buffers) bound to a shader. + + + The number of parameters in the input signature. + + + The number of parameters in the output signature. + + + The number of intermediate-language instructions in the compiled shader. + + + The number of temporary registers in the compiled shader. + + + Number of temporary arrays used. + + + Number of constant defines. + + + Number of declarations (input + output). + + + Number of non-categorized texture instructions. + + + Number of texture load instructions + + + Number of texture comparison instructions + + + Number of texture bias instructions + + + Number of texture gradient instructions. + + + Number of floating point arithmetic instructions used. + + + Number of signed integer arithmetic instructions used. + + + Number of unsigned integer arithmetic instructions used. + + + Number of static flow control instructions used. + + + Number of dynamic flow control instructions used. + + + Number of macro instructions used. + + + Number of array instructions used. + + + Number of cut instructions used. + + + Number of emit instructions used. + + + The D3D_PRIMITIVE_TOPOLOGY-typed value that represents the geometry shader output topology. + + + Geometry shader maximum output vertex count. + + + The D3D_PRIMITIVE-typed value that represents the input primitive for a geometry shader or hull shader. + + + Number of parameters in the patch-constant signature. + + + Number of geometry shader instances. + + + Number of control points in the hull shader and domain shader. + + + The D3D_TESSELLATOR_OUTPUT_PRIMITIVE-typed value that represents the tessellator output-primitive type. + + + The D3D_TESSELLATOR_PARTITIONING-typed value that represents the tessellator partitioning mode. + + + The D3D_TESSELLATOR_DOMAIN-typed value that represents the tessellator domain. + + + Number of barrier instructions in a compute shader. + + + Number of interlocked instructions in a compute shader. + + + Number of texture writes in a compute shader. + + + + Describes a CPU descriptor handle. + Microsoft Docs: + + + + The address of the descriptor. + + + + Gets the type of the command list, such as direct, bundle, compute, or copy. + Microsoft Docs: + + + + + Specifies whether a video decode conversion operation is supported. + Microsoft Docs: + + + + The video decode conversion operation isn't supported. + + + The video decode conversion operation is supported. + + + + Identifies the type of data contained in an input slot. + Microsoft Docs: + + + + Input data is per-vertex data. + + + Input data is per-instance data. + + + + Push an empty retrieval filter onto the retrieval-filter stack. + Microsoft Docs: + + + + + Specifies the type of root signature slot. + Microsoft Docs: + + + + The slot is for a descriptor table. + + + The slot is for root constants. + + + The slot is for a constant-buffer view (CBV). + + + The slot is for a shader-resource view (SRV). + + + The slot is for a unordered-access view (UAV). + + + + Add storage filters to the top of the storage-filter stack. + Microsoft Docs: + Array of storage filters. + + + + + Describes, as a node in a linked list, data about an allocation tracked by Device Removed Extended Data (DRED). + Microsoft Docs: + + + + A pointer to the ANSI debug name of the allocated runtime object. + + + A pointer to the wide debug name of the allocated runtime object. + + + A D3D12_DRED_ALLOCATION_TYPE value representing the runtime object's allocation type. + + + A pointer to a constant D3D12_DRED_ALLOCATION_NODE representing the next allocation node in the list, or nullptr if this is the last node. + + + + Provides methods for getting and setting the properties of an ID3D12StateObject. + Microsoft Docs: + + + + + Indicates the level of support that the adapter provides for timestamp queries, format-casting, immediate write, view instancing, and barycentrics. + Microsoft Docs: + + + + Indicates whether timestamp queries are supported on copy queues. + + + Indicates whether casting from one fully typed format to another, compatible, format is supported. + + + Indicates the kinds of command lists that support the ability to write an immediate value directly from the command stream into a specified buffer. + + + Indicates the level of support the adapter has for view instancing. + + + Indicates whether barycentrics are supported. + + + + Describes the subresource from a 2D texture to use in a shader-resource view. + Microsoft Docs: + + + + Index of the most detailed mipmap level to use; this number is between 0 and MipLevels (from the original Texture2D for which ID3D12Device::CreateShaderResourceView creates a view) -1. + + + The maximum number of mipmap levels for the view of the texture. See the remarks in D3D12_TEX1D_SRV. + + +Set to -1 to indicate all the mipmap levels from MostDetailedMip on down to least detailed. + + + The index (plane slice number) of the plane to use in the texture. + + + A value to clamp sample LOD values to. For example, if you specify 2.0f for the clamp value, you ensure that no individual sample accesses a mip level less than 2.0f. + + + + Describes the clear value to which resource(s) should be cleared at the beginning of a render pass. + Microsoft Docs: + + + + A D3D12_CLEAR_VALUE. The clear value to which the resource(s) should be cleared. + + + + Sets a CPU descriptor handle for the vertex buffers. + Microsoft Docs: + Index into the device's zero-based array to begin setting vertex buffers. + The number of views in the pViews array. + Specifies the vertex buffer views in an array of D3D12_VERTEX_BUFFER_VIEW structures. + + + + + Represents facilities for controlling the lifetime a lifetime-tracked object. + Microsoft Docs: + + + + + Gets a constant buffer by index for a function. + Microsoft Docs: + Zero-based index. + + + + + Defines flags that specify states related to a graphics command list. Values can be bitwise OR'd together. + Microsoft Docs: + + + + Specifies no state. + + + Specifies the state of the vertex buffer bindings on the input assembler stage. + + + Specifies the state of the index buffer binding on the input assembler stage. + + + Specifies the state of the primitive topology value set on the input assembler stage. + + + Specifies the state of the currently bound descriptor heaps. + + + Specifies the state of the currently set graphics root signature. + + + Specifies the state of the currently set compute root signature. + + + Specifies the state of the viewports bound to the rasterizer stage. + + + Specifies the state of the scissor rectangles bound to the rasterizer stage. + + + Specifies the predicate state. + + + Specifies the state of the render targets bound to the output merger stage. + + + Specifies the state of the reference value for depth stencil tests set on the output merger stage. + + + Specifies the state of the blend factor set on the output merger stage. + + + Specifies the state of the pipeline state object. + + + Specifies the state of the buffer views bound to the stream output stage. + + + Specifies the state of the depth bounds set on the output merger stage. + + + Specifies the state of the sample positions. + + + Specifies the state of the view instances mask. + + + + Indicates to re-use the memory that is associated with the command allocator. + Microsoft Docs: + + + + + Holds any version of a root signature description, and is designed to be used with serialization/deserialization functions. + Microsoft Docs: + + + + Specifies one member of D3D_ROOT_SIGNATURE_VERSION that determines the contents of the union. + + + Specifies a D3D12_ROOT_SIGNATURE_DESC (version 1.0). + + + Specifies a D3D12_ROOT_SIGNATURE_DESC1 (version 1.1). + + + + Identifies the tier level at which tiled resources are supported. + Microsoft Docs: + + + + Indicates that textures cannot be created with the D3D12_TEXTURE_LAYOUT_64KB_UNDEFINED_SWIZZLE layout. + + + +ID3D12Device::CreateReservedResource cannot be used, not even for buffers. + + + Indicates that 2D textures can be created with the D3D12_TEXTURE_LAYOUT_64KB_UNDEFINED_SWIZZLE layout. + Limitations exist for certain resource formats and properties. + For more details, see D3D12_TEXTURE_LAYOUT_64KB_UNDEFINED_SWIZZLE. + + + +ID3D12Device::CreateReservedResource can be used. + + +GPU reads or writes to NULL mappings are undefined. + Applications are encouraged to workaround this limitation by repeatedly mapping the same page to everywhere a NULL mapping would've been used. + + +When the size of a texture mipmap level is an integer multiple of the standard tile shape for its format, it is guaranteed to be nonpacked. + + + Indicates that a superset of Tier_1 functionality is supported, including this additional support: + + +
    +
  • When the size of a texture mipmap level is at least one standard tile shape for its format, the mipmap level is guaranteed to be nonpacked. + For more info, see D3D12_PACKED_MIP_INFO. +
    • +
  • Shader instructions are available for clamping level-of-detail (LOD) and for obtaining status about the shader operation. + For info about one of these shader instructions, see Sample(S,float,int,float,uint). + Sample(S,float,int,float,uint). +
    • +
  • Reading from NULL-mapped tiles treat that sampled value as zero. + Writes to NULL-mapped tiles are discarded. +
    • +
+Adapters that support feature level 12_0 all support TIER_2 or greater. + + + Indicates that a superset of Tier 2 is supported, with the addition that 3D textures (Volume Tiled Resources) are supported. + + + + Creates a descriptor heap object. + Microsoft Docs: + A pointer to a D3D12_DESCRIPTOR_HEAP_DESC structure that describes the heap. + The globally unique identifier (GUID) for the descriptor heap interface. See Remarks. + An input parameter. + A pointer to a memory block that receives a pointer to the descriptor heap. + ppvHeap can be NULL, to enable capability testing. + When ppvHeap is NULL, no object will be created and S_FALSE will be returned when pDescriptorHeapDesc is valid. + + + + + Sets all the elements in a render target to one value. + Microsoft Docs: + Specifies a D3D12_CPU_DESCRIPTOR_HANDLE structure that describes the CPU descriptor handle that represents the start of the heap for the render target to be cleared. + A 4-component array that represents the color to fill the render target with. + The number of rectangles in the array that the pRects parameter specifies. + An array of D3D12_RECT structures for the rectangles in the resource view to clear. If NULL, ClearRenderTargetView clears the entire resource view. + + + + + Adds configurable levels of GPU-based validation to the debug layer. + Microsoft Docs: + + + + + A reference counted object representing the video extension command. + Microsoft Docs: + + + + + Gets the function parameter reflector. + Microsoft Docs: + The zero-based index of the function parameter reflector to retrieve. + + + + + Describes parameters needed to allocate resources. + Microsoft Docs: + + + + The size, in bytes, of the resource. + + + The alignment value for the resource; one of 4KB (4096), 64KB (65536), or 4MB (4194304) alignment. + + + + Get a message category to break on when a message with that category passes through the storage filter. + Microsoft Docs: + Message category to break on. + + + + + Describes a vertex element in a vertex buffer in an output slot. + Microsoft Docs: + + + + Zero-based, stream number. + + + Type of output element; possible values include: "POSITION", "NORMAL", or "TEXCOORD0". + Note that if SemanticName is NULL then + ComponentCount can be greater than 4 and the described entry will be a gap in the stream out where no data will be written. + + + Output element's zero-based index. Use, for example, if you have more than one texture coordinate stored in each vertex. + + + The component of the entry to begin writing out to. Valid values are 0 to 3. For example, if you only wish to output to the y and z components + of a position, StartComponent is 1 and ComponentCount is 2. + + + The number of components of the entry to write out to. Valid values are 1 to 4. For example, if you only wish to output to the y and z components + of a position, StartComponent is 1 and ComponentCount is 2. Note that if SemanticName is NULL then + ComponentCount can be greater than 4 and the described entry will be a gap in the stream out where no data will be written. + + + The associated stream output buffer that is bound to the pipeline. + The valid range for OutputSlot is 0 to 3. + + + + Indicates the level of support for protected resource sessions. + Microsoft Docs: + + + + An input field, indicating the adapter index to query. + + + An output field indicating the type of protected resource session support. + + + + Indicates whether a class type implements an interface. + Microsoft Docs: + A pointer to a ID3D12ShaderReflectionType Interface. + + + + + Specifies the type of acceleration structure post-build info that can be retrieved with calls to EmitRaytracingAccelerationStructurePostbuildInfo and BuildRaytracingAccelerationStructure. + Microsoft Docs: + + + + The post-build info is space requirements for an acceleration structure after compaction. For more information, see D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_COMPACTED_SIZE_DESC. + + + The post-build info is space requirements for generating tools visualization for an acceleration structure. For more information, see D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_TOOLS_VISUALIZATION_DESC. + + + The post-build info is space requirements for serializing an acceleration structure. For more information, see D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_SERIALIZATION_DESC. + + + The post-build info is size of the current acceleration structure. For more information, see D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_CURRENT_SIZE_DESC. + + + + Converts root signature description structures to a requested version. + Microsoft Docs: + Specifies the required D3D_ROOT_SIGNATURE_VERSION. + Contains the deserialized root signature in a D3D12_VERSIONED_ROOT_SIGNATURE_DESC structure. + + + + + Sets the view for the index buffer. + Microsoft Docs: + The view specifies the index buffer's address, size, and DXGI_FORMAT, as a pointer to a D3D12_INDEX_BUFFER_VIEW structure. + + + + + Specifies the mode used by a WriteBufferImmediate operation. + Microsoft Docs: + + + + The write operation behaves the same as normal copy-write operations. + + + The write operation is guaranteed to occur after all preceding commands in the command stream have started, including previous WriteBufferImmediate operations. + + + The write operation is deferred until all previous commands in the command stream have completed through the GPU pipeline, including previous WriteBufferImmediate operations. Write operations that specify D3D12_WRITEBUFFERIMMEDIATE_MODE_MARKER_OUT don't block subsequent operations from starting. If there are no previous operations in the command stream, then the write operation behaves as if D3D12_WRITEBUFFERIMMEDIATE_MODE_MARKER_IN was specified. + + + + Describes the subresources from an array of 2D textures to use in a shader-resource view. + Microsoft Docs: + + + + Index of the most detailed mipmap level to use; this number is between 0 and MipLevels -1 (where MipLevels is from the original Texture2D for which ID3D12Device::CreateShaderResourceView creates a view). + + + The maximum number of mipmap levels for the view of the texture. See the remarks in D3D12_TEX1D_SRV. + + +Set to -1 to indicate all the mipmap levels from MostDetailedMip on down to least detailed. + + + The index of the first texture to use in an array of textures. + + + Number of textures in the array. + + + The index (plane slice number) of the plane to use in an array of textures. + + + A value to clamp sample LOD values to. For example, if you specify 2.0f for the clamp value, you ensure that no individual sample accesses a mip level less than 2.0f. + + + + Monitors the validity of a protected resource session. + Microsoft Docs: + + + + + Gets the number of Mov instructions. + Microsoft Docs: + + + + + Describes the coordinates of a resource. + Microsoft Docs: + + + + The x-coordinate of the resource. + + + The y-coordinate of the resource. + + + The z-coordinate of the resource. + + + The index of the subresource for the resource. + + + + Specifies the level of sharing across nodes of an adapter, such as Tier 1 Emulated, Tier 1, or Tier 2. + Microsoft Docs: + + + + If an adapter has only 1 node, then cross-node sharing doesn't apply, so the CrossNodeSharingTier member of the D3D12_FEATURE_DATA_D3D12_OPTIONS structure is set to D3D12_CROSS_NODE_SHARING_NOT_SUPPORTED. + + + Tier 1 Emulated. Devices that set the CrossNodeSharingTier member of the D3D12_FEATURE_DATA_D3D12_OPTIONS structure to D3D12_CROSS_NODE_SHARING_TIER_1_EMULATED have Tier 1 support. +However, drivers stage these copy operations through a driver-internal system memory allocation. This will cause these copy operations to consume time on the destination GPU as well as the source. + + + Tier 1. Devices that set the CrossNodeSharingTier member of the D3D12_FEATURE_DATA_D3D12_OPTIONS structure to D3D12_CROSS_NODE_SHARING_TIER_1 only support the following cross-node copy operations: + + + +Additionally, the cross-node resource must be the destination of the copy operation. + + + Tier 2. Devices that set the CrossNodeSharingTier member of the D3D12_FEATURE_DATA_D3D12_OPTIONS structure to D3D12_CROSS_NODE_SHARING_TIER_2 support all operations across nodes, except for the following: + +
    +
  • Render target views.
    • +
  • Depth stencil views.
    • +
  • UAV atomic operations. Similar to CPU/GPU interop, shaders may perform UAV atomic operations; however, no atomicity across adapters is guaranteed.
    • +
+Applications can retrieve the node where a resource/heap exists from the D3D12_HEAP_DESC structure. These values are retrievable for opened resources. The runtime performs the appropriate re-mapping in case the 2 devices are using different UMD-specified node re-mappings. + + + Indicates support for [D3D12_HEAP_FLAG_ALLOW_SHADER_ATOMICS](./ne-d3d12-d3d12_heap_flags.md) on heaps that are visible to multiple nodes. + + + + Describes allocation data related to a GPU page fault on a given virtual address (VA). + Microsoft Docs: + + + + A D3D12_GPU_VIRTUAL_ADDRESS containing the GPU virtual address (VA) of the faulting operation if device removal was due to a GPU page fault. + + + A pointer to a constant D3D12_DRED_ALLOCATION_NODE object representing the head of a linked list of allocation nodes for active allocated runtime objects with virtual address (VA) ranges that match the faulting VA (PageFaultVA). Has a value of nullptr if the list is empty. + + + A pointer to a constant D3D12_DRED_ALLOCATION_NODE object representing the head of a linked list of allocation nodes for recently freed runtime objects with virtual address (VA) ranges that match the faulting VA (PageFaultVA). Has a value of nullptr if the list is empty. + + + + Describes the footprint of a placed subresource, including the offset and the D3D12_SUBRESOURCE_FOOTPRINT. + Microsoft Docs: + + + + The offset of the subresource within the parent resource, in bytes. + The offset between the start of the parent resource and this subresource. + + + The format, width, height, depth, and row-pitch of the subresource, + as a D3D12_SUBRESOURCE_FOOTPRINT structure. + + + + Specifies the volatility of the data referenced by descriptors in a Root Signature 1.1 description, which can enable some driver optimizations. + Microsoft Docs: + + + + Default assumptions are made for data (for SRV/CBV: DATA_STATIC_WHILE_SET_AT_EXECUTE, and for UAV: DATA_VOLATILE). + + + Data is volatile. Equivalent to Root Signature Version 1.0. + + + Data is static while set at execute. + + + Data is static. The best potential for driver optimization. + + + + Represents the allocations of storage for graphics processing unit (GPU) commands. + Microsoft Docs: + + + + + Gets the description of the command queue. + Microsoft Docs: + + + + + Indicates the level of support that the adapter provides for render passes, ray tracing, and shader-resource view tier 3 tiled resources. + Microsoft Docs: + + + + A boolean value indicating whether the options require shader-resource view tier 3 tiled resource support. For more information, see D3D12_TILED_RESOURCES_TIER. + + + The extent to which a device driver and/or the hardware efficiently supports render passes. See D3D12_RENDERPASS_TIER. + + + + Contains the list of reference frames for the current decode operation. + Microsoft Docs: + + + + The number of references specified in the ppTexture2Ds field. + + + A list of reference textures. When specifying texture arrays, each entry will be point to the same resource. When specifying an array of textures, each entry will point to a separate resource. + + + An array of subresource indices for the reference textures specified in ppTexture2Ds. NULL indicates that subresource 0 should be assumed for each resource. + +With texture arrays within a single resource, the subresource indices point to the array index of the first resource plane. With an array of textures in individual resources, the subresource index is typically zero. + +The video device driver uses the "PicEntry" indices defined in the DXVA spec for the codec to dereference this array to find the subresource index to use with the corresponding resource. For example, in HEVC, the Driver uses [DXVA_PicEntry_HEVC::Index7Bits](/windows/win32/medfound/dxva-picentry-hevc) as an index for this array. + + + An array of ID3D12VideoDecoderHeap objects. This field is used with formats that support non-key frame resolution changes, allowing the caller to pass in the previous resolution's heap, relative to the reference it's being used for, in addition to the current resolution heap. + + + + Adds support for protected resources. + Microsoft Docs: + + + + + Describes a resource, such as a texture. This structure is used extensively. + Microsoft Docs: + + + + One member of D3D12_RESOURCE_DIMENSION, specifying the dimensions of the resource (for example, D3D12_RESOURCE_DIMENSION_TEXTURE1D), or whether it is a buffer ((D3D12_RESOURCE_DIMENSION_BUFFER). + + + Specifies the alignment. + + + Specifies the width of the resource. + + + Specifies the height of the resource. + + + Specifies the depth of the resource, if it is 3D, or the array size if it is an array of 1D or 2D resources. + + + Specifies the number of MIP levels. + + + Specifies one member of DXGI_FORMAT. + + + Specifies a DXGI_SAMPLE_DESC structure. + + + Specifies one member of D3D12_TEXTURE_LAYOUT. + + + Bitwise-OR'd flags, as D3D12_RESOURCE_FLAGS enumeration constants. + + + + Fills the parameter descriptor structure for the function's parameter. + Microsoft Docs: + A pointer to a D3D12_PARAMETER_DESC structure that receives a description of the function's parameter. + + + + + Specifies how memory gets routed by a shader resource view (SRV). + Microsoft Docs: + + + + Indicates return component 0 (red). + + + Indicates return component 1 (green). + + + Indicates return component 2 (blue). + + + Indicates return component 3 (alpha). + + + Indicates forcing the resulting value to 0. + + + Indicates forcing the resulting value 1. The value of forcing 1 is either 0x1 or 1.0f depending on the format type for that component in the source format. + + + + Specifies alpha blending parameters for video processing. + Microsoft Docs: + + + + A boolean value specifying whether alpha blending is enabled. + + + The planar alpha value. The value can range from 0.0 (transparent) to 1.0 (opaque). If Enable is FALSe, this parameter is ignored. + + + + Describes a single element for the input-assembler stage of the graphics pipeline. + Microsoft Docs: + + + + The HLSL semantic associated with this element in a shader input-signature. + + + The semantic index for the element. A semantic index modifies a semantic, with an integer index number. A semantic index is only needed in a + case where there is more than one element with the same semantic. For example, a 4x4 matrix would have four components each with the semantic + name matrix, however each of the four component would have different semantic indices (0, 1, 2, and 3). + + + A DXGI_FORMAT-typed value that specifies the format of the element data. + + + An integer value that identifies the input-assembler. For more info, see Input Slots. Valid values are between 0 and 15. + + + Optional. Offset, in bytes, to this element from the start of the vertex. Use D3D12_APPEND_ALIGNED_ELEMENT (0xffffffff) for convenience to define the current element directly + after the previous one, including any packing if necessary. + + + A value that identifies the input data class for a single input slot. + + + The number of instances to draw using the same per-instance data before advancing in the buffer by one element. This value must be 0 for an + element that contains per-vertex data (the slot class is set to the D3D12_INPUT_PER_VERTEX_DATA member of D3D12_INPUT_CLASSIFICATION). + + + + Describes depth-stencil state. + Microsoft Docs: + + + + Specifies whether to enable depth testing. Set this member to TRUE to enable depth testing. + + + A D3D12_DEPTH_WRITE_MASK-typed value that identifies a portion of the depth-stencil buffer that can be modified by depth data. + + + A D3D12_COMPARISON_FUNC-typed value that identifies a function that compares depth data against existing depth data. + + + Specifies whether to enable stencil testing. Set this member to TRUE to enable stencil testing. + + + Identify a portion of the depth-stencil buffer for reading stencil data. + + + Identify a portion of the depth-stencil buffer for writing stencil data. + + + A D3D12_DEPTH_STENCILOP_DESC structure that describes how to use the results of the depth test and the stencil test for pixels whose surface normal is facing towards the camera. + + + A D3D12_DEPTH_STENCILOP_DESC structure that describes how to use the results of the depth test and the stencil test for pixels whose surface normal is facing away from the camera. + + + TRUE to enable depth-bounds testing; otherwise, FALSE. The default value is FALSE. + + + + Identifies the type of resource that will be viewed as a shader resource. + Microsoft Docs: + + + + The type is unknown. + + + The resource is a buffer. + + + The resource is a 1D texture. + + + The resource is an array of 1D textures. + + + The resource is a 2D texture. + + + The resource is an array of 2D textures. + + + The resource is a multisampling 2D texture. + + + The resource is an array of multisampling 2D textures. + + + The resource is a 3D texture. + + + The resource is a cube texture. + + + The resource is an array of cube textures. + + + The resource is a raytracing acceleration structure. + + + + Pop a retrieval filter from the top of the retrieval-filter stack. + Microsoft Docs: + + + + + Identifies whether conservative rasterization is on or off. + Microsoft Docs: + + + + Conservative rasterization is off. + + + Conservative rasterization is on. + + + + Gets a shader-reflection variable by name. + Microsoft Docs: + Variable name. + + + + + Describes the subresources from an array of cube textures to use in a shader-resource view. + Microsoft Docs: + + + + Index of the most detailed mipmap level to use; this number is between 0 and MipLevels (from the original TextureCube for which ID3D12Device::CreateShaderResourceView creates a view) -1. + + + The maximum number of mipmap levels for the view of the texture. See the remarks in D3D12_TEX1D_SRV. + +Set to -1 to indicate all the mipmap levels from MostDetailedMip on down to least detailed. + + + Index of the first 2D texture to use. + + + Number of cube textures in the array. + + + A value to clamp sample LOD values to. For example, if you specify 2.0f for the clamp value, you ensure that no individual sample accesses a mip level less than 2.0f. + + + + Sets a constant in the graphics root signature. + Microsoft Docs: + The slot number for binding. + The source data for the constant to set. + The offset, in 32-bit values, to set the constant in the root signature. + + + + + Specifies input stream arguments for an input stream passed to ID3D12VideoCommandList::ProcessFrames. + Microsoft Docs: + + + + An array of D3D12_VIDEO_PROCESS_INPUT_STREAM structures containing the set of references for video processing. If the stereo format is D3D12_VIDEO_PROCESS_STEREO_FORMAT_SEPARATE, then two sets of input streams must be supplied. For all other stereo formats, the first set of reference must be supplied, and the second should be zero initialized. + + + A D3D12_VIDEO_PROCESS_TRANSFORM structure specifying the flip, rotation, scale and destination translation for the video input. + + + A value from the D3D12_VIDEO_PROCESS_INPUT_STREAM_FLAGS enumeration specifying the options for the input stream. + + + A D3D12_VIDEO_PROCESS_INPUT_STREAM_RATE structure specifying the framerate and input and output indicies for framerate conversion and deinterlacing. + + + The level to apply for each enabled filter. The filter level is specified in the order that filters appear in the D3D12_VIDEO_PROCESS_FILTER_FLAGS enumeration. Specify 0 if a filter is not enabled or the filter index is reserved. + + + A D3D12_VIDEO_PROCESS_ALPHA_BLENDING structure specifying the planar alpha for an input stream on the video processor. + + + + Specifies the immediate value and destination address written using ID3D12CommandList2::WriteBufferImmediate. + Microsoft Docs: + + + + The GPU virtual address at which to write the value. The address must be aligned to a 32-bit (4-byte) boundary. + + + The 32-bit value to write. + + + + Specifies the configuration for video decoding. + Microsoft Docs: + + + + No configuration flags. + + + The height of the output decoded surfaces must be a multiple of 32. + + + The driver supports post processing. If this flag is set, the host decoder can set up post-processing by using the conversion flags in the D3D12_VIDEO_DECODE_CONVERSION_ARGUMENTS. + + + Reference resources must be allocated with the D3D12_RESOURCE_FLAG_VIDEO_DECODE_REFERENCE_ONLY resource flag. References textures must be separate from output textures, similar to performing a format conversion or downscale. This flag must not be set for D3D12_VIDEO_DECODE_TIER_3 or greater. + + + The decode resolution can be changed on a non-key frame. + + + + Describes the allocation size of a video decoder heap. + Microsoft Docs: + + + + A D3D12_VIDEO_DECODER_HEAP_DESC describing a ID3D12VideoDecoderHeap. + + + The allocation size of the video decoder heap in the L0 memory pool. L0 is the physical system memory pool. When the adapter is discrete/NUMA, this pool has greater bandwidth for the CPU and less bandwidth for the GPU. When the adapter is UMA, this pool is the only one which is valid. For more information, see Residency. + + + The allocation size of the video decoder heap in the L1 memory pool. L1 is typically known as the physical video memory pool. L1 is only available when the adapter is discrete/NUMA, and has greater bandwidth for the GPU and cannot even be accessed by the CPU. When the adapter is UMA, this pool is not available. For more information, see Residency. + + + + This method creates a command signature. + Microsoft Docs: + Describes the command signature to be created with the D3D12_COMMAND_SIGNATURE_DESC structure. + Specifies the ID3D12RootSignature that the command signature applies to. + + +The root signature is required if any of the commands in the signature will update bindings on the pipeline. If the only command present is a draw or dispatch, the root signature parameter can be set to NULL. + The globally unique identifier (GUID) for the command signature interface (ID3D12CommandSignature). + The REFIID, or GUID, of the interface to the command signature can be obtained by using the __uuidof() macro. + For example, __uuidof(ID3D12CommandSignature) will get the GUID of the interface to a command signature. + Specifies a pointer, that on successful completion of the method will point to the created command signature (ID3D12CommandSignature). + + + + + Gets info about how a tiled resource is broken into tiles. + Microsoft Docs: + Specifies a tiled ID3D12Resource to get info about. + A pointer to a variable that receives the number of tiles needed to store the entire tiled resource. + A pointer to a D3D12_PACKED_MIP_INFO structure that GetResourceTiling fills with info about how the tiled resource's mipmaps are packed. + Specifies a D3D12_TILE_SHAPE structure that GetResourceTiling fills with info about the tile shape. This is info about how pixels fit in the tiles, independent of tiled resource's dimensions, not including packed mipmaps. If the entire tiled resource is packed, this parameter is meaningless because the tiled resource has no defined layout for packed mipmaps. In this situation, GetResourceTiling sets the members of D3D12_TILE_SHAPE to zeros. + A pointer to a variable that contains the number of tiles in the subresource. On input, this is the number of subresources to query tilings for; on output, this is the number that was actually retrieved at pSubresourceTilingsForNonPackedMips (clamped to what's available). + The number of the first subresource tile to get. GetResourceTiling ignores this parameter if the number that pNumSubresourceTilings points to is 0. + Specifies a D3D12_SUBRESOURCE_TILING structure that GetResourceTiling fills with info about subresource tiles. If subresource tiles are part of packed mipmaps, GetResourceTiling sets the members of D3D12_SUBRESOURCE_TILING to zeros, except the StartTileIndexInOverallResource member, which GetResourceTiling sets to D3D12_PACKED_TILE (0xffffffff). The D3D12_PACKED_TILE constant indicates that the whole D3D12_SUBRESOURCE_TILING structure is meaningless for this situation, and the info that the pPackedMipDesc parameter points to applies. + + + + + Shares a resource (or subresource) between the D3D layers and diagnostics tools. + Microsoft Docs: + A pointer to the resource that contains the final frame contents. This resource is treated as the back buffer of the Present. + An unsigned 32bit subresource id. + If provided, indicates which window the tools should use for displaying additional diagnostic information. + + + + + Describes per-command-list settings used by GPU-Based Validation. + Microsoft Docs: + + + + Specifies a D3D12_GPU_BASED_VALIDATION_SHADER_PATCH_MODE that overrides the default device-level shader patch mode (see ID3D12DebugDevice1::SetDebugParameter). By default this value is initialized to the DefaultShaderPatchMode assigned to the device (see D3D12_DEBUG_DEVICE_GPU_BASED_VALIDATION_SETTINGS. + + + + A state subobject that identifies the GPU nodes to which the state object applies. + Microsoft Docs: + + + + The node mask. + + + + Represents the state of all currently set shaders as well as certain fixed function state objects. + Microsoft Docs: + + + + + Specifies the parameters for the output stream for a video decode operation. + Microsoft Docs: + + + + An ID3D12Resource representing the output texture. If decode conversion is enabled, this texture will contain the post-conversion output. If decode conversion is not enabled, this texture will contain the decode output. + + + The index of the output subresource of pOutputTexture2D to use. This allows you to specify array indices if the output is an array. + + + An optional D3D12_VIDEO_DECODE_CONVERSION_ARGUMENTS structure containing output conversion parameters. + + + An array of D3D12_VIDEO_DECODE_OUTPUT_HISTOGRAM structures that are populated with histogram data. The maximum size of the array is 4. + + + + Defines general properties of a state object. + Microsoft Docs: + + + + A value from the D3D12_STATE_OBJECT_FLAGS flags enumeration that specifies the requirements for the state object. + + + + Represents an application-defined callback used for being notified of lifetime changes of an object. + Microsoft Docs: + + + + + Describes a shader variable. + Microsoft Docs: + + + + The variable name. + + + Offset from the start of the parent structure to the beginning of the variable. + + + Size of the variable (in bytes). + + + A combination of D3D_SHADER_VARIABLE_FLAGS-typed values that are combined by using a bitwise-OR operation. + The resulting value identifies shader-variable properties. + + + The default value for initializing the variable. + Emits default values for reflection. + + + Offset from the start of the variable to the beginning of the texture. + + + The size of the texture, in bytes. + + + Offset from the start of the variable to the beginning of the sampler. + + + The size of the sampler, in bytes. + + + + Specifies whether a video format and colorspace conversion operation is supported. + Microsoft Docs: + + + + The conversion from the source format and colorspace to destination format and colorspace are not supported. + + + The conversion from the source format and colorspace to destination format and colorspace are are supported. + + + + Updates a fence to a specified value. + Microsoft Docs: + A pointer to the ID3D12Fence object. + The value to set the fence to. + + + + + An interface from which ID3D12GraphicsCommandList inherits from. It represents an ordered set of commands that the GPU executes, while allowing for extension to support other command lists than just those for graphics (such as compute and copy). + Microsoft Docs: + + + + + Specifies the type of query. + Microsoft Docs: + + + + Indicates the query is for depth/stencil occlusion counts. + + + Indicates the query is for a binary depth/stencil occlusion statistics. + +This new query type acts like D3D12_QUERY_TYPE_OCCLUSION except that it returns simply a binary 0/1 result: 0 indicates that no samples passed depth and stencil testing, 1 indicates that at least one sample passed depth and stencil testing. This enables occlusion queries to not interfere with any GPU performance optimization associated with depth/stencil testing. + + + Indicates the query is for high definition GPU and CPU timestamps. + + + Indicates the query type is for graphics pipeline statistics, refer to D3D12_QUERY_DATA_PIPELINE_STATISTICS. + + + Stream 0 output statistics. In Direct3D 12 there is no single stream output (SO) overflow query for all the output streams. Apps need to issue multiple single-stream queries, and then correlate the results. Stream output is the ability of the GPU to write vertices to a buffer. The stream output counters monitor progress. + + + Stream 1 output statistics. + + + Stream 2 output statistics. + + + Stream 3 output statistics. + + + Video decode statistics. Refer to D3D12_QUERY_DATA_VIDEO_DECODE_STATISTICS. + +Use this query type to determine if a video was successfully decoded. If decoding fails due to insufficient BitRate or FrameRate parameters set during creation of the decode heap, then the status field of the query is set to D3D12_VIDEO_DECODE_STATUS_RATE_EXCEEDED and the query also contains new BitRate and FrameRate values that would succeed. + +This query type can only be performed on video decode command lists [(D3D12_COMMAND_LIST_TYPE_VIDEO_DECODE)](/windows/desktop/api/d3d12/ne-d3d12-d3d12_command_list_type). This query type does not use [ID3D12VideoDecodeCommandList::BeginQuery](../d3d12video/nf-d3d12video-id3d12videodecodecommandlist-beginquery.md), only [ID3D12VideoDecodeCommandList::EndQuery](../d3d12video/nf-d3d12video-id3d12videodecodecommandlist-endquery.md). Statistics are recorded only for the most recent [ID3D12VideoDecodeCommandList::DecodeFrame](../d3d12video/nf-d3d12video-id3d12videodecodecommandlist-decodeframe.md) call in the same command list. + +Decode status structures are defined by the codec specification. + + + + Resets the state of a direct command list back to the state it was in when the command list was created. + Microsoft Docs: + A pointer to the ID3D12PipelineState object that contains the initial pipeline state for the command list. + + + + + Gets the number of conversion instructions. + Microsoft Docs: + + + + + Specifies the predication operation to apply. + Microsoft Docs: + + + + Enables predication if all 64-bits are zero. + + + Enables predication if at least one of the 64-bits are not zero. + + + + Provides data for calls to ID3D12VideoDevice::CheckFeatureSupport when the feature specified is D3D12_FEATURE_VIDEO_DECODE_HISTOGRAM. + Microsoft Docs: + + + + For single GPU operation, set this to zero. If there are multiple GPU nodes, set a bit to identify the node (the device's physical adapter) to which the command queue applies. Each bit in the mask corresponds to a single node. Only 1 bit may be set. + + + A GUID representing the decode profile for which histogram capabilities will be queried. Get a list of available profile GUIDs by calling [ID3D12VideoDevice::CheckFeatureSupport](nf-d3d12video-id3d12videodevice-checkfeaturesupport.md) when the feature specified is D3D12\_FEATURE\_VIDEO\_DECODE\_PROFILES. + + + The decode width of the source stream. + + + The decode height of the source stream. + + + The DXGI\_FORMAT representing the decode format. + + + A bitwise OR combination of values from the D3D12_VIDEO_DECODE_HISTOGRAM_COMPONENT_FLAGS enumeration specifying the components of a DXGI_FORMAT for which histogram support will be queried. + + + The number of per component bins supported. This value must be greater than or equal to 64 and must be a power of 2 (e.g. 64, 128, 256, 512...). + + + The bit depth of the bin counter. The counter is always stored in a 32-bit value and therefore this value must specify 32 bits or less. The counter is stored in the lower bits of the 32-bit storage. The upper bits are set to zero. If the bin count exceeds this bit depth, the value is set to the maximum counter value. Valid values for CounterBitDepth are 16, 24, and 32. + + + + A state subobject describing an existing collection that can be included in a state object. + Microsoft Docs: + + + + The collection to include in a state object. The enclosing state object holds a reference to the existing collection. + + + Size of the pExports array. If 0, all of the collection’s exports get exported. + + + + Apps perform indirect draws/dispatches using the ExecuteIndirect method. + Microsoft Docs: + Specifies a ID3D12CommandSignature. The data referenced by pArgumentBuffer will be interpreted depending on the contents of the command signature. Refer to Indirect Drawing for the APIs that are used to create a command signature. + There are two ways that command counts can be specified: + +
    +
  • If pCountBuffer is not NULL, then MaxCommandCount specifies the maximum number of operations which will be performed. The actual number of operations to be performed are defined by the minimum of this value, and a 32-bit unsigned integer contained in pCountBuffer (at the byte offset specified by CountBufferOffset). +
    • +
  • If pCountBuffer is NULL, the MaxCommandCount specifies the exact number of operations which will be performed. +
    • +
+ Specifies one or more ID3D12Resource objects, containing the command arguments. + Specifies an offset into pArgumentBuffer to identify the first command argument. + Specifies a pointer to a ID3D12Resource. + Specifies a UINT64 that is the offset into pCountBuffer, identifying the argument count. + + + + + Ends a running query. + Microsoft Docs: + Specifies the ID3D12QueryHeap containing the query. + Specifies one member of D3D12_QUERY_TYPE. + Specifies the index of the query in the query heap. + + + + + Specifies blend factors, which modulate values for the pixel shader and render target. + Microsoft Docs: + + + + The blend factor is (0, 0, 0, 0). No pre-blend operation. + + + The blend factor is (1, 1, 1, 1). No pre-blend operation. + + + The blend factor is (Rₛ, Gₛ, Bₛ, Aₛ), that is color data (RGB) from a pixel shader. No pre-blend operation. + + + The blend factor is (1 - Rₛ, 1 - Gₛ, 1 - Bₛ, 1 - Aₛ), that is color data (RGB) from a pixel shader. The pre-blend operation inverts the data, generating 1 - RGB. + + + The blend factor is (Aₛ, Aₛ, Aₛ, Aₛ), that is alpha data (A) from a pixel shader. No pre-blend operation. + + + The blend factor is ( 1 - Aₛ, 1 - Aₛ, 1 - Aₛ, 1 - Aₛ), that is alpha data (A) from a pixel shader. The pre-blend operation inverts the data, generating 1 - A. + + + The blend factor is (Ad Ad Ad Ad), that is alpha data from a render target. No pre-blend operation. + + + The blend factor is (1 - Ad 1 - Ad 1 - Ad 1 - Ad), that is alpha data from a render target. The pre-blend operation inverts the data, generating 1 - A. + + + The blend factor is (Rd, Gd, Bd, Ad), that is color data from a render target. No pre-blend operation. + + + The blend factor is (1 - Rd, 1 - Gd, 1 - Bd, 1 - Ad), that is color data from a render target. The pre-blend operation inverts the data, generating 1 - RGB. + + + The blend factor is (f, f, f, 1); where f = min(Aₛ, 1 + - Ad). The pre-blend operation clamps the data to 1 or less. + + + The blend factor is the blend factor set with ID3D12GraphicsCommandList::OMSetBlendFactor. No pre-blend operation. + + + The blend factor is the blend factor set with ID3D12GraphicsCommandList::OMSetBlendFactor. The pre-blend operation inverts the blend factor, generating 1 - blend_factor. + + + The blend factor is data sources both as color data output by a pixel shader. There is no pre-blend operation. This blend factor supports dual-source color blending. + + + The blend factor is data sources both as color data output by a pixel shader. The pre-blend operation inverts the data, generating 1 - RGB. This blend factor supports dual-source color blending. + + + The blend factor is data sources as alpha data output by a pixel shader. There is no pre-blend operation. This blend factor supports dual-source color blending. + + + The blend factor is data sources as alpha data output by a pixel shader. The pre-blend operation inverts the data, generating 1 - A. This blend factor supports dual-source color blending. + + + + Retrieves the unique identifier for a shader that can be used in a shader record. + Microsoft Docs: + Entrypoint in the state object for which to retrieve an identifier. + + + + + Specifies the border color for a static sampler. + Microsoft Docs: + + + + Indicates black, with the alpha component as fully transparent. + + + Indicates black, with the alpha component as fully opaque. + + + Indicates white, with the alpha component as fully opaque. + + + + Specifies filtering options during texture sampling. + Microsoft Docs: + + + + Use point sampling for minification, magnification, and mip-level sampling. + + + Use point sampling for minification and magnification; use linear interpolation for mip-level sampling. + + + Use point sampling for minification; use linear interpolation for magnification; use point sampling for mip-level sampling. + + + Use point sampling for minification; use linear interpolation for magnification and mip-level sampling. + + + Use linear interpolation for minification; use point sampling for magnification and mip-level sampling. + + + Use linear interpolation for minification; use point sampling for magnification; use linear interpolation for mip-level sampling. + + + Use linear interpolation for minification and magnification; use point sampling for mip-level sampling. + + + Use linear interpolation for minification, magnification, and mip-level sampling. + + + Use anisotropic interpolation for minification, magnification, and mip-level sampling. + + + Use point sampling for minification, magnification, and mip-level sampling. Compare the result to the comparison value. + + + Use point sampling for minification and magnification; use linear interpolation for mip-level sampling. Compare the result to the comparison value. + + + Use point sampling for minification; use linear interpolation for magnification; use point sampling for mip-level sampling. Compare the result to the comparison value. + + + Use point sampling for minification; use linear interpolation for magnification and mip-level sampling. Compare the result to the comparison value. + + + Use linear interpolation for minification; use point sampling for magnification and mip-level sampling. Compare the result to the comparison value. + + + Use linear interpolation for minification; use point sampling for magnification; use linear interpolation for mip-level sampling. Compare the result to the comparison value. + + + Use linear interpolation for minification and magnification; use point sampling for mip-level sampling. Compare the result to the comparison value. + + + Use linear interpolation for minification, magnification, and mip-level sampling. Compare the result to the comparison value. + + + Use anisotropic interpolation for minification, magnification, and mip-level sampling. Compare the result to the comparison value. + + + Fetch the same set of texels as D3D12_FILTER_MIN_MAG_MIP_POINT and instead of filtering them return the minimum of the texels. Texels that are weighted 0 during filtering aren't counted towards the minimum. You can query support for this filter type from the MinMaxFiltering member in the D3D11_FEATURE_DATA_D3D11_OPTIONS1 structure. + + + Fetch the same set of texels as D3D12_FILTER_MIN_MAG_POINT_MIP_LINEAR and instead of filtering them return the minimum of the texels. Texels that are weighted 0 during filtering aren't counted towards the minimum. You can query support for this filter type from the MinMaxFiltering member in the D3D11_FEATURE_DATA_D3D11_OPTIONS1 structure. + + + Fetch the same set of texels as D3D12_FILTER_MIN_POINT_MAG_LINEAR_MIP_POINT and instead of filtering them return the minimum of the texels. Texels that are weighted 0 during filtering aren't counted towards the minimum. You can query support for this filter type from the MinMaxFiltering member in the D3D11_FEATURE_DATA_D3D11_OPTIONS1 structure. + + + Fetch the same set of texels as D3D12_FILTER_MIN_POINT_MAG_MIP_LINEAR and instead of filtering them return the minimum of the texels. Texels that are weighted 0 during filtering aren't counted towards the minimum. You can query support for this filter type from the MinMaxFiltering member in the D3D11_FEATURE_DATA_D3D11_OPTIONS1 structure. + + + Fetch the same set of texels as D3D12_FILTER_MIN_LINEAR_MAG_MIP_POINT and instead of filtering them return the minimum of the texels. Texels that are weighted 0 during filtering aren't counted towards the minimum. You can query support for this filter type from the MinMaxFiltering member in the D3D11_FEATURE_DATA_D3D11_OPTIONS1 structure. + + + Fetch the same set of texels as D3D12_FILTER_MIN_LINEAR_MAG_POINT_MIP_LINEAR and instead of filtering them return the minimum of the texels. Texels that are weighted 0 during filtering aren't counted towards the minimum. You can query support for this filter type from the MinMaxFiltering member in the D3D11_FEATURE_DATA_D3D11_OPTIONS1 structure. + + + Fetch the same set of texels as D3D12_FILTER_MIN_MAG_LINEAR_MIP_POINT and instead of filtering them return the minimum of the texels. Texels that are weighted 0 during filtering aren't counted towards the minimum. You can query support for this filter type from the MinMaxFiltering member in the D3D11_FEATURE_DATA_D3D11_OPTIONS1 structure. + + + Fetch the same set of texels as D3D12_FILTER_MIN_MAG_MIP_LINEAR and instead of filtering them return the minimum of the texels. Texels that are weighted 0 during filtering aren't counted towards the minimum. You can query support for this filter type from the MinMaxFiltering member in the D3D11_FEATURE_DATA_D3D11_OPTIONS1 structure. + + + Fetch the same set of texels as D3D12_FILTER_ANISOTROPIC and instead of filtering them return the minimum of the texels. Texels that are weighted 0 during filtering aren't counted towards the minimum. You can query support for this filter type from the MinMaxFiltering member in the D3D11_FEATURE_DATA_D3D11_OPTIONS1 structure. + + + Fetch the same set of texels as D3D12_FILTER_MIN_MAG_MIP_POINT and instead of filtering them return the maximum of the texels. Texels that are weighted 0 during filtering aren't counted towards the maximum. You can query support for this filter type from the MinMaxFiltering member in the D3D11_FEATURE_DATA_D3D11_OPTIONS1 structure. + + + Fetch the same set of texels as D3D12_FILTER_MIN_MAG_POINT_MIP_LINEAR and instead of filtering them return the maximum of the texels. Texels that are weighted 0 during filtering aren't counted towards the maximum. You can query support for this filter type from the MinMaxFiltering member in the D3D11_FEATURE_DATA_D3D11_OPTIONS1 structure. + + + Fetch the same set of texels as D3D12_FILTER_MIN_POINT_MAG_LINEAR_MIP_POINT and instead of filtering them return the maximum of the texels. Texels that are weighted 0 during filtering aren't counted towards the maximum. You can query support for this filter type from the MinMaxFiltering member in the D3D11_FEATURE_DATA_D3D11_OPTIONS1 structure. + + + Fetch the same set of texels as D3D12_FILTER_MIN_POINT_MAG_MIP_LINEAR and instead of filtering them return the maximum of the texels. Texels that are weighted 0 during filtering aren't counted towards the maximum. You can query support for this filter type from the MinMaxFiltering member in the D3D11_FEATURE_DATA_D3D11_OPTIONS1 structure. + + + Fetch the same set of texels as D3D12_FILTER_MIN_LINEAR_MAG_MIP_POINT and instead of filtering them return the maximum of the texels. Texels that are weighted 0 during filtering aren't counted towards the maximum. You can query support for this filter type from the MinMaxFiltering member in the D3D11_FEATURE_DATA_D3D11_OPTIONS1 structure. + + + Fetch the same set of texels as D3D12_FILTER_MIN_LINEAR_MAG_POINT_MIP_LINEAR and instead of filtering them return the maximum of the texels. Texels that are weighted 0 during filtering aren't counted towards the maximum. You can query support for this filter type from the MinMaxFiltering member in the D3D11_FEATURE_DATA_D3D11_OPTIONS1 structure. + + + Fetch the same set of texels as D3D12_FILTER_MIN_MAG_LINEAR_MIP_POINT and instead of filtering them return the maximum of the texels. Texels that are weighted 0 during filtering aren't counted towards the maximum. You can query support for this filter type from the MinMaxFiltering member in the D3D11_FEATURE_DATA_D3D11_OPTIONS1 structure. + + + Fetch the same set of texels as D3D12_FILTER_MIN_MAG_MIP_LINEAR and instead of filtering them return the maximum of the texels. Texels that are weighted 0 during filtering aren't counted towards the maximum. You can query support for this filter type from the MinMaxFiltering member in the D3D11_FEATURE_DATA_D3D11_OPTIONS1 structure. + + + Fetch the same set of texels as D3D12_FILTER_ANISOTROPIC and instead of filtering them return the maximum of the texels. Texels that are weighted 0 during filtering aren't counted towards the maximum. You can query support for this filter type from the MinMaxFiltering member in the D3D11_FEATURE_DATA_D3D11_OPTIONS1 structure. + + + + Provides methods to monitor and debug a command list. + Microsoft Docs: + + + + + Describes the blend state. + Microsoft Docs: + + + + Specifies whether to use alpha-to-coverage as a multisampling technique when setting a pixel to a render target. For more info about using alpha-to-coverage, see Alpha-To-Coverage. + + + Specifies whether to enable independent blending in simultaneous render targets. Set to TRUE to enable independent blending. If set to FALSE, only the RenderTarget[0] members are used; RenderTarget[1..7] are ignored. + +See the Remarks section for restrictions. + + + An array of D3D12_RENDER_TARGET_BLEND_DESC structures that describe the blend states for render targets; these correspond to the eight render targets that can be bound to the output-merger stage at one time. + + + + An interface from which many other core interfaces inherit from. It indicates that the object type encapsulates some amount of GPU-accessible memory; but does not strongly indicate whether the application can manipulate the object's residency. + Microsoft Docs: + + + + + Adds support for video extension commands. + Microsoft Docs: + + + + + Copies mappings from a source reserved resource to a destination reserved resource. + Microsoft Docs: + A pointer to the destination reserved resource. + A pointer to a + D3D12_TILED_RESOURCE_COORDINATE structure that describes the starting coordinates of the destination reserved resource. + A pointer to the source reserved resource. + A pointer to a D3D12_TILED_RESOURCE_COORDINATE structure that describes the starting coordinates of the source reserved resource. + A pointer to a D3D12_TILE_REGION_SIZE structure that describes the size of the reserved region. + One member of D3D12_TILE_MAPPING_FLAGS. + + + + + Specifies logical operations to configure for a render target. + Microsoft Docs: + + + + Clears the render target (0). + + + Sets the render target ( 1). + + + Copys the render target (s source from Pixel Shader output). + + + Performs an inverted-copy of the render target (~s). + + + No operation is performed on the render target (d destination in the Render Target View). + + + Inverts the render target (~d). + + + Performs a logical AND operation on the render target (s & d). + + + Performs a logical NAND operation on the render target (~(s & d)). + + + Performs a logical OR operation on the render target (s | d). + + + Performs a logical NOR operation on the render target (~(s | d)). + + + Performs a logical XOR operation on the render target (s ^ d). + + + Performs a logical equal operation on the render target (~(s ^ d)). + + + Performs a logical AND and reverse operation on the render target (s & ~d). + + + Performs a logical AND and invert operation on the render target (~s & d). + + + Performs a logical OR and reverse operation on the render target (s | ~d). + + + Performs a logical OR and invert operation on the render target (~s | d). + + + + Get a message from the message queue. + Microsoft Docs: + Index into message queue after an optional retrieval filter has been applied. This can be between 0 and the number of messages in the message queue that pass through the retrieval filter (which can be obtained with GetNumStoredMessagesAllowedByRetrievalFilter). 0 is the message at the front of the message queue. + Returned message. + Size of pMessage in bytes. + + + + + Describes the subresources involved in resolving at the conclusion of a render pass. + Microsoft Docs: + + + + A UINT. The source subresource. + + + A UINT. The destination subresource. + + + A UINT. The x coordinate within the destination subresource. + + + A UINT. The y coordinate within the destination subresource. + + + A D3D12_RECT. The rectangle within the source subresource. + + + + Creates a resource that is placed in a specific heap. Placed resources are the lightest weight resource objects available, and are the fastest to create and destroy. + Microsoft Docs: + A pointer to the ID3D12Heap interface that represents the heap in which the resource is placed. + The offset, in bytes, to the resource. The HeapOffset must be a multiple of the resource's alignment, and HeapOffset plus the resource size must be smaller than or equal to the heap size. GetResourceAllocationInfo must be used to understand the sizes of texture resources. + A pointer to a D3D12_RESOURCE_DESC structure that describes the resource. + The initial state of the resource, as a bitwise-OR'd combination of D3D12_RESOURCE_STATES enumeration constants. + +When a resource is created together with a D3D12_HEAP_TYPE_UPLOAD heap, InitialState must be D3D12_RESOURCE_STATE_GENERIC_READ. When a resource is created together with a D3D12_HEAP_TYPE_READBACK heap, InitialState must be D3D12_RESOURCE_STATE_COPY_DEST. + Specifies a D3D12_CLEAR_VALUE that describes the default value for a clear color. + +pOptimizedClearValue specifies a value for which clear operations are most optimal. When the created resource is a texture with either the D3D12_RESOURCE_FLAG_ALLOW_RENDER_TARGET or D3D12_RESOURCE_FLAG_ALLOW_DEPTH_STENCIL flags, your application should choose the value that the clear operation will most commonly be called with. + +Clear operations can be called with other values, but those operations will not be as efficient as when the value matches the one passed into resource creation. + +pOptimizedClearValue must be NULL when used with D3D12_RESOURCE_DIMENSION_BUFFER. + The globally unique identifier (GUID) for the resource interface. This is an input parameter. + +The REFIID, or GUID, of the interface to the resource can be obtained by using the __uuidof macro. For example, __uuidof(ID3D12Resource) gets the GUID of the interface to a resource. Although riid is, most commonly, the GUID for ID3D12Resource, it may be any GUID for any interface. If the resource object doesn't support the interface for this GUID, then creation fails with E_NOINTERFACE. + A pointer to a memory block that receives a pointer to the resource. ppvResource can be NULL, to enable capability testing. When ppvResource is NULL, no object will be created and S_FALSE will be returned when pResourceDesc and other parameters are valid. + + + + + Creates a command queue. + Microsoft Docs: + Specifies a D3D12_COMMAND_QUEUE_DESC that describes the command queue. + The globally unique identifier (GUID) for the command queue interface. See remarks. An input parameter. + A pointer to a memory block that receives a pointer to the ID3D12CommandQueue interface for the command queue. + + + + + Specifies the level of ray tracing support on the graphics device. + Microsoft Docs: + + + + No support for ray tracing on the device. Attempts to create any ray tracing-related object will fail, and using ray tracing-related APIs on command lists results in undefined behavior. + + + The device supports tier 1 ray tracing functionality. In the current release, this tier represents all available ray tracing features. + + + + Describes how a shader resource is bound to a shader input. + Microsoft Docs: + + + + Name of the shader resource. + + + A D3D_SHADER_INPUT_TYPE-typed value that identifies the type of data in the resource. + + + Starting bind point. + + + Number of contiguous bind points for arrays. + + + A combination of D3D_SHADER_INPUT_FLAGS-typed values for shader input-parameter options. + + + If the input is a texture, the D3D_RESOURCE_RETURN_TYPE-typed value that identifies the return type. + + + A D3D_SRV_DIMENSION-typed value that identifies the dimensions of the bound resource. + + + The number of samples for a multisampled texture; when a texture isn't multisampled, the value is set to -1 (0xFFFFFFFF). + This is zero if the shader resource is not a recognized texture. + + + The register space. + + + The range ID in the bytecode. + + + + Gets a shader-reflection-variable type by index. + Microsoft Docs: + Zero-based index. + + + + + Gets a resource layout that can be copied. Helps the app fill-in D3D12_PLACED_SUBRESOURCE_FOOTPRINT and D3D12_SUBRESOURCE_FOOTPRINT when suballocating space in upload heaps. + Microsoft Docs: + A description of the resource, as a pointer to a D3D12_RESOURCE_DESC structure. + Index of the first subresource in the resource. + The range of valid values is 0 to D3D12_REQ_SUBRESOURCES. + The number of subresources in the resource. The range of valid values is 0 to (D3D12_REQ_SUBRESOURCES - FirstSubresource). + The offset, in bytes, to the resource. + A pointer to an array (of length NumSubresources) of + D3D12_PLACED_SUBRESOURCE_FOOTPRINT structures, to be filled with the description and placement of each subresource. + A pointer to an array (of length NumSubresources) of integer variables, to be filled with the number of rows for each subresource. + A pointer to an array (of length NumSubresources) of integer variables, each entry to be filled with the unpadded size in bytes of a row, of each subresource. + + +For example, if a Texture2D resource has a width of 32 and bytes per pixel of 4, + +then pRowSizeInBytes returns 128. + +pRowSizeInBytes should not be confused with row pitch, as examining pLayouts and getting the row pitch from that will give you 256 as it is aligned to D3D12_TEXTURE_DATA_PITCH_ALIGNMENT. + A pointer to an integer variable, to be filled with the total size, in bytes. + + + + + Reports information about a device object's lifetime. + Microsoft Docs: + A value from the D3D12_RLDO_FLAGS enumeration. + This method uses the value in Flags to determine the amount of information to report about a device object's lifetime. + + + + + An interface used to turn on the debug layer. + Microsoft Docs: + + + + + Gets a variable by name. + Microsoft Docs: + A pointer to a string containing the variable name. + + + + + Defines priority levels for a command queue. + Microsoft Docs: + + + + Normal priority. + + + High priority. + + + Global realtime priority. + + + + An interface from which ID3D12Device and ID3D12DeviceChild inherit from. It provides methods to associate private data and annotate object names. + Microsoft Docs: + + + + + Executes a bundle. + Microsoft Docs: + Specifies the ID3D12GraphicsCommandList that determines the bundle to be executed. + + + + + Describes how the locations of elements are identified. + Microsoft Docs: + + + + For a data set of n elements, the pointer parameter points to the start of n elements in memory. + + + For a data set of n elements, the pointer parameter points to an array of n pointers in memory, each pointing to an individual element of the set. + + + + Represents a Direct3D 12 video decoder. + Microsoft Docs: + + + + + Updates mappings of tile locations in reserved resources to memory locations in a resource heap. + Microsoft Docs: + A pointer to the reserved resource. + The number of reserved resource regions. + An array of D3D12_TILED_RESOURCE_COORDINATE structures that describe the starting coordinates of the reserved resource regions. The NumResourceRegions parameter specifies the number of D3D12_TILED_RESOURCE_COORDINATE structures in the array. + An array of D3D12_TILE_REGION_SIZE structures that describe the sizes of the reserved resource regions. The NumResourceRegions parameter specifies the number of D3D12_TILE_REGION_SIZE structures in the array. + A pointer to the resource heap. + The number of tile ranges. + A pointer to an array of D3D12_TILE_RANGE_FLAGS values that describes each tile range. The NumRanges parameter specifies the number of values in the array. + An array of offsets into the resource heap. These are 0-based tile offsets, counting in tiles (not bytes). + An array of tiles. + An array of values that specify the number of tiles in each tile range. The NumRanges parameter specifies the number of values in the array. + A combination of D3D12_TILE_MAPPING_FLAGS values that are combined by using a bitwise OR operation. + + + + + This method enables you to change the depth bounds dynamically. + Microsoft Docs: + SAL: _In_ + +Specifies the minimum depth bounds. The default value is 0. NaN values silently convert to 0. + SAL: _In_ + +Specifies the maximum depth bounds. The default value is 1. NaN values silently convert to 0. + + + + + Associates a subobject defined directly in a state object with shader exports. + Microsoft Docs: + + + + Pointer to the subobject in current state object to define an association to. + + + Size of the pExports array. If 0, this is being explicitly defined as a default association. Another way to define a default association is to omit this subobject association for that subobject completely. + + + The array of exports with which the subobject is associated. + + + + Gets a constant buffer by name for a function. + Microsoft Docs: + The constant-buffer name. + + + + + A shader resource view (SRV) structure for storing a raytracing acceleration structure. + Microsoft Docs: + + + + The GPU virtual address of the SRV. + + + + Retrieves the fence for the protected session. From the fence, you can retrieve the current uniqueness validity value (using ID3D12Fence::GetCompletedValue), and add monitors for changes to its value. This is a read-only fence. + Microsoft Docs: + The GUID of the interface to a fence. Most commonly, ID3D12Fence, although it may be any GUID for any interface. If the protected session object doesn’t support the interface for this GUID, the function returns E_NOINTERFACE. + A pointer to a memory block that receives a pointer to the fence for the given protected session. + + + + + Specifies the output parameters for calls to ID3D12VideoEncodeCommandList::EstimateMotion. + Microsoft Docs: + + + + An ID3D12VideoMotionVectorHeap containing the resolved motion estimation vectors. Motion vectors are resolved to a DXGI_FORMAT_R16G16_SINT 2D texture. The resolved data is a signed 16-byte integer with quarter PEL units with the X vector component stored in the R component and the Y vector component stored in the G component. Motion vectors are stored in a 2D layout that corresponds to the pixel layout of the original input textures. + + + + Not intended to be called directly.  Use the PIX event runtime to insert events into a command queue. + Microsoft Docs: + + + + + Specifies the automatic processing features that a video processor can support. + Microsoft Docs: + + + + No automatic processing features are supported. + + + Denoise is supported. + + + Deringing is supported. + + + Edge enhancement is supported. + + + Color correction is supported. + + + Flesh tone mapping is supported. + + + Image stabilization is supported. + + + Enhanced image resolution is supported. + + + Anamorphic scaling is supported. + + + Additional processing features, not described by the other flags, are available. + + + + Specifies options for determining quality levels. + Microsoft Docs: + + + + No options are supported. + + + The number of quality levels can be determined for tiled resources. + + + + Describes the subresources from an array of multi sampled 2D textures for a depth-stencil view. + Microsoft Docs: + + + + The index of the first texture to use in an array of textures. + + + Number of textures to use. + + + + Copies tiles from buffer to tiled resource or vice versa. + Microsoft Docs: + A pointer to a tiled resource. + A pointer to a + D3D12_TILED_RESOURCE_COORDINATE structure that describes the starting coordinates of the tiled resource. + A pointer to a D3D12_TILE_REGION_SIZE structure that describes the size of the tiled region. + A pointer to an ID3D12Resource that represents a default, dynamic, or staging buffer. + The offset in bytes into the buffer at pBuffer to start the operation. + A combination of D3D12_TILE_COPY_FLAGS-typed values that are combined by using a bitwise OR operation and that identifies how to copy tiles. + + + + + Encapsulates a list of graphics commands for video processing. + Microsoft Docs: + + + + + Describes a memory range. + Microsoft Docs: + + + + The offset, in bytes, denoting the beginning of a memory range. + + + The offset, in bytes, denoting the end of a memory range. + End is one-past-the-end. + + + + Opens a handle for shared resources, shared heaps, and shared fences, by using Name and Access. + Microsoft Docs: + The name that was optionally passed as the Name parameter in the call to + ID3D12Device::CreateSharedHandle. + The access level that was specified in the Access parameter in the call to + ID3D12Device::CreateSharedHandle. + Pointer to the shared handle. + + + + + Adds the input PSO to an internal database with the corresponding name. + Microsoft Docs: + Specifies a unique name for the library. Overwriting is not supported. + Specifies the ID3D12PipelineState to add. + + + + + Creates a device that represents the display adapter. + Microsoft Docs: + A pointer to the video adapter to use when creating a device. + Pass NULL to use the default adapter, which is the first adapter that is enumerated by IDXGIFactory1::EnumAdapters. + + +
Note  Don't mix the use of DXGI 1.0 (IDXGIFactory) and DXGI 1.1 (IDXGIFactory1) in an application. + Use IDXGIFactory or IDXGIFactory1, but not both in an application. +
+
 
+ The minimum D3D_FEATURE_LEVEL required for successful device creation. + The globally unique identifier (GUID) for the device interface. + This parameter, and ppDevice, can be addressed with the single macro + IID_PPV_ARGS. + A pointer to a memory block that receives a pointer to the device. Pass NULL to test if device creation would succeed, but to not actually create the device. If NULL is passed and device creation would succeed, S_FALSE is returned. + + + + + Bind information about the primitive type, and data order that describes input data for the input assembler stage. + Microsoft Docs: + The type of primitive and ordering of the primitive data (see D3D_PRIMITIVE_TOPOLOGY). + + + + + Provides methods for getting information about the parameters to the call to ID3D12VideoDevice::CreateVideoProcessor that created the video processor. + Microsoft Docs: + + + + + Describes the tile structure of a tiled resource with mipmaps. + Microsoft Docs: + + + + The number of standard mipmaps in the tiled resource. + + + The number of packed mipmaps in the tiled resource. + + +This number starts from the least detailed mipmap (either sharing tiles or using non standard tile layout). + This number is 0 if no such packing is in the resource. + For array surfaces, this value is the number of mipmaps that are packed for a given array slice where each array slice repeats the same packing. + + +On Tier_2 tiled resources hardware, mipmaps that fill at least one standard shaped tile in all dimensions are not allowed to be included in the set of packed mipmaps. + On Tier_1 hardware, mipmaps that are an integer multiple of one standard shaped tile in all dimensions are not allowed to be included in the set of packed mipmaps. + Mipmaps with at least one dimension less than the standard tile shape may or may not be packed. + When a given mipmap needs to be packed, all coarser mipmaps for a given array slice are considered packed as well. + + + The number of tiles for the packed mipmaps in the tiled resource. + + +If there is no packing, this value is meaningless and is set to 0. + Otherwise, it is set to the number of tiles that are needed to represent the set of packed mipmaps. + The pixel layout within the packed mipmaps is hardware specific. + If apps define only partial mappings for the set of tiles in packed mipmaps, read and write behavior is vendor specific and undefined. + For arrays, this value is only the count of packed mipmaps within the subresources for each array slice. + + + The offset of the first packed tile for the resource in the overall range of tiles. + If NumPackedMips is 0, this value is meaningless and is 0. + Otherwise, it is the offset of the first packed tile for the resource in the overall range of tiles for the resource. + A value of 0 for StartTileIndexInOverallResource means the entire resource is packed. + For array surfaces, this is the offset for the tiles that contain the packed mipmaps for the first array slice. + Packed mipmaps for each array slice in arrayed surfaces are at this offset past the beginning of the tiles for each array slice. + + +
Note  The number of overall tiles, packed or not, for a given array slice is simply the total number of tiles for the resource divided by the resource's array size, + so it is easy to locate the range of tiles for any given array slice, out of which StartTileIndexInOverallResource identifies which of those are packed. +
+
 
 + + + + Defines constants used in the D3D12_DEVICE_REMOVED_EXTENDED_DATA structure to specify control flags for the Direct3D runtime. + Microsoft Docs: + + + + Typically specifies that Device Removed Extended Data (DRED) is disabled, except for when user-initiated feedback is used to produce a repro, or when otherwise enabled by Windows via automatic detection of process-instability issues. This is the default value. + + + Forces DRED to be enabled, regardless of the system state. + + + Disables DRED auto breadcrumbs. + + + + Specifies a Direct3D 12 video feature or feature set to query about. + Microsoft Docs: + + + + Check if a decode profile, bitstream encryption, resolution, and format are supported. The result is a D3D12_VIDEO_DECODE_TIER indicating the level of support. The associated data structure is D3D12_FEATURE_DATA_VIDEO_DECODE_SUPPORT. + + + Retrieve the list of decode profiles supported by the adapter. Call CheckFeatureSupport specifying the feature D3D12_FEATURE_VIDEO_DECODE_PROFILE_COUNT to get the number of profiles before calling CheckFeatureSupport for the D3D12_FEATURE_VIDEO_DECODE_PROFILES feature. The associated data structure is D3D12_FEATURE_DATA_VIDEO_DECODE_PROFILES. + + + Retrieves the list of supported decode formats for a D3D12_VIDEO_DECODE_CONFIGURATION. Call CheckFeatureSupport specifying the feature D3D12_FEATURE_VIDEO_DECODE_FORMAT_COUNT to get the number of profiles before calling CheckFeatureSupport for the D3D12_FEATURE_VIDEO_DECODE_PROFILES feature.The associated data structure is D3D12_FEATURE_DATA_VIDEO_DECODE_FORMATS. + + + Check if a colorspace conversion, format conversion, and scale are supported. The associated data structure is D3D12_FEATURE_DATA_VIDEO_DECODE_CONVERSION_SUPPORT. + + + Retrieves the video processor capabilities. The associated data structure is D3D12_FEATURE_DATA_VIDEO_PROCESS_SUPPORT. + + + Retrieves the maximum number of streams that can be enabled at the same time. The associated data structure is D3D12_FEATURE_DATA_VIDEO_PROCESS_MAX_INPUT_STREAMS. + + + Retrieves the number of past and future frames required for a given deinterlace mode, filters, frame rate conversion, and features. The associated data structure is D3D12_FEATURE_DATA_VIDEO_PROCESS_REFERENCE_INFO. + + + Checks the allocation size of a video decoder heap. The associated data structure is D3D12_FEATURE_DATA_VIDEO_DECODER_HEAP_SIZE. For information on residency budgeting for heaps, see Residency. + + + Checks the allocation size of a video processor heap. The associated data structure is D3D12_FEATURE_DATA_VIDEO_PROCESSOR_SIZE. For information on residency budgeting for heaps, see Residency. + + + Retrieves the number of supported decoder profiles. The returned count is used when querying for D3D12_FEATURE_VIDEO_DECODE_PROFILES. + + + Retrieves the number of supported decoder profiles. The returned count is used when querying for D3D12_FEATURE_VIDEO_DECODE_FORMATS. + + + Indicates if the video engine is IO coherent with the CPU. + + + Retrieves the supported components, bin count, and counter bit depth for the a decode histogram with the specified decode profile, resolution, and format. The associated data structure is D3D12_FEATURE_DATA_VIDEO_DECODE_HISTOGRAM. + + + Retrieves the supported resolutions, search block sizes, and precision for motion estimation. The associated data structure is D3D12_FEATURE_DATA_VIDEO_MOTION_ESTIMATOR. + + + Checks the allocation size of a motion estimator heap. The associated data structure is D3D12_FEATURE_DATA_VIDEO_MOTION_ESTIMATOR_SIZE. + + + Retrieves the supported number of video extension commands. The associated data structure is D3D12_FEATURE_DATA_VIDEO_EXTENSION_COMMAND_COUNT. + + + Retrieves a list of D3D12_VIDEO_EXTENSION_COMMAND_INFO structures describing video extension commands. The associated data structure is D3D12_FEATURE_DATA_VIDEO_EXTENSION_COMMAND_COUNT. + + + Retrieves the parameter count for the specified parameter stage. The associated data structure is D3D12_FEATURE_DATA_VIDEO_EXTENSION_COMMAND_PARAMETER_COUNT. + + + Retrieves a list of D3D12_VIDEO_EXTENSION_COMMAND_PARAMETER_INFO structures describing video extension command parameters for the specified parameter stage. The associated data structure is D3D12_FEATURE_DATA_VIDEO_EXTENSION_COMMAND_PARAMETERS. + + + Queries for command-defined support information. The associated data structure is D3D12_FEATURE_DATA_VIDEO_EXTENSION_COMMAND_SUPPORT. + + + Checks the allocation size of a video extension command. The associated data structure is D3D12_FEATURE_DATA_VIDEO_EXTENSION_COMMAND_SIZE. + + + Checks support for motion estimation with protected resources. The associated data structure is D3D12_FEATURE_DATA_VIDEO_MOTION_ESTIMATOR_PROTECTED_RESOURCES. + + + + Contains a pointer to the head of a linked list of D3D12_AUTO_BREADCRUMB_NODE objects. + Microsoft Docs: + + + + A pointer to a constant D3D12_AUTO_BREADCRUMB_NODE object representing the head of a linked list of auto-breadcrumb nodes, or nullptr if the list is empty. + + + + Gets a debug interface. + Microsoft Docs: + The globally unique identifier (GUID) for the debug interface. + The REFIID, or GUID, of the debug interface can be obtained by using the __uuidof() macro. + For example, __uuidof(ID3D12Debug) will get the GUID of the debug interface. + The debug interface, as a pointer to pointer to void. + See + ID3D12Debugand + ID3D12DebugDevice. + + + + + Defines constants that specify protected session status. + Microsoft Docs: + + + + Indicates that the protected session is in a valid state. + + + Indicates that the protected session is not in a valid state. + + + + Defines constants that specify what should be done with the results of earlier workload instrumentation. + Microsoft Docs: + + + + The default setting. Specifies that all results should be kept. + + + Specifies that the driver has seen all the data that it's ever going to, so it should stop waiting for more and go ahead compiling optimized shaders. + + + Like D3D12_MEASUREMENTS_ACTION_COMMIT_RESULTS, but also specifies that your application doesn't care about glitches, so the runtime should ignore the usual idle priority rules and go ahead using as many threads as possible to get shader recompiles done fast. Available only in Developer mode. + + + Specifies that the optimization state should be reset; hinting that whatever has previously been measured no longer applies. + + + + Identifies unordered-access view options. + Microsoft Docs: + + + + The view type is unknown. + + + View the resource as a buffer. + + + View the resource as a 1D texture. + + + View the resource as a 1D texture array. + + + View the resource as a 2D texture. + + + View the resource as a 2D texture array. + + + View the resource as a 3D texture array. + + + + Turns the debug features for a command list on or off. + Microsoft Docs: + A combination of feature-mask flags that are combined by using a bitwise OR operation. If a flag is present, that feature will be set to on, otherwise the feature will be set to off. + + + + + Describes a sub-pixel sample position for use with programmable sample positions. + Microsoft Docs: + + + + A signed sub-pixel coordinate value in the X axis. + + + A signed sub-pixel coordinate value in the Y axis. + + + + Gets the GPU descriptor handle that represents the start of the heap. + Microsoft Docs: + + + + + Specifies multiple wait flags for multiple fences. + Microsoft Docs: + + + + No flags are being passed. This means to use the default behavior, which is to wait for all fences before signaling the event. + + + Modifies behavior to indicate that the event should be signaled after any one of the fence values has been reached by its corresponding fence. + + + An alias for D3D12_MULTIPLE_FENCE_WAIT_FLAG_NONE, meaning to use the default behavior and wait for all fences. + + + + Records the execution (or invocation) of the specified meta command into a graphics command list. + Microsoft Docs: + A pointer to an ID3D12MetaCommand representing the meta command to initialize. + An optional pointer to a constant structure containing the values of the parameters for executing the meta command. + A SIZE_T containing the size of the structure pointed to by pExecutionParametersData, if set, otherwise 0. + + + + + Divulges the equivalent custom heap properties that are used for non-custom heap types, based on the adapter's architectural properties. + Microsoft Docs: + For single-GPU operation, set this to zero. + If there are multiple GPU nodes, set a bit to identify the node (the device's physical adapter). + Each bit in the mask corresponds to a single node. + Only 1 bit must be set. + See Multi-adapter systems. + A D3D12_HEAP_TYPE-typed value that specifies the heap to get properties for. + D3D12_HEAP_TYPE_CUSTOM is not supported as a parameter value. + + + + + Not intended to be called directly.  Use the PIX event runtime to insert events into a command queue. + Microsoft Docs: + Internal. + Internal. + Internal. + + + + + Describes the configuration for a video decoder. + Microsoft Docs: + + + + A GUID identifying the profile for the decoder, such as D3D12\_VIDEO\_DECODE\_PROFILE\_H264 or D3D12\_VIDEO\_DECODE\_PROFILE\_HEVC\_MAIN. For a list of supported GUIDs, see [Direct3D 12 Video GUIDs](/windows/desktop/medfound/direct3d-12-video-guids). + + + A member of the D3D12\_BITSTREAM\_ENCRYPTION\_TYPE enumeration specifying the type of bitstream encryption. For no encryption, use D3D12\_BITSTREAM\_ENCRYPTION\_TYPE\_NONE. + + + A member of the D3D12\_VIDEO\_FRAME\_CODED\_INTERLACE\_TYPE enumeration the desired interlace type used by the coded frames. + + + + Specifies the level of support for programmable sample positions that's offered by the adapter. + Microsoft Docs: + + + + Indicates that there's no support for programmable sample positions. + + + Indicates that there's tier 1 support for programmable sample positions. In tier 1, a single sample pattern can be specified to repeat for every pixel (SetSamplePosition parameter NumPixels = 1) and ResolveSubResource is supported. + + + Indicates that there's tier 2 support for programmable sample positions. In tier 2, four separate sample patterns can be specified for each pixel in a 2x2 grid (SetSamplePosition parameter NumPixels = 1) that repeats over the render-target or viewport, aligned on even coordinates . + + + + This method enables or disables GPU-based validation (GBV) before creating a device with the debug layer enabled. + Microsoft Docs: + TRUE to enable GPU-based validation, otherwise FALSE. + + + + + Specifies an orientation operation to be performed by a video processor. + Microsoft Docs: + + + + No change in orientation. 0 degrees. + + + The image is flipped horizontally. + + + The image is rotated 90 degrees clockwise. + + + The image is rotated 90 degrees clockwise and then flipped horizontally. + + + The image is rotated 180 degrees clockwise. + + + The image is flipped vertically. + + + The image is rotated 270 degrees clockwise. + + + The image is rotated 270 degrees clockwise and then flipped horizontally. + + + + Adds support for motion estimation. + Microsoft Docs: + + + + + Represents a virtual adapter. This interface extends ID3D12Device3. + Microsoft Docs: + + + + + This interface controls Device Removed Extended Data (DRED) settings. + Microsoft Docs: + + + + + Describes a resource, such as a texture, including a mip region. This structure is used in several methods. + Microsoft Docs: + + + + One member of D3D12_RESOURCE_DIMENSION, specifying the dimensions of the resource (for example, D3D12_RESOURCE_DIMENSION_TEXTURE1D), or whether it is a buffer ((D3D12_RESOURCE_DIMENSION_BUFFER). + + + Specifies the alignment. + + + Specifies the width of the resource. + + + Specifies the height of the resource. + + + Specifies the depth of the resource, if it is 3D, or the array size if it is an array of 1D or 2D resources. + + + Specifies the number of MIP levels. + + + Specifies one member of DXGI_FORMAT. + + + Specifies a DXGI_SAMPLE_DESC structure. + + + Specifies one member of D3D12_TEXTURE_LAYOUT. + + + Bitwise-OR'd flags, as D3D12_RESOURCE_FLAGS enumeration constants. + + + A D3D12_MIP_REGION struct. + + + + Describes minimum precision support options for shaders in the current graphics driver. + Microsoft Docs: + + + + The driver supports only full 32-bit precision for all shader stages. + + + The driver supports 10-bit precision. + + + The driver supports 16-bit precision. + + + + Describes a function. + Microsoft Docs: + + + + The shader version. + See also D3D12_SHADER_VERSION_TYPE. + + + The name of the originator of the function. + + + A combination of D3DCOMPILE Constants that are combined by using a bitwise OR operation. The resulting value specifies shader compilation and parsing. + + + The number of constant buffers for the function. + + + The number of bound resources for the function. + + + The number of emitted instructions for the function. + + + The number of temporary registers used by the function. + + + The number of temporary arrays used by the function. + + + The number of constant defines for the function. + + + The number of declarations (input + output) for the function. + + + The number of non-categorized texture instructions for the function. + + + The number of texture load instructions for the function. + + + The number of texture comparison instructions for the function. + + + The number of texture bias instructions for the function. + + + The number of texture gradient instructions for the function. + + + The number of floating point arithmetic instructions used by the function. + + + The number of signed integer arithmetic instructions used by the function. + + + The number of unsigned integer arithmetic instructions used by the function. + + + The number of static flow control instructions used by the function. + + + The number of dynamic flow control instructions used by the function. + + + The number of macro instructions used by the function. + + + The number of array instructions used by the function. + + + The number of mov instructions used by the function. + + + The number of movc instructions used by the function. + + + The number of type conversion instructions used by the function. + + + The number of bitwise arithmetic instructions used by the function. + + + A D3D_FEATURE_LEVEL-typed value that specifies the minimum Direct3D feature level target of the function byte code. + + + A value that contains a combination of one or more shader requirements flags; each flag specifies a requirement of the shader. A default value of 0 means there are no requirements. For a list of values, see ID3D12ShaderReflection::GetRequiresFlags. + + + The name of the function. + + + The number of logical parameters in the function signature, not including the return value. + + + Indicates whether the function returns a value. TRUE indicates it returns a value; otherwise, FALSE (it is a subroutine). + + + Indicates whether there is a Direct3D 10Level9 vertex shader blob. TRUE indicates there is a 10Level9 vertex shader blob; otherwise, FALSE. + + + Indicates whether there is a Direct3D 10Level9 pixel shader blob. TRUE indicates there is a 10Level9 pixel shader blob; otherwise, FALSE. + + + + Gets a shader-variable description. + Microsoft Docs: + A pointer to a shader-variable description (see D3D12_SHADER_VARIABLE_DESC). + + + + + Inherits from ID3D12VideoProcessor and provides support for protected resources. + Microsoft Docs: + + + + + Gets a constant-buffer description. + Microsoft Docs: + A shader-buffer description, as a pointer to a D3D12_SHADER_BUFFER_DESC structure. + + + + + Sets a constant in the compute root signature. + Microsoft Docs: + The slot number for binding. + The source data for the constant to set. + The offset, in 32-bit values, to set the constant in the root signature. + + + + + This method configures the sample positions used by subsequent draw, copy, resolve, and similar operations. + Microsoft Docs: + SAL: _In_ + +Specifies the number of samples to take, per pixel. This value can be 1, 2, 4, 8, or 16, otherwise the SetSamplePosition call is dropped. The number of samples must match the sample count configured in the PSO at draw time, otherwise the behavior is undefined. + SAL: _In_ + +Specifies the number of pixels that sample patterns are being specified for. This value can be either 1 or 4, otherwise the SetSamplePosition call is dropped. A value of 1 configures a single sample pattern to be used for each pixel; a value of 4 configures separate sample patterns for each pixel in a 2x2 pixel grid which is repeated over the render-target or viewport space, aligned to even coordintes. + +Note that the maximum number of combined samples can't exceed 16, otherwise the call is dropped. If NumPixels is set to 4, NumSamplesPerPixel can specify no more than 4 samples. + SAL: _In_reads_(NumSamplesPerPixel*NumPixels) + +Specifies an array of D3D12_SAMPLE_POSITION elements. The size of the array is NumPixels * NumSamplesPerPixel. If NumPixels is set to 4, then the first group of sample positions corresponds to the upper-left pixel in the 2x2 grid of pixels; the next group of sample positions corresponds to the upper-right pixel, the next group to the lower-left pixel, and the final group to the lower-right pixel. + +If centroid interpolation is used during rendering, the order of positions for each pixel determines centroid-sampling prioritiy. That is, the first covered sample in the order specified is chosen as the centroid sample location. + + + + + Represents a resource in which all UAV accesses must complete before any future UAV accesses can begin. + Microsoft Docs: + + + + The resource used in the transition, as a pointer to ID3D12Resource. + + + + Describes bindings (fixed for the duration of the render pass) to one or more render target views (RTVs), as well as their beginning and ending access characteristics. + Microsoft Docs: + + + + A D3D12_CPU_DESCRIPTOR_HANDLE. The CPU descriptor handle corresponding to the render target view(s) (RTVs). + + + A D3D12_RENDER_PASS_BEGINNING_ACCESS. The access to the RTV(s) requested at the transition into a render pass. + + + A D3D12_RENDER_PASS_ENDING_ACCESS. The access to the RTV(s) requested at the transition out of a render pass. + + + + Describes parameters needed to allocate resources, including offset. + Microsoft Docs: + + + + The offset, in bytes, of the resource. + + + The alignment value for the resource; one of 4KB (4096), 64KB (65536), or 4MB (4194304) alignment. + + + The size, in bytes, of the resource. + + + + Enumerates the types of shaders that Direct3D recognizes. Used to encode the Version member of the D3D12_SHADER_DESC structure. + Microsoft Docs: + + + + Pixel shader. + + + Vertex shader. + + + Geometry shader. + + + Hull shader. + + + Domain shader. + + + Compute shader. + + + Indicates the end of the enumeration. + + + + Specifies support for protected resources in video operations. + Microsoft Docs: + + + + Protected resources are not supported. + + + Protected resources are supported. + + + + Specifies the interlace type of coded video frames. + Microsoft Docs: + + + + The coded frames are not interlaced, often referred to as "progressive". + + + The coded frames may be interlaced. + + + + Gets the status of the protected session. + Microsoft Docs: + + + + + Specifies options for view instancing. + Microsoft Docs: + + + + Indicates a default view instancing configuration. + + + Enables view instance masking. + + + + Provides input data for calls to ID3D12VideoEncodeCommandList::ResolveMotionVectorHeap. + Microsoft Docs: + + + + The ID3D12VideoMotionVectorHeap containing the hardware-dependent data layout of the motion search. + + + The pixel width of the texture that the motion estimation operation was performed on. The motion estimator heap may be allocated to support a size range, this parameter informs the size of the last motion estimation operation. + + + The pixel height of the texture that the motion estimation operation was performed on. The motion estimator heap may be allocated to support a size range, this parameter informs the size of the last motion estimation operation. + + + + Writes a number of 32-bit immediate values to the specified buffer locations directly from the command stream. + Microsoft Docs: + The number of D3D12_WRITEBUFFERIMMEDIATE_PARAMETER structures that are pointed to by pParams and pModes. + The address of an array containing a number of D3D12_WRITEBUFFERIMMEDIATE_PARAMETER structures equal to Count. + The address of an array containing a number of D3D12_WRITEBUFFERIMMEDIATE_MODE structures equal to Count. The default value is null; passing null causes the system to write all immediate values using D3D12_WRITEBUFFERIMMEDIATE_MODE_DEFAULT. + + + + + Specifies resources that are supported for a provided format. + Microsoft Docs: + + + + No resources are supported. + + + Buffer resources supported. + + + Vertex buffers supported. + + + Index buffers supported. + + + Streaming output buffers supported. + + + 1D texture resources supported. + + + 2D texture resources supported. + + + 3D texture resources supported. + + + Cube texture resources supported. + + + The HLSL Load function for texture objects is supported. + + + The HLSL Sample function for texture objects is supported. + +
Note  If the device supports the format as a resource (1D, 2D, 3D, or cube map) but doesn't support this option, the resource can still use the Sample method but must use only the point filtering sampler state to perform the sample.
+
 
 + + + The HLSL SampleCmp and SampleCmpLevelZero functions for texture objects are supported. + +
Note  Windows 8 and later might provide limited support for these functions on Direct3D feature levels 9_1, 9_2, and 9_3. For more info, see Implementing shadow buffers for Direct3D feature level 9. +
+
 
 + + + Reserved. + + + Mipmaps are supported. + + + Render targets are supported. + + + Blend operations supported. + + + Depth stencils supported. + + + Multisample antialiasing (MSAA) resolve operations are supported. For more info, see ID3D12GraphicsCommandList::ResolveSubresource. + + + Format can be displayed on screen. + + + Format can't be cast to another format. + + + Format can be used as a multi-sampled render target. + + + Format can be used as a multi-sampled texture and read into a shader with the HLSL Load function. + + + Format can be used with the HLSL gather function. This value is available in DirectX 10.1 or higher. + + + Format supports casting when the resource is a back buffer. + + + Format can be used for an unordered access view. + + + Format can be used with the HLSL gather with comparison function. + + + Format can be used with the decoder output. + + + Format can be used with the video processor output. + + + Format can be used with the video processor input. + + + Format can be used with the video encoder. + + + + Represents a GPU virtual address range. + Microsoft Docs: + + + + The beginning of the virtual address range. + + + The size of the virtual address range, in bytes. + + + + Creates a heap that can be used with placed resources and reserved resources. + Microsoft Docs: + A pointer to a constant D3D12_HEAP_DESC structure that describes the heap. + A reference to the globally unique identifier (GUID) of the heap interface to return in ppvHeap. + +While riidResource is most commonly the GUID of ID3D12Heap, it may be the GUID of any interface. If the resource object doesn't support the interface for this GUID, then creation fails with E_NOINTERFACE. + An optional pointer to a memory block that receives the requested interface pointer to the created heap object. + +ppvHeap can be nullptr, to enable capability testing. When ppvHeap is nullptr, no object is created, and S_FALSE is returned when pDesc is valid. + + + + + Describes query data for stream output. + Microsoft Docs: + + + + Specifies the number of primitives written. + + + Specifies the total amount of storage needed by the primitives. + + + + Defines constants that specify the stage of a parameter to a meta command. + Microsoft Docs: + + + + Specifies that the parameter is used at the meta command creation stage. + + + Specifies that the parameter is used at the meta command initialization stage. + + + Specifies that the parameter is used at the meta command execution stage. + + + + Changes the currently bound descriptor heaps that are associated with a command list. + Microsoft Docs: + Number of descriptor heaps to bind. + A pointer to an array of ID3D12DescriptorHeap objects for the heaps to set on the command list. + +You can only bind descriptor heaps of type [D3D12_DESCRIPTOR_HEAP_TYPE_CBV_SRV_UAV](/windows/win32/api/d3d12/nf-d3d12-id3d12graphicscommandlist-setdescriptorheaps) and [D3D12_DESCRIPTOR_HEAP_TYPE_SAMPLER](/windows/win32/api/d3d12/nf-d3d12-id3d12graphicscommandlist-setdescriptorheaps). + +Only one descriptor heap of each type can be set at one time, which means a maximum of 2 heaps (one sampler, one CBV/SRV/UAV) can be set at one time. + + + + + Specifies input stream arguments for an input stream passed to ID3D12VideoProcessCommandList1::ProcessFrames1, which supports changing the field type for each call. + Microsoft Docs: + + + + An array of D3D12_VIDEO_PROCESS_INPUT_STREAM structures containing the set of references for video processing. If the stereo format is D3D12_VIDEO_PROCESS_STEREO_FORMAT_SEPARATE, then two sets of input streams must be supplied. For all other stereo formats, the first set of reference must be supplied, and the second should be zero initialized. + + + A D3D12_VIDEO_PROCESS_TRANSFORM structure specifying the flip, rotation, scale and destination translation for the video input. + + + A value from the D3D12_VIDEO_PROCESS_INPUT_STREAM_FLAGS enumeration specifying the options for the input stream. + + + A D3D12_VIDEO_PROCESS_INPUT_STREAM_RATE structure specifying the framerate and input and output indicies for framerate conversion and deinterlacing. + + + The level to apply for each enabled filter. The filter level is specified in the order that filters appear in the D3D12_VIDEO_PROCESS_FILTER_FLAGS enumeration. Specify 0 if a filter is not enabled or the filter index is reserved. + + + A D3D12_VIDEO_PROCESS_ALPHA_BLENDING structure specifying the planar alpha for an input stream on the video processor. + + + A value from the D3D12_VIDEO_FIELD_TYPE enumeration specfying the interlaced field type of the input source. When working with mixed content, use [ID3D12VideoProcessCommandList1::ProcessFrames1](nf-d3d12video-id3d12videoprocesscommandlist1-processframes1.md) which supports changing the field type for each call. + + + + Describes a ID3D12VideoDecoderHeap. + Microsoft Docs: + + + + The node mask specifying the physical adapter on which the video processor will be used. For single GPU operation, set this to zero. If there are multiple GPU nodes, set a bit to identify the node, i.e. the device's physical adapter, to which the command queue applies. Each bit in the mask corresponds to a single node. Only 1 bit may be set. + + + A D3D12_VIDEO_DECODE_CONFIGURATION structure specifying the configuration of the video decoder. + + + The decode width of the bitstream to be decoded. + + + The decode height of the bitstream to be decoded. + + + A DXGI_FORMAT structure specifying the format of the bitstream to be decoded. + + + The frame rate of the input video stream. For more information, see the Remarks section. + + + The average bits per second data compression rate for the compressed video stream. For more information, see the Remarks section. + + + The maximum number of decode picture buffers this stream can have. + + + + Represents Device Removed Extended Data (DRED) version 1.0 data. + Microsoft Docs: + + + + An input parameter of type D3D12_DRED_FLAGS, specifying control flags for the Direct3D runtime. + + + An output parameter of type pointer to D3D12_AUTO_BREADCRUMB_NODE representing the returned auto-breadcrumb object(s). This is a pointer to the head of a linked list of auto-breadcrumb objects. All of the nodes in the linked list represent potentially incomplete command list execution on the GPU at the time of the device-removal event. + + + + Specifies the type of a raytracing hit group state subobject. Use a value from this enumeration with the D3D12_HIT_GROUP_DESC structure. + Microsoft Docs: + + + + The hit group uses a list of triangles to calculate ray hits. Hit groups that use triangles can’t contain an intersection shader. + + + The hit group uses a procedural primitive within a bounding box to calculate ray hits. Hit groups that use procedural primitives must contain an intersection shader. + + + + Represents data for a video decode statistics query invoked by calling ID3D12VideoDecodeCommandList::EndQuery. + Microsoft Docs: + + + + A member of the D3D12_VIDEO_DECODE_STATUS enumeration indicating the video decoding status. + + + If Status is not 0, this member contains the accelerator's estimate of the number of super-blocks in the decoded frame that were adversely affected by the reported problem. If the accelerator does not provide an estimate, the value is D3D12\_VIDEO\_DECODE\_MACROBLOCKS\_AFFECTED\_UNKNOWN (0xFFFFFFFFFFFFFFFF). + + + The decode frame rate. + + + When the Status returned is D3D12_VIDEO_DECODE_STATUS_RATE_EXCEEDED, this field reports the bitrate that would succeed. This value may be used to recreate the decoder and try again. A value of zero here is valid to indicate that the worst case bit rate should be assumed. + +For all other Status values, BitRate is set to zero. + + + + Determines whether shader instrumentation is enabled. + Microsoft Docs: + + + + + Monitors the validity of a protected resource session. + Microsoft Docs: + + + + + Specifies flags for video processing input streams. + Microsoft Docs: + + + + No flags specified. + + + Set this flag when not processing frames in order, such as seeking between frames + + + Set this flag when applying video process operation to the same set of inputs. + + + + Gets a shader-variable type. + Microsoft Docs: + + + + + Specifies a range of tile mappings. + Microsoft Docs: + + + + No tile-mapping flags are specified. + + + The tile range is NULL. + + + Skip the tile range. + + + Reuse a single tile in the tile range. + + + + Represents a GPU virtual address range and stride. + Microsoft Docs: + + + + The beginning of the virtual address range. + + + The size of the virtual address range, in bytes. + + + Defines the record-indexing stride within the memory range. + + + + Set a boolean that turns the debug output on or off. + Microsoft Docs: + Disable/Enable the debug output (true to disable or mute the output, false to enable the output). + + + + + This method configures the level of GPU-based validation that the debug device is to perform at runtime. + Microsoft Docs: + Specifies the level of GPU-based validation to perform at runtime. + + + + + Defines a global root signature state suboject that will be used with associated shaders. + Microsoft Docs: + + + + The root signature that will function as a global root signature. A state object holds a reference to this signature. + + + + Describes Direct3D 12 feature options in the current graphics driver. + Microsoft Docs: + + + + Specifies whether double types are allowed for shader operations. + If TRUE, double types are allowed; otherwise FALSE. + The supported operations are equivalent to Direct3D 11's ExtendedDoublesShaderInstructions member of the D3D11_FEATURE_DATA_D3D11_OPTIONS structure. + + +To use any HLSL shader that is compiled with a double type, + the runtime must set DoublePrecisionFloatShaderOps to TRUE. + + + Specifies whether logic operations are available in blend state. The runtime sets this member to TRUE if logic operations are available in blend state and FALSE otherwise. This member is FALSE for feature level 9.1, 9.2, and 9.3. This member is optional for feature level 10, 10.1, and 11. This member is TRUE for feature level 11.1 and 12. + + + A combination of D3D12_SHADER_MIN_PRECISION_SUPPORT-typed values that are combined by using a bitwise OR operation. The resulting value specifies minimum precision levels that the driver supports for shader stages. A value of zero indicates that the driver supports only full 32-bit precision for all shader stages. + + + Specifies whether the hardware and driver support tiled resources. The runtime sets this member to a D3D12_TILED_RESOURCES_TIER-typed value that indicates if the hardware and driver support tiled resources and at what tier level. + + + Specifies the level at which the hardware and driver support resource binding. The runtime sets this member to a D3D12_RESOURCE_BINDING_TIER-typed value that indicates the tier level. + + + Specifies whether pixel shader stencil ref is supported. If TRUE, it's supported; otherwise FALSE. + + + Specifies whether the loading of additional formats for typed unordered-access views (UAVs) is supported. + If TRUE, it's supported; otherwise FALSE. + + + Specifies whether Rasterizer Order Views (ROVs) are supported. If TRUE, they're supported; otherwise FALSE. + + + Specifies the level at which the hardware and driver support conservative rasterization. The runtime sets this member to a D3D12_CONSERVATIVE_RASTERIZATION_TIER-typed value that indicates the tier level. + + + Don't use this field; instead, use the D3D12_FEATURE_DATA_GPU_VIRTUAL_ADDRESS_SUPPORT query + (a structure with a MaxGPUVirtualAddressBitsPerResource member), which is more accurate. + + + TRUE if the hardware supports textures with the 64KB standard swizzle pattern. + Support for this pattern enables zero-copy texture optimizations while providing near-equilateral locality for each dimension within the texture. + For texture swizzle options and restrictions, see D3D12_TEXTURE_LAYOUT. + + + A D3D12_CROSS_NODE_SHARING_TIER enumeration constant that specifies the level of sharing across nodes of an adapter that has multiple nodes, + such as Tier 1 Emulated, Tier 1, or Tier 2. + + + FALSE means the device only supports copy operations to and from cross-adapter row-major textures. + TRUE means the device supports shader resource views, unordered access views, and render target views of cross-adapter row-major textures. + "Cross-adapter" means between multiple adapters (even from different IHVs). + + + Whether the viewport (VP) and Render Target (RT) array index from any shader feeding the rasterizer are supported without geometry shader emulation. + Compare the VPAndRTArrayIndexFromAnyShaderFeedingRasterizer member of the D3D11_FEATURE_DATA_D3D11_OPTIONS3 structure. + In ID3D12ShaderReflection::GetRequiresFlags, see the #define D3D_SHADER_REQUIRES_VIEWPORT_AND_RT_ARRAY_INDEX_FROM_ANY_SHADER_FEEDING_RASTERIZER. + + + Specifies the level at which the hardware and driver require heap attribution related to resource type. + The runtime sets this member to a D3D12_RESOURCE_HEAP_TIER enumeration constant. + + + + Specifies RGB or alpha blending operations. + Microsoft Docs: + + + + Add source 1 and source 2. + + + Subtract source 1 from source 2. + + + Subtract source 2 from source 1. + + + Find the minimum of source 1 and source 2. + + + Find the maximum of source 1 and source 2. + + + + Reports the number of physical adapters (nodes) that are associated with this device. + Microsoft Docs: + + + + + Get a boolean that determines if debug output is on or off. + Microsoft Docs: + + + + + Specifies how GPU-Based Validation handles patched pipeline states during ID3D12Device::CreateGraphicsPipelineState and ID3D12Device::CreateComputePipelineState. + Microsoft Docs: + + + + This is the default value. Indicates no patching of pipeline states should be done during PSO creation. Instead PSO’s are patched on first use in a command list. This can help to reduce the up-front cost of PSO creation but may instead slow down command list recording until a steady-state is reached. + + + Indicates that state-tracking GPU-Based Validation PSO’s should be created along with the original PSO at create time. + + + Indicates that unguarded GPU-Based Validation PSO’s should be created along with the original PSO at create time. + + + Indicates that guarded GPU-Based Validation PSO’s should be created along with the original PSO at create time. + + + Internal use only. + + + + Describes the elements in a buffer to use in a unordered-access view. + Microsoft Docs: + + + + The zero-based index of the first element to be accessed. + + + The number of elements in the resource. For structured buffers, this is the number of structures in the buffer. + + + The size of each element in the buffer structure (in bytes) when the buffer represents a structured buffer. + + + The counter offset, in bytes. + + + A D3D12_BUFFER_UAV_FLAGS-typed value that specifies the view options for the resource. + + + + Writes the contents of the library to the provided memory, to be provided back to the runtime at a later time. + Microsoft Docs: + Specifies a pointer to the data. This memory must be readable and writeable up to the input size. This data can be saved and provided to CreatePipelineLibrary at a later time, including future instances of this or other processes. The data becomes invalidated if the runtime or driver is updated, and is not portable to other hardware or devices. + The size provided must be at least the size returned from GetSerializedSize. + + + + + Specifies whether or not protected resources can be accessed by subsequent commands in the command list. + Microsoft Docs: + An optional pointer to an ID3D12ProtectedResourceSession. You can obtain an ID3D12ProtectedResourceSession by calling [ID3D12Device4::CreateProtectedResourceSession](./nf-d3d12-id3d12device4-createprotectedresourcesession.md). + + + + + Sets the fence to the specified value. + Microsoft Docs: + The value to set the fence to. + + + + + Specifies how to access a resource used in a depth-stencil view. + Microsoft Docs: + + + + D3D12_DSV_DIMENSION_UNKNOWN is not a valid value for D3D12_DEPTH_STENCIL_VIEW_DESC and is not used. + + + The resource will be accessed as a 1D texture. + + + The resource will be accessed as an array of 1D textures. + + + The resource will be accessed as a 2D texture. + + + The resource will be accessed as an array of 2D textures. + + + The resource will be accessed as a 2D texture with multi sampling. + + + The resource will be accessed as an array of 2D textures with multi sampling. + + + + Gets an output-parameter description for a shader. + Microsoft Docs: + A zero-based parameter index. + A shader-output-parameter description, as a pointer to a D3D12_SIGNATURE_PARAMETER_DESC structure. + + + + + Describes a function parameter. + Microsoft Docs: + + + + The name of the function parameter. + + + The HLSL semantic that is associated with this function parameter. This name includes the index, for example, SV_Target[n]. + + + A D3D_SHADER_VARIABLE_TYPE-typed value that identifies the variable type for the parameter. + + + A D3D_SHADER_VARIABLE_CLASS-typed value that identifies the variable class for the parameter as one of scalar, vector, matrix, object, and so on. + + + The number of rows for a matrix parameter. + + + The number of columns for a matrix parameter. + + + A D3D_INTERPOLATION_MODE-typed value that identifies the interpolation mode for the parameter. + + + A combination of D3D_PARAMETER_FLAGS-typed values that are combined by using a bitwise OR operation. The resulting value specifies semantic flags for the parameter. + + + The first input register for this parameter. + + + The first input register component for this parameter. + + + The first output register for this parameter. + + + The first output register component for this parameter. + + + + Describes a pipeline state stream. + Microsoft Docs: + + + + SAL: _In_ + +Specifies the size of the opaque data structure pointed to by the pPipelineStateSubobjectStream member, in bytes. + + + SAL: _In_reads_(_Inexpressible_("Dependentonsizeofsubobjects")) + +Specifies the address of a data structure that describes as a bytestream an arbitrary pipeline state subobject. + + + + Provides detail about each adapter's architectural details, so that your application can better optimize for certain adapter properties. + Microsoft Docs: + + + + In multi-adapter operation, this indicates which physical adapter of the device is relevant. + See Multi-adapter systems. + NodeIndex is filled out by the application before calling CheckFeatureSupport, as the application can retrieve details about the architecture of each adapter. + + + Specifies whether the hardware and driver support a tile-based renderer. + The runtime sets this member to TRUE if the hardware and driver support a tile-based renderer. + + + Specifies whether the hardware and driver support UMA. + The runtime sets this member to TRUE if the hardware and driver support UMA. + + + Specifies whether the hardware and driver support cache-coherent UMA. + The runtime sets this member to TRUE if the hardware and driver support cache-coherent UMA. + + + SAL: _Out_ + +Specifies whether the hardware and driver support isolated Memory Management Unit (MMU). + The runtime sets this member to TRUE if the GPU honors CPU page table properties like MEM_WRITE_WATCH (for more information, see VirtualAlloc) and PAGE_READONLY (for more information, see Memory Protection Constants). + +If TRUE, the application must take care to no use memory with these page table properties with the GPU, as the GPU might trigger these page table properties in unexpected ways. For example, GPU write operations might be coarser than the application expects, particularly writes from within shaders. Certain write-watch pages migth appear dirty, even when it isn't obvious how GPU writes may have affected them. GPU operations associated with upload and readback heap usage scenarios work well with write-watch pages, but might occasionally generate false positives that can be safely ignored. + + + + Identifies unordered-access view options for a buffer resource. + Microsoft Docs: + + + + Indicates a default view. + + + Resource contains raw, unstructured data. Requires the UAV format to be DXGI_FORMAT_R32_TYPELESS. + For more info about raw viewing of buffers, see Raw Views of Buffers. + + + + Gets a shader-reflection variable by index. + Microsoft Docs: + Zero-based index. + + + + + Copies a source acceleration structure to destination memory while applying the specified transformation. + Microsoft Docs: + The destination memory. The required size can be discovered by calling EmitRaytracingAccelerationStructurePostbuildInfo beforehand, if necessary for the specified Mode. + +The destination start address must be aligned to 256 bytes, defined as D3D12_RAYTRACING_ACCELERATION_STRUCTURE_BYTE_ALIGNMENT, regardless of the specified Mode. + +The destination memory range cannot overlap source. Otherwise, results are undefined. + +The resource state that the memory pointed to must be in depends on the Mode parameter. For more information, see D3D12_RAYTRACING_ACCELERATION_STRUCTURE_COPY_MODE. + The address of the acceleration structure or other type of data to copy/transform based on the specified Mode. The data remains unchanged and usable. The operation only copies the data pointed to by SourceAccelerationStructureData and not any other data, such as acceleration structures, that the source data may point to. For example, in the case of a top-level acceleration structure, any bottom-level acceleration structures that it points to are not copied in the operation. + +The source memory must be aligned to 256 bytes, defined as D3D12_RAYTRACING_ACCELERATION_STRUCTURE_BYTE_ALIGNMENT, regardless of the specified Mode. + +The resource state that the memory pointed to must be in depends on the Mode parameter. For more information, see D3D12_RAYTRACING_ACCELERATION_STRUCTURE_COPY_MODE. + The type of copy operation to perform. For more information, see D3D12_RAYTRACING_ACCELERATION_STRUCTURE_COPY_MODE. + + + + + Defines the inputs for a raytracing acceleration structure build operation. This structure is used by ID3D12GraphicsCommandList4::BuildRaytracingAccelerationStructure and ID3D12Device5::GetRaytracingAccelerationStructurePrebuildInfo. + Microsoft Docs: + + + + The type of acceleration structure to build. + + + The build flags. + + + If Type is D3D12_RAYTRACING_ACCELERATION_STRUCTURE_TOP_LEVEL, this value is the number of instances, laid out based on DescsLayout. + +If Type is D3D12_RAYTRACING_ACCELERATION_STRUCTURE_BOTTOM_LEVEL, this value is the number of elements referred to by pGeometryDescs or ppGeometryDescs. Which of these fields is used depends on DescsLayout. + + + How geometry descriptions are specified; either an array of descriptions or an array of pointers to descriptions. + + + If Type is D3D12_RAYTRACING_ACCELERATION_STRUCTURE_TOP_LEVEL, this refers to NumDescsD3D12_RAYTRACING_INSTANCE_DESC structures in GPU memory describing instances. Each instance must be aligned to 16 bytes, defined as D3D12_RAYTRACING_INSTANCE_DESC_BYTE_ALIGNMENT. + +If Type is not D3D12_RAYTRACING_ACCELERATION_STRUCTURE_TOP_LEVEL, this parameter is unused. + +If DescLayout is D3D12_ELEMENTS_LAYOUT_ARRAY, InstanceDescs points to an array of instance descriptions in GPU memory. + +If DescLayout is D3D12_ELEMENTS_LAYOUT_ARRAY_OF_POINTERS, InstanceDescs points to an array in GPU memory of D3D12_GPU_VIRTUAL_ADDRESS pointers to instance descriptions. + +The memory pointed to must be in state D3D12_RESOURCE_STATE_NON_PIXEL_SHADER_RESOURCE. + + + If Type is D3D12_RAYTRACING_ACCELERATION_STRUCTURE_BOTTOM_LEVEL, and DescsLayout is D3D12_ELEMENTS_LAYOUT_ARRAY, this field is used and points to NumDescs contiguous D3D12_RAYTRACING_GEOMETRY_DESC structures on the CPU, describing individual geometries. + +If Type is not D3D12_RAYTRACING_ACCELERATION_STRUCTURE_BOTTOM_LEVEL or DescsLayout is not D3D12_ELEMENTS_LAYOUT_ARRAY, this parameter is unused. + + + If Type is D3D12_RAYTRACING_ACCELERATION_STRUCTURE_BOTTOM_LEVEL, and DescsLayout is D3D12_ELEMENTS_LAYOUT_ARRAY_OF_POINTERS, this field is used and points to an array of NumDescs pointers to D3D12_RAYTRACING_GEOMETRY_DESC structures on the CPU, describing individual geometries. + + + + Specifies a type of resource barrier (transition in resource use) description. + Microsoft Docs: + + + + A transition barrier that indicates a transition of a set of subresources between different usages. The caller must specify the before and after usages of the subresources. + + + An aliasing barrier that indicates a transition between usages of 2 different resources that have mappings into the same tile pool. The caller can specify both the before and the after resource. Note that one or both resources can be NULL, which indicates that any tiled resource could cause aliasing. + + + An unordered access view (UAV) barrier that indicates all UAV accesses (reads or writes) to a particular resource must complete before any future UAV accesses (read or write) can begin. + + + + Gets a shader-reflection-variable type by name. + Microsoft Docs: + Member name. + + + + + Enables the debug layer. + Microsoft Docs: + + + + + Describes a video extension command. + Microsoft Docs: + + + + The unique identifier for the video extension command. + + + A pointer to a wide string containing the name of the command. + + + A member of the D3D12_COMMAND_LIST_SUPPORT_FLAGS enumeration. Indicates the video command queue that the video extension targets. Only one value from the enumeration can be set. + + + + Describes stencil operations that can be performed based on the results of stencil test. + Microsoft Docs: + + + + A D3D12_STENCIL_OP-typed value that identifies the stencil operation to perform when stencil testing fails. + + + A D3D12_STENCIL_OP-typed value that identifies the stencil operation to perform when stencil testing passes and depth testing fails. + + + A D3D12_STENCIL_OP-typed value that identifies the stencil operation to perform when stencil testing and depth testing both pass. + + + A D3D12_COMPARISON_FUNC-typed value that identifies the function that compares stencil data against existing stencil data. + + + + Represents a virtual adapter; it is used to create command allocators, command lists, command queues, fences, resources, pipeline state objects, heaps, root signatures, samplers, and many resource views. + Microsoft Docs: + + + + + Defines constants that specify heap serialization support. + Microsoft Docs: + + + + Indicates that heap serialization is not supported. + + + Indicates that heap serialization is supported. Your application can serialize resource data in heaps through copying APIs such as CopyResource, without necessarily requiring an explicit [state transition](/windows/desktop/direct3d12/using-resource-barriers-to-synchronize-resource-states-in-direct3d-12#implicit-state-transitions) of resources on those heaps. + + + + Enables or disables dependent command queue synchronization when using a D3D12 device with the debug layer enabled. + Microsoft Docs: + TRUE to enable Dependent Command Queue Synchronization, otherwise FALSE. + + + + + Describes the subresources from a resource that are accessible by using a render-target view. + Microsoft Docs: + + + + A DXGI_FORMAT-typed value that specifies the viewing format. + + + A D3D12_RTV_DIMENSION-typed value that specifies how the render-target resource will be accessed. This type specifies how the resource will be accessed. This member also determines which _RTV to use in the following union. + + + A D3D12_BUFFER_RTV structure that specifies which buffer elements can be accessed. + + + A D3D12_TEX1D_RTV structure that specifies the subresources in a 1D texture that can be accessed. + + + A D3D12_TEX1D_ARRAY_RTV structure that specifies the subresources in a 1D texture array that can be accessed. + + + A D3D12_TEX2D_RTV structure that specifies the subresources in a 2D texture that can be accessed. + + + A D3D12_TEX2D_ARRAY_RTV structure that specifies the subresources in a 2D texture array that can be accessed. + + + A D3D12_TEX2DMS_RTV structure that specifies a single subresource because a multisampled 2D texture only contains one subresource. + + + A D3D12_TEX2DMS_ARRAY_RTV structure that specifies the subresources in a multisampled 2D texture array that can be accessed. + + + A D3D12_TEX3D_RTV structure that specifies subresources in a 3D texture that can be accessed. + + + + Emits post-build properties for a set of acceleration structures. This enables applications to know the output resource requirements for performing acceleration structure operations via ID3D12GraphicsCommandList4::CopyRaytracingAccelerationStructure. + Microsoft Docs: + Description of pos-tbuild information to generate. + Number of pointers to acceleration structure GPU virtual addresses pointed to by pSourceAccelerationStructureData. This number also affects the destination (output), which will be a contiguous array of NumSourceAccelerationStructures output structures, where the type of the structures depends on InfoType field of the supplied in the pDesc description. + Pointer to array of GPU virtual addresses of size NumSourceAccelerationStructures. + +The address must be aligned to 256 bytes, defined as D3D12_RAYTRACING_ACCELERATION_STRUCTURE_BYTE_ALIGNMENT. + +The memory pointed to must be in state D3D12_RESOURCE_STATE_RAYTRACING_ACCELERATION_STRUCTURE. + + + + + Adds a user-defined message to the message queue and sends that message to debug output. + Microsoft Docs: + Severity of a message. + Specifies the message string. + + + + + Flags passed to the TraceRay function to override transparency, culling, and early-out behavior. + Microsoft Docs: + + + + No options selected. + + + All ray-primitive intersections encountered in a raytrace are treated as opaque. So no any hit shaders will be executed regardless of whether or not the hit geometry specifies D3D12_RAYTRACING_GEOMETRY_FLAG_OPAQUE, and regardless of the instance flags on the instance that was hit. + +This flag is mutually exclusive with RAY_FLAG_FORCE_NON_OPAQUE, RAY_FLAG_CULL_OPAQUE and RAY_FLAG_CULL_NON_OPAQUE. + + + All ray-primitive intersections encountered in a raytrace are treated as non-opaque. So any hit shaders, if present, will be executed regardless of whether or not the hit geometry specifies D3D12_RAYTRACING_GEOMETRY_FLAG_OPAQUE, and regardless of the instance flags on the instance that was hit. This flag is mutually exclusive with RAY_FLAG_FORCE_\OPAQUE, RAY_FLAG_CULL_OPAQUE and RAY_FLAG_CULL_NON_OPAQUE. + + + The first ray-primitive intersection encountered in a raytrace automatically causes AcceptHitAndEndSearch to be called immediately after the any hit shader, including if there is no any hit shader. + +The only exception is when the preceding any hit shader calls IgnoreHit, in which case the ray continues unaffected such that the next hit becomes another candidate to be the first hit. For this exception to apply, the any hit shader has to actually be executed. So if the any hit shader is skipped because the hit is treated as opaque (e.g. due to RAY_FLAG_FORCE_OPAQUE or D3D12_RAYTRACING_GEOMETRY_FLAG_OPAQUE or D3D12_RAYTRACING_INSTANCE_FLAG_OPAQUE being set), then AcceptHitAndEndSearch is called. + +If a closest hit shader is present at the first hit, it gets invoked unless RAY_FLAG_SKIP_CLOSEST_HIT_SHADER is also present. The one hit that was found is considered “closest”, even though other potential hits that might be closer on the ray may not have been visited. + +A typical use for this flag is for shadows, where only a single hit needs to be found. + + + Even if at least one hit has been committed, and the hit group for the closest hit contains a closest hit shader, skip execution of that shader. + + + Enables culling of back facing triangles. See D3D12_RAYTRACING_INSTANCE_FLAGS for selecting which triangles are back facing, per-instance. + +On instances that specify D3D12_RAYTRACING_INSTANCE_FLAG_TRIANGLE_CULL_DISABLE, this flag has no effect. + +On geometry types other than D3D12_RAYTRACING_GEOMETRY_TYPE_TRIANGLES, this flag has no effect. + +This flag is mutually exclusive with RAY_FLAG_CULL_FRONT_FACING_TRIANGLES. + + + Enables culling of front facing triangles. See D3D12_RAYTRACING_INSTANCE_FLAGS for selecting which triangles are back facing, per-instance. + +On instances that specify D3D12_RAYTRACING_INSTANCE_FLAG_TRIANGLE_CULL_DISABLE, this flag has no effect. + +On geometry types other than D3D12_RAYTRACING_GEOMETRY_TYPE_TRIANGLES, this flag has no effect. + +This flag is mutually exclusive with RAY_FLAG_CULL_FRONT_FACING_TRIANGLES. + + + Culls all primitives that are considered opaque based on their geometry and instance flags. + +This flag is mutually exclusive with RAY_FLAG_FORCE_OPAQUE, RAY_FLAG_FORCE_NON_OPAQUE, and RAY_FLAG_CULL_NON_OPAQUE. + + + Culls all primitives that are considered non-opaque based on their geometry and instance flags. + +This flag is mutually exclusive with RAY_FLAG_FORCE_OPAQUE, RAY_FLAG_FORCE_NON_OPAQUE, and RAY_FLAG_CULL_OPAQUE. + + + + Manages a query heap. A query heap holds an array of queries, referenced by indexes. + Microsoft Docs: + + + + + Enables the page-out of data, which precludes GPU access of that data. + Microsoft Docs: + The number of objects in the ppObjects array to evict from the device. + A pointer to a memory block that contains an array of ID3D12Pageable interface pointers for the objects. + + +Even though most D3D12 objects inherit from ID3D12Pageable, residency changes are only supported on the following objects: +Descriptor Heaps, Heaps, Committed Resources, and Query Heaps + + + + + Describes the level of support for shader caching in the current graphics driver. + Microsoft Docs: + + + + Indicates that the driver does not support shader caching. + + + Indicates that the driver supports the CachedPSO member of the D3D12_GRAPHICS_PIPELINE_STATE_DESC and D3D12_COMPUTE_PIPELINE_STATE_DESC structures. This is always supported. + + + Indicates that the driver supports the ID3D12PipelineLibrary interface, which provides application-controlled PSO grouping and caching. This is supported by drivers targetting the Windows 10 Anniversary Update. + + + Indicates that the driver supports an OS-managed shader cache that stores compiled shaders in memory during the current run of the application. + + + Indicates that the driver supports an OS-managed shader cache that stores compiled shaders on disk to accelerate future runs of the application. + + + + Signals a shared fence between the D3D layers and diagnostics tools. + Microsoft Docs: + A pointer to the shared fence to signal. + An unsigned 64bit value to signal the shared fence with. + + + + + Retrieves the list of video extension commands from the driver. + Microsoft Docs: + + + + For single GPU operation, set this to zero. If there are multiple GPU nodes, set a bit to identify the node (the device's physical adapter) to which the command queue applies. Each bit in the mask corresponds to a single node. Only 1 bit may be set. + + + The supported number of video extension commands. This value must be the count returned by a call to[ID3D12VideoDevice::CheckFeatureSupport](nf-d3d12video-id3d12videodevice-checkfeaturesupport.md) with D3D12_FEATURE_VIDEO_EXTENSION_COMMAND_COUNT specified as the feature. + + + Receives a list of D3D12_VIDEO_EXTENSION_COMMAND_INFO structures describing video extension commands. + + + + Indicates the level of support that the adapter provides for depth-bounds tests and programmable sample positions. + Microsoft Docs: + + + + SAL: _Out_ + +On return, contains true if depth-bounds tests are supported; otherwise, false. + + + SAL: _Out_ + +On return, contains a value that indicates the level of support offered for programmable sample positions. + + + + Gets the reason that the device was removed. + Microsoft Docs: + + + + + Describes the arguments (parameters) of a command signature. + Microsoft Docs: + + + + Specifies the size of each argument of a command signature, in bytes. + + + Specifies the number of arguments in the command signature. + + + An array of D3D12_INDIRECT_ARGUMENT_DESC structures, + containing details of the arguments, including whether the argument is a vertex buffer, constant, constant buffer view, shader resource view, or unordered access view. + + + For single GPU operation, set this to zero. If there are multiple GPU nodes, set bits to identify the nodes (the device's physical adapters) for which the command signature is to apply. + Each bit in the mask corresponds to a single node. + Refer to Multi-adapter systems. + + + + Describes the width, height, format, and color space of a picture buffer. + Microsoft Docs: + + + + The width of the sample. + + + The height of the sample. + + + A D3D12_VIDEO_FORMAT structure describing the format and colorspace of the sample. + + + + Specifies a type of descriptor heap. + Microsoft Docs: + + + + The descriptor heap for the combination of constant-buffer, shader-resource, and unordered-access views. + + + The descriptor heap for the sampler. + + + The descriptor heap for the render-target view. + + + The descriptor heap for the depth-stencil view. + + + The number of types of descriptor heaps. + + + + Returns the ID3D12ShaderReflectionConstantBuffer of the present ID3D12ShaderReflectionVariable. + Microsoft Docs: + + + + + Flags to control pipeline state. + Microsoft Docs: + + + + Indicates no flags. + + + Indicates that the pipeline state should be compiled with additional information to assist debugging. + This can only be set on WARP devices. + + + + Describes the subresource from a multi sampled 2D texture to use in a render-target view. + Microsoft Docs: + + + + Integer of any value. See remarks. + + + + Specifies options for working with resources. + Microsoft Docs: + + + + No options are specified. + + + Allows a render target view to be created for the resource, as well as enables the resource to transition into the state of D3D12_RESOURCE_STATE_RENDER_TARGET. Some adapter architectures allocate extra memory for textures with this flag to reduce the effective bandwidth during common rendering. This characteristic may not be beneficial for textures that are never rendered to, nor is it available for textures compressed with BC formats. Applications should avoid setting this flag when rendering will never occur. + + +The following restrictions and interactions apply: + +
    +
  • Either the texture format must support render target capabilities at the current feature level. Or, when the format is a typeless format, a format within the same typeless group must support render target capabilities at the current feature level.
    • +
  • Cannot be set in conjunction with textures that have D3D12_TEXTURE_LAYOUT_ROW_MAJOR when D3D12_FEATURE_DATA_D3D12_OPTIONS::CrossAdapterRowMajorTextureSupported is FALSE nor in conjunction with textures that have D3D12_TEXTURE_LAYOUT_64KB_STANDARD_SWIZZLE when D3D12_FEATURE_DATA_D3D12_OPTIONS::StandardSwizzle64KBSupported is FALSE. +
    • +
  • Cannot be used with 4KB alignment, D3D12_RESOURCE_FLAG_ALLOW_DEPTH_STENCIL, nor usage with heaps that have D3D12_HEAP_FLAG_DENY_RT_DS_TEXTURES.
    • +
 + + + Allows a depth stencil view to be created for the resource, as well as enables the resource to transition into the state of D3D12_RESOURCE_STATE_DEPTH_WRITE and/or D3D12_RESOURCE_STATE_DEPTH_READ. Most adapter architectures allocate extra memory for textures with this flag to reduce the effective bandwidth and maximize optimizations for early depth-test. Applications should avoid setting this flag when depth operations will never occur. + + +The following restrictions and interactions apply: + +
    +
  • Either the texture format must support depth stencil capabilities at the current feature level. Or, when the format is a typeless format, a format within the same typeless group must support depth stencil capabilities at the current feature level.
    • +
  • Cannot be used with D3D12_RESOURCE_DIMENSION_BUFFER, 4KB alignment, D3D12_RESOURCE_FLAG_ALLOW_RENDER_TARGET, D3D12_RESOURCE_FLAG_ALLOW_UNORDERED_ACCESS, D3D12_RESOURCE_FLAG_ALLOW_SIMULTANEOUS_ACCESS, D3D12_TEXTURE_LAYOUT_64KB_STANDARD_SWIZZLE, D3D12_TEXTURE_LAYOUT_ROW_MAJOR, nor used with heaps that have D3D12_HEAP_FLAG_DENY_RT_DS_TEXTURES or D3D12_HEAP_FLAG_ALLOW_DISPLAY. +
    • +
  • Precludes usage of WriteToSubresource and ReadFromSubresource. +
    • +
  • Precludes GPU copying of a subregion. CopyTextureRegion must copy a whole subresource to or from resources with this flag.
    • +
 + + + Allows an unordered access view to be created for the resource, as well as enables the resource to transition into the state of D3D12_RESOURCE_STATE_UNORDERED_ACCESS. Some adapter architectures must resort to less efficient texture layouts in order to provide this functionality. If a texture is rarely used for unordered access, it may be worth having two textures around and copying between them. One texture would have this flag, while the other wouldn't. Applications should avoid setting this flag when unordered access operations will never occur. + + +The following restrictions and interactions apply: + +
    +
  • Either the texture format must support unordered access capabilities at the current feature level. Or, when the format is a typeless format, a format within the same typeless group must support unordered access capabilities at the current feature level. +
    • +
  • Cannot be set in conjunction with textures that have D3D12_TEXTURE_LAYOUT_ROW_MAJOR when D3D12_FEATURE_DATA_D3D12_OPTIONS::CrossAdapterRowMajorTextureSupported is FALSE nor in conjunction with textures that have D3D12_TEXTURE_LAYOUT_64KB_STANDARD_SWIZZLE when D3D12_FEATURE_DATA_D3D12_OPTIONS::StandardSwizzle64KBSupported is FALSE, nor when the feature level is less than 11.0. +
    • +
  • Cannot be used with MSAA textures.
    • +
 + + + Disallows a shader resource view to be created for the resource, as well as disables the resource to transition into the state of D3D12_RESOURCE_STATE_NON_PIXEL_SHADER_RESOURCE or D3D12_RESOURCE_STATE_PIXEL_SHADER_RESOURCE. Some adapter architectures experience increased bandwidth for depth stencil textures when shader resource views are precluded. If a texture is rarely used for shader resource, it may be worth having two textures around and copying between them. One texture would have this flag and the other wouldn't. Applications should set this flag when depth stencil textures will never be used from shader resource views. + + +The following restrictions and interactions apply: + + +
    +
  • Must be used with D3D12_RESOURCE_FLAG_ALLOW_DEPTH_STENCIL. +
    • +
 + + + Allows the resource to be used for cross-adapter data, as well as the same features enabled by ALLOW_SIMULTANEOUS_ACCESS. Cross adapter resources commonly preclude techniques that reduce effective texture bandwidth during usage, and some adapter architectures may require different caching behavior. Applications should avoid setting this flag when the resource data will never be used with another adapter. + +The following restrictions and interactions apply: + + +
    +
  • Must be used with heaps that have D3D12_HEAP_FLAG_SHARED_CROSS_ADAPTER.
    • +
  • Cannot be used with heaps that have D3D12_HEAP_FLAG_ALLOW_DISPLAY.
    • +
 + + + Allows a resource to be simultaneously accessed by multiple different queues, devices or processes (for example, allows a resource to be used with ResourceBarrier transitions performed in more than one command list + executing at the same time). + +Simultaneous access allows multiple readers and one writer, as long as the writer doesn't concurrently modify the texels that other readers are accessing. Some adapter architectures cannot leverage techniques to reduce effective texture bandwidth during usage. + +However, applications should avoid setting this flag when multiple readers are not required during frequent, non-overlapping writes to textures. Use of this flag can compromise resource fences to perform waits, and prevents any compression being used with a resource. + +These restrictions and interactions apply. + +- Can't be used with D3D12_RESOURCE_DIMENSION_BUFFER; but buffers always have the properties represented by this flag. +- Can't be used with MSAA textures. +- Can't be used with [D3D12_RESOURCE_FLAG_ALLOW_DEPTH_STENCIL](). + + + This resource may only be used as a decode reference frame. It may only be written to or read by the video decode operation. + +D3D12_VIDEO_DECODE_TIER_1 and D3D12_VIDEO_DECODE_TIER_2 may report D3D12_VIDEO_DECODE_CONFIGURATION_FLAG_REFERENCE_ONLY_ALLOCATIONS_REQUIRED in the D3D12_FEATURE_DATA_VIDEO_DECODE_SUPPORT structure configuration flag. If so, the application must allocate reference frames with the new D3D12\_RESOURCE\_VIDEO\_DECODE\_REFERENCE\_ONLY resource flag. D3D12_VIDEO_DECODE_TIER_3 must not set the [D3D12_VIDEO_DECODE_CONFIGURATION_FLAG_REFERENCE_ONLY_ALLOCATIONS_REQUIRED] +(../d3d12video/ne-d3d12video-d3d12_video_decode_configuration_flags)) configuration flag and must not require the use of this resource flag. + + + + Atomically copies a primary data element of type UINT from one resource to another, along with optional dependent resources. + Microsoft Docs: + SAL: _In_ + +The resource that the UINT primary data element is copied into. + An offset into the destination resource buffer that specifies where the primary data element is copied into, in bytes. This offset combined with the base address of the resource buffer must result in a memory address that's naturally aligned for UINT values. + SAL: _In_ + +The resource that the UINT primary data element is copied from. This data is typically an address, index, or other handle that shader code can use to locate the most-recent version of latency-sensitive information. + An offset into the source resource buffer that specifies where the primary data element is copied from, in bytes. This offset combined with the base address of the resource buffer must result in a memory address that's naturally aligned for UINT values. + The number of dependent resources. + SAL: _In_reads_(Dependencies) + +An array of resources that contain the dependent elements of the data payload. + SAL: _In_reads_(Dependencies) + +An array of subresource ranges that specify the dependent elements of the data payload. These elements are completely updated before the primary data element is itself atomically copied. This ensures that the entire operation is logically atomic; that is, the primary data element never refers to an incomplete data payload. + + + + + Represents a meta command. A meta command is a Direct3D 12 object representing an algorithm that is accelerated by independent hardware vendors (IHVs). It's an opaque reference to a command generator that is implemented by the driver. + Microsoft Docs: + + + + + Specifies the result of a call to ID3D12Device5::CheckDriverMatchingIdentifier which queries whether serialized data is compatible with the current device and driver version. + Microsoft Docs: + + + + Serialized data is compatible with the current device/driver. + + + The specified D3D12_SERIALIZED_DATA_TYPE specified is unknown or unsupported. + + + Format of the data in D3D12_SERIALIZED_DATA_DRIVER_MATCHING_IDENTIFIER is unrecognized. This could indicate either corrupt data or the identifier was produced by a different hardware vendor. + + + Serialized data is recognized, but its version is not compatible with the current driver. This result may indicate that the device is from the same hardware vendor but is an incompatible version. + + + D3D12_SERIALIZED_DATA_TYPE specifies a data type that is not compatible with the type of serialized data. As long as there is only a single defined serialized data type this error cannot not be produced. + + + + Defines constants that specify a cross-API sharing support tier. + Microsoft Docs: + + + + Specifies that the most basic level of cross-API sharing is supported, including the following resource data formats. + +* DXGI_FORMAT_R8G8B8A8_UNORM +* DXGI_FORMAT_R8G8B8A8_UNORM_SRGB +* DXGI_FORMAT_B8G8R8A8_UNORM +* DXGI_FORMAT_B8G8R8A8_UNORM_SRGB +* DXGI_FORMAT_B8G8R8X8_UNORM +* DXGI_FORMAT_B8G8R8X8_UNORM_SRGB +* DXGI_FORMAT_R10G10B10A2_UNORM +* DXGI_FORMAT_R16G16B16A16_FLOAT + + + Specifies that cross-API sharing functionality of Tier 0 is supported, plus the following formats. + +* DXGI_FORMAT_R16G16B16A16_TYPELESS +* DXGI_FORMAT_R10G10B10A2_TYPELESS +* DXGI_FORMAT_R8G8B8A8_TYPELESS +* DXGI_FORMAT_R8G8B8X8_TYPELESS +* DXGI_FORMAT_R16G16_TYPELESS +* DXGI_FORMAT_R8G8_TYPELESS +* DXGI_FORMAT_R32_TYPELESS +* DXGI_FORMAT_R16_TYPELESS +* DXGI_FORMAT_R8_TYPELESS + +This level support is built into WDDM 2.4. + +Also see [Extended support for shared Texture2D resources](/windows/win32/direct3d11/direct3d-11-1-features#extended-support-for-shared-texture2d-resources). + + + Specifies that cross-API sharing functionality of Tier 1 is supported, plus the following formats. + +* DXGI_FORMAT_NV12 (also see [Extended NV12 texture support](/windows/win32/direct3d11/direct3d-11-4-features#extended-nv12-texture-support)) + + + Specifies that cross-API sharing functionality of Tier 2 is supported, plus the following formats. + +* DXGI_FORMAT_R11G11B10_FLOAT + + + + Describes a video extension command. + Microsoft Docs: + + + + For single GPU operation, set this to zero. If there are multiple GPU nodes, set a bit to identify the node (the device's physical adapter) to which the command queue applies. Each bit in the mask corresponds to a single node. Only 1 bit may be set. + + + The unique identifier for the video extension command. + + + + Specifies the type of access that an application is given to the specified resource(s) at the transition into a render pass. + Microsoft Docs: + + + + Indicates that your application doesn't have any dependency on the prior contents of the resource(s). You also shouldn't have any expectations about those contents, because a display driver may return the previously-written contents, or it may return uninitialized data. You can be assured that reading from the resource(s) won't hang the GPU, even if you do get undefined data back. +A read is defined as a traditional read from an unordered access view (UAV), a shader resource view (SRV), a constant buffer view (CBV), a vertex buffer view (VBV), an index buffer view (IBV), an IndirectArg binding/read, or a blend/depth-testing-induced read. + + + Indicates that your application has a dependency on the prior contents of the resource(s), so the contents must be loaded from main memory. + + + Indicates that your application needs the resource(s) to be cleared to a specific value (a value that your application specifies). This clear occurs whether or not you interact with the resource(s) during the render pass. You specify the clear value at +BeginRenderPass time, in the Clear member of your D3D12_RENDER_PASS_BEGINNING_ACCESS structure. + + + Indicates that your application will neither read from nor write to the resource(s) during the render pass. You would most likely use this value to indicate that you won't be accessing the depth/stencil plane for a depth/stencil view (DSV). You must pair this value with D3D12_RENDER_PASS_ENDING_ACCESS_TYPE_NO_ACCESS in the corresponding D3D12_RENDER_PASS_ENDING_ACCESS structure. + + + + Enables the debug layer. + Microsoft Docs: + + + + + Describes the space currently used by an acceleration structure.. + Microsoft Docs: + + + + Space currently used by an acceleration structure. If the acceleration structure hasn’t had a compaction operation performed on it, this size is the same one reported by GetRaytracingAccelerationStructurePrebuildInfo, and if it has been compacted this size is the same reported for post-build info with D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_COMPACTED_SIZE. + + + + Specifies the type of heap. When resident, heaps reside in a particular physical memory pool with certain CPU cache properties. + Microsoft Docs: + + + + Specifies the default heap. + This heap type experiences the most bandwidth for the GPU, but cannot provide CPU access. + The GPU can read and write to the memory from this pool, and resource transition barriers may be changed. + The majority of heaps and resources are expected to be located here, and are typically populated through resources in upload heaps. + + + Specifies a heap used for uploading. + This heap type has CPU access optimized for uploading to the GPU, but does not experience the maximum amount of bandwidth for the GPU. + This heap type is best for CPU-write-once, GPU-read-once data; but GPU-read-once is stricter than necessary. + GPU-read-once-or-from-cache is an acceptable use-case for the data; but such usages are hard to judge due to differing GPU cache designs and sizes. + If in doubt, stick to the GPU-read-once definition or profile the difference on many GPUs between copying the data to a _DEFAULT heap vs. reading the data from an _UPLOAD heap. + + +Resources in this heap must be created with D3D12_RESOURCE_STATE_GENERIC_READ and cannot be changed away from this. + The CPU address for such heaps is commonly not efficient for CPU reads. + + +The following are typical usages for _UPLOAD heaps: + + +
    +
  • Initializing resources in a _DEFAULT heap with data from the CPU. +
    • +
  • Uploading dynamic data in a constant buffer that is read, repeatedly, by each vertex or pixel. +
    • +
+The following are likely not good usages for _UPLOAD heaps: + + +
    +
  • Re-initializing the contents of a resource every frame. +
    • +
  • Uploading constant data which is only used every other Draw call, where each Draw uses a non-trivial amount of other data. +
    • +
 + + + Specifies a heap used for reading back. + This heap type has CPU access optimized for reading data back from the GPU, but does not experience the maximum amount of bandwidth for the GPU. + This heap type is best for GPU-write-once, CPU-readable data. + The CPU cache behavior is write-back, which is conducive for multiple sub-cache-line CPU reads. + + +Resources in this heap must be created with D3D12_RESOURCE_STATE_COPY_DEST, and cannot be changed away from this. + + + Specifies a custom heap. + The application may specify the memory pool and CPU cache properties directly, which can be useful for UMA optimizations, multi-engine, multi-adapter, or other special cases. + To do so, the application is expected to understand the adapter architecture to make the right choice. + For more details, see + D3D12_FEATURE_ARCHITECTURE, + D3D12_FEATURE_DATA_ARCHITECTURE, and + GetCustomHeapProperties. + + + + Represents a Direct3D 12 video decoder that contains resolution-independent resources and state for performing the decode operation. Adds support for protected resources. + Microsoft Docs: + + + + + Retrieves the requested PSO from the library. + Microsoft Docs: + The unique name of the PSO. + Specifies a description of the required PSO in a D3D12_GRAPHICS_PIPELINE_STATE_DESC structure. This input description is matched against the data in the current library database, and stored in order to prevent duplication of PSO contents. + Specifies a REFIID for the ID3D12PipelineState object. Typically set this, and the following parameter, with the macro IID_PPV_ARGS(&PSO1), where PSO1 is the name of the object. + Specifies a pointer that will reference the returned PSO. + + + + + Describes the shape of a tile by specifying its dimensions. + Microsoft Docs: + + + + The width in texels of the tile. + + + The height in texels of the tile. + + + The depth in texels of the tile. + + + + Description of the post-build information to generate from an acceleration structure. Use this structure in calls to EmitRaytracingAccelerationStructurePostbuildInfo and BuildRaytracingAccelerationStructure. + Microsoft Docs: + + + + Storage for the post-build info result. Size required and the layout of the contents written by the system depend on the value of the InfoType field. + +The memory pointed to must be in state D3D12_RESOURCE_STATE_UNORDERED_ACCESS. The memory must be aligned to the natural alignment for the members of the particular output structure being generated (e.g. 8 bytes for a struct with the largest members being UINT64). + + + The type of post-build information to retrieve. + + + + Describes parameters for drawing indexed instances. + Microsoft Docs: + + + + The number of indices read from the index buffer for each instance. + + + The number of instances to draw. + + + The location of the first index read by the GPU from the index buffer. + + + A value added to each index before reading a vertex from the vertex buffer. + + + A value added to each index before reading per-instance data from a vertex buffer. + + + + Indicates whether a shader is a sample frequency shader. + Microsoft Docs: + + + + + Allow or deny certain types of messages to pass through a filter. + Microsoft Docs: + + + + Number of message categories to allow or deny. + + + Array of message categories to allow or deny. Array must have at least NumCategories members (see D3D12_MESSAGE_CATEGORY). + + + Number of message severity levels to allow or deny. + + + Array of message severity levels to allow or deny. Array must have at least NumSeverities members (see D3D12_MESSAGE_SEVERITY). + + + Number of message IDs to allow or deny. + + + Array of message IDs to allow or deny. Array must have at least NumIDs members (see D3D12_MESSAGE_ID). + + + + Reports the compatibility of serialized data, such as a serialized raytracing acceleration structure resulting from a call to CopyRaytracingAccelerationStructure with mode D3D12_RAYTRACING_ACCELERATION_STRUCTURE_COPY_MODE_SERIALIZE, with the current device/driver. + Microsoft Docs: + The type of the serialized data. For more information, see D3D12_SERIALIZED_DATA_TYPE. + Identifier from the header of the serialized data to check with the driver. For more information, see D3D12_SERIALIZED_DATA_DRIVER_MATCHING_IDENTIFIER. + + + + + Describes a 3D box. + Microsoft Docs: + + + + The x position of the left hand side of the box. + + + The y position of the top of the box. + + + The z position of the front of the box. + + + The x position of the right hand side of the box, plus 1. This means that right - left equals the width of the box. + + + The y position of the bottom of the box, plus 1. This means that bottom - top equals the height of the box. + + + The z position of the back of the box, plus 1. This means that back - front equals the depth of the box. + + + + Provides data for calls to ID3D12VideoDevice::CheckFeatureSupport when the feature specified is D3D12_FEATURE_VIDEO_MOTION_ESTIMATOR. Retrieves the motion estimation capabilities for a video encoder. + Microsoft Docs: + + + + In multi-adapter operation, identifies the physical adapter of the device this operation applies to. + + + A DXGI_FORMAT structure specifying the format of the input resources. + + + A bitwise OR combination of values from the D3D12_VIDEO_MOTION_ESTIMATOR_SEARCH_BLOCK_SIZE_FLAGS enumeration specifying the encoder's supported search block sizes for motion estimation. + + + A bitwise OR combination of values from the D3D12_VIDEO_MOTION_ESTIMATOR_VECTOR_PRECISION_FLAGS enumeration specifying the encoder's supported vector precision for motion estimation. + + + A D3D12_VIDEO_SIZE_RANGE structure representing the minimum and maximum input size supported by the driver. The driver sets the fields of this structure to zero if motion estimation is unsupported. + + + + Specifies whether a video decoding operation is supported. + Microsoft Docs: + + + + The video decoding operation isn't supported. + + + The video decoding operation is supported. + + + + Specifies the type of the indirect parameter. + Microsoft Docs: + + + + Indicates the type is a Draw call. + + + Indicates the type is a DrawIndexed call. + + + Indicates the type is a Dispatch call. + + + Indicates the type is a vertex buffer view. + + + Indicates the type is an index buffer view. + + + Indicates the type is a constant. + + + Indicates the type is a constant buffer view (CBV). + + + Indicates the type is a shader resource view (SRV). + + + Indicates the type is an unordered access view (UAV). + + + + Creates a graphics pipeline state object. + Microsoft Docs: + A pointer to a D3D12_GRAPHICS_PIPELINE_STATE_DESC structure that describes graphics pipeline state. + The globally unique identifier (GUID) for the pipeline state interface (ID3D12PipelineState). + The REFIID, or GUID, of the interface to the pipeline state can be obtained by using the __uuidof() macro. + For example, __uuidof(ID3D12PipelineState) will get the GUID of the interface to a pipeline state. + A pointer to a memory block that receives a pointer to the ID3D12PipelineState interface for the pipeline state object. + The pipeline state object is an immutable state object. It contains no methods. + + + + + Copy a multi-sampled resource into a non-multi-sampled resource. + Microsoft Docs: + Destination resource. Must be a created on a D3D12_HEAP_TYPE_DEFAULT heap and be single-sampled. See ID3D12Resource. + A zero-based index, that identifies the destination subresource. Use D3D12CalcSubresource to calculate the subresource index if the parent resource is complex. + Source resource. Must be multisampled. + The source subresource of the source resource. + A DXGI_FORMAT that indicates how the multisampled resource will be resolved to a single-sampled resource. See remarks. + + + + + A library-reflection interface accesses library info. + Microsoft Docs: + + + + + Push a copy of retrieval filter currently on the top of the retrieval-filter stack onto the retrieval-filter stack. + Microsoft Docs: + + + + + Describes parameters for drawing instances. + Microsoft Docs: + + + + Specifies the number of vertices to draw, per instance. + + + Specifies the number of instances. + + + Specifies an index to the first vertex to start drawing from. + + + Specifies an index to the first instance to start drawing from. + + + + Describes the index buffer to view. + Microsoft Docs: + + + + The GPU virtual address of the index buffer. + D3D12_GPU_VIRTUAL_ADDRESS is a typedef'd synonym of UINT64. + + + The size in bytes of the index buffer. + + + A DXGI_FORMAT-typed value for the index-buffer format. + + + + Specifies flags for raytracing geometry in a D3D12_RAYTRACING_GEOMETRY_DESC structure. + Microsoft Docs: + + + + No options specified. + + + When rays encounter this geometry, the geometry acts as if no any hit shader is present. It is recommended that apps use this flag liberally, as it can enable important ray-processing optimizations. Note that this behavior can be overridden on a per-instance basis with D3D12_RAYTRACING_INSTANCE_FLAGS and on a per-ray basis using ray flags in TraceRay. + + + By default, the system is free to trigger an any hit shader more than once for a given ray-primitive intersection. This flexibility helps improve the traversal efficiency of acceleration structures in certain cases. For instance, if the acceleration structure is implemented internally with bounding volumes, the implementation may find it beneficial to store relatively long triangles in multiple bounding boxes rather than a larger single box. However, some application use cases require that intersections be reported to the any hit shader at most once. This flag enables that guarantee for the given geometry, potentially with some performance impact. + +This flag applies to all geometry types. + + + + The type of a state subobject. Use with D3D12_STATE_SUBOBJECT. + Microsoft Docs: + + + + Subobject type is D3D12_STATE_OBJECT_CONFIG. + + + Subobject type is D3D12_GLOBAL_ROOT_SIGNATURE. + + + Subobject type is D3D12_LOCAL_ROOT_SIGNATURE. + + + Subobject type is D3D12_NODE_MASK. + +> [!IMPORTANT] +> On some versions of the DirectX Runtime, specifying a node via [D3D12_NODE_MASK](/windows/win32/api/d3d12/ns-d3d12-d3d12_node_mask) in a [D3D12_STATE_SUBOBJECT](/windows/win32/api/d3d12/ns-d3d12-d3d12_state_subobject) with type D3D12_STATE_SUBOBJECT_TYPE_NODE_MASK, the runtime will incorrectly handle a node mask value of 0, which should use node #1, which will lead to errors when attempting to use the state object later. Specify an explicit node value of 1, or omit the [D3D12_NODE_MASK](/windows/win32/api/d3d12/ns-d3d12-d3d12_node_mask) subobject to avoid this issue. + + + Subobject type is D3D12_DXIL_LIBRARY_DESC. + + + Subobject type is D3D12_EXISTING_COLLECTION_DESC. + + + Subobject type is D3D12_SUBOBJECT_TO_EXPORTS_ASSOCIATION. + + + Subobject type is D3D12_DXIL_SUBOBJECT_TO_EXPORTS_ASSOCIATION. + + + Subobject type is D3D12_RAYTRACING_SHADER_CONFIG. + + + Subobject type is D3D12_RAYTRACING_PIPELINE_CONFIG. + + + Subobject type is D3D12_HIT_GROUP_DESC + + + The maximum valid subobject type value. + + + + A state subobject that represents a shader configuration. + Microsoft Docs: + + + + The maximum storage for scalars (counted as 4 bytes each) in ray payloads in raytracing pipelines that contain this program. + + + The maximum number of scalars (counted as 4 bytes each) that can be used for attributes in pipelines that contain this shader. The value cannot exceed D3D12_RAYTRACING_MAX_ATTRIBUTE_SIZE_IN_BYTES. + + + + Defines vector precision values for video motion estimation. + Microsoft Docs: + + + + The vector precision is quarter-pixel motion. + + + + Describes the level of shader caching supported in the current graphics driver. + Microsoft Docs: + + + + SAL: _Out_ + +Indicates the level of caching supported. + + + + Specifies the types of parameters for video extension commands. + Microsoft Docs: + + + + Unsigned 8-bit integer. + + + Unsigned 16-bit integer. + + + Unsigned 32-bit integer. + + + Unsigned 64-bit integer. + + + Signed 8-bit integer. + + + Signed 16-bit integer. + + + Signed 32-bit integer. + + + Signed 64-bit integer. + + + IEEE 32-bit floating point number + + + IEEE 64-bit floating point number + + + A D3D12DDI_HRESOURCE handle. The caller must use resource barriers to transition to the state appropriate for the parameter. + +| D3D12_COMMAND_LIST_SUPPORT_FLAGS value | Read | Write | +|-------------------|---------------------------|------------------------| +| D3D12_COMMAND_LIST_SUPPORT_FLAG_VIDEO_DECODE | D3D12_RESOURCE_STATE_VIDEO_DECODE_READ | D3D12_RESOURCE_STATE_VIDEO_DECODE_WRITE | +| D3D12_COMMAND_LIST_SUPPORT_FLAG_VIDEO_PROCESS | D3D12_RESOURCE_STATE_VIDEO_PROCESS_READ | D3D12_RESOURCE_STATE_VIDEO_PROCESS_WRITE | +| D3D12_COMMAND_LIST_SUPPORT_FLAG_VIDEO_ENCODE | D3D12_RESOURCE_STATE_VIDEO_ENCODE_READ | D3D12_RESOURCE_STATE_VIDEO_ENCODE_WRITE | + + + + Details the adapter's GPU virtual address space limitations, including maximum address bits per resource and per process. + Microsoft Docs: + + + + The maximum GPU virtual address bits per resource. + +Some adapters have significantly less bits available per resource than per process, while other adapters have significantly greater bits available per resource than per process. The latter scenario tends to happen in less common scenarios, like when running a 32-bit process on certain UMA adapters. +When per resource capabilities are greater than per process, the greater per resource capabilities can only be leveraged by reserved resources or NULL mapped pages. + + + The maximum GPU virtual address bits per process. + +When this value is nearly equal to the available residency budget, Evict will not be a feasible option to manage residency. See MakeResident for more details. + + + + Describes which resources are supported by the current graphics driver for a given format. + Microsoft Docs: + + + + A DXGI_FORMAT-typed value for the format to return info about. + + + A combination of D3D12_FORMAT_SUPPORT1-typed values that are combined by using a bitwise OR operation. The resulting value specifies which resources are supported. + + + A combination of D3D12_FORMAT_SUPPORT2-typed values that are combined by using a bitwise OR operation. The resulting value specifies which unordered resource options are supported. + + + + Returns the debug feature flags that have been set on a command list. + Microsoft Docs: + + + + + Gets optional device-wide Debug Layer settings. + Microsoft Docs: + Specifies a D3D12_DEBUG_DEVICE_PARAMETER_TYPE value that indicates which debug parameter data to set. + Points to the memory that will be filled with a copy of the debug parameter data. The interpretation of this data depends on the D3D12_DEBUG_DEVICE_PARAMETER_TYPE given in the Type parameter. + Size in bytes of the memory buffer pointed to by pData. + + + + + Specifies depth-stencil view options. + Microsoft Docs: + + + + Indicates a default view. + + + Indicates that depth values are read only. + + + Indicates that stencil values are read only. + + + + Describes the access to resource(s) that is requested by an application at the transition out of a render pass. + Microsoft Docs: + + + + A D3D12_RENDER_PASS_ENDING_ACCESS_TYPE. The type of access being requested. + + + A D3D12_RENDER_PASS_ENDING_ACCESS_RESOLVE_PARAMETERS. Appropriate when Type is D3D12_RENDER_PASS_ENDING_ACCESS_TYPE_RESOLVE. Description of the resource to resolve to. + + + + Gets an ID3D12ShaderReflectionType Interface interface containing the variable base class type. + Microsoft Docs: + + + + + Provides detail about whether the adapter supports creating heaps from existing system memory. + Microsoft Docs: + + + + TRUE if the adapter can create a heap from existing system memory. Otherwise, FALSE. + + + + Gets the function reflector. + Microsoft Docs: + The zero-based index of the function reflector to retrieve. + + + + + Represents prebuild information about a raytracing acceleration structure. Get an instance of this stucture by calling GetRaytracingAccelerationStructurePrebuildInfo. + Microsoft Docs: + + + + Size required to hold the result of an acceleration structure build based on the specified inputs. + + + Scratch storage on the GPU required during acceleration structure build based on the specified inputs. + + + + Defines constants that specify the shading rate (for variable-rate shading, or VRS). + Microsoft Docs: + + + + Specifies no change to the shading rate. + + + Specifies that the shading rate should reduce vertical resolution 2x. + + + Specifies that the shading rate should reduce horizontal resolution 2x. + + + Specifies that the shading rate should reduce the resolution of both axes 2x. + + + Specifies that the shading rate should reduce horizontal resolution 2x, and reduce vertical resolution 4x. + + + Specifies that the shading rate should reduce horizontal resolution 4x, and reduce vertical resolution 2x. + + + Specifies that the shading rate should reduce the resolution of both axes 4x. + + + + Describes an array of unordered-access 1D texture resources. + Microsoft Docs: + + + + The mipmap slice index. + + + The zero-based index of the first array slice to be accessed. + + + The number of slices in the array. + + + + Gets application-defined data from a device object. + Microsoft Docs: + The GUID that is associated with the data. + A pointer to a variable that on input contains the size, in bytes, of the buffer that pData points to, and on output contains the size, in bytes, of the amount of data that GetPrivateData retrieved. + A pointer to a memory block that receives the data from the device object if pDataSize points to a value that specifies a buffer large enough to hold the data. + + + + + Retrieves support information for video decoding. + Microsoft Docs: + + + + For single GPU operation, set this to zero. If there are multiple GPU nodes, set a bit to identify the node (the device's physical adapter) to which the command queue applies. Each bit in the mask corresponds to a single node. Only 1 bit may be set. + + + A D3D12\_VIDEO\_DECODE\_CONFIGURATION structure specifying the decode profile, bitstream encryption, and interlace type of the source stream. + + + The decode width of the source stream. + + + The decode height of the source stream + + + The DXGI\_FORMAT to use as the decode format. This format is the output format if no decoder conversion is specified. + + + The frame rate of the video format. A value of 0 means the frame rate is unknown. + + + The average bits per second data compression rate for the compressed video stream. This information is used by the driver to determine whether the video can be decoded in real-time. A value of 0 means the bit rate is unknown. + + + A combination of values from the D3D12\_VIDEO\_DECODE\_SUPPORT\_FLAGS enumeration indicating the support for video decoding. This value is populated by the call to ID3D12Device::CheckFeatureSupport. + + + A combination of values from the D3D12\_VIDEO\_DECODE\_CONFIGURATION\_FLAGS eumeration describing the video decode configuration. This value is populated by the call to ID3D12Device::CheckFeatureSupport. + + + A member of the D3D12\_VIDEO\_DECODE\_TIER enumeration specifying the decoding tier of a hardware video decoder. + + + + Specifies indices for arrays of per component histogram information. + Microsoft Docs: + + + + If the format is a YUV format, indicates a histogram for the Y component. + + + If the format is a YUV format, indicates a histogram for the U component. + + + If the format is a YUV format, indicates a histogram for the V component. + + + If the format is an RGB/BGR format, indicates a histogram for the R component. + + + If the format is an RGB/BGR format, indicates a histogram for the G component. + + + If the format is an RGB/BGR format, indicates a histogram for the B component. + + + If the format has an alpha channel, indicates a histogram for the A component. + + + + Identifies the portion of a depth-stencil buffer for writing depth data. + Microsoft Docs: + + + + Turn off writes to the depth-stencil buffer. + + + Turn on writes to the depth-stencil buffer. + + + + Creates a shader-resource view for accessing data in a resource. + Microsoft Docs: + A pointer to the ID3D12Resource object that represents the shader resource. + +At least one of pResource or pDesc must be provided. +A null pResource is used to initialize a null descriptor, which guarantees D3D11-like null binding behavior (reading 0s, writes are discarded), but must have a valid pDesc in order to determine the descriptor type. + A pointer to a D3D12_SHADER_RESOURCE_VIEW_DESC structure that describes the shader-resource view. + +A null pDesc is used to initialize a default descriptor, if possible. This behavior is identical to the D3D11 null descriptor behavior, where defaults are filled in. This behavior inherits the resource format and dimension (if not typeless) and for buffers SRVs target a full buffer and are typed (not raw or structured), and for textures SRVs target a full texture, all mips and all array slices. Not all resources support null descriptor initialization. + Describes the CPU descriptor handle that represents the shader-resource view. This handle can be created in a shader-visible or non-shader-visible descriptor heap. + + + + + Defines constants that specify protected resource session flags. + Microsoft Docs: + + + + Specifies no flag. + + + + The root signature defines what resources are bound to the graphics pipeline. A root signature is configured by the app and links command lists to the resources the shaders require. Currently, there is one graphics and one compute root signature per app. + Microsoft Docs: + + + + + Contains methods to return the deserialized D3D12_ROOT_SIGNATURE_DESC1 data structure, of any version of a serialized root signature. + Microsoft Docs: + + + + + Represents a virtual adapter. This interface extends ID3D12Device5. + Microsoft Docs: + + + + + Encapsulates a list of graphics commands for video encoding, including motion estimation. + Microsoft Docs: + + + + + A command signature object enables apps to specify indirect drawing, including the buffer format, command type and resource bindings to be used. + Microsoft Docs: + + + + + Get the number of messages that are able to pass through a retrieval filter. + Microsoft Docs: + + + + + Get a message identifier to break on when a message with that identifier passes through the storage filter. + Microsoft Docs: + Message identifier to break on. + + + + + Contains the reference frames needed to perform video processing. + Microsoft Docs: + + + + The number of past reference frames provided in ppPastFrames. + + + A pointer to an array of ID3D12Resource surfaces. The number of elements in the array is NumPastFrames. + + + An array of subresource indices for the list of ppPastFrames textures. NULL indicates subresource 0 for each resource. + + + The number of future reference frames provided in ppPastFrames. + + + A pointer to an array of ID3D12Resource surfaces. The number of elements in the array is NumFutureFrames. + + + An array of subresource indices for the list of ppFutureFrames textures. NULL indicates subresource 0 for each resource. + + + + Sets a descriptor table into the graphics root signature. + Microsoft Docs: + The slot number for binding. + A GPU_descriptor_handle object for the base descriptor to set. + + + + + Indicates root signature version support. + Microsoft Docs: + + + + On input, specifies the highest version D3D_ROOT_SIGNATURE_VERSION to check for. On output specifies the highest version, up to the input version specified, actually available. + + + + Deserializes a root signature so you can determine the layout definition (D3D12_ROOT_SIGNATURE_DESC). + Microsoft Docs: + A pointer to the source data for the serialized root signature. + The size, in bytes, of the block of memory that pSrcData points to. + The globally unique identifier (GUID) for the root signature deserializer interface. See remarks. + A pointer to a memory block that receives a pointer to the root signature deserializer. + + + + + A descriptor heap is a collection of contiguous allocations of descriptors, one allocation for every descriptor. + Microsoft Docs: + + + + + Asynchronously makes objects resident for the device. + Microsoft Docs: + Controls whether the objects should be made resident if the application is over its memory budget. + The number of objects in the ppObjects array to make resident for the device. + A pointer to a memory block; contains an array of ID3D12Pageable interface pointers for the objects. + + +Even though most D3D12 objects inherit from ID3D12Pageable, residency changes are only supported on the following: + +
    +
  • descriptor heaps
    • +
  • heaps
    • +
  • committed resources
    • +
  • query heaps
    • +
+ A pointer to the fence used to signal when the work is done. + An unsigned 64-bit value signaled to the fence when the work is done. + + + + + Describes a compute pipeline state object. + Microsoft Docs: + + + + A pointer to the ID3D12RootSignature object. + + + A D3D12_SHADER_BYTECODE structure that describes the compute shader. + + + For single GPU operation, set this to zero. If there are multiple GPU nodes, set bits to identify the nodes (the device's physical adapters) for which the compute pipeline state is to apply. + Each bit in the mask corresponds to a single node. + Refer to Multi-adapter systems. + + + A cached pipeline state object, as a D3D12_CACHED_PIPELINE_STATE structure. pCachedBlob and CachedBlobSizeInBytes may be set to NULL and 0 respectively. + + + A D3D12_PIPELINE_STATE_FLAGS enumeration constant such as for "tool debug". + + + + Get the retrieval filter at the top of the retrieval-filter stack. + Microsoft Docs: + Retrieval filter at the top of the retrieval-filter stack. + Size of the retrieval filter in bytes. If pFilter is NULL, the size of the retrieval filter will be output to this parameter. + + + + + Sets a group of constants in the compute root signature. + Microsoft Docs: + The slot number for binding. + The number of constants to set in the root signature. + The source data for the group of constants to set. + The offset, in 32-bit values, to set the first constant of the group in the root signature. + + + + + Describes the subresource from a multi sampled 2D texture that is accessible to a depth-stencil view. + Microsoft Docs: + + + + Unused. + + + + Sets a state object on the command list. + Microsoft Docs: + The state object to set on the command list. In the current release, this can only be of type D3D12_STATE_OBJECT_TYPE_RAYTRACING_PIPELINE. + + + + + Flags for a raytracing acceleration structure instance. These flags can be used to override D3D12_RAYTRACING_GEOMETRY_FLAGS for individual instances. + Microsoft Docs: + + + + No options specified. + + + Disables front/back face culling for this instance. The Ray flags RAY_FLAG_CULL_BACK_FACING_TRIANGLES and RAY_FLAG_CULL_FRONT_FACING_TRIANGLES will have no effect on this instance. + + + This flag reverses front and back facings, which is useful if the application’s natural winding order differs from the default. By default, a triangle is front facing if its vertices appear clockwise from the ray origin and back facing if its vertices appear counter-clockwise from the ray origin, in object space in a left-handed coordinate system. + +Since these winding direction rules are defined in object space, they are unaffected by instance transforms. For example, an instance transform matrix with negative determinant (e.g. mirroring some geometry) does not change the facing of the triangles within the instance. Per-geometry transforms defined in D3D12_RAYTRACING_GEOMETRY_TRIANGLES_DESC , by contrast, get combined with the associated vertex data in object space, so a negative determinant matrix there does flip triangle winding. + + + The instance will act as if D3D12_RAYTRACING_GEOMETRY_FLAG_OPAQUE had been specified for all the geometries in the bottom-level acceleration structure referenced by the instance. Note that this behavior can be overridden by the ray flag RAY_FLAG_FORCE_NON_OPAQUE. + +This flag is mutually exclusive to the D3D12_RAYTRACING_INSTANCE_FLAG_FORCE_NON_OPAQUE flag. + + + The instance will act as if D3D12_RAYTRACING_GEOMETRY_FLAG_OPAQUE had not been specified for any of the geometries in the bottom-level acceleration structure referenced by the instance. Note that this behavior can be overridden by the ray flag RAY_FLAG_FORCE_OPAQUE. + +This flag is mutually exclusive to the D3D12_RAYTRACING_INSTANCE_FLAG_FORCE_OPAQUE flag. + + + + Describes a shader constant-buffer. + Microsoft Docs: + + + + The name of the buffer. + + + A D3D_CBUFFER_TYPE-typed value that indicates the intended use of the constant data. + + + The number of unique variables. + + + The size of the buffer, in bytes. + + + A combination of D3D_SHADER_CBUFFER_FLAGS-typed values that are combined by using a bitwise OR operation. The resulting value specifies properties for the shader constant-buffer. + + + + Defines the header for a serialized raytracing acceleration structure. + Microsoft Docs: + + + + The driver-matching identifier. + + + The size of serialized data. + + + Size of the memory that will be consumed when the acceleration structure is deserialized. This value is less than or equal to the size of the original acceleration structure before it was serialized. + + + Size of the array of D3D12_GPU_VIRTUAL_ADDRESS values that follow the header. For more information, see D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_SERIALIZATION_DESC. + + + + Gets a bit field of flags that indicates which debug features are on or off. + Microsoft Docs: + + + + + Sets all shaders and programs most of the fixed-function state of the graphics processing unit (GPU) pipeline. + Microsoft Docs: + Pointer to the ID3D12PipelineState containing the pipeline state data. + + + + + Provides detail about the adapter architecture, so that your application can better optimize for certain adapter properties. + Microsoft Docs: + + + + In multi-adapter operation, this indicates which physical adapter of the device is relevant. + See Multi-adapter systems. + NodeIndex is filled out by the application before calling CheckFeatureSupport, as the application can retrieve details about the architecture of each adapter. + + + Specifies whether the hardware and driver support a tile-based renderer. + The runtime sets this member to TRUE if the hardware and driver support a tile-based renderer. + + + Specifies whether the hardware and driver support UMA. + The runtime sets this member to TRUE if the hardware and driver support UMA. + + + Specifies whether the hardware and driver support cache-coherent UMA. + The runtime sets this member to TRUE if the hardware and driver support cache-coherent UMA. + + + + Gets a shader-reflection-variable type. + Microsoft Docs: + Zero-based index. + + + + + This interface enables modification of additional command list debug layer settings. + Microsoft Docs: + + + + + Gets an input-parameter description for a shader. + Microsoft Docs: + A zero-based parameter index. + A pointer to a shader-input-signature description. See D3D12_SIGNATURE_PARAMETER_DESC. + + + + + Sets application-defined data to a device object and associates that data with an application-defined GUID. + Microsoft Docs: + The GUID to associate with the data. + The size in bytes of the data. + A pointer to a memory block that contains the data to be stored with this device object. If pData is NULL, DataSize must also be 0, and any data that was previously associated with the GUID specified in guid will be destroyed. + + + + + Marks the beginning of a render pass by binding a set of output resources for the duration of the render pass. These bindings are to one or more render target views (RTVs), and/or to a depth stencil view (DSV). + Microsoft Docs: + A UINT. The number of render targets being bound. + A pointer to a constant D3D12_RENDER_PASS_RENDER_TARGET_DESC, which describes bindings (fixed for the duration of the render pass) to one or more render target views (RTVs), as well as their beginning and ending access characteristics. + A pointer to a constant D3D12_RENDER_PASS_DEPTH_STENCIL_DESC, which describes a binding (fixed for the duration of the render pass) to a depth stencil view (DSV), as well as its beginning and ending access characteristics. + A D3D12_RENDER_PASS_FLAGS. The nature/requirements of the render pass; for example, whether it is a suspending or a resuming render pass, or whether it wants to write to unordered access view(s). + + + + + Retrieves the list of supported profiles. + Microsoft Docs: + + + + For single GPU operation, set this to zero. If there are multiple GPU nodes, set a bit to identify the node (the device's physical adapter) to which the command queue applies. Each bit in the mask corresponds to a single node. Only 1 bit may be set. + + + A D3D12\_VIDEO\_DECODE\_CONFIGURATION structure describing the decode configuration. + + + A D3D12\_VIDEO\_SAMPLE structure representing the source decoded as sample description. + + + A D3D12\_VIDEO\_FORMAT structure containing the output sample description. + + + The frame rate of the video content. This is used by the driver to determine whether the video can be decoded in real-time. + + + The average bits per second data compression rate for the compressed video stream. This is used by the driver to determine whether the video can be decoded in real-time. + + + A combination of values from the D3D12\_VIDEO\_DECODE\_CONVERSION\_SUPPORT\_FLAGS indicating the support for the specified conversion. + + + A D3D12\_VIDEO\_SCALE\_SUPPORT structure representing the output size range for decode conversion. + + + + This interface is used to configure the runtime for tools such as PIX. Its not intended or supported for any other scenario. + Microsoft Docs: + + + + + Represents a fence. This interface extends ID3D12Fence, and supports the retrieval of the flags used to create the original fence. + Microsoft Docs: + + + + + Specifies the parameters for decode output conversion. + Microsoft Docs: + + + + A boolean value indicating whether decode conversion should be used. + + + A pointer to an ID3D12Resource containing the native decoding output. When downsampling is enabled, the output at native decode resolution, color space, and format may be required for future decode submissions (as reference frames, for instance). + + + The subresource index of the resource provided in pDecodeTexture2D to use. + + + A value from the DXGI_COLOR_SPACE_TYPE enumeration specifying the target color space of the output. + + + A value from the DXGI_COLOR_SPACE_TYPE enumeration specifying the source-decoded color space before conversion. + + + The output width, in pixels. + + + The output width, in pixels. + + + + Describes a meta command. + Microsoft Docs: + + + + A GUID uniquely identifying the meta command. + + + The meta command name. + + + Declares the command list states that are modified by the call to initialize the meta command. If all state bits are set, then that's equivalent to calling ID3D12GraphicsCommandList::ClearState. + + + Declares the command list states that are modified by the call to execute the meta command. If all state bits are set, then that's equivalent to calling ID3D12GraphicsCommandList::ClearState. + + + + Describes a shader-resource view. + Microsoft Docs: + + + + A DXGI_FORMAT-typed value that specifies the viewing format. See remarks. + + + A D3D12_SRV_DIMENSION-typed value that specifies the resource type of the view. This type is the same as the resource type of the underlying resource. This member also determines which _SRV to use in the union below. + + + A value, constructed using the D3D12_ENCODE_SHADER_4_COMPONENT_MAPPING macro. The D3D12_SHADER_COMPONENT_MAPPING enumeration specifies what values from memory should be returned when the texture is accessed in a shader via this shader resource view (SRV). For example, it can route component 1 (green) from memory, or the constant 0, into component 2 (.b) of the value given to the shader. + + + A D3D12_BUFFER_SRV structure that views the resource as a buffer. + + + A D3D12_TEX1D_SRV structure that views the resource as a 1D texture. + + + A D3D12_TEX1D_ARRAY_SRV structure that views the resource as a 1D-texture array. + + + A D3D12_TEX2D_SRV structure that views the resource as a 2D-texture. + + + A D3D12_TEX2D_ARRAY_SRV structure that views the resource as a 2D-texture array. + + + A D3D12_TEX2DMS_SRV structure that views the resource as a 2D-multisampled texture. + + + A D3D12_TEX2DMS_ARRAY_SRV structure that views the resource as a 2D-multisampled-texture array. + + + A D3D12_TEX3D_SRV structure that views the resource as a 3D texture. + + + A D3D12_TEXCUBE_SRV structure that views the resource as a 3D-cube texture. + + + A D3D12_TEXCUBE_ARRAY_SRV structure that views the resource as a 3D-cube-texture array. + + + A D3D12_RAYTRACING_ACCELERATION_STRUCTURE_SRV structure that views the resource as a raytracing acceleration structure. + + + + Push an empty storage filter onto the storage-filter stack. + Microsoft Docs: + + + + + Get the number of messages that were allowed to pass through a storage filter. + Microsoft Docs: + + + + + This shader-reflection interface provides access to variable type. + Microsoft Docs: + + + + + Describes the subresource from a 2D texture to use in a render-target view. + Microsoft Docs: + + + + The index of the mipmap level to use. + + + The index (plane slice number) of the plane to use in the texture. + + + + Specifies constraints for state objects. Use values from this enumeration in the D3D12_STATE_OBJECT_CONFIG structure. + Microsoft Docs: + + + + No state object constraints. + + + This flag applies to state objects of type collection only. Otherwise this flag is ignored. + +The exports from this collection are allowed to have unresolved references (dependencies) that would have to be resolved (defined) when the collection is included in a containing state object, such as a raytracing pipeline state object (RTPSO). This includes depending on externally defined subobject associations to associate an external subobject (e.g. root signature) to a local export. + +In the absence of this flag, all exports in this collection must have their dependencies fully locally resolved, including any necessary subobject associations being defined locally. Advanced implementations/drivers will have enough information to compile the code in the collection and not need to keep around any uncompiled code (unless the D3D12_STATE_OBJECT_FLAG_ALLOW_EXTERNAL_DEPENDENCIES_ON_LOCAL_DEFINITIONS flag is set), so that when the collection is used in a containing state object (e.g. RTPSO), minimal work needs to be done by the driver, ideally a “cheap” link at most. + + + This flag applies to state objects of type collection only. Otherwise this flag is ignored. + +If this collection is included in another state object (e.g. RTPSO), shaders / functions in the rest of the containing state object are allowed to depend on (e.g. call) exports from this collection. + +In the absence of this flag (default), exports from this collection cannot be directly referenced by other parts of containing state objects (e.g. RTPSO). This can reduce memory footprint for the collection slightly since drivers don’t need to keep uncompiled code in the collection on the off chance that it may get called by some external function that would then compile all the code together. That said, if not all necessary subobject associations have been locally defined for code in this collection, the driver may not be able to compile shader code yet and may still need to keep uncompiled code around. + +A subobject association defined externally that associates an external subobject to a local export does not count as an external dependency on a local definition, so the presence or absence of this flag does not affect whether the association is allowed or not. On the other hand if the current collection defines a subobject association for a locally defined subobject to an external export (e.g. shader), that counts as an external dependency on a local definition and this flag must be set. + +Regardless of the presence or absence of this flag, shader entrypoints (such as hit groups or miss shaders) in the collection are visible as entrypoints to a containing state object (e.g. RTPSO) if exported by it. In the case of an RTPSO, the exported entrypoints can be used in shader tables for raytracing. + + + + Represents a virtual adapter. This interface extends ID3D12Device6. + Microsoft Docs: + + + + + Specifies support for the image filters defined by the D3D12_VIDEO_PROCESS_FILTER enumeration. + Microsoft Docs: + + + + The video processor doesn't support any filters. + + + The video processor can adjust the brightness level. + + + The video processor can adjust the contrast level. + + + The video processor can adjust hue. + + + The video processor can adjust the saturation level. + + + The video processor can perform noise reduction. + + + The video processor can perform edge enhancement. + + + The video processor can perform anamorphic scaling. Anamorphic scaling can be used to stretch 4:3 content to a widescreen 16:9 aspect ratio. + + + For stereo 3D video, the video processor can adjust the offset between the left and right views, allowing the user to reduce potential eye strain. + + + + Represents a fence, an object used for synchronization of the CPU and one or more GPUs. + Microsoft Docs: + + + + + Describes descriptors inline in the root signature version 1.1 that appear in shaders. + Microsoft Docs: + + + + The shader register. + + + The register space. + + + Specifies the D3D12_ROOT_DESCRIPTOR_FLAGS that determine the volatility of descriptors and the data they reference. + + + + Copy a region of a multisampled or compressed resource into a non-multisampled or non-compressed resource. + Microsoft Docs: + SAL: _In_ + +Destination resource. Must be created with the D3D11_USAGE_DEFAULT flag and must be single-sampled unless its to be resolved from a compressed resource (D3D12_RESOLVE_MODE_DECOMPRESS); in this case it must have the same sample count as the compressed source. + SAL: _In_ + +A zero-based index that identifies the destination subresource. Use D3D12CalcSubresource to calculate the subresource index if the parent resource is complex. + SAL: _In_ + +The X coordinate of the left-most edge of the destination region. The width of the destination region is the same as the width of the source rect. + SAL: _In_ + +The Y coordinate of the top-most edge of the destination region. The height of the destination region is the same as the height of the source rect. + SAL: _In_ + +Source resource. Must be multisampled or compressed. + SAL: _In_ + +A zero-based index that identifies the source subresource. + SAL: _In_opt_ + +Specifies the rectangular region of the source resource to be resolved. Passing NULL for pSrcRect specifies that the entire subresource is to be resolved. + SAL: _In_ + +A DXGI_FORMAT that specifies how the source and destination resource formats are consolidated. + SAL: _In_ + +Specifies the operation used to resolve the source samples. + +When using the D3D12_RESOLVE_MODE_DECOMPRESS operation, the sample count can be larger than 1 as long as the source and destination have the same sample count, and source and destination may specify the same resource as long as the source rect aligns with the destination X and Y coordinates, in which case decompression occurs in place. + +When using the D3D12_RESOLVE_MODE_MIN, D3D12_RESOLVE_MODE_MAX, or D3D12_RESOLVE_MODE_AVERAGE operation, the destination must have a sample count of 1. + + + + + Extracts data from a query. ResolveQueryData works with all heap types (default, upload, and readback).  ResolveQueryData works with all heap types (default, upload, and readback). . + Microsoft Docs: + Specifies the ID3D12QueryHeap containing the queries to resolve. + Specifies the type of query, one member of D3D12_QUERY_TYPE. + Specifies an index of the first query to resolve. + Specifies the number of queries to resolve. + Specifies an ID3D12Resource destination buffer, which must be in the state + D3D12_RESOURCE_STATE_COPY_DEST. + Specifies an alignment offset into the destination buffer. + Must be a multiple of 8 bytes. + + + + + Gets the cached blob representing the pipeline state. + Microsoft Docs: + After this method returns, points to the cached blob representing the pipeline state. + + + + + Describes the properties of a ray dispatch operation initiated with a call to ID3D12GraphicsCommandList4::DispatchRays. + Microsoft Docs: + + + + The shader record for the ray generation shader to use. + +The memory pointed to must be in state D3D12_RESOURCE_STATE_NON_PIXEL_SHADER_RESOURCE. + +The address must be aligned to 64 bytes, defined as D3D12_RAYTRACING_SHADER_TABLE_BYTE_ALIGNMENT, and in the range [0...4096] bytes. + + + The shader table for miss shaders. + +The stride is record stride, and must be aligned to 32 bytes, defined as D3D12_RAYTRACING_SHADER_RECORD_BYTE_ALIGNMENT, and in the range [0...4096] bytes. 0 is allowed. + +The memory pointed to must be in state D3D12_RESOURCE_STATE_NON_PIXEL_SHADER_RESOURCE. + +The address must be aligned to 64 bytes, defined as D3D12_RAYTRACING_SHADER_TABLE_BYTE_ALIGNMENT. + + + The shader table for hit groups. + +The stride is record stride, and must be aligned to 32 bytes, defined as D3D12_RAYTRACING_SHADER_RECORD_BYTE_ALIGNMENT, and in the range [0...4096] bytes. 0 is allowed. + +The memory pointed to must be in state D3D12_RESOURCE_STATE_NON_PIXEL_SHADER_RESOURCE. + +The address must be aligned to 64 bytes, defined as D3D12_RAYTRACING_SHADER_TABLE_BYTE_ALIGNMENT. + + + The shader table for callable shaders. + +The stride is record stride, and must be aligned to 32 bytes, defined as D3D12_RAYTRACING_SHADER_RECORD_BYTE_ALIGNMENT. 0 is allowed. + +The memory pointed to must be in state D3D12_RESOURCE_STATE_NON_PIXEL_SHADER_RESOURCE. + +The address must be aligned to 64 bytes, defined as D3D12_RAYTRACING_SHADER_TABLE_BYTE_ALIGNMENT. + + + The width of the generation shader thread grid. + + + The height of the generation shader thread grid. + + + The depth of the generation shader thread grid. + + + + Gets a description of how a resource is bound to a function. + Microsoft Docs: + A zero-based resource index. + A pointer to a D3D12_SHADER_INPUT_BIND_DESC structure that describes input binding of the resource. + + + + + Retrieves the number of video extension commands. + Microsoft Docs: + + + + For single GPU operation, set this to zero. If there are multiple GPU nodes, set a bit to identify the node (the device's physical adapter) to which the command queue applies. Each bit in the mask corresponds to a single node. Only 1 bit may be set. + + + The supported number of video extension commands. + + + + This method is used to determine the rate at which the GPU timestamp counter increments. + Microsoft Docs: + The GPU timestamp counter frequency (in ticks/second). + + + + + Specifies fence options. + Microsoft Docs: + + + + No options are specified. + + + The fence is shared. + + + The fence is shared with another GPU adapter. + + + The fence is of the non-monitored type. Non-monitored fences should only be used when the adapter doesn't support monitored fences, or when a fence is shared with an adapter that doesn't support monitored fences. + + + + Describes the coordinates of a tiled resource. + Microsoft Docs: + + + + The x-coordinate of the tiled resource. + + + The y-coordinate of the tiled resource. + + + The z-coordinate of the tiled resource. + + + The index of the subresource for the tiled resource. + +For mipmaps that use nonstandard tiling, or are packed, or both use nonstandard tiling and are packed, any subresource value that indicates any of the packed mipmaps all refer to the same tile. Additionally, the X coordinate is used to indicate a tile within the packed mip region, rather than a logical region of a single subresource. The Y and Z coordinates must be zero. + + + + Specifies the usage of the associated video extension command parameter. + Microsoft Docs: + + + + None. Set for simple data type parameters. + + + The resource parameter is read. This flag is for ID3D12Resource only and is not valid for simple data type parameters. + + + The resource parameter is written. This flag is for ID3D12Resource only and is not valid for simple data type parameters. + + + + Describes descriptors inline in the root signature version 1.0 that appear in shaders. + Microsoft Docs: + + + + The shader register. + + + The register space. + + + + Manages a pipeline library, in particular loading and retrieving individual PSOs. + Microsoft Docs: + + + + + Sets a CPU descriptor handle for the constant buffer in the compute root signature. + Microsoft Docs: + The slot number for binding. + Specifies the D3D12_GPU_VIRTUAL_ADDRESS of the constant buffer. + + + + + Describes dispatch parameters, for use by the compute shader. + Microsoft Docs: + + + + The size, in thread groups, of the x-dimension of the thread-group grid. + + + The size, in thread groups, of the y-dimension of the thread-group grid. + + + The size, in thread groups, of the z-dimension of the thread-group grid. + + + + Identifies which components of each pixel of a render target are writable during blending. + Microsoft Docs: + + + + Allow data to be stored in the red component. + + + Allow data to be stored in the green component. + + + Allow data to be stored in the blue component. + + + Allow data to be stored in the alpha component. + + + Allow data to be stored in all components. + + + + Specifies a range so that, for example, if part of a descriptor table has 100 shader-resource views (SRVs) that range can be declared in one entry rather than 100. + Microsoft Docs: + + + + Specifies a range of SRVs. + + + Specifies a range of unordered-access views (UAVs). + + + Specifies a range of constant-buffer views (CBVs). + + + Specifies a range of samplers. + + + + Specifies output stream arguments for the output passed to ID3D12VideoCommandList::ProcessFrames. + Microsoft Docs: + + + + An array of D3D12_VIDEO_PROCESS_OUTPUT_STREAM structures representing the output surfaces for the video process command. If stereo output is enabled, index zero contains the left output while index 1 contains the right input. If stereo output is not enabled, only index 0 is used to specify the output while index 1 should be set to nullptr. + + + The target rectangle is the area within the destination surface where the output will be drawn. The target rectangle is given in pixel coordinates, relative to the destination surface. + + + + Gets a patch-constant parameter description for a shader. + Microsoft Docs: + A zero-based parameter index. + A pointer to a shader-input-signature description. See D3D12_SIGNATURE_PARAMETER_DESC. + + + + + Describes a shader signature. + Microsoft Docs: + + + + A per-parameter string that identifies how the data will be used. For more info, see Semantics. + + + Semantic index that modifies the semantic. Used to differentiate different parameters that use the same semantic. + + + The register that will contain this variable's data. + + + A D3D_NAME-typed value that identifies a predefined string that determines the functionality of certain pipeline stages. + + + A D3D_REGISTER_COMPONENT_TYPE-typed value that identifies the per-component-data type that is stored in a register. Each register can store up to four-components of data. + + + Mask which indicates which components of a register are used. + + + Mask which indicates whether a given component is never written (if the signature is an output signature) or always read (if the signature is an input signature). + + + Indicates which stream the geometry shader is using for the signature parameter. + + + A D3D_MIN_PRECISION-typed value that indicates the minimum desired interpolation precision. For more info, see Using HLSL minimum precision. + + + + This method sets residency priorities of a specified list of objects. + Microsoft Docs: + Specifies the number of objects in the ppObjects and pPriorities arrays. + Specifies an array, of length NumObjects, containing references to ID3D12Pageable objects. + Specifies an array, of length NumObjects, of D3D12_RESIDENCY_PRIORITY values for the list of objects. + + + + + Creates a command allocator object. + Microsoft Docs: + A D3D12_COMMAND_LIST_TYPE-typed value that specifies the type of command allocator to create. + The type of command allocator can be the type that records either direct command lists or bundles. + The globally unique identifier (GUID) for the command allocator interface (ID3D12CommandAllocator). + The REFIID, or GUID, of the interface to the command allocator can be obtained by using the __uuidof() macro. + For example, __uuidof(ID3D12CommandAllocator) will get the GUID of the interface to a command allocator. + A pointer to a memory block that receives a pointer to the ID3D12CommandAllocator interface for the command allocator. + + + + + Gets a locally unique identifier for the current device (adapter). + Microsoft Docs: + + + + + Creates a fence object. + Microsoft Docs: + The initial value for the fence. + A combination of D3D12_FENCE_FLAGS-typed values that are combined by using a bitwise OR operation. + The resulting value specifies options for the fence. + The globally unique identifier (GUID) for the fence interface (ID3D12Fence). + The REFIID, or GUID, of the interface to the fence can be obtained by using the __uuidof() macro. + For example, __uuidof(ID3D12Fence) will get the GUID of the interface to a fence. + A pointer to a memory block that receives a pointer to the ID3D12Fence interface that is used to access the fence. + + + + + Describes flags for a protected resource session, per adapter. + Microsoft Docs: + + + + The node mask. For single GPU operation, set this to zero. If there are multiple GPU nodes, then set a bit to identify the node (the device's physical adapter) to which the protected session applies. Each bit in the mask corresponds to a single node. Only 1 bit may be set. + + + Specifies the supported crypto sessions options. + + + + Gets a constant buffer by name. + Microsoft Docs: + The constant-buffer name. + + + + + Gets the size of the handle increment for the given type of descriptor heap. This value is typically used to increment a handle into a descriptor array by the correct amount. + Microsoft Docs: + The D3D12_DESCRIPTOR_HEAP_TYPE-typed value that specifies the type of descriptor heap to get the size of the handle increment for. + + + + + Get a message severity level to break on when a message with that severity level passes through the storage filter. + Microsoft Docs: + Message severity level to break on. + + + + + Specifies the type of access that an application is given to the specified resource(s) at the transition out of a render pass. + Microsoft Docs: + + + + Indicates that your application won't have any future dependency on any data that you wrote to the resource(s) during this render pass. For example, a depth buffer that won't be textured from before it's written to again. + + + Indicates that your application will have a dependency on the written contents of the resource(s) in the future, and so they must be preserved. + + + Indicates that the resource(s)—for example, a multi-sample anti-aliasing (MSAA) surface—should be directly resolved to a separate resource at the conclusion of the render pass. For a tile-based deferred renderer (TBDR), this should ideally happenwhile the MSAA contents are still in the tile cache. You should ensure that the resolve destination is in the D3D12_RESOURCE_STATE_RESOLVE_DEST resource state when the render pass ends. The resolve source is left in its initial resource state at the time the render pass ends. A resolve operation submitted by a render pass doesn't implicitly change the state of any resource. + + + Indicates that your application will neither read from nor write to the resource(s) during the render pass. You would most likely use this value to indicate that you won't be accessing the depth/stencil plane for a depth/stencil view (DSV). You must pair this value with D3D12_RENDER_PASS_BEGINNING_ACCESS_TYPE_NO_ACCESS in the corresponding D3D12_RENDER_PASS_BEGINNING_ACCESS structure. + + + + Creates a resource that is reserved, and not yet mapped to any pages in a heap. + Microsoft Docs: + A pointer to a D3D12_RESOURCE_DESC structure that describes the resource. + The initial state of the resource, as a bitwise-OR'd combination of D3D12_RESOURCE_STATES enumeration constants. + Specifies a D3D12_CLEAR_VALUE structure that describes the default value for a clear color. + +pOptimizedClearValue specifies a value for which clear operations are most optimal. When the created resource is a texture with either the D3D12_RESOURCE_FLAG_ALLOW_RENDER_TARGET or D3D12_RESOURCE_FLAG_ALLOW_DEPTH_STENCIL flags, you should choose the value with which the clear operation will most commonly be called. You can call the clear operation with other values, but those operations won't be as efficient as when the value matches the one passed in to resource creation. + +When you use D3D12_RESOURCE_DIMENSION_BUFFER, you must set pOptimizedClearValue to nullptr. + A reference to the globally unique identifier (GUID) of the resource interface to return in ppvResource. See Remarks. + +While riidResource is most commonly the GUID of ID3D12Resource, it may be the GUID of any interface. If the resource object doesn't support the interface for this GUID, then creation fails with E_NOINTERFACE. + An optional pointer to a memory block that receives the requested interface pointer to the created resource object. + +ppvResource can be nullptr, to enable capability testing. When ppvResource is nullptr, no object is created, and S_FALSE is returned when pDesc is valid. + + + + + Describes a command queue. + Microsoft Docs: + + + + Specifies one member of D3D12_COMMAND_LIST_TYPE. + + + The priority for the command queue, as a + D3D12_COMMAND_QUEUE_PRIORITYenumeration constant to select normal or high priority. + + + Specifies any flags from the D3D12_COMMAND_QUEUE_FLAGS enumeration. + + + For single GPU operation, set this to zero. If there are multiple GPU nodes, set a bit to identify the node (the device's physical adapter) to which the command queue applies. + Each bit in the mask corresponds to a single node. + Only 1 bit must be set. + Refer to Multi-adapter systems. + + + + Submits an array of command lists for execution. + Microsoft Docs: + The number of command lists to be executed. + The array of ID3D12CommandList command lists to be executed. + + + + + Represents a virtual adapter. This interface extends ID3D12Device7. + Microsoft Docs: + + + + + Draws non-indexed, instanced primitives. + Microsoft Docs: + Number of vertices to draw. + Number of instances to draw. + Index of the first vertex. + A value added to each index before reading per-instance data from a vertex buffer. + + + + + Represents a virtual adapter. This interface extends ID3D12Device1 to create pipeline state objects from pipeline state stream descriptions. + Microsoft Docs: + + + + + Gets the heap description. + Microsoft Docs: + + + + + Describes the subresources from an array of 2D textures that are accessible to a depth-stencil view. + Microsoft Docs: + + + + The index of the first mipmap level to use. + + + The index of the first texture to use in an array of textures. + + + Number of textures to use. + + + + Sets a descriptor table into the compute root signature. + Microsoft Docs: + The slot number for binding. + A GPU_descriptor_handle object for the base descriptor to set. + + + + + Defines the encryption byte mapping of sub samples for video decoding. + Microsoft Docs: + + + + This field is unused. + + + This field is unused. + + + + Specifies the data type of the memory pointed to by the pData parameter of ID3D12DebugDevice1::SetDebugParameter and ID3D12DebugDevice1::GetDebugParameter. + Microsoft Docs: + + + + Indicates pData points to a D3D12_DEBUG_FEATURE value. + + + Indicates pData points to a D3D12_DEBUG_DEVICE_GPU_BASED_VALIDATION_SETTINGS structure. + + + Indicates pData points to a D3D12_DEBUG_DEVICE_GPU_SLOWDOWN_PERFORMANCE_FACTOR structure. + + + + Modifies optional Debug Layer settings of a command list. + Microsoft Docs: + Specifies a D3D12_DEBUG_COMMAND_LIST_PARAMETER_TYPE value that indicates which debug parameter data to set. + Pointer to debug parameter data to set. The interpretation of this data depends on the D3D12_DEBUG_COMMAND_LIST_PARAMETER_TYPE given in the Type parameter. + Specifies the size in bytes of the debug parameter pData. + + + + + Uses the CPU to copy data from a subresource, enabling the CPU to read the contents of most textures with undefined layouts. + Microsoft Docs: + A pointer to the destination data in memory. + The distance from one row of destination data to the next row. + The distance from one depth slice of destination data to the next. + Specifies the index of the subresource to read from. + A pointer to a box that defines the portion of the destination subresource to copy the resource data from. + If NULL, the data is read from the destination subresource with no offset. + The dimensions of the destination must fit the destination (see + D3D12_BOX). + + +An empty box results in a no-op. + A box is empty if the top value is greater than or equal to the bottom value, or the left value is greater than or equal to the right value, or the front value is greater than or equal to the back value. + When the box is empty, this method doesn't perform any operation. + + + + + Specifies the type of copy operation performed when calling CopyRaytracingAccelerationStructure. + Microsoft Docs: + + + + Copy an acceleration structure while fixing any self-referential pointers that may be present so that the destination is a self-contained copy of the source. Any external pointers to other acceleration structures remain unchanged from source to destination in the copy. The size of the destination is identical to the size of the source. + +> [!IMPORTANT] +> The source memory must be in state [D3D12_RESOURCE_STATE_RAYTRACING_ACCELERATION_STRUCTURE](/windows/desktop/api/d3d12/ne-d3d12-d3d12_resource_states). +> The destination memory must be in state [D3D12_RESOURCE_STATE_RAYTRACING_ACCELERATION_STRUCTURE](/windows/desktop/api/d3d12/ne-d3d12-d3d12_resource_states). + + + Produces a functionally equivalent acceleration structure to source in the destination, similar to the clone mode, but also fits the destination into a potentially smaller, and certainly not larger, memory footprint. The size required for the destination can be retrieved beforehand from EmitRaytracingAccelerationStructurePostbuildInfo. + +This mode is only valid if the source acceleration structure was originally built with the D3D12_RAYTRACING_ACCELERATION_STRUCTURE_BUILD_FLAG_ALLOW_COMPACTION flag, otherwise results are undefined. + +Compacting geometry requires the entire acceleration structure to be constructed, which is why you must first build and then compact the structure. + +> [!IMPORTANT] +> The source memory must be in state [D3D12_RESOURCE_STATE_RAYTRACING_ACCELERATION_STRUCTURE](/windows/desktop/api/d3d12/ne-d3d12-d3d12_resource_states). +> The destination memory must be in state [D3D12_RESOURCE_STATE_RAYTRACING_ACCELERATION_STRUCTURE](/windows/desktop/api/d3d12/ne-d3d12-d3d12_resource_states). + + + The destination is takes the layout described in D3D12_BUILD_RAYTRACING_ACCELERATION_STRUCTURE_TOOLS_VISUALIZATION_HEADER. The size required for the destination can be retrieved beforehand from EmitRaytracingAccelerationStructurePostbuildInfo. + +This mode is only intended for tools such as PIX, though nothing stops any app from using it. The output is essentially the inverse of an acceleration structure build. This overall structure with is sufficient for tools/PIX to be able to give the application some visual sense of the acceleration structure the driver made out of the app’s input. Visualization can help reveal driver bugs in acceleration structures if what is shown grossly mismatches the data the application used to create the acceleration structure, beyond allowed tolerances. + +For top-level acceleration structures, the output includes a set of instance descriptions that are identical to the data used in the original build and in the same order. For bottom-level acceleration structures, the output includes a set of geometry descriptions roughly matching the data used in the original build. The output is only a rough match for the original in part because of the tolerances allowed in the specification for acceleration structures and in part due to the inherent complexity of reporting exactly the same structure as is conceptually encoded. For example. axis-aligned bounding boxes (AABBs) returned for procedural primitives could be more conservative (larger) in volume and even different in number than what is actually in the acceleration structure representation. Geometries, each with its own geometry description, appear in the same order as in the original acceleration, as shader table indexing calculations depend on this. + + +> [!IMPORTANT] +> The source memory must be in state [D3D12_RESOURCE_STATE_RAYTRACING_ACCELERATION_STRUCTURE](/windows/desktop/api/d3d12/ne-d3d12-d3d12_resource_states). +> The destination memory must be in state [D3D12_RESOURCE_STATE_UNORDERED_ACCESS](/windows/desktop/api/d3d12/ne-d3d12-d3d12_resource_states). + +This mode is only permitted when developer mode is enabled in the OS. + + + Destination takes the layout and size described in the documentation for D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_SERIALIZATION_DESC, itself a structure generated with a call to EmitRaytracingAccelerationStructurePostbuildInfo. + +This mode serializes an acceleration structure so that an app or tools can store it to a file for later reuse, typically on a different device instance, via deserialization. + +When serializing a top-level acceleration structure, the bottom-level acceleration structures it refers to do not have to still be present or intact in memory. Likewise, bottom-level acceleration structures can be serialized independent of whether any top-level acceleration structures are pointing to them. In other words, the order of serialization of acceleration structures doesn’t matter. + +> [!IMPORTANT] +> The source memory must be in state [D3D12_RESOURCE_STATE_RAYTRACING_ACCELERATION_STRUCTURE](/windows/desktop/api/d3d12/ne-d3d12-d3d12_resource_states). +> The destination memory must be in state [D3D12_RESOURCE_STATE_UNORDERED_ACCESS](/windows/desktop/api/d3d12/ne-d3d12-d3d12_resource_states). + + + The source must be a serialized acceleration structure, with any pointers, directly after the header, fixed to point to their new locations. For more information, see D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_SERIALIZATION_DESC. + +The destination gets an acceleration structure that is functionally equivalent to the acceleration structure that was originally serialized. It does not matter what order top-level and bottom-level acceleration structures are deserialized, as long as by the time a top-level acceleration structure is used for raytracing or acceleration structure updates the bottom-level acceleration structures it references are present. + +Deserialization can only be performed on the same device and driver version on which the data was serialized. Otherwise, the results are undefined. + +This mode is only intended for tools such as PIX, though nothing stops any app from using it, but this mode is only permitted when developer mode is enabled in the OS. This copy operation is not intended to be used for caching acceleration structures, because running a full acceleration structure build is likely to be faster than loading one from disk. + + +> [!IMPORTANT] +> The source memory must be in state [D3D12_RESOURCE_STATE_NON_PIXEL_SHADER_RESOURCE](/windows/desktop/api/d3d12/ne-d3d12-d3d12_resource_states). +> The destination memory must be in state [D3D12_RESOURCE_STATE_RAYTRACING_ACCELERATION_STRUCTURE](/windows/desktop/api/d3d12/ne-d3d12-d3d12_resource_states). + + + + Specifies the type of shader patching used by GPU-Based Validation at either the device or command list level. + Microsoft Docs: + + + + No shader patching is to be done. This will retain the original shader bytecode. Can lead to errors in some of the GPU-Based Validation state tracking as the unpatched shader may still change resource state (see Common state promotion) but the promotion will be untracked without patching the shader. This can improve performance but no validation will be performed and may also lead to misleading GPU-Based Validation errors. Use this mode very carefully. + + + Shaders can be patched with resource state tracking code but no validation. This may improve performance but no validation will be performed. + + + The default. Shaders are patched with validation code but erroneous instructions will still be executed. + + + Shaders are patched with validation code and erroneous instructions are skipped in execution. This can help avoid crashes or device removal. + + + Unused, simply the count of the number of modes. + + + + Describes a DXGI data format and plane count. + Microsoft Docs: + + + + A DXGI_FORMAT-typed value for the format to return info about. + + + The number of planes to provide information about. + + + + Describes the subresources from an array of 2D textures to use in a render-target view. + Microsoft Docs: + + + + The index of the mipmap level to use mip slice. + + + The index of the first texture to use in an array of textures. + + + Number of textures in the array to use in the render target view, starting from FirstArraySlice. + + + The index (plane slice number) of the plane to use in an array of textures. + + + + Describes a value used to optimize clear operations for a particular resource. + Microsoft Docs: + + + + Specifies one member of the DXGI_FORMAT enum. + +The format of the commonly cleared color follows the same validation rules as a view/ descriptor creation. In general, the format of the clear color can be any format in the same typeless group that the resource format belongs to. + +This Format must match the format of the view used during the clear operation. It indicates whether the Color or the DepthStencil member is valid and how to convert the values for usage with the resource. + + + Specifies a 4-entry array of float values, determining the RGBA value. The order of RGBA matches the order used with ClearRenderTargetView. + + + Specifies one member of D3D12_DEPTH_STENCIL_VALUE. These values match the semantics of Depth and Stencil in ClearDepthStencilView. + + + + Provides data for calls to ID3D12VideoDevice::CheckFeatureSupport when the feature specified is D3D12_FEATURE_VIDEO_PROCESS_SUPPORT. + Microsoft Docs: + + + + An integer indicating which physical adapter of the device the operation applies to, in a multi-adapter operation. + + + A D3D12\_VIDEO\_SAMPLE structure defining the width, height, and format of the input sample. + + + A member of the D3D12\_VIDEO\_FIELD\_TYPE enumeration specifying the interlaced field type of the input sample. + + + A member of the D3D12\_VIDEO\_FRAME\_STEREO\_FORMAT enumeration specifying the stereo format of the input sample. + + + The input frame rate. + + + A D3D12\_VIDEO\_FORMAT structure specifying the output DXGI format and color space. + + + A member of the D3D12\_VIDEO\_FRAME\_STEREO\_FORMAT enumeration specifying the stereo format of the output. + + + The output frame rate. + + + A member of the D3D12\_VIDEO\_PROCESS\_SUPPORT\_FLAGS indicating whether the requested format and colorspace conversion is supported. This value is populated by the call to ID3D12Device::CheckFeatureSupport. + + + A D3D12\_VIDEO\_SCALE\_SUPPORT structure specifying the supported scaling capabilities. This value is populated by the call to ID3D12Device::CheckFeatureSupport. + + + A bitwise OR combination of values from the D3D12\_VIDEO\_PROCESS\_FEATURE\_FLAGS enumeration specifying the supported video processing features. This value is populated by the call to ID3D12Device::CheckFeatureSupport. + + + A member of the D3D12\_VIDEO\_PROCESS\_DEINTERLACE\_FLAGS enumeration specifying the supported deinterlacing capabilities. This value is populated by the call to ID3D12Device::CheckFeatureSupport. + + + A member of the D3D12\_VIDEO\_PROCESS\_AUTO\_PROCESSING\_FLAGS specifying the supported automatic processing capabilities. This value is populated by the call to ID3D12Device::CheckFeatureSupport. + + + A bitwise OR combination of values from the D3D12\_VIDEO\_PROCESS\_FILTER\_FLAGS enumeration specifying the supported video filtering features. This value is populated by the call to ID3D12Device::CheckFeatureSupport. + + + An array of D3D12\_VIDEO\_PROCESS\_FILTER\_RANGE structures representing the filter range values. This value is populated by the call to ID3D12Device::CheckFeatureSupport. The calling application must allocate the memory for the filter range list before calling CheckFeatureSupport. + + + + Indicates that recording to the command list has finished. + Microsoft Docs: + + + + + Indicates the level of support for the sharing of resources between different adapters—for example, multiple GPUs. + Microsoft Docs: + + + + Indicates the tier of cross-adapter sharing support. + + + Indicates there is support for shader instructions which operate across adapters. + + + + Describes a video extension command parameter. + Microsoft Docs: + + + + A pointer to a wide string containing the name of the command. + + + A member of the D3D12_VIDEO_EXTENSION_COMMAND_PARAMETER_TYPE specifying the type of the parameter. + + + A member of the D3D12_VIDEO_EXTENSION_COMMAND_PARAMETER_FLAGS enumeration specifying the usage of the parameter. + + + + Describes the subresources from an array of multi sampled 2D textures to use in a render-target view. + Microsoft Docs: + + + + The index of the first texture to use in an array of textures. + + + The number of textures to use. + + + + Describes the allocation size of a video decoder heap. + Microsoft Docs: + + + + For single GPU operation, set this to zero. If there are multiple GPU nodes, set a bit to identify the node (the device's physical adapter) to which the command queue applies. Each bit in the mask corresponds to a single node. Only 1 bit may be set. + + + A pointer to a D3D12\_VIDEO\_PROCESS\_OUTPUT\_STREAM\_DESC(ns-d3d12video-d3d12_video_process_output_stream_desc) structure describing the output stream. + + + The number of input streams provided in the pInputStreamDescs parameter. + + + A pointer to a list of D3D12\_VIDEO\_PROCESS\_INPUT\_STREAM\_DESC(ns-d3d12video-d3d12_video_process_input_stream_desc) structures the input streams. + + + The allocation size of the video processor in the L0 memory pool. L0 is the physical system memory pool. When the adapter is discrete/NUMA, this pool has greater bandwidth for the CPU and less bandwidth for the GPU. When the adapter is UMA, this pool is the only one which is valid. For more information, see Residency. + + + The allocation size of the video processor in the L1 memory pool. L1 is typically known as the physical video memory pool. L1 is only available when the adapter is discrete/NUMA, and has greater bandwidth for the GPU and cannot even be accessed by the CPU. When the adapter is UMA, this pool is not available. For more information, see Residency. + + + + Initializes the specified meta command. + Microsoft Docs: + A pointer to an ID3D12MetaCommand representing the meta command to initialize. + An optional pointer to a constant structure containing the values of the parameters for initializing the meta command. + A SIZE_T containing the size of the structure pointed to by pInitializationParametersData, if set, otherwise 0. + + + + + Congruent with, and numerically equivalent to, 3D12DDI_HANDLETYPE enumeration values. + Microsoft Docs: + + + + + Indicates the debug parameter type used by ID3D12DebugCommandList1::SetDebugParameter and ID3D12DebugCommandList1::GetDebugParameter. + Microsoft Docs: + + + + Indicates the parameter is type D3D12_DEBUG_COMMAND_LIST_GPU_BASED_VALIDATION_SETTINGS. + + + + A function-parameter-reflection interface accesses function-parameter info. + Microsoft Docs: + + + + + Get the number of messages that were denied passage through a storage filter. + Microsoft Docs: + + + + + Retrieves the supported number of parameters for the specified parameter stage. + Microsoft Docs: + + + + The unique identifier for the video extension command for which the parameter count is queried. + + + A member of the D3D12_VIDEO_EXTENSION_COMMAND_PARAMETER_STAGE enumeration specifying the parameter stage for which the parameter count is retrieved. + + + Receives the number of parameters in the parameter stage. + + + Receives the parameter packing for the parameter stage. + + + + Represents a virtual adapter, and expands on the range of methods provided by ID3D12Device. + Microsoft Docs: + + + + + This shader-reflection interface provides access to a variable. + Microsoft Docs: + + + + + Clear all messages from the message queue. + Microsoft Docs: + + + + + Specifies options for root signature layout. + Microsoft Docs: + + + + Indicates default behavior. + + + The app is opting in to using the Input Assembler (requiring an input layout that defines a set of vertex buffer bindings). Omitting this flag can result in one root argument space being saved on some hardware. Omit this flag if the Input Assembler is not required, though the optimization is minor. + + + Denies the vertex shader access to the root signature. + + + Denies the hull shader access to the root signature. + + + Denies the domain shader access to the root signature. + + + Denies the geometry shader access to the root signature. + + + Denies the pixel shader access to the root signature. + + + The app is opting in to using Stream Output. Omitting this flag can result in one root argument space being saved on some hardware. Omit this flag if Stream Output is not required, though the optimization is minor. + + + The root signature is to be used with raytracing shaders to define resource bindings sourced from shader records in shader tables. This flag cannot be combined with any other root signature flags, which are all related to the graphics pipeline. The absence of the flag means the root signature can be used with graphics or compute, where the compute version is also shared with raytracing’s global root signature. + + + + Query information about graphics-pipeline activity in between calls to BeginQuery and EndQuery. + Microsoft Docs: + + + + Number of vertices read by input assembler. + + + Number of primitives read by the input assembler. This number can be different depending on the primitive topology used. For example, a triangle strip with 6 vertices will produce 4 triangles, however a triangle list with 6 vertices will produce 2 triangles. + + + Specifies the number of vertex shader invocations. Direct3D invokes the vertex shader once per vertex. + + + Specifies the number of geometry shader invocations. When the geometry shader is set to NULL, this statistic may or may not increment depending on the graphics adapter. + + + Specifies the number of geometry shader output primitives. + + + Number of primitives that were sent to the rasterizer. When the rasterizer is disabled, this will not increment. + + + Number of primitives that were rendered. This may be larger or smaller than CInvocations because after a primitive is clipped sometimes it is either broken up into more than one primitive or completely culled. + + + Specifies the number of pixel shader invocations. + + + Specifies the number of hull shader invocations. + + + Specifies the number of domain shader invocations. + + + Specifies the number of compute shader invocations. + + + + Describes a descriptor range, with flags to determine their volatility. + Microsoft Docs: + + + + A D3D12_DESCRIPTOR_RANGE_TYPE-typed value that specifies the type of descriptor range. + + + The number of descriptors in the range. Use -1 or UINT_MAX to specify unbounded size. Only the last entry in a table can have unbounded size. + + + The base shader register in the range. For example, for shader-resource views (SRVs), 3 maps to ": register(t3);" in HLSL. + + + The register space. Can typically be 0, but allows multiple descriptor arrays of unknown size to not appear to overlap. + For example, for SRVs, by extending the example in the BaseShaderRegister member description, 5 maps to ": register(t3,space5);" in HLSL. + + + Specifies the D3D12_DESCRIPTOR_RANGE_FLAGS that determine descriptor and data volatility. + + + The offset in descriptors from the start of the root signature. This value can be D3D12_DESCRIPTOR_RANGE_OFFSET_APPEND, which indicates this range should immediately follow the preceding range. + + + + Defines a local root signature state subobject that will be used with associated shaders. + Microsoft Docs: + + + + The root signature that will function as a local root signature. A state object holds a reference to this signature. + + + + Encapsulates a list of graphics commands for video decoding. + Microsoft Docs: + + + + + Stores a pipeline state. + Microsoft Docs: + + + + Specifies pointer that references the memory location of the cache. + + + Specifies the size of the cache in bytes. + + + + Specifies an event that should be fired when the fence reaches a certain value. + Microsoft Docs: + The fence value when the event is to be signaled. + A handle to the event object. + + + + + Checks the allocation size of a video extension command. + Microsoft Docs: + + + + For single GPU operation, set this to zero. If there are multiple GPU nodes, set a bit to identify the node (the device's physical adapter) to which the command queue applies. Each bit in the mask corresponds to a single node. Only 1 bit may be set. + + + The unique identifier for the video extension command for which size is queried. + + + A pointer to the creation parameters structure, which is defined by the command. The parameters structure must match the parameters enumerated by a call to [ID3D12VideoDevice::CheckFeatureSupport](nf-d3d12video-id3d12videodevice-checkfeaturesupport.md) with the feature value of D3D12_FEATURE_VIDEO_EXTENSION_COMMAND_PARAMETERS and a parameter stage value of D3D12_VIDEO_EXTENSION_COMMAND_PARAMETER_STAGE_CREATION. + + + The size of the pCreationParameters parameter structure, in bytes. + + + The allocation size of the video extension command in the L0 memory pool. L0 is the physical system memory pool. When the adapter is discrete/NUMA, this pool has greater bandwidth for the CPU and less bandwidth for the GPU. When the adapter is UMA, this pool is the only one which is valid. For more information, see Residency. + + + The allocation size of the video extension command heap in the L1 memory pool. L1 is typically known as the physical video memory pool. L1 is only available when the adapter is discrete/NUMA, and has greater bandwidth for the GPU and cannot even be accessed by the CPU. When the adapter is UMA, this pool is not available. For more information, see Residency. + + + + Gets a group of flags that indicates the requirements of a shader. + Microsoft Docs: + + + + + Encapsulates a list of graphics commands for rendering, extending the interface to support programmable sample positions, atomic copies for implementing late-latch techniques, and optional depth-bounds testing. + Microsoft Docs: + + + + + Makes objects resident for the device. + Microsoft Docs: + The number of objects in the ppObjects array to make resident for the device. + A pointer to a memory block that contains an array of ID3D12Pageable interface pointers for the objects. + + +Even though most D3D12 objects inherit from ID3D12Pageable, residency changes are only supported on the following objects: +Descriptor Heaps, Heaps, Committed Resources, and Query Heaps + + + + + Gets the number of bitwise instructions. + Microsoft Docs: + + + + + Specifies broad residency priority buckets useful for quickly establishing an application priority scheme. + Microsoft Docs: + + + + Indicates a minimum priority. + + + Indicates a low priority. + + + Indicates a normal, medium, priority. + + + Indicates a high priority. Applications are discouraged from using priories greater than this. For more information see ID3D12Device1::SetResidencyPriority. + + + Indicates a maximum priority. Applications are discouraged from using priorities greater than this; D3D12_RESIDENCY_PRIORITY_MAXIMUM is not guaranteed to be available. For more information see ID3D12Device1::SetResidencyPriority + + + + Defines constants that specify a Direct3D 12 feature or feature set to query about. + Microsoft Docs: + + + + Indicates a query for the level of support for basic Direct3D 12 feature options. The corresponding data structure for this value is D3D12_FEATURE_DATA_D3D12_OPTIONS. + + + Indicates a query for the adapter's architectural details, so that your application can better optimize for certain adapter properties. The corresponding data structure for this value is D3D12_FEATURE_DATA_ARCHITECTURE. + +
Note  This value has been superseded by the D3D_FEATURE_DATA_ARCHITECTURE1 value. If your application targets Windows 10, version 1703 (Creators' Update) or higher, then use the D3D_FEATURE_DATA_ARCHITECTURE1 value instead.
+
 
 + + + Indicates a query for info about the feature levels supported. The corresponding data structure for this value is D3D12_FEATURE_DATA_FEATURE_LEVELS. + + + Indicates a query for the resources supported by the current graphics driver for a given format. The corresponding data structure for this value is D3D12_FEATURE_DATA_FORMAT_SUPPORT. + + + Indicates a query for the image quality levels for a given format and sample count. The corresponding data structure for this value is D3D12_FEATURE_DATA_MULTISAMPLE_QUALITY_LEVELS. + + + Indicates a query for the DXGI data format. The corresponding data structure for this value is D3D12_FEATURE_DATA_FORMAT_INFO. + + + Indicates a query for the GPU's virtual address space limitations. The corresponding data structure for this value is D3D12_FEATURE_DATA_GPU_VIRTUAL_ADDRESS_SUPPORT. + + + Indicates a query for the supported shader model. The corresponding data structure for this value is D3D12_FEATURE_DATA_SHADER_MODEL. + + + Indicates a query for the level of support for HLSL 6.0 wave operations. The corresponding data structure for this value is D3D12_FEATURE_DATA_D3D12_OPTIONS1. + + + Indicates a query for the level of support for protected resource sessions. The corresponding data structure for this value is D3D12_FEATURE_DATA_PROTECTED_RESOURCE_SESSION_SUPPORT. + + + Indicates a query for root signature version support. The corresponding data structure for this value is D3D12_FEATURE_DATA_ROOT_SIGNATURE. + + + Indicates a query for each adapter's architectural details, so that your application can better optimize for certain adapter properties. The corresponding data structure for this value is D3D12_FEATURE_DATA_ARCHITECTURE1. + +
Note  This value supersedes the D3D_FEATURE_DATA_ARCHITECTURE value. If your application targets Windows 10, version 1703 (Creators' Update) or higher, then use D3D_FEATURE_DATA_ARCHITECTURE1.
+
 
 + + + Indicates a query for the level of support for depth-bounds tests and programmable sample positions. The corresponding data structure for this value is D3D12_FEATURE_DATA_D3D12_OPTIONS2. + + + Indicates a query for the level of support for shader caching. The corresponding data structure for this value is D3D12_FEATURE_DATA_SHADER_CACHE. + + + Indicates a query for the adapter's support for prioritization of different command queue types. The corresponding data structure for this value is D3D12_FEATURE_DATA_COMMAND_QUEUE_PRIORITY. + + + Indicates a query for the level of support for timestamp queries, format-casting, immediate write, view instancing, and barycentrics. The corresponding data structure for this value is D3D12_FEATURE_DATA_D3D12_OPTIONS3. + + + Indicates a query for whether or not the adapter supports creating heaps from existing system memory. The corresponding data structure for this value is D3D12_FEATURE_DATA_EXISTING_HEAPS. + + + Indicates a query for the level of support for 64KB-aligned MSAA textures, cross-API sharing, and native 16-bit shader operations. The corresponding data structure for this value is D3D12_FEATURE_DATA_D3D12_OPTIONS4. + + + Indicates a query for the level of support for heap serialization. The corresponding data structure for this value is D3D12_FEATURE_DATA_SERIALIZATION. + + + Indicates a query for the level of support for the sharing of resources between different adapters—for example, multiple GPUs. The corresponding data structure for this value is D3D12_FEATURE_DATA_CROSS_NODE. + + + Starting with Windows 10, version 1809 (10.0; Build 17763), indicates a query for the level of support for render passes, ray tracing, and shader-resource view tier 3 tiled resources. The corresponding data structure for this value is D3D12_FEATURE_DATA_D3D12_OPTIONS5. + + + Starting with Windows 10, version 1903 (10.0; Build 18362), indicates a query for the level of support for variable-rate shading (VRS), and indicates whether or not background processing is supported. For more info, see Variable-rate shading (VRS), and the Direct3D 12 background processing spec. + + + Indicates a query for the level of support for metacommands. The corresponding data structure for this value is D3D12_FEATURE_DATA_QUERY_META_COMMAND. + + + + Specifies options for a heap. + Microsoft Docs: + + + + Indicates default usage of a heap. + + + The flag D3D12_DESCRIPTOR_HEAP_FLAG_SHADER_VISIBLE can optionally be set on a descriptor heap to indicate it is be bound on a command list for reference by shaders. Descriptor heaps created without this flag allow applications the option to stage descriptors in CPU memory before copying them to a shader visible descriptor heap, as a convenience. But it is also fine for applications to directly create descriptors into shader visible descriptor heaps with no requirement to stage anything on the CPU. + +Descriptor heaps bound via [ID3D12GraphicsCommandList::SetDescriptorHeaps](/windows/win32/api/d3d12/nf-d3d12-id3d12graphicscommandlist-setdescriptorheaps) must have the D3D12_DESCRIPTOR_HEAP_FLAG_SHADER_VISIBLE flag set, else the debug layer will produce an error. + +Descriptor heaps with the D3D12_DESCRIPTOR_HEAP_FLAG_SHADER_VISIBLE flag can't be used as the source heaps in calls to [ID3D12Device::CopyDescriptors](/windows/win32/api/d3d12/nf-d3d12-id3d12device-copydescriptors) or [ID3D12Device::CopyDescriptorsSimple](/windows/win32/api/d3d12/nf-d3d12-id3d12device-copydescriptorssimple), because they could be resident in WRITE_COMBINE memory or GPU-local memory, which is very inefficient to read from. + +This flag only applies to CBV/SRV/UAV descriptor heaps, and sampler descriptor heaps. It does not apply to other descriptor heap types since shaders do not directly reference the other types. Attempting to create an RTV/DSV heap with D3D12_DESCRIPTOR_HEAP_FLAG_SHADER_VISIBLE results in a debug layer error. + + + + Describes rasterizer state. + Microsoft Docs: + + + + A D3D12_FILL_MODE-typed value that specifies the fill mode to use when rendering. + + + A D3D12_CULL_MODE-typed value that specifies that triangles facing the specified direction are not drawn. + + + Determines if a triangle is front- or back-facing. If this member is TRUE, a triangle will be considered front-facing if its vertices are counter-clockwise on the render target and considered back-facing if they are clockwise. If this parameter is FALSE, the opposite is true. + + + Depth value added to a given pixel. For info about depth bias, see Depth Bias. + + + Maximum depth bias of a pixel. For info about depth bias, see Depth Bias. + + + Scalar on a given pixel's slope. For info about depth bias, see Depth Bias. + + + Specifies whether to enable clipping based on distance. + + +The hardware always performs x and y clipping of rasterized coordinates. When DepthClipEnable is set to the default–TRUE, the hardware also clips the z value (that is, the hardware performs the last step of the following algorithm). + + +

+0 < w
+-w <= x <= w (or arbitrarily wider range if implementation uses a guard band to reduce clipping burden)
+-w <= y <= w (or arbitrarily wider range if implementation uses a guard band to reduce clipping burden)
+0 <= z <= w
+
+When you set DepthClipEnable to FALSE, the hardware skips the z clipping (that is, the last step in the preceding algorithm). However, the hardware still performs the "0 < w" clipping. When z clipping is disabled, improper depth ordering at the pixel level might result. However, when z clipping is disabled, stencil shadow implementations are simplified. In other words, you can avoid complex special-case handling for geometry that goes beyond the back clipping plane. + + + Specifies whether to use the quadrilateral or alpha line anti-aliasing algorithm on multisample antialiasing (MSAA) render targets. Set to TRUE to use the quadrilateral line anti-aliasing algorithm and to FALSE to use the alpha line anti-aliasing algorithm. For more info about this member, see Remarks. + + + Specifies whether to enable line antialiasing; only applies if doing line drawing and MultisampleEnable is FALSE. For more info about this member, see Remarks. + + + The sample count that is forced while UAV rendering or rasterizing. Valid values are 0, 1, 2, 4, 8, and optionally 16. 0 indicates that the sample count is not forced. + +
Note  If you want to render with ForcedSampleCount set to 1 or greater, you must follow these guidelines: + +
    +
  • Don't bind depth-stencil views.
    • +
  • Disable depth testing.
    • +
  • Ensure the shader doesn't output depth.
    • +
  • If you have any render-target views bound (D3D12_DESCRIPTOR_HEAP_TYPE_RTV) and ForcedSampleCount is greater than 1, ensure that every render target has only a single sample.
    • +
  • Don't operate the shader at sample frequency. Therefore, ID3D12ShaderReflection::IsSampleFrequencyShader returns FALSE.
    • +
Otherwise, rendering behavior is undefined.
+
 + + + A D3D12_CONSERVATIVE_RASTERIZATION_MODE-typed value that identifies whether conservative rasterization is on or off. + + + + Describes the subresources from an array of multi sampled 2D textures to use in a shader-resource view. + Microsoft Docs: + + + + The index of the first texture to use in an array of textures. + + + Number of textures to use. + + + + Represents a variable amount of configuration state, including shaders, that an application manages as a single unit and which is given to a driver atomically to process, such as compile or optimize. + Microsoft Docs: + + + + + Get the maximum number of messages that can be added to the message queue. + Microsoft Docs: + + + + + Describes a shader-variable type. + Microsoft Docs: + + + + A D3D_SHADER_VARIABLE_CLASS-typed value that identifies the variable class as one of scalar, vector, matrix, object, and so on. + + + A D3D_SHADER_VARIABLE_TYPE-typed value that identifies the variable type. + + + Number of rows in a matrix. Otherwise a numeric type returns 1, any other type returns 0. + + + Number of columns in a matrix. Otherwise a numeric type returns 1, any other type returns 0. + + + Number of elements in an array; otherwise 0. + + + Number of members in the structure; otherwise 0. + + + Offset, in bytes, between the start of the parent structure and this variable. Can be 0 if not a structure member. + + + Name of the shader-variable type. This member can be NULL if it isn't used. This member supports dynamic shader linkage interface types, which have names. For more info about dynamic shader linkage, see Dynamic Linking. + + + + Part of a contract between D3D11On12 diagnostic layers and graphics diagnostics tools. + Microsoft Docs: + + + + + Describes the subresources from a 3D texture to use in a shader-resource view. + Microsoft Docs: + + + + Index of the most detailed mipmap level to use; this number is between 0 and MipLevels (from the original Texture3D for which ID3D12Device::CreateShaderResourceView creates a view) -1. + + + The maximum number of mipmap levels for the view of the texture. See the remarks in D3D12_TEX1D_SRV. + +Set to -1 to indicate all the mipmap levels from MostDetailedMip on down to least detailed. + + + A value to clamp sample LOD values to. For example, if you specify 2.0f for the clamp value, you ensure that no individual sample accesses a mip level less than 2.0f. + + + + Specifies a bitstream encryption type. + Microsoft Docs: + + + + The bistream is not encrypted. + + + + Set a message identifier to break on when a message with that identifier passes through the storage filter. + Microsoft Docs: + Message identifier to break on. + Turns this breaking condition on or off (true for on, false for off). + + + + + Offers base functionality that allows for a consistent way to monitor the validity of a session across the different types of sessions. + Microsoft Docs: + + + + + Specifies flags to be used when creating a command queue. + Microsoft Docs: + + + + Indicates a default command queue. + + + Indicates that the GPU timeout should be disabled for this command queue. + + + + Encapsulates a list of graphics commands for rendering. Includes APIs for instrumenting the command list execution, and for setting and clearing the pipeline state. + Microsoft Docs: + + + + + Indicates the tier level at which view instancing is supported. + Microsoft Docs: + + + + View instancing is not supported. + + + View instancing is supported by draw-call level looping only. + + + View instancing is supported by draw-call level looping at worst, but the GPU can perform view instancing more efficiently in certain circumstances which are architecture-dependent. + + + View instancing is supported and instancing begins with the first shader stage that references SV_ViewID or with rasterization if no shader stage references SV_ViewID. This means that redundant work is eliminated across view instances when it's not dependent on SV_ViewID. Before rasterization, work that doesn't directly depend on SV_ViewID is shared across all views; only work that depends on SV_ViewID is repeated for each view. + +
Note  If a hull shader produces tessellation factors that are dependent on SV_ViewID, then tessellation and all subsequent work must be repeated per-view. Similarly, if the amount of geometry produced by the geometry shader depends on SV_ViewID, then the geometry shader must be repeated per-view before proceeding to rasterization.
+
 
+View instance masking only effects whether work that directly depends on SV_ViewID is performed, not the entire loop iteration (per-view). If the view instance mask is non-0, some work that depends on SV_ViewID might still be performed on masked-off pixels but will have no externally-visible effect; for example, no UAV writes are performed and clipping/rasterzation is not invoked. If the view instance mask is 0 no work is performed, including work that's not dependent on SV_ViewID. + + + + Sets a CPU descriptor handle for the unordered-access-view resource in the graphics root signature. + Microsoft Docs: + The slot number for binding. + The GPU virtual address of the buffer. + D3D12_GPU_VIRTUAL_ADDRESS is a typedef'd alias of UINT64. + + + + + Describes the size and layout of the serialized acceleration structure and header. + Microsoft Docs: + + + + The size of the serialized acceleration structure, including a header. The header is D3D12_SERIALIZED_RAYTRACING_ACCELERATION_STRUCTURE_HEADER followed by followed by a list of pointers to bottom-level acceleration structures. + + + The number of 64-bit GPU virtual addresses that will be at the start of the serialized acceleration structure, after the D3D12_SERIALIZED_RAYTRACING_ACCELERATION_STRUCTURE_HEADER. For a bottom-level acceleration structure this will be 0. For a top-level acceleration structure, the pointers indicate the acceleration structures being referred to. + +When deserialization occurs, these pointers to bottom-level pointers must be initialized by the app in the serialized data (just after the header) to the new locations where the bottom level acceleration structures will reside. It is not required that these new locations to have already been populated with bottom-level acceleration structures at deserialization time, as long as they are initialized with the expected deserialized data structures before being used in raytracing. During deserialization, the driver reads the new pointers, using them to produce an equivalent top-level acceleration structure to the original. + + + + Gets a description of how a resource is bound to a shader. + Microsoft Docs: + A zero-based resource index. + A pointer to an input-binding description. See D3D12_SHADER_INPUT_BIND_DESC. + + + + + Queues a GPU-side wait, and returns immediately. A GPU-side wait is where the GPU waits until the specified fence reaches or exceeds the specified value. + Microsoft Docs: + A pointer to the ID3D12Fence object. + The value that the command queue is waiting for the fence to reach or exceed. So when ID3D12Fence::GetCompletedValue is greater than or equal to Value, the wait is terminated. + + + + + Specifies the parameters for the input stream for a video decode operation. + Microsoft Docs: + + + + The count of frame parameters provided in the FrameArguments field. The maximum number of frame arguments is 10. + + + An array of D3D12_VIDEO_DECODE_FRAME_ARGUMENT structures containing the parameters to decode a frame. + + + A D3D12_VIDEO_DECODE_REFERENCE_FRAMES structure containing the reference frames needed to decode a frame. + + + A D3D12_VIDEO_DECODE_COMPRESSED_BITSTREAM structure representing the compressed bitstream in a single continuous buffer. + + + An ID3D12VideoDecoderHeap representing a pointer to the heap for the current decode resolution. + + + + Gets the number of Movc instructions. + Microsoft Docs: + + + + + Specifies the nature of the render pass; for example, whether it is a suspending or a resuming render pass. + Microsoft Docs: + + + + Indicates that the render pass has no special requirements. + + + Indicates that writes to unordered access view(s) should be allowed during the render pass. + + + Indicates that this is a suspending render pass. + + + Indicates that this is a resuming render pass. + + + + Gets the resource description. + Microsoft Docs: + + + + + Defines supported search block sizes for video motion estimation. + Microsoft Docs: + + + + The search block size is 8x8 pixels. + + + The search block size is 16x16 pixels. + + + + Gets the description of a shader-reflection-variable type. + Microsoft Docs: + A pointer to a shader-type description (see D3D12_SHADER_TYPE_DESC). + + + + + Identifies the tier level of conservative rasterization. + Microsoft Docs: + + + + Conservative rasterization is not supported. + + + Tier 1 enforces a maximum 1/2 pixel uncertainty region and does not support post-snap degenerates. This is good for tiled rendering, a texture atlas, light map generation and sub-pixel shadow maps. + + + Tier 2 reduces the maximum uncertainty region to 1/256 and requires post-snap degenerates not be culled. This tier is helpful for CPU-based algorithm acceleration (such as voxelization). + + + Tier 3 maintains a maximum 1/256 uncertainty region and adds support for inner input coverage. Inner input coverage adds the new value SV_InnerCoverage to High Level Shading Language (HLSL). This is a 32-bit scalar integer that can be specified on input to a pixel shader, and represents the underestimated conservative rasterization information (that is, whether a pixel is guaranteed-to-be-fully covered). This tier is helpful for occlusion culling. + + + + Encapsulates a list of graphics commands for video processing. + Microsoft Docs: + + + + + Gets a CPU pointer to the specified subresource in the resource, but may not disclose the pointer value to applications. Map also invalidates the CPU cache, when necessary, so that CPU reads to this address reflect any modifications made by the GPU. + Microsoft Docs: + Specifies the index number of the subresource. + A pointer to a D3D12_RANGE structure that describes the range of memory to access. + +This indicates the region the CPU might read, and the coordinates are subresource-relative. A null pointer indicates the entire subresource might be read by the CPU. It is valid to specify the CPU won't read any data by passing a range where End is less than or equal to Begin. + A pointer to a memory block that receives a pointer to the resource data. + +A null pointer is valid and is useful to cache a CPU virtual address range for methods like WriteToSubresource. When ppData is not NULL, the pointer returned is never offset by any values in pReadRange. + + + + + Describes the space requirement for acceleration structure after compaction. + Microsoft Docs: + + + + The space requirement for acceleration structure after compaction. + +It is guaranteed that a compacted acceleration structure doesn’t consume more space than a non-compacted acceleration structure. + +Pre-compaction, it is guaranteed that the size requirements reported by GetRaytracingAccelerationStructurePrebuildInfo for a given build configuration (triangle counts etc.) will be sufficient to store any acceleration structure whose build inputs are reduced (e.g. reducing triangle counts). This non-increasing property for smaller builds does not apply post-compaction, however. In other words, it is not guaranteed that having fewer items in an acceleration structure means it compresses to a smaller size than compressing an acceleration structure with more items. + + + + Contains input information for the video processor blend functionality. + Microsoft Docs: + + + + An ID3D12Resource representing the current input field or frame. + + + The subresource index to use of the pInputTexture argument. + + + A D3D12_VIDEO_PROCESS_REFERENCE_SET containing the set of references for video processing. Some video processing algorithms require forward or backward frame references. For more information, see D3D12_FEATURE_VIDEO_PROCESS_REFERENCE_INFO. + + + + Gets optional Command List Debug Layer settings. + Microsoft Docs: + Specifies a D3D12_DEBUG_COMMAND_LIST_PARAMETER_TYPE value that determines which debug parameter data to copy to the memory pointed to by pData. + Points to the memory that will be filled with a copy of the debug parameter data. The interpretation of this data depends on the D3D12_DEBUG_COMMAND_LIST_PARAMETER_TYPE given in the Type parameter. + Size in bytes of the memory buffer pointed to by pData. + + + + + Specifies the alpha fill mode for video processing. + Microsoft Docs: + + + + Alpha values inside the target rectangle are set to opaque. + + + Alpha values inside the target rectangle are set to the alpha value specified in the background color. + + + Existing alpha values remain unchanged in the output surface. + + + Alpha values are taken from an input stream, scaled, and copied to the corresponding destination rectangle for that stream. The input stream is specified in the AlphaFillModeSourceStreamIndex member of D3D12_VIDEO_PROCESS_OUTPUT_STREAM_ARGUMENTS. + +If the input stream does not have alpha data, the video processor sets the alpha values in the target rectangle to opaque. If the input stream is disabled or the source rectangle is empty, the alpha values in the target rectangle are not modified. + + + + Queries reflection metadata about the parameters of the specified meta command. + Microsoft Docs: + A reference to the globally unique identifier (GUID) of the meta command whose parameters you wish to be returned in pParameterDescs. + A D3D12_META_COMMAND_PARAMETER_STAGE specifying the stage of the parameters that you wish to be included in the query. + An optional pointer to a UINT containing the size of the structure containing the parameter values, which you pass when creating/initializing/executing the meta command, as appropriate. + A pointer to a UINT containing the number of parameters to query for. This field determines the size of the pParameterDescs array, unless pParameterDescs is nullptr. + An optional pointer to an array of D3D12_META_COMMAND_PARAMETER_DESC containing the descriptions of the parameters. Pass nullptr to have the parameter count returned in pParameterCount. + + + + + Retrieves the maximum number of enabled input streams supported by the video processor. + Microsoft Docs: + + + + An integer indicating which physical adapter of the device the operation applies to, in a multi-adapter operation. + + + The maximum number of streams that can be enabled for the video processor at the same time. + + + + Creates a constant-buffer view for accessing resource data. + Microsoft Docs: + A pointer to a D3D12_CONSTANT_BUFFER_VIEW_DESC structure that describes the constant-buffer view. + Describes the CPU descriptor handle that represents the start of the heap that holds the constant-buffer view. + + + + + A development-time aid for certain types of profiling and experimental prototyping. + Microsoft Docs: + Specifies a BOOL that turns the stable power state on or off. + + + + + Sets a CPU descriptor handle for the shader resource in the graphics root signature. + Microsoft Docs: + The slot number for binding. + The GPU virtual address of the Buffer. + Textures are not supported. D3D12_GPU_VIRTUAL_ADDRESS is a typedef'd alias of UINT64. + + + + + Manages a pipeline library. This interface extends ID3D12PipelineLibrary to load PSOs from a pipeline state stream description. + Microsoft Docs: + + + + + Represents the output stream for video processing commands. + Microsoft Docs: + + + + A pointer to a ID3D12Resource representing the output surfaces for the video process command. + + + The subresource indices to use within the resource specified pTexture2D resource. + + + + Flags for optional D3D12 Debug Layer features. + Microsoft Docs: + + + + The default. No optional Debug Layer features. + + + The Debug Layer is allowed to deliberately change functional behavior of an application in order to help identify potential errors. By default, the Debug Layer allows most invalid API usage to run the natural course. + + + Performs additional resource state validation of resources set in descriptors at the time ID3D12CommandQueue::ExecuteCommandLists is called. By design descriptors can be changed even after submitting command lists assuming proper synchronization. Conservative resource state tracking ignores this allowance and validates all resources used in descriptor tables when ExecuteCommandLists is called. The result may be false validation errors. + + + Disables validation of bundle commands by virtually injecting checks into the calling command list validation paths. + + + Internal use only. + + + + Describes the subresources from a resource that are accessible by using an unordered-access view. + Microsoft Docs: + + + + A DXGI_FORMAT-typed value that specifies the viewing format. + + + A D3D12_UAV_DIMENSION-typed value that specifies the resource type of the view. This type specifies how the resource will be accessed. This member also determines which _UAV to use in the union below. + + + A D3D12_BUFFER_UAV structure that specifies which buffer elements can be accessed. + + + A D3D12_TEX1D_UAV structure that specifies the subresources in a 1D texture that can be accessed. + + + A D3D12_TEX1D_ARRAY_UAV structure that specifies the subresources in a 1D texture array that can be accessed. + + + A D3D12_TEX2D_UAV structure that specifies the subresources in a 2D texture that can be accessed. + + + A D3D12_TEX2D_ARRAY_UAV structure that specifies the subresources in a 2D texture array that can be accessed. + + + A D3D12_TEX3D_UAV structure that specifies subresources in a 3D texture that can be accessed. + + + + Provides methods to monitor and debug a command queue. + Microsoft Docs: + + + + + An information-queue interface stores, retrieves, and filters debug messages. The queue consists of a message queue, an optional storage filter stack, and a optional retrieval filter stack. + Microsoft Docs: + + + + + Gets the size and alignment of memory required for a collection of resources on this adapter. + Microsoft Docs: + For single-GPU operation, set this to zero. If there are multiple GPU nodes, then set bits to identify the nodes (the device's physical adapters). Each bit in the mask corresponds to a single node. Also see [Multi-adapter systems](/windows/win32/direct3d12/multi-engine). + The number of resource descriptors in the pResourceDescs array. + An array of D3D12_RESOURCE_DESC structures that described the resources to get info about. + + + + + Push a copy of storage filter currently on the top of the storage-filter stack onto the storage-filter stack. + Microsoft Docs: + + + + + Describes a raytracing acceleration structure. Pass this structure into ID3D12GraphicsCommandList4::BuildRaytracingAccelerationStructure to describe the acceleration structure to be built. + Microsoft Docs: + + + + Location to store resulting acceleration structure. ID3D12Device5::GetRaytracingAccelerationStructurePrebuildInfo reports the amount of memory required for the result here given a set of acceleration structure build parameters. + +The address must be aligned to 256 bytes, defined as D3D12_RAYTRACING_ACCELERATION_STRUCTURE_BYTE_ALIGNMENT. + +> [!IMPORTANT] +> The memory must be in state [D3D12_RESOURCE_STATE_RAYTRACING_ACCELERATION_STRUCTURE](/windows/desktop/api/d3d12/ne-d3d12-d3d12_resource_states). + + + Description of the input data for the acceleration structure build. This is data is stored in a separate structure because it is also used with GetRaytracingAccelerationStructurePrebuildInfo. + + + Address of an existing acceleration structure if an acceleration structure update (an incremental build) is being requested, by setting D3D12_RAYTRACING_ACCELERATION_STRUCTURE_BUILD_FLAG_PERFORM_UPDATE in the Flags parameter. Otherwise this address must be NULL. + +If this address is the same as DestAccelerationStructureData, the update is to be performed in-place. Any other form of overlap of the source and destination memory is invalid and produces undefined behavior. + +The address must be aligned to 256 bytes, defined as D3D12_RAYTRACING_ACCELERATION_STRUCTURE_BYTE_ALIGNMENT, which should automatically be the case because any existing acceleration structure passed in here would have already been required to be placed with such alignment. + +> [!IMPORTANT] +> The memory must be in state [D3D12_RESOURCE_STATE_RAYTRACING_ACCELERATION_STRUCTURE](/windows/desktop/api/d3d12/ne-d3d12-d3d12_resource_states). + + + + Draws indexed, instanced primitives. + Microsoft Docs: + Number of indices read from the index buffer for each instance. + Number of instances to draw. + The location of the first index read by the GPU from the index buffer. + A value added to each index before reading a vertex from the vertex buffer. + A value added to each index before reading per-instance data from a vertex buffer. + + + + + Adds configurable levels of GPU-based validation to the debug layer. + Microsoft Docs: + + + + + Describes a raytracing hit group state subobject that can be included in a state object. + Microsoft Docs: + + + + The name of the hit group. + + + A value from the D3D12_HIT_GROUP_TYPE enumeration specifying the type of the hit group. + + + Optional name of the any-hit shader associated with the hit group. This field can be used with all hit group types. + + + Optional name of the closest-hit shader associated with the hit group. This field can be used with all hit group types. + + + Optional name of the intersection shader associated with the hit group. This field can only be used with hit groups of type procedural primitive. + + + + Describes the subresources of a texture that are accessible from a depth-stencil view. + Microsoft Docs: + + + + A DXGI_FORMAT-typed value that specifies the viewing format. For allowable formats, see Remarks. + + + A D3D12_DSV_DIMENSION-typed value that specifies how the depth-stencil resource will be accessed. This member also determines which _DSV to use in the following union. + + + A combination of D3D12_DSV_FLAGS enumeration constants that are combined by using a bitwise OR operation. + The resulting value specifies whether the texture is read only. + Pass 0 to specify that it isn't read only; otherwise, pass one or more of the members of the D3D12_DSV_FLAGS enumerated type. + + + A D3D12_TEX1D_DSV structure that specifies a 1D texture subresource. + + + A D3D12_TEX1D_ARRAY_DSV structure that specifies an array of 1D texture subresources. + + + A D3D12_TEX2D_DSV structure that specifies a 2D texture subresource. + + + A D3D12_TEX2D_ARRAY_DSV structure that specifies an array of 2D texture subresources. + + + A D3D12_TEX2DMS_DSV structure that specifies a multisampled 2D texture. + + + A D3D12_TEX2DMS_ARRAY_DSV structure that specifies an array of multisampled 2D textures. + + + + Specifies device-wide debug layer settings. + Microsoft Docs: + + + + + This subobject is unsupported in the current release. + Microsoft Docs: + + + + Size of the pExports array. If 0, this is being explicitly defined as a default association. Another way to define a default association is to omit this subobject association for that subobject completely. + + + The array of exports with which the subobject is associated. + + + + Gets the layout of the root signature, without converting between root signature versions. + Microsoft Docs: + + + + + Gets the layout of the root signature. + Microsoft Docs: + + + + + Specifies the settings used for luma keying. + Microsoft Docs: + + + + A boolean value specifying whether luma keying is enabled. + + + The lower bound for the luma key. The valid range is [0…1]. If Enable is FALSE, this parameter is ignored. + + + The upper bound for the luma key. The valid range is [0…1]. If Enable is FALSE, this parameter is ignored. + + + + Specifies the type of a raytracing acceleration structure. + Microsoft Docs: + + + + Top-level acceleration structure. + + + Bottom-level acceleration structure. + + + + Sets CPU descriptor handles for the render targets and depth stencil. + Microsoft Docs: + The number of entries in the pRenderTargetDescriptors array (ranges between 0 and D3D12_SIMULTANEOUS_RENDER_TARGET_COUNT). If this parameter is nonzero, the number of entries in the array to which pRenderTargetDescriptors points must equal the number in this parameter. + Specifies an array of D3D12_CPU_DESCRIPTOR_HANDLE structures that describe the CPU descriptor handles that represents the start of the heap of render target descriptors. If this parameter is NULL and NumRenderTargetDescriptors is 0, no render targets are bound. + True means the handle passed in is the pointer to a contiguous range of NumRenderTargetDescriptors descriptors. This case is useful if the set of descriptors to bind already happens to be contiguous in memory (so all that’s needed is a handle to the first one). For example, if NumRenderTargetDescriptors is 3 then the memory layout is taken as follows: + +Memory layout with parameter set to true +In this case the driver dereferences the handle and then increments the memory being pointed to. + +False means that the handle is the first of an array of NumRenderTargetDescriptors handles. The false case allows an application to bind a set of descriptors from different locations at once. Again assuming that NumRenderTargetDescriptors is 3, the memory layout is taken as follows: + +Memory layout with parameter set to false +In this case the driver dereferences three handles that are expected to be adjacent to each other in memory. + A pointer to a D3D12_CPU_DESCRIPTOR_HANDLE structure that describes the CPU descriptor handle that represents the start of the heap that holds the depth stencil descriptor. If this parameter is NULL, no depth stencil descriptor is bound. + + + + + Gets information about the features that are supported by the current graphics driver. + Microsoft Docs: + A constant from the D3D12_FEATURE enumeration describing the feature(s) that you want to query for support. + A pointer to a data structure that corresponds to the value of the Feature parameter. To determine the corresponding data structure for each constant, see D3D12_FEATURE. + The size of the structure pointed to by the pFeatureSupportData parameter. + + + + + Describes the level of GPU-based validation to perform at runtime. + Microsoft Docs: + + + + Default behavior; resource states, descriptors, and descriptor tables are all validated. + + + When set, GPU-based validation does not perform resource state validation which greatly reduces the performance cost of GPU-based validtion. Descriptors and descriptor heaps are still validated. + + + + Describes a ID3D12VideoMotionEstimatorHeap. Pass this structure into ID3D12VideoDevice1::CreateVideoMotionEstimatorHeap to create an instance of ID3D12VideoMotionEstimatorHeap. + Microsoft Docs: + + + + The node mask specifying the physical adapter on which the video processor will be used. For single GPU operation, set this to zero. If there are multiple GPU nodes, set a bit to identify the node, i.e. the device's physical adapter, to which the command queue applies. Each bit in the mask corresponds to a single node. Only 1 bit may be set. + + + A value from the DXGI_FORMAT enumeration specifying the format of the input and reference frames. + + + A value from the D3D12_VIDEO_MOTION_ESTIMATOR_SEARCH_BLOCK_SIZE enumeration specifying the search block size the video motion estimator will use. + + + A value from the D3D12_VIDEO_MOTION_ESTIMATOR_VECTOR_PRECISION enumeration specifying the vector precision the video motion estimator will use. + + + A D3D12_VIDEO_SIZE_RANGE structure representing the minimum and maximum input and reference frame size, in pixels, that the motion estimator will accept. + + + + Sets a rendering predicate. + Microsoft Docs: + The buffer, as an ID3D12Resource, which must be in the [D3D12_RESOURCE_STATE_PREDICATION](/windows/win32/api/d3d12/ne-d3d12-d3d12_resource_states) or [D3D21_RESOURCE_STATE_INDIRECT_ARGUMENT](/windows/win32/api/d3d12/ne-d3d12-d3d12_resource_states) state (both values are identical, and provided as aliases for clarity), or NULL to disable predication. + The aligned buffer offset, as a UINT64. + Specifies a D3D12_PREDICATION_OP, such as D3D12_PREDICATION_OP_EQUAL_ZERO or D3D12_PREDICATION_OP_NOT_EQUAL_ZERO. + + + + + Enables a list of experimental features. + Microsoft Docs: + The number of experimental features to enable. + SAL: __in_ecount(NumFeatures) + +A pointer to an array of IDs that specify which of the available experimental features to enable. + SAL: __in_ecount(NumFeatures) + +Structures that contain additional configuration details that some experimental features might need to be enabled. + SAL: __in_ecount(NumFeatures) + +The sizes of any configuration structs passed in pConfigurationStructs parameter. + + + + + Describes an array of unordered-access 2D texture resources. + Microsoft Docs: + + + + The mipmap slice index. + + + The zero-based index of the first array slice to be accessed. + + + The number of slices in the array. + + + The index (plane slice number) of the plane to use in an array of textures. + + + + Describes a graphics pipeline state object. + Microsoft Docs: + + + + A pointer to the ID3D12RootSignature object. + + + A D3D12_SHADER_BYTECODE structure that describes the vertex shader. + + + A D3D12_SHADER_BYTECODE structure that describes the pixel shader. + + + A D3D12_SHADER_BYTECODE structure that describes the domain shader. + + + A D3D12_SHADER_BYTECODE structure that describes the hull shader. + + + A D3D12_SHADER_BYTECODE structure that describes the geometry shader. + + + A D3D12_STREAM_OUTPUT_DESC structure that describes a streaming output buffer. + + + A D3D12_BLEND_DESC structure that describes the blend state. + + + The sample mask for the blend state. + + + A D3D12_RASTERIZER_DESC structure that describes the rasterizer state. + + + A D3D12_DEPTH_STENCIL_DESC structure that describes the depth-stencil state. + + + A D3D12_INPUT_LAYOUT_DESC structure that describes the input-buffer data for the input-assembler stage. + + + Specifies the properties of the index buffer in a D3D12_INDEX_BUFFER_STRIP_CUT_VALUE structure. + + + A D3D12_PRIMITIVE_TOPOLOGY_TYPE-typed value for the type of primitive, and ordering of the primitive data. + + + The number of render target formats in the RTVFormats member. + + + An array of DXGI_FORMAT-typed values for the render target formats. + + + A DXGI_FORMAT-typed value for the depth-stencil format. + + + A DXGI_SAMPLE_DESC structure that specifies multisampling parameters. + + + For single GPU operation, set this to zero. If there are multiple GPU nodes, set bits to identify the nodes (the device's physical adapters) for which the graphics pipeline state is to apply. + Each bit in the mask corresponds to a single node. + Refer to Multi-adapter systems. + + + A cached pipeline state object, as a D3D12_CACHED_PIPELINE_STATE structure. pCachedBlob and CachedBlobSizeInBytes may be set to NULL and 0 respectively. + + + A D3D12_PIPELINE_STATE_FLAGS enumeration constant such as for "tool debug". + + + + Describes a subresource memory range. + Microsoft Docs: + + + + The index of the subresource. + + + A memory range within the subresource. + + + + This shader-reflection interface provides access to a constant buffer. + Microsoft Docs: + + + + + Resets a command list back to its initial state as if a new command list was just created. + Microsoft Docs: + A pointer to the ID3D12CommandAllocator object that the device creates command lists from. + A pointer to the ID3D12PipelineState object that contains the initial pipeline state for the command list. This is optional and can be NULL. If NULL, the runtime sets a dummy initial pipeline state so that drivers don't have to deal with undefined state. The overhead for this is low, particularly for a command list, for which the overall cost of recording the command list likely dwarfs the cost of one initial state setting. So there is little cost in not setting the initial pipeline state parameter if it isn't convenient. + +For bundles on the other hand, it might make more sense to try to set the initial state parameter since bundles are likely smaller overall and can be reused frequently. + + + + + Copies the entire contents of the source resource to the destination resource. + Microsoft Docs: + A pointer to the ID3D12Resourceinterface that represents the destination resource. + A pointer to the ID3D12Resourceinterface that represents the source resource. + + + + + Describes the transition of subresources between different usages. + Microsoft Docs: + + + + A pointer to the ID3D12Resource object that represents the resource used in the transition. + + + The index of the subresource for the transition. + Use the D3D12_RESOURCE_BARRIER_ALL_SUBRESOURCES flag ( 0xffffffff ) to transition all subresources in a resource at the same time. + + + The "before" usages of the subresources, as a bitwise-OR'd combination of D3D12_RESOURCE_STATES enumeration constants. + + + The "after" usages of the subresources, as a bitwise-OR'd combination of D3D12_RESOURCE_STATES enumeration constants. + + + + Specifies the type of a sub-object in a pipeline state stream description. + Microsoft Docs: + + + + Indicates a root signature subobject type. +The corresponding subobject type is ID3D12RootSignature. + + + Indicates a vertex shader subobject type. +The corresponding subobject type is D3D12_SHADER_BYTECODE. + + + Indicates a pixel shader subobject type. +The corresponding subobject type is D3D12_SHADER_BYTECODE. + + + Indicates a domain shader subobject type. +The corresponding subobject type is D3D12_SHADER_BYTECODE. + + + Indicates a hull shader subobject type. +The corresponding subobject type is D3D12_SHADER_BYTECODE. + + + Indicates a geometry shader subobject type. +The corresponding subobject type is D3D12_SHADER_BYTECODE. + + + Indicates a compute shader subobject type. +The corresponding subobject type is D3D12_SHADER_BYTECODE. + + + Indicates a stream-output subobject type. +The corresponding subobject type is D3D12_STREAM_OUTPUT_DESC. + + + Indicates a blend subobject type. +The corresponding subobject type is D3D12_BLEND_DESC. + + + Indicates a sample mask subobject type. +The corresponding subobject type is UINT. + + + Indicates indicates a rasterizer subobject type. +The corresponding subobject type is D3D12_RASTERIZER_DESC. + + + Indicates a depth stencil subobject type. +The corresponding subobject type is D3D12_DEPTH_STENCIL_DESC. + + + Indicates an input layout subobject type. +The corresponding subobject type is D3D12_INPUT_LAYOUT_DESC. + + + Indicates an index buffer strip cut value subobject type. +The corresponding subobject type is D3D12_INDEX_BUFFER_STRIP_CUT_VALUE. + + + Indicates a primitive topology subobject type. +The corresponding subobject type is D3D12_PRIMITIVE_TOPOLOGY_TYPE. + + + Indicates a render target formats subobject type. The corresponding subobject type is D3D12_RT_FORMAT_ARRAY structure, which wraps an array of render target formats along with a count of the array elements. + + + Indicates a depth stencil format subobject. +The corresponding subobject type is DXGI_FORMAT. + + + Indicates a sample description subobject type. +The corresponding subobject type is DXGI_SAMPLE_DESC. + + + Indicates a node mask subobject type. +The corresponding subobject type is D3D12_NODE_MASK or UINT. + + + Indicates a cached pipeline state object subobject type. +The corresponding subobject type is D3D12_CACHED_PIPELINE_STATE. + + + Indicates a flags subobject type. +The corresponding subobject type is D3D12_PIPELINE_STATE_FLAGS. + + + Indicates an expanded depth stencil subobject type. This expansion of the depth stencil subobject supports optional depth bounds checking. +The corresponding subobject type is D3D12_DEPTH_STENCIL_DESC1. + + + Indicates a view instancing subobject type. +The corresponding subobject type is D3D12_VIEW_INSTANCING_DESC. + + + Indicates an amplification shader subobject type. +The corresponding subobject type is D3D12_SHADER_BYTECODE. + + + Indicates a mesh shader subobject type. +The corresponding subobject type is D3D12_SHADER_BYTECODE. + + + A sentinel value that marks the exclusive upper-bound of valid values this enumeration represents. + + + + This method uses the GPU to copy texture data between two locations. Both the source and the destination may reference texture data located within either a buffer resource or a texture resource. + Microsoft Docs: + Specifies the destination D3D12_TEXTURE_COPY_LOCATION. The subresource referred to must be in the D3D12_RESOURCE_STATE_COPY_DEST state. + The x-coordinate of the upper left corner of the destination region. + The y-coordinate of the upper left corner of the destination region. For a 1D subresource, this must be zero. + The z-coordinate of the upper left corner of the destination region. For a 1D or 2D subresource, this must be zero. + Specifies the source D3D12_TEXTURE_COPY_LOCATION. + The subresource referred to must be in the D3D12_RESOURCE_STATE_COPY_SOURCE state. + Specifies an optional D3D12_BOX that sets the size of the source texture to copy. + + + + + Gets a pointer to the device that created this interface. + Microsoft Docs: + The globally unique identifier (GUID) for the device interface. + The REFIID, or GUID, of the interface to the device can be obtained by using the __uuidof() macro. + For example, __uuidof(ID3D12Device) will get the GUID of the interface to a device. + A pointer to a memory block that receives a pointer to the ID3D12Device interface for the device. + + + + + Defines constants that specify protected resource session support. + Microsoft Docs: + + + + Indicates that protected resource sessions are not supported. + + + Indicates that protected resource sessions are supported. + + + + Specifies the scaling capabilities of the video scaler. + Microsoft Docs: + + + + All possible output size width/height combinations that exist between the maximum size and minimum size for the extent, inclusive, are supported. + + + The scaler only supports output sizes at a power of two scale factors within the range. The x and y scale factors must be the same for both dimensions when this flag is set. + + + The scaler only supports output sizes with even output dimensions. + + + + Describes a sampler state. + Microsoft Docs: + + + + A D3D12_FILTER-typed value that specifies the filtering method to use when sampling a texture. + + + A D3D12_TEXTURE_ADDRESS_MODE-typed value that specifies the method to use for resolving a u texture coordinate that is outside the 0 to 1 range. + + + A D3D12_TEXTURE_ADDRESS_MODE-typed value that specifies the method to use for resolving a v texture coordinate that is outside the 0 to 1 range. + + + A D3D12_TEXTURE_ADDRESS_MODE-typed value that specifies the method to use for resolving a w texture coordinate that is outside the 0 to 1 range. + + + Offset from the calculated mipmap level. For example, if the runtime calculates that a texture should be sampled at mipmap level 3 and MipLODBias is 2, the texture will be sampled at mipmap level 5. + + + Clamping value used if D3D12_FILTER_ANISOTROPIC or D3D12_FILTER_COMPARISON_ANISOTROPIC is specified in Filter. Valid values are between 1 and 16. + + + A D3D12_COMPARISON_FUNC-typed value that specifies a function that compares sampled data against existing sampled data. + + + Border color to use if D3D12_TEXTURE_ADDRESS_MODE_BORDER is specified for AddressU, AddressV, or AddressW. Range must be between 0.0 and 1.0 inclusive. + + + Lower end of the mipmap range to clamp access to, where 0 is the largest and most detailed mipmap level and any level higher than that is less detailed. + + + Upper end of the mipmap range to clamp access to, where 0 is the largest and most detailed mipmap level and any level higher than that is less detailed. This value must be greater than or equal to MinLOD. To have no upper limit on LOD, set this member to a large value. + + + + Describes a resource to resolve to at the conclusion of a render pass. + Microsoft Docs: + + + + A pointer to an ID3D12Resource. The source resource. + + + A pointer to an ID3D12Resource. The destination resource. + + + A UINT. The number of subresources. + + + A pointer to a constant array of D3D12_RENDER_PASS_ENDING_ACCESS_RESOLVE_SUBRESOURCE_PARAMETERS. These subresources can be a subset of the render target's array slices, but you can't target subresources that aren't part of the render target view (RTV) or the depth/stencil view (DSV). + +> [!NOTE] +> This pointer is directly referenced by the command list, and the memory for this array must remain alive and intact until EndRenderPass is called. + + + A DXGI_FORMAT. The data format of the resources. + + + A D3D12_RESOLVE_MODE. The resolve operation. + + + A BOOL. TRUE to preserve the resolve source, otherwise FALSE. + + + + Represents a virtual adapter. This interface extends ID3D12Device4. + Microsoft Docs: + + + + + Retrieves video extension command support using command-defined input and output structures. + Microsoft Docs: + + + + For single GPU operation, set this to zero. If there are multiple GPU nodes, set a bit to identify the node (the device's physical adapter) to which the command queue applies. Each bit in the mask corresponds to a single node. Only 1 bit may be set. + + + The unique identifier for the video extension command for which support is queried. + + + Input data for the capability query allocated by the caller with a size of InputDataSizeInBytes. This struct is enumerable as the D3D12_VIDEO_EXTENSION_COMMAND_PARAMETER_STAGE_CAPS_INPUT parameter stage. + + + The byte size of the input data allocation. + + + Output data for the capability query allocated by the caller with a size of OutputDataSizeInBytes. This struct is enumerable as the D3D12_VIDEO_EXTENSION_COMMAND_PARAMETER_STAGE_CAPS_OUTPUT parameter stage. + + + The byte size of the output data allocation. + + + + Describes a streaming output buffer. + Microsoft Docs: + + + + An array of D3D12_SO_DECLARATION_ENTRY structures. Can't be NULL if NumEntries > 0. + + + The number of entries in the stream output declaration array that the pSODeclaration member points to. + + + An array of buffer strides; each stride is the size of an element for that buffer. + + + The number of strides (or buffers) that the pBufferStrides member points to. + + + The index number of the stream to be sent to the rasterizer stage. + + + + Bind an array of viewports to the rasterizer stage of the pipeline. + Microsoft Docs: + Number of viewports to bind. + The range of valid values is (0, D3D12_VIEWPORT_AND_SCISSORRECT_OBJECT_COUNT_PER_PIPELINE). + An array of D3D12_VIEWPORT structures to bind to the device. + + + + + Describes depth-stencil state. + Microsoft Docs: + + + + Specifies whether to enable depth testing. Set this member to TRUE to enable depth testing. + + + A D3D12_DEPTH_WRITE_MASK-typed value that identifies a portion of the depth-stencil buffer that can be modified by depth data. + + + A D3D12_COMPARISON_FUNC-typed value that identifies a function that compares depth data against existing depth data. + + + Specifies whether to enable stencil testing. Set this member to TRUE to enable stencil testing. + + + Identify a portion of the depth-stencil buffer for reading stencil data. + + + Identify a portion of the depth-stencil buffer for writing stencil data. + + + A D3D12_DEPTH_STENCILOP_DESC structure that describes how to use the results of the depth test and the stencil test for pixels whose surface normal is facing towards the camera. + + + A D3D12_DEPTH_STENCILOP_DESC structure that describes how to use the results of the depth test and the stencil test for pixels whose surface normal is facing away from the camera. + + + + Describes a static sampler. + Microsoft Docs: + + + + The filtering method to use when sampling a texture, as a D3D12_FILTER enumeration constant. + + + Specifies the D3D12_TEXTURE_ADDRESS_MODE mode to use for resolving a u texture coordinate that is outside the 0 to 1 range. + + + Specifies the D3D12_TEXTURE_ADDRESS_MODE mode to use for resolving a v texture coordinate that is outside the 0 to 1 range. + + + Specifies the D3D12_TEXTURE_ADDRESS_MODE mode to use for resolving a w texture coordinate that is outside the 0 to 1 range. + + + Offset from the calculated mipmap level. For example, if Direct3D calculates that a texture should be sampled at mipmap level 3 and MipLODBias is 2, then the texture will be sampled at mipmap level 5. + + + Clamping value used if D3D12_FILTER_ANISOTROPIC or D3D12_FILTER_COMPARISON_ANISOTROPIC is specified as the filter. Valid values are between 1 and 16. + + + A function that compares sampled data against existing sampled data. + The function options are listed in D3D12_COMPARISON_FUNC. + + + One member of D3D12_STATIC_BORDER_COLOR, the border color to use if D3D12_TEXTURE_ADDRESS_MODE_BORDER is specified for AddressU, AddressV, or AddressW. + Range must be between 0.0 and 1.0 inclusive. + + + Lower end of the mipmap range to clamp access to, where 0 is the largest and most detailed mipmap level and any level higher than that is less detailed. + + + Upper end of the mipmap range to clamp access to, where 0 is the largest and most detailed mipmap level and any level higher than that is less detailed. This value must be greater than or equal to MinLOD. To have no upper limit on LOD set this to a large value such as D3D12_FLOAT32_MAX. + + + The ShaderRegister and RegisterSpace parameters correspond to the binding syntax of HLSL. For example, in HLSL: + + +
Texture2D<float4> a : register(t2, space3);
+This corresponds to a ShaderRegister of 2 (indicating the type is SRV), and RegisterSpace is 3. + + +The ShaderRegister and RegisterSpace pair is needed to establish correspondence between shader resources and runtime heap descriptors, using the root signature data structure. + + + See the description for ShaderRegister. + Register space is optional; the default register space is 0. + + + Specifies the visibility of the sampler to the pipeline shaders, one member of D3D12_SHADER_VISIBILITY. + + + + This method enables tools such as PIX to instrument shaders. + Microsoft Docs: + TRUE to enable shader instrumentation; otherwise, FALSE. + + + + + Indicates the level of support for 64KB-aligned MSAA textures, cross-API sharing, and native 16-bit shader operations. + Microsoft Docs: + + + + Indicates whether 64KB-aligned MSAA textures are supported. + + + Indicates the tier of cross-API sharing support. + + + Indicates native 16-bit shader operations are supported. These operations require shader model 6_2. For more information, see the [16-Bit Scalar Types](https://github.com/microsoft/DirectXShaderCompiler/wiki/16-Bit-Scalar-Types) HLSL reference. + + + + Specifies an event that should be fired when one or more of a collection of fences reach specific values. + Microsoft Docs: + An array of length NumFences that specifies the ID3D12Fence objects. + An array of length NumFences that specifies the fence values required for the event is to be signaled. + Specifies the number of fences to be included. + Specifies one of the D3D12_MULTIPLE_FENCE_WAIT_FLAGS that determines how to proceed. + A handle to the event object. + + + + + Describes a GPU descriptor handle. + Microsoft Docs: + + + + The address of the descriptor. + + + + A debug message in the Information Queue. + Microsoft Docs: + + + + The category of the message. See D3D12_MESSAGE_CATEGORY. + + + The severity of the message. See D3D12_MESSAGE_SEVERITY. + + + The ID of the message. See D3D12_MESSAGE_ID. + + + The message string. + + + The length of pDescription, in bytes. + + + + The flags to apply when exporting symbols from a state subobject. + Microsoft Docs: + + + + No export flags. + + + + Gets the flags used to create the fence represented by the current instance. + Microsoft Docs: + + + + + A state subobject that represents a raytracing pipeline configuration. + Microsoft Docs: + + + + Limit on ray recursion for the raytracing pipeline. It must be in the range of 0 to 31. Below the maximum recursion depth, shader invocations such as closest hit or miss shaders can call TraceRay any number of times. At the maximum recursion depth, TraceRay calls result in the device going into removed state. + + + + Describes a heap. + Microsoft Docs: + + + + The size, in bytes, of the heap. + To avoid wasting memory, applications should pass SizeInBytes values which are multiples of the effective Alignment; + but non-aligned SizeInBytes is also supported, for convenience. + To find out how large a heap must be to support textures with undefined layouts and adapter-specific sizes, call ID3D12Device::GetResourceAllocationInfo. + + + A D3D12_HEAP_PROPERTIES structure that describes the heap properties. + + + The alignment value for the heap. Valid values: + + + + + + + + + + + + + + + + + + + +
ValueDescription
0 + An alias for 64KB. +
D3D12_DEFAULT_RESOURCE_PLACEMENT_ALIGNMENT + #defined as 64KB. +
D3D12_DEFAULT_MSAA_RESOURCE_PLACEMENT_ALIGNMENT + #defined as 4MB. + An application must decide whether the heap will contain multi-sample anti-aliasing (MSAA), in which case, the application must choose D3D12_DEFAULT_MSAA_RESOURCE_PLACEMENT_ALIGNMENT. +
+ + + A combination of D3D12_HEAP_FLAGS-typed values that are combined by using a bitwise-OR operation. + The resulting value identifies heap options. + When creating heaps to support adapters with resource heap tier 1, an application must choose some flags. + + + + Specifies parameters used during view instancing configuration. + Microsoft Docs: + + + + Specifies the number of views to be used, up to D3D12_MAX_VIEW_INSTANCE_COUNT. + + + The address of a memory location that contains ViewInstanceCount view instance location structures that specify the location of viewport/scissor and render target details of each view instance. + + + Configures view instancing with additional options. + + + + Creates a shared handle to an heap, resource, or fence object. + Microsoft Docs: + A pointer to the ID3D12DeviceChild interface that represents the heap, resource, or fence object to create for sharing. + The following interfaces (derived from ID3D12DeviceChild) are supported: + + + + A pointer to a SECURITY_ATTRIBUTESstructure that contains two separate but related data members: an optional security descriptor, and a Booleanvalue that determines whether child processes can inherit the returned handle. + + +Set this parameter to NULL if you want child processes that the + application might create to not inherit the handle returned by + CreateSharedHandle, and if you want the resource that is associated with the returned handle to get a default security + descriptor. + + +The lpSecurityDescriptor member of the structure specifies a + SECURITY_DESCRIPTOR for the resource. + Set this member to NULL if you want the runtime to assign a default security descriptor to the resource that is associated with the returned handle. + The ACLs in the default security descriptor for the resource come from the primary or impersonation token of the creator. + For more info, see Synchronization Object Security and Access Rights. + Currently the only value this parameter accepts is GENERIC_ALL. + A NULL-terminated UNICODE string that contains the name to associate with the shared heap. + The name is limited to MAX_PATH characters. + Name comparison is case-sensitive. + + +If Name matches the name of an existing resource, CreateSharedHandle fails with DXGI_ERROR_NAME_ALREADY_EXISTS. + This occurs because these objects share the same namespace. + + +The name can have a "Global\" or "Local\" prefix to explicitly create the object in the global or session namespace. + The remainder of the name can contain any character except the backslash character (\\). + For more information, see + Kernel Object Namespaces. + Fast user switching is implemented using Terminal Services sessions. + Kernel object names must follow the guidelines outlined for Terminal Services so that applications can support multiple users. + + +The object can be created in a private namespace. + For more information, see Object Namespaces. + A pointer to a variable that receives the NT HANDLE value to the resource to share. + You can use this handle in calls to access the resource. + + + + + Represents a subobject within a state object description. Use with D3D12_STATE_OBJECT_DESC. + Microsoft Docs: + + + + A D3D12_STATE_SUBOBJECT_TYPE specifying the type of the state subobject. + + + Pointer to state object description of the type specified in the Type parameter. + + + + Encapsulates a list of graphics commands for rendering. + Microsoft Docs: + + + + + Generates an interface that can return the deserialized data structure, via GetUnconvertedRootSignatureDesc. + Microsoft Docs: + A pointer to the source data for the serialized root signature. + The size, in bytes, of the block of memory that pSrcData points to. + The globally unique identifier (GUID) for the root signature deserializer interface. See remarks. + A pointer to a memory block that receives a pointer to the root signature deserializer. + + + + + Encapsulates a list of graphics commands for rendering, extending the interface to support variable-rate shading (VRS). + Microsoft Docs: + + + + + Queries reflection metadata about available meta commands. + Microsoft Docs: + A pointer to a UINT containing the number of meta commands to query for. This field determines the size of the pDescs array, unless pDescs is nullptr. + An optional pointer to an array of D3D12_META_COMMAND_DESC containing the descriptions of the available meta commands. Pass nullptr to have the number of available meta commands returned in pNumMetaCommands. + + + + + Describes the subresources from a multi sampled 2D texture to use in a shader-resource view. + Microsoft Docs: + + + + Integer of any value. See remarks. + + + + Creates an instance of the specified meta command. + Microsoft Docs: + A reference to the globally unique identifier (GUID) of the meta command that you wish to instantiate. + For single-adapter operation, set this to zero. If there are multiple adapter nodes, set a bit to identify the node (one of the device's physical adapters) to which the meta command applies. Each bit in the mask corresponds to a single node. Only one bit must be set. See Multi-adapter systems. + An optional pointer to a constant structure containing the values of the parameters for creating the meta command. + A SIZE_T containing the size of the structure pointed to by pCreationParametersData, if set, otherwise 0. + A reference to the globally unique identifier (GUID) of the interface that you wish to be returned in ppMetaCommand. This is expected to be the GUID of ID3D12MetaCommand. + A pointer to a memory block that receives a pointer to the meta command. This is the address of a pointer to an ID3D12MetaCommand, representing the meta command created. + + + + + Specifies a resolve operation. + Microsoft Docs: + + + + Resolves compressed source samples to their uncompressed values. When using this operation, the source and destination resources must have the same sample count, unlike the min, max, and average operations that require the destination to have a sample count of 1. + + + Resolves the source samples to their minimum value. It can be used with any render target or depth stencil format. + + + Resolves the source samples to their maximum value. It can be used with any render target or depth stencil format. + + + Resolves the source samples to their average value. It can be used with any non-integer render target format, including the depth plane. It can't be used with integer render target formats, including the stencil plane. + + + + Not intended to be called directly.  Use the PIX event runtime to insert events into a command list. + Microsoft Docs: + + + + + Description of a state object. Pass this structure into ID3D12Device::CreateStateObject. + Microsoft Docs: + + + + The type of the state object. + + + Size of the pSubobjects array. + + + An array of subobject definitions. + + + + Describes the slot of a root signature version 1.0. + Microsoft Docs: + + + + A D3D12_ROOT_PARAMETER_TYPE-typed value that specifies the type of root signature slot. This member determines which type to use in the union below. + + + A D3D12_ROOT_DESCRIPTOR_TABLE structure that describes the layout of a descriptor table as a collection of descriptor ranges that appear one after the other in a descriptor heap. + + + A D3D12_ROOT_CONSTANTS structure that describes constants inline in the root signature that appear in shaders as one constant buffer. + + + A D3D12_ROOT_DESCRIPTOR structure that describes descriptors inline in the root signature that appear in shaders. + + + A D3D12_SHADER_VISIBILITY-typed value that specifies the shaders that can access the contents of the root signature slot. + + + + Describes an export from a state subobject such as a DXIL library or a collection state object. + Microsoft Docs: + + + + The name to be exported. If the name refers to a function that is overloaded, a modified version of the name (e.g. encoding function parameter information in name string) can be provided to disambiguate which overload to use. The modified name for a function can be retrieved using HLSL compiler reflection. + +If the ExportToRename field is non-null, Name refers to the new name to use for it when exported. In this case Name must be the unmodified name, whereas ExportToRename can be either a modified or unmodified name. A given internal name may be exported multiple times with different renames (and/or not renamed). + + + If non-null, this is the name of an export to use but then rename when exported. + + + + Describes a constant buffer to view. + Microsoft Docs: + + + + The D3D12_GPU_VIRTUAL_ADDRESS of the constant buffer. + D3D12_GPU_VIRTUAL_ADDRESS is a typedef'd alias of UINT64. + + + The size in bytes of the constant buffer. + + + + Describes the root signature 1.0 layout of a descriptor table as a collection of descriptor ranges that are all relative to a single base descriptor handle. + Microsoft Docs: + + + + The number of descriptor ranges in the table layout. + + + An array of D3D12_DESCRIPTOR_RANGE structures that describe the descriptor ranges. + + + + Specifies the parameters for the input stream for a video process operation. + Microsoft Docs: + + + + A value from the DXGI_FORMAT enumeration specifying the format of the input stream. In the case of stereo, this format is the format of both inputs. + + + A value from the DXGI_COLOR_SPACE_TYPE enumeration specifying the color space of the video processor input and reference surfaces. + + + A DXGI_RATIONAL structure specifying the source aspect ratio. + + + A DXGI_RATIONAL structure specifying the destination aspect ratio. + + + A DXGI_RATIONAL structure specifying the frame rate of the input video stream. + + + A D3D12_VIDEO_SIZE_RANGE structure representing the size of the source rectangle. This argument specifies the input range size this video processor must support for ProcessFrames. If a source size exceeds the range, the video processor must be recreated. + + + A D3D12_VIDEO_SIZE_RANGE structure representing the size of the destination rectangle. This argument specifies the destination range size this video processor must support for ProcessFrames. If a source size exceeds the range, the video processor must be recreated. + + + A boolean value specifying whether the video processor should support all D3D12_VIDEO_PROCESS_ORIENTATION for ProcessFrames. + + + A bitwise OR combination of one or more flags from the D3D12_VIDEO_PROCESS_FILTER_FLAGS enumeration specifying the filters to enable. + + + A value from the D3D12_VIDEO_FRAME_STEREO_FORMAT enumeration specifies whether the stream is stereo or not. A value of D3D12_VIDEO_PROCESS_STEREO_FORMAT_SEPARATE indicates that there will be two sets of input textures, and two sets of references for the stereo interlaced case. + + + A value from the D3D12_VIDEO_FIELD_TYPE enumeration specfying the interlaced field type of the input source. When working with mixed content, use [ID3D12VideoProcessCommandList1::ProcessFrames1](nf-d3d12video-id3d12videoprocesscommandlist1-processframes1.md) which supports changing the field type for each call. + + + A value from the D3D12_VIDEO_PROCESS_DEINTERLACE_FLAGS enumeration specifying the deinterlace mode to use. + + + A boolean value specifying whether alpha blending is enabled. Alpha blending settings are provided to ProcessFrames with AlphaBlending the field of the D3D12_VIDEO_PROCESS_INPUT_STREAM_ARGUMENTS structure. + + + A D3D12_VIDEO_PROCESS_LUMA_KEY structure specifying the luma key for an input stream on the video processor. + + + An integer specifying the number of past reference frames. + + + An integer specifying the number of future reference frames. + + + A boolean value specifying wither automatic processing features are enabled for the video processor. + + + + Specifies what to clear from the depth stencil view. + Microsoft Docs: + + + + Indicates the depth buffer should be cleared. + + + Indicates the stencil buffer should be cleared. + + + + Identifies the stencil operations that can be performed during depth-stencil testing. + Microsoft Docs: + + + + Keep the existing stencil data. + + + Set the stencil data to 0. + + + Set the stencil data to the reference value set by calling ID3D12GraphicsCommandList::OMSetStencilRef. + + + Increment the stencil value by 1, and clamp the result. + + + Decrement the stencil value by 1, and clamp the result. + + + Invert the stencil data. + + + Increment the stencil value by 1, and wrap the result if necessary. + + + Decrement the stencil value by 1, and wrap the result if necessary. + + + + Fills the function descriptor structure for the function. + Microsoft Docs: + A pointer to a D3D12_FUNCTION_DESC structure that receives a description of the function. + + + + + Specifies output stream arguments for the output passed to ID3D12VideoProcessCommandList::ProcessFrames. + Microsoft Docs: + + + + A DXGI_FORMAT structure specifying the format of the output resources. + + + A DXGI_COLOR_SPACE_TYPE value that specifies the colorspace for the video processor output surface. + + + A value from the D3D12_VIDEO_PROCESS_ALPHA_FILL_MODE enumeration specifying the alpha fill mode for data that the video processor writes to the render target. + + + The zero-based index of an input stream. This parameter is used if AlphaFillMode is D3D12_VIDEO_PROCESS_ALPHA_FILL_MODE_SOURCE_STREAM. Otherwise, the parameter is ignored. + + + The video processor uses the background color to fill areas of the target rectangle that do not contain a video image. Areas outside the target rectangle are not affected. The meaning of the values are specified by the ColorSpace parameter. + +| BackgroundColor | YCbCrA | RGBA | +|-------------------|----------|---------| +| BackgroundColor[0]| Y | R | +| BackgroundColor[1]| Cb | G | +| BackgroundColor[2]| Cr | B | +| BackgroundColor[3]| A | A | + + + A DXGI_RATIONAL structure specifying the frame rate of the output video stream. + + + If TRUE, stereo output is enabled. Otherwise, the video processor produces mono video frames. + + + + Represents the histogram output buffer for a single component. + Microsoft Docs: + + + + The offset location in pBuffer to write the component histogram. Must be 256-byte aligned. Set to zero when a component is disabled. + + + And ID3D12Resource representing the target buffer for hardware to write the components histogram. Set to a nullptr when the component histogram is disabled. + + + + Flags for setting split resource barriers. + Microsoft Docs: + + + + No flags. + + + This starts a barrier transition in a new state, putting a resource in a temporary no-access condition. + + + This barrier completes a transition, setting a new state and restoring active access to a resource. + + + + Defines constants that specify render/compute GPU operations. + Microsoft Docs: + + + + + Describes the range of supported sizes for a video scaler. + Microsoft Docs: + + + + The largest output width to which content can be scaled. The largest value allowed is D3D12\_REQ\_TEXTURE2D\_U\_OR\_V\_DIMENSION (16384). + + + The largest output height to which content can be scaled. The largest value allowed is D3D12\_REQ\_TEXTURE2D\_U\_OR\_V\_DIMENSION (16384). + + + The smallest output width to which content can be scaled. The smallest allowed value is 1. + + + The smallest output height to which content can be scaled. The smallest allowed value is 1. + + + + Adds a debug message to the message queue and sends that message to debug output. + Microsoft Docs: + Category of a message. + Severity of a message. + Unique identifier of a message. + User-defined message. + + + + + Identifies how to view a buffer resource. + Microsoft Docs: + + + + Indicates a default view. + + + View the buffer as raw. For more info about raw viewing of buffers, see Raw Views of Buffers. + + + + Specifies a depth and stencil value. + Microsoft Docs: + + + + Specifies the depth value. + + + Specifies the stencil value. + + + + Describes the transition between usages of two different resources that have mappings into the same heap. + Microsoft Docs: + + + + A pointer to the ID3D12Resource object that represents the before resource used in the transition. + + + A pointer to the ID3D12Resource object that represents the after resource used in the transition. + + + + Launch the threads of a ray generation shader. + Microsoft Docs: + A description of the ray dispatch + + + + + Describes a set of triangles used as raytracing geometry. The geometry pointed to by this struct are always in triangle list form, indexed or non-indexed. Triangle strips are not supported. + Microsoft Docs: + + + + Address of a 3x4 affine transform matrix in row-major layout to be applied to the vertices in the VertexBuffer during an acceleration structure build. The contents of VertexBuffer are not modified. If a 2D vertex format is used, the transformation is applied with the third vertex component assumed to be zero. + +If Transform3x4 is NULL the vertices will not be transformed. Using Transform3x4 may result in increased computation and/or memory requirements for the acceleration structure build. + + +The memory pointed to must be in state D3D12_RESOURCE_STATE_NON_PIXEL_SHADER_RESOURCE. The address must be aligned to 16 bytes, defined as D3D12_RAYTRACING_TRANSFORM3X4_BYTE_ALIGNMENT. + + + Format of the indices in the IndexBuffer. Must be one of the following: + +
    +
  • DXGI_FORMAT_UNKNOWN - when IndexBuffer is NULL
    • +
  • DXGI_FORMAT_R32_UINT
    • +
  • DXGI_FORMAT_R16_UINT
    • +
 + + + Format of the vertices in VertexBuffer. Must be one of the following: + +
    +
  • DXGI_FORMAT_R32G32_FLOAT - third component is assumed 0
    • +
  • DXGI_FORMAT_R32G32B32_FLOAT
    • +
  • DXGI_FORMAT_R16G16_FLOAT - third component is assumed 0
    • +
  • DXGI_FORMAT_R16G16B16A16_FLOAT - A16 component is ignored, other data can be packed there, such as setting vertex stride to 6 bytes.
    • +
  • DXGI_FORMAT_R16G16_SNORM - third component is assumed 0
    • +
  • DXGI_FORMAT_R16G16B16A16_SNORM - A16 component is ignored, other data can be packed there, such as setting vertex stride to 6 bytes.
    • +
 + + + Number of indices in IndexBuffer. Must be 0 if IndexBuffer is NULL. + + + Number of vertices in VertexBuffer. + + + Array of vertex indices. If NULL, triangles are non-indexed. Just as with graphics, the address must be aligned to the size of IndexFormat. + +The memory pointed to must be in state D3D12_RESOURCE_STATE_NON_PIXEL_SHADER_RESOURCE. Note that if an app wants to share index buffer inputs between graphics input assembler and raytracing acceleration structure build input, it can always put a resource into a combination of read states simultaneously, e.g. D3D12_RESOURCE_STATE_INDEX_BUFFER | D3D12_RESOURCE_STATE_NON_PIXEL_SHADER_RESOURCE. + + + Array of vertices including a stride. The alignment on the address and stride must be a multiple of the component size, so 4 bytes for formats with 32bit components and 2 bytes for formats with 16bit components. Unlike graphics, there is no constraint on the stride, other than that the bottom 32bits of the value are all that are used – the field is UINT64 purely to make neighboring fields align cleanly/obviously everywhere. Each vertex position is expected to be at the start address of the stride range and any excess space is ignored by acceleration structure builds. This excess space might contain other app data such as vertex attributes, which the app is responsible for manually fetching in shaders, whether it is interleaved in vertex buffers or elsewhere. + +The memory pointed to must be in state D3D12_RESOURCE_STATE_NON_PIXEL_SHADER_RESOURCE. Note that if an app wants to share vertex buffer inputs between graphics input assembler and raytracing acceleration structure build input, it can always put a resource into a combination of read states simultaneously, e.g. D3D12_RESOURCE_STATE_VERTEX_AND_CONSTANT_BUFFER | D3D12_RESOURCE_STATE_NON_PIXEL_SHADER_RESOURCE + + + + Describes a vertex buffer view. + Microsoft Docs: + + + + Specifies a D3D12_GPU_VIRTUAL_ADDRESS that identifies the address of the buffer. + + + Specifies the size in bytes of the buffer. + + + Specifies the size in bytes of each vertex entry. + + + + Add storage filters to the top of the retrieval-filter stack. + Microsoft Docs: + Array of retrieval filters. + + + + + Provides video decoding and processing capabilities of a Microsoft Direct3D 12 device including the ability to query video capabilities and instantiating video decoders and processors. + Microsoft Docs: + + + + + Describes subresource data. + Microsoft Docs: + + + + A pointer to a memory block that contains the subresource data. + + + The row pitch, or width, or physical size, in bytes, of the subresource data. + + + The depth pitch, or width, or physical size, in bytes, of the subresource data. + + + + Provides information about the stream rate. + Microsoft Docs: + + + + The zero-based index number of the output frame. The OutputIndex member is a zero-based cyclic number that indicates the frame index number of the output. The driver uses this output-index information to perform the video processing in a certain pattern or cycle, especially when the driver performs deinterlacing or frame-rate conversion. For example, with the following output-index pattern, the driver performs the indicated video processing: + +- Progressive format at normal and half rate: + - OutputInde = 0, 0,... +- Progressive format at 2/1 custom rate (double frame-rate conversion, OutputFrames=2): + - OutputInde = 0, 1, 0, 1,... +- Interlaced format at normal rate: + - OutputInde = 0, 1, 0, 1,... (0: first field, 1: second field) +- Interlaced format at half rate: + - OutputInde = 0, 0,... (for example, first and second fields are blended to one frame) +- Interlaced at 4/5 custom rate (3:2 inverse telecine, OutputFrames=4): + - OutputInde = 0, 1, 2, 3, 0, 1, 2, 3,... (0:A, 1:B, 2:C, 3:D film frame) + + + The zero-based index number of the input frame or field. The InputFrameOrField member is a zero-based number that indicates the frame or the field number of the input surface. For example, with the following input-frame-or-field number, the driver can perform the indicated video processing: + +- Progressive format and interlaced format at normal rate: + - InputFrameOrField = 0, 1, 2,... +- Progressive format and interlaced format at half rate: + - InputFrameOrField = 0, 2, 4,... +- Interlaced format at 4/5 custom rate (3:2 inverse telecine, OutputFrames=4 and InputFrameOrField=10): + - InputFrameOrField = 0, 0, 0, 0, 10, 10, 10, 10, 20, 20, 20, 20,... +- Interlaced format at 4/15 custom rate (8:7 inverse telecine, OutputFrames=2 and InputFrameOrField=15): + - InputFrameOrField = 0, 0, 15, 15, 30, 30,... + + + + Clears the depth-stencil resource. + Microsoft Docs: + Describes the CPU descriptor handle that represents the start of the heap for the depth stencil to be cleared. + A combination of D3D12_CLEAR_FLAGS values that are combined by using a bitwise OR operation. The resulting value identifies the type of data to clear (depth buffer, stencil buffer, or both). + A value to clear the depth buffer with. This value will be clamped between 0 and 1. + A value to clear the stencil buffer with. + The number of rectangles in the array that the pRects parameter specifies. + An array of D3D12_RECT structures for the rectangles in the resource view to clear. If NULL, ClearDepthStencilView clears the entire resource view. + + + + + Specifies what type of texture copy is to take place. + Microsoft Docs: + + + + Indicates a subresource, identified by an index, is to be copied. + + + Indicates a place footprint, identified by a D3D12_PLACED_SUBRESOURCE_FOOTPRINT structure, is to be copied. + + + + Specifies the type of a command list. + Microsoft Docs: + + + + Specifies a command buffer that the GPU can execute. A direct command list doesn't inherit any GPU state. + + + Specifies a command buffer that can be executed only directly via a direct command list. A bundle command list inherits all GPU state (except for the currently set pipeline state object and primitive topology). + + + Specifies a command buffer for computing. + + + Specifies a command buffer for copying. + + + Specifies a command buffer for video decoding. + + + Specifies a command buffer for video processing. + + + + Describes the subresource from a cube texture to use in a shader-resource view. + Microsoft Docs: + + + + Index of the most detailed mipmap level to use; this number is between 0 and MipLevels (from the original TextureCube for which ID3D12Device::CreateShaderResourceView creates a view) -1. + + + The maximum number of mipmap levels for the view of the texture. See the remarks in D3D12_TEX1D_SRV. + +Set to -1 to indicate all the mipmap levels from MostDetailedMip on down to least detailed. + + + A value to clamp sample LOD values to. For example, if you specify 2.0f for the clamp value, you ensure that no individual sample accesses a mip level less than 2.0f. + + + + Specifies the parameters for the output stream for a video decode operation. + Microsoft Docs: + + + + An ID3D12Resource representing the output texture. If decode conversion is enabled, this texture will contain the post-conversion output. If decode conversion is not enabled, this texture will contain the decode output. + + + The index of the output subresource of pOutputTexture2D to use. This allows you to specify array indices if the output is an array. + + + An optional D3D12_VIDEO_DECODE_CONVERSION_ARGUMENTS structure containing output conversion parameters. + + + + Defines the range of supported values for an image filter. + Microsoft Docs: + + + + The minimum value of the filter. + + + The maximum value of the filter. + + + The default value of the filter. + + + A multiplier. Use the following formula to translate the filter setting into the actual filter value: + +Actual Value = Set Value × Multiplier. + + + + Flags for indicating a subset of components used with video decode histogram. + Microsoft Docs: + + + + No associated component. + + + If the format is a YUV format, indicates the Y component. + + + If the format is a YUV format, indicates the U component. + + + If the format is a YUV format, indicates the V component. + + + If the format is an RGB/BGR format, indicates the R component. + + + If the format is an RGB/BGR format, indicates the G component. + + + If the format is an RGB/BGR format, indicates the B component. + + + If the format is an RGB/BGR format, indicates the A component. + + + + Describes a parameter to a meta command. + Microsoft Docs: + + + + The parameter name. + + + A D3D12_META_COMMAND_PARAMETER_TYPE specifying the parameter type. + + + A D3D12_META_COMMAND_PARAMETER_FLAGS specifying the parameter flags. + + + A D3D12_RESOURCE_STATES specifying the expected state of a resource parameter. + + + The 4-byte aligned offset for this parameter, within the structure containing the parameter values, which you pass when creating/initializing/executing the meta command, as appropriate. + + + + This method configures the level of GPU-based validation that the debug device is to perform at runtime. + Microsoft Docs: + Specifies the level of GPU-based validation to perform at runtime. + + + + + Gets an interface by index. + Microsoft Docs: + Zero-based index. + + + + + Specifies the type of serialized data. Use a value from this enumeration when calling ID3D12Device5::CheckDriverMatchingIdentifier. + Microsoft Docs: + + + + The serialized data is a raytracing acceleration structure. + + + + Specifes the status of a video decode operation. + Microsoft Docs: + + + + The operation succeeded. + + + There was a minor problem in the data format, but the host decoder should continue processing. + + + There was a significant problem in the data format. The host decoder should continue processing, but should skip display. + + + There was a severe problem in the data format. The host decoder should restart the entire decoding process, starting at a sequence or random-access entry point. + + + + Describes a unordered-access 3D texture resource. + Microsoft Docs: + + + + The mipmap slice index. + + + The zero-based index of the first depth slice to be accessed. + + + The number of depth slices. + + + + Describes a library. + Microsoft Docs: + + + + The name of the originator of the library. + + + A combination of D3DCOMPILE Constants that are combined by using a bitwise OR operation. The resulting value specifies how the compiler compiles. + + + The number of functions exported from the library. + + + + Specifies the amount of information to report on a device object's lifetime. + Microsoft Docs: + A value from the D3D12_RLDO_FLAGS enumeration. This method uses the value in Flags to determine the amount of information to report about a device object's lifetime. + + + + + Debug message severity levels for an information queue. + Microsoft Docs: + + + + Indicates a corruption error. + + + Indicates an error. + + + Indicates a warning. + + + Indicates an information message. + + + Indicates a message other than corruption, error, warning or information. + + + + Encapsulates a list of graphics commands for rendering, extending the interface to support writing immediate values directly to a buffer. + Microsoft Docs: + + + + + Describes the GPU memory layout of an acceleration structure visualization. + Microsoft Docs: + + + + The type of acceleration structure. + + + The number of descriptions. + + + + Gets the descriptor heap description. + Microsoft Docs: + + + + + Defines constants that specify a shading rate tier (for variable-rate shading, or VRS). + Microsoft Docs: + + + + Specifies that variable-rate shading is not supported. + + + Specifies that variable-rate shading tier 1 is supported. + + + Specifies that variable-rate shading tier 2 is supported. + + + + Indicates whether two ID3D12ShaderReflectionType Interface pointers have the same underlying type. + Microsoft Docs: + A pointer to a ID3D12ShaderReflectionType Interface. + + + + + Creates a view for unordered accessing. + Microsoft Docs: + A pointer to the ID3D12Resource object that represents the unordered access. + +At least one of pResource or pDesc must be provided. + +A null pResource is used to initialize a null descriptor, which guarantees Direct3D 11-like null binding behavior (reading 0s, writes are discarded), but must have a valid pDesc in order to determine the descriptor type. + The ID3D12Resource for the counter (if any) associated with the UAV. + +If pCounterResource is not specified, then the CounterOffsetInBytes member of the D3D12_BUFFER_UAV structure must be 0. + +If pCounterResource is specified, then there is a counter associated with the UAV, and the runtime performs validation of the following requirements: + +
    +
  • The StructureByteStride member of the D3D12_BUFFER_UAV structure must be greater than 0. +
    • +
  • The format must be DXGI_FORMAT_UNKNOWN. +
    • +
  • The D3D12_BUFFER_UAV_FLAG_RAW flag (a D3D12_BUFFER_UAV_FLAGS enumeration constant) must not be set. +
    • +
  • Both of the resources (pResource and pCounterResource) must be buffers. +
    • +
  • The CounterOffsetInBytes member of the D3D12_BUFFER_UAV structure must be a multiple of D3D12_UAV_COUNTER_PLACEMENT_ALIGNMENT (4096), and must be within the range of the counter resource. +
    • +
  • pResource cannot be NULL +
    • +
  • pDesc cannot be NULL. +
    • +
+ A pointer to a D3D12_UNORDERED_ACCESS_VIEW_DESC structure that describes the unordered-access view. + +A null pDesc is used to initialize a default descriptor, if possible. This behavior is identical to the D3D11 null descriptor behavior, where defaults are filled in. This behavior inherits the resource format and dimension (if not typeless) and for buffers UAVs target a full buffer and are typed, and for textures UAVs target the first mip and all array slices. Not all resources support null descriptor initialization. + Describes the CPU descriptor handle that represents the start of the heap that holds the unordered-access view. + + + + + Specifies which unordered resource options are supported for a provided format. + Microsoft Docs: + + + + No unordered resource options are supported. + + + Format supports atomic add. + + + Format supports atomic bitwise operations. + + + Format supports atomic compare with store or exchange. + + + Format supports atomic exchange. + + + Format supports atomic min and max. + + + Format supports atomic unsigned min and max. + + + Format supports a typed load. + + + Format supports a typed store. + + + Format supports logic operations in blend state. + + + Format supports tiled resources. Refer to Volume Tiled Resources. + + + Format supports multi-plane overlays. + + + + Creates a render-target view for accessing resource data. + Microsoft Docs: + A pointer to the ID3D12Resource object that represents the render target. + + +At least one of pResource or pDesc must be provided. +A null pResource is used to initialize a null descriptor, which guarantees D3D11-like null binding behavior (reading 0s, writes are discarded), but must have a valid pDesc in order to determine the descriptor type. + A pointer to a D3D12_RENDER_TARGET_VIEW_DESC structure that describes the render-target view. + +A null pDesc is used to initialize a default descriptor, if possible. This behavior is identical to the D3D11 null descriptor behavior, where defaults are filled in. This behavior inherits the resource format and dimension (if not typeless) and RTVs target the first mip and all array slices. Not all resources support null descriptor initialization. + Describes the CPU descriptor handle that represents the destination where the newly-created render target view will reside. + + + + + Sets the layout of the graphics root signature. + Microsoft Docs: + A pointer to the ID3D12RootSignature object. + + + + + Describes the purpose of a query heap. A query heap contains an array of individual queries. + Microsoft Docs: + + + + Specifies one member of D3D12_QUERY_HEAP_TYPE. + + + Specifies the number of queries the heap should contain. + + + For single GPU operation, set this to zero. If there are multiple GPU nodes, set a bit to identify the node (the device's physical adapter) to which the query heap applies. + Each bit in the mask corresponds to a single node. + Only 1 bit must be set. + Refer to Multi-adapter systems. + + + + Serializes a root signature version 1.0 that can be passed to ID3D12Device::CreateRootSignature. + Microsoft Docs: + The description of the root signature, as a pointer to a D3D12_ROOT_SIGNATURE_DESC structure. + A D3D_ROOT_SIGNATURE_VERSION-typed value that specifies the version of root signature. + A pointer to a memory block that receives a pointer to the ID3DBlob interface that you can use to access the serialized root signature. + A pointer to a memory block that receives a pointer to the ID3DBlob interface that you can use to access serializer error messages, or NULL if there are no errors. + + + + + Describes the dimensions of a mip region. + Microsoft Docs: + + + + The width of the mip region. + + + The height of the mip region. + + + The depth of the mip region. + + + + Performs a raytracing acceleration structure build on the GPU and optionally outputs post-build information immediately after the build. + Microsoft Docs: + Description of the acceleration structure to build. + Size of the pPostbuildInfoDescs array. Set to 0 if no post-build info is needed. + Optional array of descriptions for post-build info to generate describing properties of the acceleration structure that was built. + + + + + Gets a constant buffer by index. + Microsoft Docs: + Zero-based index. + + + + + Describes a DXIL library state subobject that can be included in a state object. + Microsoft Docs: + + + + The library to include in the state object. Must have been compiled with library target 6.3 or higher. It is fine to specify the same library multiple times either in the same state object / collection or across multiple, as long as the names exported each time don’t conflict in a given state object. + + + The size of pExports array. If 0, everything gets exported from the library. + + + + Describes flags and protection type for a protected resource session, per adapter. + Microsoft Docs: + + + + The node mask. For single GPU operation, set this to zero. If there are multiple GPU nodes, then set a bit to identify the node (the device's physical adapter) to which the protected session applies. Each bit in the mask corresponds to a single node. Only 1 bit may be set. + + + Specifies the supported crypto sessions options. + + + The GUID that represents the protection type. Microsoft defines D3D12_PROTECTED_RESOURCES_SESSION_HARDWARE_PROTECTED. + +Using the D3D12_PROTECTED_RESOURCES_SESSION_HARDWARE_PROTECTED GUID is equivalent to calling [ID3D12Device4::CreateProtectedResourceSession](./nf-d3d12-id3d12device4-createprotectedresourcesession.md). + + + + Sets the reference value for depth stencil tests. + Microsoft Docs: + Reference value to perform against when doing a depth-stencil test. + + + + + Specifies the argument type of a D3D12_VIDEO_DECODE_FRAME_ARGUMENT + Microsoft Docs: + + + + The argument is a picture decoding parameter buffer. + + + The argument is an inverse quantization matrix buffer. + + + The argument is a slice control buffer. + + + TBD + + + + Gets a variable by name. + Microsoft Docs: + A pointer to a string containing the variable name. + + + + + Receives output data from calls to ID3D12VideoEncodeCommandList::ResolveMotionVectorHeap. + Microsoft Docs: + + + + An ID3D12Resource representing the output resource for resolved motion vectors. Motion vectors are resolved to DXGI_FORMAT_R16G16_SINT 2D textures. The resolved data is a signed 16-byte integer with quarter PEL units with the X vector component stored in the R component and the Y vector component stored in the G component. Motion vectors are stored in a 2D layout that corresponds to the pixel layout of the original input textures. + + + A D3D12_RESOURCE_COORDINATE structure specifying the output origin of the motion vectors. The remaining sub-region must be large enough to store all motion vectors per block specified by the input pixel with and pixel height and the specified D3D12_VIDEO_MOTION_ESTIMATOR_SEARCH_BLOCK_SIZE. + + + + Fills the library descriptor structure for the library reflection. + Microsoft Docs: + A pointer to a D3D12_LIBRARY_DESC structure that receives a description of the library reflection. + + + + + Describes the elements in a buffer resource to use in a render-target view. + Microsoft Docs: + + + + Number of bytes between the beginning of the buffer and the first element to access. + + + The total number of elements in the view. + + + + Specifies the type of magnification or minification sampler filters. + Microsoft Docs: + + + + Point filtering is used as a texture magnification or minification filter. The texel with coordinates nearest to the desired pixel value is used. The texture filter to be used between mipmap levels is nearest-point mipmap filtering. The rasterizer uses the color from the texel of the nearest mipmap texture. + + + Bilinear interpolation filtering is used as a texture magnification or minification filter. A weighted average of a 2 x 2 area of texels surrounding the desired pixel is used. The texture filter to use between mipmap levels is trilinear mipmap interpolation. The rasterizer linearly interpolates pixel color, using the texels of the two nearest mipmap textures. + + + + Specifies the subresource from a 1D texture to use in a shader-resource view. + Microsoft Docs: + + + + Index of the most detailed mipmap level to use; this number is between 0 and MipLevels (from the original Texture1D for which ID3D12Device::CreateShaderResourceView creates a view) -1. + + + The maximum number of mipmap levels for the view of the texture. See the remarks. + +Set to -1 to indicate all the mipmap levels from MostDetailedMip on down to least detailed. + + + A value to clamp sample LOD values to. For example, if you specify 2.0f for the clamp value, you ensure that no individual sample accesses a mip level less than 2.0f. + + + + Specifies heap options, such as whether the heap can contain textures, and whether resources are shared across adapters. + Microsoft Docs: + + + + No options are specified. + + + The heap is shared. Refer to Shared Heaps. + + + The heap isn't allowed to contain buffers. + + + The heap is allowed to contain swap-chain surfaces. + + + The heap is allowed to share resources across adapters. Refer to Shared Heaps. + + + The heap is not allowed to store Render Target (RT) and/or Depth-Stencil (DS) textures. + + + The heap is not allowed to contain resources with D3D12_RESOURCE_DIMENSION_TEXTURE1D, D3D12_RESOURCE_DIMENSION_TEXTURE2D, or D3D12_RESOURCE_DIMENSION_TEXTURE3D unless either D3D12_RESOURCE_FLAG_ALLOW_RENDER_TARGET or D3D12_RESOURCE_FLAG_ALLOW_DEPTH_STENCIL are present. Refer to D3D12_RESOURCE_DIMENSION and D3D12_RESOURCE_FLAGS. + + + Unsupported. Do not use. + + + The heap supports MEM_WRITE_WATCH functionality, which causes the system to track the pages that are written to in the commited memory region. This flag can't be combined with the D3D12_HEAP_TYPE_DEFAULT or D3D12_CPU_PAGE_PROPERTY_UNKNOWN flags. Applications are discouraged from using this flag themselves because it prevents tools from using this functionality. + + + Ensures that atomic operations will be atomic on this heap's memory, according to components able to see the memory. + +Creating a heap with this flag will fail under either of these conditions. +- The heap type is D3D12_HEAP_TYPE_DEFAULT, and the heap can be visible on multiple nodes, but the device does not support [D3D12_CROSS_NODE_SHARING_TIER_3](./ne-d3d12-d3d12_cross_node_sharing_tier.md). +- The heap is CPU-visible, but the heap type is not D3D12_HEAP_TYPE_CUSTOM. + +Note that heaps with this flag might be a limited resource on some systems. + + + The heap is created in a non-resident state and must be made resident using [ID3D12Device::MakeResident](./nf-d3d12-id3d12device-makeresident.md) or [ID3D12Device3::EnqueueMakeResident](./nf-d3d12-id3d12device3-enqueuemakeresident.md). + +By default, the final step of heap creation is to make the heap resident, so this flag skips this step and allows the application to decide when to do so. + + + Allows the OS to not zero the heap created. By default, committed resources and heaps are almost always zeroed upon creation. This flag allows this to be elided in some scenarios. However, it doesn't guarantee it. For example, memory coming from other processes still needs to be zeroed for data protection and process isolation. This can lower the overhead of creating the heap. + + + The heap is allowed to store all types of buffers and/or textures. This is an alias; for more details, see "Aliases" in the Remarks section. + + + The heap is only allowed to store buffers. This is an alias; for more details, see "Aliases" in the Remarks section. + + + The heap is only allowed to store non-RT, non-DS textures. This is an alias; for more details, see "Aliases" in the Remarks section. + + + The heap is only allowed to store RT and/or DS textures. This is an alias; for more details, see "Aliases" in the Remarks section. + + + + Gets the number of interfaces. + Microsoft Docs: + + + + + Defines constants that specify a shading rate combiner (for variable-rate shading, or VRS). + Microsoft Docs: + + + + Specifies the combiner C.xy = A.xy, for combiner (C) and inputs (A and B). + + + Specifies the combiner C.xy = B.xy, for combiner (C) and inputs (A and B). + + + Specifies the combiner C.xy = max(A.xy, B.xy), for combiner (C) and inputs (A and B). + + + Specifies the combiner C.xy = min(A.xy, B.xy), for combiner (C) and inputs (A and B). + + + Specifies the combiner C.xy = min(maxRate, A.xy + B.xy)`, for combiner (C) and inputs (A and B). + + + + Push a storage filter onto the storage-filter stack. + Microsoft Docs: + Pointer to a storage filter. + + + + + Adds GPU-Based Validation and Dependent Command Queue Synchronization to the debug layer. + Microsoft Docs: + + + + + Marks the ending of a render pass. + Microsoft Docs: + + + + + Sets a CPU descriptor handle for the unordered-access-view resource in the compute root signature. + Microsoft Docs: + The slot number for binding. + The GPU virtual address of the buffer. + D3D12_GPU_VIRTUAL_ADDRESS is a typedef'd alias of UINT64. + + + + + Specifies triangles facing a particular direction are not drawn. + Microsoft Docs: + + + + Always draw all triangles. + + + Do not draw triangles that are front-facing. + + + Do not draw triangles that are back-facing. + + + + Used with the EnqueuMakeResident function to choose how residency operations proceed when the memory budget is exceeded. + Microsoft Docs: + + + + Specifies the default residency policy, which allows residency operations to succeed regardless of the application's current memory budget. EnqueueMakeResident returns E_OUTOFMEMORY only when there is no memory available. + + + Specifies that the EnqueueMakeResident function should return E_OUTOFMEMORY when the residency operation would exceed the application's current memory budget. + + + + Retrieves the requested PSO from the library. The input desc is matched against the data in the current library database, and remembered in order to prevent duplication of PSO contents. + Microsoft Docs: + The unique name of the PSO. + Specifies a description of the required PSO in a D3D12_COMPUTE_PIPELINE_STATE_DESC structure. This input description is matched against the data in the current library database, and stored in order to prevent duplication of PSO contents. + Specifies a REFIID for the ID3D12PipelineState object. Typically set this, and the following parameter, with the macro IID_PPV_ARGS(&PSO1), where PSO1 is the name of the object. + Specifies a pointer that will reference the returned PSO. + + + + + When using triangle strip primitive topology, vertex positions are interpreted as vertices of a continuous triangle “strip”. + Microsoft Docs: + + + + Indicates that there is no cut value. + + + Indicates that 0xFFFF should be used as the cut value. + + + Indicates that 0xFFFFFFFF should be used as the cut value. + + + + Retrieves the sizes, in units of threads, of the X, Y, and Z dimensions of the shader's thread-group grid. + Microsoft Docs: + A pointer to the size, in threads, of the x-dimension of the thread-group grid. The maximum size is 1024. + A pointer to the size, in threads, of the y-dimension of the thread-group grid. The maximum size is 1024. + A pointer to the size, in threads, of the z-dimension of the thread-group grid. The maximum size is 64. + + + + + Uses the CPU to copy data into a subresource, enabling the CPU to modify the contents of most textures with undefined layouts. + Microsoft Docs: + Specifies the index of the subresource. + A pointer to a box that defines the portion of the destination subresource to copy the resource data into. + If NULL, the data is written to the destination subresource with no offset. + The dimensions of the source must fit the destination (see + D3D12_BOX). + + +An empty box results in a no-op. + A box is empty if the top value is greater than or equal to the bottom value, or the left value is greater than or equal to the right value, + or the front value is greater than or equal to the back value. + When the box is empty, this method doesn't perform any operation. + A pointer to the source data in memory. + The distance from one row of source data to the next row. + The distance from one depth slice of source data to the next. + + + + + This method samples the CPU and GPU timestamp counters at the same moment in time. + Microsoft Docs: + The value of the GPU timestamp counter. + The value of the CPU timestamp counter. + + + + + Defines constants that specify the lifetime state of a lifetime-tracked object. + Microsoft Docs: + + + + Specifies that the lifetime-tracked object is in use. + + + Specifies that the lifetime-tracked object is not in use. + + + + Specifies the viewport/stencil and render target associated with a view instance. + Microsoft Docs: + + + + The index of the viewport in the viewports array to be used by the view instance associated with this location. + + + The index of the render target in the render targets array to be used by the view instance associated with this location. + + + + Describes a stream output buffer. + Microsoft Docs: + + + + A D3D12_GPU_VIRTUAL_ADDRESS (a UINT64) that points to the stream output buffer. + If SizeInBytes is 0, this member isn't used and can be any value. + + + The size of the stream output buffer in bytes. + + + The location of the value of how much data has been filled into the buffer, as a D3D12_GPU_VIRTUAL_ADDRESS (a UINT64). + This member can't be NULL; a filled size location must be supplied (which the hardware will increment as data is output). + If SizeInBytes is 0, this member isn't used and can be any value. + + + + Creates a depth-stencil view for accessing resource data. + Microsoft Docs: + A pointer to the ID3D12Resource object that represents the depth stencil. + + +At least one of pResource or pDesc must be provided. +A null pResource is used to initialize a null descriptor, which guarantees D3D11-like null binding behavior (reading 0s, writes are discarded), but must have a valid pDesc in order to determine the descriptor type. + A pointer to a D3D12_DEPTH_STENCIL_VIEW_DESC structure that describes the depth-stencil view. + + +A null pDesc is used to initialize a default descriptor, if possible. This behavior is identical to the D3D11 null descriptor behavior, where defaults are filled in. This behavior inherits the resource format and dimension (if not typeless) and DSVs target the first mip and all array slices. Not all resources support null descriptor initialization. + Describes the CPU descriptor handle that represents the start of the heap that holds the depth-stencil view. + + + + + Describes the subresource from a 2D texture that is accessible to a depth-stencil view. + Microsoft Docs: + + + + The index of the first mipmap level to use. + + + + Represents Device Removed Extended Data (DRED) version 1.1 data. + Microsoft Docs: + + + + An HRESULT containing the reason the device was removed (matches the return value of GetDeviceRemovedReason). Also see [COM Error Codes (UI, Audio, DirectX, Codec)](/windows/desktop/com/com-error-codes-10). + + + A D3D12_DRED_AUTO_BREADCRUMBS_OUTPUT value that contains the auto-breadcrumb state prior to device removal. + + + An output parameter of type pointer to D3D12_AUTO_BREADCRUMB_NODE representing the returned auto-breadcrumb object(s). This is a pointer to the head of a linked list of auto-breadcrumb node objects. All of the nodes in the linked list represent potentially incomplete command list execution on the GPU at the time of the device-removal event. + + + A D3D12_DRED_PAGE_FAULT_OUTPUT value that contains page fault data if device removal was the result of a GPU page fault. + + + + Gets the CPU descriptor handle that represents the start of the heap. + Microsoft Docs: + + + + + Set a message category to break on when a message with that category passes through the storage filter. + Microsoft Docs: + Message category to break on. + Turns this breaking condition on or off (true for on, false for off). + + + + + Describes constants inline in the root signature that appear in shaders as one constant buffer. + Microsoft Docs: + + + + The shader register. + + + The register space. + + + The number of constants that occupy a single shader slot (these constants appear like a single constant buffer). + All constants occupy a single root signature bind slot. + + + + Describes the space requirement for decoding an acceleration structure into a form that can be visualized by tools. + Microsoft Docs: + + + + The space requirement for decoding an acceleration structure into a form that can be visualized by tools. + + + + Sets a CPU descriptor handle for the shader resource in the compute root signature. + Microsoft Docs: + The slot number for binding. + The GPU virtual address of the buffer. + D3D12_GPU_VIRTUAL_ADDRESS is a typedef'd alias of UINT64. + + + + + Set a bit field of flags that will turn debug features on and off. + Microsoft Docs: + Feature-mask flags, as a bitwise-OR'd combination of D3D12_DEBUG_FEATURE enumeration constants. + If a flag is present, that feature will be set to on; otherwise, the feature will be set to off. + + + + + Gets a description of how a resource is bound to a function. + Microsoft Docs: + The constant-buffer name of the resource. + A pointer to a D3D12_SHADER_INPUT_BIND_DESC structure that describes input binding of the resource. + + + + + Describes the descriptor heap. + Microsoft Docs: + + + + A D3D12_DESCRIPTOR_HEAP_TYPE-typed value that specifies the types of descriptors in the heap. + + + The number of descriptors in the heap. + + + A combination of D3D12_DESCRIPTOR_HEAP_FLAGS-typed values that are combined by using a bitwise OR operation. The resulting value specifies options for the heap. + + + For single-adapter operation, set this to zero. + If there are multiple adapter nodes, set a bit to identify the node (one of the device's physical adapters) to which the descriptor heap applies. + Each bit in the mask corresponds to a single node. + Only one bit must be set. + See Multi-adapter systems. + + + + Create a sampler object that encapsulates sampling information for a texture. + Microsoft Docs: + A pointer to a D3D12_SAMPLER_DESC structure that describes the sampler. + Describes the CPU descriptor handle that represents the start of the heap that holds the sampler. + + + + + Describes the multi-sampling image quality levels for a given format and sample count. + Microsoft Docs: + + + + A DXGI_FORMAT-typed value for the format to return info about. + + + The number of multi-samples per pixel to return info about. + + + Flags to control quality levels, as a bitwise-OR'd combination of D3D12_MULTISAMPLE_QUALITY_LEVEL_FLAGS enumeration constants. + The resulting value specifies options for determining quality levels. + + + The number of quality levels. + + + + Gets the amount of stack memory required to invoke a raytracing shader in HLSL. + Microsoft Docs: + The shader entrypoint in the state object for which to retrieve stack size. For hit groups, an individual shader within the hit group must be specified using the syntax: + +hitGroupName::shaderType + +Where hitGroupName is the entrypoint name for the hit group and shaderType is one of: + +
    +
  • intersection
    • +
  • anyhit
    • +
  • closesthit
    • +
+These values are all case-sensitive. + +An example value is: "myTreeLeafHitGroup::anyhit". + + + + + Describes details for the discard-resource operation. + Microsoft Docs: + + + + The number of rectangles in the array that the pRects member specifies. + + + An array of D3D12_RECT structures for the rectangles in the resource to discard. + If NULL, DiscardResource discards the entire resource. + + + Index of the first subresource in the resource to discard. + + + The number of subresources in the resource to discard. + + + + Wraps an array of render target formats. + Microsoft Docs: + + + + Specifies a fixed-size array of DXGI_FORMAT values that define the format of up to 8 render targets. + + + Specifies the number of render target formats stored in the array. + + + + Describes a descriptor range. + Microsoft Docs: + + + + A D3D12_DESCRIPTOR_RANGE_TYPE-typed value that specifies the type of descriptor range. + + + The number of descriptors in the range. Use -1 or UINT_MAX to specify an unbounded size. If a given descriptor range is unbounded, then it must either be the last range in the table definition, or else the following range in the table definition must have a value for OffsetInDescriptorsFromTableStart that is not [D3D12_DESCRIPTOR_RANGE_OFFSET_APPEND](). + + + The base shader register in the range. For example, for shader-resource views (SRVs), 3 maps to ": register(t3);" in HLSL. + + + The register space. Can typically be 0, but allows multiple descriptor arrays of unknown size to not appear to overlap. + For example, for SRVs, by extending the example in the BaseShaderRegister member description, 5 maps to ": register(t3,space5);" in HLSL. + + + The offset in descriptors, from the start of the descriptor table which was set as the root argument value for this parameter slot. This value can be D3D12_DESCRIPTOR_RANGE_OFFSET_APPEND, which indicates this range should immediately follow the preceding range. + + + + Specifies comparison options. + Microsoft Docs: + + + + Never pass the comparison. + + + If the source data is less than the destination data, the comparison passes. + + + If the source data is equal to the destination data, the comparison passes. + + + If the source data is less than or equal to the destination data, the comparison passes. + + + If the source data is greater than the destination data, the comparison passes. + + + If the source data is not equal to the destination data, the comparison passes. + + + If the source data is greater than or equal to the destination data, the comparison passes. + + + Always pass the comparison. + + + + Describes a tiled subresource volume. + Microsoft Docs: + + + + The width in tiles of the subresource. + + + The height in tiles of the subresource. + + + The depth in tiles of the subresource. + + + The index of the tile in the overall tiled subresource to start with. + + + + Sets the blend factor that modulate values for a pixel shader, render target, or both. + Microsoft Docs: + Array of blend factors, one for each RGBA component. + + + + + Gets the geometry-shader input-primitive description. + Microsoft Docs: + + + + + Specifies the memory pool for the heap. + Microsoft Docs: + + + + The memory pool is unknown. + + + The memory pool is L0. + L0 is the physical system memory pool. + When the adapter is discrete/NUMA, this pool has greater bandwidth for the CPU and less bandwidth for the GPU. + When the adapter is UMA, this pool is the only one which is valid. + + + The memory pool is L1. + L1 is typically known as the physical video memory pool. + L1 is only available when the adapter is discrete/NUMA, and has greater bandwidth for the GPU and cannot even be accessed by the CPU. + When the adapter is UMA, this pool is not available. + + + + Retrieves the list of supported profiles. + Microsoft Docs: + + + + For single GPU operation, set this to zero. If there are multiple GPU nodes, set a bit to identify the node (the device's physical adapter) to which the command queue applies. Each bit in the mask corresponds to a single node. Only 1 bit may be set. + + + The number of profiles to retrieve. This number must match the value returned from a call [ID3D12VideoDevice::CheckFeatureSupport](nf-d3d12video-id3d12videodevice-checkfeaturesupport.md) when the feature specified is D3D12\_FEATURE\_VIDEO\_DECODE\_PROFILE\_COUNT. + + + A list of GUIDs representing the supported profiles. The calling application must allocate storage for the profile list before calling CheckFeatureSupport. + + + + Specifies the input parameters for calls to ID3D12VideoEncodeCommandList::EstimateMotion. + Microsoft Docs: + + + + An ID3D12Resource representing the current frame. The motion estimation operation applies to the entire frame. + + + The base plane of the MIP and array slice to use for the input. + + + An ID3D12Resource representing the reference frame, or past frame, used for motion estimation. + + + The base plane of the MIP and array slice to use for the reference. + + + An ID3D12VideoMotionVectorHeap representing the buffer containing the hardware-dependent output of the previous motion estimator operation which may be used for hinting the current operation. This parameter may be NULL, indicating that previous motion estimator output should not be considered for the current operation. + + + + Returns the amount of memory required to serialize the current contents of the database. + Microsoft Docs: + + + + + Describes the subresource from a 1D texture that is accessible to a depth-stencil view. + Microsoft Docs: + + + + The index of the first mipmap level to use. + + + + Defines constants that specify the flags for a parameter to a meta command. Values can be bitwise OR'd together. + Microsoft Docs: + + + + Specifies that the parameter is an input resource. + + + Specifies that the parameter is an output resource. + + + No flags specified. + + + + Specifies the volatility of both descriptors and the data they reference in a Root Signature 1.1 description, which can enable some driver optimizations. + Microsoft Docs: + + + + Default behavior. Descriptors are static, and default assumptions are made for data (for SRV/CBV: DATA_STATIC_WHILE_SET_AT_EXECUTE, and for UAV: DATA_VOLATILE). + + + If this is the only flag set, then descriptors are volatile and default assumptions are made about data (for SRV/CBV: DATA_STATIC_WHILE_SET_AT_EXECUTE, and for UAV: DATA_VOLATILE). + +If this flag is combined with DATA_VOLATILE, then both descriptors and data are volaille, which is equivalent to Root Signature Version 1.0. + +If this flag is combined with DATA_STATIC_WHILE_SET_AT_EXECUTE, then descriptors are volatile. This still doesn’t allow them to change during command list execution so it is valid to combine the additional declaration that data is static while set via root descriptor table during execution – the underlying descriptors are effectively static for longer than the data is being promised to be static. + + + Descriptors are static and the data is volatile. + + + Descriptors are static and data is static while set at execute. + + + Both descriptors and data are static. This maximizes the potential for driver optimization. + + + Provides the same benefits as static descriptors (see D3D12_DESCRIPTOR_RANGE_FLAG_NONE), except that the driver is not allowed to promote buffers to root descriptors as an optimization, because they must maintain bounds checks and root descriptors do not have those. + + + + Represents versioned Device Removed Extended Data (DRED) data. + Microsoft Docs: + + + + A D3D12_DRED_VERSION value, specifying a DRED version. This value determines which inner data member (of the union) is active. + + + A D3D12_DEVICE_REMOVED_EXTENDED_DATA value, containing DRED version 1.0 data. + + + A D3D12_DEVICE_REMOVED_EXTENDED_DATA1 value, containing DRED version 1.1 data. + + + + Remove a storage filter from the top of the storage-filter stack. + Microsoft Docs: + + + + + Specifies flags for the build of a raytracing acceleration structure. Use a value from this enumeration with the D3D12_BUILD_RAYTRACING_ACCELERATION_STRUCTURE_INPUTS structure that provides input to the acceleration structure build operation. + Microsoft Docs: + + + + No options specified for the acceleration structure build. + + + Build the acceleration structure such that it supports future updates (via the flag D3D12_RAYTRACING_ACCELERATION_STRUCTURE_BUILD_FLAG_PERFORM_UPDATE) instead of the app having to entirely rebuild the structure. This option may result in increased memory consumption, build times, and lower raytracing performance. Future updates, however, should be faster than building the equivalent acceleration structure from scratch. + +This flag can only be set on an initial acceleration structure build, or on an update where the source acceleration structure specified D3D12_RAYTRACING_ACCELERATION_STRUCTURE_BUILD_FLAG_ALLOW_UPDATE. In other words, after an acceleration structure was been built without D3D12_RAYTRACING_ACCELERATION_STRUCTURE_BUILD_FLAG_ALLOW_UPDATE, no other acceleration structures can be created from it via updates. + + + Enables the option to compact the acceleration structure by calling CopyRaytracingAccelerationStructure using compact mode, specified with D3D12_RAYTRACING_ACCELERATION_STRUCTURE_COPY_MODE_COMPACT. + +This option may result in increased memory consumption and build times. After future compaction, however, the resulting acceleration structure should consume a smaller memory footprint than building the acceleration structure from scratch. + +This flag is compatible with all other flags. If specified as part of an acceleration structure update, the source acceleration structure must have also been built with this flag. In other words, after an acceleration structure was been built without D3D12_RAYTRACING_ACCELERATION_STRUCTURE_BUILD_FLAG_ALLOW_COMPACTION, no other acceleration structures can be created from it via updates that specify D3D12_RAYTRACING_ACCELERATION_STRUCTURE_BUILD_FLAG_ALLOW_COMPACTION. + + + +Specifying ALLOW_COMPACTION may increase pre-compaction acceleration structure size versus not specifying ALLOW_COMPACTION. + + + +If multiple incremental builds are performed before finally compacting, there may be redundant compaction related work performed. + + +The size required for the compacted acceleration structure can be queried before compaction via EmitRaytracingAccelerationStructurePostbuildInfo. See D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_COMPACTED_SIZE_DESC for more information on properties of compacted acceleration structure size. + +
Note  WhenD3D12_RAYTRACING_ACCELERATION_STRUCTURE_BUILD_FLAG_ALLOW_UPDATE is specified, there is certain information that needs to be retained in the acceleration structure, and compaction will only help so much. However, if the pipeline knows that the acceleration structure will no longer be updated, it can make the structure more compact. Some apps may benefit from compacting twice - once after the initial build, and again after the acceleration structure has settled to a static state, if that occurs.
+
 
 + + + Construct a high quality acceleration structure that maximizes raytracing performance at the expense of additional build time. Typically, the implementation will take 2-3 times the build time than the default setting in order to get better tracing performance. + +This flag is recommended for static geometry in particular. It is compatible with all other flags except for D3D12_RAYTRACING_ACCELERATION_STRUCTURE_BUILD_FLAG_PREFER_FAST_BUILD. + + + Construct a lower quality acceleration structure, trading raytracing performance for build speed. Typically, the implementation will take 1/2 to 1/3 the build time than default setting, with a sacrifice in tracing performance. + +This flag is compatible with all other flags except for D3D12_RAYTRACING_ACCELERATION_STRUCTURE_BUILD_FLAG_PREFER_FAST_BUILD. + + + Minimize the amount of scratch memory used during the acceleration structure build as well as the size of the result. This option may result in increased build times and/or raytracing times. This is orthogonal to the D3D12_RAYTRACING_ACCELERATION_STRUCTURE_BUILD_FLAG_ALLOW_COMPACTION flag and the explicit acceleration structure compaction that it enables. Combining the flags can mean both the initial acceleration structure as well as the result of compacting it use less memory. + +The impact of using this flag for a build is reflected in the result of calling GetRaytracingAccelerationStructurePrebuildInfo before doing the build to retrieve memory requirements for the build. + +This flag is compatible with all other flags. + + + Perform an acceleration structure update, as opposed to building from scratch. This is faster than a full build, but can negatively impact raytracing performance, especially if the positions of the underlying objects have changed significantly from the original build of the acceleration structure before updates. + +If the addresses of the source and destination acceleration structures are identical, the update is performed in-place. Any other overlapping of address ranges of the source and destination is invalid. For non-overlapping source and destinations, the source acceleration structure is unmodified. The memory requirement for the output acceleration structure is the same as in the input acceleration structure + +The source acceleration structure must have been built with D3D12_RAYTRACING_ACCELERATION_STRUCTURE_BUILD_FLAG_ALLOW_UPDATE. + +This flag is compatible with all other flags. The other flags selections, aside from D3D12_RAYTRACING_ACCELERATION_STRUCTURE_BUILD_FLAG_ALLOW_UPDATE and D3D12_RAYTRACING_ACCELERATION_STRUCTURE_BUILD_FLAG_PERFORM_UPDATE, must match the flags in the source acceleration structure. + +Acceleration structure updates can be performed in unlimited succession, as long as the source acceleration structure was created with D3D12_RAYTRACING_ACCELERATION_STRUCTURE_BUILD_FLAG_ALLOW_UPDATE and the flags for the update build continue to specify D3D12_RAYTRACING_ACCELERATION_STRUCTURE_BUILD_FLAG_ALLOW_UPDATE. + + + + Copies descriptors from a source to a destination. + Microsoft Docs: + The number of descriptors to copy. + A D3D12_CPU_DESCRIPTOR_HANDLE that describes the destination descriptors to start to copy to. + +The destination and source descriptors must be in heaps of the same D3D12_DESCRIPTOR_HEAP_TYPE. + A D3D12_CPU_DESCRIPTOR_HANDLE that describes the source descriptors to start to copy from. + +> [!IMPORTANT] +> The SrcDescriptorRangeStart parameter must be in a non shader-visible descriptor heap. This is because shader-visible descriptor heaps may be created in WRITE_COMBINE memory or GPU local memory, which is prohibitively slow to read from. If your application manages descriptor heaps via copying the descriptors required for a given pass or frame from local "storage" descriptor heaps to the GPU-bound descriptor heap, then use shader-opaque heaps for the storage heaps and copy into the GPU-visible heap as required. + The D3D12_DESCRIPTOR_HEAP_TYPE-typed value that specifies the type of descriptor heap to copy with. This is required as different descriptor types may have different sizes. + +Both the source and destination descriptor heaps must have the same type, else the debug layer will emit an error. + + + + + Gets the number of interface slots in a shader. + Microsoft Docs: + + + + + This interface maintains context for video motion estimation operations. + Microsoft Docs: + + + + + Copies descriptors from a source to a destination. + Microsoft Docs: + The number of destination descriptor ranges to copy to. + An array of D3D12_CPU_DESCRIPTOR_HANDLE objects to copy to. + +All the destination and source descriptors must be in heaps of the same D3D12_DESCRIPTOR_HEAP_TYPE. + An array of destination descriptor range sizes to copy to. + The number of source descriptor ranges to copy from. + An array of D3D12_CPU_DESCRIPTOR_HANDLE objects to copy from. + +> [!IMPORTANT] +> All elements in the pSrcDescriptorRangeStarts parameter must be in a non shader-visible descriptor heap. This is because shader-visible descriptor heaps may be created in WRITE_COMBINE memory or GPU local memory, which is prohibitively slow to read from. If your application manages descriptor heaps via copying the descriptors required for a given pass or frame from local "storage" descriptor heaps to the GPU-bound descriptor heap, use shader-opaque heaps for the storage heaps and copy into the GPU-visible heap as required. + An array of source descriptor range sizes to copy from. + The D3D12_DESCRIPTOR_HEAP_TYPE-typed value that specifies the type of descriptor heap to copy with. This is required as different descriptor types may have different sizes. + +Both the source and destination descriptor heaps must have the same type, else the debug layer will emit an error. + + + + + An interface from which other core interfaces inherit from, including (but not limited to) ID3D12PipelineLibrary, ID3D12CommandList, ID3D12Pageable, and ID3D12RootSignature. It provides a method to get back to the device object it was created against. + Microsoft Docs: + + + + + Serializes a root signature of any version that can be passed to ID3D12Device::CreateRootSignature. + Microsoft Docs: + Specifies a D3D12_VERSIONED_ROOT_SIGNATURE_DESC that contains a description of any version of a root signature. + A pointer to a memory block that receives a pointer to the ID3DBlob interface that you can use to access the serialized root signature. + A pointer to a memory block that receives a pointer to the ID3DBlob interface that you can use to access serializer error messages, or NULL if there are no errors. + + + + + Represents a heap in which estimated motion vectors are stored. + Microsoft Docs: + + + + + Get the storage filter at the top of the storage-filter stack. + Microsoft Docs: + Storage filter at the top of the storage-filter stack. + Size of the storage filter in bytes. If pFilter is NULL, the size of the storage filter will be output to this parameter. + + + + + Specifies the motion estimation vector precision that a video encoder supports. + Microsoft Docs: + + + + Vector precision is not supported by the encoder. + + + The vector precision is quarter-pixel motion. + + + + Describes subresource data. + Microsoft Docs: + + + + Offset, in bytes, between the start of the parent resource and this subresource. + + + The row pitch, or width, or physical size, in bytes, of the subresource data. + + + The depth pitch, or width, or physical size, in bytes, of the subresource data. + + + + Specifies the type of filter reduction. + Microsoft Docs: + + + + The filter type is standard. + + + The filter type is comparison. + + + The filter type is minimum. + + + The filter type is maximum. + + + + Describes a resource barrier (transition in resource use). + Microsoft Docs: + + + + A D3D12_RESOURCE_BARRIER_TYPE-typed value that specifies the type of resource barrier. + This member determines which type to use in the union below. + + + Specifies a D3D12_RESOURCE_BARRIER_FLAGS enumeration constant such as for "begin only" or "end only". + + + A D3D12_RESOURCE_TRANSITION_BARRIER structure that describes the transition of subresources between different usages. + Members specify the before and after usages of the subresources. + + + A + D3D12_RESOURCE_ALIASING_BARRIERstructure that describes the transition between usages of two different resources that have mappings into the same heap. + + + A + D3D12_RESOURCE_UAV_BARRIERstructure that describes a resource in which all UAV accesses (reads or writes) must complete before any future UAV accesses (read or write) can begin. + + + + Specifies how a video frame is interlaced. + Microsoft Docs: + + + + The frame is progressive. + + + The frame is interlaced. The top field of each frame is displayed first. + + + The frame is interlaced. The bottom field of each frame is displayed first. + + + + Binds an array of scissor rectangles to the rasterizer stage. + Microsoft Docs: + The number of scissor rectangles to bind. + An array of scissor rectangles. + + + + + Checks whether a resource, or subresource, is in a specified state, or not. + Microsoft Docs: + Specifies the ID3D12Resource to check. + The index of the subresource to check. + This can be set to an index, or D3D12_RESOURCE_BARRIER_ALL_SUBRESOURCES. + Specifies the state to check for. This can be one or more D3D12_RESOURCE_STATES flags Or'ed together. + + + + + Describes a set of geometry that is used in the D3D12_BUILD_RAYTRACING_ACCELERATION_STRUCTURE_INPUTS structure to provide input data to a raytracing acceleration structure build operation. + Microsoft Docs: + + + + The type of geometry. + + + The geometry flags + + + A D3D12_RAYTRACING_GEOMETRY_TRIANGLES_DESC describing triangle geometry, if Type is D3D12_RAYTRACING_GEOMETRY_TYPE_TRIANGLES. Otherwise this parameter is unused. + + + A D3D12_RAYTRACING_GEOMETRY_AABBS_DESC describing triangle geometry, if Type is D3D12_RAYTRACING_GEOMETRY_TYPE_PROCEDURAL_PRIMITIVE_AABBS. Otherwise this parameter is unused. + + + + Describes the blend state for a render target. + Microsoft Docs: + + + + Specifies whether to enable (or disable) blending. Set to TRUE to enable blending. + +> [!NOTE] +> It's not valid for LogicOpEnable and BlendEnable to both be TRUE. + + + Specifies whether to enable (or disable) a logical operation. Set to TRUE to enable a logical operation. + +> [!NOTE] +> It's not valid for LogicOpEnable and BlendEnable to both be TRUE. + + + A D3D12_BLEND-typed value that specifies the operation to perform on the RGB value that the pixel shader outputs. The BlendOp member defines how to combine the SrcBlend and DestBlend operations. + + + A D3D12_BLEND-typed value that specifies the operation to perform on the current RGB value in the render target. The BlendOp member defines how to combine the SrcBlend and DestBlend operations. + + + A D3D12_BLEND_OP-typed value that defines how to combine the SrcBlend and DestBlend operations. + + + A D3D12_BLEND-typed value that specifies the operation to perform on the alpha value that the pixel shader outputs. Blend options that end in _COLOR are not allowed. The BlendOpAlpha member defines how to combine the SrcBlendAlpha and DestBlendAlpha operations. + + + A D3D12_BLEND-typed value that specifies the operation to perform on the current alpha value in the render target. Blend options that end in _COLOR are not allowed. The BlendOpAlpha member defines how to combine the SrcBlendAlpha and DestBlendAlpha operations. + + + A D3D12_BLEND_OP-typed value that defines how to combine the SrcBlendAlpha and DestBlendAlpha operations. + + + A D3D12_LOGIC_OP-typed value that specifies the logical operation to configure for the render target. + + + A combination of D3D12_COLOR_WRITE_ENABLE-typed values that are combined by using a bitwise OR operation. The resulting value specifies a write mask. + + + + Describes the root signature 1.1 layout of a descriptor table as a collection of descriptor ranges that are all relative to a single base descriptor handle. + Microsoft Docs: + + + + The number of descriptor ranges in the table layout. + + + An array of D3D12_DESCRIPTOR_RANGE1 structures that describe the descriptor ranges. + + + + Opaque data structure describing driver versioning for a serialized acceleration structure. + Microsoft Docs: + + + + The opaque identifier of the driver. + + + The opaque driver versioning data. + + + + Describes the level of support for HLSL 6.0 wave operations. + Microsoft Docs: + + + + True if the driver supports HLSL 6.0 wave operations. + + + Specifies the baseline number of lanes in the SIMD wave that this implementation can support. This term is sometimes known as "wavefront size" or "warp width". Currently apps should rely only on this minimum value for sizing workloads. + + + Specifies the maximum number of lanes in the SIMD wave that this implementation can support. This capability is reserved for future expansion, and is not expected to be used by current applications. + + + Specifies the total number of SIMD lanes on the hardware. + + + Indicates transitions are possible in and out of the CBV, and indirect argument states, on compute command lists. If CheckFeatureSupport succeeds this value will always be true. + + + Indicates that 64bit integer operations are supported. + + + + Get the number of messages currently stored in the message queue. + Microsoft Docs: + + + + + Describes the allocation size of a video motion estimator heap. + Microsoft Docs: + + + + In multi-adapter operation, identifies the physical adapter of the device this operation applies to. + + + A DXGI_FORMAT structure specifying the format of the input and reference resources. + + + A value from the D3D12_VIDEO_MOTION_ESTIMATOR_SEARCH_BLOCK_SIZE specifying the search block size for motion estimation. + + + A value from the D3D12_VIDEO_MOTION_ESTIMATOR_VECTOR_PRECISION specifying the search block size for motion estimation. + + + A D3D12_VIDEO_SIZE_RANGE structure representing the minimum and maximum input and reference frame size, in pixels, used by the motion estimator. + + + TRUE if the motion estimator operates on protected resource input and produces protected output; otherwise, FALSE. + + + The allocation size of the motion vector heap in the L0 memory pool. L0 is the physical system memory pool. When the adapter is discrete/NUMA, this pool has greater bandwidth for the CPU and less bandwidth for the GPU. When the adapter is UMA, this pool is the only one which is valid. For more information, see Residency. + + + The allocation size of the motion vector heap in the L1 memory pool. L1 is typically known as the physical video memory pool. L1 is only available when the adapter is discrete/NUMA, and has greater bandwidth for the GPU and cannot even be accessed by the CPU. When the adapter is UMA, this pool is not available. For more information, see Residency. + + + The allocation size of the motion estimator heap in the L0 memory pool. L0 is the physical system memory pool. When the adapter is discrete/NUMA, this pool has greater bandwidth for the CPU and less bandwidth for the GPU. When the adapter is UMA, this pool is the only one which is valid. For more information, see Residency. + + + The allocation size of the motion estimator heap in the L1 memory pool. L1 is typically known as the physical video memory pool. L1 is only available when the adapter is discrete/NUMA, and has greater bandwidth for the GPU and cannot even be accessed by the CPU. When the adapter is UMA, this pool is not available. For more information, see Residency. + + + + Copies a region of a buffer from one resource to another. + Microsoft Docs: + Specifies the destination ID3D12Resource. + Specifies a UINT64 offset (in bytes) into the destination resource. + Specifies the source ID3D12Resource. + Specifies a UINT64 offset (in bytes) into the source resource, to start the copy from. + Specifies the number of bytes to copy. + + + + + Identifies a technique for resolving texture coordinates that are outside of the boundaries of a texture. + Microsoft Docs: + + + + Tile the texture at every (u,v) integer junction. + For example, for u values between 0 and 3, the texture is repeated three times. + + + Flip the texture at every (u,v) integer junction. + For u values between 0 and 1, for example, the texture is addressed normally; between 1 and 2, the texture is flipped (mirrored); between 2 and 3, the texture is normal again; and so on. + + + Texture coordinates outside the range [0.0, 1.0] are set to the texture color at 0.0 or 1.0, respectively. + + + Texture coordinates outside the range [0.0, 1.0] are set to the border color specified in D3D12_SAMPLER_DESC or HLSL code. + + + Similar to + D3D12_TEXTURE_ADDRESS_MODE_MIRROR + and + D3D12_TEXTURE_ADDRESS_MODE_CLAMP. + Takes the absolute value of the texture coordinate (thus, mirroring around 0), and then clamps to the maximum value. + + + + Defines constants that specify a level of dynamic optimization to apply to GPU work that's subsequently submitted. + Microsoft Docs: + + + + The default setting. Specifies that the driver may instrument workloads, and dynamically recompile shaders, in a low overhead, non-intrusive manner that avoids glitching the foreground workload. + + + Specifies that the driver may instrument as aggressively as possible. The understanding is that causing glitches is fine while in this mode, because the current work is being submitted specifically to train the system. + + + Specifies that background work should stop. This ensures that background shader recompilation won't consume CPU cycles. Available only in Developer mode. + + + Specifies that all dynamic optimization should be disabled. For example, if you're doing an A/B performance comparison, then using this constant ensures that the driver doesn't change anything that might interfere with your results. Available only in Developer mode. + + + + Specifies which resource heap tier the hardware and driver support. + Microsoft Docs: + + + + Indicates that heaps can only support resources from a single resource category. + For the list of resource categories, see Remarks. + In tier 1, these resource categories are mutually exclusive and cannot be used with the same heap. + The resource category must be declared when creating a heap, using the correct D3D12_HEAP_FLAGS enumeration constant. + Applications cannot create heaps with flags that allow all three categories. + + + Indicates that heaps can support resources from all three categories. + For the list of resource categories, see Remarks. + In tier 2, these resource categories can be mixed within the same heap. + Applications may create heaps with flags that allow all three categories; but are not required to do so. + Applications may be written to support tier 1 and seamlessly run on tier 2. + + + + Describes the format, width, height, depth, and row-pitch of the subresource into the parent resource. + Microsoft Docs: + + + + A DXGI_FORMAT-typed value that specifies the viewing format. + + + The width of the subresource. + + + The height of the subresource. + + + The depth of the subresource. + + + The row pitch, or width, or physical size, in bytes, of the subresource data. + This must be a multiple of D3D12_TEXTURE_DATA_PITCH_ALIGNMENT (256), and must be greater than or equal to the size of the data within a row. + + + + Retrieves the amount of memory required for the specified runtime parameter resource for a meta command, for the specified stage. + Microsoft Docs: + A D3D12_META_COMMAND_PARAMETER_STAGE specifying the stage to which the parameter belongs. + The zero-based index of the parameter within the stage. + + + + + Sets a CPU descriptor handle for the constant buffer in the graphics root signature. + Microsoft Docs: + The slot number for binding. + The GPU virtual address of the constant buffer. + D3D12_GPU_VIRTUAL_ADDRESS is a typedef'd alias of UINT64. + + + + + Describes the subresources from a 3D texture to use in a render-target view. + Microsoft Docs: + + + + The index of the mipmap level to use mip slice. + + + First depth level to use. + + + Number of depth levels to use in the render-target view, starting from FirstWSlice. A value of -1 indicates all of the slices along the w axis, starting from FirstWSlice. + + + + Describes the amount of artificial slowdown inserted by the debug device to simulate lower-performance graphics adapters. + Microsoft Docs: + + + + Specifies the amount of slowdown artificially applied, as a factor of the nominal time for the fence to signal. The default value is 0. + + + + Specifies the level of support for render passes on a graphics device. + Microsoft Docs: + + + + The user-mode display driver hasn't implemented render passes, and so the feature is provided only via software emulation. Render passes might not provide a performance advantage at this level of support. + + + The render passes feature is implemented by the user-mode display driver, and render target/depth buffer writes may be accelerated. Unordered access view (UAV) writes are not efficiently supported within the render pass. + + + The render passes feature is implemented by the user-mode display driver, render target/depth buffer writes may be accelerated, and unordered access view (UAV) writes (provided that writes in a render pass are not read until a subsequent render pass) are likely to be more efficient than issuing the same work without using a render pass. + + + + Describes a binding (fixed for the duration of the render pass) to a depth stencil view (DSV), as well as its beginning and ending access characteristics. + Microsoft Docs: + + + + A D3D12_CPU_DESCRIPTOR_HANDLE. The CPU descriptor handle corresponding to the depth stencil view (DSV). + + + A D3D12_RENDER_PASS_BEGINNING_ACCESS. The access to the depth buffer requested at the transition into a render pass. + + + A D3D12_RENDER_PASS_BEGINNING_ACCESS. The access to the stencil buffer requested at the transition into a render pass. + + + A D3D12_RENDER_PASS_ENDING_ACCESS. The access to the depth buffer requested at the transition out of a render pass. + + + A D3D12_RENDER_PASS_ENDING_ACCESS. The access to the stencil buffer requested at the transition out of a render pass. + + + + Describes the destination of a memory copy operation. + Microsoft Docs: + + + + A pointer to a memory block that receives the copied data. + + + The row pitch, or width, or physical size, in bytes, of the subresource data. + + + The slice pitch, or width, or physical size, in bytes, of the subresource data. + + + + Specifies categories of debug messages. + Microsoft Docs: + + + + Indicates a user defined message, see ID3D12InfoQueue::AddMessage. + + + + Provides methods for submitting command lists, synchronizing command list execution, instrumenting the command queue, and updating resource tile mappings. + Microsoft Docs: + + + + + Opens a handle for shared resources, shared heaps, and shared fences, by using HANDLE and REFIID. + Microsoft Docs: + The handle that was output by the call to + ID3D12Device::CreateSharedHandle. + The globally unique identifier (GUID) for one of the following interfaces: + + + +The REFIID, or GUID, of the interface can be obtained by using the __uuidof() macro. + For example, __uuidof(ID3D12Heap) will get the GUID of the interface to a resource. + A pointer to a memory block that receives a pointer to one of the following interfaces: + + + + + + + + Specifies the deinterlacing video processor capabilities. + Microsoft Docs: + + + + No deinterlacing capabilities are available. + + + The video processor can perform bob deinterlacing. In bob deinterlacing, missing field lines are interpolated from the lines above and below. Bob deinterlacing does not require reference frames. + + + The video processor can perform a custom high-quality deinterlacing, which requires the number of reference frames indicated in PastFrames and FutureFrames output fields of the D3D12_FEATURE_DATA_VIDEO_PROCESS_REFERENCE_INFO populated by a call to ID3D12VideoDevice::CheckFeatureSupport when the feature specified is D3D12_FEATURE_VIDEO_PROCESS_REFERENCE_INFO. If the video processor doesn’t have the necessary number of reference frames, it falls back to bob deinterlacing. + + + + Specifies the type of geometry used for raytracing. Use a value from this enumeration to specify the geometry type in a D3D12_RAYTRACING_GEOMETRY_DESC. + Microsoft Docs: + + + + The geometry consists of triangles. + + + The geometry procedurally is defined during raytracing by intersection shaders. For the purpose of acceleration structure builds, the geometry’s bounds are described with axis-aligned bounding boxes using the D3D12_RAYTRACING_GEOMETRY_AABBS_DESC structure. + + + + Describes settings used by GPU-Based Validation. + Microsoft Docs: + + + + Specifies a UINT that limits the number of messages that can be stored in the GPU-Based Validation message log. The default value is 256. Since many identical errors can be produced in a single Draw/Dispatch call it may be useful to increase this number. Note this can become a memory burden if a large number of command lists are used as there is a committed message log per command list. + + + Specifies the D3D12_GPU_BASED_VALIDATION_SHADER_PATCH_MODE that GPU-Based Validation uses when injecting validation code into shaders, except when overridden by per-command-list GPU-Based Validation settings (see D3D12_DEBUG_COMMAND_LIST_GPU_BASED_VALIDATION_SETTINGS). The default value is D3D12_GPU_BASED_VALIDATION_SHADER_PATCH_MODE_UNGUARDED_VALIDATION. + + + Specifies one of the D3D12_GPU_BASED_VALIDATION_PIPELINE_STATE_CREATE_FLAGS that indicates how GPU-Based Validation handles patching pipeline states. The default value is D3D12_GPU_BASED_VALIDATION_PIPELINE_STATE_CREATE_FLAG_NONE. + + + + Creates a query heap. A query heap contains an array of queries. + Microsoft Docs: + Specifies the query heap in a D3D12_QUERY_HEAP_DESC structure. + Specifies a REFIID that uniquely identifies the heap. + Specifies a pointer to the heap, that will be returned on successful completion of the method. + ppvHeap can be NULL, to enable capability testing. + When ppvHeap is NULL, no object will be created and S_FALSE will be returned when pDesc is valid. + + + + + Gets the corresponding interface slot for a variable that represents an interface pointer. + Microsoft Docs: + The index of the array element to get the slot number for. + For a non-array variable this value will be zero. + + + + + Identifies the tier of resource binding being used. + Microsoft Docs: + + + + Tier 1. + See Hardware Tiers. + + + Tier 2. + See Hardware Tiers. + + + Tier 3. + See Hardware Tiers. + + + + Query the driver for resource requirements to build an acceleration structure. + Microsoft Docs: + Description of the acceleration structure build. This structure is shared with BuildRaytracingAccelerationStructure. For more information, see D3D12_BUILD_RAYTRACING_ACCELERATION_STRUCTURE_INPUTS. + +The implementation is allowed to look at all the CPU parameters in this struct and nested structs. It may not inspect/dereference any GPU virtual addresses, other than to check to see if a pointer is NULL or not, such as the optional transform in D3D12_RAYTRACING_GEOMETRY_TRIANGLES_DESC, without dereferencing it. In other words, the calculation of resource requirements for the acceleration structure does not depend on the actual geometry data (such as vertex positions), rather it can only depend on overall properties, such as the number of triangles, number of instances etc. + The result of the query. + + + + + Represents a compressed bitstream from which video is decoded. + Microsoft Docs: + + + + A pointer to an ID3D12Resource representing the source buffer containing the compressed bitstream to decode. + + + The offset to the beginning of the first slice. This offset has alignment requirements based on the tier value of the video decoder. For more information on decoding tiers, see D3D12_VIDEO_DECODE_TIER. + + + The size of the subregion of pBuffer that contains the bitstream. + + + + Retrieves the list of video extension command parameters for the specified parameter stage. + Microsoft Docs: + + + + The unique identifier for the video extension command for which parameters are retrieved. + + + A member of the D3D12_VIDEO_EXTENSION_COMMAND_PARAMETER_STAGE enumeration specifying the parameter stage for which the parameters are retrieved. + + + The supported number of video extension command parameters. This value must be the count returned by a call to[ID3D12VideoDevice::CheckFeatureSupport](nf-d3d12video-id3d12videodevice-checkfeaturesupport.md) with D3D12_FEATURE_VIDEO_EXTENSION_COMMAND_PARAMETER_COUNT specified as the feature. + + + Receives a list of D3D12_VIDEO_EXTENSION_COMMAND_PARAMETER_INFO structures describing video extension command parameters. + + + + Describes the slot of a root signature version 1.1. + Microsoft Docs: + + + + A D3D12_ROOT_PARAMETER_TYPE-typed value that specifies the type of root signature slot. This member determines which type to use in the union below. + + + A D3D12_ROOT_DESCRIPTOR_TABLE1 structure that describes the layout of a descriptor table as a collection of descriptor ranges that appear one after the other in a descriptor heap. + + + A D3D12_ROOT_CONSTANTS structure that describes constants inline in the root signature that appear in shaders as one constant buffer. + + + A D3D12_ROOT_DESCRIPTOR1 structure that describes descriptors inline in the root signature that appear in shaders. + + + A D3D12_SHADER_VISIBILITY-typed value that specifies the shaders that can access the contents of the root signature slot. + + + + Gets the current pipeline stack size. + Microsoft Docs: + + + + + A function-reflection interface accesses function info. + Microsoft Docs: + + + + + Executes a compute shader on a thread group. + Microsoft Docs: + The number of groups dispatched in the x direction. ThreadGroupCountX must be less than or equal to D3D11_CS_DISPATCH_MAX_THREAD_GROUPS_PER_DIMENSION (65535). + The number of groups dispatched in the y direction. ThreadGroupCountY must be less than or equal to D3D11_CS_DISPATCH_MAX_THREAD_GROUPS_PER_DIMENSION (65535). + The number of groups dispatched in the z direction. ThreadGroupCountZ must be less than or equal to D3D11_CS_DISPATCH_MAX_THREAD_GROUPS_PER_DIMENSION (65535). + In feature level 10 the value for ThreadGroupCountZ must be 1. + + + + + Describes the dimensions of a viewport. + Microsoft Docs: + + + + X position of the left hand side of the viewport. + + + Y position of the top of the viewport. + + + Width of the viewport. + + + Height of the viewport. + + + Minimum depth of the viewport. Ranges between 0 and 1. + + + Maximum depth of the viewport. Ranges between 0 and 1. + + + + Debug message filter; contains a lists of message types to allow or deny. + Microsoft Docs: + + + + Specifies types of messages that you want to allow. See D3D12_INFO_QUEUE_FILTER_DESC. + + + Specifies types of messages that you want to deny. + + + + Describes the elements in a buffer resource to use in a shader-resource view. + Microsoft Docs: + + + + The index of the first element to be accessed by the view. + + + The number of elements in the resource. + + + The size of each element in the buffer structure (in bytes) when the buffer represents a structured buffer. + + + A D3D12_BUFFER_SRV_FLAGS-typed value that identifies view options for the buffer. Currently, the only option is to identify a raw view of the buffer. For more info about raw viewing of buffers, see Raw Views of Buffers. + + + + Specifies options for the amount of information to report about a live device object's lifetime. + Microsoft Docs: + + + + Obtain a summary about a live device object's lifetime. + + + Obtain detailed information about a live device object's lifetime. + + + This flag indicates to ignore objects which have no external refcounts keeping them alive. D3D objects are printed using an external refcount and an internal refcount. Typically, all objects are printed. This flag means ignore the objects whose external refcount is 0, because the application is not responsible for keeping them alive. + + + + Invalidates the CPU pointer to the specified subresource in the resource. Unmap also flushes the CPU cache, when necessary, so that GPU reads to this address reflect any modifications made by the CPU. + Microsoft Docs: + Specifies the index of the subresource. + A pointer to a D3D12_RANGE structure that describes the range of memory to unmap. + +This indicates the region the CPU might have modified, and the coordinates are subresource-relative. A null pointer indicates the entire subresource might have been modified by the CPU. It is valid to specify the CPU didn't write any data by passing a range where End is less than or equal to Begin. + + + + + Specifies the parameter stages for video extension commands. + Microsoft Docs: + + + + The parameter stage is in video extension command creation. + + + The parameter stage is in video extension command initialization. + + + The parameter stage is in video extension command execution. + + + The parameter stage is input parameters passed to capabilities queries. + + + The parameter stage is output parameters passed to capabilities queries. + + + The parameter stage is device execution input. + + + The parameter stage is device execution output. + + + + Identifies the type of resource being used. + Microsoft Docs: + + + + Resource is of unknown type. + + + Resource is a buffer. + + + Resource is a 1D texture. + + + Resource is a 2D texture. + + + Resource is a 3D texture. + + + + This method returns the GPU virtual address of a buffer resource. + Microsoft Docs: + + + + + Describes the layout of a root signature version 1.0. + Microsoft Docs: + + + + The number of slots in the root signature. This number is also the number of elements in the pParameters array. + + + An array of D3D12_ROOT_PARAMETER structures for the slots in the root signature. + + + Specifies the number of static samplers. + + + Pointer to one or more D3D12_STATIC_SAMPLER_DESC structures. + + + A combination of D3D12_ROOT_SIGNATURE_FLAGS-typed values that are combined by using a bitwise OR operation. + The resulting value specifies options for the root signature layout. + + + + Sets the layout of the compute root signature. + Microsoft Docs: + A pointer to the ID3D12RootSignature object. + + + + + Encapsulates a list of graphics commands for rendering, extending the interface to support ray tracing and render passes. + Microsoft Docs: + + + + + Specifies how to perform a tile-mapping operation. + Microsoft Docs: + + + + No tile-mapping flags are specified. + + + Unsupported, do not use. + + + + Describes an indirect argument (an indirect parameter), for use with a command signature. + Microsoft Docs: + + + + A single D3D12_INDIRECT_ARGUMENT_TYPE enumeration constant. + + + Specifies the slot containing the vertex buffer address. + + + Specifies the root index of the constant. + + + The offset, in 32-bit values, to set the first constant of the group. + Supports multi-value constants at a given root index. + Root constant entries must be sorted from smallest to largest DestOffsetIn32BitValues. + + + The number of 32-bit constants that are set at the given root index. + Supports multi-value constants at a given root index. + + + + Describes the subresources from an array of 1D textures to use in a render-target view. + Microsoft Docs: + + + + The index of the mipmap level to use mip slice. + + + The index of the first texture to use in an array of textures. + + + Number of textures to use. + + + + Associates an IUnknown-derived interface with the device object and associates that interface with an application-defined GUID. + Microsoft Docs: + The GUID to associate with the interface. + A pointer to the IUnknown-derived interface to be associated with the device object. + + + + + Specifies the parameters for decode output conversion. + Microsoft Docs: + + + + A boolean value indicating whether decode conversion should be used. + + + A pointer to an ID3D12Resource containing the native decoding output. When downsampling is enabled, the output at native decode resolution, color space, and format may be required for future decode submissions (as reference frames, for instance). + + + The subresource index of the resource provided in pDecodeTexture2D to use. + + + A value from the DXGI_COLOR_SPACE_TYPE enumeration specifying the target color space of the output. + + + A value from the DXGI_COLOR_SPACE_TYPE enumeration specifying the source-decoded color space before conversion. + + + + Describes a unordered-access 1D texture resource. + Microsoft Docs: + + + + The mipmap slice index. + + + + This interface represents a graphics device for debugging. + Microsoft Docs: + + + + + Retrieves the number of past and future reference frames required for the specified deinterlace mode, filter, rate conversion, or auto processing features. + Microsoft Docs: + + + + An integer indicating which physical adapter of the device the operation applies to, in a multi-adapter operation. + + + A member of the D3D12\_VIDEO\_PROCESS\_DEINTERLACE\_FLAGS enumeration specifying the deinterlacing mode for which the required past and future reference frame counts are retrieved. + + + A bitwise OR combination of values from the D3D12\_VIDEO\_PROCESS\_FILTER\_FLAGS enumeration specifying the filters for which the required past and future reference frame counts are retrieved. + + + A bitwise OR combination of values from the D3D12\_VIDEO\_PROCESS\_FEATURE\_FLAGS enumeration specifying the features for which the required past and future reference frame counts are retrieved. + + + The input frame rate of the stream for which the required past and future reference frame counts are retrieved. + + + The output frame rate of the stream for which the required past and future reference frame counts are retrieved. + + + True if autoprocessing will be used; otherwise, false. + + + The number of past frames required to support the specified processing features. + + + The number of future frames required to support the specified processing features. + + + + Specifies the CPU-page properties for the heap. + Microsoft Docs: + + + + The CPU-page property is unknown. + + + The CPU cannot access the heap, therefore no page properties are available. + + + The CPU-page property is write-combined. + + + The CPU-page property is write-back. + + + + Not intended to be called directly.  Use the PIX event runtime to insert events into a command list. + Microsoft Docs: + Internal. + Internal. + Internal. + + + + + Specifies the motion estimation search block sizes that a video encoder can support. + Microsoft Docs: + + + + Search block size is not supported by the encoder. + + + The encoder supports a search block size of 8x8 pixels. + + + The encoder supports a search block size of 16x16 pixels. + + + + Indicates the level of support that the adapter provides for metacommands. + Microsoft Docs: + + + + The fixed GUID that identfies the metacommand to query about. + + + For single GPU operation, this is zero. If there are multiple GPU nodes, a bit is set to identify a node (the device's physical adapter). Each bit in the mask corresponds to a single node. Only 1 bit must be set. Refer to [Multi-adapter systems](/windows/win32/direct3d12/multi-engine). + + + A pointer to a buffer containing the query input data. Allocate QueryInputDataSizeInBytes bytes. + + + The size of the buffer pointed to by pQueryInputData, in bytes. + + + A pointer to a buffer containing the query output data. + + + The size of the buffer pointed to by pQueryOutputData, in bytes. + + + + Gets the minimum feature level. + Microsoft Docs: + + + + + Set a mask that controls which view instances are enabled for subsequent draws. + Microsoft Docs: + A mask that specifies which views are enabled or disabled. If bit i starting from the least-significant bit is set, view instance i is enabled. + + + + + Get the number of messages that were discarded due to the message count limit. + Microsoft Docs: + + + + + Creates an ID3D12StateObject. + Microsoft Docs: + The description of the state object to create. + The GUID of the interface to create. Use __uuidof(ID3D12StateObject). + The returned state object. + + + + + Describes the subresource from a 1D texture to use in a render-target view. + Microsoft Docs: + + + + The index of the mipmap level to use mip slice. + + + + Describes a memory range in a 64-bit address space. + Microsoft Docs: + + + + The offset, in bytes, denoting the beginning of a memory range. + + + The offset, in bytes, denoting the end of a memory range. + End is one-past-the-end. + + + + Sets all the elements in a unordered-access view (UAV) to the specified integer values. + Microsoft Docs: + A D3D12_GPU_DESCRIPTOR_HANDLE that references an initialized descriptor for the unordered-access view (UAV) that is to be cleared. This descriptor must be in a shader-visible descriptor heap, which must be set on the command list via SetDescriptorHeaps. + A D3D12_CPU_DESCRIPTOR_HANDLE in a non-shader visible descriptor heap that references an initialized descriptor for the unordered-access view (UAV) that is to be cleared. + +> [!IMPORTANT] +> This descriptor must not be in a shader-visible descriptor heap. This is to allow drivers thath implement the clear as fixed-function hardware (rather than via a dispatch) to efficiently read from the descriptor, as shader-visible heaps may be created in WRITE_BACK memory (similar to D3D12_HEAP_TYPE_UPLOAD heap types), and CPU reads from this type of memory are prohibitively slow. + A pointer to the ID3D12Resource interface that represents the unordered-access-view (UAV) resource to clear. + A 4-component array that containing the values to fill the unordered-access-view resource with. + The number of rectangles in the array that the pRects parameter specifies. + An array of D3D12_RECT structures for the rectangles in the resource view to clear. If NULL, ClearUnorderedAccessViewUint clears the entire resource view. + + + + + Represents an axis-aligned bounding box (AABB) used as raytracing geometry. + Microsoft Docs: + + + + The minimum X coordinate of the box. + + + The minimum Y coordinate of the box. + + + The minimum Z coordinate of the box. + + + The maximum X coordinate of the box. + + + The maximum Y coordinate of the box. + + + The maximum Z coordinate of the box. + + + + Validates that the given state matches the state of the subresource, assuming the state of the given subresource is known during recording of a command list (e.g. + Microsoft Docs: + Specifies the ID3D12Resource to check. + The index of the subresource to check. This can be set to an index, or D3D12_RESOURCE_BARRIER_ALL_SUBRESOURCES. + Specifies the state to check for. This can be one or more D3D12_RESOURCE_STATES flags Or'ed together. + + + + + Contains the supported shader model. + Microsoft Docs: + + + + Specifies one member of D3D_SHADER_MODEL that indicates the maximum supported shader model. + + + + Defines constants that specify the shading rate (for variable-rate shading, or VRS) along a horizontal or vertical axis. + Microsoft Docs: + + + + Specifies a 1x shading rate for the axis. + + + Specifies a 2x shading rate for the axis. + + + Specifies a 4x shading rate for the axis. + + + + Describes a ID3D12VideoMotionEstimator. Pass this structure into ID3D12VideoDevice1::CreateVideoMotionEstimator to create an instance of ID3D12VideoMotionEstimator. + Microsoft Docs: + + + + The node mask specifying the physical adapter on which the video processor will be used. For single GPU operation, set this to zero. If there are multiple GPU nodes, set a bit to identify the node, i.e. the device's physical adapter, to which the command queue applies. Each bit in the mask corresponds to a single node. Only 1 bit may be set. + + + A value from the DXGI_FORMAT enumeration specifying the format of the input and reference frames. + + + A value from the D3D12_VIDEO_MOTION_ESTIMATOR_SEARCH_BLOCK_SIZE enumeration specifying the search block size the video motion estimator will use. + + + A value from the D3D12_VIDEO_MOTION_ESTIMATOR_VECTOR_PRECISION enumeration specifying the vector precision the video motion estimator will use. + + + A D3D12_VIDEO_SIZE_RANGE structure representing the minimum and maximum input and reference frame size, in pixels, that the motion estimator will accept. + + + + Represents a virtual adapter. This interface extends ID3D12Device2 to support the creation of special-purpose diagnostic heaps in system memory that persist even in the event of a GPU-fault or device-removed scenario. + Microsoft Docs: + + + + + Contains a method to return the deserialized D3D12_ROOT_SIGNATURE_DESC data structure, of a serialized root signature version 1.0. + Microsoft Docs: + + + + + Describes the layout of a root signature version 1.1. + Microsoft Docs: + + + + The number of slots in the root signature. This number is also the number of elements in the pParameters array. + + + An array of D3D12_ROOT_PARAMETER1 structures for the slots in the root signature. + + + Specifies the number of static samplers. + + + Pointer to one or more D3D12_STATIC_SAMPLER_DESC structures. + + + Specifies the D3D12_ROOT_SIGNATURE_FLAGS that determine the data volatility. + + + + Indicates whether a variable is of the specified type. + Microsoft Docs: + A pointer to a ID3D12ShaderReflectionType Interface. + + + + + Push a retrieval filter onto the retrieval-filter stack. + Microsoft Docs: + Pointer to a retrieval filter. + + + + + Notifies the driver that it needs to synchronize multiple accesses to resources. + Microsoft Docs: + The number of submitted barrier descriptions. + Pointer to an array of barrier descriptions. + + + + + Describes shader data. + Microsoft Docs: + + + + A pointer to a memory block that contains the shader data. + + + The size, in bytes, of the shader data that the pShaderBytecode member points to. + + + + Defines constants that specify render/compute GPU operations. + Microsoft Docs: + + + + Specifies that a DRED feature is enabled only when DRED is turned on by the system automatically (for example, when a user is reproducing a problem via FeedbackHub). + + + Specifies that a DRED feature should be force-disabled, regardless of the system state. + + + Specifies that a DRED feature should be force-enabled, regardless of the system state. + + + + Specifies the type of a state object. Use with D3D12_STATE_OBJECT_DESC. + Microsoft Docs: + + + + Collection state object. + + + Raytracing pipeline state object. + + + + Describes the supported scaling range of output sizes for a video scaler. + Microsoft Docs: + + + + A D3D12_VIDEO_SIZE_RANGE structure describing the supported output size range for the scaler. + + + A member of the D3D12_VIDEO_SCALE_SUPPORT_FLAGS enumeration specifying the supported scaling capabilities of the scaler. + + + + Encapsulates a generalized ability of the CPU and GPU to read and write to physical memory, or heaps. It contains abstractions for organizing and manipulating simple arrays of data as well as multidimensional data optimized for shader sampling. + Microsoft Docs: + + + + + Gets a description of how a resource is bound to a shader. + Microsoft Docs: + The constant-buffer name of the resource. + A pointer to an input-binding description. See D3D12_SHADER_INPUT_BIND_DESC. + + + \ No newline at end of file diff --git a/src/Vortice.Win32/Generated/Graphics/Direct3D11.cs b/src/Vortice.Win32/Generated/Graphics/Direct3D11.cs index 025897b..c909a76 100644 --- a/src/Vortice.Win32/Generated/Graphics/Direct3D11.cs +++ b/src/Vortice.Win32/Generated/Graphics/Direct3D11.cs @@ -7743,7 +7743,7 @@ public partial struct ShaderResourceViewDescription public _Anonymous_e__Union Anonymous; [UnscopedRef] - public ref Graphics.Direct3D11.BufferSrv Buffer + public ref BufferSrv Buffer { [MethodImpl(MethodImplOptions.AggressiveInlining)] get @@ -7757,7 +7757,7 @@ public partial struct ShaderResourceViewDescription } [UnscopedRef] - public ref Graphics.Direct3D11.Tex1dSrv Texture1D + public ref Tex1dSrv Texture1D { [MethodImpl(MethodImplOptions.AggressiveInlining)] get @@ -7771,7 +7771,7 @@ public partial struct ShaderResourceViewDescription } [UnscopedRef] - public ref Graphics.Direct3D11.Tex1dArraySrv Texture1DArray + public ref Tex1dArraySrv Texture1DArray { [MethodImpl(MethodImplOptions.AggressiveInlining)] get @@ -7785,7 +7785,7 @@ public partial struct ShaderResourceViewDescription } [UnscopedRef] - public ref Graphics.Direct3D11.Tex2dSrv Texture2D + public ref Tex2dSrv Texture2D { [MethodImpl(MethodImplOptions.AggressiveInlining)] get @@ -7799,7 +7799,7 @@ public partial struct ShaderResourceViewDescription } [UnscopedRef] - public ref Graphics.Direct3D11.Tex2dArraySrv Texture2DArray + public ref Tex2dArraySrv Texture2DArray { [MethodImpl(MethodImplOptions.AggressiveInlining)] get @@ -7813,7 +7813,7 @@ public partial struct ShaderResourceViewDescription } [UnscopedRef] - public ref Graphics.Direct3D11.Tex2dmsSrv Texture2DMS + public ref Tex2dmsSrv Texture2DMS { [MethodImpl(MethodImplOptions.AggressiveInlining)] get @@ -7827,7 +7827,7 @@ public partial struct ShaderResourceViewDescription } [UnscopedRef] - public ref Graphics.Direct3D11.Tex2dmsArraySrv Texture2DMSArray + public ref Tex2dmsArraySrv Texture2DMSArray { [MethodImpl(MethodImplOptions.AggressiveInlining)] get @@ -7841,7 +7841,7 @@ public partial struct ShaderResourceViewDescription } [UnscopedRef] - public ref Graphics.Direct3D11.Tex3dSrv Texture3D + public ref Tex3dSrv Texture3D { [MethodImpl(MethodImplOptions.AggressiveInlining)] get @@ -7855,7 +7855,7 @@ public partial struct ShaderResourceViewDescription } [UnscopedRef] - public ref Graphics.Direct3D11.TexcubeSrv TextureCube + public ref TexcubeSrv TextureCube { [MethodImpl(MethodImplOptions.AggressiveInlining)] get @@ -7869,7 +7869,7 @@ public partial struct ShaderResourceViewDescription } [UnscopedRef] - public ref Graphics.Direct3D11.TexcubeArraySrv TextureCubeArray + public ref TexcubeArraySrv TextureCubeArray { [MethodImpl(MethodImplOptions.AggressiveInlining)] get @@ -7883,7 +7883,7 @@ public partial struct ShaderResourceViewDescription } [UnscopedRef] - public ref Graphics.Direct3D11.BufferExtendedSrv BufferEx + public ref BufferExtendedSrv BufferEx { [MethodImpl(MethodImplOptions.AggressiveInlining)] get @@ -8129,7 +8129,7 @@ public partial struct RenderTargetViewDescription public _Anonymous_e__Union Anonymous; [UnscopedRef] - public ref Graphics.Direct3D11.BufferRtv Buffer + public ref BufferRtv Buffer { [MethodImpl(MethodImplOptions.AggressiveInlining)] get @@ -8143,7 +8143,7 @@ public partial struct RenderTargetViewDescription } [UnscopedRef] - public ref Graphics.Direct3D11.Tex1dRtv Texture1D + public ref Tex1dRtv Texture1D { [MethodImpl(MethodImplOptions.AggressiveInlining)] get @@ -8157,7 +8157,7 @@ public partial struct RenderTargetViewDescription } [UnscopedRef] - public ref Graphics.Direct3D11.Tex1dArrayRtv Texture1DArray + public ref Tex1dArrayRtv Texture1DArray { [MethodImpl(MethodImplOptions.AggressiveInlining)] get @@ -8171,7 +8171,7 @@ public partial struct RenderTargetViewDescription } [UnscopedRef] - public ref Graphics.Direct3D11.Tex2dRtv Texture2D + public ref Tex2dRtv Texture2D { [MethodImpl(MethodImplOptions.AggressiveInlining)] get @@ -8185,7 +8185,7 @@ public partial struct RenderTargetViewDescription } [UnscopedRef] - public ref Graphics.Direct3D11.Tex2dArrayRtv Texture2DArray + public ref Tex2dArrayRtv Texture2DArray { [MethodImpl(MethodImplOptions.AggressiveInlining)] get @@ -8199,7 +8199,7 @@ public partial struct RenderTargetViewDescription } [UnscopedRef] - public ref Graphics.Direct3D11.Tex2dmsRtv Texture2DMS + public ref Tex2dmsRtv Texture2DMS { [MethodImpl(MethodImplOptions.AggressiveInlining)] get @@ -8213,7 +8213,7 @@ public partial struct RenderTargetViewDescription } [UnscopedRef] - public ref Graphics.Direct3D11.Tex2dmsArrayRtv Texture2DMSArray + public ref Tex2dmsArrayRtv Texture2DMSArray { [MethodImpl(MethodImplOptions.AggressiveInlining)] get @@ -8227,7 +8227,7 @@ public partial struct RenderTargetViewDescription } [UnscopedRef] - public ref Graphics.Direct3D11.Tex3dRtv Texture3D + public ref Tex3dRtv Texture3D { [MethodImpl(MethodImplOptions.AggressiveInlining)] get @@ -8358,7 +8358,7 @@ public partial struct DepthStencilViewDescription public _Anonymous_e__Union Anonymous; [UnscopedRef] - public ref Graphics.Direct3D11.Tex1dDsv Texture1D + public ref Tex1dDsv Texture1D { [MethodImpl(MethodImplOptions.AggressiveInlining)] get @@ -8372,7 +8372,7 @@ public partial struct DepthStencilViewDescription } [UnscopedRef] - public ref Graphics.Direct3D11.Tex1dArrayDsv Texture1DArray + public ref Tex1dArrayDsv Texture1DArray { [MethodImpl(MethodImplOptions.AggressiveInlining)] get @@ -8386,7 +8386,7 @@ public partial struct DepthStencilViewDescription } [UnscopedRef] - public ref Graphics.Direct3D11.Tex2dDsv Texture2D + public ref Tex2dDsv Texture2D { [MethodImpl(MethodImplOptions.AggressiveInlining)] get @@ -8400,7 +8400,7 @@ public partial struct DepthStencilViewDescription } [UnscopedRef] - public ref Graphics.Direct3D11.Tex2dArrayDsv Texture2DArray + public ref Tex2dArrayDsv Texture2DArray { [MethodImpl(MethodImplOptions.AggressiveInlining)] get @@ -8414,7 +8414,7 @@ public partial struct DepthStencilViewDescription } [UnscopedRef] - public ref Graphics.Direct3D11.Tex2dmsDsv Texture2DMS + public ref Tex2dmsDsv Texture2DMS { [MethodImpl(MethodImplOptions.AggressiveInlining)] get @@ -8428,7 +8428,7 @@ public partial struct DepthStencilViewDescription } [UnscopedRef] - public ref Graphics.Direct3D11.Tex2dmsArrayDsv Texture2DMSArray + public ref Tex2dmsArrayDsv Texture2DMSArray { [MethodImpl(MethodImplOptions.AggressiveInlining)] get @@ -8557,7 +8557,7 @@ public partial struct UnorderedAccessViewDescription public _Anonymous_e__Union Anonymous; [UnscopedRef] - public ref Graphics.Direct3D11.BufferUav Buffer + public ref BufferUav Buffer { [MethodImpl(MethodImplOptions.AggressiveInlining)] get @@ -8571,7 +8571,7 @@ public partial struct UnorderedAccessViewDescription } [UnscopedRef] - public ref Graphics.Direct3D11.Tex1dUav Texture1D + public ref Tex1dUav Texture1D { [MethodImpl(MethodImplOptions.AggressiveInlining)] get @@ -8585,7 +8585,7 @@ public partial struct UnorderedAccessViewDescription } [UnscopedRef] - public ref Graphics.Direct3D11.Tex1dArrayUav Texture1DArray + public ref Tex1dArrayUav Texture1DArray { [MethodImpl(MethodImplOptions.AggressiveInlining)] get @@ -8599,7 +8599,7 @@ public partial struct UnorderedAccessViewDescription } [UnscopedRef] - public ref Graphics.Direct3D11.Tex2dUav Texture2D + public ref Tex2dUav Texture2D { [MethodImpl(MethodImplOptions.AggressiveInlining)] get @@ -8613,7 +8613,7 @@ public partial struct UnorderedAccessViewDescription } [UnscopedRef] - public ref Graphics.Direct3D11.Tex2dArrayUav Texture2DArray + public ref Tex2dArrayUav Texture2DArray { [MethodImpl(MethodImplOptions.AggressiveInlining)] get @@ -8627,7 +8627,7 @@ public partial struct UnorderedAccessViewDescription } [UnscopedRef] - public ref Graphics.Direct3D11.Tex3dUav Texture3D + public ref Tex3dUav Texture3D { [MethodImpl(MethodImplOptions.AggressiveInlining)] get @@ -9437,7 +9437,7 @@ public partial struct VideoColor public _Anonymous_e__Union Anonymous; [UnscopedRef] - public ref Graphics.Direct3D11.VideoColorYcbcra YCbCr + public ref VideoColorYcbcra YCbCr { [MethodImpl(MethodImplOptions.AggressiveInlining)] get @@ -9451,7 +9451,7 @@ public partial struct VideoColor } [UnscopedRef] - public ref Graphics.Direct3D11.VideoColorRgba RGBA + public ref VideoColorRgba RGBA { [MethodImpl(MethodImplOptions.AggressiveInlining)] get @@ -9938,7 +9938,7 @@ public partial struct VideoDecoderOutputViewDescription public _Anonymous_e__Union Anonymous; [UnscopedRef] - public ref Graphics.Direct3D11.Tex2dVdov Texture2D + public ref Tex2dVdov Texture2D { [MethodImpl(MethodImplOptions.AggressiveInlining)] get @@ -9986,7 +9986,7 @@ public partial struct VideoProcessorInputViewDescription public _Anonymous_e__Union Anonymous; [UnscopedRef] - public ref Graphics.Direct3D11.Tex2dVpiv Texture2D + public ref Tex2dVpiv Texture2D { [MethodImpl(MethodImplOptions.AggressiveInlining)] get @@ -10042,7 +10042,7 @@ public partial struct VideoProcessorOutputViewDescription public _Anonymous_e__Union Anonymous; [UnscopedRef] - public ref Graphics.Direct3D11.Tex2dVpov Texture2D + public ref Tex2dVpov Texture2D { [MethodImpl(MethodImplOptions.AggressiveInlining)] get @@ -10056,7 +10056,7 @@ public partial struct VideoProcessorOutputViewDescription } [UnscopedRef] - public ref Graphics.Direct3D11.Tex2dArrayVpov Texture2DArray + public ref Tex2dArrayVpov Texture2DArray { [MethodImpl(MethodImplOptions.AggressiveInlining)] get @@ -10648,7 +10648,7 @@ public partial struct ShaderResourceViewDescription1 public _Anonymous_e__Union Anonymous; [UnscopedRef] - public ref Graphics.Direct3D11.BufferSrv Buffer + public ref BufferSrv Buffer { [MethodImpl(MethodImplOptions.AggressiveInlining)] get @@ -10662,7 +10662,7 @@ public partial struct ShaderResourceViewDescription1 } [UnscopedRef] - public ref Graphics.Direct3D11.Tex1dSrv Texture1D + public ref Tex1dSrv Texture1D { [MethodImpl(MethodImplOptions.AggressiveInlining)] get @@ -10676,7 +10676,7 @@ public partial struct ShaderResourceViewDescription1 } [UnscopedRef] - public ref Graphics.Direct3D11.Tex1dArraySrv Texture1DArray + public ref Tex1dArraySrv Texture1DArray { [MethodImpl(MethodImplOptions.AggressiveInlining)] get @@ -10690,7 +10690,7 @@ public partial struct ShaderResourceViewDescription1 } [UnscopedRef] - public ref Graphics.Direct3D11.Tex2dSrv1 Texture2D + public ref Tex2dSrv1 Texture2D { [MethodImpl(MethodImplOptions.AggressiveInlining)] get @@ -10704,7 +10704,7 @@ public partial struct ShaderResourceViewDescription1 } [UnscopedRef] - public ref Graphics.Direct3D11.Tex2dArraySrv1 Texture2DArray + public ref Tex2dArraySrv1 Texture2DArray { [MethodImpl(MethodImplOptions.AggressiveInlining)] get @@ -10718,7 +10718,7 @@ public partial struct ShaderResourceViewDescription1 } [UnscopedRef] - public ref Graphics.Direct3D11.Tex2dmsSrv Texture2DMS + public ref Tex2dmsSrv Texture2DMS { [MethodImpl(MethodImplOptions.AggressiveInlining)] get @@ -10732,7 +10732,7 @@ public partial struct ShaderResourceViewDescription1 } [UnscopedRef] - public ref Graphics.Direct3D11.Tex2dmsArraySrv Texture2DMSArray + public ref Tex2dmsArraySrv Texture2DMSArray { [MethodImpl(MethodImplOptions.AggressiveInlining)] get @@ -10746,7 +10746,7 @@ public partial struct ShaderResourceViewDescription1 } [UnscopedRef] - public ref Graphics.Direct3D11.Tex3dSrv Texture3D + public ref Tex3dSrv Texture3D { [MethodImpl(MethodImplOptions.AggressiveInlining)] get @@ -10760,7 +10760,7 @@ public partial struct ShaderResourceViewDescription1 } [UnscopedRef] - public ref Graphics.Direct3D11.TexcubeSrv TextureCube + public ref TexcubeSrv TextureCube { [MethodImpl(MethodImplOptions.AggressiveInlining)] get @@ -10774,7 +10774,7 @@ public partial struct ShaderResourceViewDescription1 } [UnscopedRef] - public ref Graphics.Direct3D11.TexcubeArraySrv TextureCubeArray + public ref TexcubeArraySrv TextureCubeArray { [MethodImpl(MethodImplOptions.AggressiveInlining)] get @@ -10788,7 +10788,7 @@ public partial struct ShaderResourceViewDescription1 } [UnscopedRef] - public ref Graphics.Direct3D11.BufferExtendedSrv BufferEx + public ref BufferExtendedSrv BufferEx { [MethodImpl(MethodImplOptions.AggressiveInlining)] get @@ -10893,7 +10893,7 @@ public partial struct RenderTargetViewDescription1 public _Anonymous_e__Union Anonymous; [UnscopedRef] - public ref Graphics.Direct3D11.BufferRtv Buffer + public ref BufferRtv Buffer { [MethodImpl(MethodImplOptions.AggressiveInlining)] get @@ -10907,7 +10907,7 @@ public partial struct RenderTargetViewDescription1 } [UnscopedRef] - public ref Graphics.Direct3D11.Tex1dRtv Texture1D + public ref Tex1dRtv Texture1D { [MethodImpl(MethodImplOptions.AggressiveInlining)] get @@ -10921,7 +10921,7 @@ public partial struct RenderTargetViewDescription1 } [UnscopedRef] - public ref Graphics.Direct3D11.Tex1dArrayRtv Texture1DArray + public ref Tex1dArrayRtv Texture1DArray { [MethodImpl(MethodImplOptions.AggressiveInlining)] get @@ -10935,7 +10935,7 @@ public partial struct RenderTargetViewDescription1 } [UnscopedRef] - public ref Graphics.Direct3D11.Tex2dRtv1 Texture2D + public ref Tex2dRtv1 Texture2D { [MethodImpl(MethodImplOptions.AggressiveInlining)] get @@ -10949,7 +10949,7 @@ public partial struct RenderTargetViewDescription1 } [UnscopedRef] - public ref Graphics.Direct3D11.Tex2dArrayRtv1 Texture2DArray + public ref Tex2dArrayRtv1 Texture2DArray { [MethodImpl(MethodImplOptions.AggressiveInlining)] get @@ -10963,7 +10963,7 @@ public partial struct RenderTargetViewDescription1 } [UnscopedRef] - public ref Graphics.Direct3D11.Tex2dmsRtv Texture2DMS + public ref Tex2dmsRtv Texture2DMS { [MethodImpl(MethodImplOptions.AggressiveInlining)] get @@ -10977,7 +10977,7 @@ public partial struct RenderTargetViewDescription1 } [UnscopedRef] - public ref Graphics.Direct3D11.Tex2dmsArrayRtv Texture2DMSArray + public ref Tex2dmsArrayRtv Texture2DMSArray { [MethodImpl(MethodImplOptions.AggressiveInlining)] get @@ -10991,7 +10991,7 @@ public partial struct RenderTargetViewDescription1 } [UnscopedRef] - public ref Graphics.Direct3D11.Tex3dRtv Texture3D + public ref Tex3dRtv Texture3D { [MethodImpl(MethodImplOptions.AggressiveInlining)] get @@ -11084,7 +11084,7 @@ public partial struct UnorderedAccessViewDescription1 public _Anonymous_e__Union Anonymous; [UnscopedRef] - public ref Graphics.Direct3D11.BufferUav Buffer + public ref BufferUav Buffer { [MethodImpl(MethodImplOptions.AggressiveInlining)] get @@ -11098,7 +11098,7 @@ public partial struct UnorderedAccessViewDescription1 } [UnscopedRef] - public ref Graphics.Direct3D11.Tex1dUav Texture1D + public ref Tex1dUav Texture1D { [MethodImpl(MethodImplOptions.AggressiveInlining)] get @@ -11112,7 +11112,7 @@ public partial struct UnorderedAccessViewDescription1 } [UnscopedRef] - public ref Graphics.Direct3D11.Tex1dArrayUav Texture1DArray + public ref Tex1dArrayUav Texture1DArray { [MethodImpl(MethodImplOptions.AggressiveInlining)] get @@ -11126,7 +11126,7 @@ public partial struct UnorderedAccessViewDescription1 } [UnscopedRef] - public ref Graphics.Direct3D11.Tex2dUav1 Texture2D + public ref Tex2dUav1 Texture2D { [MethodImpl(MethodImplOptions.AggressiveInlining)] get @@ -11140,7 +11140,7 @@ public partial struct UnorderedAccessViewDescription1 } [UnscopedRef] - public ref Graphics.Direct3D11.Tex2dArrayUav1 Texture2DArray + public ref Tex2dArrayUav1 Texture2DArray { [MethodImpl(MethodImplOptions.AggressiveInlining)] get @@ -11154,7 +11154,7 @@ public partial struct UnorderedAccessViewDescription1 } [UnscopedRef] - public ref Graphics.Direct3D11.Tex3dUav Texture3D + public ref Tex3dUav Texture3D { [MethodImpl(MethodImplOptions.AggressiveInlining)] get @@ -11765,7 +11765,7 @@ public partial struct ShaderTraceDescription public _Anonymous_e__Union Anonymous; [UnscopedRef] - public ref Graphics.Direct3D11.VertexShaderTraceDescription VertexShaderTraceDesc + public ref VertexShaderTraceDescription VertexShaderTraceDesc { [MethodImpl(MethodImplOptions.AggressiveInlining)] get @@ -11779,7 +11779,7 @@ public partial struct ShaderTraceDescription } [UnscopedRef] - public ref Graphics.Direct3D11.HullShaderTraceDescription HullShaderTraceDesc + public ref HullShaderTraceDescription HullShaderTraceDesc { [MethodImpl(MethodImplOptions.AggressiveInlining)] get @@ -11793,7 +11793,7 @@ public partial struct ShaderTraceDescription } [UnscopedRef] - public ref Graphics.Direct3D11.DomainShaderTraceDescription DomainShaderTraceDesc + public ref DomainShaderTraceDescription DomainShaderTraceDesc { [MethodImpl(MethodImplOptions.AggressiveInlining)] get @@ -11807,7 +11807,7 @@ public partial struct ShaderTraceDescription } [UnscopedRef] - public ref Graphics.Direct3D11.GeometryShaderTraceDescription GeometryShaderTraceDesc + public ref GeometryShaderTraceDescription GeometryShaderTraceDesc { [MethodImpl(MethodImplOptions.AggressiveInlining)] get @@ -11821,7 +11821,7 @@ public partial struct ShaderTraceDescription } [UnscopedRef] - public ref Graphics.Direct3D11.PixelShaderTraceDescription PixelShaderTraceDesc + public ref PixelShaderTraceDescription PixelShaderTraceDesc { [MethodImpl(MethodImplOptions.AggressiveInlining)] get @@ -11835,7 +11835,7 @@ public partial struct ShaderTraceDescription } [UnscopedRef] - public ref Graphics.Direct3D11.ComputeShaderTraceDescription ComputeShaderTraceDesc + public ref ComputeShaderTraceDescription ComputeShaderTraceDesc { [MethodImpl(MethodImplOptions.AggressiveInlining)] get diff --git a/src/Vortice.Win32/Generated/Graphics/Direct3D12.cs b/src/Vortice.Win32/Generated/Graphics/Direct3D12.cs new file mode 100644 index 0000000..518e8c5 --- /dev/null +++ b/src/Vortice.Win32/Generated/Graphics/Direct3D12.cs @@ -0,0 +1,34427 @@ +// ------------------------------------------------------------------------------ +// +// 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.Direct3D12; + +public static partial class Apis +{ + public const uint D3D12_SHADER_COMPONENT_MAPPING_ALWAYS_SET_BIT_AVOIDING_ZEROMEM_MISTAKES = 4096; + public const uint D3D12_DEFAULT_SHADER_4_COMPONENT_MAPPING = 5768; + public const uint D3D12_16BIT_INDEX_STRIP_CUT_VALUE = 65535; + public const uint D3D12_32BIT_INDEX_STRIP_CUT_VALUE = 4294967295; + public const uint D3D12_8BIT_INDEX_STRIP_CUT_VALUE = 255; + public const uint D3D12_APPEND_ALIGNED_ELEMENT = 4294967295; + public const uint D3D12_ARRAY_AXIS_ADDRESS_RANGE_BIT_COUNT = 9; + public const uint D3D12_CLIP_OR_CULL_DISTANCE_COUNT = 8; + public const uint D3D12_CLIP_OR_CULL_DISTANCE_ELEMENT_COUNT = 2; + public const uint D3D12_COMMONSHADER_CONSTANT_BUFFER_API_SLOT_COUNT = 14; + public const uint D3D12_COMMONSHADER_CONSTANT_BUFFER_COMPONENTS = 4; + public const uint D3D12_COMMONSHADER_CONSTANT_BUFFER_COMPONENT_BIT_COUNT = 32; + public const uint D3D12_COMMONSHADER_CONSTANT_BUFFER_HW_SLOT_COUNT = 15; + public const uint D3D12_COMMONSHADER_CONSTANT_BUFFER_PARTIAL_UPDATE_EXTENTS_BYTE_ALIGNMENT = 16; + public const uint D3D12_COMMONSHADER_CONSTANT_BUFFER_REGISTER_COMPONENTS = 4; + public const uint D3D12_COMMONSHADER_CONSTANT_BUFFER_REGISTER_COUNT = 15; + public const uint D3D12_COMMONSHADER_CONSTANT_BUFFER_REGISTER_READS_PER_INST = 1; + public const uint D3D12_COMMONSHADER_CONSTANT_BUFFER_REGISTER_READ_PORTS = 1; + public const uint D3D12_COMMONSHADER_FLOWCONTROL_NESTING_LIMIT = 64; + public const uint D3D12_COMMONSHADER_IMMEDIATE_CONSTANT_BUFFER_REGISTER_COMPONENTS = 4; + public const uint D3D12_COMMONSHADER_IMMEDIATE_CONSTANT_BUFFER_REGISTER_COUNT = 1; + public const uint D3D12_COMMONSHADER_IMMEDIATE_CONSTANT_BUFFER_REGISTER_READS_PER_INST = 1; + public const uint D3D12_COMMONSHADER_IMMEDIATE_CONSTANT_BUFFER_REGISTER_READ_PORTS = 1; + public const uint D3D12_COMMONSHADER_IMMEDIATE_VALUE_COMPONENT_BIT_COUNT = 32; + public const uint D3D12_COMMONSHADER_INPUT_RESOURCE_REGISTER_COMPONENTS = 1; + public const uint D3D12_COMMONSHADER_INPUT_RESOURCE_REGISTER_COUNT = 128; + public const uint D3D12_COMMONSHADER_INPUT_RESOURCE_REGISTER_READS_PER_INST = 1; + public const uint D3D12_COMMONSHADER_INPUT_RESOURCE_REGISTER_READ_PORTS = 1; + public const uint D3D12_COMMONSHADER_INPUT_RESOURCE_SLOT_COUNT = 128; + public const uint D3D12_COMMONSHADER_SAMPLER_REGISTER_COMPONENTS = 1; + public const uint D3D12_COMMONSHADER_SAMPLER_REGISTER_COUNT = 16; + public const uint D3D12_COMMONSHADER_SAMPLER_REGISTER_READS_PER_INST = 1; + public const uint D3D12_COMMONSHADER_SAMPLER_REGISTER_READ_PORTS = 1; + public const uint D3D12_COMMONSHADER_SAMPLER_SLOT_COUNT = 16; + public const uint D3D12_COMMONSHADER_SUBROUTINE_NESTING_LIMIT = 32; + public const uint D3D12_COMMONSHADER_TEMP_REGISTER_COMPONENTS = 4; + public const uint D3D12_COMMONSHADER_TEMP_REGISTER_COMPONENT_BIT_COUNT = 32; + public const uint D3D12_COMMONSHADER_TEMP_REGISTER_COUNT = 4096; + public const uint D3D12_COMMONSHADER_TEMP_REGISTER_READS_PER_INST = 3; + public const uint D3D12_COMMONSHADER_TEMP_REGISTER_READ_PORTS = 3; + public const uint D3D12_COMMONSHADER_TEXCOORD_RANGE_REDUCTION_MAX = 10; + public const int D3D12_COMMONSHADER_TEXCOORD_RANGE_REDUCTION_MIN = -10; + public const int D3D12_COMMONSHADER_TEXEL_OFFSET_MAX_NEGATIVE = -8; + public const uint D3D12_COMMONSHADER_TEXEL_OFFSET_MAX_POSITIVE = 7; + public const uint D3D12_CONSTANT_BUFFER_DATA_PLACEMENT_ALIGNMENT = 256; + public const uint D3D12_CS_4_X_BUCKET00_MAX_BYTES_TGSM_WRITABLE_PER_THREAD = 256; + public const uint D3D12_CS_4_X_BUCKET00_MAX_NUM_THREADS_PER_GROUP = 64; + public const uint D3D12_CS_4_X_BUCKET01_MAX_BYTES_TGSM_WRITABLE_PER_THREAD = 240; + public const uint D3D12_CS_4_X_BUCKET01_MAX_NUM_THREADS_PER_GROUP = 68; + public const uint D3D12_CS_4_X_BUCKET02_MAX_BYTES_TGSM_WRITABLE_PER_THREAD = 224; + public const uint D3D12_CS_4_X_BUCKET02_MAX_NUM_THREADS_PER_GROUP = 72; + public const uint D3D12_CS_4_X_BUCKET03_MAX_BYTES_TGSM_WRITABLE_PER_THREAD = 208; + public const uint D3D12_CS_4_X_BUCKET03_MAX_NUM_THREADS_PER_GROUP = 76; + public const uint D3D12_CS_4_X_BUCKET04_MAX_BYTES_TGSM_WRITABLE_PER_THREAD = 192; + public const uint D3D12_CS_4_X_BUCKET04_MAX_NUM_THREADS_PER_GROUP = 84; + public const uint D3D12_CS_4_X_BUCKET05_MAX_BYTES_TGSM_WRITABLE_PER_THREAD = 176; + public const uint D3D12_CS_4_X_BUCKET05_MAX_NUM_THREADS_PER_GROUP = 92; + public const uint D3D12_CS_4_X_BUCKET06_MAX_BYTES_TGSM_WRITABLE_PER_THREAD = 160; + public const uint D3D12_CS_4_X_BUCKET06_MAX_NUM_THREADS_PER_GROUP = 100; + public const uint D3D12_CS_4_X_BUCKET07_MAX_BYTES_TGSM_WRITABLE_PER_THREAD = 144; + public const uint D3D12_CS_4_X_BUCKET07_MAX_NUM_THREADS_PER_GROUP = 112; + public const uint D3D12_CS_4_X_BUCKET08_MAX_BYTES_TGSM_WRITABLE_PER_THREAD = 128; + public const uint D3D12_CS_4_X_BUCKET08_MAX_NUM_THREADS_PER_GROUP = 128; + public const uint D3D12_CS_4_X_BUCKET09_MAX_BYTES_TGSM_WRITABLE_PER_THREAD = 112; + public const uint D3D12_CS_4_X_BUCKET09_MAX_NUM_THREADS_PER_GROUP = 144; + public const uint D3D12_CS_4_X_BUCKET10_MAX_BYTES_TGSM_WRITABLE_PER_THREAD = 96; + public const uint D3D12_CS_4_X_BUCKET10_MAX_NUM_THREADS_PER_GROUP = 168; + public const uint D3D12_CS_4_X_BUCKET11_MAX_BYTES_TGSM_WRITABLE_PER_THREAD = 80; + public const uint D3D12_CS_4_X_BUCKET11_MAX_NUM_THREADS_PER_GROUP = 204; + public const uint D3D12_CS_4_X_BUCKET12_MAX_BYTES_TGSM_WRITABLE_PER_THREAD = 64; + public const uint D3D12_CS_4_X_BUCKET12_MAX_NUM_THREADS_PER_GROUP = 256; + public const uint D3D12_CS_4_X_BUCKET13_MAX_BYTES_TGSM_WRITABLE_PER_THREAD = 48; + public const uint D3D12_CS_4_X_BUCKET13_MAX_NUM_THREADS_PER_GROUP = 340; + public const uint D3D12_CS_4_X_BUCKET14_MAX_BYTES_TGSM_WRITABLE_PER_THREAD = 32; + public const uint D3D12_CS_4_X_BUCKET14_MAX_NUM_THREADS_PER_GROUP = 512; + public const uint D3D12_CS_4_X_BUCKET15_MAX_BYTES_TGSM_WRITABLE_PER_THREAD = 16; + public const uint D3D12_CS_4_X_BUCKET15_MAX_NUM_THREADS_PER_GROUP = 768; + public const uint D3D12_CS_4_X_DISPATCH_MAX_THREAD_GROUPS_IN_Z_DIMENSION = 1; + public const uint D3D12_CS_4_X_RAW_UAV_BYTE_ALIGNMENT = 256; + public const uint D3D12_CS_4_X_THREAD_GROUP_MAX_THREADS_PER_GROUP = 768; + public const uint D3D12_CS_4_X_THREAD_GROUP_MAX_X = 768; + public const uint D3D12_CS_4_X_THREAD_GROUP_MAX_Y = 768; + public const uint D3D12_CS_4_X_UAV_REGISTER_COUNT = 1; + public const uint D3D12_CS_DISPATCH_MAX_THREAD_GROUPS_PER_DIMENSION = 65535; + public const uint D3D12_CS_TGSM_REGISTER_COUNT = 8192; + public const uint D3D12_CS_TGSM_REGISTER_READS_PER_INST = 1; + public const uint D3D12_CS_TGSM_RESOURCE_REGISTER_COMPONENTS = 1; + public const uint D3D12_CS_TGSM_RESOURCE_REGISTER_READ_PORTS = 1; + public const uint D3D12_CS_THREADGROUPID_REGISTER_COMPONENTS = 3; + public const uint D3D12_CS_THREADGROUPID_REGISTER_COUNT = 1; + public const uint D3D12_CS_THREADIDINGROUPFLATTENED_REGISTER_COMPONENTS = 1; + public const uint D3D12_CS_THREADIDINGROUPFLATTENED_REGISTER_COUNT = 1; + public const uint D3D12_CS_THREADIDINGROUP_REGISTER_COMPONENTS = 3; + public const uint D3D12_CS_THREADIDINGROUP_REGISTER_COUNT = 1; + public const uint D3D12_CS_THREADID_REGISTER_COMPONENTS = 3; + public const uint D3D12_CS_THREADID_REGISTER_COUNT = 1; + public const uint D3D12_CS_THREAD_GROUP_MAX_THREADS_PER_GROUP = 1024; + public const uint D3D12_CS_THREAD_GROUP_MAX_X = 1024; + public const uint D3D12_CS_THREAD_GROUP_MAX_Y = 1024; + public const uint D3D12_CS_THREAD_GROUP_MAX_Z = 64; + public const uint D3D12_CS_THREAD_GROUP_MIN_X = 1; + public const uint D3D12_CS_THREAD_GROUP_MIN_Y = 1; + public const uint D3D12_CS_THREAD_GROUP_MIN_Z = 1; + public const uint D3D12_CS_THREAD_LOCAL_TEMP_REGISTER_POOL = 16384; + public const float D3D12_DEFAULT_BLEND_FACTOR_ALPHA = 1f; + public const float D3D12_DEFAULT_BLEND_FACTOR_BLUE = 1f; + public const float D3D12_DEFAULT_BLEND_FACTOR_GREEN = 1f; + public const float D3D12_DEFAULT_BLEND_FACTOR_RED = 1f; + public const float D3D12_DEFAULT_BORDER_COLOR_COMPONENT = 0f; + public const int D3D12_DEFAULT_DEPTH_BIAS = 0; + public const float D3D12_DEFAULT_DEPTH_BIAS_CLAMP = 0f; + public const uint D3D12_DEFAULT_MAX_ANISOTROPY = 16; + public const float D3D12_DEFAULT_MIP_LOD_BIAS = 0f; + public const uint D3D12_DEFAULT_MSAA_RESOURCE_PLACEMENT_ALIGNMENT = 4194304; + public const uint D3D12_DEFAULT_RENDER_TARGET_ARRAY_INDEX = 0; + public const uint D3D12_DEFAULT_RESOURCE_PLACEMENT_ALIGNMENT = 65536; + public const uint D3D12_DEFAULT_SAMPLE_MASK = 4294967295; + public const uint D3D12_DEFAULT_SCISSOR_ENDX = 0; + public const uint D3D12_DEFAULT_SCISSOR_ENDY = 0; + public const uint D3D12_DEFAULT_SCISSOR_STARTX = 0; + public const uint D3D12_DEFAULT_SCISSOR_STARTY = 0; + public const float D3D12_DEFAULT_SLOPE_SCALED_DEPTH_BIAS = 0f; + public const uint D3D12_DEFAULT_STENCIL_READ_MASK = 255; + public const uint D3D12_DEFAULT_STENCIL_REFERENCE = 0; + public const uint D3D12_DEFAULT_STENCIL_WRITE_MASK = 255; + public const uint D3D12_DEFAULT_VIEWPORT_AND_SCISSORRECT_INDEX = 0; + public const uint D3D12_DEFAULT_VIEWPORT_HEIGHT = 0; + public const float D3D12_DEFAULT_VIEWPORT_MAX_DEPTH = 0f; + public const float D3D12_DEFAULT_VIEWPORT_MIN_DEPTH = 0f; + public const uint D3D12_DEFAULT_VIEWPORT_TOPLEFTX = 0; + public const uint D3D12_DEFAULT_VIEWPORT_TOPLEFTY = 0; + public const uint D3D12_DEFAULT_VIEWPORT_WIDTH = 0; + public const uint D3D12_DESCRIPTOR_RANGE_OFFSET_APPEND = 4294967295; + public const uint D3D12_DRIVER_RESERVED_REGISTER_SPACE_VALUES_END = 4294967287; + public const uint D3D12_DRIVER_RESERVED_REGISTER_SPACE_VALUES_START = 4294967280; + public const uint D3D12_DS_INPUT_CONTROL_POINTS_MAX_TOTAL_SCALARS = 3968; + public const uint D3D12_DS_INPUT_CONTROL_POINT_REGISTER_COMPONENTS = 4; + public const uint D3D12_DS_INPUT_CONTROL_POINT_REGISTER_COMPONENT_BIT_COUNT = 32; + public const uint D3D12_DS_INPUT_CONTROL_POINT_REGISTER_COUNT = 32; + public const uint D3D12_DS_INPUT_CONTROL_POINT_REGISTER_READS_PER_INST = 2; + public const uint D3D12_DS_INPUT_CONTROL_POINT_REGISTER_READ_PORTS = 1; + public const uint D3D12_DS_INPUT_DOMAIN_POINT_REGISTER_COMPONENTS = 3; + public const uint D3D12_DS_INPUT_DOMAIN_POINT_REGISTER_COMPONENT_BIT_COUNT = 32; + public const uint D3D12_DS_INPUT_DOMAIN_POINT_REGISTER_COUNT = 1; + public const uint D3D12_DS_INPUT_DOMAIN_POINT_REGISTER_READS_PER_INST = 2; + public const uint D3D12_DS_INPUT_DOMAIN_POINT_REGISTER_READ_PORTS = 1; + public const uint D3D12_DS_INPUT_PATCH_CONSTANT_REGISTER_COMPONENTS = 4; + public const uint D3D12_DS_INPUT_PATCH_CONSTANT_REGISTER_COMPONENT_BIT_COUNT = 32; + public const uint D3D12_DS_INPUT_PATCH_CONSTANT_REGISTER_COUNT = 32; + public const uint D3D12_DS_INPUT_PATCH_CONSTANT_REGISTER_READS_PER_INST = 2; + public const uint D3D12_DS_INPUT_PATCH_CONSTANT_REGISTER_READ_PORTS = 1; + public const uint D3D12_DS_INPUT_PRIMITIVE_ID_REGISTER_COMPONENTS = 1; + public const uint D3D12_DS_INPUT_PRIMITIVE_ID_REGISTER_COMPONENT_BIT_COUNT = 32; + public const uint D3D12_DS_INPUT_PRIMITIVE_ID_REGISTER_COUNT = 1; + public const uint D3D12_DS_INPUT_PRIMITIVE_ID_REGISTER_READS_PER_INST = 2; + public const uint D3D12_DS_INPUT_PRIMITIVE_ID_REGISTER_READ_PORTS = 1; + public const uint D3D12_DS_OUTPUT_REGISTER_COMPONENTS = 4; + public const uint D3D12_DS_OUTPUT_REGISTER_COMPONENT_BIT_COUNT = 32; + public const uint D3D12_DS_OUTPUT_REGISTER_COUNT = 32; + public const double D3D12_FLOAT16_FUSED_TOLERANCE_IN_ULP = 0.6; + public const float D3D12_FLOAT32_MAX = 3.4028235E+38f; + public const float D3D12_FLOAT32_TO_INTEGER_TOLERANCE_IN_ULP = 0.6f; + public const float D3D12_FLOAT_TO_SRGB_EXPONENT_DENOMINATOR = 2.4f; + public const float D3D12_FLOAT_TO_SRGB_EXPONENT_NUMERATOR = 1f; + public const float D3D12_FLOAT_TO_SRGB_OFFSET = 0.055f; + public const float D3D12_FLOAT_TO_SRGB_SCALE_1 = 12.92f; + public const float D3D12_FLOAT_TO_SRGB_SCALE_2 = 1.055f; + public const float D3D12_FLOAT_TO_SRGB_THRESHOLD = 0.0031308f; + public const float D3D12_FTOI_INSTRUCTION_MAX_INPUT = 2.1474836E+09f; + public const float D3D12_FTOI_INSTRUCTION_MIN_INPUT = -2.1474836E+09f; + public const float D3D12_FTOU_INSTRUCTION_MAX_INPUT = 4.2949673E+09f; + public const float D3D12_FTOU_INSTRUCTION_MIN_INPUT = 0f; + public const uint D3D12_GS_INPUT_INSTANCE_ID_READS_PER_INST = 2; + public const uint D3D12_GS_INPUT_INSTANCE_ID_READ_PORTS = 1; + public const uint D3D12_GS_INPUT_INSTANCE_ID_REGISTER_COMPONENTS = 1; + public const uint D3D12_GS_INPUT_INSTANCE_ID_REGISTER_COMPONENT_BIT_COUNT = 32; + public const uint D3D12_GS_INPUT_INSTANCE_ID_REGISTER_COUNT = 1; + public const uint D3D12_GS_INPUT_PRIM_CONST_REGISTER_COMPONENTS = 1; + public const uint D3D12_GS_INPUT_PRIM_CONST_REGISTER_COMPONENT_BIT_COUNT = 32; + public const uint D3D12_GS_INPUT_PRIM_CONST_REGISTER_COUNT = 1; + public const uint D3D12_GS_INPUT_PRIM_CONST_REGISTER_READS_PER_INST = 2; + public const uint D3D12_GS_INPUT_PRIM_CONST_REGISTER_READ_PORTS = 1; + public const uint D3D12_GS_INPUT_REGISTER_COMPONENTS = 4; + public const uint D3D12_GS_INPUT_REGISTER_COMPONENT_BIT_COUNT = 32; + public const uint D3D12_GS_INPUT_REGISTER_COUNT = 32; + public const uint D3D12_GS_INPUT_REGISTER_READS_PER_INST = 2; + public const uint D3D12_GS_INPUT_REGISTER_READ_PORTS = 1; + public const uint D3D12_GS_INPUT_REGISTER_VERTICES = 32; + public const uint D3D12_GS_MAX_INSTANCE_COUNT = 32; + public const uint D3D12_GS_MAX_OUTPUT_VERTEX_COUNT_ACROSS_INSTANCES = 1024; + public const uint D3D12_GS_OUTPUT_ELEMENTS = 32; + public const uint D3D12_GS_OUTPUT_REGISTER_COMPONENTS = 4; + public const uint D3D12_GS_OUTPUT_REGISTER_COMPONENT_BIT_COUNT = 32; + public const uint D3D12_GS_OUTPUT_REGISTER_COUNT = 32; + public const uint D3D12_HS_CONTROL_POINT_PHASE_INPUT_REGISTER_COUNT = 32; + public const uint D3D12_HS_CONTROL_POINT_PHASE_OUTPUT_REGISTER_COUNT = 32; + public const uint D3D12_HS_CONTROL_POINT_REGISTER_COMPONENTS = 4; + public const uint D3D12_HS_CONTROL_POINT_REGISTER_COMPONENT_BIT_COUNT = 32; + public const uint D3D12_HS_CONTROL_POINT_REGISTER_READS_PER_INST = 2; + public const uint D3D12_HS_CONTROL_POINT_REGISTER_READ_PORTS = 1; + public const uint D3D12_HS_FORK_PHASE_INSTANCE_COUNT_UPPER_BOUND = 4294967295; + public const uint D3D12_HS_INPUT_FORK_INSTANCE_ID_REGISTER_COMPONENTS = 1; + public const uint D3D12_HS_INPUT_FORK_INSTANCE_ID_REGISTER_COMPONENT_BIT_COUNT = 32; + public const uint D3D12_HS_INPUT_FORK_INSTANCE_ID_REGISTER_COUNT = 1; + public const uint D3D12_HS_INPUT_FORK_INSTANCE_ID_REGISTER_READS_PER_INST = 2; + public const uint D3D12_HS_INPUT_FORK_INSTANCE_ID_REGISTER_READ_PORTS = 1; + public const uint D3D12_HS_INPUT_JOIN_INSTANCE_ID_REGISTER_COMPONENTS = 1; + public const uint D3D12_HS_INPUT_JOIN_INSTANCE_ID_REGISTER_COMPONENT_BIT_COUNT = 32; + public const uint D3D12_HS_INPUT_JOIN_INSTANCE_ID_REGISTER_COUNT = 1; + public const uint D3D12_HS_INPUT_JOIN_INSTANCE_ID_REGISTER_READS_PER_INST = 2; + public const uint D3D12_HS_INPUT_JOIN_INSTANCE_ID_REGISTER_READ_PORTS = 1; + public const uint D3D12_HS_INPUT_PRIMITIVE_ID_REGISTER_COMPONENTS = 1; + public const uint D3D12_HS_INPUT_PRIMITIVE_ID_REGISTER_COMPONENT_BIT_COUNT = 32; + public const uint D3D12_HS_INPUT_PRIMITIVE_ID_REGISTER_COUNT = 1; + public const uint D3D12_HS_INPUT_PRIMITIVE_ID_REGISTER_READS_PER_INST = 2; + public const uint D3D12_HS_INPUT_PRIMITIVE_ID_REGISTER_READ_PORTS = 1; + public const uint D3D12_HS_JOIN_PHASE_INSTANCE_COUNT_UPPER_BOUND = 4294967295; + public const float D3D12_HS_MAXTESSFACTOR_LOWER_BOUND = 1f; + public const float D3D12_HS_MAXTESSFACTOR_UPPER_BOUND = 64f; + public const uint D3D12_HS_OUTPUT_CONTROL_POINTS_MAX_TOTAL_SCALARS = 3968; + public const uint D3D12_HS_OUTPUT_CONTROL_POINT_ID_REGISTER_COMPONENTS = 1; + public const uint D3D12_HS_OUTPUT_CONTROL_POINT_ID_REGISTER_COMPONENT_BIT_COUNT = 32; + public const uint D3D12_HS_OUTPUT_CONTROL_POINT_ID_REGISTER_COUNT = 1; + public const uint D3D12_HS_OUTPUT_CONTROL_POINT_ID_REGISTER_READS_PER_INST = 2; + public const uint D3D12_HS_OUTPUT_CONTROL_POINT_ID_REGISTER_READ_PORTS = 1; + public const uint D3D12_HS_OUTPUT_PATCH_CONSTANT_REGISTER_COMPONENTS = 4; + public const uint D3D12_HS_OUTPUT_PATCH_CONSTANT_REGISTER_COMPONENT_BIT_COUNT = 32; + public const uint D3D12_HS_OUTPUT_PATCH_CONSTANT_REGISTER_COUNT = 32; + public const uint D3D12_HS_OUTPUT_PATCH_CONSTANT_REGISTER_READS_PER_INST = 2; + public const uint D3D12_HS_OUTPUT_PATCH_CONSTANT_REGISTER_READ_PORTS = 1; + public const uint D3D12_HS_OUTPUT_PATCH_CONSTANT_REGISTER_SCALAR_COMPONENTS = 128; + public const uint D3D12_IA_DEFAULT_INDEX_BUFFER_OFFSET_IN_BYTES = 0; + public const uint D3D12_IA_DEFAULT_PRIMITIVE_TOPOLOGY = 0; + public const uint D3D12_IA_DEFAULT_VERTEX_BUFFER_OFFSET_IN_BYTES = 0; + public const uint D3D12_IA_INDEX_INPUT_RESOURCE_SLOT_COUNT = 1; + public const uint D3D12_IA_INSTANCE_ID_BIT_COUNT = 32; + public const uint D3D12_IA_INTEGER_ARITHMETIC_BIT_COUNT = 32; + public const uint D3D12_IA_PATCH_MAX_CONTROL_POINT_COUNT = 32; + public const uint D3D12_IA_PRIMITIVE_ID_BIT_COUNT = 32; + public const uint D3D12_IA_VERTEX_ID_BIT_COUNT = 32; + public const uint D3D12_IA_VERTEX_INPUT_RESOURCE_SLOT_COUNT = 32; + public const uint D3D12_IA_VERTEX_INPUT_STRUCTURE_ELEMENTS_COMPONENTS = 128; + public const uint D3D12_IA_VERTEX_INPUT_STRUCTURE_ELEMENT_COUNT = 32; + public const uint D3D12_INTEGER_DIVIDE_BY_ZERO_QUOTIENT = 4294967295; + public const uint D3D12_INTEGER_DIVIDE_BY_ZERO_REMAINDER = 4294967295; + public const uint D3D12_KEEP_RENDER_TARGETS_AND_DEPTH_STENCIL = 4294967295; + public const uint D3D12_KEEP_UNORDERED_ACCESS_VIEWS = 4294967295; + public const float D3D12_LINEAR_GAMMA = 1f; + public const uint D3D12_MAJOR_VERSION = 12; + public const float D3D12_MAX_BORDER_COLOR_COMPONENT = 1f; + public const float D3D12_MAX_DEPTH = 1f; + public const uint D3D12_MAX_LIVE_STATIC_SAMPLERS = 2032; + public const uint D3D12_MAX_MAXANISOTROPY = 16; + public const uint D3D12_MAX_MULTISAMPLE_SAMPLE_COUNT = 32; + public const float D3D12_MAX_POSITION_VALUE = 3.4028236E+34f; + public const uint D3D12_MAX_ROOT_COST = 64; + public const uint D3D12_MAX_SHADER_VISIBLE_DESCRIPTOR_HEAP_SIZE_TIER_1 = 1000000; + public const uint D3D12_MAX_SHADER_VISIBLE_DESCRIPTOR_HEAP_SIZE_TIER_2 = 1000000; + public const uint D3D12_MAX_SHADER_VISIBLE_SAMPLER_HEAP_SIZE = 2048; + public const uint D3D12_MAX_TEXTURE_DIMENSION_2_TO_EXP = 17; + public const uint D3D12_MAX_VIEW_INSTANCE_COUNT = 4; + public const uint D3D12_MINOR_VERSION = 0; + public const float D3D12_MIN_BORDER_COLOR_COMPONENT = 0f; + public const float D3D12_MIN_DEPTH = 0f; + public const uint D3D12_MIN_MAXANISOTROPY = 0; + public const float D3D12_MIP_LOD_BIAS_MAX = 15.99f; + public const float D3D12_MIP_LOD_BIAS_MIN = -16f; + public const uint D3D12_MIP_LOD_FRACTIONAL_BIT_COUNT = 8; + public const uint D3D12_MIP_LOD_RANGE_BIT_COUNT = 8; + public const float D3D12_MULTISAMPLE_ANTIALIAS_LINE_WIDTH = 1.4f; + public const uint D3D12_NONSAMPLE_FETCH_OUT_OF_RANGE_ACCESS_RESULT = 0; + public const uint D3D12_OS_RESERVED_REGISTER_SPACE_VALUES_END = 4294967295; + public const uint D3D12_OS_RESERVED_REGISTER_SPACE_VALUES_START = 4294967288; + public const uint D3D12_PACKED_TILE = 4294967295; + public const uint D3D12_PIXEL_ADDRESS_RANGE_BIT_COUNT = 15; + public const uint D3D12_PRE_SCISSOR_PIXEL_ADDRESS_RANGE_BIT_COUNT = 16; + public const uint D3D12_PS_CS_UAV_REGISTER_COMPONENTS = 1; + public const uint D3D12_PS_CS_UAV_REGISTER_COUNT = 8; + public const uint D3D12_PS_CS_UAV_REGISTER_READS_PER_INST = 1; + public const uint D3D12_PS_CS_UAV_REGISTER_READ_PORTS = 1; + public const uint D3D12_PS_FRONTFACING_DEFAULT_VALUE = 4294967295; + public const uint D3D12_PS_FRONTFACING_FALSE_VALUE = 0; + public const uint D3D12_PS_FRONTFACING_TRUE_VALUE = 4294967295; + public const uint D3D12_PS_INPUT_REGISTER_COMPONENTS = 4; + public const uint D3D12_PS_INPUT_REGISTER_COMPONENT_BIT_COUNT = 32; + public const uint D3D12_PS_INPUT_REGISTER_COUNT = 32; + public const uint D3D12_PS_INPUT_REGISTER_READS_PER_INST = 2; + public const uint D3D12_PS_INPUT_REGISTER_READ_PORTS = 1; + public const float D3D12_PS_LEGACY_PIXEL_CENTER_FRACTIONAL_COMPONENT = 0f; + public const uint D3D12_PS_OUTPUT_DEPTH_REGISTER_COMPONENTS = 1; + public const uint D3D12_PS_OUTPUT_DEPTH_REGISTER_COMPONENT_BIT_COUNT = 32; + public const uint D3D12_PS_OUTPUT_DEPTH_REGISTER_COUNT = 1; + public const uint D3D12_PS_OUTPUT_MASK_REGISTER_COMPONENTS = 1; + public const uint D3D12_PS_OUTPUT_MASK_REGISTER_COMPONENT_BIT_COUNT = 32; + public const uint D3D12_PS_OUTPUT_MASK_REGISTER_COUNT = 1; + public const uint D3D12_PS_OUTPUT_REGISTER_COMPONENTS = 4; + public const uint D3D12_PS_OUTPUT_REGISTER_COMPONENT_BIT_COUNT = 32; + public const uint D3D12_PS_OUTPUT_REGISTER_COUNT = 8; + public const float D3D12_PS_PIXEL_CENTER_FRACTIONAL_COMPONENT = 0.5f; + public const uint D3D12_RAW_UAV_SRV_BYTE_ALIGNMENT = 16; + public const uint D3D12_RAYTRACING_AABB_BYTE_ALIGNMENT = 8; + public const uint D3D12_RAYTRACING_ACCELERATION_STRUCTURE_BYTE_ALIGNMENT = 256; + public const uint D3D12_RAYTRACING_INSTANCE_DESCS_BYTE_ALIGNMENT = 16; + public const uint D3D12_RAYTRACING_MAX_ATTRIBUTE_SIZE_IN_BYTES = 32; + public const uint D3D12_RAYTRACING_MAX_DECLARABLE_TRACE_RECURSION_DEPTH = 31; + public const uint D3D12_RAYTRACING_MAX_GEOMETRIES_PER_BOTTOM_LEVEL_ACCELERATION_STRUCTURE = 16777216; + public const uint D3D12_RAYTRACING_MAX_INSTANCES_PER_TOP_LEVEL_ACCELERATION_STRUCTURE = 16777216; + public const uint D3D12_RAYTRACING_MAX_PRIMITIVES_PER_BOTTOM_LEVEL_ACCELERATION_STRUCTURE = 536870912; + public const uint D3D12_RAYTRACING_MAX_RAY_GENERATION_SHADER_THREADS = 1073741824; + public const uint D3D12_RAYTRACING_MAX_SHADER_RECORD_STRIDE = 4096; + public const uint D3D12_RAYTRACING_SHADER_RECORD_BYTE_ALIGNMENT = 32; + public const uint D3D12_RAYTRACING_SHADER_TABLE_BYTE_ALIGNMENT = 64; + public const uint D3D12_RAYTRACING_TRANSFORM3X4_BYTE_ALIGNMENT = 16; + public const uint D3D12_REQ_BLEND_OBJECT_COUNT_PER_DEVICE = 4096; + public const uint D3D12_REQ_BUFFER_RESOURCE_TEXEL_COUNT_2_TO_EXP = 27; + public const uint D3D12_REQ_CONSTANT_BUFFER_ELEMENT_COUNT = 4096; + public const uint D3D12_REQ_DEPTH_STENCIL_OBJECT_COUNT_PER_DEVICE = 4096; + public const uint D3D12_REQ_DRAWINDEXED_INDEX_COUNT_2_TO_EXP = 32; + public const uint D3D12_REQ_DRAW_VERTEX_COUNT_2_TO_EXP = 32; + public const uint D3D12_REQ_FILTERING_HW_ADDRESSABLE_RESOURCE_DIMENSION = 16384; + public const uint D3D12_REQ_GS_INVOCATION_32BIT_OUTPUT_COMPONENT_LIMIT = 1024; + public const uint D3D12_REQ_IMMEDIATE_CONSTANT_BUFFER_ELEMENT_COUNT = 4096; + public const uint D3D12_REQ_MAXANISOTROPY = 16; + public const uint D3D12_REQ_MIP_LEVELS = 15; + public const uint D3D12_REQ_MULTI_ELEMENT_STRUCTURE_SIZE_IN_BYTES = 2048; + public const uint D3D12_REQ_RASTERIZER_OBJECT_COUNT_PER_DEVICE = 4096; + public const uint D3D12_REQ_RENDER_TO_BUFFER_WINDOW_WIDTH = 16384; + public const uint D3D12_REQ_RESOURCE_SIZE_IN_MEGABYTES_EXPRESSION_A_TERM = 128; + public const float D3D12_REQ_RESOURCE_SIZE_IN_MEGABYTES_EXPRESSION_B_TERM = 0.25f; + public const uint D3D12_REQ_RESOURCE_SIZE_IN_MEGABYTES_EXPRESSION_C_TERM = 2048; + public const uint D3D12_REQ_RESOURCE_VIEW_COUNT_PER_DEVICE_2_TO_EXP = 20; + public const uint D3D12_REQ_SAMPLER_OBJECT_COUNT_PER_DEVICE = 4096; + public const uint D3D12_REQ_SUBRESOURCES = 30720; + public const uint D3D12_REQ_TEXTURE1D_ARRAY_AXIS_DIMENSION = 2048; + public const uint D3D12_REQ_TEXTURE1D_U_DIMENSION = 16384; + public const uint D3D12_REQ_TEXTURE2D_ARRAY_AXIS_DIMENSION = 2048; + public const uint D3D12_REQ_TEXTURE2D_U_OR_V_DIMENSION = 16384; + public const uint D3D12_REQ_TEXTURE3D_U_V_OR_W_DIMENSION = 2048; + public const uint D3D12_REQ_TEXTURECUBE_DIMENSION = 16384; + public const uint D3D12_RESINFO_INSTRUCTION_MISSING_COMPONENT_RETVAL = 0; + public const uint D3D12_RESOURCE_BARRIER_ALL_SUBRESOURCES = 4294967295; + public const uint D3D12_RS_SET_SHADING_RATE_COMBINER_COUNT = 2; + public const uint D3D12_SDK_VERSION = 5; + public const uint D3D12_SHADER_IDENTIFIER_SIZE_IN_BYTES = 32; + public const uint D3D12_SHADER_MAJOR_VERSION = 5; + public const uint D3D12_SHADER_MAX_INSTANCES = 65535; + public const uint D3D12_SHADER_MAX_INTERFACES = 253; + public const uint D3D12_SHADER_MAX_INTERFACE_CALL_SITES = 4096; + public const uint D3D12_SHADER_MAX_TYPES = 65535; + public const uint D3D12_SHADER_MINOR_VERSION = 1; + public const uint D3D12_SHIFT_INSTRUCTION_PAD_VALUE = 0; + public const uint D3D12_SHIFT_INSTRUCTION_SHIFT_VALUE_BIT_COUNT = 5; + public const uint D3D12_SIMULTANEOUS_RENDER_TARGET_COUNT = 8; + public const uint D3D12_SMALL_MSAA_RESOURCE_PLACEMENT_ALIGNMENT = 65536; + public const uint D3D12_SMALL_RESOURCE_PLACEMENT_ALIGNMENT = 4096; + public const uint D3D12_SO_BUFFER_MAX_STRIDE_IN_BYTES = 2048; + public const uint D3D12_SO_BUFFER_MAX_WRITE_WINDOW_IN_BYTES = 512; + public const uint D3D12_SO_BUFFER_SLOT_COUNT = 4; + public const uint D3D12_SO_DDI_REGISTER_INDEX_DENOTING_GAP = 4294967295; + public const uint D3D12_SO_NO_RASTERIZED_STREAM = 4294967295; + public const uint D3D12_SO_OUTPUT_COMPONENT_COUNT = 128; + public const uint D3D12_SO_STREAM_COUNT = 4; + public const uint D3D12_SPEC_DATE_DAY = 14; + public const uint D3D12_SPEC_DATE_MONTH = 11; + public const uint D3D12_SPEC_DATE_YEAR = 2014; + public const double D3D12_SPEC_VERSION = 1.16; + public const float D3D12_SRGB_GAMMA = 2.2f; + public const float D3D12_SRGB_TO_FLOAT_DENOMINATOR_1 = 12.92f; + public const float D3D12_SRGB_TO_FLOAT_DENOMINATOR_2 = 1.055f; + public const float D3D12_SRGB_TO_FLOAT_EXPONENT = 2.4f; + public const float D3D12_SRGB_TO_FLOAT_OFFSET = 0.055f; + public const float D3D12_SRGB_TO_FLOAT_THRESHOLD = 0.04045f; + public const float D3D12_SRGB_TO_FLOAT_TOLERANCE_IN_ULP = 0.5f; + public const uint D3D12_STANDARD_COMPONENT_BIT_COUNT = 32; + public const uint D3D12_STANDARD_COMPONENT_BIT_COUNT_DOUBLED = 64; + public const uint D3D12_STANDARD_MAXIMUM_ELEMENT_ALIGNMENT_BYTE_MULTIPLE = 4; + public const uint D3D12_STANDARD_PIXEL_COMPONENT_COUNT = 128; + public const uint D3D12_STANDARD_PIXEL_ELEMENT_COUNT = 32; + public const uint D3D12_STANDARD_VECTOR_SIZE = 4; + public const uint D3D12_STANDARD_VERTEX_ELEMENT_COUNT = 32; + public const uint D3D12_STANDARD_VERTEX_TOTAL_COMPONENT_COUNT = 64; + public const uint D3D12_SUBPIXEL_FRACTIONAL_BIT_COUNT = 8; + public const uint D3D12_SUBTEXEL_FRACTIONAL_BIT_COUNT = 8; + public const uint D3D12_SYSTEM_RESERVED_REGISTER_SPACE_VALUES_END = 4294967295; + public const uint D3D12_SYSTEM_RESERVED_REGISTER_SPACE_VALUES_START = 4294967280; + public const uint D3D12_TESSELLATOR_MAX_EVEN_TESSELLATION_FACTOR = 64; + public const uint D3D12_TESSELLATOR_MAX_ISOLINE_DENSITY_TESSELLATION_FACTOR = 64; + public const uint D3D12_TESSELLATOR_MAX_ODD_TESSELLATION_FACTOR = 63; + public const uint D3D12_TESSELLATOR_MAX_TESSELLATION_FACTOR = 64; + public const uint D3D12_TESSELLATOR_MIN_EVEN_TESSELLATION_FACTOR = 2; + public const uint D3D12_TESSELLATOR_MIN_ISOLINE_DENSITY_TESSELLATION_FACTOR = 1; + public const uint D3D12_TESSELLATOR_MIN_ODD_TESSELLATION_FACTOR = 1; + public const uint D3D12_TEXEL_ADDRESS_RANGE_BIT_COUNT = 16; + public const uint D3D12_TEXTURE_DATA_PITCH_ALIGNMENT = 256; + public const uint D3D12_TEXTURE_DATA_PLACEMENT_ALIGNMENT = 512; + public const uint D3D12_TILED_RESOURCE_TILE_SIZE_IN_BYTES = 65536; + public const uint D3D12_TRACKED_WORKLOAD_MAX_INSTANCES = 32; + public const uint D3D12_UAV_COUNTER_PLACEMENT_ALIGNMENT = 4096; + public const uint D3D12_UAV_SLOT_COUNT = 64; + public const uint D3D12_UNBOUND_MEMORY_ACCESS_RESULT = 0; + public const uint D3D12_VIDEO_DECODE_MAX_ARGUMENTS = 10; + public const uint D3D12_VIDEO_DECODE_MAX_HISTOGRAM_COMPONENTS = 4; + public const uint D3D12_VIDEO_DECODE_MIN_BITSTREAM_OFFSET_ALIGNMENT = 256; + public const uint D3D12_VIDEO_DECODE_MIN_HISTOGRAM_OFFSET_ALIGNMENT = 256; + public const uint D3D12_VIDEO_DECODE_STATUS_MACROBLOCKS_AFFECTED_UNKNOWN = 4294967295; + public const uint D3D12_VIDEO_PROCESS_MAX_FILTERS = 32; + public const uint D3D12_VIDEO_PROCESS_STEREO_VIEWS = 2; + public const uint D3D12_VIEWPORT_AND_SCISSORRECT_MAX_INDEX = 15; + public const uint D3D12_VIEWPORT_AND_SCISSORRECT_OBJECT_COUNT_PER_PIPELINE = 16; + public const uint D3D12_VIEWPORT_BOUNDS_MAX = 32767; + public const int D3D12_VIEWPORT_BOUNDS_MIN = -32768; + public const uint D3D12_VS_INPUT_REGISTER_COMPONENTS = 4; + public const uint D3D12_VS_INPUT_REGISTER_COMPONENT_BIT_COUNT = 32; + public const uint D3D12_VS_INPUT_REGISTER_COUNT = 32; + public const uint D3D12_VS_INPUT_REGISTER_READS_PER_INST = 2; + public const uint D3D12_VS_INPUT_REGISTER_READ_PORTS = 1; + public const uint D3D12_VS_OUTPUT_REGISTER_COMPONENTS = 4; + public const uint D3D12_VS_OUTPUT_REGISTER_COMPONENT_BIT_COUNT = 32; + public const uint D3D12_VS_OUTPUT_REGISTER_COUNT = 32; + public const uint D3D12_WHQL_CONTEXT_COUNT_FOR_RESOURCE_LIMIT = 10; + public const uint D3D12_WHQL_DRAWINDEXED_INDEX_COUNT_2_TO_EXP = 25; + public const uint D3D12_WHQL_DRAW_VERTEX_COUNT_2_TO_EXP = 25; + public const uint D3D12_SHADER_COMPONENT_MAPPING_MASK = 7; + public const uint D3D12_SHADER_COMPONENT_MAPPING_SHIFT = 3; + public const uint D3D12_FILTER_REDUCTION_TYPE_MASK = 3; + public const uint D3D12_FILTER_REDUCTION_TYPE_SHIFT = 7; + public const uint D3D12_FILTER_TYPE_MASK = 3; + public const uint D3D12_MIN_FILTER_SHIFT = 4; + public const uint D3D12_MAG_FILTER_SHIFT = 2; + public const uint D3D12_MIP_FILTER_SHIFT = 0; + public const uint D3D12_ANISOTROPIC_FILTERING_BIT = 64; + public const uint LUID_DEFINED = 1; + public static readonly Guid D3D12_PROTECTED_RESOURCES_SESSION_HARDWARE_PROTECTED = new Guid(0x62b0084e, 0xc70e, 0x4daa, 0xa1, 0x09, 0x30, 0xff, 0x8d, 0x5a, 0x04, 0x82); + public static readonly Guid CLSID_D3D12Debug = new Guid(0xf2352aeb, 0xdd84, 0x49fe, 0xb9, 0x7b, 0xa9, 0xdc, 0xfd, 0xcc, 0x1b, 0x4f); + public static readonly Guid CLSID_D3D12Tools = new Guid(0xe38216b1, 0x3c8c, 0x4833, 0xaa, 0x09, 0x0a, 0x06, 0xb6, 0x5d, 0x96, 0xc8); + public static readonly Guid CLSID_D3D12DeviceRemovedExtendedData = new Guid(0x4a75bbc4, 0x9ff4, 0x4ad8, 0x9f, 0x18, 0xab, 0xae, 0x84, 0xdc, 0x5f, 0xf2); + public static readonly Guid CLSID_D3D12SDKConfiguration = new Guid(0x7cda6aca, 0xa03e, 0x49c8, 0x94, 0x58, 0x03, 0x34, 0xd2, 0x0e, 0x07, 0xce); + public const uint D3D12_SHADING_RATE_X_AXIS_SHIFT = 2; + public const uint D3D12_SHADING_RATE_VALID_MASK = 3; + public static readonly Guid WKPDID_D3DAutoDebugObjectNameW = new Guid(0xd4902e36, 0x757a, 0x4942, 0x95, 0x94, 0xb6, 0x76, 0x9a, 0xfa, 0x43, 0xcd); + public static readonly Guid DXGI_DEBUG_D3D12 = new Guid(0xcf59a98c, 0xa950, 0x4326, 0x91, 0xef, 0x9b, 0xba, 0xa1, 0x7b, 0xfd, 0x95); + public const uint D3D12_INFO_QUEUE_DEFAULT_MESSAGE_COUNT_LIMIT = 1024; + public const uint D3D_SHADER_REQUIRES_STENCIL_REF = 512; + public const uint D3D_SHADER_REQUIRES_INNER_COVERAGE = 1024; + public const uint D3D_SHADER_REQUIRES_TYPED_UAV_LOAD_ADDITIONAL_FORMATS = 2048; + public const uint D3D_SHADER_REQUIRES_ROVS = 4096; + public const uint D3D_SHADER_REQUIRES_VIEWPORT_AND_RT_ARRAY_INDEX_FROM_ANY_SHADER_FEEDING_RASTERIZER = 8192; + public const uint D3D_SHADER_REQUIRES_WAVE_OPS = 16384; + public const uint D3D_SHADER_REQUIRES_INT64_OPS = 32768; + public const uint D3D_SHADER_REQUIRES_VIEW_ID = 65536; + public const uint D3D_SHADER_REQUIRES_BARYCENTRICS = 131072; + public const uint D3D_SHADER_REQUIRES_NATIVE_16BIT_OPS = 262144; + public const uint D3D_SHADER_REQUIRES_SHADING_RATE = 524288; + public const uint D3D_SHADER_REQUIRES_RAYTRACING_TIER_1_1 = 1048576; + public const uint D3D_SHADER_REQUIRES_SAMPLER_FEEDBACK = 2097152; + public const uint D3D_SHADER_REQUIRES_ATOMIC_INT64_ON_TYPED_RESOURCE = 4194304; + public const uint D3D_SHADER_REQUIRES_ATOMIC_INT64_ON_GROUP_SHARED = 8388608; + public const uint D3D_SHADER_REQUIRES_DERIVATIVES_IN_MESH_AND_AMPLIFICATION_SHADERS = 16777216; + public const uint D3D_SHADER_REQUIRES_RESOURCE_DESCRIPTOR_HEAP_INDEXING = 33554432; + public const uint D3D_SHADER_REQUIRES_SAMPLER_DESCRIPTOR_HEAP_INDEXING = 67108864; + public const uint D3D_SHADER_REQUIRES_WAVE_MMA = 134217728; + public const uint D3D_SHADER_REQUIRES_ATOMIC_INT64_ON_DESCRIPTOR_HEAP_RESOURCE = 268435456; + public static readonly Guid D3D12ExperimentalShaderModels = new Guid(0x76f5573e, 0xf13a, 0x40f5, 0xb2, 0x97, 0x81, 0xce, 0x9e, 0x18, 0x93, 0x3f); + public static readonly Guid D3D12TiledResourceTier4 = new Guid(0xc9c4725f, 0xa81a, 0x4f56, 0x8c, 0x5b, 0xc5, 0x10, 0x39, 0xd6, 0x94, 0xfb); + public static readonly Guid D3D12MetaCommand = new Guid(0xc734c97e, 0x8077, 0x48c8, 0x9f, 0xdc, 0xd9, 0xd1, 0xdd, 0x31, 0xdd, 0x77); +} + +#region Enums +/// +/// D3D12_COMMAND_LIST_TYPE +public enum CommandListType : int +{ + /// + /// D3D12_COMMAND_LIST_TYPE_DIRECT + Direct = 0, + /// + /// D3D12_COMMAND_LIST_TYPE_BUNDLE + Bundle = 1, + /// + /// D3D12_COMMAND_LIST_TYPE_COMPUTE + Compute = 2, + /// + /// D3D12_COMMAND_LIST_TYPE_COPY + Copy = 3, + /// + /// D3D12_COMMAND_LIST_TYPE_VIDEO_DECODE + VideoDecode = 4, + /// + /// D3D12_COMMAND_LIST_TYPE_VIDEO_PROCESS + VideoProcess = 5, + /// + /// D3D12_COMMAND_LIST_TYPE_VIDEO_ENCODE + VideoEncode = 6, +} + +/// +/// D3D12_COMMAND_QUEUE_FLAGS +[Flags] +public enum CommandQueueFlags : uint +{ + None = 0, + /// + /// D3D12_COMMAND_QUEUE_FLAG_NONE + D3D12_COMMAND_QUEUE_FLAG_NONE = 0, + /// + /// D3D12_COMMAND_QUEUE_FLAG_DISABLE_GPU_TIMEOUT + D3D12_COMMAND_QUEUE_FLAG_DISABLE_GPU_TIMEOUT = 1, +} + +/// +/// D3D12_COMMAND_QUEUE_PRIORITY +public enum CommandQueuePriority : int +{ + /// + /// D3D12_COMMAND_QUEUE_PRIORITY_NORMAL + Normal = 0, + /// + /// D3D12_COMMAND_QUEUE_PRIORITY_HIGH + High = 100, + /// + /// D3D12_COMMAND_QUEUE_PRIORITY_GLOBAL_REALTIME + GlobalRealtime = 10000, +} + +/// +/// D3D12_PRIMITIVE_TOPOLOGY_TYPE +public enum PrimitiveTopologyType : int +{ + /// + /// D3D12_PRIMITIVE_TOPOLOGY_TYPE_UNDEFINED + Undefined = 0, + /// + /// D3D12_PRIMITIVE_TOPOLOGY_TYPE_POINT + Point = 1, + /// + /// D3D12_PRIMITIVE_TOPOLOGY_TYPE_LINE + Line = 2, + /// + /// D3D12_PRIMITIVE_TOPOLOGY_TYPE_TRIANGLE + Triangle = 3, + /// + /// D3D12_PRIMITIVE_TOPOLOGY_TYPE_PATCH + Patch = 4, +} + +/// +/// D3D12_INPUT_CLASSIFICATION +public enum InputClassification : int +{ + /// + /// D3D12_INPUT_CLASSIFICATION_PER_VERTEX_DATA + PerVertexData = 0, + /// + /// D3D12_INPUT_CLASSIFICATION_PER_INSTANCE_DATA + PerInstanceData = 1, +} + +/// +/// D3D12_FILL_MODE +public enum FillMode : int +{ + /// + /// D3D12_FILL_MODE_WIREFRAME + Wireframe = 2, + /// + /// D3D12_FILL_MODE_SOLID + Solid = 3, +} + +/// +/// D3D12_CULL_MODE +public enum CullMode : int +{ + /// + /// D3D12_CULL_MODE_NONE + None = 1, + /// + /// D3D12_CULL_MODE_FRONT + Front = 2, + /// + /// D3D12_CULL_MODE_BACK + Back = 3, +} + +/// +/// D3D12_COMPARISON_FUNC +public enum ComparisonFunc : int +{ + /// + /// D3D12_COMPARISON_FUNC_NEVER + Never = 1, + /// + /// D3D12_COMPARISON_FUNC_LESS + Less = 2, + /// + /// D3D12_COMPARISON_FUNC_EQUAL + Equal = 3, + /// + /// D3D12_COMPARISON_FUNC_LESS_EQUAL + LessEqual = 4, + /// + /// D3D12_COMPARISON_FUNC_GREATER + Greater = 5, + /// + /// D3D12_COMPARISON_FUNC_NOT_EQUAL + NotEqual = 6, + /// + /// D3D12_COMPARISON_FUNC_GREATER_EQUAL + GreaterEqual = 7, + /// + /// D3D12_COMPARISON_FUNC_ALWAYS + Always = 8, +} + +/// +/// D3D12_DEPTH_WRITE_MASK +public enum DepthWriteMask : int +{ + /// + /// D3D12_DEPTH_WRITE_MASK_ZERO + Zero = 0, + /// + /// D3D12_DEPTH_WRITE_MASK_ALL + All = 1, +} + +/// +/// D3D12_STENCIL_OP +public enum StencilOp : int +{ + /// + /// D3D12_STENCIL_OP_KEEP + Keep = 1, + /// + /// D3D12_STENCIL_OP_ZERO + Zero = 2, + /// + /// D3D12_STENCIL_OP_REPLACE + Replace = 3, + /// + /// D3D12_STENCIL_OP_INCR_SAT + IncrSat = 4, + /// + /// D3D12_STENCIL_OP_DECR_SAT + DecrSat = 5, + /// + /// D3D12_STENCIL_OP_INVERT + Invert = 6, + /// + /// D3D12_STENCIL_OP_INCR + Incr = 7, + /// + /// D3D12_STENCIL_OP_DECR + Decr = 8, +} + +/// +/// D3D12_BLEND +public enum Blend : int +{ + /// + /// D3D12_BLEND_ZERO + Zero = 1, + /// + /// D3D12_BLEND_ONE + One = 2, + /// + /// D3D12_BLEND_SRC_COLOR + SrcColor = 3, + /// + /// D3D12_BLEND_INV_SRC_COLOR + InvSrcColor = 4, + /// + /// D3D12_BLEND_SRC_ALPHA + SrcAlpha = 5, + /// + /// D3D12_BLEND_INV_SRC_ALPHA + InvSrcAlpha = 6, + /// + /// D3D12_BLEND_DEST_ALPHA + DestAlpha = 7, + /// + /// D3D12_BLEND_INV_DEST_ALPHA + InvDestAlpha = 8, + /// + /// D3D12_BLEND_DEST_COLOR + DestColor = 9, + /// + /// D3D12_BLEND_INV_DEST_COLOR + InvDestColor = 10, + /// + /// D3D12_BLEND_SRC_ALPHA_SAT + SrcAlphaSat = 11, + /// + /// D3D12_BLEND_BLEND_FACTOR + BlendFactor = 14, + /// + /// D3D12_BLEND_INV_BLEND_FACTOR + InvBlendFactor = 15, + /// + /// D3D12_BLEND_SRC1_COLOR + Src1Color = 16, + /// + /// D3D12_BLEND_INV_SRC1_COLOR + InvSrc1Color = 17, + /// + /// D3D12_BLEND_SRC1_ALPHA + Src1Alpha = 18, + /// + /// D3D12_BLEND_INV_SRC1_ALPHA + InvSrc1Alpha = 19, +} + +/// +/// D3D12_BLEND_OP +public enum BlendOp : int +{ + /// + /// D3D12_BLEND_OP_ADD + Add = 1, + /// + /// D3D12_BLEND_OP_SUBTRACT + Subtract = 2, + /// + /// D3D12_BLEND_OP_REV_SUBTRACT + RevSubtract = 3, + /// + /// D3D12_BLEND_OP_MIN + Min = 4, + /// + /// D3D12_BLEND_OP_MAX + Max = 5, +} + +/// +/// D3D12_COLOR_WRITE_ENABLE +public enum ColorWriteEnable : int +{ + /// + /// D3D12_COLOR_WRITE_ENABLE_RED + Red = 1, + /// + /// D3D12_COLOR_WRITE_ENABLE_GREEN + Green = 2, + /// + /// D3D12_COLOR_WRITE_ENABLE_BLUE + Blue = 4, + /// + /// D3D12_COLOR_WRITE_ENABLE_ALPHA + Alpha = 8, + /// + /// D3D12_COLOR_WRITE_ENABLE_ALL + All = 15, +} + +/// +/// D3D12_LOGIC_OP +public enum LogicOp : int +{ + /// + /// D3D12_LOGIC_OP_CLEAR + Clear = 0, + /// + /// D3D12_LOGIC_OP_SET + Set = 1, + /// + /// D3D12_LOGIC_OP_COPY + Copy = 2, + /// + /// D3D12_LOGIC_OP_COPY_INVERTED + CopyInverted = 3, + /// + /// D3D12_LOGIC_OP_NOOP + Noop = 4, + /// + /// D3D12_LOGIC_OP_INVERT + Invert = 5, + /// + /// D3D12_LOGIC_OP_AND + And = 6, + /// + /// D3D12_LOGIC_OP_NAND + Nand = 7, + /// + /// D3D12_LOGIC_OP_OR + Or = 8, + /// + /// D3D12_LOGIC_OP_NOR + Nor = 9, + /// + /// D3D12_LOGIC_OP_XOR + Xor = 10, + /// + /// D3D12_LOGIC_OP_EQUIV + Equiv = 11, + /// + /// D3D12_LOGIC_OP_AND_REVERSE + AndReverse = 12, + /// + /// D3D12_LOGIC_OP_AND_INVERTED + AndInverted = 13, + /// + /// D3D12_LOGIC_OP_OR_REVERSE + OrReverse = 14, + /// + /// D3D12_LOGIC_OP_OR_INVERTED + OrInverted = 15, +} + +/// +/// D3D12_CONSERVATIVE_RASTERIZATION_MODE +public enum ConservativeRasterizationMode : int +{ + /// + /// D3D12_CONSERVATIVE_RASTERIZATION_MODE_OFF + Off = 0, + /// + /// D3D12_CONSERVATIVE_RASTERIZATION_MODE_ON + On = 1, +} + +/// +/// D3D12_INDEX_BUFFER_STRIP_CUT_VALUE +public enum IndexBufferStripCutValue : int +{ + /// + /// D3D12_INDEX_BUFFER_STRIP_CUT_VALUE_DISABLED + Disabled = 0, + /// + /// D3D12_INDEX_BUFFER_STRIP_CUT_VALUE_0xFFFF + _0xffff = 1, + /// + /// D3D12_INDEX_BUFFER_STRIP_CUT_VALUE_0xFFFFFFFF + _0xffffffff = 2, +} + +/// +/// D3D12_PIPELINE_STATE_FLAGS +[Flags] +public enum PipelineStateFlags : uint +{ + None = 0, + /// + /// D3D12_PIPELINE_STATE_FLAG_NONE + D3D12_PIPELINE_STATE_FLAG_NONE = 0, + /// + /// D3D12_PIPELINE_STATE_FLAG_TOOL_DEBUG + D3D12_PIPELINE_STATE_FLAG_TOOL_DEBUG = 1, +} + +/// +/// D3D12_PIPELINE_STATE_SUBOBJECT_TYPE +public enum PipelineStateSubobjectType : int +{ + /// + /// D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_ROOT_SIGNATURE + RootSignature = 0, + /// + /// D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_VS + Vs = 1, + /// + /// D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_PS + Ps = 2, + /// + /// D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_DS + Ds = 3, + /// + /// D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_HS + Hs = 4, + /// + /// D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_GS + Gs = 5, + /// + /// D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_CS + Cs = 6, + /// + /// D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_STREAM_OUTPUT + StreamOutput = 7, + /// + /// D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_BLEND + Blend = 8, + /// + /// D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_SAMPLE_MASK + SampleMask = 9, + /// + /// D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_RASTERIZER + Rasterizer = 10, + /// + /// D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_DEPTH_STENCIL + DepthStencil = 11, + /// + /// D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_INPUT_LAYOUT + InputLayout = 12, + /// + /// D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_IB_STRIP_CUT_VALUE + IbStripCutValue = 13, + /// + /// D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_PRIMITIVE_TOPOLOGY + PrimitiveTopology = 14, + /// + /// D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_RENDER_TARGET_FORMATS + RenderTargetFormats = 15, + /// + /// D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_DEPTH_STENCIL_FORMAT + DepthStencilFormat = 16, + /// + /// D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_SAMPLE_DESC + SampleDesc = 17, + /// + /// D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_NODE_MASK + NodeMask = 18, + /// + /// D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_CACHED_PSO + CachedPso = 19, + /// + /// D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_FLAGS + Flags = 20, + /// + /// D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_DEPTH_STENCIL1 + DepthStencil1 = 21, + /// + /// D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_VIEW_INSTANCING + ViewInstancing = 22, + /// + /// D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_AS + As = 24, + /// + /// D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_MS + Ms = 25, + /// + /// D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_MAX_VALID + MaxValid = 26, +} + +/// +/// D3D12_FEATURE +public enum Feature : int +{ + /// + /// D3D12_FEATURE_D3D12_OPTIONS + Options = 0, + /// + /// D3D12_FEATURE_ARCHITECTURE + Architecture = 1, + /// + /// D3D12_FEATURE_FEATURE_LEVELS + FeatureLevels = 2, + /// + /// D3D12_FEATURE_FORMAT_SUPPORT + FormatSupport = 3, + /// + /// D3D12_FEATURE_MULTISAMPLE_QUALITY_LEVELS + MultisampleQualityLevels = 4, + /// + /// D3D12_FEATURE_FORMAT_INFO + FormatInfo = 5, + /// + /// D3D12_FEATURE_GPU_VIRTUAL_ADDRESS_SUPPORT + GpuVirtualAddressSupport = 6, + /// + /// D3D12_FEATURE_SHADER_MODEL + ShaderModel = 7, + /// + /// D3D12_FEATURE_D3D12_OPTIONS1 + Options1 = 8, + /// + /// D3D12_FEATURE_PROTECTED_RESOURCE_SESSION_SUPPORT + ProtectedResourceSessionSupport = 10, + /// + /// D3D12_FEATURE_ROOT_SIGNATURE + RootSignature = 12, + /// + /// D3D12_FEATURE_ARCHITECTURE1 + Architecture1 = 16, + /// + /// D3D12_FEATURE_D3D12_OPTIONS2 + Options2 = 18, + /// + /// D3D12_FEATURE_SHADER_CACHE + ShaderCache = 19, + /// + /// D3D12_FEATURE_COMMAND_QUEUE_PRIORITY + CommandQueuePriority = 20, + /// + /// D3D12_FEATURE_D3D12_OPTIONS3 + Options3 = 21, + /// + /// D3D12_FEATURE_EXISTING_HEAPS + ExistingHeaps = 22, + /// + /// D3D12_FEATURE_D3D12_OPTIONS4 + Options4 = 23, + /// + /// D3D12_FEATURE_SERIALIZATION + Serialization = 24, + /// + /// D3D12_FEATURE_CROSS_NODE + CrossNode = 25, + /// + /// D3D12_FEATURE_D3D12_OPTIONS5 + Options5 = 27, + /// + /// D3D12_FEATURE_DISPLAYABLE + Displayable = 28, + /// + /// D3D12_FEATURE_D3D12_OPTIONS6 + Options6 = 30, + /// + /// D3D12_FEATURE_QUERY_META_COMMAND + QueryMetaCommand = 31, + /// + /// D3D12_FEATURE_D3D12_OPTIONS7 + Options7 = 32, + /// + /// D3D12_FEATURE_PROTECTED_RESOURCE_SESSION_TYPE_COUNT + ProtectedResourceSessionTypeCount = 33, + /// + /// D3D12_FEATURE_PROTECTED_RESOURCE_SESSION_TYPES + ProtectedResourceSessionTypes = 34, + /// + /// D3D12_FEATURE_D3D12_OPTIONS8 + Options8 = 36, + /// + /// D3D12_FEATURE_D3D12_OPTIONS9 + Options9 = 37, + /// + /// D3D12_FEATURE_D3D12_OPTIONS10 + Options10 = 39, + /// + /// D3D12_FEATURE_D3D12_OPTIONS11 + Options11 = 40, +} + +/// +/// D3D12_SHADER_MIN_PRECISION_SUPPORT +[Flags] +public enum ShaderMinPrecisionSupport : uint +{ + /// + /// D3D12_SHADER_MIN_PRECISION_SUPPORT_NONE + None = 0, + /// + /// D3D12_SHADER_MIN_PRECISION_SUPPORT_10_BIT + _10Bit = 1, + /// + /// D3D12_SHADER_MIN_PRECISION_SUPPORT_16_BIT + _16Bit = 2, +} + +/// +/// D3D12_TILED_RESOURCES_TIER +public enum TiledResourcesTier : int +{ + /// + /// D3D12_TILED_RESOURCES_TIER_NOT_SUPPORTED + NotSupported = 0, + /// + /// D3D12_TILED_RESOURCES_TIER_1 + _1 = 1, + /// + /// D3D12_TILED_RESOURCES_TIER_2 + _2 = 2, + /// + /// D3D12_TILED_RESOURCES_TIER_3 + _3 = 3, + /// + /// D3D12_TILED_RESOURCES_TIER_4 + _4 = 4, +} + +/// +/// D3D12_RESOURCE_BINDING_TIER +public enum ResourceBindingTier : int +{ + /// + /// D3D12_RESOURCE_BINDING_TIER_1 + _1 = 1, + /// + /// D3D12_RESOURCE_BINDING_TIER_2 + _2 = 2, + /// + /// D3D12_RESOURCE_BINDING_TIER_3 + _3 = 3, +} + +/// +/// D3D12_CONSERVATIVE_RASTERIZATION_TIER +public enum ConservativeRasterizationTier : int +{ + /// + /// D3D12_CONSERVATIVE_RASTERIZATION_TIER_NOT_SUPPORTED + NotSupported = 0, + /// + /// D3D12_CONSERVATIVE_RASTERIZATION_TIER_1 + _1 = 1, + /// + /// D3D12_CONSERVATIVE_RASTERIZATION_TIER_2 + _2 = 2, + /// + /// D3D12_CONSERVATIVE_RASTERIZATION_TIER_3 + _3 = 3, +} + +/// +/// D3D12_FORMAT_SUPPORT1 +[Flags] +public enum FormatSupport1 : uint +{ + /// + /// D3D12_FORMAT_SUPPORT1_NONE + None = 0, + /// + /// D3D12_FORMAT_SUPPORT1_BUFFER + Buffer = 1, + /// + /// D3D12_FORMAT_SUPPORT1_IA_VERTEX_BUFFER + IaVertexBuffer = 2, + /// + /// D3D12_FORMAT_SUPPORT1_IA_INDEX_BUFFER + IaIndexBuffer = 4, + /// + /// D3D12_FORMAT_SUPPORT1_SO_BUFFER + SoBuffer = 8, + /// + /// D3D12_FORMAT_SUPPORT1_TEXTURE1D + Texture1D = 16, + /// + /// D3D12_FORMAT_SUPPORT1_TEXTURE2D + Texture2D = 32, + /// + /// D3D12_FORMAT_SUPPORT1_TEXTURE3D + Texture3D = 64, + /// + /// D3D12_FORMAT_SUPPORT1_TEXTURECUBE + TextureCube = 128, + /// + /// D3D12_FORMAT_SUPPORT1_SHADER_LOAD + ShaderLoad = 256, + /// + /// D3D12_FORMAT_SUPPORT1_SHADER_SAMPLE + ShaderSample = 512, + /// + /// D3D12_FORMAT_SUPPORT1_SHADER_SAMPLE_COMPARISON + ShaderSampleComparison = 1024, + /// + /// D3D12_FORMAT_SUPPORT1_SHADER_SAMPLE_MONO_TEXT + ShaderSampleMonoText = 2048, + /// + /// D3D12_FORMAT_SUPPORT1_MIP + Mip = 4096, + /// + /// D3D12_FORMAT_SUPPORT1_RENDER_TARGET + RenderTarget = 16384, + /// + /// D3D12_FORMAT_SUPPORT1_BLENDABLE + Blendable = 32768, + /// + /// D3D12_FORMAT_SUPPORT1_DEPTH_STENCIL + DepthStencil = 65536, + /// + /// D3D12_FORMAT_SUPPORT1_MULTISAMPLE_RESOLVE + MultisampleResolve = 262144, + /// + /// D3D12_FORMAT_SUPPORT1_DISPLAY + Display = 524288, + /// + /// D3D12_FORMAT_SUPPORT1_CAST_WITHIN_BIT_LAYOUT + CastWithinBitLayout = 1048576, + /// + /// D3D12_FORMAT_SUPPORT1_MULTISAMPLE_RENDERTARGET + MultisampleRendertarget = 2097152, + /// + /// D3D12_FORMAT_SUPPORT1_MULTISAMPLE_LOAD + MultisampleLoad = 4194304, + /// + /// D3D12_FORMAT_SUPPORT1_SHADER_GATHER + ShaderGather = 8388608, + /// + /// D3D12_FORMAT_SUPPORT1_BACK_BUFFER_CAST + BackBufferCast = 16777216, + /// + /// D3D12_FORMAT_SUPPORT1_TYPED_UNORDERED_ACCESS_VIEW + TypedUnorderedAccessView = 33554432, + /// + /// D3D12_FORMAT_SUPPORT1_SHADER_GATHER_COMPARISON + ShaderGatherComparison = 67108864, + /// + /// D3D12_FORMAT_SUPPORT1_DECODER_OUTPUT + DecoderOutput = 134217728, + /// + /// D3D12_FORMAT_SUPPORT1_VIDEO_PROCESSOR_OUTPUT + VideoProcessorOutput = 268435456, + /// + /// D3D12_FORMAT_SUPPORT1_VIDEO_PROCESSOR_INPUT + VideoProcessorInput = 536870912, + /// + /// D3D12_FORMAT_SUPPORT1_VIDEO_ENCODER + VideoEncoder = 1073741824, +} + +/// +/// D3D12_FORMAT_SUPPORT2 +[Flags] +public enum FormatSupport2 : uint +{ + /// + /// D3D12_FORMAT_SUPPORT2_NONE + None = 0, + /// + /// D3D12_FORMAT_SUPPORT2_UAV_ATOMIC_ADD + UavAtomicAdd = 1, + /// + /// D3D12_FORMAT_SUPPORT2_UAV_ATOMIC_BITWISE_OPS + UavAtomicBitwiseOps = 2, + /// + /// D3D12_FORMAT_SUPPORT2_UAV_ATOMIC_COMPARE_STORE_OR_COMPARE_EXCHANGE + UavAtomicCompareStoreOrCompareExchange = 4, + /// + /// D3D12_FORMAT_SUPPORT2_UAV_ATOMIC_EXCHANGE + UavAtomicExchange = 8, + /// + /// D3D12_FORMAT_SUPPORT2_UAV_ATOMIC_SIGNED_MIN_OR_MAX + UavAtomicSignedMinOrMax = 16, + /// + /// D3D12_FORMAT_SUPPORT2_UAV_ATOMIC_UNSIGNED_MIN_OR_MAX + UavAtomicUnsignedMinOrMax = 32, + /// + /// D3D12_FORMAT_SUPPORT2_UAV_TYPED_LOAD + UavTypedLoad = 64, + /// + /// D3D12_FORMAT_SUPPORT2_UAV_TYPED_STORE + UavTypedStore = 128, + /// + /// D3D12_FORMAT_SUPPORT2_OUTPUT_MERGER_LOGIC_OP + OutputMergerLogicOp = 256, + /// + /// D3D12_FORMAT_SUPPORT2_TILED + Tiled = 512, + /// + /// D3D12_FORMAT_SUPPORT2_MULTIPLANE_OVERLAY + MultiplaneOverlay = 16384, + /// + /// D3D12_FORMAT_SUPPORT2_SAMPLER_FEEDBACK + SamplerFeedback = 32768, +} + +/// +/// D3D12_MULTISAMPLE_QUALITY_LEVEL_FLAGS +[Flags] +public enum MultisampleQualityLevelFlags : uint +{ + None = 0, + /// + /// D3D12_MULTISAMPLE_QUALITY_LEVELS_FLAG_NONE + D3D12_MULTISAMPLE_QUALITY_LEVELS_FLAG_NONE = 0, + /// + /// D3D12_MULTISAMPLE_QUALITY_LEVELS_FLAG_TILED_RESOURCE + D3D12_MULTISAMPLE_QUALITY_LEVELS_FLAG_TILED_RESOURCE = 1, +} + +/// +/// D3D12_CROSS_NODE_SHARING_TIER +public enum CrossNodeSharingTier : int +{ + /// + /// D3D12_CROSS_NODE_SHARING_TIER_NOT_SUPPORTED + NotSupported = 0, + /// + /// D3D12_CROSS_NODE_SHARING_TIER_1_EMULATED + _1Emulated = 1, + /// + /// D3D12_CROSS_NODE_SHARING_TIER_1 + _1 = 2, + /// + /// D3D12_CROSS_NODE_SHARING_TIER_2 + _2 = 3, + /// + /// D3D12_CROSS_NODE_SHARING_TIER_3 + _3 = 4, +} + +/// +/// D3D12_RESOURCE_HEAP_TIER +public enum ResourceHeapTier : int +{ + /// + /// D3D12_RESOURCE_HEAP_TIER_1 + _1 = 1, + /// + /// D3D12_RESOURCE_HEAP_TIER_2 + _2 = 2, +} + +/// +/// D3D12_PROGRAMMABLE_SAMPLE_POSITIONS_TIER +public enum ProgrammableSamplePositionsTier : int +{ + /// + /// D3D12_PROGRAMMABLE_SAMPLE_POSITIONS_TIER_NOT_SUPPORTED + NotSupported = 0, + /// + /// D3D12_PROGRAMMABLE_SAMPLE_POSITIONS_TIER_1 + _1 = 1, + /// + /// D3D12_PROGRAMMABLE_SAMPLE_POSITIONS_TIER_2 + _2 = 2, +} + +/// +/// D3D12_VIEW_INSTANCING_TIER +public enum ViewInstancingTier : int +{ + /// + /// D3D12_VIEW_INSTANCING_TIER_NOT_SUPPORTED + NotSupported = 0, + /// + /// D3D12_VIEW_INSTANCING_TIER_1 + _1 = 1, + /// + /// D3D12_VIEW_INSTANCING_TIER_2 + _2 = 2, + /// + /// D3D12_VIEW_INSTANCING_TIER_3 + _3 = 3, +} + +/// +/// D3D_ROOT_SIGNATURE_VERSION +public enum RootSignatureVersion : int +{ + /// + /// D3D_ROOT_SIGNATURE_VERSION_1 + _1 = 1, + /// + /// D3D_ROOT_SIGNATURE_VERSION_1_0 + _10 = 1, + /// + /// D3D_ROOT_SIGNATURE_VERSION_1_1 + _11 = 2, +} + +/// +/// D3D_SHADER_MODEL +public enum ShaderModel : int +{ + /// + /// D3D_SHADER_MODEL_5_1 + _51 = 81, + /// + /// D3D_SHADER_MODEL_6_0 + _60 = 96, + /// + /// D3D_SHADER_MODEL_6_1 + _61 = 97, + /// + /// D3D_SHADER_MODEL_6_2 + _62 = 98, + /// + /// D3D_SHADER_MODEL_6_3 + _63 = 99, + /// + /// D3D_SHADER_MODEL_6_4 + _64 = 100, + /// + /// D3D_SHADER_MODEL_6_5 + _65 = 101, + /// + /// D3D_SHADER_MODEL_6_6 + _66 = 102, + /// + /// D3D_SHADER_MODEL_6_7 + _67 = 103, +} + +/// +/// D3D12_SHADER_CACHE_SUPPORT_FLAGS +[Flags] +public enum ShaderCacheSupportFlags : uint +{ + None = 0, + /// + /// D3D12_SHADER_CACHE_SUPPORT_NONE + D3D12_SHADER_CACHE_SUPPORT_NONE = 0, + /// + /// D3D12_SHADER_CACHE_SUPPORT_SINGLE_PSO + D3D12_SHADER_CACHE_SUPPORT_SINGLE_PSO = 1, + /// + /// D3D12_SHADER_CACHE_SUPPORT_LIBRARY + D3D12_SHADER_CACHE_SUPPORT_LIBRARY = 2, + /// + /// D3D12_SHADER_CACHE_SUPPORT_AUTOMATIC_INPROC_CACHE + D3D12_SHADER_CACHE_SUPPORT_AUTOMATIC_INPROC_CACHE = 4, + /// + /// D3D12_SHADER_CACHE_SUPPORT_AUTOMATIC_DISK_CACHE + D3D12_SHADER_CACHE_SUPPORT_AUTOMATIC_DISK_CACHE = 8, + /// + /// D3D12_SHADER_CACHE_SUPPORT_DRIVER_MANAGED_CACHE + D3D12_SHADER_CACHE_SUPPORT_DRIVER_MANAGED_CACHE = 16, + /// + /// D3D12_SHADER_CACHE_SUPPORT_SHADER_CONTROL_CLEAR + D3D12_SHADER_CACHE_SUPPORT_SHADER_CONTROL_CLEAR = 32, + /// + /// D3D12_SHADER_CACHE_SUPPORT_SHADER_SESSION_DELETE + D3D12_SHADER_CACHE_SUPPORT_SHADER_SESSION_DELETE = 64, +} + +/// +/// D3D12_COMMAND_LIST_SUPPORT_FLAGS +[Flags] +public enum CommandListSupportFlags : uint +{ + None = 0, + /// + /// D3D12_COMMAND_LIST_SUPPORT_FLAG_NONE + D3D12_COMMAND_LIST_SUPPORT_FLAG_NONE = 0, + /// + /// D3D12_COMMAND_LIST_SUPPORT_FLAG_DIRECT + D3D12_COMMAND_LIST_SUPPORT_FLAG_DIRECT = 1, + /// + /// D3D12_COMMAND_LIST_SUPPORT_FLAG_BUNDLE + D3D12_COMMAND_LIST_SUPPORT_FLAG_BUNDLE = 2, + /// + /// D3D12_COMMAND_LIST_SUPPORT_FLAG_COMPUTE + D3D12_COMMAND_LIST_SUPPORT_FLAG_COMPUTE = 4, + /// + /// D3D12_COMMAND_LIST_SUPPORT_FLAG_COPY + D3D12_COMMAND_LIST_SUPPORT_FLAG_COPY = 8, + /// + /// D3D12_COMMAND_LIST_SUPPORT_FLAG_VIDEO_DECODE + D3D12_COMMAND_LIST_SUPPORT_FLAG_VIDEO_DECODE = 16, + /// + /// D3D12_COMMAND_LIST_SUPPORT_FLAG_VIDEO_PROCESS + D3D12_COMMAND_LIST_SUPPORT_FLAG_VIDEO_PROCESS = 32, + /// + /// D3D12_COMMAND_LIST_SUPPORT_FLAG_VIDEO_ENCODE + D3D12_COMMAND_LIST_SUPPORT_FLAG_VIDEO_ENCODE = 64, +} + +/// +/// D3D12_SHARED_RESOURCE_COMPATIBILITY_TIER +public enum SharedResourceCompatibilityTier : int +{ + /// + /// D3D12_SHARED_RESOURCE_COMPATIBILITY_TIER_0 + _0 = 0, + /// + /// D3D12_SHARED_RESOURCE_COMPATIBILITY_TIER_1 + _1 = 1, + /// + /// D3D12_SHARED_RESOURCE_COMPATIBILITY_TIER_2 + _2 = 2, +} + +/// +/// D3D12_HEAP_SERIALIZATION_TIER +public enum HeapSerializationTier : int +{ + /// + /// D3D12_HEAP_SERIALIZATION_TIER_0 + _0 = 0, + /// + /// D3D12_HEAP_SERIALIZATION_TIER_10 + _10 = 10, +} + +/// +/// D3D12_RENDER_PASS_TIER +public enum RenderPassTier : int +{ + /// + /// D3D12_RENDER_PASS_TIER_0 + _0 = 0, + /// + /// D3D12_RENDER_PASS_TIER_1 + _1 = 1, + /// + /// D3D12_RENDER_PASS_TIER_2 + _2 = 2, +} + +/// +/// D3D12_RAYTRACING_TIER +public enum RaytracingTier : int +{ + /// + /// D3D12_RAYTRACING_TIER_NOT_SUPPORTED + NotSupported = 0, + /// + /// D3D12_RAYTRACING_TIER_1_0 + _10 = 10, + /// + /// D3D12_RAYTRACING_TIER_1_1 + _11 = 11, +} + +/// +/// D3D12_VARIABLE_SHADING_RATE_TIER +public enum VariableShadingRateTier : int +{ + /// + /// D3D12_VARIABLE_SHADING_RATE_TIER_NOT_SUPPORTED + NotSupported = 0, + /// + /// D3D12_VARIABLE_SHADING_RATE_TIER_1 + _1 = 1, + /// + /// D3D12_VARIABLE_SHADING_RATE_TIER_2 + _2 = 2, +} + +/// +/// D3D12_MESH_SHADER_TIER +public enum MeshShaderTier : int +{ + /// + /// D3D12_MESH_SHADER_TIER_NOT_SUPPORTED + NotSupported = 0, + /// + /// D3D12_MESH_SHADER_TIER_1 + _1 = 10, +} + +/// +/// D3D12_SAMPLER_FEEDBACK_TIER +public enum SamplerFeedbackTier : int +{ + /// + /// D3D12_SAMPLER_FEEDBACK_TIER_NOT_SUPPORTED + NotSupported = 0, + /// + /// D3D12_SAMPLER_FEEDBACK_TIER_0_9 + _09 = 90, + /// + /// D3D12_SAMPLER_FEEDBACK_TIER_1_0 + _10 = 100, +} + +/// +/// D3D12_WAVE_MMA_TIER +public enum WaveMmaTier : int +{ + /// + /// D3D12_WAVE_MMA_TIER_NOT_SUPPORTED + NotSupported = 0, + /// + /// D3D12_WAVE_MMA_TIER_1_0 + _10 = 10, +} + +/// +/// D3D12_HEAP_TYPE +public enum HeapType : int +{ + /// + /// D3D12_HEAP_TYPE_DEFAULT + Default = 1, + /// + /// D3D12_HEAP_TYPE_UPLOAD + Upload = 2, + /// + /// D3D12_HEAP_TYPE_READBACK + Readback = 3, + /// + /// D3D12_HEAP_TYPE_CUSTOM + Custom = 4, +} + +/// +/// D3D12_CPU_PAGE_PROPERTY +public enum CpuPageProperty : int +{ + /// + /// D3D12_CPU_PAGE_PROPERTY_UNKNOWN + Unknown = 0, + /// + /// D3D12_CPU_PAGE_PROPERTY_NOT_AVAILABLE + NotAvailable = 1, + /// + /// D3D12_CPU_PAGE_PROPERTY_WRITE_COMBINE + WriteCombine = 2, + /// + /// D3D12_CPU_PAGE_PROPERTY_WRITE_BACK + WriteBack = 3, +} + +/// +/// D3D12_MEMORY_POOL +public enum MemoryPool : int +{ + /// + /// D3D12_MEMORY_POOL_UNKNOWN + Unknown = 0, + /// + /// D3D12_MEMORY_POOL_L0 + L0 = 1, + /// + /// D3D12_MEMORY_POOL_L1 + L1 = 2, +} + +/// +/// D3D12_HEAP_FLAGS +[Flags] +public enum HeapFlags : uint +{ + None = 0, + /// + /// D3D12_HEAP_FLAG_NONE + D3D12_HEAP_FLAG_NONE = 0, + /// + /// D3D12_HEAP_FLAG_SHARED + D3D12_HEAP_FLAG_SHARED = 1, + /// + /// D3D12_HEAP_FLAG_DENY_BUFFERS + D3D12_HEAP_FLAG_DENY_BUFFERS = 4, + /// + /// D3D12_HEAP_FLAG_ALLOW_DISPLAY + D3D12_HEAP_FLAG_ALLOW_DISPLAY = 8, + /// + /// D3D12_HEAP_FLAG_SHARED_CROSS_ADAPTER + D3D12_HEAP_FLAG_SHARED_CROSS_ADAPTER = 32, + /// + /// D3D12_HEAP_FLAG_DENY_RT_DS_TEXTURES + D3D12_HEAP_FLAG_DENY_RT_DS_TEXTURES = 64, + /// + /// D3D12_HEAP_FLAG_DENY_NON_RT_DS_TEXTURES + D3D12_HEAP_FLAG_DENY_NON_RT_DS_TEXTURES = 128, + /// + /// D3D12_HEAP_FLAG_HARDWARE_PROTECTED + D3D12_HEAP_FLAG_HARDWARE_PROTECTED = 256, + /// + /// D3D12_HEAP_FLAG_ALLOW_WRITE_WATCH + D3D12_HEAP_FLAG_ALLOW_WRITE_WATCH = 512, + /// + /// D3D12_HEAP_FLAG_ALLOW_SHADER_ATOMICS + D3D12_HEAP_FLAG_ALLOW_SHADER_ATOMICS = 1024, + /// + /// D3D12_HEAP_FLAG_CREATE_NOT_RESIDENT + D3D12_HEAP_FLAG_CREATE_NOT_RESIDENT = 2048, + /// + /// D3D12_HEAP_FLAG_CREATE_NOT_ZEROED + D3D12_HEAP_FLAG_CREATE_NOT_ZEROED = 4096, + /// + /// D3D12_HEAP_FLAG_ALLOW_ALL_BUFFERS_AND_TEXTURES + D3D12_HEAP_FLAG_ALLOW_ALL_BUFFERS_AND_TEXTURES = 0, + /// + /// D3D12_HEAP_FLAG_ALLOW_ONLY_BUFFERS + D3D12_HEAP_FLAG_ALLOW_ONLY_BUFFERS = 192, + /// + /// D3D12_HEAP_FLAG_ALLOW_ONLY_NON_RT_DS_TEXTURES + D3D12_HEAP_FLAG_ALLOW_ONLY_NON_RT_DS_TEXTURES = 68, + /// + /// D3D12_HEAP_FLAG_ALLOW_ONLY_RT_DS_TEXTURES + D3D12_HEAP_FLAG_ALLOW_ONLY_RT_DS_TEXTURES = 132, +} + +/// +/// D3D12_RESOURCE_DIMENSION +public enum ResourceDimension : int +{ + /// + /// D3D12_RESOURCE_DIMENSION_UNKNOWN + Unknown = 0, + /// + /// D3D12_RESOURCE_DIMENSION_BUFFER + Buffer = 1, + /// + /// D3D12_RESOURCE_DIMENSION_TEXTURE1D + Texture1D = 2, + /// + /// D3D12_RESOURCE_DIMENSION_TEXTURE2D + Texture2D = 3, + /// + /// D3D12_RESOURCE_DIMENSION_TEXTURE3D + Texture3D = 4, +} + +/// +/// D3D12_TEXTURE_LAYOUT +public enum TextureLayout : int +{ + /// + /// D3D12_TEXTURE_LAYOUT_UNKNOWN + Unknown = 0, + /// + /// D3D12_TEXTURE_LAYOUT_ROW_MAJOR + RowMajor = 1, + /// + /// D3D12_TEXTURE_LAYOUT_64KB_UNDEFINED_SWIZZLE + _64kbUndefinedSwizzle = 2, + /// + /// D3D12_TEXTURE_LAYOUT_64KB_STANDARD_SWIZZLE + _64kbStandardSwizzle = 3, +} + +/// +/// D3D12_RESOURCE_FLAGS +[Flags] +public enum ResourceFlags : uint +{ + None = 0, + /// + /// D3D12_RESOURCE_FLAG_NONE + D3D12_RESOURCE_FLAG_NONE = 0, + /// + /// D3D12_RESOURCE_FLAG_ALLOW_RENDER_TARGET + D3D12_RESOURCE_FLAG_ALLOW_RENDER_TARGET = 1, + /// + /// D3D12_RESOURCE_FLAG_ALLOW_DEPTH_STENCIL + D3D12_RESOURCE_FLAG_ALLOW_DEPTH_STENCIL = 2, + /// + /// D3D12_RESOURCE_FLAG_ALLOW_UNORDERED_ACCESS + D3D12_RESOURCE_FLAG_ALLOW_UNORDERED_ACCESS = 4, + /// + /// D3D12_RESOURCE_FLAG_DENY_SHADER_RESOURCE + D3D12_RESOURCE_FLAG_DENY_SHADER_RESOURCE = 8, + /// + /// D3D12_RESOURCE_FLAG_ALLOW_CROSS_ADAPTER + D3D12_RESOURCE_FLAG_ALLOW_CROSS_ADAPTER = 16, + /// + /// D3D12_RESOURCE_FLAG_ALLOW_SIMULTANEOUS_ACCESS + D3D12_RESOURCE_FLAG_ALLOW_SIMULTANEOUS_ACCESS = 32, + /// + /// D3D12_RESOURCE_FLAG_VIDEO_DECODE_REFERENCE_ONLY + D3D12_RESOURCE_FLAG_VIDEO_DECODE_REFERENCE_ONLY = 64, + /// + /// D3D12_RESOURCE_FLAG_VIDEO_ENCODE_REFERENCE_ONLY + D3D12_RESOURCE_FLAG_VIDEO_ENCODE_REFERENCE_ONLY = 128, +} + +/// +/// D3D12_TILE_RANGE_FLAGS +[Flags] +public enum TileRangeFlags : int +{ + None = 0, + /// + /// D3D12_TILE_RANGE_FLAG_NONE + D3D12_TILE_RANGE_FLAG_NONE = 0, + /// + /// D3D12_TILE_RANGE_FLAG_NULL + D3D12_TILE_RANGE_FLAG_NULL = 1, + /// + /// D3D12_TILE_RANGE_FLAG_SKIP + D3D12_TILE_RANGE_FLAG_SKIP = 2, + /// + /// D3D12_TILE_RANGE_FLAG_REUSE_SINGLE_TILE + D3D12_TILE_RANGE_FLAG_REUSE_SINGLE_TILE = 4, +} + +/// +/// D3D12_TILE_MAPPING_FLAGS +[Flags] +public enum TileMappingFlags : uint +{ + None = 0, + /// + /// D3D12_TILE_MAPPING_FLAG_NONE + D3D12_TILE_MAPPING_FLAG_NONE = 0, + /// + /// D3D12_TILE_MAPPING_FLAG_NO_HAZARD + D3D12_TILE_MAPPING_FLAG_NO_HAZARD = 1, +} + +/// +/// D3D12_TILE_COPY_FLAGS +[Flags] +public enum TileCopyFlags : uint +{ + None = 0, + /// + /// D3D12_TILE_COPY_FLAG_NONE + D3D12_TILE_COPY_FLAG_NONE = 0, + /// + /// D3D12_TILE_COPY_FLAG_NO_HAZARD + D3D12_TILE_COPY_FLAG_NO_HAZARD = 1, + /// + /// D3D12_TILE_COPY_FLAG_LINEAR_BUFFER_TO_SWIZZLED_TILED_RESOURCE + D3D12_TILE_COPY_FLAG_LINEAR_BUFFER_TO_SWIZZLED_TILED_RESOURCE = 2, + /// + /// D3D12_TILE_COPY_FLAG_SWIZZLED_TILED_RESOURCE_TO_LINEAR_BUFFER + D3D12_TILE_COPY_FLAG_SWIZZLED_TILED_RESOURCE_TO_LINEAR_BUFFER = 4, +} + +/// +/// D3D12_RESOURCE_STATES +[Flags] +public enum ResourceStates : uint +{ + None = 0, + /// + /// D3D12_RESOURCE_STATE_COMMON + D3D12_RESOURCE_STATE_COMMON = 0, + /// + /// D3D12_RESOURCE_STATE_VERTEX_AND_CONSTANT_BUFFER + D3D12_RESOURCE_STATE_VERTEX_AND_CONSTANT_BUFFER = 1, + /// + /// D3D12_RESOURCE_STATE_INDEX_BUFFER + D3D12_RESOURCE_STATE_INDEX_BUFFER = 2, + /// + /// D3D12_RESOURCE_STATE_RENDER_TARGET + D3D12_RESOURCE_STATE_RENDER_TARGET = 4, + /// + /// D3D12_RESOURCE_STATE_UNORDERED_ACCESS + D3D12_RESOURCE_STATE_UNORDERED_ACCESS = 8, + /// + /// D3D12_RESOURCE_STATE_DEPTH_WRITE + D3D12_RESOURCE_STATE_DEPTH_WRITE = 16, + /// + /// D3D12_RESOURCE_STATE_DEPTH_READ + D3D12_RESOURCE_STATE_DEPTH_READ = 32, + /// + /// D3D12_RESOURCE_STATE_NON_PIXEL_SHADER_RESOURCE + D3D12_RESOURCE_STATE_NON_PIXEL_SHADER_RESOURCE = 64, + /// + /// D3D12_RESOURCE_STATE_PIXEL_SHADER_RESOURCE + D3D12_RESOURCE_STATE_PIXEL_SHADER_RESOURCE = 128, + /// + /// D3D12_RESOURCE_STATE_STREAM_OUT + D3D12_RESOURCE_STATE_STREAM_OUT = 256, + /// + /// D3D12_RESOURCE_STATE_INDIRECT_ARGUMENT + D3D12_RESOURCE_STATE_INDIRECT_ARGUMENT = 512, + /// + /// D3D12_RESOURCE_STATE_COPY_DEST + D3D12_RESOURCE_STATE_COPY_DEST = 1024, + /// + /// D3D12_RESOURCE_STATE_COPY_SOURCE + D3D12_RESOURCE_STATE_COPY_SOURCE = 2048, + /// + /// D3D12_RESOURCE_STATE_RESOLVE_DEST + D3D12_RESOURCE_STATE_RESOLVE_DEST = 4096, + /// + /// D3D12_RESOURCE_STATE_RESOLVE_SOURCE + D3D12_RESOURCE_STATE_RESOLVE_SOURCE = 8192, + /// + /// D3D12_RESOURCE_STATE_RAYTRACING_ACCELERATION_STRUCTURE + D3D12_RESOURCE_STATE_RAYTRACING_ACCELERATION_STRUCTURE = 4194304, + /// + /// D3D12_RESOURCE_STATE_SHADING_RATE_SOURCE + D3D12_RESOURCE_STATE_SHADING_RATE_SOURCE = 16777216, + /// + /// D3D12_RESOURCE_STATE_GENERIC_READ + D3D12_RESOURCE_STATE_GENERIC_READ = 2755, + /// + /// D3D12_RESOURCE_STATE_ALL_SHADER_RESOURCE + D3D12_RESOURCE_STATE_ALL_SHADER_RESOURCE = 192, + /// + /// D3D12_RESOURCE_STATE_PRESENT + D3D12_RESOURCE_STATE_PRESENT = 0, + /// + /// D3D12_RESOURCE_STATE_PREDICATION + D3D12_RESOURCE_STATE_PREDICATION = 512, + /// + /// D3D12_RESOURCE_STATE_VIDEO_DECODE_READ + D3D12_RESOURCE_STATE_VIDEO_DECODE_READ = 65536, + /// + /// D3D12_RESOURCE_STATE_VIDEO_DECODE_WRITE + D3D12_RESOURCE_STATE_VIDEO_DECODE_WRITE = 131072, + /// + /// D3D12_RESOURCE_STATE_VIDEO_PROCESS_READ + D3D12_RESOURCE_STATE_VIDEO_PROCESS_READ = 262144, + /// + /// D3D12_RESOURCE_STATE_VIDEO_PROCESS_WRITE + D3D12_RESOURCE_STATE_VIDEO_PROCESS_WRITE = 524288, + /// + /// D3D12_RESOURCE_STATE_VIDEO_ENCODE_READ + D3D12_RESOURCE_STATE_VIDEO_ENCODE_READ = 2097152, + /// + /// D3D12_RESOURCE_STATE_VIDEO_ENCODE_WRITE + D3D12_RESOURCE_STATE_VIDEO_ENCODE_WRITE = 8388608, +} + +/// +/// D3D12_RESOURCE_BARRIER_TYPE +public enum ResourceBarrierType : int +{ + /// + /// D3D12_RESOURCE_BARRIER_TYPE_TRANSITION + Transition = 0, + /// + /// D3D12_RESOURCE_BARRIER_TYPE_ALIASING + Aliasing = 1, + /// + /// D3D12_RESOURCE_BARRIER_TYPE_UAV + Uav = 2, +} + +/// +/// D3D12_RESOURCE_BARRIER_FLAGS +[Flags] +public enum ResourceBarrierFlags : uint +{ + None = 0, + /// + /// D3D12_RESOURCE_BARRIER_FLAG_NONE + D3D12_RESOURCE_BARRIER_FLAG_NONE = 0, + /// + /// D3D12_RESOURCE_BARRIER_FLAG_BEGIN_ONLY + D3D12_RESOURCE_BARRIER_FLAG_BEGIN_ONLY = 1, + /// + /// D3D12_RESOURCE_BARRIER_FLAG_END_ONLY + D3D12_RESOURCE_BARRIER_FLAG_END_ONLY = 2, +} + +/// +/// D3D12_TEXTURE_COPY_TYPE +public enum TextureCopyType : int +{ + /// + /// D3D12_TEXTURE_COPY_TYPE_SUBRESOURCE_INDEX + SubresourceIndex = 0, + /// + /// D3D12_TEXTURE_COPY_TYPE_PLACED_FOOTPRINT + PlacedFootprint = 1, +} + +/// +/// D3D12_RESOLVE_MODE +public enum ResolveMode : int +{ + /// + /// D3D12_RESOLVE_MODE_DECOMPRESS + Decompress = 0, + /// + /// D3D12_RESOLVE_MODE_MIN + Min = 1, + /// + /// D3D12_RESOLVE_MODE_MAX + Max = 2, + /// + /// D3D12_RESOLVE_MODE_AVERAGE + Average = 3, + /// + /// D3D12_RESOLVE_MODE_ENCODE_SAMPLER_FEEDBACK + EncodeSamplerFeedback = 4, + /// + /// D3D12_RESOLVE_MODE_DECODE_SAMPLER_FEEDBACK + DecodeSamplerFeedback = 5, +} + +/// +/// D3D12_VIEW_INSTANCING_FLAGS +[Flags] +public enum ViewInstancingFlags : uint +{ + None = 0, + /// + /// D3D12_VIEW_INSTANCING_FLAG_NONE + D3D12_VIEW_INSTANCING_FLAG_NONE = 0, + /// + /// D3D12_VIEW_INSTANCING_FLAG_ENABLE_VIEW_INSTANCE_MASKING + D3D12_VIEW_INSTANCING_FLAG_ENABLE_VIEW_INSTANCE_MASKING = 1, +} + +/// +/// D3D12_SHADER_COMPONENT_MAPPING +public enum ShaderComponentMapping : int +{ + /// + /// D3D12_SHADER_COMPONENT_MAPPING_FROM_MEMORY_COMPONENT_0 + FromMemoryComponent0 = 0, + /// + /// D3D12_SHADER_COMPONENT_MAPPING_FROM_MEMORY_COMPONENT_1 + FromMemoryComponent1 = 1, + /// + /// D3D12_SHADER_COMPONENT_MAPPING_FROM_MEMORY_COMPONENT_2 + FromMemoryComponent2 = 2, + /// + /// D3D12_SHADER_COMPONENT_MAPPING_FROM_MEMORY_COMPONENT_3 + FromMemoryComponent3 = 3, + /// + /// D3D12_SHADER_COMPONENT_MAPPING_FORCE_VALUE_0 + ForceValue0 = 4, + /// + /// D3D12_SHADER_COMPONENT_MAPPING_FORCE_VALUE_1 + ForceValue1 = 5, +} + +/// +/// D3D12_BUFFER_SRV_FLAGS +[Flags] +public enum BufferSrvFlags : uint +{ + None = 0, + /// + /// D3D12_BUFFER_SRV_FLAG_NONE + D3D12_BUFFER_SRV_FLAG_NONE = 0, + /// + /// D3D12_BUFFER_SRV_FLAG_RAW + D3D12_BUFFER_SRV_FLAG_RAW = 1, +} + +/// +/// D3D12_SRV_DIMENSION +public enum SrvDimension : int +{ + /// + /// D3D12_SRV_DIMENSION_UNKNOWN + Unknown = 0, + /// + /// D3D12_SRV_DIMENSION_BUFFER + Buffer = 1, + /// + /// D3D12_SRV_DIMENSION_TEXTURE1D + Texture1D = 2, + /// + /// D3D12_SRV_DIMENSION_TEXTURE1DARRAY + Texture1DArray = 3, + /// + /// D3D12_SRV_DIMENSION_TEXTURE2D + Texture2D = 4, + /// + /// D3D12_SRV_DIMENSION_TEXTURE2DARRAY + Texture2DArray = 5, + /// + /// D3D12_SRV_DIMENSION_TEXTURE2DMS + Texture2DMs = 6, + /// + /// D3D12_SRV_DIMENSION_TEXTURE2DMSARRAY + Texture2DMsArray = 7, + /// + /// D3D12_SRV_DIMENSION_TEXTURE3D + Texture3D = 8, + /// + /// D3D12_SRV_DIMENSION_TEXTURECUBE + TextureCube = 9, + /// + /// D3D12_SRV_DIMENSION_TEXTURECUBEARRAY + TextureCubeArray = 10, + /// + /// D3D12_SRV_DIMENSION_RAYTRACING_ACCELERATION_STRUCTURE + RaytracingAccelerationStructure = 11, +} + +/// +/// D3D12_FILTER +public enum Filter : int +{ + /// + /// D3D12_FILTER_MIN_MAG_MIP_POINT + MinMagMipPoint = 0, + /// + /// D3D12_FILTER_MIN_MAG_POINT_MIP_LINEAR + MinMagPointMipLinear = 1, + /// + /// D3D12_FILTER_MIN_POINT_MAG_LINEAR_MIP_POINT + MinPointMagLinearMipPoint = 4, + /// + /// D3D12_FILTER_MIN_POINT_MAG_MIP_LINEAR + MinPointMagMipLinear = 5, + /// + /// D3D12_FILTER_MIN_LINEAR_MAG_MIP_POINT + MinLinearMagMipPoint = 16, + /// + /// D3D12_FILTER_MIN_LINEAR_MAG_POINT_MIP_LINEAR + MinLinearMagPointMipLinear = 17, + /// + /// D3D12_FILTER_MIN_MAG_LINEAR_MIP_POINT + MinMagLinearMipPoint = 20, + /// + /// D3D12_FILTER_MIN_MAG_MIP_LINEAR + MinMagMipLinear = 21, + /// + /// D3D12_FILTER_ANISOTROPIC + Anisotropic = 85, + /// + /// D3D12_FILTER_COMPARISON_MIN_MAG_MIP_POINT + ComparisonMinMagMipPoint = 128, + /// + /// D3D12_FILTER_COMPARISON_MIN_MAG_POINT_MIP_LINEAR + ComparisonMinMagPointMipLinear = 129, + /// + /// D3D12_FILTER_COMPARISON_MIN_POINT_MAG_LINEAR_MIP_POINT + ComparisonMinPointMagLinearMipPoint = 132, + /// + /// D3D12_FILTER_COMPARISON_MIN_POINT_MAG_MIP_LINEAR + ComparisonMinPointMagMipLinear = 133, + /// + /// D3D12_FILTER_COMPARISON_MIN_LINEAR_MAG_MIP_POINT + ComparisonMinLinearMagMipPoint = 144, + /// + /// D3D12_FILTER_COMPARISON_MIN_LINEAR_MAG_POINT_MIP_LINEAR + ComparisonMinLinearMagPointMipLinear = 145, + /// + /// D3D12_FILTER_COMPARISON_MIN_MAG_LINEAR_MIP_POINT + ComparisonMinMagLinearMipPoint = 148, + /// + /// D3D12_FILTER_COMPARISON_MIN_MAG_MIP_LINEAR + ComparisonMinMagMipLinear = 149, + /// + /// D3D12_FILTER_COMPARISON_ANISOTROPIC + ComparisonAnisotropic = 213, + /// + /// D3D12_FILTER_MINIMUM_MIN_MAG_MIP_POINT + MinimumMinMagMipPoint = 256, + /// + /// D3D12_FILTER_MINIMUM_MIN_MAG_POINT_MIP_LINEAR + MinimumMinMagPointMipLinear = 257, + /// + /// D3D12_FILTER_MINIMUM_MIN_POINT_MAG_LINEAR_MIP_POINT + MinimumMinPointMagLinearMipPoint = 260, + /// + /// D3D12_FILTER_MINIMUM_MIN_POINT_MAG_MIP_LINEAR + MinimumMinPointMagMipLinear = 261, + /// + /// D3D12_FILTER_MINIMUM_MIN_LINEAR_MAG_MIP_POINT + MinimumMinLinearMagMipPoint = 272, + /// + /// D3D12_FILTER_MINIMUM_MIN_LINEAR_MAG_POINT_MIP_LINEAR + MinimumMinLinearMagPointMipLinear = 273, + /// + /// D3D12_FILTER_MINIMUM_MIN_MAG_LINEAR_MIP_POINT + MinimumMinMagLinearMipPoint = 276, + /// + /// D3D12_FILTER_MINIMUM_MIN_MAG_MIP_LINEAR + MinimumMinMagMipLinear = 277, + /// + /// D3D12_FILTER_MINIMUM_ANISOTROPIC + MinimumAnisotropic = 341, + /// + /// D3D12_FILTER_MAXIMUM_MIN_MAG_MIP_POINT + MaximumMinMagMipPoint = 384, + /// + /// D3D12_FILTER_MAXIMUM_MIN_MAG_POINT_MIP_LINEAR + MaximumMinMagPointMipLinear = 385, + /// + /// D3D12_FILTER_MAXIMUM_MIN_POINT_MAG_LINEAR_MIP_POINT + MaximumMinPointMagLinearMipPoint = 388, + /// + /// D3D12_FILTER_MAXIMUM_MIN_POINT_MAG_MIP_LINEAR + MaximumMinPointMagMipLinear = 389, + /// + /// D3D12_FILTER_MAXIMUM_MIN_LINEAR_MAG_MIP_POINT + MaximumMinLinearMagMipPoint = 400, + /// + /// D3D12_FILTER_MAXIMUM_MIN_LINEAR_MAG_POINT_MIP_LINEAR + MaximumMinLinearMagPointMipLinear = 401, + /// + /// D3D12_FILTER_MAXIMUM_MIN_MAG_LINEAR_MIP_POINT + MaximumMinMagLinearMipPoint = 404, + /// + /// D3D12_FILTER_MAXIMUM_MIN_MAG_MIP_LINEAR + MaximumMinMagMipLinear = 405, + /// + /// D3D12_FILTER_MAXIMUM_ANISOTROPIC + MaximumAnisotropic = 469, +} + +/// +/// D3D12_FILTER_TYPE +public enum FilterType : int +{ + /// + /// D3D12_FILTER_TYPE_POINT + Point = 0, + /// + /// D3D12_FILTER_TYPE_LINEAR + Linear = 1, +} + +/// +/// D3D12_FILTER_REDUCTION_TYPE +public enum FilterReductionType : int +{ + /// + /// D3D12_FILTER_REDUCTION_TYPE_STANDARD + Standard = 0, + /// + /// D3D12_FILTER_REDUCTION_TYPE_COMPARISON + Comparison = 1, + /// + /// D3D12_FILTER_REDUCTION_TYPE_MINIMUM + Minimum = 2, + /// + /// D3D12_FILTER_REDUCTION_TYPE_MAXIMUM + Maximum = 3, +} + +/// +/// D3D12_TEXTURE_ADDRESS_MODE +public enum TextureAddressMode : int +{ + /// + /// D3D12_TEXTURE_ADDRESS_MODE_WRAP + Wrap = 1, + /// + /// D3D12_TEXTURE_ADDRESS_MODE_MIRROR + Mirror = 2, + /// + /// D3D12_TEXTURE_ADDRESS_MODE_CLAMP + Clamp = 3, + /// + /// D3D12_TEXTURE_ADDRESS_MODE_BORDER + Border = 4, + /// + /// D3D12_TEXTURE_ADDRESS_MODE_MIRROR_ONCE + MirrorOnce = 5, +} + +/// +/// D3D12_BUFFER_UAV_FLAGS +[Flags] +public enum BufferUavFlags : uint +{ + None = 0, + /// + /// D3D12_BUFFER_UAV_FLAG_NONE + D3D12_BUFFER_UAV_FLAG_NONE = 0, + /// + /// D3D12_BUFFER_UAV_FLAG_RAW + D3D12_BUFFER_UAV_FLAG_RAW = 1, +} + +/// +/// D3D12_UAV_DIMENSION +public enum UavDimension : int +{ + /// + /// D3D12_UAV_DIMENSION_UNKNOWN + Unknown = 0, + /// + /// D3D12_UAV_DIMENSION_BUFFER + Buffer = 1, + /// + /// D3D12_UAV_DIMENSION_TEXTURE1D + Texture1D = 2, + /// + /// D3D12_UAV_DIMENSION_TEXTURE1DARRAY + Texture1DArray = 3, + /// + /// D3D12_UAV_DIMENSION_TEXTURE2D + Texture2D = 4, + /// + /// D3D12_UAV_DIMENSION_TEXTURE2DARRAY + Texture2DArray = 5, + /// + /// D3D12_UAV_DIMENSION_TEXTURE3D + Texture3D = 8, +} + +/// +/// D3D12_RTV_DIMENSION +public enum RtvDimension : int +{ + /// + /// D3D12_RTV_DIMENSION_UNKNOWN + Unknown = 0, + /// + /// D3D12_RTV_DIMENSION_BUFFER + Buffer = 1, + /// + /// D3D12_RTV_DIMENSION_TEXTURE1D + Texture1D = 2, + /// + /// D3D12_RTV_DIMENSION_TEXTURE1DARRAY + Texture1DArray = 3, + /// + /// D3D12_RTV_DIMENSION_TEXTURE2D + Texture2D = 4, + /// + /// D3D12_RTV_DIMENSION_TEXTURE2DARRAY + Texture2DArray = 5, + /// + /// D3D12_RTV_DIMENSION_TEXTURE2DMS + Texture2DMs = 6, + /// + /// D3D12_RTV_DIMENSION_TEXTURE2DMSARRAY + Texture2DMsArray = 7, + /// + /// D3D12_RTV_DIMENSION_TEXTURE3D + Texture3D = 8, +} + +/// +/// D3D12_DSV_FLAGS +[Flags] +public enum DsvFlags : uint +{ + None = 0, + /// + /// D3D12_DSV_FLAG_NONE + D3D12_DSV_FLAG_NONE = 0, + /// + /// D3D12_DSV_FLAG_READ_ONLY_DEPTH + D3D12_DSV_FLAG_READ_ONLY_DEPTH = 1, + /// + /// D3D12_DSV_FLAG_READ_ONLY_STENCIL + D3D12_DSV_FLAG_READ_ONLY_STENCIL = 2, +} + +/// +/// D3D12_DSV_DIMENSION +public enum DsvDimension : int +{ + /// + /// D3D12_DSV_DIMENSION_UNKNOWN + Unknown = 0, + /// + /// D3D12_DSV_DIMENSION_TEXTURE1D + Texture1D = 1, + /// + /// D3D12_DSV_DIMENSION_TEXTURE1DARRAY + Texture1DArray = 2, + /// + /// D3D12_DSV_DIMENSION_TEXTURE2D + Texture2D = 3, + /// + /// D3D12_DSV_DIMENSION_TEXTURE2DARRAY + Texture2DArray = 4, + /// + /// D3D12_DSV_DIMENSION_TEXTURE2DMS + Texture2DMs = 5, + /// + /// D3D12_DSV_DIMENSION_TEXTURE2DMSARRAY + Texture2DMsArray = 6, +} + +/// +/// D3D12_CLEAR_FLAGS +[Flags] +public enum ClearFlags : uint +{ + None = 0, + /// + /// D3D12_CLEAR_FLAG_DEPTH + D3D12_CLEAR_FLAG_DEPTH = 1, + /// + /// D3D12_CLEAR_FLAG_STENCIL + D3D12_CLEAR_FLAG_STENCIL = 2, +} + +/// +/// D3D12_FENCE_FLAGS +[Flags] +public enum FenceFlags : uint +{ + None = 0, + /// + /// D3D12_FENCE_FLAG_NONE + D3D12_FENCE_FLAG_NONE = 0, + /// + /// D3D12_FENCE_FLAG_SHARED + D3D12_FENCE_FLAG_SHARED = 1, + /// + /// D3D12_FENCE_FLAG_SHARED_CROSS_ADAPTER + D3D12_FENCE_FLAG_SHARED_CROSS_ADAPTER = 2, + /// + /// D3D12_FENCE_FLAG_NON_MONITORED + D3D12_FENCE_FLAG_NON_MONITORED = 4, +} + +/// +/// D3D12_DESCRIPTOR_HEAP_TYPE +public enum DescriptorHeapType : int +{ + /// + /// D3D12_DESCRIPTOR_HEAP_TYPE_CBV_SRV_UAV + CbvSrvUav = 0, + /// + /// D3D12_DESCRIPTOR_HEAP_TYPE_SAMPLER + Sampler = 1, + /// + /// D3D12_DESCRIPTOR_HEAP_TYPE_RTV + Rtv = 2, + /// + /// D3D12_DESCRIPTOR_HEAP_TYPE_DSV + Dsv = 3, + /// + /// D3D12_DESCRIPTOR_HEAP_TYPE_NUM_TYPES + NumTypes = 4, +} + +/// +/// D3D12_DESCRIPTOR_HEAP_FLAGS +[Flags] +public enum DescriptorHeapFlags : uint +{ + None = 0, + /// + /// D3D12_DESCRIPTOR_HEAP_FLAG_NONE + D3D12_DESCRIPTOR_HEAP_FLAG_NONE = 0, + /// + /// D3D12_DESCRIPTOR_HEAP_FLAG_SHADER_VISIBLE + D3D12_DESCRIPTOR_HEAP_FLAG_SHADER_VISIBLE = 1, +} + +/// +/// D3D12_DESCRIPTOR_RANGE_TYPE +public enum DescriptorRangeType : int +{ + /// + /// D3D12_DESCRIPTOR_RANGE_TYPE_SRV + Srv = 0, + /// + /// D3D12_DESCRIPTOR_RANGE_TYPE_UAV + Uav = 1, + /// + /// D3D12_DESCRIPTOR_RANGE_TYPE_CBV + Cbv = 2, + /// + /// D3D12_DESCRIPTOR_RANGE_TYPE_SAMPLER + Sampler = 3, +} + +/// +/// D3D12_SHADER_VISIBILITY +public enum ShaderVisibility : int +{ + /// + /// D3D12_SHADER_VISIBILITY_ALL + All = 0, + /// + /// D3D12_SHADER_VISIBILITY_VERTEX + Vertex = 1, + /// + /// D3D12_SHADER_VISIBILITY_HULL + Hull = 2, + /// + /// D3D12_SHADER_VISIBILITY_DOMAIN + Domain = 3, + /// + /// D3D12_SHADER_VISIBILITY_GEOMETRY + Geometry = 4, + /// + /// D3D12_SHADER_VISIBILITY_PIXEL + Pixel = 5, + /// + /// D3D12_SHADER_VISIBILITY_AMPLIFICATION + Amplification = 6, + /// + /// D3D12_SHADER_VISIBILITY_MESH + Mesh = 7, +} + +/// +/// D3D12_ROOT_PARAMETER_TYPE +public enum RootParameterType : int +{ + /// + /// D3D12_ROOT_PARAMETER_TYPE_DESCRIPTOR_TABLE + DescriptorTable = 0, + /// + /// D3D12_ROOT_PARAMETER_TYPE_32BIT_CONSTANTS + _32bitConstants = 1, + /// + /// D3D12_ROOT_PARAMETER_TYPE_CBV + Cbv = 2, + /// + /// D3D12_ROOT_PARAMETER_TYPE_SRV + Srv = 3, + /// + /// D3D12_ROOT_PARAMETER_TYPE_UAV + Uav = 4, +} + +/// +/// D3D12_ROOT_SIGNATURE_FLAGS +[Flags] +public enum RootSignatureFlags : uint +{ + None = 0, + /// + /// D3D12_ROOT_SIGNATURE_FLAG_NONE + D3D12_ROOT_SIGNATURE_FLAG_NONE = 0, + /// + /// D3D12_ROOT_SIGNATURE_FLAG_ALLOW_INPUT_ASSEMBLER_INPUT_LAYOUT + D3D12_ROOT_SIGNATURE_FLAG_ALLOW_INPUT_ASSEMBLER_INPUT_LAYOUT = 1, + /// + /// D3D12_ROOT_SIGNATURE_FLAG_DENY_VERTEX_SHADER_ROOT_ACCESS + D3D12_ROOT_SIGNATURE_FLAG_DENY_VERTEX_SHADER_ROOT_ACCESS = 2, + /// + /// D3D12_ROOT_SIGNATURE_FLAG_DENY_HULL_SHADER_ROOT_ACCESS + D3D12_ROOT_SIGNATURE_FLAG_DENY_HULL_SHADER_ROOT_ACCESS = 4, + /// + /// D3D12_ROOT_SIGNATURE_FLAG_DENY_DOMAIN_SHADER_ROOT_ACCESS + D3D12_ROOT_SIGNATURE_FLAG_DENY_DOMAIN_SHADER_ROOT_ACCESS = 8, + /// + /// D3D12_ROOT_SIGNATURE_FLAG_DENY_GEOMETRY_SHADER_ROOT_ACCESS + D3D12_ROOT_SIGNATURE_FLAG_DENY_GEOMETRY_SHADER_ROOT_ACCESS = 16, + /// + /// D3D12_ROOT_SIGNATURE_FLAG_DENY_PIXEL_SHADER_ROOT_ACCESS + D3D12_ROOT_SIGNATURE_FLAG_DENY_PIXEL_SHADER_ROOT_ACCESS = 32, + /// + /// D3D12_ROOT_SIGNATURE_FLAG_ALLOW_STREAM_OUTPUT + D3D12_ROOT_SIGNATURE_FLAG_ALLOW_STREAM_OUTPUT = 64, + /// + /// D3D12_ROOT_SIGNATURE_FLAG_LOCAL_ROOT_SIGNATURE + D3D12_ROOT_SIGNATURE_FLAG_LOCAL_ROOT_SIGNATURE = 128, + /// + /// D3D12_ROOT_SIGNATURE_FLAG_DENY_AMPLIFICATION_SHADER_ROOT_ACCESS + D3D12_ROOT_SIGNATURE_FLAG_DENY_AMPLIFICATION_SHADER_ROOT_ACCESS = 256, + /// + /// D3D12_ROOT_SIGNATURE_FLAG_DENY_MESH_SHADER_ROOT_ACCESS + D3D12_ROOT_SIGNATURE_FLAG_DENY_MESH_SHADER_ROOT_ACCESS = 512, + /// + /// D3D12_ROOT_SIGNATURE_FLAG_CBV_SRV_UAV_HEAP_DIRECTLY_INDEXED + D3D12_ROOT_SIGNATURE_FLAG_CBV_SRV_UAV_HEAP_DIRECTLY_INDEXED = 1024, + /// + /// D3D12_ROOT_SIGNATURE_FLAG_SAMPLER_HEAP_DIRECTLY_INDEXED + D3D12_ROOT_SIGNATURE_FLAG_SAMPLER_HEAP_DIRECTLY_INDEXED = 2048, +} + +/// +/// D3D12_STATIC_BORDER_COLOR +public enum StaticBorderColor : int +{ + /// + /// D3D12_STATIC_BORDER_COLOR_TRANSPARENT_BLACK + TransparentBlack = 0, + /// + /// D3D12_STATIC_BORDER_COLOR_OPAQUE_BLACK + OpaqueBlack = 1, + /// + /// D3D12_STATIC_BORDER_COLOR_OPAQUE_WHITE + OpaqueWhite = 2, +} + +/// +/// D3D12_DESCRIPTOR_RANGE_FLAGS +[Flags] +public enum DescriptorRangeFlags : uint +{ + None = 0, + /// + /// D3D12_DESCRIPTOR_RANGE_FLAG_NONE + D3D12_DESCRIPTOR_RANGE_FLAG_NONE = 0, + /// + /// D3D12_DESCRIPTOR_RANGE_FLAG_DESCRIPTORS_VOLATILE + D3D12_DESCRIPTOR_RANGE_FLAG_DESCRIPTORS_VOLATILE = 1, + /// + /// D3D12_DESCRIPTOR_RANGE_FLAG_DATA_VOLATILE + D3D12_DESCRIPTOR_RANGE_FLAG_DATA_VOLATILE = 2, + /// + /// D3D12_DESCRIPTOR_RANGE_FLAG_DATA_STATIC_WHILE_SET_AT_EXECUTE + D3D12_DESCRIPTOR_RANGE_FLAG_DATA_STATIC_WHILE_SET_AT_EXECUTE = 4, + /// + /// D3D12_DESCRIPTOR_RANGE_FLAG_DATA_STATIC + D3D12_DESCRIPTOR_RANGE_FLAG_DATA_STATIC = 8, + /// + /// D3D12_DESCRIPTOR_RANGE_FLAG_DESCRIPTORS_STATIC_KEEPING_BUFFER_BOUNDS_CHECKS + D3D12_DESCRIPTOR_RANGE_FLAG_DESCRIPTORS_STATIC_KEEPING_BUFFER_BOUNDS_CHECKS = 65536, +} + +/// +/// D3D12_ROOT_DESCRIPTOR_FLAGS +[Flags] +public enum RootDescriptorFlags : uint +{ + None = 0, + /// + /// D3D12_ROOT_DESCRIPTOR_FLAG_NONE + D3D12_ROOT_DESCRIPTOR_FLAG_NONE = 0, + /// + /// D3D12_ROOT_DESCRIPTOR_FLAG_DATA_VOLATILE + D3D12_ROOT_DESCRIPTOR_FLAG_DATA_VOLATILE = 2, + /// + /// D3D12_ROOT_DESCRIPTOR_FLAG_DATA_STATIC_WHILE_SET_AT_EXECUTE + D3D12_ROOT_DESCRIPTOR_FLAG_DATA_STATIC_WHILE_SET_AT_EXECUTE = 4, + /// + /// D3D12_ROOT_DESCRIPTOR_FLAG_DATA_STATIC + D3D12_ROOT_DESCRIPTOR_FLAG_DATA_STATIC = 8, +} + +/// +/// D3D12_QUERY_HEAP_TYPE +public enum QueryHeapType : int +{ + /// + /// D3D12_QUERY_HEAP_TYPE_OCCLUSION + Occlusion = 0, + /// + /// D3D12_QUERY_HEAP_TYPE_TIMESTAMP + Timestamp = 1, + /// + /// D3D12_QUERY_HEAP_TYPE_PIPELINE_STATISTICS + PipelineStatistics = 2, + /// + /// D3D12_QUERY_HEAP_TYPE_SO_STATISTICS + SoStatistics = 3, + /// + /// D3D12_QUERY_HEAP_TYPE_VIDEO_DECODE_STATISTICS + VideoDecodeStatistics = 4, + /// + /// D3D12_QUERY_HEAP_TYPE_COPY_QUEUE_TIMESTAMP + CopyQueueTimestamp = 5, + /// + /// D3D12_QUERY_HEAP_TYPE_PIPELINE_STATISTICS1 + PipelineStatistics1 = 7, +} + +/// +/// D3D12_QUERY_TYPE +public enum QueryType : int +{ + /// + /// D3D12_QUERY_TYPE_OCCLUSION + Occlusion = 0, + /// + /// D3D12_QUERY_TYPE_BINARY_OCCLUSION + BinaryOcclusion = 1, + /// + /// D3D12_QUERY_TYPE_TIMESTAMP + Timestamp = 2, + /// + /// D3D12_QUERY_TYPE_PIPELINE_STATISTICS + PipelineStatistics = 3, + /// + /// D3D12_QUERY_TYPE_SO_STATISTICS_STREAM0 + SoStatisticsStream0 = 4, + /// + /// D3D12_QUERY_TYPE_SO_STATISTICS_STREAM1 + SoStatisticsStream1 = 5, + /// + /// D3D12_QUERY_TYPE_SO_STATISTICS_STREAM2 + SoStatisticsStream2 = 6, + /// + /// D3D12_QUERY_TYPE_SO_STATISTICS_STREAM3 + SoStatisticsStream3 = 7, + /// + /// D3D12_QUERY_TYPE_VIDEO_DECODE_STATISTICS + VideoDecodeStatistics = 8, + /// + /// D3D12_QUERY_TYPE_PIPELINE_STATISTICS1 + PipelineStatistics1 = 10, +} + +/// +/// D3D12_PREDICATION_OP +public enum PredicationOp : int +{ + /// + /// D3D12_PREDICATION_OP_EQUAL_ZERO + EqualZero = 0, + /// + /// D3D12_PREDICATION_OP_NOT_EQUAL_ZERO + NotEqualZero = 1, +} + +/// +/// D3D12_INDIRECT_ARGUMENT_TYPE +public enum IndirectArgumentType : int +{ + /// + /// D3D12_INDIRECT_ARGUMENT_TYPE_DRAW + Draw = 0, + /// + /// D3D12_INDIRECT_ARGUMENT_TYPE_DRAW_INDEXED + DrawIndexed = 1, + /// + /// D3D12_INDIRECT_ARGUMENT_TYPE_DISPATCH + Dispatch = 2, + /// + /// D3D12_INDIRECT_ARGUMENT_TYPE_VERTEX_BUFFER_VIEW + VertexBufferView = 3, + /// + /// D3D12_INDIRECT_ARGUMENT_TYPE_INDEX_BUFFER_VIEW + IndexBufferView = 4, + /// + /// D3D12_INDIRECT_ARGUMENT_TYPE_CONSTANT + Constant = 5, + /// + /// D3D12_INDIRECT_ARGUMENT_TYPE_CONSTANT_BUFFER_VIEW + ConstantBufferView = 6, + /// + /// D3D12_INDIRECT_ARGUMENT_TYPE_SHADER_RESOURCE_VIEW + ShaderResourceView = 7, + /// + /// D3D12_INDIRECT_ARGUMENT_TYPE_UNORDERED_ACCESS_VIEW + UnorderedAccessView = 8, + /// + /// D3D12_INDIRECT_ARGUMENT_TYPE_DISPATCH_RAYS + DispatchRays = 9, + /// + /// D3D12_INDIRECT_ARGUMENT_TYPE_DISPATCH_MESH + DispatchMesh = 10, +} + +/// +/// D3D12_WRITEBUFFERIMMEDIATE_MODE +public enum WritebufferimmediateMode : int +{ + /// + /// D3D12_WRITEBUFFERIMMEDIATE_MODE_DEFAULT + Default = 0, + /// + /// D3D12_WRITEBUFFERIMMEDIATE_MODE_MARKER_IN + MarkerIn = 1, + /// + /// D3D12_WRITEBUFFERIMMEDIATE_MODE_MARKER_OUT + MarkerOut = 2, +} + +/// +/// D3D12_MULTIPLE_FENCE_WAIT_FLAGS +[Flags] +public enum MultipleFenceWaitFlags : uint +{ + None = 0, + /// + /// D3D12_MULTIPLE_FENCE_WAIT_FLAG_NONE + D3D12_MULTIPLE_FENCE_WAIT_FLAG_NONE = 0, + /// + /// D3D12_MULTIPLE_FENCE_WAIT_FLAG_ANY + D3D12_MULTIPLE_FENCE_WAIT_FLAG_ANY = 1, + /// + /// D3D12_MULTIPLE_FENCE_WAIT_FLAG_ALL + D3D12_MULTIPLE_FENCE_WAIT_FLAG_ALL = 0, +} + +/// +/// D3D12_RESIDENCY_PRIORITY +public enum ResidencyPriority : int +{ + /// + /// D3D12_RESIDENCY_PRIORITY_MINIMUM + Minimum = 671088640, + /// + /// D3D12_RESIDENCY_PRIORITY_LOW + Low = 1342177280, + /// + /// D3D12_RESIDENCY_PRIORITY_NORMAL + Normal = 2013265920, + /// + /// D3D12_RESIDENCY_PRIORITY_HIGH + High = -1610547200, + /// + /// D3D12_RESIDENCY_PRIORITY_MAXIMUM + Maximum = -939524096, +} + +/// +/// D3D12_RESIDENCY_FLAGS +[Flags] +public enum ResidencyFlags : uint +{ + None = 0, + /// + /// D3D12_RESIDENCY_FLAG_NONE + D3D12_RESIDENCY_FLAG_NONE = 0, + /// + /// D3D12_RESIDENCY_FLAG_DENY_OVERBUDGET + D3D12_RESIDENCY_FLAG_DENY_OVERBUDGET = 1, +} + +/// +/// D3D12_COMMAND_LIST_FLAGS +[Flags] +public enum CommandListFlags : uint +{ + None = 0, + /// + /// D3D12_COMMAND_LIST_FLAG_NONE + D3D12_COMMAND_LIST_FLAG_NONE = 0, +} + +/// +/// D3D12_COMMAND_POOL_FLAGS +[Flags] +public enum CommandPoolFlags : uint +{ + None = 0, + /// + /// D3D12_COMMAND_POOL_FLAG_NONE + D3D12_COMMAND_POOL_FLAG_NONE = 0, +} + +/// +/// D3D12_COMMAND_RECORDER_FLAGS +[Flags] +public enum CommandRecorderFlags : uint +{ + None = 0, + /// + /// D3D12_COMMAND_RECORDER_FLAG_NONE + D3D12_COMMAND_RECORDER_FLAG_NONE = 0, +} + +/// +/// D3D12_PROTECTED_SESSION_STATUS +public enum ProtectedSessionStatus : int +{ + /// + /// D3D12_PROTECTED_SESSION_STATUS_OK + Ok = 0, + /// + /// D3D12_PROTECTED_SESSION_STATUS_INVALID + Invalid = 1, +} + +/// +/// D3D12_PROTECTED_RESOURCE_SESSION_SUPPORT_FLAGS +[Flags] +public enum ProtectedResourceSessionSupportFlags : uint +{ + None = 0, + /// + /// D3D12_PROTECTED_RESOURCE_SESSION_SUPPORT_FLAG_NONE + D3D12_PROTECTED_RESOURCE_SESSION_SUPPORT_FLAG_NONE = 0, + /// + /// D3D12_PROTECTED_RESOURCE_SESSION_SUPPORT_FLAG_SUPPORTED + D3D12_PROTECTED_RESOURCE_SESSION_SUPPORT_FLAG_SUPPORTED = 1, +} + +/// +/// D3D12_PROTECTED_RESOURCE_SESSION_FLAGS +[Flags] +public enum ProtectedResourceSessionFlags : uint +{ + None = 0, + /// + /// D3D12_PROTECTED_RESOURCE_SESSION_FLAG_NONE + D3D12_PROTECTED_RESOURCE_SESSION_FLAG_NONE = 0, +} + +/// +/// D3D12_LIFETIME_STATE +public enum LifetimeState : int +{ + /// + /// D3D12_LIFETIME_STATE_IN_USE + InUse = 0, + /// + /// D3D12_LIFETIME_STATE_NOT_IN_USE + NotInUse = 1, +} + +/// +/// D3D12_META_COMMAND_PARAMETER_TYPE +public enum MetaCommandParameterType : int +{ + /// + /// D3D12_META_COMMAND_PARAMETER_TYPE_FLOAT + Float = 0, + /// + /// D3D12_META_COMMAND_PARAMETER_TYPE_UINT64 + Uint64 = 1, + /// + /// D3D12_META_COMMAND_PARAMETER_TYPE_GPU_VIRTUAL_ADDRESS + GpuVirtualAddress = 2, + /// + /// D3D12_META_COMMAND_PARAMETER_TYPE_CPU_DESCRIPTOR_HANDLE_HEAP_TYPE_CBV_SRV_UAV + CpuDescriptorHandleHeapTypeCbvSrvUav = 3, + /// + /// D3D12_META_COMMAND_PARAMETER_TYPE_GPU_DESCRIPTOR_HANDLE_HEAP_TYPE_CBV_SRV_UAV + GpuDescriptorHandleHeapTypeCbvSrvUav = 4, +} + +/// +/// D3D12_META_COMMAND_PARAMETER_FLAGS +[Flags] +public enum MetaCommandParameterFlags : uint +{ + None = 0, + /// + /// D3D12_META_COMMAND_PARAMETER_FLAG_INPUT + D3D12_META_COMMAND_PARAMETER_FLAG_INPUT = 1, + /// + /// D3D12_META_COMMAND_PARAMETER_FLAG_OUTPUT + D3D12_META_COMMAND_PARAMETER_FLAG_OUTPUT = 2, +} + +/// +/// D3D12_META_COMMAND_PARAMETER_STAGE +public enum MetaCommandParameterStage : int +{ + /// + /// D3D12_META_COMMAND_PARAMETER_STAGE_CREATION + Creation = 0, + /// + /// D3D12_META_COMMAND_PARAMETER_STAGE_INITIALIZATION + Initialization = 1, + /// + /// D3D12_META_COMMAND_PARAMETER_STAGE_EXECUTION + Execution = 2, +} + +/// +/// D3D12_GRAPHICS_STATES +[Flags] +public enum GraphicsStates : uint +{ + None = 0, + /// + /// D3D12_GRAPHICS_STATE_NONE + D3D12_GRAPHICS_STATE_NONE = 0, + /// + /// D3D12_GRAPHICS_STATE_IA_VERTEX_BUFFERS + D3D12_GRAPHICS_STATE_IA_VERTEX_BUFFERS = 1, + /// + /// D3D12_GRAPHICS_STATE_IA_INDEX_BUFFER + D3D12_GRAPHICS_STATE_IA_INDEX_BUFFER = 2, + /// + /// D3D12_GRAPHICS_STATE_IA_PRIMITIVE_TOPOLOGY + D3D12_GRAPHICS_STATE_IA_PRIMITIVE_TOPOLOGY = 4, + /// + /// D3D12_GRAPHICS_STATE_DESCRIPTOR_HEAP + D3D12_GRAPHICS_STATE_DESCRIPTOR_HEAP = 8, + /// + /// D3D12_GRAPHICS_STATE_GRAPHICS_ROOT_SIGNATURE + D3D12_GRAPHICS_STATE_GRAPHICS_ROOT_SIGNATURE = 16, + /// + /// D3D12_GRAPHICS_STATE_COMPUTE_ROOT_SIGNATURE + D3D12_GRAPHICS_STATE_COMPUTE_ROOT_SIGNATURE = 32, + /// + /// D3D12_GRAPHICS_STATE_RS_VIEWPORTS + D3D12_GRAPHICS_STATE_RS_VIEWPORTS = 64, + /// + /// D3D12_GRAPHICS_STATE_RS_SCISSOR_RECTS + D3D12_GRAPHICS_STATE_RS_SCISSOR_RECTS = 128, + /// + /// D3D12_GRAPHICS_STATE_PREDICATION + D3D12_GRAPHICS_STATE_PREDICATION = 256, + /// + /// D3D12_GRAPHICS_STATE_OM_RENDER_TARGETS + D3D12_GRAPHICS_STATE_OM_RENDER_TARGETS = 512, + /// + /// D3D12_GRAPHICS_STATE_OM_STENCIL_REF + D3D12_GRAPHICS_STATE_OM_STENCIL_REF = 1024, + /// + /// D3D12_GRAPHICS_STATE_OM_BLEND_FACTOR + D3D12_GRAPHICS_STATE_OM_BLEND_FACTOR = 2048, + /// + /// D3D12_GRAPHICS_STATE_PIPELINE_STATE + D3D12_GRAPHICS_STATE_PIPELINE_STATE = 4096, + /// + /// D3D12_GRAPHICS_STATE_SO_TARGETS + D3D12_GRAPHICS_STATE_SO_TARGETS = 8192, + /// + /// D3D12_GRAPHICS_STATE_OM_DEPTH_BOUNDS + D3D12_GRAPHICS_STATE_OM_DEPTH_BOUNDS = 16384, + /// + /// D3D12_GRAPHICS_STATE_SAMPLE_POSITIONS + D3D12_GRAPHICS_STATE_SAMPLE_POSITIONS = 32768, + /// + /// D3D12_GRAPHICS_STATE_VIEW_INSTANCE_MASK + D3D12_GRAPHICS_STATE_VIEW_INSTANCE_MASK = 65536, +} + +/// +/// D3D12_STATE_SUBOBJECT_TYPE +public enum StateSubobjectType : int +{ + /// + /// D3D12_STATE_SUBOBJECT_TYPE_STATE_OBJECT_CONFIG + StateObjectConfig = 0, + /// + /// D3D12_STATE_SUBOBJECT_TYPE_GLOBAL_ROOT_SIGNATURE + GlobalRootSignature = 1, + /// + /// D3D12_STATE_SUBOBJECT_TYPE_LOCAL_ROOT_SIGNATURE + LocalRootSignature = 2, + /// + /// D3D12_STATE_SUBOBJECT_TYPE_NODE_MASK + NodeMask = 3, + /// + /// D3D12_STATE_SUBOBJECT_TYPE_DXIL_LIBRARY + DxilLibrary = 5, + /// + /// D3D12_STATE_SUBOBJECT_TYPE_EXISTING_COLLECTION + ExistingCollection = 6, + /// + /// D3D12_STATE_SUBOBJECT_TYPE_SUBOBJECT_TO_EXPORTS_ASSOCIATION + SubobjectToExportsAssociation = 7, + /// + /// D3D12_STATE_SUBOBJECT_TYPE_DXIL_SUBOBJECT_TO_EXPORTS_ASSOCIATION + DxilSubobjectToExportsAssociation = 8, + /// + /// D3D12_STATE_SUBOBJECT_TYPE_RAYTRACING_SHADER_CONFIG + RaytracingShaderConfig = 9, + /// + /// D3D12_STATE_SUBOBJECT_TYPE_RAYTRACING_PIPELINE_CONFIG + RaytracingPipelineConfig = 10, + /// + /// D3D12_STATE_SUBOBJECT_TYPE_HIT_GROUP + HitGroup = 11, + /// + /// D3D12_STATE_SUBOBJECT_TYPE_RAYTRACING_PIPELINE_CONFIG1 + RaytracingPipelineConfig1 = 12, + /// + /// D3D12_STATE_SUBOBJECT_TYPE_MAX_VALID + MaxValid = 13, +} + +/// +/// D3D12_STATE_OBJECT_FLAGS +[Flags] +public enum StateObjectFlags : uint +{ + None = 0, + /// + /// D3D12_STATE_OBJECT_FLAG_NONE + D3D12_STATE_OBJECT_FLAG_NONE = 0, + /// + /// D3D12_STATE_OBJECT_FLAG_ALLOW_LOCAL_DEPENDENCIES_ON_EXTERNAL_DEFINITIONS + D3D12_STATE_OBJECT_FLAG_ALLOW_LOCAL_DEPENDENCIES_ON_EXTERNAL_DEFINITIONS = 1, + /// + /// D3D12_STATE_OBJECT_FLAG_ALLOW_EXTERNAL_DEPENDENCIES_ON_LOCAL_DEFINITIONS + D3D12_STATE_OBJECT_FLAG_ALLOW_EXTERNAL_DEPENDENCIES_ON_LOCAL_DEFINITIONS = 2, + /// + /// D3D12_STATE_OBJECT_FLAG_ALLOW_STATE_OBJECT_ADDITIONS + D3D12_STATE_OBJECT_FLAG_ALLOW_STATE_OBJECT_ADDITIONS = 4, +} + +/// +/// D3D12_EXPORT_FLAGS +[Flags] +public enum ExportFlags : uint +{ + None = 0, + /// + /// D3D12_EXPORT_FLAG_NONE + D3D12_EXPORT_FLAG_NONE = 0, +} + +/// +/// D3D12_HIT_GROUP_TYPE +public enum HitGroupType : int +{ + /// + /// D3D12_HIT_GROUP_TYPE_TRIANGLES + Triangles = 0, + /// + /// D3D12_HIT_GROUP_TYPE_PROCEDURAL_PRIMITIVE + ProceduralPrimitive = 1, +} + +/// +/// D3D12_RAYTRACING_PIPELINE_FLAGS +[Flags] +public enum RaytracingPipelineFlags : uint +{ + None = 0, + /// + /// D3D12_RAYTRACING_PIPELINE_FLAG_NONE + D3D12_RAYTRACING_PIPELINE_FLAG_NONE = 0, + /// + /// D3D12_RAYTRACING_PIPELINE_FLAG_SKIP_TRIANGLES + D3D12_RAYTRACING_PIPELINE_FLAG_SKIP_TRIANGLES = 256, + /// + /// D3D12_RAYTRACING_PIPELINE_FLAG_SKIP_PROCEDURAL_PRIMITIVES + D3D12_RAYTRACING_PIPELINE_FLAG_SKIP_PROCEDURAL_PRIMITIVES = 512, +} + +/// +/// D3D12_STATE_OBJECT_TYPE +public enum StateObjectType : int +{ + /// + /// D3D12_STATE_OBJECT_TYPE_COLLECTION + Collection = 0, + /// + /// D3D12_STATE_OBJECT_TYPE_RAYTRACING_PIPELINE + RaytracingPipeline = 3, +} + +/// +/// D3D12_RAYTRACING_GEOMETRY_FLAGS +[Flags] +public enum RaytracingGeometryFlags : uint +{ + None = 0, + /// + /// D3D12_RAYTRACING_GEOMETRY_FLAG_NONE + D3D12_RAYTRACING_GEOMETRY_FLAG_NONE = 0, + /// + /// D3D12_RAYTRACING_GEOMETRY_FLAG_OPAQUE + D3D12_RAYTRACING_GEOMETRY_FLAG_OPAQUE = 1, + /// + /// D3D12_RAYTRACING_GEOMETRY_FLAG_NO_DUPLICATE_ANYHIT_INVOCATION + D3D12_RAYTRACING_GEOMETRY_FLAG_NO_DUPLICATE_ANYHIT_INVOCATION = 2, +} + +/// +/// D3D12_RAYTRACING_GEOMETRY_TYPE +public enum RaytracingGeometryType : int +{ + /// + /// D3D12_RAYTRACING_GEOMETRY_TYPE_TRIANGLES + Triangles = 0, + /// + /// D3D12_RAYTRACING_GEOMETRY_TYPE_PROCEDURAL_PRIMITIVE_AABBS + ProceduralPrimitiveAabbs = 1, +} + +/// +/// D3D12_RAYTRACING_INSTANCE_FLAGS +[Flags] +public enum RaytracingInstanceFlags : uint +{ + None = 0, + /// + /// D3D12_RAYTRACING_INSTANCE_FLAG_NONE + D3D12_RAYTRACING_INSTANCE_FLAG_NONE = 0, + /// + /// D3D12_RAYTRACING_INSTANCE_FLAG_TRIANGLE_CULL_DISABLE + D3D12_RAYTRACING_INSTANCE_FLAG_TRIANGLE_CULL_DISABLE = 1, + /// + /// D3D12_RAYTRACING_INSTANCE_FLAG_TRIANGLE_FRONT_COUNTERCLOCKWISE + D3D12_RAYTRACING_INSTANCE_FLAG_TRIANGLE_FRONT_COUNTERCLOCKWISE = 2, + /// + /// D3D12_RAYTRACING_INSTANCE_FLAG_FORCE_OPAQUE + D3D12_RAYTRACING_INSTANCE_FLAG_FORCE_OPAQUE = 4, + /// + /// D3D12_RAYTRACING_INSTANCE_FLAG_FORCE_NON_OPAQUE + D3D12_RAYTRACING_INSTANCE_FLAG_FORCE_NON_OPAQUE = 8, +} + +/// +/// D3D12_RAYTRACING_ACCELERATION_STRUCTURE_BUILD_FLAGS +[Flags] +public enum RaytracingAccelerationStructureBuildFlags : uint +{ + None = 0, + /// + /// D3D12_RAYTRACING_ACCELERATION_STRUCTURE_BUILD_FLAG_NONE + D3D12_RAYTRACING_ACCELERATION_STRUCTURE_BUILD_FLAG_NONE = 0, + /// + /// D3D12_RAYTRACING_ACCELERATION_STRUCTURE_BUILD_FLAG_ALLOW_UPDATE + D3D12_RAYTRACING_ACCELERATION_STRUCTURE_BUILD_FLAG_ALLOW_UPDATE = 1, + /// + /// D3D12_RAYTRACING_ACCELERATION_STRUCTURE_BUILD_FLAG_ALLOW_COMPACTION + D3D12_RAYTRACING_ACCELERATION_STRUCTURE_BUILD_FLAG_ALLOW_COMPACTION = 2, + /// + /// D3D12_RAYTRACING_ACCELERATION_STRUCTURE_BUILD_FLAG_PREFER_FAST_TRACE + D3D12_RAYTRACING_ACCELERATION_STRUCTURE_BUILD_FLAG_PREFER_FAST_TRACE = 4, + /// + /// D3D12_RAYTRACING_ACCELERATION_STRUCTURE_BUILD_FLAG_PREFER_FAST_BUILD + D3D12_RAYTRACING_ACCELERATION_STRUCTURE_BUILD_FLAG_PREFER_FAST_BUILD = 8, + /// + /// D3D12_RAYTRACING_ACCELERATION_STRUCTURE_BUILD_FLAG_MINIMIZE_MEMORY + D3D12_RAYTRACING_ACCELERATION_STRUCTURE_BUILD_FLAG_MINIMIZE_MEMORY = 16, + /// + /// D3D12_RAYTRACING_ACCELERATION_STRUCTURE_BUILD_FLAG_PERFORM_UPDATE + D3D12_RAYTRACING_ACCELERATION_STRUCTURE_BUILD_FLAG_PERFORM_UPDATE = 32, +} + +/// +/// D3D12_RAYTRACING_ACCELERATION_STRUCTURE_COPY_MODE +public enum RaytracingAccelerationStructureCopyMode : int +{ + /// + /// D3D12_RAYTRACING_ACCELERATION_STRUCTURE_COPY_MODE_CLONE + Clone = 0, + /// + /// D3D12_RAYTRACING_ACCELERATION_STRUCTURE_COPY_MODE_COMPACT + Compact = 1, + /// + /// D3D12_RAYTRACING_ACCELERATION_STRUCTURE_COPY_MODE_VISUALIZATION_DECODE_FOR_TOOLS + VisualizationDecodeForTools = 2, + /// + /// D3D12_RAYTRACING_ACCELERATION_STRUCTURE_COPY_MODE_SERIALIZE + Serialize = 3, + /// + /// D3D12_RAYTRACING_ACCELERATION_STRUCTURE_COPY_MODE_DESERIALIZE + Deserialize = 4, +} + +/// +/// D3D12_RAYTRACING_ACCELERATION_STRUCTURE_TYPE +public enum RaytracingAccelerationStructureType : int +{ + /// + /// D3D12_RAYTRACING_ACCELERATION_STRUCTURE_TYPE_TOP_LEVEL + TopLevel = 0, + /// + /// D3D12_RAYTRACING_ACCELERATION_STRUCTURE_TYPE_BOTTOM_LEVEL + BottomLevel = 1, +} + +/// +/// D3D12_ELEMENTS_LAYOUT +public enum ElementsLayout : int +{ + /// + /// D3D12_ELEMENTS_LAYOUT_ARRAY + Array = 0, + /// + /// D3D12_ELEMENTS_LAYOUT_ARRAY_OF_POINTERS + ArrayOfPointers = 1, +} + +/// +/// D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_TYPE +public enum RaytracingAccelerationStructurePostbuildInfoType : int +{ + /// + /// D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_COMPACTED_SIZE + D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_COMPACTED_SIZE = 0, + /// + /// D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_TOOLS_VISUALIZATION + D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_TOOLS_VISUALIZATION = 1, + /// + /// D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_SERIALIZATION + D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_SERIALIZATION = 2, + /// + /// D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_CURRENT_SIZE + D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_CURRENT_SIZE = 3, +} + +/// +/// D3D12_SERIALIZED_DATA_TYPE +public enum SerializedDataType : int +{ + /// + /// D3D12_SERIALIZED_DATA_RAYTRACING_ACCELERATION_STRUCTURE + D3D12_SERIALIZED_DATA_RAYTRACING_ACCELERATION_STRUCTURE = 0, +} + +/// +/// D3D12_DRIVER_MATCHING_IDENTIFIER_STATUS +public enum DriverMatchingIdentifierStatus : int +{ + /// + /// D3D12_DRIVER_MATCHING_IDENTIFIER_COMPATIBLE_WITH_DEVICE + D3D12_DRIVER_MATCHING_IDENTIFIER_COMPATIBLE_WITH_DEVICE = 0, + /// + /// D3D12_DRIVER_MATCHING_IDENTIFIER_UNSUPPORTED_TYPE + D3D12_DRIVER_MATCHING_IDENTIFIER_UNSUPPORTED_TYPE = 1, + /// + /// D3D12_DRIVER_MATCHING_IDENTIFIER_UNRECOGNIZED + D3D12_DRIVER_MATCHING_IDENTIFIER_UNRECOGNIZED = 2, + /// + /// D3D12_DRIVER_MATCHING_IDENTIFIER_INCOMPATIBLE_VERSION + D3D12_DRIVER_MATCHING_IDENTIFIER_INCOMPATIBLE_VERSION = 3, + /// + /// D3D12_DRIVER_MATCHING_IDENTIFIER_INCOMPATIBLE_TYPE + D3D12_DRIVER_MATCHING_IDENTIFIER_INCOMPATIBLE_TYPE = 4, +} + +/// +/// D3D12_RAY_FLAGS +[Flags] +public enum RayFlags : uint +{ + None = 0, + /// + /// D3D12_RAY_FLAG_NONE + D3D12_RAY_FLAG_NONE = 0, + /// + /// D3D12_RAY_FLAG_FORCE_OPAQUE + D3D12_RAY_FLAG_FORCE_OPAQUE = 1, + /// + /// D3D12_RAY_FLAG_FORCE_NON_OPAQUE + D3D12_RAY_FLAG_FORCE_NON_OPAQUE = 2, + /// + /// D3D12_RAY_FLAG_ACCEPT_FIRST_HIT_AND_END_SEARCH + D3D12_RAY_FLAG_ACCEPT_FIRST_HIT_AND_END_SEARCH = 4, + /// + /// D3D12_RAY_FLAG_SKIP_CLOSEST_HIT_SHADER + D3D12_RAY_FLAG_SKIP_CLOSEST_HIT_SHADER = 8, + /// + /// D3D12_RAY_FLAG_CULL_BACK_FACING_TRIANGLES + D3D12_RAY_FLAG_CULL_BACK_FACING_TRIANGLES = 16, + /// + /// D3D12_RAY_FLAG_CULL_FRONT_FACING_TRIANGLES + D3D12_RAY_FLAG_CULL_FRONT_FACING_TRIANGLES = 32, + /// + /// D3D12_RAY_FLAG_CULL_OPAQUE + D3D12_RAY_FLAG_CULL_OPAQUE = 64, + /// + /// D3D12_RAY_FLAG_CULL_NON_OPAQUE + D3D12_RAY_FLAG_CULL_NON_OPAQUE = 128, + /// + /// D3D12_RAY_FLAG_SKIP_TRIANGLES + D3D12_RAY_FLAG_SKIP_TRIANGLES = 256, + /// + /// D3D12_RAY_FLAG_SKIP_PROCEDURAL_PRIMITIVES + D3D12_RAY_FLAG_SKIP_PROCEDURAL_PRIMITIVES = 512, +} + +/// +/// D3D12_HIT_KIND +public enum HitKind : int +{ + /// + /// D3D12_HIT_KIND_TRIANGLE_FRONT_FACE + TriangleFrontFace = 254, + /// + /// D3D12_HIT_KIND_TRIANGLE_BACK_FACE + TriangleBackFace = 255, +} + +/// +/// D3D12_AUTO_BREADCRUMB_OP +public enum AutoBreadcrumbOp : int +{ + /// + /// D3D12_AUTO_BREADCRUMB_OP_SETMARKER + Setmarker = 0, + /// + /// D3D12_AUTO_BREADCRUMB_OP_BEGINEVENT + Beginevent = 1, + /// + /// D3D12_AUTO_BREADCRUMB_OP_ENDEVENT + Endevent = 2, + /// + /// D3D12_AUTO_BREADCRUMB_OP_DRAWINSTANCED + Drawinstanced = 3, + /// + /// D3D12_AUTO_BREADCRUMB_OP_DRAWINDEXEDINSTANCED + Drawindexedinstanced = 4, + /// + /// D3D12_AUTO_BREADCRUMB_OP_EXECUTEINDIRECT + Executeindirect = 5, + /// + /// D3D12_AUTO_BREADCRUMB_OP_DISPATCH + Dispatch = 6, + /// + /// D3D12_AUTO_BREADCRUMB_OP_COPYBUFFERREGION + Copybufferregion = 7, + /// + /// D3D12_AUTO_BREADCRUMB_OP_COPYTEXTUREREGION + Copytextureregion = 8, + /// + /// D3D12_AUTO_BREADCRUMB_OP_COPYRESOURCE + Copyresource = 9, + /// + /// D3D12_AUTO_BREADCRUMB_OP_COPYTILES + Copytiles = 10, + /// + /// D3D12_AUTO_BREADCRUMB_OP_RESOLVESUBRESOURCE + Resolvesubresource = 11, + /// + /// D3D12_AUTO_BREADCRUMB_OP_CLEARRENDERTARGETVIEW + Clearrendertargetview = 12, + /// + /// D3D12_AUTO_BREADCRUMB_OP_CLEARUNORDEREDACCESSVIEW + Clearunorderedaccessview = 13, + /// + /// D3D12_AUTO_BREADCRUMB_OP_CLEARDEPTHSTENCILVIEW + Cleardepthstencilview = 14, + /// + /// D3D12_AUTO_BREADCRUMB_OP_RESOURCEBARRIER + Resourcebarrier = 15, + /// + /// D3D12_AUTO_BREADCRUMB_OP_EXECUTEBUNDLE + Executebundle = 16, + /// + /// D3D12_AUTO_BREADCRUMB_OP_PRESENT + Present = 17, + /// + /// D3D12_AUTO_BREADCRUMB_OP_RESOLVEQUERYDATA + Resolvequerydata = 18, + /// + /// D3D12_AUTO_BREADCRUMB_OP_BEGINSUBMISSION + Beginsubmission = 19, + /// + /// D3D12_AUTO_BREADCRUMB_OP_ENDSUBMISSION + Endsubmission = 20, + /// + /// D3D12_AUTO_BREADCRUMB_OP_DECODEFRAME + Decodeframe = 21, + /// + /// D3D12_AUTO_BREADCRUMB_OP_PROCESSFRAMES + Processframes = 22, + /// + /// D3D12_AUTO_BREADCRUMB_OP_ATOMICCOPYBUFFERUINT + Atomiccopybufferuint = 23, + /// + /// D3D12_AUTO_BREADCRUMB_OP_ATOMICCOPYBUFFERUINT64 + Atomiccopybufferuint64 = 24, + /// + /// D3D12_AUTO_BREADCRUMB_OP_RESOLVESUBRESOURCEREGION + Resolvesubresourceregion = 25, + /// + /// D3D12_AUTO_BREADCRUMB_OP_WRITEBUFFERIMMEDIATE + Writebufferimmediate = 26, + /// + /// D3D12_AUTO_BREADCRUMB_OP_DECODEFRAME1 + Decodeframe1 = 27, + /// + /// D3D12_AUTO_BREADCRUMB_OP_SETPROTECTEDRESOURCESESSION + Setprotectedresourcesession = 28, + /// + /// D3D12_AUTO_BREADCRUMB_OP_DECODEFRAME2 + Decodeframe2 = 29, + /// + /// D3D12_AUTO_BREADCRUMB_OP_PROCESSFRAMES1 + Processframes1 = 30, + /// + /// D3D12_AUTO_BREADCRUMB_OP_BUILDRAYTRACINGACCELERATIONSTRUCTURE + Buildraytracingaccelerationstructure = 31, + /// + /// D3D12_AUTO_BREADCRUMB_OP_EMITRAYTRACINGACCELERATIONSTRUCTUREPOSTBUILDINFO + Emitraytracingaccelerationstructurepostbuildinfo = 32, + /// + /// D3D12_AUTO_BREADCRUMB_OP_COPYRAYTRACINGACCELERATIONSTRUCTURE + Copyraytracingaccelerationstructure = 33, + /// + /// D3D12_AUTO_BREADCRUMB_OP_DISPATCHRAYS + Dispatchrays = 34, + /// + /// D3D12_AUTO_BREADCRUMB_OP_INITIALIZEMETACOMMAND + Initializemetacommand = 35, + /// + /// D3D12_AUTO_BREADCRUMB_OP_EXECUTEMETACOMMAND + Executemetacommand = 36, + /// + /// D3D12_AUTO_BREADCRUMB_OP_ESTIMATEMOTION + Estimatemotion = 37, + /// + /// D3D12_AUTO_BREADCRUMB_OP_RESOLVEMOTIONVECTORHEAP + Resolvemotionvectorheap = 38, + /// + /// D3D12_AUTO_BREADCRUMB_OP_SETPIPELINESTATE1 + Setpipelinestate1 = 39, + /// + /// D3D12_AUTO_BREADCRUMB_OP_INITIALIZEEXTENSIONCOMMAND + Initializeextensioncommand = 40, + /// + /// D3D12_AUTO_BREADCRUMB_OP_EXECUTEEXTENSIONCOMMAND + Executeextensioncommand = 41, + /// + /// D3D12_AUTO_BREADCRUMB_OP_DISPATCHMESH + Dispatchmesh = 42, + /// + /// D3D12_AUTO_BREADCRUMB_OP_ENCODEFRAME + Encodeframe = 43, + /// + /// D3D12_AUTO_BREADCRUMB_OP_RESOLVEENCODEROUTPUTMETADATA + Resolveencoderoutputmetadata = 44, +} + +/// +/// D3D12_DRED_VERSION +public enum DredVersion : int +{ + /// + /// D3D12_DRED_VERSION_1_0 + _10 = 1, + /// + /// D3D12_DRED_VERSION_1_1 + _11 = 2, + /// + /// D3D12_DRED_VERSION_1_2 + _12 = 3, + /// + /// D3D12_DRED_VERSION_1_3 + _13 = 4, +} + +/// +/// D3D12_DRED_FLAGS +[Flags] +public enum DredFlags : uint +{ + None = 0, + /// + /// D3D12_DRED_FLAG_NONE + D3D12_DRED_FLAG_NONE = 0, + /// + /// D3D12_DRED_FLAG_FORCE_ENABLE + D3D12_DRED_FLAG_FORCE_ENABLE = 1, + /// + /// D3D12_DRED_FLAG_DISABLE_AUTOBREADCRUMBS + D3D12_DRED_FLAG_DISABLE_AUTOBREADCRUMBS = 2, +} + +/// +/// D3D12_DRED_ENABLEMENT +public enum DredEnablement : int +{ + /// + /// D3D12_DRED_ENABLEMENT_SYSTEM_CONTROLLED + SystemControlled = 0, + /// + /// D3D12_DRED_ENABLEMENT_FORCED_OFF + ForcedOff = 1, + /// + /// D3D12_DRED_ENABLEMENT_FORCED_ON + ForcedOn = 2, +} + +/// +/// D3D12_DRED_ALLOCATION_TYPE +public enum DredAllocationType : int +{ + /// + /// D3D12_DRED_ALLOCATION_TYPE_COMMAND_QUEUE + CommandQueue = 19, + /// + /// D3D12_DRED_ALLOCATION_TYPE_COMMAND_ALLOCATOR + CommandAllocator = 20, + /// + /// D3D12_DRED_ALLOCATION_TYPE_PIPELINE_STATE + PipelineState = 21, + /// + /// D3D12_DRED_ALLOCATION_TYPE_COMMAND_LIST + CommandList = 22, + /// + /// D3D12_DRED_ALLOCATION_TYPE_FENCE + Fence = 23, + /// + /// D3D12_DRED_ALLOCATION_TYPE_DESCRIPTOR_HEAP + DescriptorHeap = 24, + /// + /// D3D12_DRED_ALLOCATION_TYPE_HEAP + Heap = 25, + /// + /// D3D12_DRED_ALLOCATION_TYPE_QUERY_HEAP + QueryHeap = 27, + /// + /// D3D12_DRED_ALLOCATION_TYPE_COMMAND_SIGNATURE + CommandSignature = 28, + /// + /// D3D12_DRED_ALLOCATION_TYPE_PIPELINE_LIBRARY + PipelineLibrary = 29, + /// + /// D3D12_DRED_ALLOCATION_TYPE_VIDEO_DECODER + VideoDecoder = 30, + /// + /// D3D12_DRED_ALLOCATION_TYPE_VIDEO_PROCESSOR + VideoProcessor = 32, + /// + /// D3D12_DRED_ALLOCATION_TYPE_RESOURCE + Resource = 34, + /// + /// D3D12_DRED_ALLOCATION_TYPE_PASS + Pass = 35, + /// + /// D3D12_DRED_ALLOCATION_TYPE_CRYPTOSESSION + Cryptosession = 36, + /// + /// D3D12_DRED_ALLOCATION_TYPE_CRYPTOSESSIONPOLICY + Cryptosessionpolicy = 37, + /// + /// D3D12_DRED_ALLOCATION_TYPE_PROTECTEDRESOURCESESSION + Protectedresourcesession = 38, + /// + /// D3D12_DRED_ALLOCATION_TYPE_VIDEO_DECODER_HEAP + VideoDecoderHeap = 39, + /// + /// D3D12_DRED_ALLOCATION_TYPE_COMMAND_POOL + CommandPool = 40, + /// + /// D3D12_DRED_ALLOCATION_TYPE_COMMAND_RECORDER + CommandRecorder = 41, + /// + /// D3D12_DRED_ALLOCATION_TYPE_STATE_OBJECT + StateObject = 42, + /// + /// D3D12_DRED_ALLOCATION_TYPE_METACOMMAND + Metacommand = 43, + /// + /// D3D12_DRED_ALLOCATION_TYPE_SCHEDULINGGROUP + Schedulinggroup = 44, + /// + /// D3D12_DRED_ALLOCATION_TYPE_VIDEO_MOTION_ESTIMATOR + VideoMotionEstimator = 45, + /// + /// D3D12_DRED_ALLOCATION_TYPE_VIDEO_MOTION_VECTOR_HEAP + VideoMotionVectorHeap = 46, + /// + /// D3D12_DRED_ALLOCATION_TYPE_VIDEO_EXTENSION_COMMAND + VideoExtensionCommand = 47, + /// + /// D3D12_DRED_ALLOCATION_TYPE_VIDEO_ENCODER + VideoEncoder = 48, + /// + /// D3D12_DRED_ALLOCATION_TYPE_VIDEO_ENCODER_HEAP + VideoEncoderHeap = 49, + /// + /// D3D12_DRED_ALLOCATION_TYPE_INVALID + Invalid = -1, +} + +/// +/// D3D12_DRED_PAGE_FAULT_FLAGS +[Flags] +public enum DredPageFaultFlags : uint +{ + /// + /// D3D12_DRED_PAGE_FAULT_FLAGS_NONE + None = 0, +} + +/// +/// D3D12_DRED_DEVICE_STATE +public enum DredDeviceState : int +{ + /// + /// D3D12_DRED_DEVICE_STATE_UNKNOWN + Unknown = 0, + /// + /// D3D12_DRED_DEVICE_STATE_HUNG + Hung = 3, + /// + /// D3D12_DRED_DEVICE_STATE_FAULT + Fault = 6, + /// + /// D3D12_DRED_DEVICE_STATE_PAGEFAULT + Pagefault = 7, +} + +/// +/// D3D12_BACKGROUND_PROCESSING_MODE +public enum BackgroundProcessingMode : int +{ + /// + /// D3D12_BACKGROUND_PROCESSING_MODE_ALLOWED + Allowed = 0, + /// + /// D3D12_BACKGROUND_PROCESSING_MODE_ALLOW_INTRUSIVE_MEASUREMENTS + AllowIntrusiveMeasurements = 1, + /// + /// D3D12_BACKGROUND_PROCESSING_MODE_DISABLE_BACKGROUND_WORK + DisableBackgroundWork = 2, + /// + /// D3D12_BACKGROUND_PROCESSING_MODE_DISABLE_PROFILING_BY_SYSTEM + DisableProfilingBySystem = 3, +} + +/// +/// D3D12_MEASUREMENTS_ACTION +public enum MeasurementsAction : int +{ + /// + /// D3D12_MEASUREMENTS_ACTION_KEEP_ALL + KeepAll = 0, + /// + /// D3D12_MEASUREMENTS_ACTION_COMMIT_RESULTS + CommitResults = 1, + /// + /// D3D12_MEASUREMENTS_ACTION_COMMIT_RESULTS_HIGH_PRIORITY + CommitResultsHighPriority = 2, + /// + /// D3D12_MEASUREMENTS_ACTION_DISCARD_PREVIOUS + DiscardPrevious = 3, +} + +/// +/// D3D12_RENDER_PASS_BEGINNING_ACCESS_TYPE +public enum RenderPassBeginningAccessType : int +{ + /// + /// D3D12_RENDER_PASS_BEGINNING_ACCESS_TYPE_DISCARD + Discard = 0, + /// + /// D3D12_RENDER_PASS_BEGINNING_ACCESS_TYPE_PRESERVE + Preserve = 1, + /// + /// D3D12_RENDER_PASS_BEGINNING_ACCESS_TYPE_CLEAR + Clear = 2, + /// + /// D3D12_RENDER_PASS_BEGINNING_ACCESS_TYPE_NO_ACCESS + NoAccess = 3, +} + +/// +/// D3D12_RENDER_PASS_ENDING_ACCESS_TYPE +public enum RenderPassEndingAccessType : int +{ + /// + /// D3D12_RENDER_PASS_ENDING_ACCESS_TYPE_DISCARD + Discard = 0, + /// + /// D3D12_RENDER_PASS_ENDING_ACCESS_TYPE_PRESERVE + Preserve = 1, + /// + /// D3D12_RENDER_PASS_ENDING_ACCESS_TYPE_RESOLVE + Resolve = 2, + /// + /// D3D12_RENDER_PASS_ENDING_ACCESS_TYPE_NO_ACCESS + NoAccess = 3, +} + +/// +/// D3D12_RENDER_PASS_FLAGS +[Flags] +public enum RenderPassFlags : uint +{ + None = 0, + /// + /// D3D12_RENDER_PASS_FLAG_NONE + D3D12_RENDER_PASS_FLAG_NONE = 0, + /// + /// D3D12_RENDER_PASS_FLAG_ALLOW_UAV_WRITES + D3D12_RENDER_PASS_FLAG_ALLOW_UAV_WRITES = 1, + /// + /// D3D12_RENDER_PASS_FLAG_SUSPENDING_PASS + D3D12_RENDER_PASS_FLAG_SUSPENDING_PASS = 2, + /// + /// D3D12_RENDER_PASS_FLAG_RESUMING_PASS + D3D12_RENDER_PASS_FLAG_RESUMING_PASS = 4, +} + +/// +/// D3D12_SHADER_CACHE_MODE +public enum ShaderCacheMode : int +{ + /// + /// D3D12_SHADER_CACHE_MODE_MEMORY + Memory = 0, + /// + /// D3D12_SHADER_CACHE_MODE_DISK + Disk = 1, +} + +/// +/// D3D12_SHADER_CACHE_FLAGS +[Flags] +public enum ShaderCacheFlags : uint +{ + None = 0, + /// + /// D3D12_SHADER_CACHE_FLAG_NONE + D3D12_SHADER_CACHE_FLAG_NONE = 0, + /// + /// D3D12_SHADER_CACHE_FLAG_DRIVER_VERSIONED + D3D12_SHADER_CACHE_FLAG_DRIVER_VERSIONED = 1, + /// + /// D3D12_SHADER_CACHE_FLAG_USE_WORKING_DIR + D3D12_SHADER_CACHE_FLAG_USE_WORKING_DIR = 2, +} + +/// +/// D3D12_SHADER_CACHE_KIND_FLAGS +[Flags] +public enum ShaderCacheKindFlags : uint +{ + None = 0, + /// + /// D3D12_SHADER_CACHE_KIND_FLAG_IMPLICIT_D3D_CACHE_FOR_DRIVER + D3D12_SHADER_CACHE_KIND_FLAG_IMPLICIT_D3D_CACHE_FOR_DRIVER = 1, + /// + /// D3D12_SHADER_CACHE_KIND_FLAG_IMPLICIT_D3D_CONVERSIONS + D3D12_SHADER_CACHE_KIND_FLAG_IMPLICIT_D3D_CONVERSIONS = 2, + /// + /// D3D12_SHADER_CACHE_KIND_FLAG_IMPLICIT_DRIVER_MANAGED + D3D12_SHADER_CACHE_KIND_FLAG_IMPLICIT_DRIVER_MANAGED = 4, + /// + /// D3D12_SHADER_CACHE_KIND_FLAG_APPLICATION_MANAGED + D3D12_SHADER_CACHE_KIND_FLAG_APPLICATION_MANAGED = 8, +} + +/// +/// D3D12_SHADER_CACHE_CONTROL_FLAGS +[Flags] +public enum ShaderCacheControlFlags : uint +{ + None = 0, + /// + /// D3D12_SHADER_CACHE_CONTROL_FLAG_DISABLE + D3D12_SHADER_CACHE_CONTROL_FLAG_DISABLE = 1, + /// + /// D3D12_SHADER_CACHE_CONTROL_FLAG_ENABLE + D3D12_SHADER_CACHE_CONTROL_FLAG_ENABLE = 2, + /// + /// D3D12_SHADER_CACHE_CONTROL_FLAG_CLEAR + D3D12_SHADER_CACHE_CONTROL_FLAG_CLEAR = 4, +} + +/// +/// D3D12_GPU_BASED_VALIDATION_FLAGS +[Flags] +public enum GpuBasedValidationFlags : int +{ + /// + /// D3D12_GPU_BASED_VALIDATION_FLAGS_NONE + None = 0, + /// + /// D3D12_GPU_BASED_VALIDATION_FLAGS_DISABLE_STATE_TRACKING + DisableStateTracking = 1, +} + +/// +/// D3D12_RLDO_FLAGS +[Flags] +public enum RldoFlags : int +{ + None = 0, + /// + /// D3D12_RLDO_NONE + D3D12_RLDO_NONE = 0, + /// + /// D3D12_RLDO_SUMMARY + D3D12_RLDO_SUMMARY = 1, + /// + /// D3D12_RLDO_DETAIL + D3D12_RLDO_DETAIL = 2, + /// + /// D3D12_RLDO_IGNORE_INTERNAL + D3D12_RLDO_IGNORE_INTERNAL = 4, +} + +/// +/// D3D12_DEBUG_DEVICE_PARAMETER_TYPE +public enum DebugDeviceParameterType : int +{ + /// + /// D3D12_DEBUG_DEVICE_PARAMETER_FEATURE_FLAGS + D3D12_DEBUG_DEVICE_PARAMETER_FEATURE_FLAGS = 0, + /// + /// D3D12_DEBUG_DEVICE_PARAMETER_GPU_BASED_VALIDATION_SETTINGS + D3D12_DEBUG_DEVICE_PARAMETER_GPU_BASED_VALIDATION_SETTINGS = 1, + /// + /// D3D12_DEBUG_DEVICE_PARAMETER_GPU_SLOWDOWN_PERFORMANCE_FACTOR + D3D12_DEBUG_DEVICE_PARAMETER_GPU_SLOWDOWN_PERFORMANCE_FACTOR = 2, +} + +/// +/// D3D12_DEBUG_FEATURE +public enum DebugFeature : int +{ + /// + /// D3D12_DEBUG_FEATURE_NONE + None = 0, + /// + /// D3D12_DEBUG_FEATURE_ALLOW_BEHAVIOR_CHANGING_DEBUG_AIDS + AllowBehaviorChangingDebugAids = 1, + /// + /// D3D12_DEBUG_FEATURE_CONSERVATIVE_RESOURCE_STATE_TRACKING + ConservativeResourceStateTracking = 2, + /// + /// D3D12_DEBUG_FEATURE_DISABLE_VIRTUALIZED_BUNDLES_VALIDATION + DisableVirtualizedBundlesValidation = 4, + /// + /// D3D12_DEBUG_FEATURE_EMULATE_WINDOWS7 + EmulateWindows7 = 8, +} + +/// +/// D3D12_GPU_BASED_VALIDATION_SHADER_PATCH_MODE +public enum GpuBasedValidationShaderPatchMode : int +{ + /// + /// D3D12_GPU_BASED_VALIDATION_SHADER_PATCH_MODE_NONE + None = 0, + /// + /// D3D12_GPU_BASED_VALIDATION_SHADER_PATCH_MODE_STATE_TRACKING_ONLY + StateTrackingOnly = 1, + /// + /// D3D12_GPU_BASED_VALIDATION_SHADER_PATCH_MODE_UNGUARDED_VALIDATION + UnguardedValidation = 2, + /// + /// D3D12_GPU_BASED_VALIDATION_SHADER_PATCH_MODE_GUARDED_VALIDATION + GuardedValidation = 3, + /// + /// NUM_D3D12_GPU_BASED_VALIDATION_SHADER_PATCH_MODES + NUM_D3D12_GPU_BASED_VALIDATION_SHADER_PATCH_MODES = 4, +} + +/// +/// D3D12_GPU_BASED_VALIDATION_PIPELINE_STATE_CREATE_FLAGS +[Flags] +public enum GpuBasedValidationPipelineStateCreateFlags : int +{ + None = 0, + /// + /// D3D12_GPU_BASED_VALIDATION_PIPELINE_STATE_CREATE_FLAG_NONE + D3D12_GPU_BASED_VALIDATION_PIPELINE_STATE_CREATE_FLAG_NONE = 0, + /// + /// D3D12_GPU_BASED_VALIDATION_PIPELINE_STATE_CREATE_FLAG_FRONT_LOAD_CREATE_TRACKING_ONLY_SHADERS + D3D12_GPU_BASED_VALIDATION_PIPELINE_STATE_CREATE_FLAG_FRONT_LOAD_CREATE_TRACKING_ONLY_SHADERS = 1, + /// + /// D3D12_GPU_BASED_VALIDATION_PIPELINE_STATE_CREATE_FLAG_FRONT_LOAD_CREATE_UNGUARDED_VALIDATION_SHADERS + D3D12_GPU_BASED_VALIDATION_PIPELINE_STATE_CREATE_FLAG_FRONT_LOAD_CREATE_UNGUARDED_VALIDATION_SHADERS = 2, + /// + /// D3D12_GPU_BASED_VALIDATION_PIPELINE_STATE_CREATE_FLAG_FRONT_LOAD_CREATE_GUARDED_VALIDATION_SHADERS + D3D12_GPU_BASED_VALIDATION_PIPELINE_STATE_CREATE_FLAG_FRONT_LOAD_CREATE_GUARDED_VALIDATION_SHADERS = 4, + /// + /// D3D12_GPU_BASED_VALIDATION_PIPELINE_STATE_CREATE_FLAGS_VALID_MASK + ValidMask = 7, +} + +/// +/// D3D12_DEBUG_COMMAND_LIST_PARAMETER_TYPE +public enum DebugCommandListParameterType : int +{ + /// + /// D3D12_DEBUG_COMMAND_LIST_PARAMETER_GPU_BASED_VALIDATION_SETTINGS + D3D12_DEBUG_COMMAND_LIST_PARAMETER_GPU_BASED_VALIDATION_SETTINGS = 0, +} + +/// +/// D3D12_MESSAGE_CATEGORY +public enum MessageCategory : int +{ + /// + /// D3D12_MESSAGE_CATEGORY_APPLICATION_DEFINED + ApplicationDefined = 0, + /// + /// D3D12_MESSAGE_CATEGORY_MISCELLANEOUS + Miscellaneous = 1, + /// + /// D3D12_MESSAGE_CATEGORY_INITIALIZATION + Initialization = 2, + /// + /// D3D12_MESSAGE_CATEGORY_CLEANUP + Cleanup = 3, + /// + /// D3D12_MESSAGE_CATEGORY_COMPILATION + Compilation = 4, + /// + /// D3D12_MESSAGE_CATEGORY_STATE_CREATION + StateCreation = 5, + /// + /// D3D12_MESSAGE_CATEGORY_STATE_SETTING + StateSetting = 6, + /// + /// D3D12_MESSAGE_CATEGORY_STATE_GETTING + StateGetting = 7, + /// + /// D3D12_MESSAGE_CATEGORY_RESOURCE_MANIPULATION + ResourceManipulation = 8, + /// + /// D3D12_MESSAGE_CATEGORY_EXECUTION + Execution = 9, + /// + /// D3D12_MESSAGE_CATEGORY_SHADER + Shader = 10, +} + +/// +/// D3D12_MESSAGE_SEVERITY +public enum MessageSeverity : int +{ + /// + /// D3D12_MESSAGE_SEVERITY_CORRUPTION + Corruption = 0, + /// + /// D3D12_MESSAGE_SEVERITY_ERROR + Error = 1, + /// + /// D3D12_MESSAGE_SEVERITY_WARNING + Warning = 2, + /// + /// D3D12_MESSAGE_SEVERITY_INFO + Info = 3, + /// + /// D3D12_MESSAGE_SEVERITY_MESSAGE + Message = 4, +} + +/// +/// D3D12_MESSAGE_ID +public enum MessageId : int +{ + /// + /// D3D12_MESSAGE_ID_UNKNOWN + Unknown = 0, + /// + /// D3D12_MESSAGE_ID_STRING_FROM_APPLICATION + StringFromApplication = 1, + /// + /// D3D12_MESSAGE_ID_CORRUPTED_THIS + CorruptedThis = 2, + /// + /// D3D12_MESSAGE_ID_CORRUPTED_PARAMETER1 + CorruptedParameter1 = 3, + /// + /// D3D12_MESSAGE_ID_CORRUPTED_PARAMETER2 + CorruptedParameter2 = 4, + /// + /// D3D12_MESSAGE_ID_CORRUPTED_PARAMETER3 + CorruptedParameter3 = 5, + /// + /// D3D12_MESSAGE_ID_CORRUPTED_PARAMETER4 + CorruptedParameter4 = 6, + /// + /// D3D12_MESSAGE_ID_CORRUPTED_PARAMETER5 + CorruptedParameter5 = 7, + /// + /// D3D12_MESSAGE_ID_CORRUPTED_PARAMETER6 + CorruptedParameter6 = 8, + /// + /// D3D12_MESSAGE_ID_CORRUPTED_PARAMETER7 + CorruptedParameter7 = 9, + /// + /// D3D12_MESSAGE_ID_CORRUPTED_PARAMETER8 + CorruptedParameter8 = 10, + /// + /// D3D12_MESSAGE_ID_CORRUPTED_PARAMETER9 + CorruptedParameter9 = 11, + /// + /// D3D12_MESSAGE_ID_CORRUPTED_PARAMETER10 + CorruptedParameter10 = 12, + /// + /// D3D12_MESSAGE_ID_CORRUPTED_PARAMETER11 + CorruptedParameter11 = 13, + /// + /// D3D12_MESSAGE_ID_CORRUPTED_PARAMETER12 + CorruptedParameter12 = 14, + /// + /// D3D12_MESSAGE_ID_CORRUPTED_PARAMETER13 + CorruptedParameter13 = 15, + /// + /// D3D12_MESSAGE_ID_CORRUPTED_PARAMETER14 + CorruptedParameter14 = 16, + /// + /// D3D12_MESSAGE_ID_CORRUPTED_PARAMETER15 + CorruptedParameter15 = 17, + /// + /// D3D12_MESSAGE_ID_CORRUPTED_MULTITHREADING + CorruptedMultithreading = 18, + /// + /// D3D12_MESSAGE_ID_MESSAGE_REPORTING_OUTOFMEMORY + MessageReportingOutofmemory = 19, + /// + /// D3D12_MESSAGE_ID_GETPRIVATEDATA_MOREDATA + GetprivatedataMoredata = 20, + /// + /// D3D12_MESSAGE_ID_SETPRIVATEDATA_INVALIDFREEDATA + SetprivatedataInvalidfreedata = 21, + /// + /// D3D12_MESSAGE_ID_SETPRIVATEDATA_CHANGINGPARAMS + SetprivatedataChangingparams = 24, + /// + /// D3D12_MESSAGE_ID_SETPRIVATEDATA_OUTOFMEMORY + SetprivatedataOutofmemory = 25, + /// + /// D3D12_MESSAGE_ID_CREATESHADERRESOURCEVIEW_UNRECOGNIZEDFORMAT + CreateshaderresourceviewUnrecognizedformat = 26, + /// + /// D3D12_MESSAGE_ID_CREATESHADERRESOURCEVIEW_INVALIDDESC + CreateshaderresourceviewInvaliddesc = 27, + /// + /// D3D12_MESSAGE_ID_CREATESHADERRESOURCEVIEW_INVALIDFORMAT + CreateshaderresourceviewInvalidformat = 28, + /// + /// D3D12_MESSAGE_ID_CREATESHADERRESOURCEVIEW_INVALIDVIDEOPLANESLICE + CreateshaderresourceviewInvalidvideoplaneslice = 29, + /// + /// D3D12_MESSAGE_ID_CREATESHADERRESOURCEVIEW_INVALIDPLANESLICE + CreateshaderresourceviewInvalidplaneslice = 30, + /// + /// D3D12_MESSAGE_ID_CREATESHADERRESOURCEVIEW_INVALIDDIMENSIONS + CreateshaderresourceviewInvaliddimensions = 31, + /// + /// D3D12_MESSAGE_ID_CREATESHADERRESOURCEVIEW_INVALIDRESOURCE + CreateshaderresourceviewInvalidresource = 32, + /// + /// D3D12_MESSAGE_ID_CREATERENDERTARGETVIEW_UNRECOGNIZEDFORMAT + CreaterendertargetviewUnrecognizedformat = 35, + /// + /// D3D12_MESSAGE_ID_CREATERENDERTARGETVIEW_UNSUPPORTEDFORMAT + CreaterendertargetviewUnsupportedformat = 36, + /// + /// D3D12_MESSAGE_ID_CREATERENDERTARGETVIEW_INVALIDDESC + CreaterendertargetviewInvaliddesc = 37, + /// + /// D3D12_MESSAGE_ID_CREATERENDERTARGETVIEW_INVALIDFORMAT + CreaterendertargetviewInvalidformat = 38, + /// + /// D3D12_MESSAGE_ID_CREATERENDERTARGETVIEW_INVALIDVIDEOPLANESLICE + CreaterendertargetviewInvalidvideoplaneslice = 39, + /// + /// D3D12_MESSAGE_ID_CREATERENDERTARGETVIEW_INVALIDPLANESLICE + CreaterendertargetviewInvalidplaneslice = 40, + /// + /// D3D12_MESSAGE_ID_CREATERENDERTARGETVIEW_INVALIDDIMENSIONS + CreaterendertargetviewInvaliddimensions = 41, + /// + /// D3D12_MESSAGE_ID_CREATERENDERTARGETVIEW_INVALIDRESOURCE + CreaterendertargetviewInvalidresource = 42, + /// + /// D3D12_MESSAGE_ID_CREATEDEPTHSTENCILVIEW_UNRECOGNIZEDFORMAT + CreatedepthstencilviewUnrecognizedformat = 45, + /// + /// D3D12_MESSAGE_ID_CREATEDEPTHSTENCILVIEW_INVALIDDESC + CreatedepthstencilviewInvaliddesc = 46, + /// + /// D3D12_MESSAGE_ID_CREATEDEPTHSTENCILVIEW_INVALIDFORMAT + CreatedepthstencilviewInvalidformat = 47, + /// + /// D3D12_MESSAGE_ID_CREATEDEPTHSTENCILVIEW_INVALIDDIMENSIONS + CreatedepthstencilviewInvaliddimensions = 48, + /// + /// D3D12_MESSAGE_ID_CREATEDEPTHSTENCILVIEW_INVALIDRESOURCE + CreatedepthstencilviewInvalidresource = 49, + /// + /// D3D12_MESSAGE_ID_CREATEINPUTLAYOUT_OUTOFMEMORY + CreateinputlayoutOutofmemory = 52, + /// + /// D3D12_MESSAGE_ID_CREATEINPUTLAYOUT_TOOMANYELEMENTS + CreateinputlayoutToomanyelements = 53, + /// + /// D3D12_MESSAGE_ID_CREATEINPUTLAYOUT_INVALIDFORMAT + CreateinputlayoutInvalidformat = 54, + /// + /// D3D12_MESSAGE_ID_CREATEINPUTLAYOUT_INCOMPATIBLEFORMAT + CreateinputlayoutIncompatibleformat = 55, + /// + /// D3D12_MESSAGE_ID_CREATEINPUTLAYOUT_INVALIDSLOT + CreateinputlayoutInvalidslot = 56, + /// + /// D3D12_MESSAGE_ID_CREATEINPUTLAYOUT_INVALIDINPUTSLOTCLASS + CreateinputlayoutInvalidinputslotclass = 57, + /// + /// D3D12_MESSAGE_ID_CREATEINPUTLAYOUT_STEPRATESLOTCLASSMISMATCH + CreateinputlayoutSteprateslotclassmismatch = 58, + /// + /// D3D12_MESSAGE_ID_CREATEINPUTLAYOUT_INVALIDSLOTCLASSCHANGE + CreateinputlayoutInvalidslotclasschange = 59, + /// + /// D3D12_MESSAGE_ID_CREATEINPUTLAYOUT_INVALIDSTEPRATECHANGE + CreateinputlayoutInvalidstepratechange = 60, + /// + /// D3D12_MESSAGE_ID_CREATEINPUTLAYOUT_INVALIDALIGNMENT + CreateinputlayoutInvalidalignment = 61, + /// + /// D3D12_MESSAGE_ID_CREATEINPUTLAYOUT_DUPLICATESEMANTIC + CreateinputlayoutDuplicatesemantic = 62, + /// + /// D3D12_MESSAGE_ID_CREATEINPUTLAYOUT_UNPARSEABLEINPUTSIGNATURE + CreateinputlayoutUnparseableinputsignature = 63, + /// + /// D3D12_MESSAGE_ID_CREATEINPUTLAYOUT_NULLSEMANTIC + CreateinputlayoutNullsemantic = 64, + /// + /// D3D12_MESSAGE_ID_CREATEINPUTLAYOUT_MISSINGELEMENT + CreateinputlayoutMissingelement = 65, + /// + /// D3D12_MESSAGE_ID_CREATEVERTEXSHADER_OUTOFMEMORY + CreatevertexshaderOutofmemory = 66, + /// + /// D3D12_MESSAGE_ID_CREATEVERTEXSHADER_INVALIDSHADERBYTECODE + CreatevertexshaderInvalidshaderbytecode = 67, + /// + /// D3D12_MESSAGE_ID_CREATEVERTEXSHADER_INVALIDSHADERTYPE + CreatevertexshaderInvalidshadertype = 68, + /// + /// D3D12_MESSAGE_ID_CREATEGEOMETRYSHADER_OUTOFMEMORY + CreategeometryshaderOutofmemory = 69, + /// + /// D3D12_MESSAGE_ID_CREATEGEOMETRYSHADER_INVALIDSHADERBYTECODE + CreategeometryshaderInvalidshaderbytecode = 70, + /// + /// D3D12_MESSAGE_ID_CREATEGEOMETRYSHADER_INVALIDSHADERTYPE + CreategeometryshaderInvalidshadertype = 71, + /// + /// D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_OUTOFMEMORY + CreategeometryshaderwithstreamoutputOutofmemory = 72, + /// + /// D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_INVALIDSHADERBYTECODE + CreategeometryshaderwithstreamoutputInvalidshaderbytecode = 73, + /// + /// D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_INVALIDSHADERTYPE + CreategeometryshaderwithstreamoutputInvalidshadertype = 74, + /// + /// D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_INVALIDNUMENTRIES + CreategeometryshaderwithstreamoutputInvalidnumentries = 75, + /// + /// D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_OUTPUTSTREAMSTRIDEUNUSED + CreategeometryshaderwithstreamoutputOutputstreamstrideunused = 76, + /// + /// D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_OUTPUTSLOT0EXPECTED + CreategeometryshaderwithstreamoutputOutputslot0expected = 79, + /// + /// D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_INVALIDOUTPUTSLOT + CreategeometryshaderwithstreamoutputInvalidoutputslot = 80, + /// + /// D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_ONLYONEELEMENTPERSLOT + CreategeometryshaderwithstreamoutputOnlyoneelementperslot = 81, + /// + /// D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_INVALIDCOMPONENTCOUNT + CreategeometryshaderwithstreamoutputInvalidcomponentcount = 82, + /// + /// D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_INVALIDSTARTCOMPONENTANDCOMPONENTCOUNT + CreategeometryshaderwithstreamoutputInvalidstartcomponentandcomponentcount = 83, + /// + /// D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_INVALIDGAPDEFINITION + CreategeometryshaderwithstreamoutputInvalidgapdefinition = 84, + /// + /// D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_REPEATEDOUTPUT + CreategeometryshaderwithstreamoutputRepeatedoutput = 85, + /// + /// D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_INVALIDOUTPUTSTREAMSTRIDE + CreategeometryshaderwithstreamoutputInvalidoutputstreamstride = 86, + /// + /// D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_MISSINGSEMANTIC + CreategeometryshaderwithstreamoutputMissingsemantic = 87, + /// + /// D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_MASKMISMATCH + CreategeometryshaderwithstreamoutputMaskmismatch = 88, + /// + /// D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_CANTHAVEONLYGAPS + CreategeometryshaderwithstreamoutputCanthaveonlygaps = 89, + /// + /// D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_DECLTOOCOMPLEX + CreategeometryshaderwithstreamoutputDecltoocomplex = 90, + /// + /// D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_MISSINGOUTPUTSIGNATURE + CreategeometryshaderwithstreamoutputMissingoutputsignature = 91, + /// + /// D3D12_MESSAGE_ID_CREATEPIXELSHADER_OUTOFMEMORY + CreatepixelshaderOutofmemory = 92, + /// + /// D3D12_MESSAGE_ID_CREATEPIXELSHADER_INVALIDSHADERBYTECODE + CreatepixelshaderInvalidshaderbytecode = 93, + /// + /// D3D12_MESSAGE_ID_CREATEPIXELSHADER_INVALIDSHADERTYPE + CreatepixelshaderInvalidshadertype = 94, + /// + /// D3D12_MESSAGE_ID_CREATERASTERIZERSTATE_INVALIDFILLMODE + CreaterasterizerstateInvalidfillmode = 95, + /// + /// D3D12_MESSAGE_ID_CREATERASTERIZERSTATE_INVALIDCULLMODE + CreaterasterizerstateInvalidcullmode = 96, + /// + /// D3D12_MESSAGE_ID_CREATERASTERIZERSTATE_INVALIDDEPTHBIASCLAMP + CreaterasterizerstateInvaliddepthbiasclamp = 97, + /// + /// D3D12_MESSAGE_ID_CREATERASTERIZERSTATE_INVALIDSLOPESCALEDDEPTHBIAS + CreaterasterizerstateInvalidslopescaleddepthbias = 98, + /// + /// D3D12_MESSAGE_ID_CREATEDEPTHSTENCILSTATE_INVALIDDEPTHWRITEMASK + CreatedepthstencilstateInvaliddepthwritemask = 100, + /// + /// D3D12_MESSAGE_ID_CREATEDEPTHSTENCILSTATE_INVALIDDEPTHFUNC + CreatedepthstencilstateInvaliddepthfunc = 101, + /// + /// D3D12_MESSAGE_ID_CREATEDEPTHSTENCILSTATE_INVALIDFRONTFACESTENCILFAILOP + CreatedepthstencilstateInvalidfrontfacestencilfailop = 102, + /// + /// D3D12_MESSAGE_ID_CREATEDEPTHSTENCILSTATE_INVALIDFRONTFACESTENCILZFAILOP + CreatedepthstencilstateInvalidfrontfacestencilzfailop = 103, + /// + /// D3D12_MESSAGE_ID_CREATEDEPTHSTENCILSTATE_INVALIDFRONTFACESTENCILPASSOP + CreatedepthstencilstateInvalidfrontfacestencilpassop = 104, + /// + /// D3D12_MESSAGE_ID_CREATEDEPTHSTENCILSTATE_INVALIDFRONTFACESTENCILFUNC + CreatedepthstencilstateInvalidfrontfacestencilfunc = 105, + /// + /// D3D12_MESSAGE_ID_CREATEDEPTHSTENCILSTATE_INVALIDBACKFACESTENCILFAILOP + CreatedepthstencilstateInvalidbackfacestencilfailop = 106, + /// + /// D3D12_MESSAGE_ID_CREATEDEPTHSTENCILSTATE_INVALIDBACKFACESTENCILZFAILOP + CreatedepthstencilstateInvalidbackfacestencilzfailop = 107, + /// + /// D3D12_MESSAGE_ID_CREATEDEPTHSTENCILSTATE_INVALIDBACKFACESTENCILPASSOP + CreatedepthstencilstateInvalidbackfacestencilpassop = 108, + /// + /// D3D12_MESSAGE_ID_CREATEDEPTHSTENCILSTATE_INVALIDBACKFACESTENCILFUNC + CreatedepthstencilstateInvalidbackfacestencilfunc = 109, + /// + /// D3D12_MESSAGE_ID_CREATEBLENDSTATE_INVALIDSRCBLEND + CreateblendstateInvalidsrcblend = 111, + /// + /// D3D12_MESSAGE_ID_CREATEBLENDSTATE_INVALIDDESTBLEND + CreateblendstateInvaliddestblend = 112, + /// + /// D3D12_MESSAGE_ID_CREATEBLENDSTATE_INVALIDBLENDOP + CreateblendstateInvalidblendop = 113, + /// + /// D3D12_MESSAGE_ID_CREATEBLENDSTATE_INVALIDSRCBLENDALPHA + CreateblendstateInvalidsrcblendalpha = 114, + /// + /// D3D12_MESSAGE_ID_CREATEBLENDSTATE_INVALIDDESTBLENDALPHA + CreateblendstateInvaliddestblendalpha = 115, + /// + /// D3D12_MESSAGE_ID_CREATEBLENDSTATE_INVALIDBLENDOPALPHA + CreateblendstateInvalidblendopalpha = 116, + /// + /// D3D12_MESSAGE_ID_CREATEBLENDSTATE_INVALIDRENDERTARGETWRITEMASK + CreateblendstateInvalidrendertargetwritemask = 117, + /// + /// D3D12_MESSAGE_ID_CLEARDEPTHSTENCILVIEW_INVALID + CleardepthstencilviewInvalid = 135, + /// + /// D3D12_MESSAGE_ID_COMMAND_LIST_DRAW_ROOT_SIGNATURE_NOT_SET + CommandListDrawRootSignatureNotSet = 200, + /// + /// D3D12_MESSAGE_ID_COMMAND_LIST_DRAW_ROOT_SIGNATURE_MISMATCH + CommandListDrawRootSignatureMismatch = 201, + /// + /// D3D12_MESSAGE_ID_COMMAND_LIST_DRAW_VERTEX_BUFFER_NOT_SET + CommandListDrawVertexBufferNotSet = 202, + /// + /// D3D12_MESSAGE_ID_COMMAND_LIST_DRAW_VERTEX_BUFFER_STRIDE_TOO_SMALL + CommandListDrawVertexBufferStrideTooSmall = 209, + /// + /// D3D12_MESSAGE_ID_COMMAND_LIST_DRAW_VERTEX_BUFFER_TOO_SMALL + CommandListDrawVertexBufferTooSmall = 210, + /// + /// D3D12_MESSAGE_ID_COMMAND_LIST_DRAW_INDEX_BUFFER_NOT_SET + CommandListDrawIndexBufferNotSet = 211, + /// + /// D3D12_MESSAGE_ID_COMMAND_LIST_DRAW_INDEX_BUFFER_FORMAT_INVALID + CommandListDrawIndexBufferFormatInvalid = 212, + /// + /// D3D12_MESSAGE_ID_COMMAND_LIST_DRAW_INDEX_BUFFER_TOO_SMALL + CommandListDrawIndexBufferTooSmall = 213, + /// + /// D3D12_MESSAGE_ID_COMMAND_LIST_DRAW_INVALID_PRIMITIVETOPOLOGY + CommandListDrawInvalidPrimitivetopology = 219, + /// + /// D3D12_MESSAGE_ID_COMMAND_LIST_DRAW_VERTEX_STRIDE_UNALIGNED + CommandListDrawVertexStrideUnaligned = 221, + /// + /// D3D12_MESSAGE_ID_COMMAND_LIST_DRAW_INDEX_OFFSET_UNALIGNED + CommandListDrawIndexOffsetUnaligned = 222, + /// + /// D3D12_MESSAGE_ID_DEVICE_REMOVAL_PROCESS_AT_FAULT + DeviceRemovalProcessAtFault = 232, + /// + /// D3D12_MESSAGE_ID_DEVICE_REMOVAL_PROCESS_POSSIBLY_AT_FAULT + DeviceRemovalProcessPossiblyAtFault = 233, + /// + /// D3D12_MESSAGE_ID_DEVICE_REMOVAL_PROCESS_NOT_AT_FAULT + DeviceRemovalProcessNotAtFault = 234, + /// + /// D3D12_MESSAGE_ID_CREATEINPUTLAYOUT_TRAILING_DIGIT_IN_SEMANTIC + CreateinputlayoutTrailingDigitInSemantic = 239, + /// + /// D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_TRAILING_DIGIT_IN_SEMANTIC + CreategeometryshaderwithstreamoutputTrailingDigitInSemantic = 240, + /// + /// D3D12_MESSAGE_ID_CREATEINPUTLAYOUT_TYPE_MISMATCH + CreateinputlayoutTypeMismatch = 245, + /// + /// D3D12_MESSAGE_ID_CREATEINPUTLAYOUT_EMPTY_LAYOUT + CreateinputlayoutEmptyLayout = 253, + /// + /// D3D12_MESSAGE_ID_LIVE_OBJECT_SUMMARY + LiveObjectSummary = 255, + /// + /// D3D12_MESSAGE_ID_LIVE_DEVICE + LiveDevice = 274, + /// + /// D3D12_MESSAGE_ID_LIVE_SWAPCHAIN + LiveSwapchain = 275, + /// + /// D3D12_MESSAGE_ID_CREATEDEPTHSTENCILVIEW_INVALIDFLAGS + CreatedepthstencilviewInvalidflags = 276, + /// + /// D3D12_MESSAGE_ID_CREATEVERTEXSHADER_INVALIDCLASSLINKAGE + CreatevertexshaderInvalidclasslinkage = 277, + /// + /// D3D12_MESSAGE_ID_CREATEGEOMETRYSHADER_INVALIDCLASSLINKAGE + CreategeometryshaderInvalidclasslinkage = 278, + /// + /// D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_INVALIDSTREAMTORASTERIZER + CreategeometryshaderwithstreamoutputInvalidstreamtorasterizer = 280, + /// + /// D3D12_MESSAGE_ID_CREATEPIXELSHADER_INVALIDCLASSLINKAGE + CreatepixelshaderInvalidclasslinkage = 283, + /// + /// D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_INVALIDSTREAM + CreategeometryshaderwithstreamoutputInvalidstream = 284, + /// + /// D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_UNEXPECTEDENTRIES + CreategeometryshaderwithstreamoutputUnexpectedentries = 285, + /// + /// D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_UNEXPECTEDSTRIDES + CreategeometryshaderwithstreamoutputUnexpectedstrides = 286, + /// + /// D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_INVALIDNUMSTRIDES + CreategeometryshaderwithstreamoutputInvalidnumstrides = 287, + /// + /// D3D12_MESSAGE_ID_CREATEHULLSHADER_OUTOFMEMORY + CreatehullshaderOutofmemory = 289, + /// + /// D3D12_MESSAGE_ID_CREATEHULLSHADER_INVALIDSHADERBYTECODE + CreatehullshaderInvalidshaderbytecode = 290, + /// + /// D3D12_MESSAGE_ID_CREATEHULLSHADER_INVALIDSHADERTYPE + CreatehullshaderInvalidshadertype = 291, + /// + /// D3D12_MESSAGE_ID_CREATEHULLSHADER_INVALIDCLASSLINKAGE + CreatehullshaderInvalidclasslinkage = 292, + /// + /// D3D12_MESSAGE_ID_CREATEDOMAINSHADER_OUTOFMEMORY + CreatedomainshaderOutofmemory = 294, + /// + /// D3D12_MESSAGE_ID_CREATEDOMAINSHADER_INVALIDSHADERBYTECODE + CreatedomainshaderInvalidshaderbytecode = 295, + /// + /// D3D12_MESSAGE_ID_CREATEDOMAINSHADER_INVALIDSHADERTYPE + CreatedomainshaderInvalidshadertype = 296, + /// + /// D3D12_MESSAGE_ID_CREATEDOMAINSHADER_INVALIDCLASSLINKAGE + CreatedomainshaderInvalidclasslinkage = 297, + /// + /// D3D12_MESSAGE_ID_RESOURCE_UNMAP_NOTMAPPED + ResourceUnmapNotmapped = 310, + /// + /// D3D12_MESSAGE_ID_DEVICE_CHECKFEATURESUPPORT_MISMATCHED_DATA_SIZE + DeviceCheckfeaturesupportMismatchedDataSize = 318, + /// + /// D3D12_MESSAGE_ID_CREATECOMPUTESHADER_OUTOFMEMORY + CreatecomputeshaderOutofmemory = 321, + /// + /// D3D12_MESSAGE_ID_CREATECOMPUTESHADER_INVALIDSHADERBYTECODE + CreatecomputeshaderInvalidshaderbytecode = 322, + /// + /// D3D12_MESSAGE_ID_CREATECOMPUTESHADER_INVALIDCLASSLINKAGE + CreatecomputeshaderInvalidclasslinkage = 323, + /// + /// D3D12_MESSAGE_ID_DEVICE_CREATEVERTEXSHADER_DOUBLEFLOATOPSNOTSUPPORTED + DeviceCreatevertexshaderDoublefloatopsnotsupported = 331, + /// + /// D3D12_MESSAGE_ID_DEVICE_CREATEHULLSHADER_DOUBLEFLOATOPSNOTSUPPORTED + DeviceCreatehullshaderDoublefloatopsnotsupported = 332, + /// + /// D3D12_MESSAGE_ID_DEVICE_CREATEDOMAINSHADER_DOUBLEFLOATOPSNOTSUPPORTED + DeviceCreatedomainshaderDoublefloatopsnotsupported = 333, + /// + /// D3D12_MESSAGE_ID_DEVICE_CREATEGEOMETRYSHADER_DOUBLEFLOATOPSNOTSUPPORTED + DeviceCreategeometryshaderDoublefloatopsnotsupported = 334, + /// + /// D3D12_MESSAGE_ID_DEVICE_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_DOUBLEFLOATOPSNOTSUPPORTED + DeviceCreategeometryshaderwithstreamoutputDoublefloatopsnotsupported = 335, + /// + /// D3D12_MESSAGE_ID_DEVICE_CREATEPIXELSHADER_DOUBLEFLOATOPSNOTSUPPORTED + DeviceCreatepixelshaderDoublefloatopsnotsupported = 336, + /// + /// D3D12_MESSAGE_ID_DEVICE_CREATECOMPUTESHADER_DOUBLEFLOATOPSNOTSUPPORTED + DeviceCreatecomputeshaderDoublefloatopsnotsupported = 337, + /// + /// D3D12_MESSAGE_ID_CREATEUNORDEREDACCESSVIEW_INVALIDRESOURCE + CreateunorderedaccessviewInvalidresource = 340, + /// + /// D3D12_MESSAGE_ID_CREATEUNORDEREDACCESSVIEW_INVALIDDESC + CreateunorderedaccessviewInvaliddesc = 341, + /// + /// D3D12_MESSAGE_ID_CREATEUNORDEREDACCESSVIEW_INVALIDFORMAT + CreateunorderedaccessviewInvalidformat = 342, + /// + /// D3D12_MESSAGE_ID_CREATEUNORDEREDACCESSVIEW_INVALIDVIDEOPLANESLICE + CreateunorderedaccessviewInvalidvideoplaneslice = 343, + /// + /// D3D12_MESSAGE_ID_CREATEUNORDEREDACCESSVIEW_INVALIDPLANESLICE + CreateunorderedaccessviewInvalidplaneslice = 344, + /// + /// D3D12_MESSAGE_ID_CREATEUNORDEREDACCESSVIEW_INVALIDDIMENSIONS + CreateunorderedaccessviewInvaliddimensions = 345, + /// + /// D3D12_MESSAGE_ID_CREATEUNORDEREDACCESSVIEW_UNRECOGNIZEDFORMAT + CreateunorderedaccessviewUnrecognizedformat = 346, + /// + /// D3D12_MESSAGE_ID_CREATEUNORDEREDACCESSVIEW_INVALIDFLAGS + CreateunorderedaccessviewInvalidflags = 354, + /// + /// D3D12_MESSAGE_ID_CREATERASTERIZERSTATE_INVALIDFORCEDSAMPLECOUNT + CreaterasterizerstateInvalidforcedsamplecount = 401, + /// + /// D3D12_MESSAGE_ID_CREATEBLENDSTATE_INVALIDLOGICOPS + CreateblendstateInvalidlogicops = 403, + /// + /// D3D12_MESSAGE_ID_DEVICE_CREATEVERTEXSHADER_DOUBLEEXTENSIONSNOTSUPPORTED + DeviceCreatevertexshaderDoubleextensionsnotsupported = 410, + /// + /// D3D12_MESSAGE_ID_DEVICE_CREATEHULLSHADER_DOUBLEEXTENSIONSNOTSUPPORTED + DeviceCreatehullshaderDoubleextensionsnotsupported = 412, + /// + /// D3D12_MESSAGE_ID_DEVICE_CREATEDOMAINSHADER_DOUBLEEXTENSIONSNOTSUPPORTED + DeviceCreatedomainshaderDoubleextensionsnotsupported = 414, + /// + /// D3D12_MESSAGE_ID_DEVICE_CREATEGEOMETRYSHADER_DOUBLEEXTENSIONSNOTSUPPORTED + DeviceCreategeometryshaderDoubleextensionsnotsupported = 416, + /// + /// D3D12_MESSAGE_ID_DEVICE_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_DOUBLEEXTENSIONSNOTSUPPORTED + DeviceCreategeometryshaderwithstreamoutputDoubleextensionsnotsupported = 418, + /// + /// D3D12_MESSAGE_ID_DEVICE_CREATEPIXELSHADER_DOUBLEEXTENSIONSNOTSUPPORTED + DeviceCreatepixelshaderDoubleextensionsnotsupported = 420, + /// + /// D3D12_MESSAGE_ID_DEVICE_CREATECOMPUTESHADER_DOUBLEEXTENSIONSNOTSUPPORTED + DeviceCreatecomputeshaderDoubleextensionsnotsupported = 422, + /// + /// D3D12_MESSAGE_ID_DEVICE_CREATEVERTEXSHADER_UAVSNOTSUPPORTED + DeviceCreatevertexshaderUavsnotsupported = 425, + /// + /// D3D12_MESSAGE_ID_DEVICE_CREATEHULLSHADER_UAVSNOTSUPPORTED + DeviceCreatehullshaderUavsnotsupported = 426, + /// + /// D3D12_MESSAGE_ID_DEVICE_CREATEDOMAINSHADER_UAVSNOTSUPPORTED + DeviceCreatedomainshaderUavsnotsupported = 427, + /// + /// D3D12_MESSAGE_ID_DEVICE_CREATEGEOMETRYSHADER_UAVSNOTSUPPORTED + DeviceCreategeometryshaderUavsnotsupported = 428, + /// + /// D3D12_MESSAGE_ID_DEVICE_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_UAVSNOTSUPPORTED + DeviceCreategeometryshaderwithstreamoutputUavsnotsupported = 429, + /// + /// D3D12_MESSAGE_ID_DEVICE_CREATEPIXELSHADER_UAVSNOTSUPPORTED + DeviceCreatepixelshaderUavsnotsupported = 430, + /// + /// D3D12_MESSAGE_ID_DEVICE_CREATECOMPUTESHADER_UAVSNOTSUPPORTED + DeviceCreatecomputeshaderUavsnotsupported = 431, + /// + /// D3D12_MESSAGE_ID_DEVICE_CLEARVIEW_INVALIDSOURCERECT + DeviceClearviewInvalidsourcerect = 447, + /// + /// D3D12_MESSAGE_ID_DEVICE_CLEARVIEW_EMPTYRECT + DeviceClearviewEmptyrect = 448, + /// + /// D3D12_MESSAGE_ID_UPDATETILEMAPPINGS_INVALID_PARAMETER + UpdatetilemappingsInvalidParameter = 493, + /// + /// D3D12_MESSAGE_ID_COPYTILEMAPPINGS_INVALID_PARAMETER + CopytilemappingsInvalidParameter = 494, + /// + /// D3D12_MESSAGE_ID_CREATEDEVICE_INVALIDARGS + CreatedeviceInvalidargs = 506, + /// + /// D3D12_MESSAGE_ID_CREATEDEVICE_WARNING + CreatedeviceWarning = 507, + /// + /// D3D12_MESSAGE_ID_RESOURCE_BARRIER_INVALID_TYPE + ResourceBarrierInvalidType = 519, + /// + /// D3D12_MESSAGE_ID_RESOURCE_BARRIER_NULL_POINTER + ResourceBarrierNullPointer = 520, + /// + /// D3D12_MESSAGE_ID_RESOURCE_BARRIER_INVALID_SUBRESOURCE + ResourceBarrierInvalidSubresource = 521, + /// + /// D3D12_MESSAGE_ID_RESOURCE_BARRIER_RESERVED_BITS + ResourceBarrierReservedBits = 522, + /// + /// D3D12_MESSAGE_ID_RESOURCE_BARRIER_MISSING_BIND_FLAGS + ResourceBarrierMissingBindFlags = 523, + /// + /// D3D12_MESSAGE_ID_RESOURCE_BARRIER_MISMATCHING_MISC_FLAGS + ResourceBarrierMismatchingMiscFlags = 524, + /// + /// D3D12_MESSAGE_ID_RESOURCE_BARRIER_MATCHING_STATES + ResourceBarrierMatchingStates = 525, + /// + /// D3D12_MESSAGE_ID_RESOURCE_BARRIER_INVALID_COMBINATION + ResourceBarrierInvalidCombination = 526, + /// + /// D3D12_MESSAGE_ID_RESOURCE_BARRIER_BEFORE_AFTER_MISMATCH + ResourceBarrierBeforeAfterMismatch = 527, + /// + /// D3D12_MESSAGE_ID_RESOURCE_BARRIER_INVALID_RESOURCE + ResourceBarrierInvalidResource = 528, + /// + /// D3D12_MESSAGE_ID_RESOURCE_BARRIER_SAMPLE_COUNT + ResourceBarrierSampleCount = 529, + /// + /// D3D12_MESSAGE_ID_RESOURCE_BARRIER_INVALID_FLAGS + ResourceBarrierInvalidFlags = 530, + /// + /// D3D12_MESSAGE_ID_RESOURCE_BARRIER_INVALID_COMBINED_FLAGS + ResourceBarrierInvalidCombinedFlags = 531, + /// + /// D3D12_MESSAGE_ID_RESOURCE_BARRIER_INVALID_FLAGS_FOR_FORMAT + ResourceBarrierInvalidFlagsForFormat = 532, + /// + /// D3D12_MESSAGE_ID_RESOURCE_BARRIER_INVALID_SPLIT_BARRIER + ResourceBarrierInvalidSplitBarrier = 533, + /// + /// D3D12_MESSAGE_ID_RESOURCE_BARRIER_UNMATCHED_END + ResourceBarrierUnmatchedEnd = 534, + /// + /// D3D12_MESSAGE_ID_RESOURCE_BARRIER_UNMATCHED_BEGIN + ResourceBarrierUnmatchedBegin = 535, + /// + /// D3D12_MESSAGE_ID_RESOURCE_BARRIER_INVALID_FLAG + ResourceBarrierInvalidFlag = 536, + /// + /// D3D12_MESSAGE_ID_RESOURCE_BARRIER_INVALID_COMMAND_LIST_TYPE + ResourceBarrierInvalidCommandListType = 537, + /// + /// D3D12_MESSAGE_ID_INVALID_SUBRESOURCE_STATE + InvalidSubresourceState = 538, + /// + /// D3D12_MESSAGE_ID_COMMAND_ALLOCATOR_CONTENTION + CommandAllocatorContention = 540, + /// + /// D3D12_MESSAGE_ID_COMMAND_ALLOCATOR_RESET + CommandAllocatorReset = 541, + /// + /// D3D12_MESSAGE_ID_COMMAND_ALLOCATOR_RESET_BUNDLE + CommandAllocatorResetBundle = 542, + /// + /// D3D12_MESSAGE_ID_COMMAND_ALLOCATOR_CANNOT_RESET + CommandAllocatorCannotReset = 543, + /// + /// D3D12_MESSAGE_ID_COMMAND_LIST_OPEN + CommandListOpen = 544, + /// + /// D3D12_MESSAGE_ID_INVALID_BUNDLE_API + InvalidBundleApi = 546, + /// + /// D3D12_MESSAGE_ID_COMMAND_LIST_CLOSED + CommandListClosed = 547, + /// + /// D3D12_MESSAGE_ID_WRONG_COMMAND_ALLOCATOR_TYPE + WrongCommandAllocatorType = 549, + /// + /// D3D12_MESSAGE_ID_COMMAND_ALLOCATOR_SYNC + CommandAllocatorSync = 552, + /// + /// D3D12_MESSAGE_ID_COMMAND_LIST_SYNC + CommandListSync = 553, + /// + /// D3D12_MESSAGE_ID_SET_DESCRIPTOR_HEAP_INVALID + SetDescriptorHeapInvalid = 554, + /// + /// D3D12_MESSAGE_ID_CREATE_COMMANDQUEUE + CreateCommandqueue = 557, + /// + /// D3D12_MESSAGE_ID_CREATE_COMMANDALLOCATOR + CreateCommandallocator = 558, + /// + /// D3D12_MESSAGE_ID_CREATE_PIPELINESTATE + CreatePipelinestate = 559, + /// + /// D3D12_MESSAGE_ID_CREATE_COMMANDLIST12 + CreateCommandlist12 = 560, + /// + /// D3D12_MESSAGE_ID_CREATE_RESOURCE + CreateResource = 562, + /// + /// D3D12_MESSAGE_ID_CREATE_DESCRIPTORHEAP + CreateDescriptorheap = 563, + /// + /// D3D12_MESSAGE_ID_CREATE_ROOTSIGNATURE + CreateRootsignature = 564, + /// + /// D3D12_MESSAGE_ID_CREATE_LIBRARY + CreateLibrary = 565, + /// + /// D3D12_MESSAGE_ID_CREATE_HEAP + CreateHeap = 566, + /// + /// D3D12_MESSAGE_ID_CREATE_MONITOREDFENCE + CreateMonitoredfence = 567, + /// + /// D3D12_MESSAGE_ID_CREATE_QUERYHEAP + CreateQueryheap = 568, + /// + /// D3D12_MESSAGE_ID_CREATE_COMMANDSIGNATURE + CreateCommandsignature = 569, + /// + /// D3D12_MESSAGE_ID_LIVE_COMMANDQUEUE + LiveCommandqueue = 570, + /// + /// D3D12_MESSAGE_ID_LIVE_COMMANDALLOCATOR + LiveCommandallocator = 571, + /// + /// D3D12_MESSAGE_ID_LIVE_PIPELINESTATE + LivePipelinestate = 572, + /// + /// D3D12_MESSAGE_ID_LIVE_COMMANDLIST12 + LiveCommandlist12 = 573, + /// + /// D3D12_MESSAGE_ID_LIVE_RESOURCE + LiveResource = 575, + /// + /// D3D12_MESSAGE_ID_LIVE_DESCRIPTORHEAP + LiveDescriptorheap = 576, + /// + /// D3D12_MESSAGE_ID_LIVE_ROOTSIGNATURE + LiveRootsignature = 577, + /// + /// D3D12_MESSAGE_ID_LIVE_LIBRARY + LiveLibrary = 578, + /// + /// D3D12_MESSAGE_ID_LIVE_HEAP + LiveHeap = 579, + /// + /// D3D12_MESSAGE_ID_LIVE_MONITOREDFENCE + LiveMonitoredfence = 580, + /// + /// D3D12_MESSAGE_ID_LIVE_QUERYHEAP + LiveQueryheap = 581, + /// + /// D3D12_MESSAGE_ID_LIVE_COMMANDSIGNATURE + LiveCommandsignature = 582, + /// + /// D3D12_MESSAGE_ID_DESTROY_COMMANDQUEUE + DestroyCommandqueue = 583, + /// + /// D3D12_MESSAGE_ID_DESTROY_COMMANDALLOCATOR + DestroyCommandallocator = 584, + /// + /// D3D12_MESSAGE_ID_DESTROY_PIPELINESTATE + DestroyPipelinestate = 585, + /// + /// D3D12_MESSAGE_ID_DESTROY_COMMANDLIST12 + DestroyCommandlist12 = 586, + /// + /// D3D12_MESSAGE_ID_DESTROY_RESOURCE + DestroyResource = 588, + /// + /// D3D12_MESSAGE_ID_DESTROY_DESCRIPTORHEAP + DestroyDescriptorheap = 589, + /// + /// D3D12_MESSAGE_ID_DESTROY_ROOTSIGNATURE + DestroyRootsignature = 590, + /// + /// D3D12_MESSAGE_ID_DESTROY_LIBRARY + DestroyLibrary = 591, + /// + /// D3D12_MESSAGE_ID_DESTROY_HEAP + DestroyHeap = 592, + /// + /// D3D12_MESSAGE_ID_DESTROY_MONITOREDFENCE + DestroyMonitoredfence = 593, + /// + /// D3D12_MESSAGE_ID_DESTROY_QUERYHEAP + DestroyQueryheap = 594, + /// + /// D3D12_MESSAGE_ID_DESTROY_COMMANDSIGNATURE + DestroyCommandsignature = 595, + /// + /// D3D12_MESSAGE_ID_CREATERESOURCE_INVALIDDIMENSIONS + CreateresourceInvaliddimensions = 597, + /// + /// D3D12_MESSAGE_ID_CREATERESOURCE_INVALIDMISCFLAGS + CreateresourceInvalidmiscflags = 599, + /// + /// D3D12_MESSAGE_ID_CREATERESOURCE_INVALIDARG_RETURN + CreateresourceInvalidargReturn = 602, + /// + /// D3D12_MESSAGE_ID_CREATERESOURCE_OUTOFMEMORY_RETURN + CreateresourceOutofmemoryReturn = 603, + /// + /// D3D12_MESSAGE_ID_CREATERESOURCE_INVALIDDESC + CreateresourceInvaliddesc = 604, + /// + /// D3D12_MESSAGE_ID_POSSIBLY_INVALID_SUBRESOURCE_STATE + PossiblyInvalidSubresourceState = 607, + /// + /// D3D12_MESSAGE_ID_INVALID_USE_OF_NON_RESIDENT_RESOURCE + InvalidUseOfNonResidentResource = 608, + /// + /// D3D12_MESSAGE_ID_POSSIBLE_INVALID_USE_OF_NON_RESIDENT_RESOURCE + PossibleInvalidUseOfNonResidentResource = 609, + /// + /// D3D12_MESSAGE_ID_BUNDLE_PIPELINE_STATE_MISMATCH + BundlePipelineStateMismatch = 610, + /// + /// D3D12_MESSAGE_ID_PRIMITIVE_TOPOLOGY_MISMATCH_PIPELINE_STATE + PrimitiveTopologyMismatchPipelineState = 611, + /// + /// D3D12_MESSAGE_ID_RENDER_TARGET_FORMAT_MISMATCH_PIPELINE_STATE + RenderTargetFormatMismatchPipelineState = 613, + /// + /// D3D12_MESSAGE_ID_RENDER_TARGET_SAMPLE_DESC_MISMATCH_PIPELINE_STATE + RenderTargetSampleDescMismatchPipelineState = 614, + /// + /// D3D12_MESSAGE_ID_DEPTH_STENCIL_FORMAT_MISMATCH_PIPELINE_STATE + DepthStencilFormatMismatchPipelineState = 615, + /// + /// D3D12_MESSAGE_ID_DEPTH_STENCIL_SAMPLE_DESC_MISMATCH_PIPELINE_STATE + DepthStencilSampleDescMismatchPipelineState = 616, + /// + /// D3D12_MESSAGE_ID_CREATESHADER_INVALIDBYTECODE + CreateshaderInvalidbytecode = 622, + /// + /// D3D12_MESSAGE_ID_CREATEHEAP_NULLDESC + CreateheapNulldesc = 623, + /// + /// D3D12_MESSAGE_ID_CREATEHEAP_INVALIDSIZE + CreateheapInvalidsize = 624, + /// + /// D3D12_MESSAGE_ID_CREATEHEAP_UNRECOGNIZEDHEAPTYPE + CreateheapUnrecognizedheaptype = 625, + /// + /// D3D12_MESSAGE_ID_CREATEHEAP_UNRECOGNIZEDCPUPAGEPROPERTIES + CreateheapUnrecognizedcpupageproperties = 626, + /// + /// D3D12_MESSAGE_ID_CREATEHEAP_UNRECOGNIZEDMEMORYPOOL + CreateheapUnrecognizedmemorypool = 627, + /// + /// D3D12_MESSAGE_ID_CREATEHEAP_INVALIDPROPERTIES + CreateheapInvalidproperties = 628, + /// + /// D3D12_MESSAGE_ID_CREATEHEAP_INVALIDALIGNMENT + CreateheapInvalidalignment = 629, + /// + /// D3D12_MESSAGE_ID_CREATEHEAP_UNRECOGNIZEDMISCFLAGS + CreateheapUnrecognizedmiscflags = 630, + /// + /// D3D12_MESSAGE_ID_CREATEHEAP_INVALIDMISCFLAGS + CreateheapInvalidmiscflags = 631, + /// + /// D3D12_MESSAGE_ID_CREATEHEAP_INVALIDARG_RETURN + CreateheapInvalidargReturn = 632, + /// + /// D3D12_MESSAGE_ID_CREATEHEAP_OUTOFMEMORY_RETURN + CreateheapOutofmemoryReturn = 633, + /// + /// D3D12_MESSAGE_ID_CREATERESOURCEANDHEAP_NULLHEAPPROPERTIES + CreateresourceandheapNullheapproperties = 634, + /// + /// D3D12_MESSAGE_ID_CREATERESOURCEANDHEAP_UNRECOGNIZEDHEAPTYPE + CreateresourceandheapUnrecognizedheaptype = 635, + /// + /// D3D12_MESSAGE_ID_CREATERESOURCEANDHEAP_UNRECOGNIZEDCPUPAGEPROPERTIES + CreateresourceandheapUnrecognizedcpupageproperties = 636, + /// + /// D3D12_MESSAGE_ID_CREATERESOURCEANDHEAP_UNRECOGNIZEDMEMORYPOOL + CreateresourceandheapUnrecognizedmemorypool = 637, + /// + /// D3D12_MESSAGE_ID_CREATERESOURCEANDHEAP_INVALIDHEAPPROPERTIES + CreateresourceandheapInvalidheapproperties = 638, + /// + /// D3D12_MESSAGE_ID_CREATERESOURCEANDHEAP_UNRECOGNIZEDHEAPMISCFLAGS + CreateresourceandheapUnrecognizedheapmiscflags = 639, + /// + /// D3D12_MESSAGE_ID_CREATERESOURCEANDHEAP_INVALIDHEAPMISCFLAGS + CreateresourceandheapInvalidheapmiscflags = 640, + /// + /// D3D12_MESSAGE_ID_CREATERESOURCEANDHEAP_INVALIDARG_RETURN + CreateresourceandheapInvalidargReturn = 641, + /// + /// D3D12_MESSAGE_ID_CREATERESOURCEANDHEAP_OUTOFMEMORY_RETURN + CreateresourceandheapOutofmemoryReturn = 642, + /// + /// D3D12_MESSAGE_ID_GETCUSTOMHEAPPROPERTIES_UNRECOGNIZEDHEAPTYPE + GetcustomheappropertiesUnrecognizedheaptype = 643, + /// + /// D3D12_MESSAGE_ID_GETCUSTOMHEAPPROPERTIES_INVALIDHEAPTYPE + GetcustomheappropertiesInvalidheaptype = 644, + /// + /// D3D12_MESSAGE_ID_CREATE_DESCRIPTOR_HEAP_INVALID_DESC + CreateDescriptorHeapInvalidDesc = 645, + /// + /// D3D12_MESSAGE_ID_INVALID_DESCRIPTOR_HANDLE + InvalidDescriptorHandle = 646, + /// + /// D3D12_MESSAGE_ID_CREATERASTERIZERSTATE_INVALID_CONSERVATIVERASTERMODE + CreaterasterizerstateInvalidConservativerastermode = 647, + /// + /// D3D12_MESSAGE_ID_CREATE_CONSTANT_BUFFER_VIEW_INVALID_RESOURCE + CreateConstantBufferViewInvalidResource = 649, + /// + /// D3D12_MESSAGE_ID_CREATE_CONSTANT_BUFFER_VIEW_INVALID_DESC + CreateConstantBufferViewInvalidDesc = 650, + /// + /// D3D12_MESSAGE_ID_CREATE_UNORDEREDACCESS_VIEW_INVALID_COUNTER_USAGE + CreateUnorderedaccessViewInvalidCounterUsage = 652, + /// + /// D3D12_MESSAGE_ID_COPY_DESCRIPTORS_INVALID_RANGES + CopyDescriptorsInvalidRanges = 653, + /// + /// D3D12_MESSAGE_ID_COPY_DESCRIPTORS_WRITE_ONLY_DESCRIPTOR + CopyDescriptorsWriteOnlyDescriptor = 654, + /// + /// D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_RTV_FORMAT_NOT_UNKNOWN + CreategraphicspipelinestateRtvFormatNotUnknown = 655, + /// + /// D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_INVALID_RENDER_TARGET_COUNT + CreategraphicspipelinestateInvalidRenderTargetCount = 656, + /// + /// D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_VERTEX_SHADER_NOT_SET + CreategraphicspipelinestateVertexShaderNotSet = 657, + /// + /// D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_INPUTLAYOUT_NOT_SET + CreategraphicspipelinestateInputlayoutNotSet = 658, + /// + /// D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_SHADER_LINKAGE_HS_DS_SIGNATURE_MISMATCH + CreategraphicspipelinestateShaderLinkageHsDsSignatureMismatch = 659, + /// + /// D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_SHADER_LINKAGE_REGISTERINDEX + CreategraphicspipelinestateShaderLinkageRegisterindex = 660, + /// + /// D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_SHADER_LINKAGE_COMPONENTTYPE + CreategraphicspipelinestateShaderLinkageComponenttype = 661, + /// + /// D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_SHADER_LINKAGE_REGISTERMASK + CreategraphicspipelinestateShaderLinkageRegistermask = 662, + /// + /// D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_SHADER_LINKAGE_SYSTEMVALUE + CreategraphicspipelinestateShaderLinkageSystemvalue = 663, + /// + /// D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_SHADER_LINKAGE_NEVERWRITTEN_ALWAYSREADS + CreategraphicspipelinestateShaderLinkageNeverwrittenAlwaysreads = 664, + /// + /// D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_SHADER_LINKAGE_MINPRECISION + CreategraphicspipelinestateShaderLinkageMinprecision = 665, + /// + /// D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_SHADER_LINKAGE_SEMANTICNAME_NOT_FOUND + CreategraphicspipelinestateShaderLinkageSemanticnameNotFound = 666, + /// + /// D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_HS_XOR_DS_MISMATCH + CreategraphicspipelinestateHsXorDsMismatch = 667, + /// + /// D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_HULL_SHADER_INPUT_TOPOLOGY_MISMATCH + CreategraphicspipelinestateHullShaderInputTopologyMismatch = 668, + /// + /// D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_HS_DS_CONTROL_POINT_COUNT_MISMATCH + CreategraphicspipelinestateHsDsControlPointCountMismatch = 669, + /// + /// D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_HS_DS_TESSELLATOR_DOMAIN_MISMATCH + CreategraphicspipelinestateHsDsTessellatorDomainMismatch = 670, + /// + /// D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_INVALID_USE_OF_CENTER_MULTISAMPLE_PATTERN + CreategraphicspipelinestateInvalidUseOfCenterMultisamplePattern = 671, + /// + /// D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_INVALID_USE_OF_FORCED_SAMPLE_COUNT + CreategraphicspipelinestateInvalidUseOfForcedSampleCount = 672, + /// + /// D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_INVALID_PRIMITIVETOPOLOGY + CreategraphicspipelinestateInvalidPrimitivetopology = 673, + /// + /// D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_INVALID_SYSTEMVALUE + CreategraphicspipelinestateInvalidSystemvalue = 674, + /// + /// D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_OM_DUAL_SOURCE_BLENDING_CAN_ONLY_HAVE_RENDER_TARGET_0 + CreategraphicspipelinestateOmDualSourceBlendingCanOnlyHaveRenderTarget0 = 675, + /// + /// D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_OM_RENDER_TARGET_DOES_NOT_SUPPORT_BLENDING + CreategraphicspipelinestateOmRenderTargetDoesNotSupportBlending = 676, + /// + /// D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_PS_OUTPUT_TYPE_MISMATCH + CreategraphicspipelinestatePsOutputTypeMismatch = 677, + /// + /// D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_OM_RENDER_TARGET_DOES_NOT_SUPPORT_LOGIC_OPS + CreategraphicspipelinestateOmRenderTargetDoesNotSupportLogicOps = 678, + /// + /// D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_RENDERTARGETVIEW_NOT_SET + CreategraphicspipelinestateRenderTargetViewNotSet = 679, + /// + /// D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_DEPTHSTENCILVIEW_NOT_SET + CreategraphicspipelinestateDepthStencilViewNotSet = 680, + /// + /// D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_GS_INPUT_PRIMITIVE_MISMATCH + CreategraphicspipelinestateGsInputPrimitiveMismatch = 681, + /// + /// D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_POSITION_NOT_PRESENT + CreategraphicspipelinestatePositionNotPresent = 682, + /// + /// D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_MISSING_ROOT_SIGNATURE_FLAGS + CreategraphicspipelinestateMissingRootSignatureFlags = 683, + /// + /// D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_INVALID_INDEX_BUFFER_PROPERTIES + CreategraphicspipelinestateInvalidIndexBufferProperties = 684, + /// + /// D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_INVALID_SAMPLE_DESC + CreategraphicspipelinestateInvalidSampleDesc = 685, + /// + /// D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_HS_ROOT_SIGNATURE_MISMATCH + CreategraphicspipelinestateHsRootSignatureMismatch = 686, + /// + /// D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_DS_ROOT_SIGNATURE_MISMATCH + CreategraphicspipelinestateDsRootSignatureMismatch = 687, + /// + /// D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_VS_ROOT_SIGNATURE_MISMATCH + CreategraphicspipelinestateVsRootSignatureMismatch = 688, + /// + /// D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_GS_ROOT_SIGNATURE_MISMATCH + CreategraphicspipelinestateGsRootSignatureMismatch = 689, + /// + /// D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_PS_ROOT_SIGNATURE_MISMATCH + CreategraphicspipelinestatePsRootSignatureMismatch = 690, + /// + /// D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_MISSING_ROOT_SIGNATURE + CreategraphicspipelinestateMissingRootSignature = 691, + /// + /// D3D12_MESSAGE_ID_EXECUTE_BUNDLE_OPEN_BUNDLE + ExecuteBundleOpenBundle = 692, + /// + /// D3D12_MESSAGE_ID_EXECUTE_BUNDLE_DESCRIPTOR_HEAP_MISMATCH + ExecuteBundleDescriptorHeapMismatch = 693, + /// + /// D3D12_MESSAGE_ID_EXECUTE_BUNDLE_TYPE + ExecuteBundleType = 694, + /// + /// D3D12_MESSAGE_ID_DRAW_EMPTY_SCISSOR_RECTANGLE + DrawEmptyScissorRectangle = 695, + /// + /// D3D12_MESSAGE_ID_CREATE_ROOT_SIGNATURE_BLOB_NOT_FOUND + CreateRootSignatureBlobNotFound = 696, + /// + /// D3D12_MESSAGE_ID_CREATE_ROOT_SIGNATURE_DESERIALIZE_FAILED + CreateRootSignatureDeserializeFailed = 697, + /// + /// D3D12_MESSAGE_ID_CREATE_ROOT_SIGNATURE_INVALID_CONFIGURATION + CreateRootSignatureInvalidConfiguration = 698, + /// + /// D3D12_MESSAGE_ID_CREATE_ROOT_SIGNATURE_NOT_SUPPORTED_ON_DEVICE + CreateRootSignatureNotSupportedOnDevice = 699, + /// + /// D3D12_MESSAGE_ID_CREATERESOURCEANDHEAP_NULLRESOURCEPROPERTIES + CreateresourceandheapNullresourceproperties = 700, + /// + /// D3D12_MESSAGE_ID_CREATERESOURCEANDHEAP_NULLHEAP + CreateresourceandheapNullheap = 701, + /// + /// D3D12_MESSAGE_ID_GETRESOURCEALLOCATIONINFO_INVALIDRDESCS + GetresourceallocationinfoInvalidrdescs = 702, + /// + /// D3D12_MESSAGE_ID_MAKERESIDENT_NULLOBJECTARRAY + MakeresidentNullobjectarray = 703, + /// + /// D3D12_MESSAGE_ID_EVICT_NULLOBJECTARRAY + EvictNullobjectarray = 705, + /// + /// D3D12_MESSAGE_ID_SET_DESCRIPTOR_TABLE_INVALID + SetDescriptorTableInvalid = 708, + /// + /// D3D12_MESSAGE_ID_SET_ROOT_CONSTANT_INVALID + SetRootConstantInvalid = 709, + /// + /// D3D12_MESSAGE_ID_SET_ROOT_CONSTANT_BUFFER_VIEW_INVALID + SetRootConstantBufferViewInvalid = 710, + /// + /// D3D12_MESSAGE_ID_SET_ROOT_SHADER_RESOURCE_VIEW_INVALID + SetRootShaderResourceViewInvalid = 711, + /// + /// D3D12_MESSAGE_ID_SET_ROOT_UNORDERED_ACCESS_VIEW_INVALID + SetRootUnorderedAccessViewInvalid = 712, + /// + /// D3D12_MESSAGE_ID_SET_VERTEX_BUFFERS_INVALID_DESC + SetVertexBuffersInvalidDesc = 713, + /// + /// D3D12_MESSAGE_ID_SET_INDEX_BUFFER_INVALID_DESC + SetIndexBufferInvalidDesc = 715, + /// + /// D3D12_MESSAGE_ID_SET_STREAM_OUTPUT_BUFFERS_INVALID_DESC + SetStreamOutputBuffersInvalidDesc = 717, + /// + /// D3D12_MESSAGE_ID_CREATERESOURCE_UNRECOGNIZEDDIMENSIONALITY + CreateresourceUnrecognizeddimensionality = 718, + /// + /// D3D12_MESSAGE_ID_CREATERESOURCE_UNRECOGNIZEDLAYOUT + CreateresourceUnrecognizedlayout = 719, + /// + /// D3D12_MESSAGE_ID_CREATERESOURCE_INVALIDDIMENSIONALITY + CreateresourceInvaliddimensionality = 720, + /// + /// D3D12_MESSAGE_ID_CREATERESOURCE_INVALIDALIGNMENT + CreateresourceInvalidalignment = 721, + /// + /// D3D12_MESSAGE_ID_CREATERESOURCE_INVALIDMIPLEVELS + CreateresourceInvalidmiplevels = 722, + /// + /// D3D12_MESSAGE_ID_CREATERESOURCE_INVALIDSAMPLEDESC + CreateresourceInvalidsampledesc = 723, + /// + /// D3D12_MESSAGE_ID_CREATERESOURCE_INVALIDLAYOUT + CreateresourceInvalidlayout = 724, + /// + /// D3D12_MESSAGE_ID_SET_INDEX_BUFFER_INVALID + SetIndexBufferInvalid = 725, + /// + /// D3D12_MESSAGE_ID_SET_VERTEX_BUFFERS_INVALID + SetVertexBuffersInvalid = 726, + /// + /// D3D12_MESSAGE_ID_SET_STREAM_OUTPUT_BUFFERS_INVALID + SetStreamOutputBuffersInvalid = 727, + /// + /// D3D12_MESSAGE_ID_SET_RENDER_TARGETS_INVALID + SetRenderTargetsInvalid = 728, + /// + /// D3D12_MESSAGE_ID_CREATEQUERY_HEAP_INVALID_PARAMETERS + CreatequeryHeapInvalidParameters = 729, + /// + /// D3D12_MESSAGE_ID_BEGIN_END_QUERY_INVALID_PARAMETERS + BeginEndQueryInvalidParameters = 731, + /// + /// D3D12_MESSAGE_ID_CLOSE_COMMAND_LIST_OPEN_QUERY + CloseCommandListOpenQuery = 732, + /// + /// D3D12_MESSAGE_ID_RESOLVE_QUERY_DATA_INVALID_PARAMETERS + ResolveQueryDataInvalidParameters = 733, + /// + /// D3D12_MESSAGE_ID_SET_PREDICATION_INVALID_PARAMETERS + SetPredicationInvalidParameters = 734, + /// + /// D3D12_MESSAGE_ID_TIMESTAMPS_NOT_SUPPORTED + TimestampsNotSupported = 735, + /// + /// D3D12_MESSAGE_ID_CREATERESOURCE_UNRECOGNIZEDFORMAT + CreateresourceUnrecognizedformat = 737, + /// + /// D3D12_MESSAGE_ID_CREATERESOURCE_INVALIDFORMAT + CreateresourceInvalidformat = 738, + /// + /// D3D12_MESSAGE_ID_GETCOPYABLEFOOTPRINTS_INVALIDSUBRESOURCERANGE + GetcopyablefootprintsInvalidsubresourcerange = 739, + /// + /// D3D12_MESSAGE_ID_GETCOPYABLEFOOTPRINTS_INVALIDBASEOFFSET + GetcopyablefootprintsInvalidbaseoffset = 740, + /// + /// D3D12_MESSAGE_ID_GETCOPYABLELAYOUT_INVALIDSUBRESOURCERANGE + GetcopyablelayoutInvalidsubresourcerange = 739, + /// + /// D3D12_MESSAGE_ID_GETCOPYABLELAYOUT_INVALIDBASEOFFSET + GetcopyablelayoutInvalidbaseoffset = 740, + /// + /// D3D12_MESSAGE_ID_RESOURCE_BARRIER_INVALID_HEAP + ResourceBarrierInvalidHeap = 741, + /// + /// D3D12_MESSAGE_ID_CREATE_SAMPLER_INVALID + CreateSamplerInvalid = 742, + /// + /// D3D12_MESSAGE_ID_CREATECOMMANDSIGNATURE_INVALID + CreatecommandsignatureInvalid = 743, + /// + /// D3D12_MESSAGE_ID_EXECUTE_INDIRECT_INVALID_PARAMETERS + ExecuteIndirectInvalidParameters = 744, + /// + /// D3D12_MESSAGE_ID_GETGPUVIRTUALADDRESS_INVALID_RESOURCE_DIMENSION + GetgpuvirtualaddressInvalidResourceDimension = 745, + /// + /// D3D12_MESSAGE_ID_CREATERESOURCE_INVALIDCLEARVALUE + CreateresourceInvalidclearvalue = 815, + /// + /// D3D12_MESSAGE_ID_CREATERESOURCE_UNRECOGNIZEDCLEARVALUEFORMAT + CreateresourceUnrecognizedclearvalueformat = 816, + /// + /// D3D12_MESSAGE_ID_CREATERESOURCE_INVALIDCLEARVALUEFORMAT + CreateresourceInvalidclearvalueformat = 817, + /// + /// D3D12_MESSAGE_ID_CREATERESOURCE_CLEARVALUEDENORMFLUSH + CreateresourceClearvaluedenormflush = 818, + /// + /// D3D12_MESSAGE_ID_CLEARRENDERTARGETVIEW_MISMATCHINGCLEARVALUE + ClearrendertargetviewMismatchingclearvalue = 820, + /// + /// D3D12_MESSAGE_ID_CLEARDEPTHSTENCILVIEW_MISMATCHINGCLEARVALUE + CleardepthstencilviewMismatchingclearvalue = 821, + /// + /// D3D12_MESSAGE_ID_MAP_INVALIDHEAP + MapInvalidheap = 822, + /// + /// D3D12_MESSAGE_ID_UNMAP_INVALIDHEAP + UnmapInvalidheap = 823, + /// + /// D3D12_MESSAGE_ID_MAP_INVALIDRESOURCE + MapInvalidresource = 824, + /// + /// D3D12_MESSAGE_ID_UNMAP_INVALIDRESOURCE + UnmapInvalidresource = 825, + /// + /// D3D12_MESSAGE_ID_MAP_INVALIDSUBRESOURCE + MapInvalidsubresource = 826, + /// + /// D3D12_MESSAGE_ID_UNMAP_INVALIDSUBRESOURCE + UnmapInvalidsubresource = 827, + /// + /// D3D12_MESSAGE_ID_MAP_INVALIDRANGE + MapInvalidrange = 828, + /// + /// D3D12_MESSAGE_ID_UNMAP_INVALIDRANGE + UnmapInvalidrange = 829, + /// + /// D3D12_MESSAGE_ID_MAP_INVALIDDATAPOINTER + MapInvaliddatapointer = 832, + /// + /// D3D12_MESSAGE_ID_MAP_INVALIDARG_RETURN + MapInvalidargReturn = 833, + /// + /// D3D12_MESSAGE_ID_MAP_OUTOFMEMORY_RETURN + MapOutofmemoryReturn = 834, + /// + /// D3D12_MESSAGE_ID_EXECUTECOMMANDLISTS_BUNDLENOTSUPPORTED + ExecutecommandlistsBundlenotsupported = 835, + /// + /// D3D12_MESSAGE_ID_EXECUTECOMMANDLISTS_COMMANDLISTMISMATCH + ExecutecommandlistsCommandlistmismatch = 836, + /// + /// D3D12_MESSAGE_ID_EXECUTECOMMANDLISTS_OPENCOMMANDLIST + ExecutecommandlistsOpencommandlist = 837, + /// + /// D3D12_MESSAGE_ID_EXECUTECOMMANDLISTS_FAILEDCOMMANDLIST + ExecutecommandlistsFailedcommandlist = 838, + /// + /// D3D12_MESSAGE_ID_COPYBUFFERREGION_NULLDST + CopybufferregionNulldst = 839, + /// + /// D3D12_MESSAGE_ID_COPYBUFFERREGION_INVALIDDSTRESOURCEDIMENSION + CopybufferregionInvaliddstresourcedimension = 840, + /// + /// D3D12_MESSAGE_ID_COPYBUFFERREGION_DSTRANGEOUTOFBOUNDS + CopybufferregionDstrangeoutofbounds = 841, + /// + /// D3D12_MESSAGE_ID_COPYBUFFERREGION_NULLSRC + CopybufferregionNullsrc = 842, + /// + /// D3D12_MESSAGE_ID_COPYBUFFERREGION_INVALIDSRCRESOURCEDIMENSION + CopybufferregionInvalidsrcresourcedimension = 843, + /// + /// D3D12_MESSAGE_ID_COPYBUFFERREGION_SRCRANGEOUTOFBOUNDS + CopybufferregionSrcrangeoutofbounds = 844, + /// + /// D3D12_MESSAGE_ID_COPYBUFFERREGION_INVALIDCOPYFLAGS + CopybufferregionInvalidcopyflags = 845, + /// + /// D3D12_MESSAGE_ID_COPYTEXTUREREGION_NULLDST + CopytextureregionNulldst = 846, + /// + /// D3D12_MESSAGE_ID_COPYTEXTUREREGION_UNRECOGNIZEDDSTTYPE + CopytextureregionUnrecognizeddsttype = 847, + /// + /// D3D12_MESSAGE_ID_COPYTEXTUREREGION_INVALIDDSTRESOURCEDIMENSION + CopytextureregionInvaliddstresourcedimension = 848, + /// + /// D3D12_MESSAGE_ID_COPYTEXTUREREGION_INVALIDDSTRESOURCE + CopytextureregionInvaliddstresource = 849, + /// + /// D3D12_MESSAGE_ID_COPYTEXTUREREGION_INVALIDDSTSUBRESOURCE + CopytextureregionInvaliddstsubresource = 850, + /// + /// D3D12_MESSAGE_ID_COPYTEXTUREREGION_INVALIDDSTOFFSET + CopytextureregionInvaliddstoffset = 851, + /// + /// D3D12_MESSAGE_ID_COPYTEXTUREREGION_UNRECOGNIZEDDSTFORMAT + CopytextureregionUnrecognizeddstformat = 852, + /// + /// D3D12_MESSAGE_ID_COPYTEXTUREREGION_INVALIDDSTFORMAT + CopytextureregionInvaliddstformat = 853, + /// + /// D3D12_MESSAGE_ID_COPYTEXTUREREGION_INVALIDDSTDIMENSIONS + CopytextureregionInvaliddstdimensions = 854, + /// + /// D3D12_MESSAGE_ID_COPYTEXTUREREGION_INVALIDDSTROWPITCH + CopytextureregionInvaliddstrowpitch = 855, + /// + /// D3D12_MESSAGE_ID_COPYTEXTUREREGION_INVALIDDSTPLACEMENT + CopytextureregionInvaliddstplacement = 856, + /// + /// D3D12_MESSAGE_ID_COPYTEXTUREREGION_INVALIDDSTDSPLACEDFOOTPRINTFORMAT + CopytextureregionInvaliddstdsplacedfootprintformat = 857, + /// + /// D3D12_MESSAGE_ID_COPYTEXTUREREGION_DSTREGIONOUTOFBOUNDS + CopytextureregionDstregionoutofbounds = 858, + /// + /// D3D12_MESSAGE_ID_COPYTEXTUREREGION_NULLSRC + CopytextureregionNullsrc = 859, + /// + /// D3D12_MESSAGE_ID_COPYTEXTUREREGION_UNRECOGNIZEDSRCTYPE + CopytextureregionUnrecognizedsrctype = 860, + /// + /// D3D12_MESSAGE_ID_COPYTEXTUREREGION_INVALIDSRCRESOURCEDIMENSION + CopytextureregionInvalidsrcresourcedimension = 861, + /// + /// D3D12_MESSAGE_ID_COPYTEXTUREREGION_INVALIDSRCRESOURCE + CopytextureregionInvalidsrcresource = 862, + /// + /// D3D12_MESSAGE_ID_COPYTEXTUREREGION_INVALIDSRCSUBRESOURCE + CopytextureregionInvalidsrcsubresource = 863, + /// + /// D3D12_MESSAGE_ID_COPYTEXTUREREGION_INVALIDSRCOFFSET + CopytextureregionInvalidsrcoffset = 864, + /// + /// D3D12_MESSAGE_ID_COPYTEXTUREREGION_UNRECOGNIZEDSRCFORMAT + CopytextureregionUnrecognizedsrcformat = 865, + /// + /// D3D12_MESSAGE_ID_COPYTEXTUREREGION_INVALIDSRCFORMAT + CopytextureregionInvalidsrcformat = 866, + /// + /// D3D12_MESSAGE_ID_COPYTEXTUREREGION_INVALIDSRCDIMENSIONS + CopytextureregionInvalidsrcdimensions = 867, + /// + /// D3D12_MESSAGE_ID_COPYTEXTUREREGION_INVALIDSRCROWPITCH + CopytextureregionInvalidsrcrowpitch = 868, + /// + /// D3D12_MESSAGE_ID_COPYTEXTUREREGION_INVALIDSRCPLACEMENT + CopytextureregionInvalidsrcplacement = 869, + /// + /// D3D12_MESSAGE_ID_COPYTEXTUREREGION_INVALIDSRCDSPLACEDFOOTPRINTFORMAT + CopytextureregionInvalidsrcdsplacedfootprintformat = 870, + /// + /// D3D12_MESSAGE_ID_COPYTEXTUREREGION_SRCREGIONOUTOFBOUNDS + CopytextureregionSrcregionoutofbounds = 871, + /// + /// D3D12_MESSAGE_ID_COPYTEXTUREREGION_INVALIDDSTCOORDINATES + CopytextureregionInvaliddstcoordinates = 872, + /// + /// D3D12_MESSAGE_ID_COPYTEXTUREREGION_INVALIDSRCBOX + CopytextureregionInvalidsrcbox = 873, + /// + /// D3D12_MESSAGE_ID_COPYTEXTUREREGION_FORMATMISMATCH + CopytextureregionFormatmismatch = 874, + /// + /// D3D12_MESSAGE_ID_COPYTEXTUREREGION_EMPTYBOX + CopytextureregionEmptybox = 875, + /// + /// D3D12_MESSAGE_ID_COPYTEXTUREREGION_INVALIDCOPYFLAGS + CopytextureregionInvalidcopyflags = 876, + /// + /// D3D12_MESSAGE_ID_RESOLVESUBRESOURCE_INVALID_SUBRESOURCE_INDEX + ResolvesubresourceInvalidSubresourceIndex = 877, + /// + /// D3D12_MESSAGE_ID_RESOLVESUBRESOURCE_INVALID_FORMAT + ResolvesubresourceInvalidFormat = 878, + /// + /// D3D12_MESSAGE_ID_RESOLVESUBRESOURCE_RESOURCE_MISMATCH + ResolvesubresourceResourceMismatch = 879, + /// + /// D3D12_MESSAGE_ID_RESOLVESUBRESOURCE_INVALID_SAMPLE_COUNT + ResolvesubresourceInvalidSampleCount = 880, + /// + /// D3D12_MESSAGE_ID_CREATECOMPUTEPIPELINESTATE_INVALID_SHADER + CreatecomputepipelinestateInvalidShader = 881, + /// + /// D3D12_MESSAGE_ID_CREATECOMPUTEPIPELINESTATE_CS_ROOT_SIGNATURE_MISMATCH + CreatecomputepipelinestateCsRootSignatureMismatch = 882, + /// + /// D3D12_MESSAGE_ID_CREATECOMPUTEPIPELINESTATE_MISSING_ROOT_SIGNATURE + CreatecomputepipelinestateMissingRootSignature = 883, + /// + /// D3D12_MESSAGE_ID_CREATEPIPELINESTATE_INVALIDCACHEDBLOB + CreatepipelinestateInvalidcachedblob = 884, + /// + /// D3D12_MESSAGE_ID_CREATEPIPELINESTATE_CACHEDBLOBADAPTERMISMATCH + CreatepipelinestateCachedblobadaptermismatch = 885, + /// + /// D3D12_MESSAGE_ID_CREATEPIPELINESTATE_CACHEDBLOBDRIVERVERSIONMISMATCH + CreatepipelinestateCachedblobdriverversionmismatch = 886, + /// + /// D3D12_MESSAGE_ID_CREATEPIPELINESTATE_CACHEDBLOBDESCMISMATCH + CreatepipelinestateCachedblobdescmismatch = 887, + /// + /// D3D12_MESSAGE_ID_CREATEPIPELINESTATE_CACHEDBLOBIGNORED + CreatepipelinestateCachedblobignored = 888, + /// + /// D3D12_MESSAGE_ID_WRITETOSUBRESOURCE_INVALIDHEAP + WritetosubresourceInvalidheap = 889, + /// + /// D3D12_MESSAGE_ID_WRITETOSUBRESOURCE_INVALIDRESOURCE + WritetosubresourceInvalidresource = 890, + /// + /// D3D12_MESSAGE_ID_WRITETOSUBRESOURCE_INVALIDBOX + WritetosubresourceInvalidbox = 891, + /// + /// D3D12_MESSAGE_ID_WRITETOSUBRESOURCE_INVALIDSUBRESOURCE + WritetosubresourceInvalidsubresource = 892, + /// + /// D3D12_MESSAGE_ID_WRITETOSUBRESOURCE_EMPTYBOX + WritetosubresourceEmptybox = 893, + /// + /// D3D12_MESSAGE_ID_READFROMSUBRESOURCE_INVALIDHEAP + ReadfromsubresourceInvalidheap = 894, + /// + /// D3D12_MESSAGE_ID_READFROMSUBRESOURCE_INVALIDRESOURCE + ReadfromsubresourceInvalidresource = 895, + /// + /// D3D12_MESSAGE_ID_READFROMSUBRESOURCE_INVALIDBOX + ReadfromsubresourceInvalidbox = 896, + /// + /// D3D12_MESSAGE_ID_READFROMSUBRESOURCE_INVALIDSUBRESOURCE + ReadfromsubresourceInvalidsubresource = 897, + /// + /// D3D12_MESSAGE_ID_READFROMSUBRESOURCE_EMPTYBOX + ReadfromsubresourceEmptybox = 898, + /// + /// D3D12_MESSAGE_ID_TOO_MANY_NODES_SPECIFIED + TooManyNodesSpecified = 899, + /// + /// D3D12_MESSAGE_ID_INVALID_NODE_INDEX + InvalidNodeIndex = 900, + /// + /// D3D12_MESSAGE_ID_GETHEAPPROPERTIES_INVALIDRESOURCE + GetheappropertiesInvalidresource = 901, + /// + /// D3D12_MESSAGE_ID_NODE_MASK_MISMATCH + NodeMaskMismatch = 902, + /// + /// D3D12_MESSAGE_ID_COMMAND_LIST_OUTOFMEMORY + CommandListOutofmemory = 903, + /// + /// D3D12_MESSAGE_ID_COMMAND_LIST_MULTIPLE_SWAPCHAIN_BUFFER_REFERENCES + CommandListMultipleSwapchainBufferReferences = 904, + /// + /// D3D12_MESSAGE_ID_COMMAND_LIST_TOO_MANY_SWAPCHAIN_REFERENCES + CommandListTooManySwapchainReferences = 905, + /// + /// D3D12_MESSAGE_ID_COMMAND_QUEUE_TOO_MANY_SWAPCHAIN_REFERENCES + CommandQueueTooManySwapchainReferences = 906, + /// + /// D3D12_MESSAGE_ID_EXECUTECOMMANDLISTS_WRONGSWAPCHAINBUFFERREFERENCE + ExecutecommandlistsWrongswapchainbufferreference = 907, + /// + /// D3D12_MESSAGE_ID_COMMAND_LIST_SETRENDERTARGETS_INVALIDNUMRENDERTARGETS + CommandListSetrendertargetsInvalidnumrendertargets = 908, + /// + /// D3D12_MESSAGE_ID_CREATE_QUEUE_INVALID_TYPE + CreateQueueInvalidType = 909, + /// + /// D3D12_MESSAGE_ID_CREATE_QUEUE_INVALID_FLAGS + CreateQueueInvalidFlags = 910, + /// + /// D3D12_MESSAGE_ID_CREATESHAREDRESOURCE_INVALIDFLAGS + CreatesharedresourceInvalidflags = 911, + /// + /// D3D12_MESSAGE_ID_CREATESHAREDRESOURCE_INVALIDFORMAT + CreatesharedresourceInvalidformat = 912, + /// + /// D3D12_MESSAGE_ID_CREATESHAREDHEAP_INVALIDFLAGS + CreatesharedheapInvalidflags = 913, + /// + /// D3D12_MESSAGE_ID_REFLECTSHAREDPROPERTIES_UNRECOGNIZEDPROPERTIES + ReflectsharedpropertiesUnrecognizedproperties = 914, + /// + /// D3D12_MESSAGE_ID_REFLECTSHAREDPROPERTIES_INVALIDSIZE + ReflectsharedpropertiesInvalidsize = 915, + /// + /// D3D12_MESSAGE_ID_REFLECTSHAREDPROPERTIES_INVALIDOBJECT + ReflectsharedpropertiesInvalidobject = 916, + /// + /// D3D12_MESSAGE_ID_KEYEDMUTEX_INVALIDOBJECT + KeyedMutexInvalidobject = 917, + /// + /// D3D12_MESSAGE_ID_KEYEDMUTEX_INVALIDKEY + KeyedMutexInvalidkey = 918, + /// + /// D3D12_MESSAGE_ID_KEYEDMUTEX_WRONGSTATE + KeyedMutexWrongstate = 919, + /// + /// D3D12_MESSAGE_ID_CREATE_QUEUE_INVALID_PRIORITY + CreateQueueInvalidPriority = 920, + /// + /// D3D12_MESSAGE_ID_OBJECT_DELETED_WHILE_STILL_IN_USE + ObjectDeletedWhileStillInUse = 921, + /// + /// D3D12_MESSAGE_ID_CREATEPIPELINESTATE_INVALID_FLAGS + CreatepipelinestateInvalidFlags = 922, + /// + /// D3D12_MESSAGE_ID_HEAP_ADDRESS_RANGE_HAS_NO_RESOURCE + HeapAddressRangeHasNoResource = 923, + /// + /// D3D12_MESSAGE_ID_COMMAND_LIST_DRAW_RENDER_TARGET_DELETED + CommandListDrawRenderTargetDeleted = 924, + /// + /// D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_ALL_RENDER_TARGETS_HAVE_UNKNOWN_FORMAT + CreategraphicspipelinestateAllRenderTargetsHaveUnknownFormat = 925, + /// + /// D3D12_MESSAGE_ID_HEAP_ADDRESS_RANGE_INTERSECTS_MULTIPLE_BUFFERS + HeapAddressRangeIntersectsMultipleBuffers = 926, + /// + /// D3D12_MESSAGE_ID_EXECUTECOMMANDLISTS_GPU_WRITTEN_READBACK_RESOURCE_MAPPED + ExecutecommandlistsGpuWrittenReadbackResourceMapped = 927, + /// + /// D3D12_MESSAGE_ID_UNMAP_RANGE_NOT_EMPTY + UnmapRangeNotEmpty = 929, + /// + /// D3D12_MESSAGE_ID_MAP_INVALID_NULLRANGE + MapInvalidNullrange = 930, + /// + /// D3D12_MESSAGE_ID_UNMAP_INVALID_NULLRANGE + UnmapInvalidNullrange = 931, + /// + /// D3D12_MESSAGE_ID_NO_GRAPHICS_API_SUPPORT + NoGraphicsApiSupport = 932, + /// + /// D3D12_MESSAGE_ID_NO_COMPUTE_API_SUPPORT + NoComputeApiSupport = 933, + /// + /// D3D12_MESSAGE_ID_RESOLVESUBRESOURCE_RESOURCE_FLAGS_NOT_SUPPORTED + ResolvesubresourceResourceFlagsNotSupported = 934, + /// + /// D3D12_MESSAGE_ID_GPU_BASED_VALIDATION_ROOT_ARGUMENT_UNINITIALIZED + GpuBasedValidationRootArgumentUninitialized = 935, + /// + /// D3D12_MESSAGE_ID_GPU_BASED_VALIDATION_DESCRIPTOR_HEAP_INDEX_OUT_OF_BOUNDS + GpuBasedValidationDescriptorHeapIndexOutOfBounds = 936, + /// + /// D3D12_MESSAGE_ID_GPU_BASED_VALIDATION_DESCRIPTOR_TABLE_REGISTER_INDEX_OUT_OF_BOUNDS + GpuBasedValidationDescriptorTableRegisterIndexOutOfBounds = 937, + /// + /// D3D12_MESSAGE_ID_GPU_BASED_VALIDATION_DESCRIPTOR_UNINITIALIZED + GpuBasedValidationDescriptorUninitialized = 938, + /// + /// D3D12_MESSAGE_ID_GPU_BASED_VALIDATION_DESCRIPTOR_TYPE_MISMATCH + GpuBasedValidationDescriptorTypeMismatch = 939, + /// + /// D3D12_MESSAGE_ID_GPU_BASED_VALIDATION_SRV_RESOURCE_DIMENSION_MISMATCH + GpuBasedValidationSrvResourceDimensionMismatch = 940, + /// + /// D3D12_MESSAGE_ID_GPU_BASED_VALIDATION_UAV_RESOURCE_DIMENSION_MISMATCH + GpuBasedValidationUavResourceDimensionMismatch = 941, + /// + /// D3D12_MESSAGE_ID_GPU_BASED_VALIDATION_INCOMPATIBLE_RESOURCE_STATE + GpuBasedValidationIncompatibleResourceState = 942, + /// + /// D3D12_MESSAGE_ID_COPYRESOURCE_NULLDST + CopyresourceNulldst = 943, + /// + /// D3D12_MESSAGE_ID_COPYRESOURCE_INVALIDDSTRESOURCE + CopyresourceInvaliddstresource = 944, + /// + /// D3D12_MESSAGE_ID_COPYRESOURCE_NULLSRC + CopyresourceNullsrc = 945, + /// + /// D3D12_MESSAGE_ID_COPYRESOURCE_INVALIDSRCRESOURCE + CopyresourceInvalidsrcresource = 946, + /// + /// D3D12_MESSAGE_ID_RESOLVESUBRESOURCE_NULLDST + ResolvesubresourceNulldst = 947, + /// + /// D3D12_MESSAGE_ID_RESOLVESUBRESOURCE_INVALIDDSTRESOURCE + ResolvesubresourceInvaliddstresource = 948, + /// + /// D3D12_MESSAGE_ID_RESOLVESUBRESOURCE_NULLSRC + ResolvesubresourceNullsrc = 949, + /// + /// D3D12_MESSAGE_ID_RESOLVESUBRESOURCE_INVALIDSRCRESOURCE + ResolvesubresourceInvalidsrcresource = 950, + /// + /// D3D12_MESSAGE_ID_PIPELINE_STATE_TYPE_MISMATCH + PipelineStateTypeMismatch = 951, + /// + /// D3D12_MESSAGE_ID_COMMAND_LIST_DISPATCH_ROOT_SIGNATURE_NOT_SET + CommandListDispatchRootSignatureNotSet = 952, + /// + /// D3D12_MESSAGE_ID_COMMAND_LIST_DISPATCH_ROOT_SIGNATURE_MISMATCH + CommandListDispatchRootSignatureMismatch = 953, + /// + /// D3D12_MESSAGE_ID_RESOURCE_BARRIER_ZERO_BARRIERS + ResourceBarrierZeroBarriers = 954, + /// + /// D3D12_MESSAGE_ID_BEGIN_END_EVENT_MISMATCH + BeginEndEventMismatch = 955, + /// + /// D3D12_MESSAGE_ID_RESOURCE_BARRIER_POSSIBLE_BEFORE_AFTER_MISMATCH + ResourceBarrierPossibleBeforeAfterMismatch = 956, + /// + /// D3D12_MESSAGE_ID_RESOURCE_BARRIER_MISMATCHING_BEGIN_END + ResourceBarrierMismatchingBeginEnd = 957, + /// + /// D3D12_MESSAGE_ID_GPU_BASED_VALIDATION_INVALID_RESOURCE + GpuBasedValidationInvalidResource = 958, + /// + /// D3D12_MESSAGE_ID_USE_OF_ZERO_REFCOUNT_OBJECT + UseOfZeroRefcountObject = 959, + /// + /// D3D12_MESSAGE_ID_OBJECT_EVICTED_WHILE_STILL_IN_USE + ObjectEvictedWhileStillInUse = 960, + /// + /// D3D12_MESSAGE_ID_GPU_BASED_VALIDATION_ROOT_DESCRIPTOR_ACCESS_OUT_OF_BOUNDS + GpuBasedValidationRootDescriptorAccessOutOfBounds = 961, + /// + /// D3D12_MESSAGE_ID_CREATEPIPELINELIBRARY_INVALIDLIBRARYBLOB + CreatepipelinelibraryInvalidlibraryblob = 962, + /// + /// D3D12_MESSAGE_ID_CREATEPIPELINELIBRARY_DRIVERVERSIONMISMATCH + CreatepipelinelibraryDriverversionmismatch = 963, + /// + /// D3D12_MESSAGE_ID_CREATEPIPELINELIBRARY_ADAPTERVERSIONMISMATCH + CreatepipelinelibraryAdapterversionmismatch = 964, + /// + /// D3D12_MESSAGE_ID_CREATEPIPELINELIBRARY_UNSUPPORTED + CreatepipelinelibraryUnsupported = 965, + /// + /// D3D12_MESSAGE_ID_CREATE_PIPELINELIBRARY + CreatePipelinelibrary = 966, + /// + /// D3D12_MESSAGE_ID_LIVE_PIPELINELIBRARY + LivePipelinelibrary = 967, + /// + /// D3D12_MESSAGE_ID_DESTROY_PIPELINELIBRARY + DestroyPipelinelibrary = 968, + /// + /// D3D12_MESSAGE_ID_STOREPIPELINE_NONAME + StorepipelineNoname = 969, + /// + /// D3D12_MESSAGE_ID_STOREPIPELINE_DUPLICATENAME + StorepipelineDuplicatename = 970, + /// + /// D3D12_MESSAGE_ID_LOADPIPELINE_NAMENOTFOUND + LoadpipelineNamenotfound = 971, + /// + /// D3D12_MESSAGE_ID_LOADPIPELINE_INVALIDDESC + LoadpipelineInvaliddesc = 972, + /// + /// D3D12_MESSAGE_ID_PIPELINELIBRARY_SERIALIZE_NOTENOUGHMEMORY + PipelinelibrarySerializeNotenoughmemory = 973, + /// + /// D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_PS_OUTPUT_RT_OUTPUT_MISMATCH + CreategraphicspipelinestatePsOutputRtOutputMismatch = 974, + /// + /// D3D12_MESSAGE_ID_SETEVENTONMULTIPLEFENCECOMPLETION_INVALIDFLAGS + SeteventonmultiplefencecompletionInvalidflags = 975, + /// + /// D3D12_MESSAGE_ID_CREATE_QUEUE_VIDEO_NOT_SUPPORTED + CreateQueueVideoNotSupported = 976, + /// + /// D3D12_MESSAGE_ID_CREATE_COMMAND_ALLOCATOR_VIDEO_NOT_SUPPORTED + CreateCommandAllocatorVideoNotSupported = 977, + /// + /// D3D12_MESSAGE_ID_CREATEQUERY_HEAP_VIDEO_DECODE_STATISTICS_NOT_SUPPORTED + CreatequeryHeapVideoDecodeStatisticsNotSupported = 978, + /// + /// D3D12_MESSAGE_ID_CREATE_VIDEODECODECOMMANDLIST + CreateVideodecodecommandlist = 979, + /// + /// D3D12_MESSAGE_ID_CREATE_VIDEODECODER + CreateVideodecoder = 980, + /// + /// D3D12_MESSAGE_ID_CREATE_VIDEODECODESTREAM + CreateVideodecodestream = 981, + /// + /// D3D12_MESSAGE_ID_LIVE_VIDEODECODECOMMANDLIST + LiveVideodecodecommandlist = 982, + /// + /// D3D12_MESSAGE_ID_LIVE_VIDEODECODER + LiveVideodecoder = 983, + /// + /// D3D12_MESSAGE_ID_LIVE_VIDEODECODESTREAM + LiveVideodecodestream = 984, + /// + /// D3D12_MESSAGE_ID_DESTROY_VIDEODECODECOMMANDLIST + DestroyVideodecodecommandlist = 985, + /// + /// D3D12_MESSAGE_ID_DESTROY_VIDEODECODER + DestroyVideodecoder = 986, + /// + /// D3D12_MESSAGE_ID_DESTROY_VIDEODECODESTREAM + DestroyVideodecodestream = 987, + /// + /// D3D12_MESSAGE_ID_DECODE_FRAME_INVALID_PARAMETERS + DecodeFrameInvalidParameters = 988, + /// + /// D3D12_MESSAGE_ID_DEPRECATED_API + DeprecatedApi = 989, + /// + /// D3D12_MESSAGE_ID_RESOURCE_BARRIER_MISMATCHING_COMMAND_LIST_TYPE + ResourceBarrierMismatchingCommandListType = 990, + /// + /// D3D12_MESSAGE_ID_COMMAND_LIST_DESCRIPTOR_TABLE_NOT_SET + CommandListDescriptorTableNotSet = 991, + /// + /// D3D12_MESSAGE_ID_COMMAND_LIST_ROOT_CONSTANT_BUFFER_VIEW_NOT_SET + CommandListRootConstantBufferViewNotSet = 992, + /// + /// D3D12_MESSAGE_ID_COMMAND_LIST_ROOT_SHADER_RESOURCE_VIEW_NOT_SET + CommandListRootShaderResourceViewNotSet = 993, + /// + /// D3D12_MESSAGE_ID_COMMAND_LIST_ROOT_UNORDERED_ACCESS_VIEW_NOT_SET + CommandListRootUnorderedAccessViewNotSet = 994, + /// + /// D3D12_MESSAGE_ID_DISCARD_INVALID_SUBRESOURCE_RANGE + DiscardInvalidSubresourceRange = 995, + /// + /// D3D12_MESSAGE_ID_DISCARD_ONE_SUBRESOURCE_FOR_MIPS_WITH_RECTS + DiscardOneSubresourceForMipsWithRects = 996, + /// + /// D3D12_MESSAGE_ID_DISCARD_NO_RECTS_FOR_NON_TEXTURE2D + DiscardNoRectsForNonTexture2D = 997, + /// + /// D3D12_MESSAGE_ID_COPY_ON_SAME_SUBRESOURCE + CopyOnSameSubresource = 998, + /// + /// D3D12_MESSAGE_ID_SETRESIDENCYPRIORITY_INVALID_PAGEABLE + SetresidencypriorityInvalidPageable = 999, + /// + /// D3D12_MESSAGE_ID_GPU_BASED_VALIDATION_UNSUPPORTED + GpuBasedValidationUnsupported = 1000, + /// + /// D3D12_MESSAGE_ID_STATIC_DESCRIPTOR_INVALID_DESCRIPTOR_CHANGE + StaticDescriptorInvalidDescriptorChange = 1001, + /// + /// D3D12_MESSAGE_ID_DATA_STATIC_DESCRIPTOR_INVALID_DATA_CHANGE + DataStaticDescriptorInvalidDataChange = 1002, + /// + /// D3D12_MESSAGE_ID_DATA_STATIC_WHILE_SET_AT_EXECUTE_DESCRIPTOR_INVALID_DATA_CHANGE + DataStaticWhileSetAtExecuteDescriptorInvalidDataChange = 1003, + /// + /// D3D12_MESSAGE_ID_EXECUTE_BUNDLE_STATIC_DESCRIPTOR_DATA_STATIC_NOT_SET + ExecuteBundleStaticDescriptorDataStaticNotSet = 1004, + /// + /// D3D12_MESSAGE_ID_GPU_BASED_VALIDATION_RESOURCE_ACCESS_OUT_OF_BOUNDS + GpuBasedValidationResourceAccessOutOfBounds = 1005, + /// + /// D3D12_MESSAGE_ID_GPU_BASED_VALIDATION_SAMPLER_MODE_MISMATCH + GpuBasedValidationSamplerModeMismatch = 1006, + /// + /// D3D12_MESSAGE_ID_CREATE_FENCE_INVALID_FLAGS + CreateFenceInvalidFlags = 1007, + /// + /// D3D12_MESSAGE_ID_RESOURCE_BARRIER_DUPLICATE_SUBRESOURCE_TRANSITIONS + ResourceBarrierDuplicateSubresourceTransitions = 1008, + /// + /// D3D12_MESSAGE_ID_SETRESIDENCYPRIORITY_INVALID_PRIORITY + SetresidencypriorityInvalidPriority = 1009, + /// + /// D3D12_MESSAGE_ID_CREATE_DESCRIPTOR_HEAP_LARGE_NUM_DESCRIPTORS + CreateDescriptorHeapLargeNumDescriptors = 1013, + /// + /// D3D12_MESSAGE_ID_BEGIN_EVENT + BeginEvent = 1014, + /// + /// D3D12_MESSAGE_ID_END_EVENT + EndEvent = 1015, + /// + /// D3D12_MESSAGE_ID_CREATEDEVICE_DEBUG_LAYER_STARTUP_OPTIONS + CreatedeviceDebugLayerStartupOptions = 1016, + /// + /// D3D12_MESSAGE_ID_CREATEDEPTHSTENCILSTATE_DEPTHBOUNDSTEST_UNSUPPORTED + CreatedepthstencilstateDepthboundstestUnsupported = 1017, + /// + /// D3D12_MESSAGE_ID_CREATEPIPELINESTATE_DUPLICATE_SUBOBJECT + CreatepipelinestateDuplicateSubobject = 1018, + /// + /// D3D12_MESSAGE_ID_CREATEPIPELINESTATE_UNKNOWN_SUBOBJECT + CreatepipelinestateUnknownSubobject = 1019, + /// + /// D3D12_MESSAGE_ID_CREATEPIPELINESTATE_ZERO_SIZE_STREAM + CreatepipelinestateZeroSizeStream = 1020, + /// + /// D3D12_MESSAGE_ID_CREATEPIPELINESTATE_INVALID_STREAM + CreatepipelinestateInvalidStream = 1021, + /// + /// D3D12_MESSAGE_ID_CREATEPIPELINESTATE_CANNOT_DEDUCE_TYPE + CreatepipelinestateCannotDeduceType = 1022, + /// + /// D3D12_MESSAGE_ID_COMMAND_LIST_STATIC_DESCRIPTOR_RESOURCE_DIMENSION_MISMATCH + CommandListStaticDescriptorResourceDimensionMismatch = 1023, + /// + /// D3D12_MESSAGE_ID_CREATE_COMMAND_QUEUE_INSUFFICIENT_PRIVILEGE_FOR_GLOBAL_REALTIME + CreateCommandQueueInsufficientPrivilegeForGlobalRealtime = 1024, + /// + /// D3D12_MESSAGE_ID_CREATE_COMMAND_QUEUE_INSUFFICIENT_HARDWARE_SUPPORT_FOR_GLOBAL_REALTIME + CreateCommandQueueInsufficientHardwareSupportForGlobalRealtime = 1025, + /// + /// D3D12_MESSAGE_ID_ATOMICCOPYBUFFER_INVALID_ARCHITECTURE + AtomiccopybufferInvalidArchitecture = 1026, + /// + /// D3D12_MESSAGE_ID_ATOMICCOPYBUFFER_NULL_DST + AtomiccopybufferNullDst = 1027, + /// + /// D3D12_MESSAGE_ID_ATOMICCOPYBUFFER_INVALID_DST_RESOURCE_DIMENSION + AtomiccopybufferInvalidDstResourceDimension = 1028, + /// + /// D3D12_MESSAGE_ID_ATOMICCOPYBUFFER_DST_RANGE_OUT_OF_BOUNDS + AtomiccopybufferDstRangeOutOfBounds = 1029, + /// + /// D3D12_MESSAGE_ID_ATOMICCOPYBUFFER_NULL_SRC + AtomiccopybufferNullSrc = 1030, + /// + /// D3D12_MESSAGE_ID_ATOMICCOPYBUFFER_INVALID_SRC_RESOURCE_DIMENSION + AtomiccopybufferInvalidSrcResourceDimension = 1031, + /// + /// D3D12_MESSAGE_ID_ATOMICCOPYBUFFER_SRC_RANGE_OUT_OF_BOUNDS + AtomiccopybufferSrcRangeOutOfBounds = 1032, + /// + /// D3D12_MESSAGE_ID_ATOMICCOPYBUFFER_INVALID_OFFSET_ALIGNMENT + AtomiccopybufferInvalidOffsetAlignment = 1033, + /// + /// D3D12_MESSAGE_ID_ATOMICCOPYBUFFER_NULL_DEPENDENT_RESOURCES + AtomiccopybufferNullDependentResources = 1034, + /// + /// D3D12_MESSAGE_ID_ATOMICCOPYBUFFER_NULL_DEPENDENT_SUBRESOURCE_RANGES + AtomiccopybufferNullDependentSubresourceRanges = 1035, + /// + /// D3D12_MESSAGE_ID_ATOMICCOPYBUFFER_INVALID_DEPENDENT_RESOURCE + AtomiccopybufferInvalidDependentResource = 1036, + /// + /// D3D12_MESSAGE_ID_ATOMICCOPYBUFFER_INVALID_DEPENDENT_SUBRESOURCE_RANGE + AtomiccopybufferInvalidDependentSubresourceRange = 1037, + /// + /// D3D12_MESSAGE_ID_ATOMICCOPYBUFFER_DEPENDENT_SUBRESOURCE_OUT_OF_BOUNDS + AtomiccopybufferDependentSubresourceOutOfBounds = 1038, + /// + /// D3D12_MESSAGE_ID_ATOMICCOPYBUFFER_DEPENDENT_RANGE_OUT_OF_BOUNDS + AtomiccopybufferDependentRangeOutOfBounds = 1039, + /// + /// D3D12_MESSAGE_ID_ATOMICCOPYBUFFER_ZERO_DEPENDENCIES + AtomiccopybufferZeroDependencies = 1040, + /// + /// D3D12_MESSAGE_ID_DEVICE_CREATE_SHARED_HANDLE_INVALIDARG + DeviceCreateSharedHandleInvalidarg = 1041, + /// + /// D3D12_MESSAGE_ID_DESCRIPTOR_HANDLE_WITH_INVALID_RESOURCE + DescriptorHandleWithInvalidResource = 1042, + /// + /// D3D12_MESSAGE_ID_SETDEPTHBOUNDS_INVALIDARGS + SetdepthboundsInvalidargs = 1043, + /// + /// D3D12_MESSAGE_ID_GPU_BASED_VALIDATION_RESOURCE_STATE_IMPRECISE + GpuBasedValidationResourceStateImprecise = 1044, + /// + /// D3D12_MESSAGE_ID_COMMAND_LIST_PIPELINE_STATE_NOT_SET + CommandListPipelineStateNotSet = 1045, + /// + /// D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_SHADER_MODEL_MISMATCH + CreategraphicspipelinestateShaderModelMismatch = 1046, + /// + /// D3D12_MESSAGE_ID_OBJECT_ACCESSED_WHILE_STILL_IN_USE + ObjectAccessedWhileStillInUse = 1047, + /// + /// D3D12_MESSAGE_ID_PROGRAMMABLE_MSAA_UNSUPPORTED + ProgrammableMsaaUnsupported = 1048, + /// + /// D3D12_MESSAGE_ID_SETSAMPLEPOSITIONS_INVALIDARGS + SetsamplepositionsInvalidargs = 1049, + /// + /// D3D12_MESSAGE_ID_RESOLVESUBRESOURCEREGION_INVALID_RECT + ResolvesubresourceregionInvalidRect = 1050, + /// + /// D3D12_MESSAGE_ID_CREATE_VIDEODECODECOMMANDQUEUE + CreateVideodecodecommandqueue = 1051, + /// + /// D3D12_MESSAGE_ID_CREATE_VIDEOPROCESSCOMMANDLIST + CreateVideoprocesscommandlist = 1052, + /// + /// D3D12_MESSAGE_ID_CREATE_VIDEOPROCESSCOMMANDQUEUE + CreateVideoprocesscommandqueue = 1053, + /// + /// D3D12_MESSAGE_ID_LIVE_VIDEODECODECOMMANDQUEUE + LiveVideodecodecommandqueue = 1054, + /// + /// D3D12_MESSAGE_ID_LIVE_VIDEOPROCESSCOMMANDLIST + LiveVideoprocesscommandlist = 1055, + /// + /// D3D12_MESSAGE_ID_LIVE_VIDEOPROCESSCOMMANDQUEUE + LiveVideoprocesscommandqueue = 1056, + /// + /// D3D12_MESSAGE_ID_DESTROY_VIDEODECODECOMMANDQUEUE + DestroyVideodecodecommandqueue = 1057, + /// + /// D3D12_MESSAGE_ID_DESTROY_VIDEOPROCESSCOMMANDLIST + DestroyVideoprocesscommandlist = 1058, + /// + /// D3D12_MESSAGE_ID_DESTROY_VIDEOPROCESSCOMMANDQUEUE + DestroyVideoprocesscommandqueue = 1059, + /// + /// D3D12_MESSAGE_ID_CREATE_VIDEOPROCESSOR + CreateVideoprocessor = 1060, + /// + /// D3D12_MESSAGE_ID_CREATE_VIDEOPROCESSSTREAM + CreateVideoprocessstream = 1061, + /// + /// D3D12_MESSAGE_ID_LIVE_VIDEOPROCESSOR + LiveVideoprocessor = 1062, + /// + /// D3D12_MESSAGE_ID_LIVE_VIDEOPROCESSSTREAM + LiveVideoprocessstream = 1063, + /// + /// D3D12_MESSAGE_ID_DESTROY_VIDEOPROCESSOR + DestroyVideoprocessor = 1064, + /// + /// D3D12_MESSAGE_ID_DESTROY_VIDEOPROCESSSTREAM + DestroyVideoprocessstream = 1065, + /// + /// D3D12_MESSAGE_ID_PROCESS_FRAME_INVALID_PARAMETERS + ProcessFrameInvalidParameters = 1066, + /// + /// D3D12_MESSAGE_ID_COPY_INVALIDLAYOUT + CopyInvalidlayout = 1067, + /// + /// D3D12_MESSAGE_ID_CREATE_CRYPTO_SESSION + CreateCryptoSession = 1068, + /// + /// D3D12_MESSAGE_ID_CREATE_CRYPTO_SESSION_POLICY + CreateCryptoSessionPolicy = 1069, + /// + /// D3D12_MESSAGE_ID_CREATE_PROTECTED_RESOURCE_SESSION + CreateProtectedResourceSession = 1070, + /// + /// D3D12_MESSAGE_ID_LIVE_CRYPTO_SESSION + LiveCryptoSession = 1071, + /// + /// D3D12_MESSAGE_ID_LIVE_CRYPTO_SESSION_POLICY + LiveCryptoSessionPolicy = 1072, + /// + /// D3D12_MESSAGE_ID_LIVE_PROTECTED_RESOURCE_SESSION + LiveProtectedResourceSession = 1073, + /// + /// D3D12_MESSAGE_ID_DESTROY_CRYPTO_SESSION + DestroyCryptoSession = 1074, + /// + /// D3D12_MESSAGE_ID_DESTROY_CRYPTO_SESSION_POLICY + DestroyCryptoSessionPolicy = 1075, + /// + /// D3D12_MESSAGE_ID_DESTROY_PROTECTED_RESOURCE_SESSION + DestroyProtectedResourceSession = 1076, + /// + /// D3D12_MESSAGE_ID_PROTECTED_RESOURCE_SESSION_UNSUPPORTED + ProtectedResourceSessionUnsupported = 1077, + /// + /// D3D12_MESSAGE_ID_FENCE_INVALIDOPERATION + FenceInvalidoperation = 1078, + /// + /// D3D12_MESSAGE_ID_CREATEQUERY_HEAP_COPY_QUEUE_TIMESTAMPS_NOT_SUPPORTED + CreatequeryHeapCopyQueueTimestampsNotSupported = 1079, + /// + /// D3D12_MESSAGE_ID_SAMPLEPOSITIONS_MISMATCH_DEFERRED + SamplepositionsMismatchDeferred = 1080, + /// + /// D3D12_MESSAGE_ID_SAMPLEPOSITIONS_MISMATCH_RECORDTIME_ASSUMEDFROMFIRSTUSE + SamplepositionsMismatchRecordtimeAssumedfromfirstuse = 1081, + /// + /// D3D12_MESSAGE_ID_SAMPLEPOSITIONS_MISMATCH_RECORDTIME_ASSUMEDFROMCLEAR + SamplepositionsMismatchRecordtimeAssumedfromclear = 1082, + /// + /// D3D12_MESSAGE_ID_CREATE_VIDEODECODERHEAP + CreateVideodecoderheap = 1083, + /// + /// D3D12_MESSAGE_ID_LIVE_VIDEODECODERHEAP + LiveVideodecoderheap = 1084, + /// + /// D3D12_MESSAGE_ID_DESTROY_VIDEODECODERHEAP + DestroyVideodecoderheap = 1085, + /// + /// D3D12_MESSAGE_ID_OPENEXISTINGHEAP_INVALIDARG_RETURN + OpenexistingheapInvalidargReturn = 1086, + /// + /// D3D12_MESSAGE_ID_OPENEXISTINGHEAP_OUTOFMEMORY_RETURN + OpenexistingheapOutofmemoryReturn = 1087, + /// + /// D3D12_MESSAGE_ID_OPENEXISTINGHEAP_INVALIDADDRESS + OpenexistingheapInvalidaddress = 1088, + /// + /// D3D12_MESSAGE_ID_OPENEXISTINGHEAP_INVALIDHANDLE + OpenexistingheapInvalidhandle = 1089, + /// + /// D3D12_MESSAGE_ID_WRITEBUFFERIMMEDIATE_INVALID_DEST + WritebufferimmediateInvalidDest = 1090, + /// + /// D3D12_MESSAGE_ID_WRITEBUFFERIMMEDIATE_INVALID_MODE + WritebufferimmediateInvalidMode = 1091, + /// + /// D3D12_MESSAGE_ID_WRITEBUFFERIMMEDIATE_INVALID_ALIGNMENT + WritebufferimmediateInvalidAlignment = 1092, + /// + /// D3D12_MESSAGE_ID_WRITEBUFFERIMMEDIATE_NOT_SUPPORTED + WritebufferimmediateNotSupported = 1093, + /// + /// D3D12_MESSAGE_ID_SETVIEWINSTANCEMASK_INVALIDARGS + SetviewinstancemaskInvalidargs = 1094, + /// + /// D3D12_MESSAGE_ID_VIEW_INSTANCING_UNSUPPORTED + ViewInstancingUnsupported = 1095, + /// + /// D3D12_MESSAGE_ID_VIEW_INSTANCING_INVALIDARGS + ViewInstancingInvalidargs = 1096, + /// + /// D3D12_MESSAGE_ID_COPYTEXTUREREGION_MISMATCH_DECODE_REFERENCE_ONLY_FLAG + CopytextureregionMismatchDecodeReferenceOnlyFlag = 1097, + /// + /// D3D12_MESSAGE_ID_COPYRESOURCE_MISMATCH_DECODE_REFERENCE_ONLY_FLAG + CopyresourceMismatchDecodeReferenceOnlyFlag = 1098, + /// + /// D3D12_MESSAGE_ID_CREATE_VIDEO_DECODE_HEAP_CAPS_FAILURE + CreateVideoDecodeHeapCapsFailure = 1099, + /// + /// D3D12_MESSAGE_ID_CREATE_VIDEO_DECODE_HEAP_CAPS_UNSUPPORTED + CreateVideoDecodeHeapCapsUnsupported = 1100, + /// + /// D3D12_MESSAGE_ID_VIDEO_DECODE_SUPPORT_INVALID_INPUT + VideoDecodeSupportInvalidInput = 1101, + /// + /// D3D12_MESSAGE_ID_CREATE_VIDEO_DECODER_UNSUPPORTED + CreateVideoDecoderUnsupported = 1102, + /// + /// D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_METADATA_ERROR + CreategraphicspipelinestateMetadataError = 1103, + /// + /// D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_VIEW_INSTANCING_VERTEX_SIZE_EXCEEDED + CreategraphicspipelinestateViewInstancingVertexSizeExceeded = 1104, + /// + /// D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_RUNTIME_INTERNAL_ERROR + CreategraphicspipelinestateRuntimeInternalError = 1105, + /// + /// D3D12_MESSAGE_ID_NO_VIDEO_API_SUPPORT + NoVideoApiSupport = 1106, + /// + /// D3D12_MESSAGE_ID_VIDEO_PROCESS_SUPPORT_INVALID_INPUT + VideoProcessSupportInvalidInput = 1107, + /// + /// D3D12_MESSAGE_ID_CREATE_VIDEO_PROCESSOR_CAPS_FAILURE + CreateVideoProcessorCapsFailure = 1108, + /// + /// D3D12_MESSAGE_ID_VIDEO_PROCESS_SUPPORT_UNSUPPORTED_FORMAT + VideoProcessSupportUnsupportedFormat = 1109, + /// + /// D3D12_MESSAGE_ID_VIDEO_DECODE_FRAME_INVALID_ARGUMENT + VideoDecodeFrameInvalidArgument = 1110, + /// + /// D3D12_MESSAGE_ID_ENQUEUE_MAKE_RESIDENT_INVALID_FLAGS + EnqueueMakeResidentInvalidFlags = 1111, + /// + /// D3D12_MESSAGE_ID_OPENEXISTINGHEAP_UNSUPPORTED + OpenexistingheapUnsupported = 1112, + /// + /// D3D12_MESSAGE_ID_VIDEO_PROCESS_FRAMES_INVALID_ARGUMENT + VideoProcessFramesInvalidArgument = 1113, + /// + /// D3D12_MESSAGE_ID_VIDEO_DECODE_SUPPORT_UNSUPPORTED + VideoDecodeSupportUnsupported = 1114, + /// + /// D3D12_MESSAGE_ID_CREATE_COMMANDRECORDER + CreateCommandrecorder = 1115, + /// + /// D3D12_MESSAGE_ID_LIVE_COMMANDRECORDER + LiveCommandrecorder = 1116, + /// + /// D3D12_MESSAGE_ID_DESTROY_COMMANDRECORDER + DestroyCommandrecorder = 1117, + /// + /// D3D12_MESSAGE_ID_CREATE_COMMAND_RECORDER_VIDEO_NOT_SUPPORTED + CreateCommandRecorderVideoNotSupported = 1118, + /// + /// D3D12_MESSAGE_ID_CREATE_COMMAND_RECORDER_INVALID_SUPPORT_FLAGS + CreateCommandRecorderInvalidSupportFlags = 1119, + /// + /// D3D12_MESSAGE_ID_CREATE_COMMAND_RECORDER_INVALID_FLAGS + CreateCommandRecorderInvalidFlags = 1120, + /// + /// D3D12_MESSAGE_ID_CREATE_COMMAND_RECORDER_MORE_RECORDERS_THAN_LOGICAL_PROCESSORS + CreateCommandRecorderMoreRecordersThanLogicalProcessors = 1121, + /// + /// D3D12_MESSAGE_ID_CREATE_COMMANDPOOL + CreateCommandpool = 1122, + /// + /// D3D12_MESSAGE_ID_LIVE_COMMANDPOOL + LiveCommandpool = 1123, + /// + /// D3D12_MESSAGE_ID_DESTROY_COMMANDPOOL + DestroyCommandpool = 1124, + /// + /// D3D12_MESSAGE_ID_CREATE_COMMAND_POOL_INVALID_FLAGS + CreateCommandPoolInvalidFlags = 1125, + /// + /// D3D12_MESSAGE_ID_CREATE_COMMAND_LIST_VIDEO_NOT_SUPPORTED + CreateCommandListVideoNotSupported = 1126, + /// + /// D3D12_MESSAGE_ID_COMMAND_RECORDER_SUPPORT_FLAGS_MISMATCH + CommandRecorderSupportFlagsMismatch = 1127, + /// + /// D3D12_MESSAGE_ID_COMMAND_RECORDER_CONTENTION + CommandRecorderContention = 1128, + /// + /// D3D12_MESSAGE_ID_COMMAND_RECORDER_USAGE_WITH_CREATECOMMANDLIST_COMMAND_LIST + CommandRecorderUsageWithCreatecommandlistCommandList = 1129, + /// + /// D3D12_MESSAGE_ID_COMMAND_ALLOCATOR_USAGE_WITH_CREATECOMMANDLIST1_COMMAND_LIST + CommandAllocatorUsageWithCreatecommandlist1CommandList = 1130, + /// + /// D3D12_MESSAGE_ID_CANNOT_EXECUTE_EMPTY_COMMAND_LIST + CannotExecuteEmptyCommandList = 1131, + /// + /// D3D12_MESSAGE_ID_CANNOT_RESET_COMMAND_POOL_WITH_OPEN_COMMAND_LISTS + CannotResetCommandPoolWithOpenCommandLists = 1132, + /// + /// D3D12_MESSAGE_ID_CANNOT_USE_COMMAND_RECORDER_WITHOUT_CURRENT_TARGET + CannotUseCommandRecorderWithoutCurrentTarget = 1133, + /// + /// D3D12_MESSAGE_ID_CANNOT_CHANGE_COMMAND_RECORDER_TARGET_WHILE_RECORDING + CannotChangeCommandRecorderTargetWhileRecording = 1134, + /// + /// D3D12_MESSAGE_ID_COMMAND_POOL_SYNC + CommandPoolSync = 1135, + /// + /// D3D12_MESSAGE_ID_EVICT_UNDERFLOW + EvictUnderflow = 1136, + /// + /// D3D12_MESSAGE_ID_CREATE_META_COMMAND + CreateMetaCommand = 1137, + /// + /// D3D12_MESSAGE_ID_LIVE_META_COMMAND + LiveMetaCommand = 1138, + /// + /// D3D12_MESSAGE_ID_DESTROY_META_COMMAND + DestroyMetaCommand = 1139, + /// + /// D3D12_MESSAGE_ID_COPYBUFFERREGION_INVALID_DST_RESOURCE + CopybufferregionInvalidDstResource = 1140, + /// + /// D3D12_MESSAGE_ID_COPYBUFFERREGION_INVALID_SRC_RESOURCE + CopybufferregionInvalidSrcResource = 1141, + /// + /// D3D12_MESSAGE_ID_ATOMICCOPYBUFFER_INVALID_DST_RESOURCE + AtomiccopybufferInvalidDstResource = 1142, + /// + /// D3D12_MESSAGE_ID_ATOMICCOPYBUFFER_INVALID_SRC_RESOURCE + AtomiccopybufferInvalidSrcResource = 1143, + /// + /// D3D12_MESSAGE_ID_CREATEPLACEDRESOURCEONBUFFER_NULL_BUFFER + CreateplacedresourceonbufferNullBuffer = 1144, + /// + /// D3D12_MESSAGE_ID_CREATEPLACEDRESOURCEONBUFFER_NULL_RESOURCE_DESC + CreateplacedresourceonbufferNullResourceDesc = 1145, + /// + /// D3D12_MESSAGE_ID_CREATEPLACEDRESOURCEONBUFFER_UNSUPPORTED + CreateplacedresourceonbufferUnsupported = 1146, + /// + /// D3D12_MESSAGE_ID_CREATEPLACEDRESOURCEONBUFFER_INVALID_BUFFER_DIMENSION + CreateplacedresourceonbufferInvalidBufferDimension = 1147, + /// + /// D3D12_MESSAGE_ID_CREATEPLACEDRESOURCEONBUFFER_INVALID_BUFFER_FLAGS + CreateplacedresourceonbufferInvalidBufferFlags = 1148, + /// + /// D3D12_MESSAGE_ID_CREATEPLACEDRESOURCEONBUFFER_INVALID_BUFFER_OFFSET + CreateplacedresourceonbufferInvalidBufferOffset = 1149, + /// + /// D3D12_MESSAGE_ID_CREATEPLACEDRESOURCEONBUFFER_INVALID_RESOURCE_DIMENSION + CreateplacedresourceonbufferInvalidResourceDimension = 1150, + /// + /// D3D12_MESSAGE_ID_CREATEPLACEDRESOURCEONBUFFER_INVALID_RESOURCE_FLAGS + CreateplacedresourceonbufferInvalidResourceFlags = 1151, + /// + /// D3D12_MESSAGE_ID_CREATEPLACEDRESOURCEONBUFFER_OUTOFMEMORY_RETURN + CreateplacedresourceonbufferOutofmemoryReturn = 1152, + /// + /// D3D12_MESSAGE_ID_CANNOT_CREATE_GRAPHICS_AND_VIDEO_COMMAND_RECORDER + CannotCreateGraphicsAndVideoCommandRecorder = 1153, + /// + /// D3D12_MESSAGE_ID_UPDATETILEMAPPINGS_POSSIBLY_MISMATCHING_PROPERTIES + UpdatetilemappingsPossiblyMismatchingProperties = 1154, + /// + /// D3D12_MESSAGE_ID_CREATE_COMMAND_LIST_INVALID_COMMAND_LIST_TYPE + CreateCommandListInvalidCommandListType = 1155, + /// + /// D3D12_MESSAGE_ID_CLEARUNORDEREDACCESSVIEW_INCOMPATIBLE_WITH_STRUCTURED_BUFFERS + ClearunorderedaccessviewIncompatibleWithStructuredBuffers = 1156, + /// + /// D3D12_MESSAGE_ID_COMPUTE_ONLY_DEVICE_OPERATION_UNSUPPORTED + ComputeOnlyDeviceOperationUnsupported = 1157, + /// + /// D3D12_MESSAGE_ID_BUILD_RAYTRACING_ACCELERATION_STRUCTURE_INVALID + BuildRaytracingAccelerationStructureInvalid = 1158, + /// + /// D3D12_MESSAGE_ID_EMIT_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_INVALID + EmitRaytracingAccelerationStructurePostbuildInfoInvalid = 1159, + /// + /// D3D12_MESSAGE_ID_COPY_RAYTRACING_ACCELERATION_STRUCTURE_INVALID + CopyRaytracingAccelerationStructureInvalid = 1160, + /// + /// D3D12_MESSAGE_ID_DISPATCH_RAYS_INVALID + DispatchRaysInvalid = 1161, + /// + /// D3D12_MESSAGE_ID_GET_RAYTRACING_ACCELERATION_STRUCTURE_PREBUILD_INFO_INVALID + GetRaytracingAccelerationStructurePrebuildInfoInvalid = 1162, + /// + /// D3D12_MESSAGE_ID_CREATE_LIFETIMETRACKER + CreateLifetimetracker = 1163, + /// + /// D3D12_MESSAGE_ID_LIVE_LIFETIMETRACKER + LiveLifetimetracker = 1164, + /// + /// D3D12_MESSAGE_ID_DESTROY_LIFETIMETRACKER + DestroyLifetimetracker = 1165, + /// + /// D3D12_MESSAGE_ID_DESTROYOWNEDOBJECT_OBJECTNOTOWNED + DestroyownedobjectObjectnotowned = 1166, + /// + /// D3D12_MESSAGE_ID_CREATE_TRACKEDWORKLOAD + CreateTrackedworkload = 1167, + /// + /// D3D12_MESSAGE_ID_LIVE_TRACKEDWORKLOAD + LiveTrackedworkload = 1168, + /// + /// D3D12_MESSAGE_ID_DESTROY_TRACKEDWORKLOAD + DestroyTrackedworkload = 1169, + /// + /// D3D12_MESSAGE_ID_RENDER_PASS_ERROR + RenderPassError = 1170, + /// + /// D3D12_MESSAGE_ID_META_COMMAND_ID_INVALID + MetaCommandIdInvalid = 1171, + /// + /// D3D12_MESSAGE_ID_META_COMMAND_UNSUPPORTED_PARAMS + MetaCommandUnsupportedParams = 1172, + /// + /// D3D12_MESSAGE_ID_META_COMMAND_FAILED_ENUMERATION + MetaCommandFailedEnumeration = 1173, + /// + /// D3D12_MESSAGE_ID_META_COMMAND_PARAMETER_SIZE_MISMATCH + MetaCommandParameterSizeMismatch = 1174, + /// + /// D3D12_MESSAGE_ID_UNINITIALIZED_META_COMMAND + UninitializedMetaCommand = 1175, + /// + /// D3D12_MESSAGE_ID_META_COMMAND_INVALID_GPU_VIRTUAL_ADDRESS + MetaCommandInvalidGpuVirtualAddress = 1176, + /// + /// D3D12_MESSAGE_ID_CREATE_VIDEOENCODECOMMANDLIST + CreateVideoencodecommandlist = 1177, + /// + /// D3D12_MESSAGE_ID_LIVE_VIDEOENCODECOMMANDLIST + LiveVideoencodecommandlist = 1178, + /// + /// D3D12_MESSAGE_ID_DESTROY_VIDEOENCODECOMMANDLIST + DestroyVideoencodecommandlist = 1179, + /// + /// D3D12_MESSAGE_ID_CREATE_VIDEOENCODECOMMANDQUEUE + CreateVideoencodecommandqueue = 1180, + /// + /// D3D12_MESSAGE_ID_LIVE_VIDEOENCODECOMMANDQUEUE + LiveVideoencodecommandqueue = 1181, + /// + /// D3D12_MESSAGE_ID_DESTROY_VIDEOENCODECOMMANDQUEUE + DestroyVideoencodecommandqueue = 1182, + /// + /// D3D12_MESSAGE_ID_CREATE_VIDEOMOTIONESTIMATOR + CreateVideomotionestimator = 1183, + /// + /// D3D12_MESSAGE_ID_LIVE_VIDEOMOTIONESTIMATOR + LiveVideomotionestimator = 1184, + /// + /// D3D12_MESSAGE_ID_DESTROY_VIDEOMOTIONESTIMATOR + DestroyVideomotionestimator = 1185, + /// + /// D3D12_MESSAGE_ID_CREATE_VIDEOMOTIONVECTORHEAP + CreateVideomotionvectorheap = 1186, + /// + /// D3D12_MESSAGE_ID_LIVE_VIDEOMOTIONVECTORHEAP + LiveVideomotionvectorheap = 1187, + /// + /// D3D12_MESSAGE_ID_DESTROY_VIDEOMOTIONVECTORHEAP + DestroyVideomotionvectorheap = 1188, + /// + /// D3D12_MESSAGE_ID_MULTIPLE_TRACKED_WORKLOADS + MultipleTrackedWorkloads = 1189, + /// + /// D3D12_MESSAGE_ID_MULTIPLE_TRACKED_WORKLOAD_PAIRS + MultipleTrackedWorkloadPairs = 1190, + /// + /// D3D12_MESSAGE_ID_OUT_OF_ORDER_TRACKED_WORKLOAD_PAIR + OutOfOrderTrackedWorkloadPair = 1191, + /// + /// D3D12_MESSAGE_ID_CANNOT_ADD_TRACKED_WORKLOAD + CannotAddTrackedWorkload = 1192, + /// + /// D3D12_MESSAGE_ID_INCOMPLETE_TRACKED_WORKLOAD_PAIR + IncompleteTrackedWorkloadPair = 1193, + /// + /// D3D12_MESSAGE_ID_CREATE_STATE_OBJECT_ERROR + CreateStateObjectError = 1194, + /// + /// D3D12_MESSAGE_ID_GET_SHADER_IDENTIFIER_ERROR + GetShaderIdentifierError = 1195, + /// + /// D3D12_MESSAGE_ID_GET_SHADER_STACK_SIZE_ERROR + GetShaderStackSizeError = 1196, + /// + /// D3D12_MESSAGE_ID_GET_PIPELINE_STACK_SIZE_ERROR + GetPipelineStackSizeError = 1197, + /// + /// D3D12_MESSAGE_ID_SET_PIPELINE_STACK_SIZE_ERROR + SetPipelineStackSizeError = 1198, + /// + /// D3D12_MESSAGE_ID_GET_SHADER_IDENTIFIER_SIZE_INVALID + GetShaderIdentifierSizeInvalid = 1199, + /// + /// D3D12_MESSAGE_ID_CHECK_DRIVER_MATCHING_IDENTIFIER_INVALID + CheckDriverMatchingIdentifierInvalid = 1200, + /// + /// D3D12_MESSAGE_ID_CHECK_DRIVER_MATCHING_IDENTIFIER_DRIVER_REPORTED_ISSUE + CheckDriverMatchingIdentifierDriverReportedIssue = 1201, + /// + /// D3D12_MESSAGE_ID_RENDER_PASS_INVALID_RESOURCE_BARRIER + RenderPassInvalidResourceBarrier = 1202, + /// + /// D3D12_MESSAGE_ID_RENDER_PASS_DISALLOWED_API_CALLED + RenderPassDisallowedApiCalled = 1203, + /// + /// D3D12_MESSAGE_ID_RENDER_PASS_CANNOT_NEST_RENDER_PASSES + RenderPassCannotNestRenderPasses = 1204, + /// + /// D3D12_MESSAGE_ID_RENDER_PASS_CANNOT_END_WITHOUT_BEGIN + RenderPassCannotEndWithoutBegin = 1205, + /// + /// D3D12_MESSAGE_ID_RENDER_PASS_CANNOT_CLOSE_COMMAND_LIST + RenderPassCannotCloseCommandList = 1206, + /// + /// D3D12_MESSAGE_ID_RENDER_PASS_GPU_WORK_WHILE_SUSPENDED + RenderPassGpuWorkWhileSuspended = 1207, + /// + /// D3D12_MESSAGE_ID_RENDER_PASS_MISMATCHING_SUSPEND_RESUME + RenderPassMismatchingSuspendResume = 1208, + /// + /// D3D12_MESSAGE_ID_RENDER_PASS_NO_PRIOR_SUSPEND_WITHIN_EXECUTECOMMANDLISTS + RenderPassNoPriorSuspendWithinExecutecommandlists = 1209, + /// + /// D3D12_MESSAGE_ID_RENDER_PASS_NO_SUBSEQUENT_RESUME_WITHIN_EXECUTECOMMANDLISTS + RenderPassNoSubsequentResumeWithinExecutecommandlists = 1210, + /// + /// D3D12_MESSAGE_ID_TRACKED_WORKLOAD_COMMAND_QUEUE_MISMATCH + TrackedWorkloadCommandQueueMismatch = 1211, + /// + /// D3D12_MESSAGE_ID_TRACKED_WORKLOAD_NOT_SUPPORTED + TrackedWorkloadNotSupported = 1212, + /// + /// D3D12_MESSAGE_ID_RENDER_PASS_MISMATCHING_NO_ACCESS + RenderPassMismatchingNoAccess = 1213, + /// + /// D3D12_MESSAGE_ID_RENDER_PASS_UNSUPPORTED_RESOLVE + RenderPassUnsupportedResolve = 1214, + /// + /// D3D12_MESSAGE_ID_CLEARUNORDEREDACCESSVIEW_INVALID_RESOURCE_PTR + ClearunorderedaccessviewInvalidResourcePtr = 1215, + /// + /// D3D12_MESSAGE_ID_WINDOWS7_FENCE_OUTOFORDER_SIGNAL + Windows7FenceOutoforderSignal = 1216, + /// + /// D3D12_MESSAGE_ID_WINDOWS7_FENCE_OUTOFORDER_WAIT + Windows7FenceOutoforderWait = 1217, + /// + /// D3D12_MESSAGE_ID_VIDEO_CREATE_MOTION_ESTIMATOR_INVALID_ARGUMENT + VideoCreateMotionEstimatorInvalidArgument = 1218, + /// + /// D3D12_MESSAGE_ID_VIDEO_CREATE_MOTION_VECTOR_HEAP_INVALID_ARGUMENT + VideoCreateMotionVectorHeapInvalidArgument = 1219, + /// + /// D3D12_MESSAGE_ID_ESTIMATE_MOTION_INVALID_ARGUMENT + EstimateMotionInvalidArgument = 1220, + /// + /// D3D12_MESSAGE_ID_RESOLVE_MOTION_VECTOR_HEAP_INVALID_ARGUMENT + ResolveMotionVectorHeapInvalidArgument = 1221, + /// + /// D3D12_MESSAGE_ID_GETGPUVIRTUALADDRESS_INVALID_HEAP_TYPE + GetgpuvirtualaddressInvalidHeapType = 1222, + /// + /// D3D12_MESSAGE_ID_SET_BACKGROUND_PROCESSING_MODE_INVALID_ARGUMENT + SetBackgroundProcessingModeInvalidArgument = 1223, + /// + /// D3D12_MESSAGE_ID_CREATE_COMMAND_LIST_INVALID_COMMAND_LIST_TYPE_FOR_FEATURE_LEVEL + CreateCommandListInvalidCommandListTypeForFeatureLevel = 1224, + /// + /// D3D12_MESSAGE_ID_CREATE_VIDEOEXTENSIONCOMMAND + CreateVideoextensioncommand = 1225, + /// + /// D3D12_MESSAGE_ID_LIVE_VIDEOEXTENSIONCOMMAND + LiveVideoextensioncommand = 1226, + /// + /// D3D12_MESSAGE_ID_DESTROY_VIDEOEXTENSIONCOMMAND + DestroyVideoextensioncommand = 1227, + /// + /// D3D12_MESSAGE_ID_INVALID_VIDEO_EXTENSION_COMMAND_ID + InvalidVideoExtensionCommandId = 1228, + /// + /// D3D12_MESSAGE_ID_VIDEO_EXTENSION_COMMAND_INVALID_ARGUMENT + VideoExtensionCommandInvalidArgument = 1229, + /// + /// D3D12_MESSAGE_ID_CREATE_ROOT_SIGNATURE_NOT_UNIQUE_IN_DXIL_LIBRARY + CreateRootSignatureNotUniqueInDxilLibrary = 1230, + /// + /// D3D12_MESSAGE_ID_VARIABLE_SHADING_RATE_NOT_ALLOWED_WITH_TIR + VariableShadingRateNotAllowedWithTir = 1231, + /// + /// D3D12_MESSAGE_ID_GEOMETRY_SHADER_OUTPUTTING_BOTH_VIEWPORT_ARRAY_INDEX_AND_SHADING_RATE_NOT_SUPPORTED_ON_DEVICE + GeometryShaderOutputtingBothViewportArrayIndexAndShadingRateNotSupportedOnDevice = 1232, + /// + /// D3D12_MESSAGE_ID_RSSETSHADING_RATE_INVALID_SHADING_RATE + RssetshadingRateInvalidShadingRate = 1233, + /// + /// D3D12_MESSAGE_ID_RSSETSHADING_RATE_SHADING_RATE_NOT_PERMITTED_BY_CAP + RssetshadingRateShadingRateNotPermittedByCap = 1234, + /// + /// D3D12_MESSAGE_ID_RSSETSHADING_RATE_INVALID_COMBINER + RssetshadingRateInvalidCombiner = 1235, + /// + /// D3D12_MESSAGE_ID_RSSETSHADINGRATEIMAGE_REQUIRES_TIER_2 + RssetshadingrateimageRequiresTier2 = 1236, + /// + /// D3D12_MESSAGE_ID_RSSETSHADINGRATE_REQUIRES_TIER_1 + RssetshadingrateRequiresTier1 = 1237, + /// + /// D3D12_MESSAGE_ID_SHADING_RATE_IMAGE_INCORRECT_FORMAT + ShadingRateImageIncorrectFormat = 1238, + /// + /// D3D12_MESSAGE_ID_SHADING_RATE_IMAGE_INCORRECT_ARRAY_SIZE + ShadingRateImageIncorrectArraySize = 1239, + /// + /// D3D12_MESSAGE_ID_SHADING_RATE_IMAGE_INCORRECT_MIP_LEVEL + ShadingRateImageIncorrectMipLevel = 1240, + /// + /// D3D12_MESSAGE_ID_SHADING_RATE_IMAGE_INCORRECT_SAMPLE_COUNT + ShadingRateImageIncorrectSampleCount = 1241, + /// + /// D3D12_MESSAGE_ID_SHADING_RATE_IMAGE_INCORRECT_SAMPLE_QUALITY + ShadingRateImageIncorrectSampleQuality = 1242, + /// + /// D3D12_MESSAGE_ID_NON_RETAIL_SHADER_MODEL_WONT_VALIDATE + NonRetailShaderModelWontValidate = 1243, + /// + /// D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_AS_ROOT_SIGNATURE_MISMATCH + CreategraphicspipelinestateAsRootSignatureMismatch = 1244, + /// + /// D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_MS_ROOT_SIGNATURE_MISMATCH + CreategraphicspipelinestateMsRootSignatureMismatch = 1245, + /// + /// D3D12_MESSAGE_ID_ADD_TO_STATE_OBJECT_ERROR + AddToStateObjectError = 1246, + /// + /// D3D12_MESSAGE_ID_CREATE_PROTECTED_RESOURCE_SESSION_INVALID_ARGUMENT + CreateProtectedResourceSessionInvalidArgument = 1247, + /// + /// D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_MS_PSO_DESC_MISMATCH + CreategraphicspipelinestateMsPsoDescMismatch = 1248, + /// + /// D3D12_MESSAGE_ID_CREATEPIPELINESTATE_MS_INCOMPLETE_TYPE + CreatepipelinestateMsIncompleteType = 1249, + /// + /// D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_AS_NOT_MS_MISMATCH + CreategraphicspipelinestateAsNotMsMismatch = 1250, + /// + /// D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_MS_NOT_PS_MISMATCH + CreategraphicspipelinestateMsNotPsMismatch = 1251, + /// + /// D3D12_MESSAGE_ID_NONZERO_SAMPLER_FEEDBACK_MIP_REGION_WITH_INCOMPATIBLE_FORMAT + NonzeroSamplerFeedbackMipRegionWithIncompatibleFormat = 1252, + /// + /// D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_INPUTLAYOUT_SHADER_MISMATCH + CreategraphicspipelinestateInputlayoutShaderMismatch = 1253, + /// + /// D3D12_MESSAGE_ID_EMPTY_DISPATCH + EmptyDispatch = 1254, + /// + /// D3D12_MESSAGE_ID_RESOURCE_FORMAT_REQUIRES_SAMPLER_FEEDBACK_CAPABILITY + ResourceFormatRequiresSamplerFeedbackCapability = 1255, + /// + /// D3D12_MESSAGE_ID_SAMPLER_FEEDBACK_MAP_INVALID_MIP_REGION + SamplerFeedbackMapInvalidMipRegion = 1256, + /// + /// D3D12_MESSAGE_ID_SAMPLER_FEEDBACK_MAP_INVALID_DIMENSION + SamplerFeedbackMapInvalidDimension = 1257, + /// + /// D3D12_MESSAGE_ID_SAMPLER_FEEDBACK_MAP_INVALID_SAMPLE_COUNT + SamplerFeedbackMapInvalidSampleCount = 1258, + /// + /// D3D12_MESSAGE_ID_SAMPLER_FEEDBACK_MAP_INVALID_SAMPLE_QUALITY + SamplerFeedbackMapInvalidSampleQuality = 1259, + /// + /// D3D12_MESSAGE_ID_SAMPLER_FEEDBACK_MAP_INVALID_LAYOUT + SamplerFeedbackMapInvalidLayout = 1260, + /// + /// D3D12_MESSAGE_ID_SAMPLER_FEEDBACK_MAP_REQUIRES_UNORDERED_ACCESS_FLAG + SamplerFeedbackMapRequiresUnorderedAccessFlag = 1261, + /// + /// D3D12_MESSAGE_ID_SAMPLER_FEEDBACK_CREATE_UAV_NULL_ARGUMENTS + SamplerFeedbackCreateUavNullArguments = 1262, + /// + /// D3D12_MESSAGE_ID_SAMPLER_FEEDBACK_UAV_REQUIRES_SAMPLER_FEEDBACK_CAPABILITY + SamplerFeedbackUavRequiresSamplerFeedbackCapability = 1263, + /// + /// D3D12_MESSAGE_ID_SAMPLER_FEEDBACK_CREATE_UAV_REQUIRES_FEEDBACK_MAP_FORMAT + SamplerFeedbackCreateUavRequiresFeedbackMapFormat = 1264, + /// + /// D3D12_MESSAGE_ID_CREATEMESHSHADER_INVALIDSHADERBYTECODE + CreatemeshshaderInvalidshaderbytecode = 1265, + /// + /// D3D12_MESSAGE_ID_CREATEMESHSHADER_OUTOFMEMORY + CreatemeshshaderOutofmemory = 1266, + /// + /// D3D12_MESSAGE_ID_CREATEMESHSHADERWITHSTREAMOUTPUT_INVALIDSHADERTYPE + CreatemeshshaderwithstreamoutputInvalidshadertype = 1267, + /// + /// D3D12_MESSAGE_ID_RESOLVESUBRESOURCE_SAMPLER_FEEDBACK_TRANSCODE_INVALID_FORMAT + ResolvesubresourceSamplerFeedbackTranscodeInvalidFormat = 1268, + /// + /// D3D12_MESSAGE_ID_RESOLVESUBRESOURCE_SAMPLER_FEEDBACK_INVALID_MIP_LEVEL_COUNT + ResolvesubresourceSamplerFeedbackInvalidMipLevelCount = 1269, + /// + /// D3D12_MESSAGE_ID_RESOLVESUBRESOURCE_SAMPLER_FEEDBACK_TRANSCODE_ARRAY_SIZE_MISMATCH + ResolvesubresourceSamplerFeedbackTranscodeArraySizeMismatch = 1270, + /// + /// D3D12_MESSAGE_ID_SAMPLER_FEEDBACK_CREATE_UAV_MISMATCHING_TARGETED_RESOURCE + SamplerFeedbackCreateUavMismatchingTargetedResource = 1271, + /// + /// D3D12_MESSAGE_ID_CREATEMESHSHADER_OUTPUTEXCEEDSMAXSIZE + CreatemeshshaderOutputexceedsmaxsize = 1272, + /// + /// D3D12_MESSAGE_ID_CREATEMESHSHADER_GROUPSHAREDEXCEEDSMAXSIZE + CreatemeshshaderGroupsharedexceedsmaxsize = 1273, + /// + /// D3D12_MESSAGE_ID_VERTEX_SHADER_OUTPUTTING_BOTH_VIEWPORT_ARRAY_INDEX_AND_SHADING_RATE_NOT_SUPPORTED_ON_DEVICE + VertexShaderOutputtingBothViewportArrayIndexAndShadingRateNotSupportedOnDevice = 1274, + /// + /// D3D12_MESSAGE_ID_MESH_SHADER_OUTPUTTING_BOTH_VIEWPORT_ARRAY_INDEX_AND_SHADING_RATE_NOT_SUPPORTED_ON_DEVICE + MeshShaderOutputtingBothViewportArrayIndexAndShadingRateNotSupportedOnDevice = 1275, + /// + /// D3D12_MESSAGE_ID_CREATEMESHSHADER_MISMATCHEDASMSPAYLOADSIZE + CreatemeshshaderMismatchedasmspayloadsize = 1276, + /// + /// D3D12_MESSAGE_ID_CREATE_ROOT_SIGNATURE_UNBOUNDED_STATIC_DESCRIPTORS + CreateRootSignatureUnboundedStaticDescriptors = 1277, + /// + /// D3D12_MESSAGE_ID_CREATEAMPLIFICATIONSHADER_INVALIDSHADERBYTECODE + CreateamplificationshaderInvalidshaderbytecode = 1278, + /// + /// D3D12_MESSAGE_ID_CREATEAMPLIFICATIONSHADER_OUTOFMEMORY + CreateamplificationshaderOutofmemory = 1279, + /// + /// D3D12_MESSAGE_ID_CREATE_SHADERCACHESESSION + CreateShadercachesession = 1280, + /// + /// D3D12_MESSAGE_ID_LIVE_SHADERCACHESESSION + LiveShadercachesession = 1281, + /// + /// D3D12_MESSAGE_ID_DESTROY_SHADERCACHESESSION + DestroyShadercachesession = 1282, + /// + /// D3D12_MESSAGE_ID_CREATESHADERCACHESESSION_INVALIDARGS + CreateshadercachesessionInvalidargs = 1283, + /// + /// D3D12_MESSAGE_ID_CREATESHADERCACHESESSION_DISABLED + CreateshadercachesessionDisabled = 1284, + /// + /// D3D12_MESSAGE_ID_CREATESHADERCACHESESSION_ALREADYOPEN + CreateshadercachesessionAlreadyopen = 1285, + /// + /// D3D12_MESSAGE_ID_SHADERCACHECONTROL_DEVELOPERMODE + ShadercachecontrolDevelopermode = 1286, + /// + /// D3D12_MESSAGE_ID_SHADERCACHECONTROL_INVALIDFLAGS + ShadercachecontrolInvalidflags = 1287, + /// + /// D3D12_MESSAGE_ID_SHADERCACHECONTROL_STATEALREADYSET + ShadercachecontrolStatealreadyset = 1288, + /// + /// D3D12_MESSAGE_ID_SHADERCACHECONTROL_IGNOREDFLAG + ShadercachecontrolIgnoredflag = 1289, + /// + /// D3D12_MESSAGE_ID_SHADERCACHESESSION_STOREVALUE_ALREADYPRESENT + ShadercachesessionStorevalueAlreadypresent = 1290, + /// + /// D3D12_MESSAGE_ID_SHADERCACHESESSION_STOREVALUE_HASHCOLLISION + ShadercachesessionStorevalueHashcollision = 1291, + /// + /// D3D12_MESSAGE_ID_SHADERCACHESESSION_STOREVALUE_CACHEFULL + ShadercachesessionStorevalueCachefull = 1292, + /// + /// D3D12_MESSAGE_ID_SHADERCACHESESSION_FINDVALUE_NOTFOUND + ShadercachesessionFindvalueNotfound = 1293, + /// + /// D3D12_MESSAGE_ID_SHADERCACHESESSION_CORRUPT + ShadercachesessionCorrupt = 1294, + /// + /// D3D12_MESSAGE_ID_SHADERCACHESESSION_DISABLED + ShadercachesessionDisabled = 1295, + /// + /// D3D12_MESSAGE_ID_OVERSIZED_DISPATCH + OversizedDispatch = 1296, + /// + /// D3D12_MESSAGE_ID_CREATE_VIDEOENCODER + CreateVideoencoder = 1297, + /// + /// D3D12_MESSAGE_ID_LIVE_VIDEOENCODER + LiveVideoencoder = 1298, + /// + /// D3D12_MESSAGE_ID_DESTROY_VIDEOENCODER + DestroyVideoencoder = 1299, + /// + /// D3D12_MESSAGE_ID_CREATE_VIDEOENCODERHEAP + CreateVideoencoderheap = 1300, + /// + /// D3D12_MESSAGE_ID_LIVE_VIDEOENCODERHEAP + LiveVideoencoderheap = 1301, + /// + /// D3D12_MESSAGE_ID_DESTROY_VIDEOENCODERHEAP + DestroyVideoencoderheap = 1302, + /// + /// D3D12_MESSAGE_ID_COPYTEXTUREREGION_MISMATCH_ENCODE_REFERENCE_ONLY_FLAG + CopytextureregionMismatchEncodeReferenceOnlyFlag = 1303, + /// + /// D3D12_MESSAGE_ID_COPYRESOURCE_MISMATCH_ENCODE_REFERENCE_ONLY_FLAG + CopyresourceMismatchEncodeReferenceOnlyFlag = 1304, + /// + /// D3D12_MESSAGE_ID_ENCODE_FRAME_INVALID_PARAMETERS + EncodeFrameInvalidParameters = 1305, + /// + /// D3D12_MESSAGE_ID_ENCODE_FRAME_UNSUPPORTED_PARAMETERS + EncodeFrameUnsupportedParameters = 1306, + /// + /// D3D12_MESSAGE_ID_RESOLVE_ENCODER_OUTPUT_METADATA_INVALID_PARAMETERS + ResolveEncoderOutputMetadataInvalidParameters = 1307, + /// + /// D3D12_MESSAGE_ID_RESOLVE_ENCODER_OUTPUT_METADATA_UNSUPPORTED_PARAMETERS + ResolveEncoderOutputMetadataUnsupportedParameters = 1308, + /// + /// D3D12_MESSAGE_ID_CREATE_VIDEO_ENCODER_INVALID_PARAMETERS + CreateVideoEncoderInvalidParameters = 1309, + /// + /// D3D12_MESSAGE_ID_CREATE_VIDEO_ENCODER_UNSUPPORTED_PARAMETERS + CreateVideoEncoderUnsupportedParameters = 1310, + /// + /// D3D12_MESSAGE_ID_CREATE_VIDEO_ENCODER_HEAP_INVALID_PARAMETERS + CreateVideoEncoderHeapInvalidParameters = 1311, + /// + /// D3D12_MESSAGE_ID_CREATE_VIDEO_ENCODER_HEAP_UNSUPPORTED_PARAMETERS + CreateVideoEncoderHeapUnsupportedParameters = 1312, + /// + /// D3D12_MESSAGE_ID_CREATECOMMANDLIST_NULL_COMMANDALLOCATOR + CreatecommandlistNullCommandallocator = 1313, + /// + /// D3D12_MESSAGE_ID_CLEAR_UNORDERED_ACCESS_VIEW_INVALID_DESCRIPTOR_HANDLE + ClearUnorderedAccessViewInvalidDescriptorHandle = 1314, + /// + /// D3D12_MESSAGE_ID_DESCRIPTOR_HEAP_NOT_SHADER_VISIBLE + DescriptorHeapNotShaderVisible = 1315, + /// + /// D3D12_MESSAGE_ID_CREATEBLENDSTATE_BLENDOP_WARNING + CreateblendstateBlendopWarning = 1316, + /// + /// D3D12_MESSAGE_ID_CREATEBLENDSTATE_BLENDOPALPHA_WARNING + CreateblendstateBlendopalphaWarning = 1317, + /// + /// D3D12_MESSAGE_ID_WRITE_COMBINE_PERFORMANCE_WARNING + WriteCombinePerformanceWarning = 1318, + /// + /// D3D12_MESSAGE_ID_RESOLVE_QUERY_INVALID_QUERY_STATE + ResolveQueryInvalidQueryState = 1319, + /// + /// D3D12_MESSAGE_ID_SETPRIVATEDATA_NO_ACCESS + SetprivatedataNoAccess = 1320, + /// + /// D3D12_MESSAGE_ID_COMMAND_LIST_STATIC_DESCRIPTOR_SAMPLER_MODE_MISMATCH + CommandListStaticDescriptorSamplerModeMismatch = 1321, + /// + /// D3D12_MESSAGE_ID_GETCOPYABLEFOOTPRINTS_UNSUPPORTED_BUFFER_WIDTH + GetcopyablefootprintsUnsupportedBufferWidth = 1322, + /// + /// D3D12_MESSAGE_ID_CREATEMESHSHADER_TOPOLOGY_MISMATCH + CreatemeshshaderTopologyMismatch = 1323, + /// + /// D3D12_MESSAGE_ID_VRS_SUM_COMBINER_REQUIRES_CAPABILITY + VrsSumCombinerRequiresCapability = 1324, + /// + /// D3D12_MESSAGE_ID_SETTING_SHADING_RATE_FROM_MS_REQUIRES_CAPABILITY + SettingShadingRateFromMsRequiresCapability = 1325, + /// + /// D3D12_MESSAGE_ID_SHADERCACHESESSION_SHADERCACHEDELETE_NOTSUPPORTED + ShadercachesessionShadercachedeleteNotsupported = 1326, + /// + /// D3D12_MESSAGE_ID_SHADERCACHECONTROL_SHADERCACHECLEAR_NOTSUPPORTED + ShadercachecontrolShadercacheclearNotsupported = 1327, +} + +/// +/// D3D12_MESSAGE_CALLBACK_FLAGS +[Flags] +public enum MessageCallbackFlags : int +{ + None = 0, + /// + /// D3D12_MESSAGE_CALLBACK_FLAG_NONE + D3D12_MESSAGE_CALLBACK_FLAG_NONE = 0, + /// + /// D3D12_MESSAGE_CALLBACK_IGNORE_FILTERS + D3D12_MESSAGE_CALLBACK_IGNORE_FILTERS = 1, +} + +/// +/// D3D12_AXIS_SHADING_RATE +public enum AxisShadingRate : int +{ + /// + /// D3D12_AXIS_SHADING_RATE_1X + _1x = 0, + /// + /// D3D12_AXIS_SHADING_RATE_2X + _2x = 1, + /// + /// D3D12_AXIS_SHADING_RATE_4X + _4x = 2, +} + +/// +/// D3D12_SHADING_RATE +public enum ShadingRate : int +{ + /// + /// D3D12_SHADING_RATE_1X1 + _1x1 = 0, + /// + /// D3D12_SHADING_RATE_1X2 + _1x2 = 1, + /// + /// D3D12_SHADING_RATE_2X1 + _2x1 = 4, + /// + /// D3D12_SHADING_RATE_2X2 + _2x2 = 5, + /// + /// D3D12_SHADING_RATE_2X4 + _2x4 = 6, + /// + /// D3D12_SHADING_RATE_4X2 + _4x2 = 9, + /// + /// D3D12_SHADING_RATE_4X4 + _4x4 = 10, +} + +/// +/// D3D12_SHADING_RATE_COMBINER +public enum ShadingRateCombiner : int +{ + /// + /// D3D12_SHADING_RATE_COMBINER_PASSTHROUGH + Passthrough = 0, + /// + /// D3D12_SHADING_RATE_COMBINER_OVERRIDE + Override = 1, + /// + /// D3D12_SHADING_RATE_COMBINER_MIN + Min = 2, + /// + /// D3D12_SHADING_RATE_COMBINER_MAX + Max = 3, + /// + /// D3D12_SHADING_RATE_COMBINER_SUM + Sum = 4, +} + +/// +/// D3D12_SHADER_VERSION_TYPE +public enum ShaderVersionType : int +{ + /// + /// D3D12_SHVER_PIXEL_SHADER + D3D12_SHVER_PIXEL_SHADER = 0, + /// + /// D3D12_SHVER_VERTEX_SHADER + D3D12_SHVER_VERTEX_SHADER = 1, + /// + /// D3D12_SHVER_GEOMETRY_SHADER + D3D12_SHVER_GEOMETRY_SHADER = 2, + /// + /// D3D12_SHVER_HULL_SHADER + D3D12_SHVER_HULL_SHADER = 3, + /// + /// D3D12_SHVER_DOMAIN_SHADER + D3D12_SHVER_DOMAIN_SHADER = 4, + /// + /// D3D12_SHVER_COMPUTE_SHADER + D3D12_SHVER_COMPUTE_SHADER = 5, + /// + /// D3D12_SHVER_RESERVED0 + D3D12_SHVER_RESERVED0 = 65520, +} + +#endregion Enums + +#region Generated Enums +#endregion Generated Enums + +#region Unions +#endregion Unions + +#region Structs +/// +/// D3D12_COMMAND_QUEUE_DESC +public partial struct CommandQueueDescription +{ + /// + public CommandListType Type; + + /// + public int Priority; + + /// + public CommandQueueFlags Flags; + + /// + public uint NodeMask; +} + +/// +/// D3D12_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; +} + +/// +/// D3D12_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; +} + +/// +/// D3D12_VIEWPORT +public partial struct Viewport +{ + /// + public float TopLeftX; + + /// + public float TopLeftY; + + /// + public float Width; + + /// + public float Height; + + /// + public float MinDepth; + + /// + public float MaxDepth; +} + +/// +/// D3D12_BOX +public partial struct Box +{ + /// + public uint left; + + /// + public uint top; + + /// + public uint front; + + /// + public uint right; + + /// + public uint bottom; + + /// + public uint back; +} + +/// +/// D3D12_DEPTH_STENCILOP_DESC +public partial struct DepthStencilopDescription +{ + /// + public StencilOp StencilFailOp; + + /// + public StencilOp StencilDepthFailOp; + + /// + public StencilOp StencilPassOp; + + /// + public ComparisonFunc StencilFunc; +} + +/// +/// D3D12_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; +} + +/// +/// D3D12_DEPTH_STENCIL_DESC1 +public partial struct DepthStencilDescription1 +{ + /// + public Bool32 DepthEnable; + + /// + public DepthWriteMask DepthWriteMask; + + /// + public ComparisonFunc DepthFunc; + + /// + public Bool32 StencilEnable; + + /// + public byte StencilReadMask; + + /// + public byte StencilWriteMask; + + /// + public DepthStencilopDescription FrontFace; + + /// + public DepthStencilopDescription BackFace; + + /// + public Bool32 DepthBoundsTestEnable; +} + +/// +/// D3D12_RENDER_TARGET_BLEND_DESC +public partial struct RenderTargetBlendDescription +{ + /// + 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; +} + +/// +/// D3D12_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); + } + } +} + +/// +/// D3D12_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 MultisampleEnable; + + /// + public Bool32 AntialiasedLineEnable; + + /// + public uint ForcedSampleCount; + + /// + public ConservativeRasterizationMode ConservativeRaster; +} + +/// +/// D3D12_SHADER_BYTECODE +public partial struct ShaderBytecode +{ + /// + public unsafe void* pShaderBytecode; + + /// + public nuint BytecodeLength; +} + +/// +/// D3D12_STREAM_OUTPUT_DESC +public partial struct StreamOutputDescription +{ + /// + public unsafe SoDeclarationEntry* pSODeclaration; + + /// + public uint NumEntries; + + /// + public unsafe uint* pBufferStrides; + + /// + public uint NumStrides; + + /// + public uint RasterizedStream; +} + +/// +/// D3D12_INPUT_LAYOUT_DESC +public partial struct InputLayoutDescription +{ + /// + public unsafe InputElementDescription* pInputElementDescs; + + /// + public uint NumElements; +} + +/// +/// D3D12_CACHED_PIPELINE_STATE +public partial struct CachedPipelineState +{ + /// + public unsafe void* pCachedBlob; + + /// + public nuint CachedBlobSizeInBytes; +} + +/// +/// D3D12_GRAPHICS_PIPELINE_STATE_DESC +public partial struct GraphicsPipelineStateDescription +{ + /// + public ID3D12RootSignature pRootSignature; + + /// + public ShaderBytecode VS; + + /// + public ShaderBytecode PS; + + /// + public ShaderBytecode DS; + + /// + public ShaderBytecode HS; + + /// + public ShaderBytecode GS; + + /// + public StreamOutputDescription StreamOutput; + + /// + public BlendDescription BlendState; + + /// + public uint SampleMask; + + /// + public RasterizerDescription RasterizerState; + + /// + public DepthStencilDescription DepthStencilState; + + /// + public InputLayoutDescription InputLayout; + + /// + public IndexBufferStripCutValue IBStripCutValue; + + /// + public PrimitiveTopologyType PrimitiveTopologyType; + + /// + public uint NumRenderTargets; + + /// + public RTVFormats__FixedBuffer RTVFormats; + + public unsafe struct RTVFormats__FixedBuffer + { + public Graphics.Dxgi.Common.Format e0; + public Graphics.Dxgi.Common.Format e1; + public Graphics.Dxgi.Common.Format e2; + public Graphics.Dxgi.Common.Format e3; + public Graphics.Dxgi.Common.Format e4; + public Graphics.Dxgi.Common.Format e5; + public Graphics.Dxgi.Common.Format e6; + public Graphics.Dxgi.Common.Format e7; + + [UnscopedRef] + public ref Graphics.Dxgi.Common.Format this[int index] + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + return ref AsSpan()[index]; + } + } + + [UnscopedRef] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public Span AsSpan() + { + return MemoryMarshal.CreateSpan(ref e0, 8); + } + } + + /// + public Graphics.Dxgi.Common.Format DSVFormat; + + /// + public Graphics.Dxgi.Common.SampleDescription SampleDesc; + + /// + public uint NodeMask; + + /// + public CachedPipelineState CachedPSO; + + /// + public PipelineStateFlags Flags; +} + +/// +/// D3D12_COMPUTE_PIPELINE_STATE_DESC +public partial struct ComputePipelineStateDescription +{ + /// + public ID3D12RootSignature pRootSignature; + + /// + public ShaderBytecode CS; + + /// + public uint NodeMask; + + /// + public CachedPipelineState CachedPSO; + + /// + public PipelineStateFlags Flags; +} + +/// +/// D3D12_RT_FORMAT_ARRAY +public partial struct RtFormatArray +{ + /// + public RTFormats__FixedBuffer RTFormats; + + public unsafe struct RTFormats__FixedBuffer + { + public Graphics.Dxgi.Common.Format e0; + public Graphics.Dxgi.Common.Format e1; + public Graphics.Dxgi.Common.Format e2; + public Graphics.Dxgi.Common.Format e3; + public Graphics.Dxgi.Common.Format e4; + public Graphics.Dxgi.Common.Format e5; + public Graphics.Dxgi.Common.Format e6; + public Graphics.Dxgi.Common.Format e7; + + [UnscopedRef] + public ref Graphics.Dxgi.Common.Format this[int index] + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + return ref AsSpan()[index]; + } + } + + [UnscopedRef] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public Span AsSpan() + { + return MemoryMarshal.CreateSpan(ref e0, 8); + } + } + + /// + public uint NumRenderTargets; +} + +/// +/// D3D12_PIPELINE_STATE_STREAM_DESC +public partial struct PipelineStateStreamDescription +{ + /// + public nuint SizeInBytes; + + /// + public unsafe void* pPipelineStateSubobjectStream; +} + +/// +/// D3D12_FEATURE_DATA_D3D12_OPTIONS +public partial struct FeatureDataD3d12Options +{ + /// + public Bool32 DoublePrecisionFloatShaderOps; + + /// + public Bool32 OutputMergerLogicOp; + + /// + public ShaderMinPrecisionSupport MinPrecisionSupport; + + /// + public TiledResourcesTier TiledResourcesTier; + + /// + public ResourceBindingTier ResourceBindingTier; + + /// + public Bool32 PSSpecifiedStencilRefSupported; + + /// + public Bool32 TypedUAVLoadAdditionalFormats; + + /// + public Bool32 ROVsSupported; + + /// + public ConservativeRasterizationTier ConservativeRasterizationTier; + + /// + public uint MaxGPUVirtualAddressBitsPerResource; + + /// + public Bool32 StandardSwizzle64KBSupported; + + /// + public CrossNodeSharingTier CrossNodeSharingTier; + + /// + public Bool32 CrossAdapterRowMajorTextureSupported; + + /// + public Bool32 VPAndRTArrayIndexFromAnyShaderFeedingRasterizerSupportedWithoutGSEmulation; + + /// + public ResourceHeapTier ResourceHeapTier; +} + +/// +/// D3D12_FEATURE_DATA_D3D12_OPTIONS1 +public partial struct FeatureDataD3d12Options1 +{ + /// + public Bool32 WaveOps; + + /// + public uint WaveLaneCountMin; + + /// + public uint WaveLaneCountMax; + + /// + public uint TotalLaneCount; + + /// + public Bool32 ExpandedComputeResourceStates; + + /// + public Bool32 Int64ShaderOps; +} + +/// +/// D3D12_FEATURE_DATA_D3D12_OPTIONS2 +public partial struct FeatureDataD3d12Options2 +{ + /// + public Bool32 DepthBoundsTestSupported; + + /// + public ProgrammableSamplePositionsTier ProgrammableSamplePositionsTier; +} + +/// +/// D3D12_FEATURE_DATA_ROOT_SIGNATURE +public partial struct FeatureDataRootSignature +{ + /// + public RootSignatureVersion HighestVersion; +} + +/// +/// D3D12_FEATURE_DATA_ARCHITECTURE +public partial struct FeatureDataArchitecture +{ + /// + public uint NodeIndex; + + /// + public Bool32 TileBasedRenderer; + + /// + public Bool32 UMA; + + /// + public Bool32 CacheCoherentUMA; +} + +/// +/// D3D12_FEATURE_DATA_ARCHITECTURE1 +public partial struct FeatureDataArchitecture1 +{ + /// + public uint NodeIndex; + + /// + public Bool32 TileBasedRenderer; + + /// + public Bool32 UMA; + + /// + public Bool32 CacheCoherentUMA; + + /// + public Bool32 IsolatedMMU; +} + +/// +/// D3D12_FEATURE_DATA_FEATURE_LEVELS +public partial struct FeatureDataFeatureLevels +{ + /// + public uint NumFeatureLevels; + + /// + public unsafe Graphics.Direct3D.FeatureLevel* pFeatureLevelsRequested; + + /// + public Graphics.Direct3D.FeatureLevel MaxSupportedFeatureLevel; +} + +/// +/// D3D12_FEATURE_DATA_SHADER_MODEL +public partial struct FeatureDataShaderModel +{ + /// + public ShaderModel HighestShaderModel; +} + +/// +/// D3D12_FEATURE_DATA_FORMAT_SUPPORT +public partial struct FeatureDataFormatSupport +{ + /// + public Graphics.Dxgi.Common.Format Format; + + /// + public FormatSupport1 Support1; + + /// + public FormatSupport2 Support2; +} + +/// +/// D3D12_FEATURE_DATA_MULTISAMPLE_QUALITY_LEVELS +public partial struct FeatureDataMultisampleQualityLevels +{ + /// + public Graphics.Dxgi.Common.Format Format; + + /// + public uint SampleCount; + + /// + public MultisampleQualityLevelFlags Flags; + + /// + public uint NumQualityLevels; +} + +/// +/// D3D12_FEATURE_DATA_FORMAT_INFO +public partial struct FeatureDataFormatInfo +{ + /// + public Graphics.Dxgi.Common.Format Format; + + /// + public byte PlaneCount; +} + +/// +/// D3D12_FEATURE_DATA_GPU_VIRTUAL_ADDRESS_SUPPORT +public partial struct FeatureDataGpuVirtualAddressSupport +{ + /// + public uint MaxGPUVirtualAddressBitsPerResource; + + /// + public uint MaxGPUVirtualAddressBitsPerProcess; +} + +/// +/// D3D12_FEATURE_DATA_SHADER_CACHE +public partial struct FeatureDataShaderCache +{ + /// + public ShaderCacheSupportFlags SupportFlags; +} + +/// +/// D3D12_FEATURE_DATA_COMMAND_QUEUE_PRIORITY +public partial struct FeatureDataCommandQueuePriority +{ + /// + public CommandListType CommandListType; + + /// + public uint Priority; + + /// + public Bool32 PriorityForTypeIsSupported; +} + +/// +/// D3D12_FEATURE_DATA_D3D12_OPTIONS3 +public partial struct FeatureDataD3d12Options3 +{ + /// + public Bool32 CopyQueueTimestampQueriesSupported; + + /// + public Bool32 CastingFullyTypedFormatSupported; + + /// + public CommandListSupportFlags WriteBufferImmediateSupportFlags; + + /// + public ViewInstancingTier ViewInstancingTier; + + /// + public Bool32 BarycentricsSupported; +} + +/// +/// D3D12_FEATURE_DATA_EXISTING_HEAPS +public partial struct FeatureDataExistingHeaps +{ + /// + public Bool32 Supported; +} + +/// +/// D3D12_FEATURE_DATA_DISPLAYABLE +public partial struct FeatureDataDisplayable +{ + /// + public Bool32 DisplayableTexture; + + /// + public SharedResourceCompatibilityTier SharedResourceCompatibilityTier; +} + +/// +/// D3D12_FEATURE_DATA_D3D12_OPTIONS4 +public partial struct FeatureDataD3d12Options4 +{ + /// + public Bool32 MSAA64KBAlignedTextureSupported; + + /// + public SharedResourceCompatibilityTier SharedResourceCompatibilityTier; + + /// + public Bool32 Native16BitShaderOpsSupported; +} + +/// +/// D3D12_FEATURE_DATA_SERIALIZATION +public partial struct FeatureDataSerialization +{ + /// + public uint NodeIndex; + + /// + public HeapSerializationTier HeapSerializationTier; +} + +/// +/// D3D12_FEATURE_DATA_CROSS_NODE +public partial struct FeatureDataCrossNode +{ + /// + public CrossNodeSharingTier SharingTier; + + /// + public Bool32 AtomicShaderInstructions; +} + +/// +/// D3D12_FEATURE_DATA_D3D12_OPTIONS5 +public partial struct FeatureDataD3d12Options5 +{ + /// + public Bool32 SRVOnlyTiledResourceTier3; + + /// + public RenderPassTier RenderPassesTier; + + /// + public RaytracingTier RaytracingTier; +} + +/// +/// D3D12_FEATURE_DATA_D3D12_OPTIONS6 +public partial struct FeatureDataD3d12Options6 +{ + /// + public Bool32 AdditionalShadingRatesSupported; + + /// + public Bool32 PerPrimitiveShadingRateSupportedWithViewportIndexing; + + /// + public VariableShadingRateTier VariableShadingRateTier; + + /// + public uint ShadingRateImageTileSize; + + /// + public Bool32 BackgroundProcessingSupported; +} + +/// +/// D3D12_FEATURE_DATA_D3D12_OPTIONS7 +public partial struct FeatureDataD3d12Options7 +{ + /// + public MeshShaderTier MeshShaderTier; + + /// + public SamplerFeedbackTier SamplerFeedbackTier; +} + +/// +/// D3D12_FEATURE_DATA_QUERY_META_COMMAND +public partial struct FeatureDataQueryMetaCommand +{ + /// + public Guid CommandId; + + /// + public uint NodeMask; + + /// + public unsafe void* pQueryInputData; + + /// + public nuint QueryInputDataSizeInBytes; + + /// + public unsafe void* pQueryOutputData; + + /// + public nuint QueryOutputDataSizeInBytes; +} + +/// +/// D3D12_FEATURE_DATA_D3D12_OPTIONS8 +public partial struct FeatureDataD3d12Options8 +{ + /// + public Bool32 UnalignedBlockTexturesSupported; +} + +/// +/// D3D12_FEATURE_DATA_D3D12_OPTIONS9 +public partial struct FeatureDataD3d12Options9 +{ + /// + public Bool32 MeshShaderPipelineStatsSupported; + + /// + public Bool32 MeshShaderSupportsFullRangeRenderTargetArrayIndex; + + /// + public Bool32 AtomicInt64OnTypedResourceSupported; + + /// + public Bool32 AtomicInt64OnGroupSharedSupported; + + /// + public Bool32 DerivativesInMeshAndAmplificationShadersSupported; + + /// + public WaveMmaTier WaveMMATier; +} + +/// +/// D3D12_FEATURE_DATA_D3D12_OPTIONS10 +public partial struct FeatureDataD3d12Options10 +{ + /// + public Bool32 VariableRateShadingSumCombinerSupported; + + /// + public Bool32 MeshShaderPerPrimitiveShadingRateSupported; +} + +/// +/// D3D12_FEATURE_DATA_D3D12_OPTIONS11 +public partial struct FeatureDataD3d12Options11 +{ + /// + public Bool32 AtomicInt64OnDescriptorHeapResourceSupported; +} + +/// +/// D3D12_RESOURCE_ALLOCATION_INFO +public partial struct ResourceAllocationInfo +{ + /// + public ulong SizeInBytes; + + /// + public ulong Alignment; +} + +/// +/// D3D12_RESOURCE_ALLOCATION_INFO1 +public partial struct ResourceAllocationInfo1 +{ + /// + public ulong Offset; + + /// + public ulong Alignment; + + /// + public ulong SizeInBytes; +} + +/// +/// D3D12_HEAP_PROPERTIES +public partial struct HeapProperties +{ + /// + public HeapType Type; + + /// + public CpuPageProperty CPUPageProperty; + + /// + public MemoryPool MemoryPoolPreference; + + /// + public uint CreationNodeMask; + + /// + public uint VisibleNodeMask; +} + +/// +/// D3D12_HEAP_DESC +public partial struct HeapDescription +{ + /// + public ulong SizeInBytes; + + /// + public HeapProperties Properties; + + /// + public ulong Alignment; + + /// + public HeapFlags Flags; +} + +/// +/// D3D12_MIP_REGION +public partial struct MipRegion +{ + /// + public uint Width; + + /// + public uint Height; + + /// + public uint Depth; +} + +/// +/// D3D12_RESOURCE_DESC +public partial struct ResourceDescription +{ + /// + public ResourceDimension Dimension; + + /// + public ulong Alignment; + + /// + public ulong Width; + + /// + public uint Height; + + /// + public ushort DepthOrArraySize; + + /// + public ushort MipLevels; + + /// + public Graphics.Dxgi.Common.Format Format; + + /// + public Graphics.Dxgi.Common.SampleDescription SampleDesc; + + /// + public TextureLayout Layout; + + /// + public ResourceFlags Flags; +} + +/// +/// D3D12_RESOURCE_DESC1 +public partial struct ResourceDescription1 +{ + /// + public ResourceDimension Dimension; + + /// + public ulong Alignment; + + /// + public ulong Width; + + /// + public uint Height; + + /// + public ushort DepthOrArraySize; + + /// + public ushort MipLevels; + + /// + public Graphics.Dxgi.Common.Format Format; + + /// + public Graphics.Dxgi.Common.SampleDescription SampleDesc; + + /// + public TextureLayout Layout; + + /// + public ResourceFlags Flags; + + /// + public MipRegion SamplerFeedbackMipRegion; +} + +/// +/// D3D12_DEPTH_STENCIL_VALUE +public partial struct DepthStencilValue +{ + /// + public float Depth; + + /// + public byte Stencil; +} + +/// +/// D3D12_CLEAR_VALUE +public partial struct ClearValue +{ + /// + public Graphics.Dxgi.Common.Format Format; + + /// + public _Anonymous_e__Union Anonymous; + + [UnscopedRef] + public unsafe Span Color + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + return MemoryMarshal.CreateSpan(ref Anonymous.Color[0], 4); + } + } + + [UnscopedRef] + public ref DepthStencilValue DepthStencil + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { +#if NET7_0_OR_GREATER + return ref Anonymous.DepthStencil; +#else + return ref MemoryMarshal.GetReference(MemoryMarshal.CreateSpan(ref Anonymous.DepthStencil, 1)); +#endif + } + } + + [StructLayout(LayoutKind.Explicit)] + public partial struct _Anonymous_e__Union + { + /// + [FieldOffset(0)] + public unsafe fixed float Color[4]; + + /// + [FieldOffset(0)] + public DepthStencilValue DepthStencil; + } + +} + +/// +/// D3D12_RANGE +public partial struct Range +{ + /// + public nuint Begin; + + /// + public nuint End; +} + +/// +/// D3D12_RANGE_UINT64 +public partial struct RangeUint64 +{ + /// + public ulong Begin; + + /// + public ulong End; +} + +/// +/// D3D12_SUBRESOURCE_RANGE_UINT64 +public partial struct SubresourceRangeUint64 +{ + /// + public uint Subresource; + + /// + public RangeUint64 Range; +} + +/// +/// D3D12_SUBRESOURCE_INFO +public partial struct SubresourceInfo +{ + /// + public ulong Offset; + + /// + public uint RowPitch; + + /// + public uint DepthPitch; +} + +/// +/// D3D12_TILED_RESOURCE_COORDINATE +public partial struct TiledResourceCoordinate +{ + /// + public uint X; + + /// + public uint Y; + + /// + public uint Z; + + /// + public uint Subresource; +} + +/// +/// D3D12_TILE_REGION_SIZE +public partial struct TileRegionSize +{ + /// + public uint NumTiles; + + /// + public Bool32 UseBox; + + /// + public uint Width; + + /// + public ushort Height; + + /// + public ushort Depth; +} + +/// +/// D3D12_SUBRESOURCE_TILING +public partial struct SubresourceTiling +{ + /// + public uint WidthInTiles; + + /// + public ushort HeightInTiles; + + /// + public ushort DepthInTiles; + + /// + public uint StartTileIndexInOverallResource; +} + +/// +/// D3D12_TILE_SHAPE +public partial struct TileShape +{ + /// + public uint WidthInTexels; + + /// + public uint HeightInTexels; + + /// + public uint DepthInTexels; +} + +/// +/// D3D12_PACKED_MIP_INFO +public partial struct PackedMipInfo +{ + /// + public byte NumStandardMips; + + /// + public byte NumPackedMips; + + /// + public uint NumTilesForPackedMips; + + /// + public uint StartTileIndexInOverallResource; +} + +/// +/// D3D12_RESOURCE_TRANSITION_BARRIER +public partial struct ResourceTransitionBarrier +{ + /// + public ID3D12Resource pResource; + + /// + public uint Subresource; + + /// + public ResourceStates StateBefore; + + /// + public ResourceStates StateAfter; +} + +/// +/// D3D12_RESOURCE_ALIASING_BARRIER +public partial struct ResourceAliasingBarrier +{ + /// + public ID3D12Resource pResourceBefore; + + /// + public ID3D12Resource pResourceAfter; +} + +/// +/// D3D12_RESOURCE_UAV_BARRIER +public partial struct ResourceUavBarrier +{ + /// + public ID3D12Resource pResource; +} + +/// +/// D3D12_RESOURCE_BARRIER +public partial struct ResourceBarrier +{ + /// + public ResourceBarrierType Type; + + /// + public ResourceBarrierFlags Flags; + + /// + public _Anonymous_e__Union Anonymous; + + [UnscopedRef] + public ref ResourceTransitionBarrier Transition + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { +#if NET7_0_OR_GREATER + return ref Anonymous.Transition; +#else + return ref MemoryMarshal.GetReference(MemoryMarshal.CreateSpan(ref Anonymous.Transition, 1)); +#endif + } + } + + [UnscopedRef] + public ref ResourceAliasingBarrier Aliasing + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { +#if NET7_0_OR_GREATER + return ref Anonymous.Aliasing; +#else + return ref MemoryMarshal.GetReference(MemoryMarshal.CreateSpan(ref Anonymous.Aliasing, 1)); +#endif + } + } + + [UnscopedRef] + public ref ResourceUavBarrier UAV + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { +#if NET7_0_OR_GREATER + return ref Anonymous.UAV; +#else + return ref MemoryMarshal.GetReference(MemoryMarshal.CreateSpan(ref Anonymous.UAV, 1)); +#endif + } + } + + [StructLayout(LayoutKind.Explicit)] + public partial struct _Anonymous_e__Union + { + /// + [FieldOffset(0)] + public ResourceTransitionBarrier Transition; + + /// + [FieldOffset(0)] + public ResourceAliasingBarrier Aliasing; + + /// + [FieldOffset(0)] + public ResourceUavBarrier UAV; + } + +} + +/// +/// D3D12_SUBRESOURCE_FOOTPRINT +public partial struct SubresourceFootprint +{ + /// + public Graphics.Dxgi.Common.Format Format; + + /// + public uint Width; + + /// + public uint Height; + + /// + public uint Depth; + + /// + public uint RowPitch; +} + +/// +/// D3D12_PLACED_SUBRESOURCE_FOOTPRINT +public partial struct PlacedSubresourceFootprint +{ + /// + public ulong Offset; + + /// + public SubresourceFootprint Footprint; +} + +/// +/// D3D12_TEXTURE_COPY_LOCATION +public partial struct TextureCopyLocation +{ + /// + public ID3D12Resource pResource; + + /// + public TextureCopyType Type; + + /// + public _Anonymous_e__Union Anonymous; + + [UnscopedRef] + public ref PlacedSubresourceFootprint PlacedFootprint + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { +#if NET7_0_OR_GREATER + return ref Anonymous.PlacedFootprint; +#else + return ref MemoryMarshal.GetReference(MemoryMarshal.CreateSpan(ref Anonymous.PlacedFootprint, 1)); +#endif + } + } + + [UnscopedRef] + public ref uint SubresourceIndex + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { +#if NET7_0_OR_GREATER + return ref Anonymous.SubresourceIndex; +#else + return ref MemoryMarshal.GetReference(MemoryMarshal.CreateSpan(ref Anonymous.SubresourceIndex, 1)); +#endif + } + } + + [StructLayout(LayoutKind.Explicit)] + public partial struct _Anonymous_e__Union + { + /// + [FieldOffset(0)] + public PlacedSubresourceFootprint PlacedFootprint; + + /// + [FieldOffset(0)] + public uint SubresourceIndex; + } + +} + +/// +/// D3D12_SAMPLE_POSITION +public partial struct SamplePosition +{ + /// + public sbyte X; + + /// + public sbyte Y; +} + +/// +/// D3D12_VIEW_INSTANCE_LOCATION +public partial struct ViewInstanceLocation +{ + /// + public uint ViewportArrayIndex; + + /// + public uint RenderTargetArrayIndex; +} + +/// +/// D3D12_VIEW_INSTANCING_DESC +public partial struct ViewInstancingDescription +{ + /// + public uint ViewInstanceCount; + + /// + public unsafe ViewInstanceLocation* pViewInstanceLocations; + + /// + public ViewInstancingFlags Flags; +} + +/// +/// D3D12_BUFFER_SRV +public partial struct BufferSrv +{ + /// + public ulong FirstElement; + + /// + public uint NumElements; + + /// + public uint StructureByteStride; + + /// + public BufferSrvFlags Flags; +} + +/// +/// D3D12_TEX1D_SRV +public partial struct Tex1dSrv +{ + /// + public uint MostDetailedMip; + + /// + public uint MipLevels; + + /// + public float ResourceMinLODClamp; +} + +/// +/// D3D12_TEX1D_ARRAY_SRV +public partial struct Tex1dArraySrv +{ + /// + public uint MostDetailedMip; + + /// + public uint MipLevels; + + /// + public uint FirstArraySlice; + + /// + public uint ArraySize; + + /// + public float ResourceMinLODClamp; +} + +/// +/// D3D12_TEX2D_SRV +public partial struct Tex2dSrv +{ + /// + public uint MostDetailedMip; + + /// + public uint MipLevels; + + /// + public uint PlaneSlice; + + /// + public float ResourceMinLODClamp; +} + +/// +/// D3D12_TEX2D_ARRAY_SRV +public partial struct Tex2dArraySrv +{ + /// + public uint MostDetailedMip; + + /// + public uint MipLevels; + + /// + public uint FirstArraySlice; + + /// + public uint ArraySize; + + /// + public uint PlaneSlice; + + /// + public float ResourceMinLODClamp; +} + +/// +/// D3D12_TEX3D_SRV +public partial struct Tex3dSrv +{ + /// + public uint MostDetailedMip; + + /// + public uint MipLevels; + + /// + public float ResourceMinLODClamp; +} + +/// +/// D3D12_TEXCUBE_SRV +public partial struct TexcubeSrv +{ + /// + public uint MostDetailedMip; + + /// + public uint MipLevels; + + /// + public float ResourceMinLODClamp; +} + +/// +/// D3D12_TEXCUBE_ARRAY_SRV +public partial struct TexcubeArraySrv +{ + /// + public uint MostDetailedMip; + + /// + public uint MipLevels; + + /// + public uint First2DArrayFace; + + /// + public uint NumCubes; + + /// + public float ResourceMinLODClamp; +} + +/// +/// D3D12_TEX2DMS_SRV +public partial struct Tex2dmsSrv +{ + /// + public uint UnusedField_NothingToDefine; +} + +/// +/// D3D12_TEX2DMS_ARRAY_SRV +public partial struct Tex2dmsArraySrv +{ + /// + public uint FirstArraySlice; + + /// + public uint ArraySize; +} + +/// +/// D3D12_RAYTRACING_ACCELERATION_STRUCTURE_SRV +public partial struct RaytracingAccelerationStructureSrv +{ + /// + public ulong Location; +} + +/// +/// D3D12_SHADER_RESOURCE_VIEW_DESC +public partial struct ShaderResourceViewDescription +{ + /// + public Graphics.Dxgi.Common.Format Format; + + /// + public SrvDimension ViewDimension; + + /// + public uint Shader4ComponentMapping; + + /// + public _Anonymous_e__Union Anonymous; + + [UnscopedRef] + public ref BufferSrv Buffer + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { +#if NET7_0_OR_GREATER + return ref Anonymous.Buffer; +#else + return ref MemoryMarshal.GetReference(MemoryMarshal.CreateSpan(ref Anonymous.Buffer, 1)); +#endif + } + } + + [UnscopedRef] + public ref Tex1dSrv Texture1D + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { +#if NET7_0_OR_GREATER + return ref Anonymous.Texture1D; +#else + return ref MemoryMarshal.GetReference(MemoryMarshal.CreateSpan(ref Anonymous.Texture1D, 1)); +#endif + } + } + + [UnscopedRef] + public ref Tex1dArraySrv Texture1DArray + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { +#if NET7_0_OR_GREATER + return ref Anonymous.Texture1DArray; +#else + return ref MemoryMarshal.GetReference(MemoryMarshal.CreateSpan(ref Anonymous.Texture1DArray, 1)); +#endif + } + } + + [UnscopedRef] + public ref Tex2dSrv Texture2D + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { +#if NET7_0_OR_GREATER + return ref Anonymous.Texture2D; +#else + return ref MemoryMarshal.GetReference(MemoryMarshal.CreateSpan(ref Anonymous.Texture2D, 1)); +#endif + } + } + + [UnscopedRef] + public ref Tex2dArraySrv Texture2DArray + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { +#if NET7_0_OR_GREATER + return ref Anonymous.Texture2DArray; +#else + return ref MemoryMarshal.GetReference(MemoryMarshal.CreateSpan(ref Anonymous.Texture2DArray, 1)); +#endif + } + } + + [UnscopedRef] + public ref Tex2dmsSrv Texture2DMS + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { +#if NET7_0_OR_GREATER + return ref Anonymous.Texture2DMS; +#else + return ref MemoryMarshal.GetReference(MemoryMarshal.CreateSpan(ref Anonymous.Texture2DMS, 1)); +#endif + } + } + + [UnscopedRef] + public ref Tex2dmsArraySrv Texture2DMSArray + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { +#if NET7_0_OR_GREATER + return ref Anonymous.Texture2DMSArray; +#else + return ref MemoryMarshal.GetReference(MemoryMarshal.CreateSpan(ref Anonymous.Texture2DMSArray, 1)); +#endif + } + } + + [UnscopedRef] + public ref Tex3dSrv Texture3D + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { +#if NET7_0_OR_GREATER + return ref Anonymous.Texture3D; +#else + return ref MemoryMarshal.GetReference(MemoryMarshal.CreateSpan(ref Anonymous.Texture3D, 1)); +#endif + } + } + + [UnscopedRef] + public ref TexcubeSrv TextureCube + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { +#if NET7_0_OR_GREATER + return ref Anonymous.TextureCube; +#else + return ref MemoryMarshal.GetReference(MemoryMarshal.CreateSpan(ref Anonymous.TextureCube, 1)); +#endif + } + } + + [UnscopedRef] + public ref TexcubeArraySrv TextureCubeArray + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { +#if NET7_0_OR_GREATER + return ref Anonymous.TextureCubeArray; +#else + return ref MemoryMarshal.GetReference(MemoryMarshal.CreateSpan(ref Anonymous.TextureCubeArray, 1)); +#endif + } + } + + [UnscopedRef] + public ref RaytracingAccelerationStructureSrv RaytracingAccelerationStructure + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { +#if NET7_0_OR_GREATER + return ref Anonymous.RaytracingAccelerationStructure; +#else + return ref MemoryMarshal.GetReference(MemoryMarshal.CreateSpan(ref Anonymous.RaytracingAccelerationStructure, 1)); +#endif + } + } + + [StructLayout(LayoutKind.Explicit)] + public partial struct _Anonymous_e__Union + { + /// + [FieldOffset(0)] + public BufferSrv Buffer; + + /// + [FieldOffset(0)] + public Tex1dSrv Texture1D; + + /// + [FieldOffset(0)] + public Tex1dArraySrv Texture1DArray; + + /// + [FieldOffset(0)] + public Tex2dSrv Texture2D; + + /// + [FieldOffset(0)] + public Tex2dArraySrv Texture2DArray; + + /// + [FieldOffset(0)] + public Tex2dmsSrv Texture2DMS; + + /// + [FieldOffset(0)] + public Tex2dmsArraySrv Texture2DMSArray; + + /// + [FieldOffset(0)] + public Tex3dSrv Texture3D; + + /// + [FieldOffset(0)] + public TexcubeSrv TextureCube; + + /// + [FieldOffset(0)] + public TexcubeArraySrv TextureCubeArray; + + /// + [FieldOffset(0)] + public RaytracingAccelerationStructureSrv RaytracingAccelerationStructure; + } + +} + +/// +/// D3D12_CONSTANT_BUFFER_VIEW_DESC +public partial struct ConstantBufferViewDescription +{ + /// + public ulong BufferLocation; + + /// + public uint SizeInBytes; +} + +/// +/// D3D12_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; +} + +/// +/// D3D12_BUFFER_UAV +public partial struct BufferUav +{ + /// + public ulong FirstElement; + + /// + public uint NumElements; + + /// + public uint StructureByteStride; + + /// + public ulong CounterOffsetInBytes; + + /// + public BufferUavFlags Flags; +} + +/// +/// D3D12_TEX1D_UAV +public partial struct Tex1dUav +{ + /// + public uint MipSlice; +} + +/// +/// D3D12_TEX1D_ARRAY_UAV +public partial struct Tex1dArrayUav +{ + /// + public uint MipSlice; + + /// + public uint FirstArraySlice; + + /// + public uint ArraySize; +} + +/// +/// D3D12_TEX2D_UAV +public partial struct Tex2dUav +{ + /// + public uint MipSlice; + + /// + public uint PlaneSlice; +} + +/// +/// D3D12_TEX2D_ARRAY_UAV +public partial struct Tex2dArrayUav +{ + /// + public uint MipSlice; + + /// + public uint FirstArraySlice; + + /// + public uint ArraySize; + + /// + public uint PlaneSlice; +} + +/// +/// D3D12_TEX3D_UAV +public partial struct Tex3dUav +{ + /// + public uint MipSlice; + + /// + public uint FirstWSlice; + + /// + public uint WSize; +} + +/// +/// D3D12_UNORDERED_ACCESS_VIEW_DESC +public partial struct UnorderedAccessViewDescription +{ + /// + public Graphics.Dxgi.Common.Format Format; + + /// + public UavDimension ViewDimension; + + /// + public _Anonymous_e__Union Anonymous; + + [UnscopedRef] + public ref BufferUav Buffer + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { +#if NET7_0_OR_GREATER + return ref Anonymous.Buffer; +#else + return ref MemoryMarshal.GetReference(MemoryMarshal.CreateSpan(ref Anonymous.Buffer, 1)); +#endif + } + } + + [UnscopedRef] + public ref Tex1dUav Texture1D + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { +#if NET7_0_OR_GREATER + return ref Anonymous.Texture1D; +#else + return ref MemoryMarshal.GetReference(MemoryMarshal.CreateSpan(ref Anonymous.Texture1D, 1)); +#endif + } + } + + [UnscopedRef] + public ref Tex1dArrayUav Texture1DArray + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { +#if NET7_0_OR_GREATER + return ref Anonymous.Texture1DArray; +#else + return ref MemoryMarshal.GetReference(MemoryMarshal.CreateSpan(ref Anonymous.Texture1DArray, 1)); +#endif + } + } + + [UnscopedRef] + public ref Tex2dUav Texture2D + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { +#if NET7_0_OR_GREATER + return ref Anonymous.Texture2D; +#else + return ref MemoryMarshal.GetReference(MemoryMarshal.CreateSpan(ref Anonymous.Texture2D, 1)); +#endif + } + } + + [UnscopedRef] + public ref Tex2dArrayUav Texture2DArray + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { +#if NET7_0_OR_GREATER + return ref Anonymous.Texture2DArray; +#else + return ref MemoryMarshal.GetReference(MemoryMarshal.CreateSpan(ref Anonymous.Texture2DArray, 1)); +#endif + } + } + + [UnscopedRef] + public ref Tex3dUav Texture3D + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { +#if NET7_0_OR_GREATER + return ref Anonymous.Texture3D; +#else + return ref MemoryMarshal.GetReference(MemoryMarshal.CreateSpan(ref Anonymous.Texture3D, 1)); +#endif + } + } + + [StructLayout(LayoutKind.Explicit)] + public partial struct _Anonymous_e__Union + { + /// + [FieldOffset(0)] + public BufferUav Buffer; + + /// + [FieldOffset(0)] + public Tex1dUav Texture1D; + + /// + [FieldOffset(0)] + public Tex1dArrayUav Texture1DArray; + + /// + [FieldOffset(0)] + public Tex2dUav Texture2D; + + /// + [FieldOffset(0)] + public Tex2dArrayUav Texture2DArray; + + /// + [FieldOffset(0)] + public Tex3dUav Texture3D; + } + +} + +/// +/// D3D12_BUFFER_RTV +public partial struct BufferRtv +{ + /// + public ulong FirstElement; + + /// + public uint NumElements; +} + +/// +/// D3D12_TEX1D_RTV +public partial struct Tex1dRtv +{ + /// + public uint MipSlice; +} + +/// +/// D3D12_TEX1D_ARRAY_RTV +public partial struct Tex1dArrayRtv +{ + /// + public uint MipSlice; + + /// + public uint FirstArraySlice; + + /// + public uint ArraySize; +} + +/// +/// D3D12_TEX2D_RTV +public partial struct Tex2dRtv +{ + /// + public uint MipSlice; + + /// + public uint PlaneSlice; +} + +/// +/// D3D12_TEX2DMS_RTV +public partial struct Tex2dmsRtv +{ + /// + public uint UnusedField_NothingToDefine; +} + +/// +/// D3D12_TEX2D_ARRAY_RTV +public partial struct Tex2dArrayRtv +{ + /// + public uint MipSlice; + + /// + public uint FirstArraySlice; + + /// + public uint ArraySize; + + /// + public uint PlaneSlice; +} + +/// +/// D3D12_TEX2DMS_ARRAY_RTV +public partial struct Tex2dmsArrayRtv +{ + /// + public uint FirstArraySlice; + + /// + public uint ArraySize; +} + +/// +/// D3D12_TEX3D_RTV +public partial struct Tex3dRtv +{ + /// + public uint MipSlice; + + /// + public uint FirstWSlice; + + /// + public uint WSize; +} + +/// +/// D3D12_RENDER_TARGET_VIEW_DESC +public partial struct RenderTargetViewDescription +{ + /// + public Graphics.Dxgi.Common.Format Format; + + /// + public RtvDimension ViewDimension; + + /// + public _Anonymous_e__Union Anonymous; + + [UnscopedRef] + public ref BufferRtv Buffer + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { +#if NET7_0_OR_GREATER + return ref Anonymous.Buffer; +#else + return ref MemoryMarshal.GetReference(MemoryMarshal.CreateSpan(ref Anonymous.Buffer, 1)); +#endif + } + } + + [UnscopedRef] + public ref Tex1dRtv Texture1D + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { +#if NET7_0_OR_GREATER + return ref Anonymous.Texture1D; +#else + return ref MemoryMarshal.GetReference(MemoryMarshal.CreateSpan(ref Anonymous.Texture1D, 1)); +#endif + } + } + + [UnscopedRef] + public ref Tex1dArrayRtv Texture1DArray + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { +#if NET7_0_OR_GREATER + return ref Anonymous.Texture1DArray; +#else + return ref MemoryMarshal.GetReference(MemoryMarshal.CreateSpan(ref Anonymous.Texture1DArray, 1)); +#endif + } + } + + [UnscopedRef] + public ref Tex2dRtv Texture2D + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { +#if NET7_0_OR_GREATER + return ref Anonymous.Texture2D; +#else + return ref MemoryMarshal.GetReference(MemoryMarshal.CreateSpan(ref Anonymous.Texture2D, 1)); +#endif + } + } + + [UnscopedRef] + public ref Tex2dArrayRtv Texture2DArray + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { +#if NET7_0_OR_GREATER + return ref Anonymous.Texture2DArray; +#else + return ref MemoryMarshal.GetReference(MemoryMarshal.CreateSpan(ref Anonymous.Texture2DArray, 1)); +#endif + } + } + + [UnscopedRef] + public ref Tex2dmsRtv Texture2DMS + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { +#if NET7_0_OR_GREATER + return ref Anonymous.Texture2DMS; +#else + return ref MemoryMarshal.GetReference(MemoryMarshal.CreateSpan(ref Anonymous.Texture2DMS, 1)); +#endif + } + } + + [UnscopedRef] + public ref Tex2dmsArrayRtv Texture2DMSArray + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { +#if NET7_0_OR_GREATER + return ref Anonymous.Texture2DMSArray; +#else + return ref MemoryMarshal.GetReference(MemoryMarshal.CreateSpan(ref Anonymous.Texture2DMSArray, 1)); +#endif + } + } + + [UnscopedRef] + public ref Tex3dRtv Texture3D + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { +#if NET7_0_OR_GREATER + return ref Anonymous.Texture3D; +#else + return ref MemoryMarshal.GetReference(MemoryMarshal.CreateSpan(ref Anonymous.Texture3D, 1)); +#endif + } + } + + [StructLayout(LayoutKind.Explicit)] + public partial struct _Anonymous_e__Union + { + /// + [FieldOffset(0)] + public BufferRtv Buffer; + + /// + [FieldOffset(0)] + public Tex1dRtv Texture1D; + + /// + [FieldOffset(0)] + public Tex1dArrayRtv Texture1DArray; + + /// + [FieldOffset(0)] + public Tex2dRtv Texture2D; + + /// + [FieldOffset(0)] + public Tex2dArrayRtv Texture2DArray; + + /// + [FieldOffset(0)] + public Tex2dmsRtv Texture2DMS; + + /// + [FieldOffset(0)] + public Tex2dmsArrayRtv Texture2DMSArray; + + /// + [FieldOffset(0)] + public Tex3dRtv Texture3D; + } + +} + +/// +/// D3D12_TEX1D_DSV +public partial struct Tex1dDsv +{ + /// + public uint MipSlice; +} + +/// +/// D3D12_TEX1D_ARRAY_DSV +public partial struct Tex1dArrayDsv +{ + /// + public uint MipSlice; + + /// + public uint FirstArraySlice; + + /// + public uint ArraySize; +} + +/// +/// D3D12_TEX2D_DSV +public partial struct Tex2dDsv +{ + /// + public uint MipSlice; +} + +/// +/// D3D12_TEX2D_ARRAY_DSV +public partial struct Tex2dArrayDsv +{ + /// + public uint MipSlice; + + /// + public uint FirstArraySlice; + + /// + public uint ArraySize; +} + +/// +/// D3D12_TEX2DMS_DSV +public partial struct Tex2dmsDsv +{ + /// + public uint UnusedField_NothingToDefine; +} + +/// +/// D3D12_TEX2DMS_ARRAY_DSV +public partial struct Tex2dmsArrayDsv +{ + /// + public uint FirstArraySlice; + + /// + public uint ArraySize; +} + +/// +/// D3D12_DEPTH_STENCIL_VIEW_DESC +public partial struct DepthStencilViewDescription +{ + /// + public Graphics.Dxgi.Common.Format Format; + + /// + public DsvDimension ViewDimension; + + /// + public DsvFlags Flags; + + /// + public _Anonymous_e__Union Anonymous; + + [UnscopedRef] + public ref Tex1dDsv Texture1D + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { +#if NET7_0_OR_GREATER + return ref Anonymous.Texture1D; +#else + return ref MemoryMarshal.GetReference(MemoryMarshal.CreateSpan(ref Anonymous.Texture1D, 1)); +#endif + } + } + + [UnscopedRef] + public ref Tex1dArrayDsv Texture1DArray + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { +#if NET7_0_OR_GREATER + return ref Anonymous.Texture1DArray; +#else + return ref MemoryMarshal.GetReference(MemoryMarshal.CreateSpan(ref Anonymous.Texture1DArray, 1)); +#endif + } + } + + [UnscopedRef] + public ref Tex2dDsv Texture2D + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { +#if NET7_0_OR_GREATER + return ref Anonymous.Texture2D; +#else + return ref MemoryMarshal.GetReference(MemoryMarshal.CreateSpan(ref Anonymous.Texture2D, 1)); +#endif + } + } + + [UnscopedRef] + public ref Tex2dArrayDsv Texture2DArray + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { +#if NET7_0_OR_GREATER + return ref Anonymous.Texture2DArray; +#else + return ref MemoryMarshal.GetReference(MemoryMarshal.CreateSpan(ref Anonymous.Texture2DArray, 1)); +#endif + } + } + + [UnscopedRef] + public ref Tex2dmsDsv Texture2DMS + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { +#if NET7_0_OR_GREATER + return ref Anonymous.Texture2DMS; +#else + return ref MemoryMarshal.GetReference(MemoryMarshal.CreateSpan(ref Anonymous.Texture2DMS, 1)); +#endif + } + } + + [UnscopedRef] + public ref Tex2dmsArrayDsv Texture2DMSArray + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { +#if NET7_0_OR_GREATER + return ref Anonymous.Texture2DMSArray; +#else + return ref MemoryMarshal.GetReference(MemoryMarshal.CreateSpan(ref Anonymous.Texture2DMSArray, 1)); +#endif + } + } + + [StructLayout(LayoutKind.Explicit)] + public partial struct _Anonymous_e__Union + { + /// + [FieldOffset(0)] + public Tex1dDsv Texture1D; + + /// + [FieldOffset(0)] + public Tex1dArrayDsv Texture1DArray; + + /// + [FieldOffset(0)] + public Tex2dDsv Texture2D; + + /// + [FieldOffset(0)] + public Tex2dArrayDsv Texture2DArray; + + /// + [FieldOffset(0)] + public Tex2dmsDsv Texture2DMS; + + /// + [FieldOffset(0)] + public Tex2dmsArrayDsv Texture2DMSArray; + } + +} + +/// +/// D3D12_DESCRIPTOR_HEAP_DESC +public partial struct DescriptorHeapDescription +{ + /// + public DescriptorHeapType Type; + + /// + public uint NumDescriptors; + + /// + public DescriptorHeapFlags Flags; + + /// + public uint NodeMask; +} + +/// +/// D3D12_DESCRIPTOR_RANGE +public partial struct DescriptorRange +{ + /// + public DescriptorRangeType RangeType; + + /// + public uint NumDescriptors; + + /// + public uint BaseShaderRegister; + + /// + public uint RegisterSpace; + + /// + public uint OffsetInDescriptorsFromTableStart; +} + +/// +/// D3D12_ROOT_DESCRIPTOR_TABLE +public partial struct RootDescriptorTable +{ + /// + public uint NumDescriptorRanges; + + /// + public unsafe DescriptorRange* pDescriptorRanges; +} + +/// +/// D3D12_ROOT_CONSTANTS +public partial struct RootConstants +{ + /// + public uint ShaderRegister; + + /// + public uint RegisterSpace; + + /// + public uint Num32BitValues; +} + +/// +/// D3D12_ROOT_DESCRIPTOR +public partial struct RootDescriptor +{ + /// + public uint ShaderRegister; + + /// + public uint RegisterSpace; +} + +/// +/// D3D12_ROOT_PARAMETER +public partial struct RootParameter +{ + /// + public RootParameterType ParameterType; + + /// + public _Anonymous_e__Union Anonymous; + + /// + public ShaderVisibility ShaderVisibility; + + [UnscopedRef] + public ref RootDescriptorTable DescriptorTable + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { +#if NET7_0_OR_GREATER + return ref Anonymous.DescriptorTable; +#else + return ref MemoryMarshal.GetReference(MemoryMarshal.CreateSpan(ref Anonymous.DescriptorTable, 1)); +#endif + } + } + + [UnscopedRef] + public ref RootConstants Constants + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { +#if NET7_0_OR_GREATER + return ref Anonymous.Constants; +#else + return ref MemoryMarshal.GetReference(MemoryMarshal.CreateSpan(ref Anonymous.Constants, 1)); +#endif + } + } + + [UnscopedRef] + public ref RootDescriptor Descriptor + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { +#if NET7_0_OR_GREATER + return ref Anonymous.Descriptor; +#else + return ref MemoryMarshal.GetReference(MemoryMarshal.CreateSpan(ref Anonymous.Descriptor, 1)); +#endif + } + } + + [StructLayout(LayoutKind.Explicit)] + public partial struct _Anonymous_e__Union + { + /// + [FieldOffset(0)] + public RootDescriptorTable DescriptorTable; + + /// + [FieldOffset(0)] + public RootConstants Constants; + + /// + [FieldOffset(0)] + public RootDescriptor Descriptor; + } + +} + +/// +/// D3D12_STATIC_SAMPLER_DESC +public partial struct StaticSamplerDescription +{ + /// + public Filter Filter; + + /// + public TextureAddressMode AddressU; + + /// + public TextureAddressMode AddressV; + + /// + public TextureAddressMode AddressW; + + /// + public float MipLODBias; + + /// + public uint MaxAnisotropy; + + /// + public ComparisonFunc ComparisonFunc; + + /// + public StaticBorderColor BorderColor; + + /// + public float MinLOD; + + /// + public float MaxLOD; + + /// + public uint ShaderRegister; + + /// + public uint RegisterSpace; + + /// + public ShaderVisibility ShaderVisibility; +} + +/// +/// D3D12_ROOT_SIGNATURE_DESC +public partial struct RootSignatureDescription +{ + /// + public uint NumParameters; + + /// + public unsafe RootParameter* pParameters; + + /// + public uint NumStaticSamplers; + + /// + public unsafe StaticSamplerDescription* pStaticSamplers; + + /// + public RootSignatureFlags Flags; +} + +/// +/// D3D12_DESCRIPTOR_RANGE1 +public partial struct DescriptorRange1 +{ + /// + public DescriptorRangeType RangeType; + + /// + public uint NumDescriptors; + + /// + public uint BaseShaderRegister; + + /// + public uint RegisterSpace; + + /// + public DescriptorRangeFlags Flags; + + /// + public uint OffsetInDescriptorsFromTableStart; +} + +/// +/// D3D12_ROOT_DESCRIPTOR_TABLE1 +public partial struct RootDescriptorTable1 +{ + /// + public uint NumDescriptorRanges; + + /// + public unsafe DescriptorRange1* pDescriptorRanges; +} + +/// +/// D3D12_ROOT_DESCRIPTOR1 +public partial struct RootDescriptor1 +{ + /// + public uint ShaderRegister; + + /// + public uint RegisterSpace; + + /// + public RootDescriptorFlags Flags; +} + +/// +/// D3D12_ROOT_PARAMETER1 +public partial struct RootParameter1 +{ + /// + public RootParameterType ParameterType; + + /// + public _Anonymous_e__Union Anonymous; + + /// + public ShaderVisibility ShaderVisibility; + + [UnscopedRef] + public ref RootDescriptorTable1 DescriptorTable + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { +#if NET7_0_OR_GREATER + return ref Anonymous.DescriptorTable; +#else + return ref MemoryMarshal.GetReference(MemoryMarshal.CreateSpan(ref Anonymous.DescriptorTable, 1)); +#endif + } + } + + [UnscopedRef] + public ref RootConstants Constants + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { +#if NET7_0_OR_GREATER + return ref Anonymous.Constants; +#else + return ref MemoryMarshal.GetReference(MemoryMarshal.CreateSpan(ref Anonymous.Constants, 1)); +#endif + } + } + + [UnscopedRef] + public ref RootDescriptor1 Descriptor + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { +#if NET7_0_OR_GREATER + return ref Anonymous.Descriptor; +#else + return ref MemoryMarshal.GetReference(MemoryMarshal.CreateSpan(ref Anonymous.Descriptor, 1)); +#endif + } + } + + [StructLayout(LayoutKind.Explicit)] + public partial struct _Anonymous_e__Union + { + /// + [FieldOffset(0)] + public RootDescriptorTable1 DescriptorTable; + + /// + [FieldOffset(0)] + public RootConstants Constants; + + /// + [FieldOffset(0)] + public RootDescriptor1 Descriptor; + } + +} + +/// +/// D3D12_ROOT_SIGNATURE_DESC1 +public partial struct RootSignatureDescription1 +{ + /// + public uint NumParameters; + + /// + public unsafe RootParameter1* pParameters; + + /// + public uint NumStaticSamplers; + + /// + public unsafe StaticSamplerDescription* pStaticSamplers; + + /// + public RootSignatureFlags Flags; +} + +/// +/// D3D12_VERSIONED_ROOT_SIGNATURE_DESC +public partial struct VersionedRootSignatureDescription +{ + /// + public RootSignatureVersion Version; + + /// + public _Anonymous_e__Union Anonymous; + + [UnscopedRef] + public ref RootSignatureDescription Desc_1_0 + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { +#if NET7_0_OR_GREATER + return ref Anonymous.Desc_1_0; +#else + return ref MemoryMarshal.GetReference(MemoryMarshal.CreateSpan(ref Anonymous.Desc_1_0, 1)); +#endif + } + } + + [UnscopedRef] + public ref RootSignatureDescription1 Desc_1_1 + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { +#if NET7_0_OR_GREATER + return ref Anonymous.Desc_1_1; +#else + return ref MemoryMarshal.GetReference(MemoryMarshal.CreateSpan(ref Anonymous.Desc_1_1, 1)); +#endif + } + } + + [StructLayout(LayoutKind.Explicit)] + public partial struct _Anonymous_e__Union + { + /// + [FieldOffset(0)] + public RootSignatureDescription Desc_1_0; + + /// + [FieldOffset(0)] + public RootSignatureDescription1 Desc_1_1; + } + +} + +/// +/// D3D12_CPU_DESCRIPTOR_HANDLE +public partial struct CpuDescriptorHandle +{ + /// + public nuint ptr; +} + +/// +/// D3D12_GPU_DESCRIPTOR_HANDLE +public partial struct GpuDescriptorHandle +{ + /// + public ulong ptr; +} + +/// +/// D3D12_DISCARD_REGION +public partial struct DiscardRegion +{ + /// + public uint NumRects; + + /// + public unsafe RawRect* pRects; + + /// + public uint FirstSubresource; + + /// + public uint NumSubresources; +} + +/// +/// D3D12_QUERY_HEAP_DESC +public partial struct QueryHeapDescription +{ + /// + public QueryHeapType Type; + + /// + public uint Count; + + /// + public uint NodeMask; +} + +/// +/// D3D12_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; +} + +/// +/// D3D12_QUERY_DATA_PIPELINE_STATISTICS1 +public partial struct QueryDataPipelineStatistics1 +{ + /// + 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; + + /// + public ulong ASInvocations; + + /// + public ulong MSInvocations; + + /// + public ulong MSPrimitives; +} + +/// +/// D3D12_QUERY_DATA_SO_STATISTICS +public partial struct QueryDataSoStatistics +{ + /// + public ulong NumPrimitivesWritten; + + /// + public ulong PrimitivesStorageNeeded; +} + +/// +/// D3D12_STREAM_OUTPUT_BUFFER_VIEW +public partial struct StreamOutputBufferView +{ + /// + public ulong BufferLocation; + + /// + public ulong SizeInBytes; + + /// + public ulong BufferFilledSizeLocation; +} + +/// +/// D3D12_DRAW_ARGUMENTS +public partial struct DrawArguments +{ + /// + public uint VertexCountPerInstance; + + /// + public uint InstanceCount; + + /// + public uint StartVertexLocation; + + /// + public uint StartInstanceLocation; +} + +/// +/// D3D12_DRAW_INDEXED_ARGUMENTS +public partial struct DrawIndexedArguments +{ + /// + public uint IndexCountPerInstance; + + /// + public uint InstanceCount; + + /// + public uint StartIndexLocation; + + /// + public int BaseVertexLocation; + + /// + public uint StartInstanceLocation; +} + +/// +/// D3D12_DISPATCH_ARGUMENTS +public partial struct DispatchArguments +{ + /// + public uint ThreadGroupCountX; + + /// + public uint ThreadGroupCountY; + + /// + public uint ThreadGroupCountZ; +} + +/// +/// D3D12_VERTEX_BUFFER_VIEW +public partial struct VertexBufferView +{ + /// + public ulong BufferLocation; + + /// + public uint SizeInBytes; + + /// + public uint StrideInBytes; +} + +/// +/// D3D12_INDEX_BUFFER_VIEW +public partial struct IndexBufferView +{ + /// + public ulong BufferLocation; + + /// + public uint SizeInBytes; + + /// + public Graphics.Dxgi.Common.Format Format; +} + +/// +/// D3D12_INDIRECT_ARGUMENT_DESC +public partial struct IndirectArgumentDescription +{ + /// + public IndirectArgumentType Type; + + /// + public _Anonymous_e__Union Anonymous; + + [UnscopedRef] + public ref _Anonymous_e__Union._VertexBuffer_e__Struct VertexBuffer + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { +#if NET7_0_OR_GREATER + return ref Anonymous.VertexBuffer; +#else + return ref MemoryMarshal.GetReference(MemoryMarshal.CreateSpan(ref Anonymous.VertexBuffer, 1)); +#endif + } + } + + [UnscopedRef] + public ref _Anonymous_e__Union._Constant_e__Struct Constant + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { +#if NET7_0_OR_GREATER + return ref Anonymous.Constant; +#else + return ref MemoryMarshal.GetReference(MemoryMarshal.CreateSpan(ref Anonymous.Constant, 1)); +#endif + } + } + + [UnscopedRef] + public ref _Anonymous_e__Union._ConstantBufferView_e__Struct ConstantBufferView + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { +#if NET7_0_OR_GREATER + return ref Anonymous.ConstantBufferView; +#else + return ref MemoryMarshal.GetReference(MemoryMarshal.CreateSpan(ref Anonymous.ConstantBufferView, 1)); +#endif + } + } + + [UnscopedRef] + public ref _Anonymous_e__Union._ShaderResourceView_e__Struct ShaderResourceView + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { +#if NET7_0_OR_GREATER + return ref Anonymous.ShaderResourceView; +#else + return ref MemoryMarshal.GetReference(MemoryMarshal.CreateSpan(ref Anonymous.ShaderResourceView, 1)); +#endif + } + } + + [UnscopedRef] + public ref _Anonymous_e__Union._UnorderedAccessView_e__Struct UnorderedAccessView + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { +#if NET7_0_OR_GREATER + return ref Anonymous.UnorderedAccessView; +#else + return ref MemoryMarshal.GetReference(MemoryMarshal.CreateSpan(ref Anonymous.UnorderedAccessView, 1)); +#endif + } + } + + [StructLayout(LayoutKind.Explicit)] + public partial struct _Anonymous_e__Union + { + /// + [FieldOffset(0)] + public _Anonymous_e__Union._VertexBuffer_e__Struct VertexBuffer; + + /// + [FieldOffset(0)] + public _Anonymous_e__Union._Constant_e__Struct Constant; + + /// + [FieldOffset(0)] + public _Anonymous_e__Union._ConstantBufferView_e__Struct ConstantBufferView; + + /// + [FieldOffset(0)] + public _Anonymous_e__Union._ShaderResourceView_e__Struct ShaderResourceView; + + /// + [FieldOffset(0)] + public _Anonymous_e__Union._UnorderedAccessView_e__Struct UnorderedAccessView; + + public partial struct _ShaderResourceView_e__Struct + { + /// + public uint RootParameterIndex; + } + + public partial struct _Constant_e__Struct + { + /// + public uint RootParameterIndex; + + /// + public uint DestOffsetIn32BitValues; + + /// + public uint Num32BitValuesToSet; + } + + public partial struct _UnorderedAccessView_e__Struct + { + /// + public uint RootParameterIndex; + } + + public partial struct _VertexBuffer_e__Struct + { + /// + public uint Slot; + } + + public partial struct _ConstantBufferView_e__Struct + { + /// + public uint RootParameterIndex; + } + + } + +} + +/// +/// D3D12_COMMAND_SIGNATURE_DESC +public partial struct CommandSignatureDescription +{ + /// + public uint ByteStride; + + /// + public uint NumArgumentDescs; + + /// + public unsafe IndirectArgumentDescription* pArgumentDescs; + + /// + public uint NodeMask; +} + +/// +/// D3D12_WRITEBUFFERIMMEDIATE_PARAMETER +public partial struct WritebufferimmediateParameter +{ + /// + public ulong Dest; + + /// + public uint Value; +} + +/// +/// D3D12_FEATURE_DATA_PROTECTED_RESOURCE_SESSION_SUPPORT +public partial struct FeatureDataProtectedResourceSessionSupport +{ + /// + public uint NodeIndex; + + /// + public ProtectedResourceSessionSupportFlags Support; +} + +/// +/// D3D12_PROTECTED_RESOURCE_SESSION_DESC +public partial struct ProtectedResourceSessionDescription +{ + /// + public uint NodeMask; + + /// + public ProtectedResourceSessionFlags Flags; +} + +/// +/// D3D12_META_COMMAND_PARAMETER_DESC +public partial struct MetaCommandParameterDescription +{ + /// + public unsafe char* Name; + + /// + public MetaCommandParameterType Type; + + /// + public MetaCommandParameterFlags Flags; + + /// + public ResourceStates RequiredResourceState; + + /// + public uint StructureOffset; +} + +/// +/// D3D12_META_COMMAND_DESC +public partial struct MetaCommandDescription +{ + /// + public Guid Id; + + /// + public unsafe char* Name; + + /// + public GraphicsStates InitializationDirtyState; + + /// + public GraphicsStates ExecutionDirtyState; +} + +/// +/// D3D12_STATE_SUBOBJECT +public partial struct StateSubobject +{ + /// + public StateSubobjectType Type; + + /// + public unsafe void* pDesc; +} + +/// +/// D3D12_STATE_OBJECT_CONFIG +public partial struct StateObjectConfig +{ + /// + public StateObjectFlags Flags; +} + +/// +/// D3D12_GLOBAL_ROOT_SIGNATURE +public partial struct GlobalRootSignature +{ + /// + public ID3D12RootSignature pGlobalRootSignature; +} + +/// +/// D3D12_LOCAL_ROOT_SIGNATURE +public partial struct LocalRootSignature +{ + /// + public ID3D12RootSignature pLocalRootSignature; +} + +/// +/// D3D12_NODE_MASK +public partial struct NodeMask +{ + /// + public uint Mask; +} + +/// +/// D3D12_EXPORT_DESC +public partial struct ExportDescription +{ + /// + public unsafe char* Name; + + /// + public unsafe char* ExportToRename; + + /// + public ExportFlags Flags; +} + +/// +/// D3D12_DXIL_LIBRARY_DESC +public partial struct DxilLibraryDescription +{ + /// + public ShaderBytecode DXILLibrary; + + /// + public uint NumExports; + + /// + public unsafe ExportDescription* pExports; +} + +/// +/// D3D12_EXISTING_COLLECTION_DESC +public partial struct ExistingCollectionDescription +{ + /// + public ID3D12StateObject pExistingCollection; + + /// + public uint NumExports; + + /// + public unsafe ExportDescription* pExports; +} + +/// +/// D3D12_SUBOBJECT_TO_EXPORTS_ASSOCIATION +public partial struct SubobjectToExportsAssociation +{ + /// + public unsafe StateSubobject* pSubobjectToAssociate; + + /// + public uint NumExports; + + /// + public unsafe char** pExports; +} + +/// +/// D3D12_DXIL_SUBOBJECT_TO_EXPORTS_ASSOCIATION +public partial struct DxilSubobjectToExportsAssociation +{ + /// + public unsafe char* SubobjectToAssociate; + + /// + public uint NumExports; + + /// + public unsafe char** pExports; +} + +/// +/// D3D12_HIT_GROUP_DESC +public partial struct HitGroupDescription +{ + /// + public unsafe char* HitGroupExport; + + /// + public HitGroupType Type; + + /// + public unsafe char* AnyHitShaderImport; + + /// + public unsafe char* ClosestHitShaderImport; + + /// + public unsafe char* IntersectionShaderImport; +} + +/// +/// D3D12_RAYTRACING_SHADER_CONFIG +public partial struct RaytracingShaderConfig +{ + /// + public uint MaxPayloadSizeInBytes; + + /// + public uint MaxAttributeSizeInBytes; +} + +/// +/// D3D12_RAYTRACING_PIPELINE_CONFIG +public partial struct RaytracingPipelineConfig +{ + /// + public uint MaxTraceRecursionDepth; +} + +/// +/// D3D12_RAYTRACING_PIPELINE_CONFIG1 +public partial struct RaytracingPipelineConfig1 +{ + /// + public uint MaxTraceRecursionDepth; + + /// + public RaytracingPipelineFlags Flags; +} + +/// +/// D3D12_STATE_OBJECT_DESC +public partial struct StateObjectDescription +{ + /// + public StateObjectType Type; + + /// + public uint NumSubobjects; + + /// + public unsafe StateSubobject* pSubobjects; +} + +/// +/// D3D12_GPU_VIRTUAL_ADDRESS_AND_STRIDE +public partial struct GpuVirtualAddressAndStride +{ + /// + public ulong StartAddress; + + /// + public ulong StrideInBytes; +} + +/// +/// D3D12_GPU_VIRTUAL_ADDRESS_RANGE +public partial struct GpuVirtualAddressRange +{ + /// + public ulong StartAddress; + + /// + public ulong SizeInBytes; +} + +/// +/// D3D12_GPU_VIRTUAL_ADDRESS_RANGE_AND_STRIDE +public partial struct GpuVirtualAddressRangeAndStride +{ + /// + public ulong StartAddress; + + /// + public ulong SizeInBytes; + + /// + public ulong StrideInBytes; +} + +/// +/// D3D12_RAYTRACING_GEOMETRY_TRIANGLES_DESC +public partial struct RaytracingGeometryTrianglesDescription +{ + /// + public ulong Transform3x4; + + /// + public Graphics.Dxgi.Common.Format IndexFormat; + + /// + public Graphics.Dxgi.Common.Format VertexFormat; + + /// + public uint IndexCount; + + /// + public uint VertexCount; + + /// + public ulong IndexBuffer; + + /// + public GpuVirtualAddressAndStride VertexBuffer; +} + +/// +/// D3D12_RAYTRACING_AABB +public partial struct RaytracingAabb +{ + /// + public float MinX; + + /// + public float MinY; + + /// + public float MinZ; + + /// + public float MaxX; + + /// + public float MaxY; + + /// + public float MaxZ; +} + +/// +/// D3D12_RAYTRACING_GEOMETRY_AABBS_DESC +public partial struct RaytracingGeometryAabbsDescription +{ + /// + public ulong AABBCount; + + /// + public GpuVirtualAddressAndStride AABBs; +} + +/// +/// D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_DESC +public partial struct RaytracingAccelerationStructurePostbuildInfoDescription +{ + /// + public ulong DestBuffer; + + /// + public RaytracingAccelerationStructurePostbuildInfoType InfoType; +} + +/// +/// D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_COMPACTED_SIZE_DESC +public partial struct RaytracingAccelerationStructurePostbuildInfoCompactedSizeDescription +{ + /// + public ulong CompactedSizeInBytes; +} + +/// +/// D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_TOOLS_VISUALIZATION_DESC +public partial struct RaytracingAccelerationStructurePostbuildInfoToolsVisualizationDescription +{ + /// + public ulong DecodedSizeInBytes; +} + +/// +/// D3D12_BUILD_RAYTRACING_ACCELERATION_STRUCTURE_TOOLS_VISUALIZATION_HEADER +public partial struct BuildRaytracingAccelerationStructureToolsVisualizationHeader +{ + /// + public RaytracingAccelerationStructureType Type; + + /// + public uint NumDescs; +} + +/// +/// D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_SERIALIZATION_DESC +public partial struct RaytracingAccelerationStructurePostbuildInfoSerializationDescription +{ + /// + public ulong SerializedSizeInBytes; + + /// + public ulong NumBottomLevelAccelerationStructurePointers; +} + +/// +/// D3D12_SERIALIZED_DATA_DRIVER_MATCHING_IDENTIFIER +public partial struct SerializedDataDriverMatchingIdentifier +{ + /// + public Guid DriverOpaqueGUID; + + /// + public unsafe fixed byte DriverOpaqueVersioningData[16]; +} + +/// +/// D3D12_SERIALIZED_RAYTRACING_ACCELERATION_STRUCTURE_HEADER +public partial struct SerializedRaytracingAccelerationStructureHeader +{ + /// + public SerializedDataDriverMatchingIdentifier DriverMatchingIdentifier; + + /// + public ulong SerializedSizeInBytesIncludingHeader; + + /// + public ulong DeserializedSizeInBytes; + + /// + public ulong NumBottomLevelAccelerationStructurePointersAfterHeader; +} + +/// +/// D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_CURRENT_SIZE_DESC +public partial struct RaytracingAccelerationStructurePostbuildInfoCurrentSizeDescription +{ + /// + public ulong CurrentSizeInBytes; +} + +/// +/// D3D12_RAYTRACING_INSTANCE_DESC +public partial struct RaytracingInstanceDescription +{ + /// + public unsafe fixed float Transform[12]; + + /// + public uint _bitfield1; + + /// + public uint _bitfield2; + + /// + public ulong AccelerationStructure; +} + +/// +/// D3D12_RAYTRACING_GEOMETRY_DESC +public partial struct RaytracingGeometryDescription +{ + /// + public RaytracingGeometryType Type; + + /// + public RaytracingGeometryFlags Flags; + + /// + public _Anonymous_e__Union Anonymous; + + [UnscopedRef] + public ref RaytracingGeometryTrianglesDescription Triangles + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { +#if NET7_0_OR_GREATER + return ref Anonymous.Triangles; +#else + return ref MemoryMarshal.GetReference(MemoryMarshal.CreateSpan(ref Anonymous.Triangles, 1)); +#endif + } + } + + [UnscopedRef] + public ref RaytracingGeometryAabbsDescription AABBs + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { +#if NET7_0_OR_GREATER + return ref Anonymous.AABBs; +#else + return ref MemoryMarshal.GetReference(MemoryMarshal.CreateSpan(ref Anonymous.AABBs, 1)); +#endif + } + } + + [StructLayout(LayoutKind.Explicit)] + public partial struct _Anonymous_e__Union + { + /// + [FieldOffset(0)] + public RaytracingGeometryTrianglesDescription Triangles; + + /// + [FieldOffset(0)] + public RaytracingGeometryAabbsDescription AABBs; + } + +} + +/// +/// D3D12_BUILD_RAYTRACING_ACCELERATION_STRUCTURE_INPUTS +public partial struct BuildRaytracingAccelerationStructureInputs +{ + /// + public RaytracingAccelerationStructureType Type; + + /// + public RaytracingAccelerationStructureBuildFlags Flags; + + /// + public uint NumDescs; + + /// + public ElementsLayout DescsLayout; + + /// + public _Anonymous_e__Union Anonymous; + + [UnscopedRef] + public ref ulong InstanceDescs + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { +#if NET7_0_OR_GREATER + return ref Anonymous.InstanceDescs; +#else + return ref MemoryMarshal.GetReference(MemoryMarshal.CreateSpan(ref Anonymous.InstanceDescs, 1)); +#endif + } + } + + [UnscopedRef] + public unsafe ref RaytracingGeometryDescription* pGeometryDescs + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { +#if NET7_0_OR_GREATER + return ref Anonymous.pGeometryDescs; +#else + return ref MemoryMarshal.GetReference(MemoryMarshal.CreateSpan(ref this, 1)).Anonymous.pGeometryDescs; +#endif + } + } + + [UnscopedRef] + public unsafe ref RaytracingGeometryDescription** ppGeometryDescs + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { +#if NET7_0_OR_GREATER + return ref Anonymous.ppGeometryDescs; +#else + return ref MemoryMarshal.GetReference(MemoryMarshal.CreateSpan(ref this, 1)).Anonymous.ppGeometryDescs; +#endif + } + } + + [StructLayout(LayoutKind.Explicit)] + public partial struct _Anonymous_e__Union + { + /// + [FieldOffset(0)] + public ulong InstanceDescs; + + /// + [FieldOffset(0)] + public unsafe RaytracingGeometryDescription* pGeometryDescs; + + /// + [FieldOffset(0)] + public unsafe RaytracingGeometryDescription** ppGeometryDescs; + } + +} + +/// +/// D3D12_BUILD_RAYTRACING_ACCELERATION_STRUCTURE_DESC +public partial struct BuildRaytracingAccelerationStructureDescription +{ + /// + public ulong DestAccelerationStructureData; + + /// + public BuildRaytracingAccelerationStructureInputs Inputs; + + /// + public ulong SourceAccelerationStructureData; + + /// + public ulong ScratchAccelerationStructureData; +} + +/// +/// D3D12_RAYTRACING_ACCELERATION_STRUCTURE_PREBUILD_INFO +public partial struct RaytracingAccelerationStructurePrebuildInfo +{ + /// + public ulong ResultDataMaxSizeInBytes; + + /// + public ulong ScratchDataSizeInBytes; + + /// + public ulong UpdateScratchDataSizeInBytes; +} + +/// +/// D3D12_AUTO_BREADCRUMB_NODE +public partial struct AutoBreadcrumbNode +{ + /// + public unsafe byte* pCommandListDebugNameA; + + /// + public unsafe char* pCommandListDebugNameW; + + /// + public unsafe byte* pCommandQueueDebugNameA; + + /// + public unsafe char* pCommandQueueDebugNameW; + + /// + public ID3D12GraphicsCommandList pCommandList; + + /// + public ID3D12CommandQueue pCommandQueue; + + /// + public uint BreadcrumbCount; + + /// + public unsafe uint* pLastBreadcrumbValue; + + /// + public unsafe AutoBreadcrumbOp* pCommandHistory; + + /// + public unsafe AutoBreadcrumbNode* pNext; +} + +/// +/// D3D12_DRED_BREADCRUMB_CONTEXT +public partial struct DredBreadcrumbContext +{ + /// + public uint BreadcrumbIndex; + + /// + public unsafe char* pContextString; +} + +/// +/// D3D12_AUTO_BREADCRUMB_NODE1 +public partial struct AutoBreadcrumbNode1 +{ + /// + public unsafe byte* pCommandListDebugNameA; + + /// + public unsafe char* pCommandListDebugNameW; + + /// + public unsafe byte* pCommandQueueDebugNameA; + + /// + public unsafe char* pCommandQueueDebugNameW; + + /// + public ID3D12GraphicsCommandList pCommandList; + + /// + public ID3D12CommandQueue pCommandQueue; + + /// + public uint BreadcrumbCount; + + /// + public unsafe uint* pLastBreadcrumbValue; + + /// + public unsafe AutoBreadcrumbOp* pCommandHistory; + + /// + public unsafe AutoBreadcrumbNode1* pNext; + + /// + public uint BreadcrumbContextsCount; + + /// + public unsafe DredBreadcrumbContext* pBreadcrumbContexts; +} + +/// +/// D3D12_DEVICE_REMOVED_EXTENDED_DATA +public partial struct DeviceRemovedExtendedData +{ + /// + public DredFlags Flags; + + /// + public unsafe AutoBreadcrumbNode* pHeadAutoBreadcrumbNode; +} + +/// +/// D3D12_DRED_ALLOCATION_NODE +public partial struct DredAllocationNode +{ + /// + public unsafe byte* ObjectNameA; + + /// + public unsafe char* ObjectNameW; + + /// + public DredAllocationType AllocationType; + + /// + public unsafe DredAllocationNode* pNext; +} + +/// +/// D3D12_DRED_ALLOCATION_NODE1 +public partial struct DredAllocationNode1 +{ + /// + public unsafe byte* ObjectNameA; + + /// + public unsafe char* ObjectNameW; + + /// + public DredAllocationType AllocationType; + + /// + public unsafe DredAllocationNode1* pNext; + + /// + public IUnknown pObject; +} + +/// +/// D3D12_DRED_AUTO_BREADCRUMBS_OUTPUT +public partial struct DredAutoBreadcrumbsOutput +{ + /// + public unsafe AutoBreadcrumbNode* pHeadAutoBreadcrumbNode; +} + +/// +/// D3D12_DRED_AUTO_BREADCRUMBS_OUTPUT1 +public partial struct DredAutoBreadcrumbsOutput1 +{ + /// + public unsafe AutoBreadcrumbNode1* pHeadAutoBreadcrumbNode; +} + +/// +/// D3D12_DRED_PAGE_FAULT_OUTPUT +public partial struct DredPageFaultOutput +{ + /// + public ulong PageFaultVA; + + /// + public unsafe DredAllocationNode* pHeadExistingAllocationNode; + + /// + public unsafe DredAllocationNode* pHeadRecentFreedAllocationNode; +} + +/// +/// D3D12_DRED_PAGE_FAULT_OUTPUT1 +public partial struct DredPageFaultOutput1 +{ + /// + public ulong PageFaultVA; + + /// + public unsafe DredAllocationNode1* pHeadExistingAllocationNode; + + /// + public unsafe DredAllocationNode1* pHeadRecentFreedAllocationNode; +} + +/// +/// D3D12_DRED_PAGE_FAULT_OUTPUT2 +public partial struct DredPageFaultOutput2 +{ + /// + public ulong PageFaultVA; + + /// + public unsafe DredAllocationNode1* pHeadExistingAllocationNode; + + /// + public unsafe DredAllocationNode1* pHeadRecentFreedAllocationNode; + + /// + public DredPageFaultFlags PageFaultFlags; +} + +/// +/// D3D12_DEVICE_REMOVED_EXTENDED_DATA1 +public partial struct DeviceRemovedExtendedData1 +{ + /// + public HResult DeviceRemovedReason; + + /// + public DredAutoBreadcrumbsOutput AutoBreadcrumbsOutput; + + /// + public DredPageFaultOutput PageFaultOutput; +} + +/// +/// D3D12_DEVICE_REMOVED_EXTENDED_DATA2 +public partial struct DeviceRemovedExtendedData2 +{ + /// + public HResult DeviceRemovedReason; + + /// + public DredAutoBreadcrumbsOutput1 AutoBreadcrumbsOutput; + + /// + public DredPageFaultOutput1 PageFaultOutput; +} + +/// +/// D3D12_DEVICE_REMOVED_EXTENDED_DATA3 +public partial struct DeviceRemovedExtendedData3 +{ + /// + public HResult DeviceRemovedReason; + + /// + public DredAutoBreadcrumbsOutput1 AutoBreadcrumbsOutput; + + /// + public DredPageFaultOutput2 PageFaultOutput; + + /// + public DredDeviceState DeviceState; +} + +/// +/// D3D12_VERSIONED_DEVICE_REMOVED_EXTENDED_DATA +public partial struct VersionedDeviceRemovedExtendedData +{ + /// + public DredVersion Version; + + /// + public _Anonymous_e__Union Anonymous; + + [UnscopedRef] + public ref DeviceRemovedExtendedData Dred_1_0 + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { +#if NET7_0_OR_GREATER + return ref Anonymous.Dred_1_0; +#else + return ref MemoryMarshal.GetReference(MemoryMarshal.CreateSpan(ref Anonymous.Dred_1_0, 1)); +#endif + } + } + + [UnscopedRef] + public ref DeviceRemovedExtendedData1 Dred_1_1 + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { +#if NET7_0_OR_GREATER + return ref Anonymous.Dred_1_1; +#else + return ref MemoryMarshal.GetReference(MemoryMarshal.CreateSpan(ref Anonymous.Dred_1_1, 1)); +#endif + } + } + + [UnscopedRef] + public ref DeviceRemovedExtendedData2 Dred_1_2 + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { +#if NET7_0_OR_GREATER + return ref Anonymous.Dred_1_2; +#else + return ref MemoryMarshal.GetReference(MemoryMarshal.CreateSpan(ref Anonymous.Dred_1_2, 1)); +#endif + } + } + + [UnscopedRef] + public ref DeviceRemovedExtendedData3 Dred_1_3 + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { +#if NET7_0_OR_GREATER + return ref Anonymous.Dred_1_3; +#else + return ref MemoryMarshal.GetReference(MemoryMarshal.CreateSpan(ref Anonymous.Dred_1_3, 1)); +#endif + } + } + + [StructLayout(LayoutKind.Explicit)] + public partial struct _Anonymous_e__Union + { + /// + [FieldOffset(0)] + public DeviceRemovedExtendedData Dred_1_0; + + /// + [FieldOffset(0)] + public DeviceRemovedExtendedData1 Dred_1_1; + + /// + [FieldOffset(0)] + public DeviceRemovedExtendedData2 Dred_1_2; + + /// + [FieldOffset(0)] + public DeviceRemovedExtendedData3 Dred_1_3; + } + +} + +/// +/// D3D12_FEATURE_DATA_PROTECTED_RESOURCE_SESSION_TYPE_COUNT +public partial struct FeatureDataProtectedResourceSessionTypeCount +{ + /// + public uint NodeIndex; + + /// + public uint Count; +} + +/// +/// D3D12_FEATURE_DATA_PROTECTED_RESOURCE_SESSION_TYPES +public partial struct FeatureDataProtectedResourceSessionTypes +{ + /// + public uint NodeIndex; + + /// + public uint Count; + + /// + public unsafe Guid* pTypes; +} + +/// +/// D3D12_PROTECTED_RESOURCE_SESSION_DESC1 +public partial struct ProtectedResourceSessionDescription1 +{ + /// + public uint NodeMask; + + /// + public ProtectedResourceSessionFlags Flags; + + /// + public Guid ProtectionType; +} + +/// +/// D3D12_RENDER_PASS_BEGINNING_ACCESS_CLEAR_PARAMETERS +public partial struct RenderPassBeginningAccessClearParameters +{ + /// + public ClearValue ClearValue; +} + +/// +/// D3D12_RENDER_PASS_BEGINNING_ACCESS +public partial struct RenderPassBeginningAccess +{ + /// + public RenderPassBeginningAccessType Type; + + /// + public _Anonymous_e__Union Anonymous; + + [UnscopedRef] + public ref RenderPassBeginningAccessClearParameters Clear + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { +#if NET7_0_OR_GREATER + return ref Anonymous.Clear; +#else + return ref MemoryMarshal.GetReference(MemoryMarshal.CreateSpan(ref Anonymous.Clear, 1)); +#endif + } + } + + [StructLayout(LayoutKind.Explicit)] + public partial struct _Anonymous_e__Union + { + /// + [FieldOffset(0)] + public RenderPassBeginningAccessClearParameters Clear; + } + +} + +/// +/// D3D12_RENDER_PASS_ENDING_ACCESS_RESOLVE_SUBRESOURCE_PARAMETERS +public partial struct RenderPassEndingAccessResolveSubresourceParameters +{ + /// + public uint SrcSubresource; + + /// + public uint DstSubresource; + + /// + public uint DstX; + + /// + public uint DstY; + + /// + public RawRect SrcRect; +} + +/// +/// D3D12_RENDER_PASS_ENDING_ACCESS_RESOLVE_PARAMETERS +public partial struct RenderPassEndingAccessResolveParameters +{ + /// + public ID3D12Resource pSrcResource; + + /// + public ID3D12Resource pDstResource; + + /// + public uint SubresourceCount; + + /// + public unsafe RenderPassEndingAccessResolveSubresourceParameters* pSubresourceParameters; + + /// + public Graphics.Dxgi.Common.Format Format; + + /// + public ResolveMode ResolveMode; + + /// + public Bool32 PreserveResolveSource; +} + +/// +/// D3D12_RENDER_PASS_ENDING_ACCESS +public partial struct RenderPassEndingAccess +{ + /// + public RenderPassEndingAccessType Type; + + /// + public _Anonymous_e__Union Anonymous; + + [UnscopedRef] + public ref RenderPassEndingAccessResolveParameters Resolve + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { +#if NET7_0_OR_GREATER + return ref Anonymous.Resolve; +#else + return ref MemoryMarshal.GetReference(MemoryMarshal.CreateSpan(ref Anonymous.Resolve, 1)); +#endif + } + } + + [StructLayout(LayoutKind.Explicit)] + public partial struct _Anonymous_e__Union + { + /// + [FieldOffset(0)] + public RenderPassEndingAccessResolveParameters Resolve; + } + +} + +/// +/// D3D12_RENDER_PASS_RENDER_TARGET_DESC +public partial struct RenderPassRenderTargetDescription +{ + /// + public CpuDescriptorHandle cpuDescriptor; + + /// + public RenderPassBeginningAccess BeginningAccess; + + /// + public RenderPassEndingAccess EndingAccess; +} + +/// +/// D3D12_RENDER_PASS_DEPTH_STENCIL_DESC +public partial struct RenderPassDepthStencilDescription +{ + /// + public CpuDescriptorHandle cpuDescriptor; + + /// + public RenderPassBeginningAccess DepthBeginningAccess; + + /// + public RenderPassBeginningAccess StencilBeginningAccess; + + /// + public RenderPassEndingAccess DepthEndingAccess; + + /// + public RenderPassEndingAccess StencilEndingAccess; +} + +/// +/// D3D12_DISPATCH_RAYS_DESC +public partial struct DispatchRaysDescription +{ + /// + public GpuVirtualAddressRange RayGenerationShaderRecord; + + /// + public GpuVirtualAddressRangeAndStride MissShaderTable; + + /// + public GpuVirtualAddressRangeAndStride HitGroupTable; + + /// + public GpuVirtualAddressRangeAndStride CallableShaderTable; + + /// + public uint Width; + + /// + public uint Height; + + /// + public uint Depth; +} + +/// +/// D3D12_SHADER_CACHE_SESSION_DESC +public partial struct ShaderCacheSessionDescription +{ + /// + public Guid Identifier; + + /// + public ShaderCacheMode Mode; + + /// + public ShaderCacheFlags Flags; + + /// + public uint MaximumInMemoryCacheSizeBytes; + + /// + public uint MaximumInMemoryCacheEntries; + + /// + public uint MaximumValueFileSizeBytes; + + /// + public ulong Version; +} + +/// +/// D3D12_SUBRESOURCE_DATA +public partial struct SubresourceData +{ + /// + public unsafe void* pData; + + /// + public nint RowPitch; + + /// + public nint SlicePitch; +} + +/// +/// D3D12_MEMCPY_DEST +public partial struct MemcpyDest +{ + /// + public unsafe void* pData; + + /// + public nuint RowPitch; + + /// + public nuint SlicePitch; +} + +/// +/// D3D12_DEBUG_DEVICE_GPU_BASED_VALIDATION_SETTINGS +public partial struct DebugDeviceGpuBasedValidationSettings +{ + /// + public uint MaxMessagesPerCommandList; + + /// + public GpuBasedValidationShaderPatchMode DefaultShaderPatchMode; + + /// + public GpuBasedValidationPipelineStateCreateFlags PipelineStateCreateFlags; +} + +/// +/// D3D12_DEBUG_DEVICE_GPU_SLOWDOWN_PERFORMANCE_FACTOR +public partial struct DebugDeviceGpuSlowdownPerformanceFactor +{ + /// + public float SlowdownFactor; +} + +/// +/// D3D12_DEBUG_COMMAND_LIST_GPU_BASED_VALIDATION_SETTINGS +public partial struct DebugCommandListGpuBasedValidationSettings +{ + /// + public GpuBasedValidationShaderPatchMode ShaderPatchMode; +} + +/// +/// D3D12_MESSAGE +public partial struct Message +{ + /// + public MessageCategory Category; + + /// + public MessageSeverity Severity; + + /// + public MessageId ID; + + /// + public unsafe byte* pDescription; + + /// + public nuint DescriptionByteLength; +} + +/// +/// D3D12_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; +} + +/// +/// D3D12_INFO_QUEUE_FILTER +public partial struct InfoQueueFilter +{ + /// + public InfoQueueFilterDescription AllowList; + + /// + public InfoQueueFilterDescription DenyList; +} + +/// +/// D3D12_DISPATCH_MESH_ARGUMENTS +public partial struct DispatchMeshArguments +{ + /// + public uint ThreadGroupCountX; + + /// + public uint ThreadGroupCountY; + + /// + public uint ThreadGroupCountZ; +} + +/// +/// D3D12_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; +} + +/// +/// D3D12_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; +} + +/// +/// D3D12_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; +} + +/// +/// D3D12_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; +} + +/// +/// D3D12_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; +} + +/// +/// D3D12_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; + + /// + public uint Space; + + /// + public uint uID; +} + +/// +/// D3D12_LIBRARY_DESC +public partial struct LibraryDescription +{ + /// + public unsafe byte* Creator; + + /// + public uint Flags; + + /// + public uint FunctionCount; +} + +/// +/// D3D12_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; +} + +/// +/// D3D12_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; +} + +#endregion Structs + +#region COM Types +/// +/// ID3D12Object +[Guid("c4fec28f-7966-4e95-9f94-f431cb56c3b8")] +[NativeTypeName("struct ID3D12Object : IUnknown")] +[NativeInheritance("IUnknown")] +public unsafe partial struct ID3D12Object : ID3D12Object.Interface +{ + public static ref readonly Guid IID_ID3D12Object + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x8F, 0xC2, 0xFE, 0xC4, + 0x66, 0x79, + 0x95, 0x4E, + 0x9F, + 0x94, + 0xF4, + 0x31, + 0xCB, + 0x56, + 0xC3, + 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_ID3D12Object)); + + 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 GetPrivateData(Guid* guid, uint* pDataSize, void* pData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[3]))((ID3D12Object*)Unsafe.AsPointer(ref this), guid, pDataSize, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((ID3D12Object*)Unsafe.AsPointer(ref this), guid, pDataSize, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public HResult SetPrivateData(Guid* guid, uint DataSize, void* pData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[4]))((ID3D12Object*)Unsafe.AsPointer(ref this), guid, DataSize, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((ID3D12Object*)Unsafe.AsPointer(ref this), guid, DataSize, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(5)] + public HResult SetPrivateDataInterface(Guid* guid, IUnknown* pData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[5]))((ID3D12Object*)Unsafe.AsPointer(ref this), guid, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((ID3D12Object*)Unsafe.AsPointer(ref this), guid, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(6)] + public HResult SetName(char** Name) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[6]))((ID3D12Object*)Unsafe.AsPointer(ref this), Name); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((ID3D12Object*)Unsafe.AsPointer(ref this), Name); +#endif + } + + public interface Interface : IUnknown.Interface + { + } +} + +/// +/// ID3D12DeviceChild +[Guid("905db94b-a00c-4140-9df5-2b64ca9ea357")] +[NativeTypeName("struct ID3D12DeviceChild : ID3D12Object")] +[NativeInheritance("ID3D12Object")] +public unsafe partial struct ID3D12DeviceChild : ID3D12DeviceChild.Interface +{ + public static ref readonly Guid IID_ID3D12DeviceChild + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x4B, 0xB9, 0x5D, 0x90, + 0x0C, 0xA0, + 0x40, 0x41, + 0x9D, + 0xF5, + 0x2B, + 0x64, + 0xCA, + 0x9E, + 0xA3, + 0x57 + }; + + 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_ID3D12DeviceChild)); + + 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 GetPrivateData(Guid* guid, uint* pDataSize, void* pData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[3]))((ID3D12DeviceChild*)Unsafe.AsPointer(ref this), guid, pDataSize, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((ID3D12DeviceChild*)Unsafe.AsPointer(ref this), guid, pDataSize, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public HResult SetPrivateData(Guid* guid, uint DataSize, void* pData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[4]))((ID3D12DeviceChild*)Unsafe.AsPointer(ref this), guid, DataSize, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((ID3D12DeviceChild*)Unsafe.AsPointer(ref this), guid, DataSize, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(5)] + public HResult SetPrivateDataInterface(Guid* guid, IUnknown* pData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[5]))((ID3D12DeviceChild*)Unsafe.AsPointer(ref this), guid, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((ID3D12DeviceChild*)Unsafe.AsPointer(ref this), guid, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(6)] + public HResult SetName(char** Name) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[6]))((ID3D12DeviceChild*)Unsafe.AsPointer(ref this), Name); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((ID3D12DeviceChild*)Unsafe.AsPointer(ref this), Name); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(7)] + public HResult GetDevice(Guid* riid, void** ppvDevice) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[7]))((ID3D12DeviceChild*)Unsafe.AsPointer(ref this), riid, ppvDevice); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((ID3D12DeviceChild*)Unsafe.AsPointer(ref this), riid, ppvDevice); +#endif + } + + public interface Interface : ID3D12Object.Interface + { + } +} + +/// +/// ID3D12RootSignature +[Guid("c54a6b66-72df-4ee8-8be5-a946a1429214")] +[NativeTypeName("struct ID3D12RootSignature : ID3D12DeviceChild")] +[NativeInheritance("ID3D12DeviceChild")] +public unsafe partial struct ID3D12RootSignature : ID3D12RootSignature.Interface +{ + public static ref readonly Guid IID_ID3D12RootSignature + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x66, 0x6B, 0x4A, 0xC5, + 0xDF, 0x72, + 0xE8, 0x4E, + 0x8B, + 0xE5, + 0xA9, + 0x46, + 0xA1, + 0x42, + 0x92, + 0x14 + }; + + 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_ID3D12RootSignature)); + + 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 GetDevice(Guid* riid, void** ppvDevice) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[3]))((ID3D12RootSignature*)Unsafe.AsPointer(ref this), riid, ppvDevice); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((ID3D12RootSignature*)Unsafe.AsPointer(ref this), riid, ppvDevice); +#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]))((ID3D12RootSignature*)Unsafe.AsPointer(ref this), guid, pDataSize, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((ID3D12RootSignature*)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]))((ID3D12RootSignature*)Unsafe.AsPointer(ref this), guid, DataSize, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((ID3D12RootSignature*)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]))((ID3D12RootSignature*)Unsafe.AsPointer(ref this), guid, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((ID3D12RootSignature*)Unsafe.AsPointer(ref this), guid, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(7)] + public HResult SetName(char** Name) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[7]))((ID3D12RootSignature*)Unsafe.AsPointer(ref this), Name); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((ID3D12RootSignature*)Unsafe.AsPointer(ref this), Name); +#endif + } + + public interface Interface : ID3D12DeviceChild.Interface + { + } +} + +/// +/// ID3D12RootSignatureDeserializer +[Guid("34ab647b-3cc8-46ac-841b-c0965645c046")] +[NativeTypeName("struct ID3D12RootSignatureDeserializer : IUnknown")] +[NativeInheritance("IUnknown")] +public unsafe partial struct ID3D12RootSignatureDeserializer : ID3D12RootSignatureDeserializer.Interface +{ + public static ref readonly Guid IID_ID3D12RootSignatureDeserializer + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x7B, 0x64, 0xAB, 0x34, + 0xC8, 0x3C, + 0xAC, 0x46, + 0x84, + 0x1B, + 0xC0, + 0x96, + 0x56, + 0x45, + 0xC0, + 0x46 + }; + + 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_ID3D12RootSignatureDeserializer)); + + 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 Graphics.Direct3D12.RootSignatureDescription* GetRootSignatureDesc() + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[3]))((ID3D12RootSignatureDeserializer*)Unsafe.AsPointer(ref this)); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((ID3D12RootSignatureDeserializer*)Unsafe.AsPointer(ref this)); +#endif + } + + public interface Interface : IUnknown.Interface + { + } +} + +/// +/// ID3D12VersionedRootSignatureDeserializer +[Guid("7f91ce67-090c-4bb7-b78e-ed8ff2e31da0")] +[NativeTypeName("struct ID3D12VersionedRootSignatureDeserializer : IUnknown")] +[NativeInheritance("IUnknown")] +public unsafe partial struct ID3D12VersionedRootSignatureDeserializer : ID3D12VersionedRootSignatureDeserializer.Interface +{ + public static ref readonly Guid IID_ID3D12VersionedRootSignatureDeserializer + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x67, 0xCE, 0x91, 0x7F, + 0x0C, 0x09, + 0xB7, 0x4B, + 0xB7, + 0x8E, + 0xED, + 0x8F, + 0xF2, + 0xE3, + 0x1D, + 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_ID3D12VersionedRootSignatureDeserializer)); + + 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 GetRootSignatureDescAtVersion(RootSignatureVersion convertToVersion, VersionedRootSignatureDescription** ppDesc) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[3]))((ID3D12VersionedRootSignatureDeserializer*)Unsafe.AsPointer(ref this), convertToVersion, ppDesc); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((ID3D12VersionedRootSignatureDeserializer*)Unsafe.AsPointer(ref this), convertToVersion, ppDesc); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public Graphics.Direct3D12.VersionedRootSignatureDescription* GetUnconvertedRootSignatureDesc() + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[4]))((ID3D12VersionedRootSignatureDeserializer*)Unsafe.AsPointer(ref this)); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((ID3D12VersionedRootSignatureDeserializer*)Unsafe.AsPointer(ref this)); +#endif + } + + public interface Interface : IUnknown.Interface + { + } +} + +/// +/// ID3D12Pageable +[Guid("63ee58fb-1268-4835-86da-f008ce62f0d6")] +[NativeTypeName("struct ID3D12Pageable : ID3D12DeviceChild")] +[NativeInheritance("ID3D12DeviceChild")] +public unsafe partial struct ID3D12Pageable : ID3D12Pageable.Interface +{ + public static ref readonly Guid IID_ID3D12Pageable + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0xFB, 0x58, 0xEE, 0x63, + 0x68, 0x12, + 0x35, 0x48, + 0x86, + 0xDA, + 0xF0, + 0x08, + 0xCE, + 0x62, + 0xF0, + 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_ID3D12Pageable)); + + 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 GetDevice(Guid* riid, void** ppvDevice) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[3]))((ID3D12Pageable*)Unsafe.AsPointer(ref this), riid, ppvDevice); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((ID3D12Pageable*)Unsafe.AsPointer(ref this), riid, ppvDevice); +#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]))((ID3D12Pageable*)Unsafe.AsPointer(ref this), guid, pDataSize, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((ID3D12Pageable*)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]))((ID3D12Pageable*)Unsafe.AsPointer(ref this), guid, DataSize, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((ID3D12Pageable*)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]))((ID3D12Pageable*)Unsafe.AsPointer(ref this), guid, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((ID3D12Pageable*)Unsafe.AsPointer(ref this), guid, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(7)] + public HResult SetName(char** Name) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[7]))((ID3D12Pageable*)Unsafe.AsPointer(ref this), Name); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((ID3D12Pageable*)Unsafe.AsPointer(ref this), Name); +#endif + } + + public interface Interface : ID3D12DeviceChild.Interface + { + } +} + +/// +/// ID3D12Heap +[Guid("6b3b2502-6e51-45b3-90ee-9884265e8df3")] +[NativeTypeName("struct ID3D12Heap : ID3D12Pageable")] +[NativeInheritance("ID3D12Pageable")] +public unsafe partial struct ID3D12Heap : ID3D12Heap.Interface +{ + public static ref readonly Guid IID_ID3D12Heap + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x02, 0x25, 0x3B, 0x6B, + 0x51, 0x6E, + 0xB3, 0x45, + 0x90, + 0xEE, + 0x98, + 0x84, + 0x26, + 0x5E, + 0x8D, + 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_ID3D12Heap)); + + 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 GetDevice(Guid* riid, void** ppvDevice) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[3]))((ID3D12Heap*)Unsafe.AsPointer(ref this), riid, ppvDevice); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((ID3D12Heap*)Unsafe.AsPointer(ref this), riid, ppvDevice); +#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]))((ID3D12Heap*)Unsafe.AsPointer(ref this), guid, pDataSize, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((ID3D12Heap*)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]))((ID3D12Heap*)Unsafe.AsPointer(ref this), guid, DataSize, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((ID3D12Heap*)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]))((ID3D12Heap*)Unsafe.AsPointer(ref this), guid, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((ID3D12Heap*)Unsafe.AsPointer(ref this), guid, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(7)] + public HResult SetName(char** Name) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[7]))((ID3D12Heap*)Unsafe.AsPointer(ref this), Name); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((ID3D12Heap*)Unsafe.AsPointer(ref this), Name); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(8)] + public Graphics.Direct3D12.HeapDescription GetDesc() + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[8]))((ID3D12Heap*)Unsafe.AsPointer(ref this)); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[8]))((ID3D12Heap*)Unsafe.AsPointer(ref this)); +#endif + } + + public interface Interface : ID3D12Pageable.Interface + { + } +} + +/// +/// ID3D12Resource +[Guid("696442be-a72e-4059-bc79-5b5c98040fad")] +[NativeTypeName("struct ID3D12Resource : ID3D12Pageable")] +[NativeInheritance("ID3D12Pageable")] +public unsafe partial struct ID3D12Resource : ID3D12Resource.Interface +{ + public static ref readonly Guid IID_ID3D12Resource + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0xBE, 0x42, 0x64, 0x69, + 0x2E, 0xA7, + 0x59, 0x40, + 0xBC, + 0x79, + 0x5B, + 0x5C, + 0x98, + 0x04, + 0x0F, + 0xAD + }; + + 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_ID3D12Resource)); + + 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 GetDevice(Guid* riid, void** ppvDevice) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[3]))((ID3D12Resource*)Unsafe.AsPointer(ref this), riid, ppvDevice); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((ID3D12Resource*)Unsafe.AsPointer(ref this), riid, ppvDevice); +#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]))((ID3D12Resource*)Unsafe.AsPointer(ref this), guid, pDataSize, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((ID3D12Resource*)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]))((ID3D12Resource*)Unsafe.AsPointer(ref this), guid, DataSize, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((ID3D12Resource*)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]))((ID3D12Resource*)Unsafe.AsPointer(ref this), guid, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((ID3D12Resource*)Unsafe.AsPointer(ref this), guid, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(7)] + public HResult SetName(char** Name) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[7]))((ID3D12Resource*)Unsafe.AsPointer(ref this), Name); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((ID3D12Resource*)Unsafe.AsPointer(ref this), Name); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(8)] + public HResult Map(uint Subresource, Range* pReadRange, void** ppData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[8]))((ID3D12Resource*)Unsafe.AsPointer(ref this), Subresource, pReadRange, ppData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[8]))((ID3D12Resource*)Unsafe.AsPointer(ref this), Subresource, pReadRange, ppData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(9)] + public void Unmap(uint Subresource, Range* pWrittenRange) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[9]))((ID3D12Resource*)Unsafe.AsPointer(ref this), Subresource, pWrittenRange); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[9]))((ID3D12Resource*)Unsafe.AsPointer(ref this), Subresource, pWrittenRange); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(10)] + public Graphics.Direct3D12.ResourceDescription GetDesc() + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[10]))((ID3D12Resource*)Unsafe.AsPointer(ref this)); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[10]))((ID3D12Resource*)Unsafe.AsPointer(ref this)); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(11)] + public ulong GetGPUVirtualAddress() + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[11]))((ID3D12Resource*)Unsafe.AsPointer(ref this)); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[11]))((ID3D12Resource*)Unsafe.AsPointer(ref this)); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(12)] + public HResult WriteToSubresource(uint DstSubresource, Box* pDstBox, void* pSrcData, uint SrcRowPitch, uint SrcDepthPitch) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[12]))((ID3D12Resource*)Unsafe.AsPointer(ref this), DstSubresource, pDstBox, pSrcData, SrcRowPitch, SrcDepthPitch); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[12]))((ID3D12Resource*)Unsafe.AsPointer(ref this), DstSubresource, pDstBox, pSrcData, SrcRowPitch, SrcDepthPitch); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(13)] + public HResult ReadFromSubresource(void* pDstData, uint DstRowPitch, uint DstDepthPitch, uint SrcSubresource, Box* pSrcBox) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[13]))((ID3D12Resource*)Unsafe.AsPointer(ref this), pDstData, DstRowPitch, DstDepthPitch, SrcSubresource, pSrcBox); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[13]))((ID3D12Resource*)Unsafe.AsPointer(ref this), pDstData, DstRowPitch, DstDepthPitch, SrcSubresource, pSrcBox); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(14)] + public HResult GetHeapProperties(HeapProperties* pHeapProperties, HeapFlags* pHeapFlags) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[14]))((ID3D12Resource*)Unsafe.AsPointer(ref this), pHeapProperties, pHeapFlags); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[14]))((ID3D12Resource*)Unsafe.AsPointer(ref this), pHeapProperties, pHeapFlags); +#endif + } + + public interface Interface : ID3D12Pageable.Interface + { + } +} + +/// +/// ID3D12CommandAllocator +[Guid("6102dee4-af59-4b09-b999-b44d73f09b24")] +[NativeTypeName("struct ID3D12CommandAllocator : ID3D12Pageable")] +[NativeInheritance("ID3D12Pageable")] +public unsafe partial struct ID3D12CommandAllocator : ID3D12CommandAllocator.Interface +{ + public static ref readonly Guid IID_ID3D12CommandAllocator + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0xE4, 0xDE, 0x02, 0x61, + 0x59, 0xAF, + 0x09, 0x4B, + 0xB9, + 0x99, + 0xB4, + 0x4D, + 0x73, + 0xF0, + 0x9B, + 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_ID3D12CommandAllocator)); + + 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 GetDevice(Guid* riid, void** ppvDevice) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[3]))((ID3D12CommandAllocator*)Unsafe.AsPointer(ref this), riid, ppvDevice); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((ID3D12CommandAllocator*)Unsafe.AsPointer(ref this), riid, ppvDevice); +#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]))((ID3D12CommandAllocator*)Unsafe.AsPointer(ref this), guid, pDataSize, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((ID3D12CommandAllocator*)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]))((ID3D12CommandAllocator*)Unsafe.AsPointer(ref this), guid, DataSize, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((ID3D12CommandAllocator*)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]))((ID3D12CommandAllocator*)Unsafe.AsPointer(ref this), guid, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((ID3D12CommandAllocator*)Unsafe.AsPointer(ref this), guid, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(7)] + public HResult SetName(char** Name) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[7]))((ID3D12CommandAllocator*)Unsafe.AsPointer(ref this), Name); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((ID3D12CommandAllocator*)Unsafe.AsPointer(ref this), Name); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(8)] + public HResult Reset() + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[8]))((ID3D12CommandAllocator*)Unsafe.AsPointer(ref this)); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[8]))((ID3D12CommandAllocator*)Unsafe.AsPointer(ref this)); +#endif + } + + public interface Interface : ID3D12Pageable.Interface + { + } +} + +/// +/// ID3D12Fence +[Guid("0a753dcf-c4d8-4b91-adf6-be5a60d95a76")] +[NativeTypeName("struct ID3D12Fence : ID3D12Pageable")] +[NativeInheritance("ID3D12Pageable")] +public unsafe partial struct ID3D12Fence : ID3D12Fence.Interface +{ + public static ref readonly Guid IID_ID3D12Fence + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0xCF, 0x3D, 0x75, 0x0A, + 0xD8, 0xC4, + 0x91, 0x4B, + 0xAD, + 0xF6, + 0xBE, + 0x5A, + 0x60, + 0xD9, + 0x5A, + 0x76 + }; + + 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_ID3D12Fence)); + + 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 GetDevice(Guid* riid, void** ppvDevice) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[3]))((ID3D12Fence*)Unsafe.AsPointer(ref this), riid, ppvDevice); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((ID3D12Fence*)Unsafe.AsPointer(ref this), riid, ppvDevice); +#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]))((ID3D12Fence*)Unsafe.AsPointer(ref this), guid, pDataSize, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((ID3D12Fence*)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]))((ID3D12Fence*)Unsafe.AsPointer(ref this), guid, DataSize, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((ID3D12Fence*)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]))((ID3D12Fence*)Unsafe.AsPointer(ref this), guid, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((ID3D12Fence*)Unsafe.AsPointer(ref this), guid, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(7)] + public HResult SetName(char** Name) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[7]))((ID3D12Fence*)Unsafe.AsPointer(ref this), Name); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((ID3D12Fence*)Unsafe.AsPointer(ref this), Name); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(8)] + public ulong GetCompletedValue() + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[8]))((ID3D12Fence*)Unsafe.AsPointer(ref this)); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[8]))((ID3D12Fence*)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]))((ID3D12Fence*)Unsafe.AsPointer(ref this), Value, hEvent); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[9]))((ID3D12Fence*)Unsafe.AsPointer(ref this), Value, hEvent); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(10)] + public HResult Signal(ulong Value) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[10]))((ID3D12Fence*)Unsafe.AsPointer(ref this), Value); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[10]))((ID3D12Fence*)Unsafe.AsPointer(ref this), Value); +#endif + } + + public interface Interface : ID3D12Pageable.Interface + { + } +} + +/// +/// ID3D12Fence1 +[Guid("433685fe-e22b-4ca0-a8db-b5b4f4dd0e4a")] +[NativeTypeName("struct ID3D12Fence1 : ID3D12Fence")] +[NativeInheritance("ID3D12Fence")] +public unsafe partial struct ID3D12Fence1 : ID3D12Fence1.Interface +{ + public static ref readonly Guid IID_ID3D12Fence1 + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0xFE, 0x85, 0x36, 0x43, + 0x2B, 0xE2, + 0xA0, 0x4C, + 0xA8, + 0xDB, + 0xB5, + 0xB4, + 0xF4, + 0xDD, + 0x0E, + 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_ID3D12Fence1)); + + 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 ulong GetCompletedValue() + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[3]))((ID3D12Fence1*)Unsafe.AsPointer(ref this)); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((ID3D12Fence1*)Unsafe.AsPointer(ref this)); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public HResult SetEventOnCompletion(ulong Value, IntPtr hEvent) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[4]))((ID3D12Fence1*)Unsafe.AsPointer(ref this), Value, hEvent); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((ID3D12Fence1*)Unsafe.AsPointer(ref this), Value, hEvent); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(5)] + public HResult Signal(ulong Value) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[5]))((ID3D12Fence1*)Unsafe.AsPointer(ref this), Value); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((ID3D12Fence1*)Unsafe.AsPointer(ref this), Value); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(6)] + public HResult GetDevice(Guid* riid, void** ppvDevice) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[6]))((ID3D12Fence1*)Unsafe.AsPointer(ref this), riid, ppvDevice); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((ID3D12Fence1*)Unsafe.AsPointer(ref this), riid, ppvDevice); +#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]))((ID3D12Fence1*)Unsafe.AsPointer(ref this), guid, pDataSize, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((ID3D12Fence1*)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]))((ID3D12Fence1*)Unsafe.AsPointer(ref this), guid, DataSize, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[8]))((ID3D12Fence1*)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]))((ID3D12Fence1*)Unsafe.AsPointer(ref this), guid, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[9]))((ID3D12Fence1*)Unsafe.AsPointer(ref this), guid, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(10)] + public HResult SetName(char** Name) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[10]))((ID3D12Fence1*)Unsafe.AsPointer(ref this), Name); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[10]))((ID3D12Fence1*)Unsafe.AsPointer(ref this), Name); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(11)] + public Graphics.Direct3D12.FenceFlags GetCreationFlags() + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[11]))((ID3D12Fence1*)Unsafe.AsPointer(ref this)); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[11]))((ID3D12Fence1*)Unsafe.AsPointer(ref this)); +#endif + } + + public interface Interface : ID3D12Fence.Interface + { + } +} + +/// +/// ID3D12PipelineState +[Guid("765a30f3-f624-4c6f-a828-ace948622445")] +[NativeTypeName("struct ID3D12PipelineState : ID3D12Pageable")] +[NativeInheritance("ID3D12Pageable")] +public unsafe partial struct ID3D12PipelineState : ID3D12PipelineState.Interface +{ + public static ref readonly Guid IID_ID3D12PipelineState + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0xF3, 0x30, 0x5A, 0x76, + 0x24, 0xF6, + 0x6F, 0x4C, + 0xA8, + 0x28, + 0xAC, + 0xE9, + 0x48, + 0x62, + 0x24, + 0x45 + }; + + 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_ID3D12PipelineState)); + + 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 GetDevice(Guid* riid, void** ppvDevice) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[3]))((ID3D12PipelineState*)Unsafe.AsPointer(ref this), riid, ppvDevice); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((ID3D12PipelineState*)Unsafe.AsPointer(ref this), riid, ppvDevice); +#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]))((ID3D12PipelineState*)Unsafe.AsPointer(ref this), guid, pDataSize, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((ID3D12PipelineState*)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]))((ID3D12PipelineState*)Unsafe.AsPointer(ref this), guid, DataSize, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((ID3D12PipelineState*)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]))((ID3D12PipelineState*)Unsafe.AsPointer(ref this), guid, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((ID3D12PipelineState*)Unsafe.AsPointer(ref this), guid, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(7)] + public HResult SetName(char** Name) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[7]))((ID3D12PipelineState*)Unsafe.AsPointer(ref this), Name); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((ID3D12PipelineState*)Unsafe.AsPointer(ref this), Name); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(8)] + public HResult GetCachedBlob(Graphics.Direct3D.ID3DBlob** ppBlob) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[8]))((ID3D12PipelineState*)Unsafe.AsPointer(ref this), ppBlob); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[8]))((ID3D12PipelineState*)Unsafe.AsPointer(ref this), ppBlob); +#endif + } + + public interface Interface : ID3D12Pageable.Interface + { + } +} + +/// +/// ID3D12DescriptorHeap +[Guid("8efb471d-616c-4f49-90f7-127bb763fa51")] +[NativeTypeName("struct ID3D12DescriptorHeap : ID3D12Pageable")] +[NativeInheritance("ID3D12Pageable")] +public unsafe partial struct ID3D12DescriptorHeap : ID3D12DescriptorHeap.Interface +{ + public static ref readonly Guid IID_ID3D12DescriptorHeap + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x1D, 0x47, 0xFB, 0x8E, + 0x6C, 0x61, + 0x49, 0x4F, + 0x90, + 0xF7, + 0x12, + 0x7B, + 0xB7, + 0x63, + 0xFA, + 0x51 + }; + + 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_ID3D12DescriptorHeap)); + + 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 GetDevice(Guid* riid, void** ppvDevice) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[3]))((ID3D12DescriptorHeap*)Unsafe.AsPointer(ref this), riid, ppvDevice); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((ID3D12DescriptorHeap*)Unsafe.AsPointer(ref this), riid, ppvDevice); +#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]))((ID3D12DescriptorHeap*)Unsafe.AsPointer(ref this), guid, pDataSize, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((ID3D12DescriptorHeap*)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]))((ID3D12DescriptorHeap*)Unsafe.AsPointer(ref this), guid, DataSize, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((ID3D12DescriptorHeap*)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]))((ID3D12DescriptorHeap*)Unsafe.AsPointer(ref this), guid, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((ID3D12DescriptorHeap*)Unsafe.AsPointer(ref this), guid, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(7)] + public HResult SetName(char** Name) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[7]))((ID3D12DescriptorHeap*)Unsafe.AsPointer(ref this), Name); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((ID3D12DescriptorHeap*)Unsafe.AsPointer(ref this), Name); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(8)] + public Graphics.Direct3D12.DescriptorHeapDescription GetDesc() + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[8]))((ID3D12DescriptorHeap*)Unsafe.AsPointer(ref this)); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[8]))((ID3D12DescriptorHeap*)Unsafe.AsPointer(ref this)); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(9)] + public Graphics.Direct3D12.CpuDescriptorHandle GetCPUDescriptorHandleForHeapStart() + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[9]))((ID3D12DescriptorHeap*)Unsafe.AsPointer(ref this)); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[9]))((ID3D12DescriptorHeap*)Unsafe.AsPointer(ref this)); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(10)] + public Graphics.Direct3D12.GpuDescriptorHandle GetGPUDescriptorHandleForHeapStart() + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[10]))((ID3D12DescriptorHeap*)Unsafe.AsPointer(ref this)); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[10]))((ID3D12DescriptorHeap*)Unsafe.AsPointer(ref this)); +#endif + } + + public interface Interface : ID3D12Pageable.Interface + { + } +} + +/// +/// ID3D12QueryHeap +[Guid("0d9658ae-ed45-469e-a61d-970ec583cab4")] +[NativeTypeName("struct ID3D12QueryHeap : ID3D12Pageable")] +[NativeInheritance("ID3D12Pageable")] +public unsafe partial struct ID3D12QueryHeap : ID3D12QueryHeap.Interface +{ + public static ref readonly Guid IID_ID3D12QueryHeap + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0xAE, 0x58, 0x96, 0x0D, + 0x45, 0xED, + 0x9E, 0x46, + 0xA6, + 0x1D, + 0x97, + 0x0E, + 0xC5, + 0x83, + 0xCA, + 0xB4 + }; + + 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_ID3D12QueryHeap)); + + 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 GetDevice(Guid* riid, void** ppvDevice) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[3]))((ID3D12QueryHeap*)Unsafe.AsPointer(ref this), riid, ppvDevice); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((ID3D12QueryHeap*)Unsafe.AsPointer(ref this), riid, ppvDevice); +#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]))((ID3D12QueryHeap*)Unsafe.AsPointer(ref this), guid, pDataSize, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((ID3D12QueryHeap*)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]))((ID3D12QueryHeap*)Unsafe.AsPointer(ref this), guid, DataSize, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((ID3D12QueryHeap*)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]))((ID3D12QueryHeap*)Unsafe.AsPointer(ref this), guid, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((ID3D12QueryHeap*)Unsafe.AsPointer(ref this), guid, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(7)] + public HResult SetName(char** Name) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[7]))((ID3D12QueryHeap*)Unsafe.AsPointer(ref this), Name); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((ID3D12QueryHeap*)Unsafe.AsPointer(ref this), Name); +#endif + } + + public interface Interface : ID3D12Pageable.Interface + { + } +} + +/// +/// ID3D12CommandSignature +[Guid("c36a797c-ec80-4f0a-8985-a7b2475082d1")] +[NativeTypeName("struct ID3D12CommandSignature : ID3D12Pageable")] +[NativeInheritance("ID3D12Pageable")] +public unsafe partial struct ID3D12CommandSignature : ID3D12CommandSignature.Interface +{ + public static ref readonly Guid IID_ID3D12CommandSignature + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x7C, 0x79, 0x6A, 0xC3, + 0x80, 0xEC, + 0x0A, 0x4F, + 0x89, + 0x85, + 0xA7, + 0xB2, + 0x47, + 0x50, + 0x82, + 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_ID3D12CommandSignature)); + + 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 GetDevice(Guid* riid, void** ppvDevice) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[3]))((ID3D12CommandSignature*)Unsafe.AsPointer(ref this), riid, ppvDevice); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((ID3D12CommandSignature*)Unsafe.AsPointer(ref this), riid, ppvDevice); +#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]))((ID3D12CommandSignature*)Unsafe.AsPointer(ref this), guid, pDataSize, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((ID3D12CommandSignature*)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]))((ID3D12CommandSignature*)Unsafe.AsPointer(ref this), guid, DataSize, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((ID3D12CommandSignature*)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]))((ID3D12CommandSignature*)Unsafe.AsPointer(ref this), guid, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((ID3D12CommandSignature*)Unsafe.AsPointer(ref this), guid, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(7)] + public HResult SetName(char** Name) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[7]))((ID3D12CommandSignature*)Unsafe.AsPointer(ref this), Name); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((ID3D12CommandSignature*)Unsafe.AsPointer(ref this), Name); +#endif + } + + public interface Interface : ID3D12Pageable.Interface + { + } +} + +/// +/// ID3D12CommandList +[Guid("7116d91c-e7e4-47ce-b8c6-ec8168f437e5")] +[NativeTypeName("struct ID3D12CommandList : ID3D12DeviceChild")] +[NativeInheritance("ID3D12DeviceChild")] +public unsafe partial struct ID3D12CommandList : ID3D12CommandList.Interface +{ + public static ref readonly Guid IID_ID3D12CommandList + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x1C, 0xD9, 0x16, 0x71, + 0xE4, 0xE7, + 0xCE, 0x47, + 0xB8, + 0xC6, + 0xEC, + 0x81, + 0x68, + 0xF4, + 0x37, + 0xE5 + }; + + 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_ID3D12CommandList)); + + 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 GetDevice(Guid* riid, void** ppvDevice) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[3]))((ID3D12CommandList*)Unsafe.AsPointer(ref this), riid, ppvDevice); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((ID3D12CommandList*)Unsafe.AsPointer(ref this), riid, ppvDevice); +#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]))((ID3D12CommandList*)Unsafe.AsPointer(ref this), guid, pDataSize, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((ID3D12CommandList*)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]))((ID3D12CommandList*)Unsafe.AsPointer(ref this), guid, DataSize, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((ID3D12CommandList*)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]))((ID3D12CommandList*)Unsafe.AsPointer(ref this), guid, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((ID3D12CommandList*)Unsafe.AsPointer(ref this), guid, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(7)] + public HResult SetName(char** Name) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[7]))((ID3D12CommandList*)Unsafe.AsPointer(ref this), Name); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((ID3D12CommandList*)Unsafe.AsPointer(ref this), Name); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(8)] + public new Graphics.Direct3D12.CommandListType GetType() + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[8]))((ID3D12CommandList*)Unsafe.AsPointer(ref this)); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[8]))((ID3D12CommandList*)Unsafe.AsPointer(ref this)); +#endif + } + + public interface Interface : ID3D12DeviceChild.Interface + { + } +} + +/// +/// ID3D12GraphicsCommandList +[Guid("5b160d0f-ac1b-4185-8ba8-b3ae42a5a455")] +[NativeTypeName("struct ID3D12GraphicsCommandList : ID3D12CommandList")] +[NativeInheritance("ID3D12CommandList")] +public unsafe partial struct ID3D12GraphicsCommandList : ID3D12GraphicsCommandList.Interface +{ + public static ref readonly Guid IID_ID3D12GraphicsCommandList + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x0F, 0x0D, 0x16, 0x5B, + 0x1B, 0xAC, + 0x85, 0x41, + 0x8B, + 0xA8, + 0xB3, + 0xAE, + 0x42, + 0xA5, + 0xA4, + 0x55 + }; + + 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_ID3D12GraphicsCommandList)); + + 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 new Graphics.Direct3D12.CommandListType GetType() + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[3]))((ID3D12GraphicsCommandList*)Unsafe.AsPointer(ref this)); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((ID3D12GraphicsCommandList*)Unsafe.AsPointer(ref this)); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public HResult GetDevice(Guid* riid, void** ppvDevice) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[4]))((ID3D12GraphicsCommandList*)Unsafe.AsPointer(ref this), riid, ppvDevice); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((ID3D12GraphicsCommandList*)Unsafe.AsPointer(ref this), riid, ppvDevice); +#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]))((ID3D12GraphicsCommandList*)Unsafe.AsPointer(ref this), guid, pDataSize, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((ID3D12GraphicsCommandList*)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]))((ID3D12GraphicsCommandList*)Unsafe.AsPointer(ref this), guid, DataSize, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((ID3D12GraphicsCommandList*)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]))((ID3D12GraphicsCommandList*)Unsafe.AsPointer(ref this), guid, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((ID3D12GraphicsCommandList*)Unsafe.AsPointer(ref this), guid, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(8)] + public HResult SetName(char** Name) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[8]))((ID3D12GraphicsCommandList*)Unsafe.AsPointer(ref this), Name); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[8]))((ID3D12GraphicsCommandList*)Unsafe.AsPointer(ref this), Name); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(9)] + public HResult Close() + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[9]))((ID3D12GraphicsCommandList*)Unsafe.AsPointer(ref this)); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[9]))((ID3D12GraphicsCommandList*)Unsafe.AsPointer(ref this)); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(10)] + public HResult Reset(ID3D12CommandAllocator* pAllocator, ID3D12PipelineState* pInitialState) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[10]))((ID3D12GraphicsCommandList*)Unsafe.AsPointer(ref this), pAllocator, pInitialState); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[10]))((ID3D12GraphicsCommandList*)Unsafe.AsPointer(ref this), pAllocator, pInitialState); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(11)] + public void ClearState(ID3D12PipelineState* pPipelineState) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[11]))((ID3D12GraphicsCommandList*)Unsafe.AsPointer(ref this), pPipelineState); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[11]))((ID3D12GraphicsCommandList*)Unsafe.AsPointer(ref this), pPipelineState); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(12)] + public void DrawInstanced(uint VertexCountPerInstance, uint InstanceCount, uint StartVertexLocation, uint StartInstanceLocation) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[12]))((ID3D12GraphicsCommandList*)Unsafe.AsPointer(ref this), VertexCountPerInstance, InstanceCount, StartVertexLocation, StartInstanceLocation); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[12]))((ID3D12GraphicsCommandList*)Unsafe.AsPointer(ref this), VertexCountPerInstance, InstanceCount, StartVertexLocation, StartInstanceLocation); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(13)] + public void DrawIndexedInstanced(uint IndexCountPerInstance, uint InstanceCount, uint StartIndexLocation, int BaseVertexLocation, uint StartInstanceLocation) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[13]))((ID3D12GraphicsCommandList*)Unsafe.AsPointer(ref this), IndexCountPerInstance, InstanceCount, StartIndexLocation, BaseVertexLocation, StartInstanceLocation); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[13]))((ID3D12GraphicsCommandList*)Unsafe.AsPointer(ref this), IndexCountPerInstance, InstanceCount, StartIndexLocation, BaseVertexLocation, StartInstanceLocation); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(14)] + public void Dispatch(uint ThreadGroupCountX, uint ThreadGroupCountY, uint ThreadGroupCountZ) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[14]))((ID3D12GraphicsCommandList*)Unsafe.AsPointer(ref this), ThreadGroupCountX, ThreadGroupCountY, ThreadGroupCountZ); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[14]))((ID3D12GraphicsCommandList*)Unsafe.AsPointer(ref this), ThreadGroupCountX, ThreadGroupCountY, ThreadGroupCountZ); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(15)] + public void CopyBufferRegion(ID3D12Resource* pDstBuffer, ulong DstOffset, ID3D12Resource* pSrcBuffer, ulong SrcOffset, ulong NumBytes) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[15]))((ID3D12GraphicsCommandList*)Unsafe.AsPointer(ref this), pDstBuffer, DstOffset, pSrcBuffer, SrcOffset, NumBytes); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[15]))((ID3D12GraphicsCommandList*)Unsafe.AsPointer(ref this), pDstBuffer, DstOffset, pSrcBuffer, SrcOffset, NumBytes); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(16)] + public void CopyTextureRegion(TextureCopyLocation* pDst, uint DstX, uint DstY, uint DstZ, TextureCopyLocation* pSrc, Box* pSrcBox) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[16]))((ID3D12GraphicsCommandList*)Unsafe.AsPointer(ref this), pDst, DstX, DstY, DstZ, pSrc, pSrcBox); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[16]))((ID3D12GraphicsCommandList*)Unsafe.AsPointer(ref this), pDst, DstX, DstY, DstZ, pSrc, pSrcBox); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(17)] + public void CopyResource(ID3D12Resource* pDstResource, ID3D12Resource* pSrcResource) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[17]))((ID3D12GraphicsCommandList*)Unsafe.AsPointer(ref this), pDstResource, pSrcResource); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[17]))((ID3D12GraphicsCommandList*)Unsafe.AsPointer(ref this), pDstResource, pSrcResource); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(18)] + public void CopyTiles(ID3D12Resource* pTiledResource, TiledResourceCoordinate* pTileRegionStartCoordinate, TileRegionSize* pTileRegionSize, ID3D12Resource* pBuffer, ulong BufferStartOffsetInBytes, TileCopyFlags Flags) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[18]))((ID3D12GraphicsCommandList*)Unsafe.AsPointer(ref this), pTiledResource, pTileRegionStartCoordinate, pTileRegionSize, pBuffer, BufferStartOffsetInBytes, Flags); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[18]))((ID3D12GraphicsCommandList*)Unsafe.AsPointer(ref this), pTiledResource, pTileRegionStartCoordinate, pTileRegionSize, pBuffer, BufferStartOffsetInBytes, Flags); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(19)] + public void ResolveSubresource(ID3D12Resource* pDstResource, uint DstSubresource, ID3D12Resource* pSrcResource, uint SrcSubresource, Graphics.Dxgi.Common.Format Format) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[19]))((ID3D12GraphicsCommandList*)Unsafe.AsPointer(ref this), pDstResource, DstSubresource, pSrcResource, SrcSubresource, Format); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[19]))((ID3D12GraphicsCommandList*)Unsafe.AsPointer(ref this), pDstResource, DstSubresource, pSrcResource, SrcSubresource, Format); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(20)] + public void IASetPrimitiveTopology(Graphics.Direct3D.PrimitiveTopology PrimitiveTopology) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[20]))((ID3D12GraphicsCommandList*)Unsafe.AsPointer(ref this), PrimitiveTopology); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[20]))((ID3D12GraphicsCommandList*)Unsafe.AsPointer(ref this), PrimitiveTopology); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(21)] + public void RSSetViewports(uint NumViewports, Viewport* pViewports) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[21]))((ID3D12GraphicsCommandList*)Unsafe.AsPointer(ref this), NumViewports, pViewports); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[21]))((ID3D12GraphicsCommandList*)Unsafe.AsPointer(ref this), NumViewports, pViewports); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(22)] + public void RSSetScissorRects(uint NumRects, RawRect* pRects) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[22]))((ID3D12GraphicsCommandList*)Unsafe.AsPointer(ref this), NumRects, pRects); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[22]))((ID3D12GraphicsCommandList*)Unsafe.AsPointer(ref this), NumRects, pRects); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(23)] + public void OMSetBlendFactor(float* BlendFactor) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[23]))((ID3D12GraphicsCommandList*)Unsafe.AsPointer(ref this), BlendFactor); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[23]))((ID3D12GraphicsCommandList*)Unsafe.AsPointer(ref this), BlendFactor); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(24)] + public void OMSetStencilRef(uint StencilRef) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[24]))((ID3D12GraphicsCommandList*)Unsafe.AsPointer(ref this), StencilRef); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[24]))((ID3D12GraphicsCommandList*)Unsafe.AsPointer(ref this), StencilRef); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(25)] + public void SetPipelineState(ID3D12PipelineState* pPipelineState) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[25]))((ID3D12GraphicsCommandList*)Unsafe.AsPointer(ref this), pPipelineState); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[25]))((ID3D12GraphicsCommandList*)Unsafe.AsPointer(ref this), pPipelineState); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(26)] + public void ResourceBarrier(uint NumBarriers, ResourceBarrier* pBarriers) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[26]))((ID3D12GraphicsCommandList*)Unsafe.AsPointer(ref this), NumBarriers, pBarriers); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[26]))((ID3D12GraphicsCommandList*)Unsafe.AsPointer(ref this), NumBarriers, pBarriers); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(27)] + public void ExecuteBundle(ID3D12GraphicsCommandList* pCommandList) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[27]))((ID3D12GraphicsCommandList*)Unsafe.AsPointer(ref this), pCommandList); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[27]))((ID3D12GraphicsCommandList*)Unsafe.AsPointer(ref this), pCommandList); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(28)] + public void SetDescriptorHeaps(uint NumDescriptorHeaps, ID3D12DescriptorHeap* ppDescriptorHeaps) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[28]))((ID3D12GraphicsCommandList*)Unsafe.AsPointer(ref this), NumDescriptorHeaps, ppDescriptorHeaps); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[28]))((ID3D12GraphicsCommandList*)Unsafe.AsPointer(ref this), NumDescriptorHeaps, ppDescriptorHeaps); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(29)] + public void SetComputeRootSignature(ID3D12RootSignature* pRootSignature) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[29]))((ID3D12GraphicsCommandList*)Unsafe.AsPointer(ref this), pRootSignature); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[29]))((ID3D12GraphicsCommandList*)Unsafe.AsPointer(ref this), pRootSignature); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(30)] + public void SetGraphicsRootSignature(ID3D12RootSignature* pRootSignature) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[30]))((ID3D12GraphicsCommandList*)Unsafe.AsPointer(ref this), pRootSignature); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[30]))((ID3D12GraphicsCommandList*)Unsafe.AsPointer(ref this), pRootSignature); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(31)] + public void SetComputeRootDescriptorTable(uint RootParameterIndex, GpuDescriptorHandle* BaseDescriptor) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[31]))((ID3D12GraphicsCommandList*)Unsafe.AsPointer(ref this), RootParameterIndex, BaseDescriptor); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[31]))((ID3D12GraphicsCommandList*)Unsafe.AsPointer(ref this), RootParameterIndex, BaseDescriptor); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(32)] + public void SetGraphicsRootDescriptorTable(uint RootParameterIndex, GpuDescriptorHandle* BaseDescriptor) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[32]))((ID3D12GraphicsCommandList*)Unsafe.AsPointer(ref this), RootParameterIndex, BaseDescriptor); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[32]))((ID3D12GraphicsCommandList*)Unsafe.AsPointer(ref this), RootParameterIndex, BaseDescriptor); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(33)] + public void SetComputeRoot32BitConstant(uint RootParameterIndex, uint SrcData, uint DestOffsetIn32BitValues) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[33]))((ID3D12GraphicsCommandList*)Unsafe.AsPointer(ref this), RootParameterIndex, SrcData, DestOffsetIn32BitValues); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[33]))((ID3D12GraphicsCommandList*)Unsafe.AsPointer(ref this), RootParameterIndex, SrcData, DestOffsetIn32BitValues); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(34)] + public void SetGraphicsRoot32BitConstant(uint RootParameterIndex, uint SrcData, uint DestOffsetIn32BitValues) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[34]))((ID3D12GraphicsCommandList*)Unsafe.AsPointer(ref this), RootParameterIndex, SrcData, DestOffsetIn32BitValues); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[34]))((ID3D12GraphicsCommandList*)Unsafe.AsPointer(ref this), RootParameterIndex, SrcData, DestOffsetIn32BitValues); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(35)] + public void SetComputeRoot32BitConstants(uint RootParameterIndex, uint Num32BitValuesToSet, void* pSrcData, uint DestOffsetIn32BitValues) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[35]))((ID3D12GraphicsCommandList*)Unsafe.AsPointer(ref this), RootParameterIndex, Num32BitValuesToSet, pSrcData, DestOffsetIn32BitValues); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[35]))((ID3D12GraphicsCommandList*)Unsafe.AsPointer(ref this), RootParameterIndex, Num32BitValuesToSet, pSrcData, DestOffsetIn32BitValues); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(36)] + public void SetGraphicsRoot32BitConstants(uint RootParameterIndex, uint Num32BitValuesToSet, void* pSrcData, uint DestOffsetIn32BitValues) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[36]))((ID3D12GraphicsCommandList*)Unsafe.AsPointer(ref this), RootParameterIndex, Num32BitValuesToSet, pSrcData, DestOffsetIn32BitValues); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[36]))((ID3D12GraphicsCommandList*)Unsafe.AsPointer(ref this), RootParameterIndex, Num32BitValuesToSet, pSrcData, DestOffsetIn32BitValues); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(37)] + public void SetComputeRootConstantBufferView(uint RootParameterIndex, ulong BufferLocation) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[37]))((ID3D12GraphicsCommandList*)Unsafe.AsPointer(ref this), RootParameterIndex, BufferLocation); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[37]))((ID3D12GraphicsCommandList*)Unsafe.AsPointer(ref this), RootParameterIndex, BufferLocation); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(38)] + public void SetGraphicsRootConstantBufferView(uint RootParameterIndex, ulong BufferLocation) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[38]))((ID3D12GraphicsCommandList*)Unsafe.AsPointer(ref this), RootParameterIndex, BufferLocation); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[38]))((ID3D12GraphicsCommandList*)Unsafe.AsPointer(ref this), RootParameterIndex, BufferLocation); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(39)] + public void SetComputeRootShaderResourceView(uint RootParameterIndex, ulong BufferLocation) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[39]))((ID3D12GraphicsCommandList*)Unsafe.AsPointer(ref this), RootParameterIndex, BufferLocation); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[39]))((ID3D12GraphicsCommandList*)Unsafe.AsPointer(ref this), RootParameterIndex, BufferLocation); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(40)] + public void SetGraphicsRootShaderResourceView(uint RootParameterIndex, ulong BufferLocation) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[40]))((ID3D12GraphicsCommandList*)Unsafe.AsPointer(ref this), RootParameterIndex, BufferLocation); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[40]))((ID3D12GraphicsCommandList*)Unsafe.AsPointer(ref this), RootParameterIndex, BufferLocation); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(41)] + public void SetComputeRootUnorderedAccessView(uint RootParameterIndex, ulong BufferLocation) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[41]))((ID3D12GraphicsCommandList*)Unsafe.AsPointer(ref this), RootParameterIndex, BufferLocation); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[41]))((ID3D12GraphicsCommandList*)Unsafe.AsPointer(ref this), RootParameterIndex, BufferLocation); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(42)] + public void SetGraphicsRootUnorderedAccessView(uint RootParameterIndex, ulong BufferLocation) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[42]))((ID3D12GraphicsCommandList*)Unsafe.AsPointer(ref this), RootParameterIndex, BufferLocation); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[42]))((ID3D12GraphicsCommandList*)Unsafe.AsPointer(ref this), RootParameterIndex, BufferLocation); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(43)] + public void IASetIndexBuffer(IndexBufferView* pView) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[43]))((ID3D12GraphicsCommandList*)Unsafe.AsPointer(ref this), pView); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[43]))((ID3D12GraphicsCommandList*)Unsafe.AsPointer(ref this), pView); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(44)] + public void IASetVertexBuffers(uint StartSlot, uint NumViews, VertexBufferView* pViews) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[44]))((ID3D12GraphicsCommandList*)Unsafe.AsPointer(ref this), StartSlot, NumViews, pViews); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[44]))((ID3D12GraphicsCommandList*)Unsafe.AsPointer(ref this), StartSlot, NumViews, pViews); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(45)] + public void SOSetTargets(uint StartSlot, uint NumViews, StreamOutputBufferView* pViews) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[45]))((ID3D12GraphicsCommandList*)Unsafe.AsPointer(ref this), StartSlot, NumViews, pViews); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[45]))((ID3D12GraphicsCommandList*)Unsafe.AsPointer(ref this), StartSlot, NumViews, pViews); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(46)] + public void OMSetRenderTargets(uint NumRenderTargetDescriptors, CpuDescriptorHandle* pRenderTargetDescriptors, Bool32 RTsSingleHandleToDescriptorRange, CpuDescriptorHandle* pDepthStencilDescriptor) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[46]))((ID3D12GraphicsCommandList*)Unsafe.AsPointer(ref this), NumRenderTargetDescriptors, pRenderTargetDescriptors, RTsSingleHandleToDescriptorRange, pDepthStencilDescriptor); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[46]))((ID3D12GraphicsCommandList*)Unsafe.AsPointer(ref this), NumRenderTargetDescriptors, pRenderTargetDescriptors, RTsSingleHandleToDescriptorRange, pDepthStencilDescriptor); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(47)] + public void ClearDepthStencilView(CpuDescriptorHandle* DepthStencilView, ClearFlags ClearFlags, float Depth, byte Stencil, uint NumRects, RawRect* pRects) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[47]))((ID3D12GraphicsCommandList*)Unsafe.AsPointer(ref this), DepthStencilView, ClearFlags, Depth, Stencil, NumRects, pRects); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[47]))((ID3D12GraphicsCommandList*)Unsafe.AsPointer(ref this), DepthStencilView, ClearFlags, Depth, Stencil, NumRects, pRects); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(48)] + public void ClearRenderTargetView(CpuDescriptorHandle* RenderTargetView, float* ColorRGBA, uint NumRects, RawRect* pRects) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[48]))((ID3D12GraphicsCommandList*)Unsafe.AsPointer(ref this), RenderTargetView, ColorRGBA, NumRects, pRects); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[48]))((ID3D12GraphicsCommandList*)Unsafe.AsPointer(ref this), RenderTargetView, ColorRGBA, NumRects, pRects); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(49)] + public void ClearUnorderedAccessViewUint(GpuDescriptorHandle* ViewGPUHandleInCurrentHeap, CpuDescriptorHandle* ViewCPUHandle, ID3D12Resource* pResource, uint* Values, uint NumRects, RawRect* pRects) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[49]))((ID3D12GraphicsCommandList*)Unsafe.AsPointer(ref this), ViewGPUHandleInCurrentHeap, ViewCPUHandle, pResource, Values, NumRects, pRects); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[49]))((ID3D12GraphicsCommandList*)Unsafe.AsPointer(ref this), ViewGPUHandleInCurrentHeap, ViewCPUHandle, pResource, Values, NumRects, pRects); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(50)] + public void ClearUnorderedAccessViewFloat(GpuDescriptorHandle* ViewGPUHandleInCurrentHeap, CpuDescriptorHandle* ViewCPUHandle, ID3D12Resource* pResource, float* Values, uint NumRects, RawRect* pRects) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[50]))((ID3D12GraphicsCommandList*)Unsafe.AsPointer(ref this), ViewGPUHandleInCurrentHeap, ViewCPUHandle, pResource, Values, NumRects, pRects); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[50]))((ID3D12GraphicsCommandList*)Unsafe.AsPointer(ref this), ViewGPUHandleInCurrentHeap, ViewCPUHandle, pResource, Values, NumRects, pRects); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(51)] + public void DiscardResource(ID3D12Resource* pResource, DiscardRegion* pRegion) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[51]))((ID3D12GraphicsCommandList*)Unsafe.AsPointer(ref this), pResource, pRegion); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[51]))((ID3D12GraphicsCommandList*)Unsafe.AsPointer(ref this), pResource, pRegion); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(52)] + public void BeginQuery(ID3D12QueryHeap* pQueryHeap, QueryType Type, uint Index) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[52]))((ID3D12GraphicsCommandList*)Unsafe.AsPointer(ref this), pQueryHeap, Type, Index); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[52]))((ID3D12GraphicsCommandList*)Unsafe.AsPointer(ref this), pQueryHeap, Type, Index); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(53)] + public void EndQuery(ID3D12QueryHeap* pQueryHeap, QueryType Type, uint Index) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[53]))((ID3D12GraphicsCommandList*)Unsafe.AsPointer(ref this), pQueryHeap, Type, Index); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[53]))((ID3D12GraphicsCommandList*)Unsafe.AsPointer(ref this), pQueryHeap, Type, Index); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(54)] + public void ResolveQueryData(ID3D12QueryHeap* pQueryHeap, QueryType Type, uint StartIndex, uint NumQueries, ID3D12Resource* pDestinationBuffer, ulong AlignedDestinationBufferOffset) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[54]))((ID3D12GraphicsCommandList*)Unsafe.AsPointer(ref this), pQueryHeap, Type, StartIndex, NumQueries, pDestinationBuffer, AlignedDestinationBufferOffset); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[54]))((ID3D12GraphicsCommandList*)Unsafe.AsPointer(ref this), pQueryHeap, Type, StartIndex, NumQueries, pDestinationBuffer, AlignedDestinationBufferOffset); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(55)] + public void SetPredication(ID3D12Resource* pBuffer, ulong AlignedBufferOffset, PredicationOp Operation) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[55]))((ID3D12GraphicsCommandList*)Unsafe.AsPointer(ref this), pBuffer, AlignedBufferOffset, Operation); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[55]))((ID3D12GraphicsCommandList*)Unsafe.AsPointer(ref this), pBuffer, AlignedBufferOffset, Operation); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(56)] + public void SetMarker(uint Metadata, void* pData, uint Size) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[56]))((ID3D12GraphicsCommandList*)Unsafe.AsPointer(ref this), Metadata, pData, Size); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[56]))((ID3D12GraphicsCommandList*)Unsafe.AsPointer(ref this), Metadata, pData, Size); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(57)] + public void BeginEvent(uint Metadata, void* pData, uint Size) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[57]))((ID3D12GraphicsCommandList*)Unsafe.AsPointer(ref this), Metadata, pData, Size); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[57]))((ID3D12GraphicsCommandList*)Unsafe.AsPointer(ref this), Metadata, pData, Size); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(58)] + public void EndEvent() + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[58]))((ID3D12GraphicsCommandList*)Unsafe.AsPointer(ref this)); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[58]))((ID3D12GraphicsCommandList*)Unsafe.AsPointer(ref this)); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(59)] + public void ExecuteIndirect(ID3D12CommandSignature* pCommandSignature, uint MaxCommandCount, ID3D12Resource* pArgumentBuffer, ulong ArgumentBufferOffset, ID3D12Resource* pCountBuffer, ulong CountBufferOffset) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[59]))((ID3D12GraphicsCommandList*)Unsafe.AsPointer(ref this), pCommandSignature, MaxCommandCount, pArgumentBuffer, ArgumentBufferOffset, pCountBuffer, CountBufferOffset); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[59]))((ID3D12GraphicsCommandList*)Unsafe.AsPointer(ref this), pCommandSignature, MaxCommandCount, pArgumentBuffer, ArgumentBufferOffset, pCountBuffer, CountBufferOffset); +#endif + } + + public interface Interface : ID3D12CommandList.Interface + { + } +} + +/// +/// ID3D12GraphicsCommandList1 +[Guid("553103fb-1fe7-4557-bb38-946d7d0e7ca7")] +[NativeTypeName("struct ID3D12GraphicsCommandList1 : ID3D12GraphicsCommandList")] +[NativeInheritance("ID3D12GraphicsCommandList")] +public unsafe partial struct ID3D12GraphicsCommandList1 : ID3D12GraphicsCommandList1.Interface +{ + public static ref readonly Guid IID_ID3D12GraphicsCommandList1 + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0xFB, 0x03, 0x31, 0x55, + 0xE7, 0x1F, + 0x57, 0x45, + 0xBB, + 0x38, + 0x94, + 0x6D, + 0x7D, + 0x0E, + 0x7C, + 0xA7 + }; + + 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_ID3D12GraphicsCommandList1)); + + 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 Close() + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[3]))((ID3D12GraphicsCommandList1*)Unsafe.AsPointer(ref this)); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((ID3D12GraphicsCommandList1*)Unsafe.AsPointer(ref this)); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public HResult Reset(ID3D12CommandAllocator* pAllocator, ID3D12PipelineState* pInitialState) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[4]))((ID3D12GraphicsCommandList1*)Unsafe.AsPointer(ref this), pAllocator, pInitialState); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((ID3D12GraphicsCommandList1*)Unsafe.AsPointer(ref this), pAllocator, pInitialState); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(5)] + public void ClearState(ID3D12PipelineState* pPipelineState) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[5]))((ID3D12GraphicsCommandList1*)Unsafe.AsPointer(ref this), pPipelineState); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((ID3D12GraphicsCommandList1*)Unsafe.AsPointer(ref this), pPipelineState); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(6)] + public void DrawInstanced(uint VertexCountPerInstance, uint InstanceCount, uint StartVertexLocation, uint StartInstanceLocation) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[6]))((ID3D12GraphicsCommandList1*)Unsafe.AsPointer(ref this), VertexCountPerInstance, InstanceCount, StartVertexLocation, StartInstanceLocation); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((ID3D12GraphicsCommandList1*)Unsafe.AsPointer(ref this), VertexCountPerInstance, InstanceCount, StartVertexLocation, StartInstanceLocation); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(7)] + public void DrawIndexedInstanced(uint IndexCountPerInstance, uint InstanceCount, uint StartIndexLocation, int BaseVertexLocation, uint StartInstanceLocation) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[7]))((ID3D12GraphicsCommandList1*)Unsafe.AsPointer(ref this), IndexCountPerInstance, InstanceCount, StartIndexLocation, BaseVertexLocation, StartInstanceLocation); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((ID3D12GraphicsCommandList1*)Unsafe.AsPointer(ref this), IndexCountPerInstance, InstanceCount, StartIndexLocation, BaseVertexLocation, StartInstanceLocation); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(8)] + public void Dispatch(uint ThreadGroupCountX, uint ThreadGroupCountY, uint ThreadGroupCountZ) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[8]))((ID3D12GraphicsCommandList1*)Unsafe.AsPointer(ref this), ThreadGroupCountX, ThreadGroupCountY, ThreadGroupCountZ); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[8]))((ID3D12GraphicsCommandList1*)Unsafe.AsPointer(ref this), ThreadGroupCountX, ThreadGroupCountY, ThreadGroupCountZ); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(9)] + public void CopyBufferRegion(ID3D12Resource* pDstBuffer, ulong DstOffset, ID3D12Resource* pSrcBuffer, ulong SrcOffset, ulong NumBytes) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[9]))((ID3D12GraphicsCommandList1*)Unsafe.AsPointer(ref this), pDstBuffer, DstOffset, pSrcBuffer, SrcOffset, NumBytes); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[9]))((ID3D12GraphicsCommandList1*)Unsafe.AsPointer(ref this), pDstBuffer, DstOffset, pSrcBuffer, SrcOffset, NumBytes); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(10)] + public void CopyTextureRegion(TextureCopyLocation* pDst, uint DstX, uint DstY, uint DstZ, TextureCopyLocation* pSrc, Box* pSrcBox) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[10]))((ID3D12GraphicsCommandList1*)Unsafe.AsPointer(ref this), pDst, DstX, DstY, DstZ, pSrc, pSrcBox); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[10]))((ID3D12GraphicsCommandList1*)Unsafe.AsPointer(ref this), pDst, DstX, DstY, DstZ, pSrc, pSrcBox); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(11)] + public void CopyResource(ID3D12Resource* pDstResource, ID3D12Resource* pSrcResource) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[11]))((ID3D12GraphicsCommandList1*)Unsafe.AsPointer(ref this), pDstResource, pSrcResource); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[11]))((ID3D12GraphicsCommandList1*)Unsafe.AsPointer(ref this), pDstResource, pSrcResource); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(12)] + public void CopyTiles(ID3D12Resource* pTiledResource, TiledResourceCoordinate* pTileRegionStartCoordinate, TileRegionSize* pTileRegionSize, ID3D12Resource* pBuffer, ulong BufferStartOffsetInBytes, TileCopyFlags Flags) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[12]))((ID3D12GraphicsCommandList1*)Unsafe.AsPointer(ref this), pTiledResource, pTileRegionStartCoordinate, pTileRegionSize, pBuffer, BufferStartOffsetInBytes, Flags); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[12]))((ID3D12GraphicsCommandList1*)Unsafe.AsPointer(ref this), pTiledResource, pTileRegionStartCoordinate, pTileRegionSize, pBuffer, BufferStartOffsetInBytes, Flags); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(13)] + public void ResolveSubresource(ID3D12Resource* pDstResource, uint DstSubresource, ID3D12Resource* pSrcResource, uint SrcSubresource, Graphics.Dxgi.Common.Format Format) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[13]))((ID3D12GraphicsCommandList1*)Unsafe.AsPointer(ref this), pDstResource, DstSubresource, pSrcResource, SrcSubresource, Format); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[13]))((ID3D12GraphicsCommandList1*)Unsafe.AsPointer(ref this), pDstResource, DstSubresource, pSrcResource, SrcSubresource, Format); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(14)] + public void IASetPrimitiveTopology(Graphics.Direct3D.PrimitiveTopology PrimitiveTopology) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[14]))((ID3D12GraphicsCommandList1*)Unsafe.AsPointer(ref this), PrimitiveTopology); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[14]))((ID3D12GraphicsCommandList1*)Unsafe.AsPointer(ref this), PrimitiveTopology); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(15)] + public void RSSetViewports(uint NumViewports, Viewport* pViewports) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[15]))((ID3D12GraphicsCommandList1*)Unsafe.AsPointer(ref this), NumViewports, pViewports); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[15]))((ID3D12GraphicsCommandList1*)Unsafe.AsPointer(ref this), NumViewports, pViewports); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(16)] + public void RSSetScissorRects(uint NumRects, RawRect* pRects) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[16]))((ID3D12GraphicsCommandList1*)Unsafe.AsPointer(ref this), NumRects, pRects); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[16]))((ID3D12GraphicsCommandList1*)Unsafe.AsPointer(ref this), NumRects, pRects); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(17)] + public void OMSetBlendFactor(float* BlendFactor) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[17]))((ID3D12GraphicsCommandList1*)Unsafe.AsPointer(ref this), BlendFactor); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[17]))((ID3D12GraphicsCommandList1*)Unsafe.AsPointer(ref this), BlendFactor); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(18)] + public void OMSetStencilRef(uint StencilRef) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[18]))((ID3D12GraphicsCommandList1*)Unsafe.AsPointer(ref this), StencilRef); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[18]))((ID3D12GraphicsCommandList1*)Unsafe.AsPointer(ref this), StencilRef); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(19)] + public void SetPipelineState(ID3D12PipelineState* pPipelineState) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[19]))((ID3D12GraphicsCommandList1*)Unsafe.AsPointer(ref this), pPipelineState); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[19]))((ID3D12GraphicsCommandList1*)Unsafe.AsPointer(ref this), pPipelineState); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(20)] + public void ResourceBarrier(uint NumBarriers, ResourceBarrier* pBarriers) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[20]))((ID3D12GraphicsCommandList1*)Unsafe.AsPointer(ref this), NumBarriers, pBarriers); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[20]))((ID3D12GraphicsCommandList1*)Unsafe.AsPointer(ref this), NumBarriers, pBarriers); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(21)] + public void ExecuteBundle(ID3D12GraphicsCommandList* pCommandList) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[21]))((ID3D12GraphicsCommandList1*)Unsafe.AsPointer(ref this), pCommandList); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[21]))((ID3D12GraphicsCommandList1*)Unsafe.AsPointer(ref this), pCommandList); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(22)] + public void SetDescriptorHeaps(uint NumDescriptorHeaps, ID3D12DescriptorHeap* ppDescriptorHeaps) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[22]))((ID3D12GraphicsCommandList1*)Unsafe.AsPointer(ref this), NumDescriptorHeaps, ppDescriptorHeaps); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[22]))((ID3D12GraphicsCommandList1*)Unsafe.AsPointer(ref this), NumDescriptorHeaps, ppDescriptorHeaps); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(23)] + public void SetComputeRootSignature(ID3D12RootSignature* pRootSignature) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[23]))((ID3D12GraphicsCommandList1*)Unsafe.AsPointer(ref this), pRootSignature); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[23]))((ID3D12GraphicsCommandList1*)Unsafe.AsPointer(ref this), pRootSignature); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(24)] + public void SetGraphicsRootSignature(ID3D12RootSignature* pRootSignature) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[24]))((ID3D12GraphicsCommandList1*)Unsafe.AsPointer(ref this), pRootSignature); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[24]))((ID3D12GraphicsCommandList1*)Unsafe.AsPointer(ref this), pRootSignature); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(25)] + public void SetComputeRootDescriptorTable(uint RootParameterIndex, GpuDescriptorHandle* BaseDescriptor) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[25]))((ID3D12GraphicsCommandList1*)Unsafe.AsPointer(ref this), RootParameterIndex, BaseDescriptor); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[25]))((ID3D12GraphicsCommandList1*)Unsafe.AsPointer(ref this), RootParameterIndex, BaseDescriptor); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(26)] + public void SetGraphicsRootDescriptorTable(uint RootParameterIndex, GpuDescriptorHandle* BaseDescriptor) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[26]))((ID3D12GraphicsCommandList1*)Unsafe.AsPointer(ref this), RootParameterIndex, BaseDescriptor); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[26]))((ID3D12GraphicsCommandList1*)Unsafe.AsPointer(ref this), RootParameterIndex, BaseDescriptor); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(27)] + public void SetComputeRoot32BitConstant(uint RootParameterIndex, uint SrcData, uint DestOffsetIn32BitValues) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[27]))((ID3D12GraphicsCommandList1*)Unsafe.AsPointer(ref this), RootParameterIndex, SrcData, DestOffsetIn32BitValues); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[27]))((ID3D12GraphicsCommandList1*)Unsafe.AsPointer(ref this), RootParameterIndex, SrcData, DestOffsetIn32BitValues); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(28)] + public void SetGraphicsRoot32BitConstant(uint RootParameterIndex, uint SrcData, uint DestOffsetIn32BitValues) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[28]))((ID3D12GraphicsCommandList1*)Unsafe.AsPointer(ref this), RootParameterIndex, SrcData, DestOffsetIn32BitValues); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[28]))((ID3D12GraphicsCommandList1*)Unsafe.AsPointer(ref this), RootParameterIndex, SrcData, DestOffsetIn32BitValues); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(29)] + public void SetComputeRoot32BitConstants(uint RootParameterIndex, uint Num32BitValuesToSet, void* pSrcData, uint DestOffsetIn32BitValues) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[29]))((ID3D12GraphicsCommandList1*)Unsafe.AsPointer(ref this), RootParameterIndex, Num32BitValuesToSet, pSrcData, DestOffsetIn32BitValues); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[29]))((ID3D12GraphicsCommandList1*)Unsafe.AsPointer(ref this), RootParameterIndex, Num32BitValuesToSet, pSrcData, DestOffsetIn32BitValues); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(30)] + public void SetGraphicsRoot32BitConstants(uint RootParameterIndex, uint Num32BitValuesToSet, void* pSrcData, uint DestOffsetIn32BitValues) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[30]))((ID3D12GraphicsCommandList1*)Unsafe.AsPointer(ref this), RootParameterIndex, Num32BitValuesToSet, pSrcData, DestOffsetIn32BitValues); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[30]))((ID3D12GraphicsCommandList1*)Unsafe.AsPointer(ref this), RootParameterIndex, Num32BitValuesToSet, pSrcData, DestOffsetIn32BitValues); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(31)] + public void SetComputeRootConstantBufferView(uint RootParameterIndex, ulong BufferLocation) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[31]))((ID3D12GraphicsCommandList1*)Unsafe.AsPointer(ref this), RootParameterIndex, BufferLocation); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[31]))((ID3D12GraphicsCommandList1*)Unsafe.AsPointer(ref this), RootParameterIndex, BufferLocation); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(32)] + public void SetGraphicsRootConstantBufferView(uint RootParameterIndex, ulong BufferLocation) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[32]))((ID3D12GraphicsCommandList1*)Unsafe.AsPointer(ref this), RootParameterIndex, BufferLocation); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[32]))((ID3D12GraphicsCommandList1*)Unsafe.AsPointer(ref this), RootParameterIndex, BufferLocation); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(33)] + public void SetComputeRootShaderResourceView(uint RootParameterIndex, ulong BufferLocation) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[33]))((ID3D12GraphicsCommandList1*)Unsafe.AsPointer(ref this), RootParameterIndex, BufferLocation); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[33]))((ID3D12GraphicsCommandList1*)Unsafe.AsPointer(ref this), RootParameterIndex, BufferLocation); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(34)] + public void SetGraphicsRootShaderResourceView(uint RootParameterIndex, ulong BufferLocation) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[34]))((ID3D12GraphicsCommandList1*)Unsafe.AsPointer(ref this), RootParameterIndex, BufferLocation); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[34]))((ID3D12GraphicsCommandList1*)Unsafe.AsPointer(ref this), RootParameterIndex, BufferLocation); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(35)] + public void SetComputeRootUnorderedAccessView(uint RootParameterIndex, ulong BufferLocation) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[35]))((ID3D12GraphicsCommandList1*)Unsafe.AsPointer(ref this), RootParameterIndex, BufferLocation); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[35]))((ID3D12GraphicsCommandList1*)Unsafe.AsPointer(ref this), RootParameterIndex, BufferLocation); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(36)] + public void SetGraphicsRootUnorderedAccessView(uint RootParameterIndex, ulong BufferLocation) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[36]))((ID3D12GraphicsCommandList1*)Unsafe.AsPointer(ref this), RootParameterIndex, BufferLocation); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[36]))((ID3D12GraphicsCommandList1*)Unsafe.AsPointer(ref this), RootParameterIndex, BufferLocation); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(37)] + public void IASetIndexBuffer(IndexBufferView* pView) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[37]))((ID3D12GraphicsCommandList1*)Unsafe.AsPointer(ref this), pView); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[37]))((ID3D12GraphicsCommandList1*)Unsafe.AsPointer(ref this), pView); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(38)] + public void IASetVertexBuffers(uint StartSlot, uint NumViews, VertexBufferView* pViews) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[38]))((ID3D12GraphicsCommandList1*)Unsafe.AsPointer(ref this), StartSlot, NumViews, pViews); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[38]))((ID3D12GraphicsCommandList1*)Unsafe.AsPointer(ref this), StartSlot, NumViews, pViews); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(39)] + public void SOSetTargets(uint StartSlot, uint NumViews, StreamOutputBufferView* pViews) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[39]))((ID3D12GraphicsCommandList1*)Unsafe.AsPointer(ref this), StartSlot, NumViews, pViews); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[39]))((ID3D12GraphicsCommandList1*)Unsafe.AsPointer(ref this), StartSlot, NumViews, pViews); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(40)] + public void OMSetRenderTargets(uint NumRenderTargetDescriptors, CpuDescriptorHandle* pRenderTargetDescriptors, Bool32 RTsSingleHandleToDescriptorRange, CpuDescriptorHandle* pDepthStencilDescriptor) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[40]))((ID3D12GraphicsCommandList1*)Unsafe.AsPointer(ref this), NumRenderTargetDescriptors, pRenderTargetDescriptors, RTsSingleHandleToDescriptorRange, pDepthStencilDescriptor); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[40]))((ID3D12GraphicsCommandList1*)Unsafe.AsPointer(ref this), NumRenderTargetDescriptors, pRenderTargetDescriptors, RTsSingleHandleToDescriptorRange, pDepthStencilDescriptor); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(41)] + public void ClearDepthStencilView(CpuDescriptorHandle* DepthStencilView, ClearFlags ClearFlags, float Depth, byte Stencil, uint NumRects, RawRect* pRects) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[41]))((ID3D12GraphicsCommandList1*)Unsafe.AsPointer(ref this), DepthStencilView, ClearFlags, Depth, Stencil, NumRects, pRects); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[41]))((ID3D12GraphicsCommandList1*)Unsafe.AsPointer(ref this), DepthStencilView, ClearFlags, Depth, Stencil, NumRects, pRects); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(42)] + public void ClearRenderTargetView(CpuDescriptorHandle* RenderTargetView, float* ColorRGBA, uint NumRects, RawRect* pRects) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[42]))((ID3D12GraphicsCommandList1*)Unsafe.AsPointer(ref this), RenderTargetView, ColorRGBA, NumRects, pRects); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[42]))((ID3D12GraphicsCommandList1*)Unsafe.AsPointer(ref this), RenderTargetView, ColorRGBA, NumRects, pRects); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(43)] + public void ClearUnorderedAccessViewUint(GpuDescriptorHandle* ViewGPUHandleInCurrentHeap, CpuDescriptorHandle* ViewCPUHandle, ID3D12Resource* pResource, uint* Values, uint NumRects, RawRect* pRects) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[43]))((ID3D12GraphicsCommandList1*)Unsafe.AsPointer(ref this), ViewGPUHandleInCurrentHeap, ViewCPUHandle, pResource, Values, NumRects, pRects); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[43]))((ID3D12GraphicsCommandList1*)Unsafe.AsPointer(ref this), ViewGPUHandleInCurrentHeap, ViewCPUHandle, pResource, Values, NumRects, pRects); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(44)] + public void ClearUnorderedAccessViewFloat(GpuDescriptorHandle* ViewGPUHandleInCurrentHeap, CpuDescriptorHandle* ViewCPUHandle, ID3D12Resource* pResource, float* Values, uint NumRects, RawRect* pRects) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[44]))((ID3D12GraphicsCommandList1*)Unsafe.AsPointer(ref this), ViewGPUHandleInCurrentHeap, ViewCPUHandle, pResource, Values, NumRects, pRects); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[44]))((ID3D12GraphicsCommandList1*)Unsafe.AsPointer(ref this), ViewGPUHandleInCurrentHeap, ViewCPUHandle, pResource, Values, NumRects, pRects); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(45)] + public void DiscardResource(ID3D12Resource* pResource, DiscardRegion* pRegion) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[45]))((ID3D12GraphicsCommandList1*)Unsafe.AsPointer(ref this), pResource, pRegion); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[45]))((ID3D12GraphicsCommandList1*)Unsafe.AsPointer(ref this), pResource, pRegion); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(46)] + public void BeginQuery(ID3D12QueryHeap* pQueryHeap, QueryType Type, uint Index) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[46]))((ID3D12GraphicsCommandList1*)Unsafe.AsPointer(ref this), pQueryHeap, Type, Index); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[46]))((ID3D12GraphicsCommandList1*)Unsafe.AsPointer(ref this), pQueryHeap, Type, Index); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(47)] + public void EndQuery(ID3D12QueryHeap* pQueryHeap, QueryType Type, uint Index) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[47]))((ID3D12GraphicsCommandList1*)Unsafe.AsPointer(ref this), pQueryHeap, Type, Index); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[47]))((ID3D12GraphicsCommandList1*)Unsafe.AsPointer(ref this), pQueryHeap, Type, Index); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(48)] + public void ResolveQueryData(ID3D12QueryHeap* pQueryHeap, QueryType Type, uint StartIndex, uint NumQueries, ID3D12Resource* pDestinationBuffer, ulong AlignedDestinationBufferOffset) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[48]))((ID3D12GraphicsCommandList1*)Unsafe.AsPointer(ref this), pQueryHeap, Type, StartIndex, NumQueries, pDestinationBuffer, AlignedDestinationBufferOffset); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[48]))((ID3D12GraphicsCommandList1*)Unsafe.AsPointer(ref this), pQueryHeap, Type, StartIndex, NumQueries, pDestinationBuffer, AlignedDestinationBufferOffset); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(49)] + public void SetPredication(ID3D12Resource* pBuffer, ulong AlignedBufferOffset, PredicationOp Operation) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[49]))((ID3D12GraphicsCommandList1*)Unsafe.AsPointer(ref this), pBuffer, AlignedBufferOffset, Operation); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[49]))((ID3D12GraphicsCommandList1*)Unsafe.AsPointer(ref this), pBuffer, AlignedBufferOffset, Operation); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(50)] + public void SetMarker(uint Metadata, void* pData, uint Size) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[50]))((ID3D12GraphicsCommandList1*)Unsafe.AsPointer(ref this), Metadata, pData, Size); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[50]))((ID3D12GraphicsCommandList1*)Unsafe.AsPointer(ref this), Metadata, pData, Size); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(51)] + public void BeginEvent(uint Metadata, void* pData, uint Size) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[51]))((ID3D12GraphicsCommandList1*)Unsafe.AsPointer(ref this), Metadata, pData, Size); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[51]))((ID3D12GraphicsCommandList1*)Unsafe.AsPointer(ref this), Metadata, pData, Size); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(52)] + public void EndEvent() + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[52]))((ID3D12GraphicsCommandList1*)Unsafe.AsPointer(ref this)); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[52]))((ID3D12GraphicsCommandList1*)Unsafe.AsPointer(ref this)); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(53)] + public void ExecuteIndirect(ID3D12CommandSignature* pCommandSignature, uint MaxCommandCount, ID3D12Resource* pArgumentBuffer, ulong ArgumentBufferOffset, ID3D12Resource* pCountBuffer, ulong CountBufferOffset) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[53]))((ID3D12GraphicsCommandList1*)Unsafe.AsPointer(ref this), pCommandSignature, MaxCommandCount, pArgumentBuffer, ArgumentBufferOffset, pCountBuffer, CountBufferOffset); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[53]))((ID3D12GraphicsCommandList1*)Unsafe.AsPointer(ref this), pCommandSignature, MaxCommandCount, pArgumentBuffer, ArgumentBufferOffset, pCountBuffer, CountBufferOffset); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(54)] + public new Graphics.Direct3D12.CommandListType GetType() + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[54]))((ID3D12GraphicsCommandList1*)Unsafe.AsPointer(ref this)); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[54]))((ID3D12GraphicsCommandList1*)Unsafe.AsPointer(ref this)); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(55)] + public HResult GetDevice(Guid* riid, void** ppvDevice) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[55]))((ID3D12GraphicsCommandList1*)Unsafe.AsPointer(ref this), riid, ppvDevice); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[55]))((ID3D12GraphicsCommandList1*)Unsafe.AsPointer(ref this), riid, ppvDevice); +#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]))((ID3D12GraphicsCommandList1*)Unsafe.AsPointer(ref this), guid, pDataSize, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[56]))((ID3D12GraphicsCommandList1*)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]))((ID3D12GraphicsCommandList1*)Unsafe.AsPointer(ref this), guid, DataSize, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[57]))((ID3D12GraphicsCommandList1*)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]))((ID3D12GraphicsCommandList1*)Unsafe.AsPointer(ref this), guid, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[58]))((ID3D12GraphicsCommandList1*)Unsafe.AsPointer(ref this), guid, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(59)] + public HResult SetName(char** Name) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[59]))((ID3D12GraphicsCommandList1*)Unsafe.AsPointer(ref this), Name); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[59]))((ID3D12GraphicsCommandList1*)Unsafe.AsPointer(ref this), Name); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(60)] + public void AtomicCopyBufferUINT(ID3D12Resource* pDstBuffer, ulong DstOffset, ID3D12Resource* pSrcBuffer, ulong SrcOffset, uint Dependencies, ID3D12Resource* ppDependentResources, SubresourceRangeUint64* pDependentSubresourceRanges) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[60]))((ID3D12GraphicsCommandList1*)Unsafe.AsPointer(ref this), pDstBuffer, DstOffset, pSrcBuffer, SrcOffset, Dependencies, ppDependentResources, pDependentSubresourceRanges); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[60]))((ID3D12GraphicsCommandList1*)Unsafe.AsPointer(ref this), pDstBuffer, DstOffset, pSrcBuffer, SrcOffset, Dependencies, ppDependentResources, pDependentSubresourceRanges); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(61)] + public void AtomicCopyBufferUINT64(ID3D12Resource* pDstBuffer, ulong DstOffset, ID3D12Resource* pSrcBuffer, ulong SrcOffset, uint Dependencies, ID3D12Resource* ppDependentResources, SubresourceRangeUint64* pDependentSubresourceRanges) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[61]))((ID3D12GraphicsCommandList1*)Unsafe.AsPointer(ref this), pDstBuffer, DstOffset, pSrcBuffer, SrcOffset, Dependencies, ppDependentResources, pDependentSubresourceRanges); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[61]))((ID3D12GraphicsCommandList1*)Unsafe.AsPointer(ref this), pDstBuffer, DstOffset, pSrcBuffer, SrcOffset, Dependencies, ppDependentResources, pDependentSubresourceRanges); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(62)] + public void OMSetDepthBounds(float Min, float Max) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[62]))((ID3D12GraphicsCommandList1*)Unsafe.AsPointer(ref this), Min, Max); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[62]))((ID3D12GraphicsCommandList1*)Unsafe.AsPointer(ref this), Min, Max); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(63)] + public void SetSamplePositions(uint NumSamplesPerPixel, uint NumPixels, SamplePosition* pSamplePositions) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[63]))((ID3D12GraphicsCommandList1*)Unsafe.AsPointer(ref this), NumSamplesPerPixel, NumPixels, pSamplePositions); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[63]))((ID3D12GraphicsCommandList1*)Unsafe.AsPointer(ref this), NumSamplesPerPixel, NumPixels, pSamplePositions); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(64)] + public void ResolveSubresourceRegion(ID3D12Resource* pDstResource, uint DstSubresource, uint DstX, uint DstY, ID3D12Resource* pSrcResource, uint SrcSubresource, RawRect* pSrcRect, Graphics.Dxgi.Common.Format Format, ResolveMode ResolveMode) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[64]))((ID3D12GraphicsCommandList1*)Unsafe.AsPointer(ref this), pDstResource, DstSubresource, DstX, DstY, pSrcResource, SrcSubresource, pSrcRect, Format, ResolveMode); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[64]))((ID3D12GraphicsCommandList1*)Unsafe.AsPointer(ref this), pDstResource, DstSubresource, DstX, DstY, pSrcResource, SrcSubresource, pSrcRect, Format, ResolveMode); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(65)] + public void SetViewInstanceMask(uint Mask) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[65]))((ID3D12GraphicsCommandList1*)Unsafe.AsPointer(ref this), Mask); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[65]))((ID3D12GraphicsCommandList1*)Unsafe.AsPointer(ref this), Mask); +#endif + } + + public interface Interface : ID3D12GraphicsCommandList.Interface + { + } +} + +/// +/// ID3D12GraphicsCommandList2 +[Guid("38c3e585-ff17-412c-9150-4fc6f9d72a28")] +[NativeTypeName("struct ID3D12GraphicsCommandList2 : ID3D12GraphicsCommandList1")] +[NativeInheritance("ID3D12GraphicsCommandList1")] +public unsafe partial struct ID3D12GraphicsCommandList2 : ID3D12GraphicsCommandList2.Interface +{ + public static ref readonly Guid IID_ID3D12GraphicsCommandList2 + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x85, 0xE5, 0xC3, 0x38, + 0x17, 0xFF, + 0x2C, 0x41, + 0x91, + 0x50, + 0x4F, + 0xC6, + 0xF9, + 0xD7, + 0x2A, + 0x28 + }; + + 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_ID3D12GraphicsCommandList2)); + + 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 AtomicCopyBufferUINT(ID3D12Resource* pDstBuffer, ulong DstOffset, ID3D12Resource* pSrcBuffer, ulong SrcOffset, uint Dependencies, ID3D12Resource* ppDependentResources, SubresourceRangeUint64* pDependentSubresourceRanges) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[3]))((ID3D12GraphicsCommandList2*)Unsafe.AsPointer(ref this), pDstBuffer, DstOffset, pSrcBuffer, SrcOffset, Dependencies, ppDependentResources, pDependentSubresourceRanges); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((ID3D12GraphicsCommandList2*)Unsafe.AsPointer(ref this), pDstBuffer, DstOffset, pSrcBuffer, SrcOffset, Dependencies, ppDependentResources, pDependentSubresourceRanges); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public void AtomicCopyBufferUINT64(ID3D12Resource* pDstBuffer, ulong DstOffset, ID3D12Resource* pSrcBuffer, ulong SrcOffset, uint Dependencies, ID3D12Resource* ppDependentResources, SubresourceRangeUint64* pDependentSubresourceRanges) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[4]))((ID3D12GraphicsCommandList2*)Unsafe.AsPointer(ref this), pDstBuffer, DstOffset, pSrcBuffer, SrcOffset, Dependencies, ppDependentResources, pDependentSubresourceRanges); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((ID3D12GraphicsCommandList2*)Unsafe.AsPointer(ref this), pDstBuffer, DstOffset, pSrcBuffer, SrcOffset, Dependencies, ppDependentResources, pDependentSubresourceRanges); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(5)] + public void OMSetDepthBounds(float Min, float Max) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[5]))((ID3D12GraphicsCommandList2*)Unsafe.AsPointer(ref this), Min, Max); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((ID3D12GraphicsCommandList2*)Unsafe.AsPointer(ref this), Min, Max); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(6)] + public void SetSamplePositions(uint NumSamplesPerPixel, uint NumPixels, SamplePosition* pSamplePositions) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[6]))((ID3D12GraphicsCommandList2*)Unsafe.AsPointer(ref this), NumSamplesPerPixel, NumPixels, pSamplePositions); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((ID3D12GraphicsCommandList2*)Unsafe.AsPointer(ref this), NumSamplesPerPixel, NumPixels, pSamplePositions); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(7)] + public void ResolveSubresourceRegion(ID3D12Resource* pDstResource, uint DstSubresource, uint DstX, uint DstY, ID3D12Resource* pSrcResource, uint SrcSubresource, RawRect* pSrcRect, Graphics.Dxgi.Common.Format Format, ResolveMode ResolveMode) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[7]))((ID3D12GraphicsCommandList2*)Unsafe.AsPointer(ref this), pDstResource, DstSubresource, DstX, DstY, pSrcResource, SrcSubresource, pSrcRect, Format, ResolveMode); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((ID3D12GraphicsCommandList2*)Unsafe.AsPointer(ref this), pDstResource, DstSubresource, DstX, DstY, pSrcResource, SrcSubresource, pSrcRect, Format, ResolveMode); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(8)] + public void SetViewInstanceMask(uint Mask) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[8]))((ID3D12GraphicsCommandList2*)Unsafe.AsPointer(ref this), Mask); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[8]))((ID3D12GraphicsCommandList2*)Unsafe.AsPointer(ref this), Mask); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(9)] + public HResult Close() + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[9]))((ID3D12GraphicsCommandList2*)Unsafe.AsPointer(ref this)); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[9]))((ID3D12GraphicsCommandList2*)Unsafe.AsPointer(ref this)); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(10)] + public HResult Reset(ID3D12CommandAllocator* pAllocator, ID3D12PipelineState* pInitialState) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[10]))((ID3D12GraphicsCommandList2*)Unsafe.AsPointer(ref this), pAllocator, pInitialState); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[10]))((ID3D12GraphicsCommandList2*)Unsafe.AsPointer(ref this), pAllocator, pInitialState); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(11)] + public void ClearState(ID3D12PipelineState* pPipelineState) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[11]))((ID3D12GraphicsCommandList2*)Unsafe.AsPointer(ref this), pPipelineState); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[11]))((ID3D12GraphicsCommandList2*)Unsafe.AsPointer(ref this), pPipelineState); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(12)] + public void DrawInstanced(uint VertexCountPerInstance, uint InstanceCount, uint StartVertexLocation, uint StartInstanceLocation) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[12]))((ID3D12GraphicsCommandList2*)Unsafe.AsPointer(ref this), VertexCountPerInstance, InstanceCount, StartVertexLocation, StartInstanceLocation); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[12]))((ID3D12GraphicsCommandList2*)Unsafe.AsPointer(ref this), VertexCountPerInstance, InstanceCount, StartVertexLocation, StartInstanceLocation); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(13)] + public void DrawIndexedInstanced(uint IndexCountPerInstance, uint InstanceCount, uint StartIndexLocation, int BaseVertexLocation, uint StartInstanceLocation) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[13]))((ID3D12GraphicsCommandList2*)Unsafe.AsPointer(ref this), IndexCountPerInstance, InstanceCount, StartIndexLocation, BaseVertexLocation, StartInstanceLocation); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[13]))((ID3D12GraphicsCommandList2*)Unsafe.AsPointer(ref this), IndexCountPerInstance, InstanceCount, StartIndexLocation, BaseVertexLocation, StartInstanceLocation); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(14)] + public void Dispatch(uint ThreadGroupCountX, uint ThreadGroupCountY, uint ThreadGroupCountZ) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[14]))((ID3D12GraphicsCommandList2*)Unsafe.AsPointer(ref this), ThreadGroupCountX, ThreadGroupCountY, ThreadGroupCountZ); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[14]))((ID3D12GraphicsCommandList2*)Unsafe.AsPointer(ref this), ThreadGroupCountX, ThreadGroupCountY, ThreadGroupCountZ); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(15)] + public void CopyBufferRegion(ID3D12Resource* pDstBuffer, ulong DstOffset, ID3D12Resource* pSrcBuffer, ulong SrcOffset, ulong NumBytes) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[15]))((ID3D12GraphicsCommandList2*)Unsafe.AsPointer(ref this), pDstBuffer, DstOffset, pSrcBuffer, SrcOffset, NumBytes); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[15]))((ID3D12GraphicsCommandList2*)Unsafe.AsPointer(ref this), pDstBuffer, DstOffset, pSrcBuffer, SrcOffset, NumBytes); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(16)] + public void CopyTextureRegion(TextureCopyLocation* pDst, uint DstX, uint DstY, uint DstZ, TextureCopyLocation* pSrc, Box* pSrcBox) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[16]))((ID3D12GraphicsCommandList2*)Unsafe.AsPointer(ref this), pDst, DstX, DstY, DstZ, pSrc, pSrcBox); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[16]))((ID3D12GraphicsCommandList2*)Unsafe.AsPointer(ref this), pDst, DstX, DstY, DstZ, pSrc, pSrcBox); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(17)] + public void CopyResource(ID3D12Resource* pDstResource, ID3D12Resource* pSrcResource) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[17]))((ID3D12GraphicsCommandList2*)Unsafe.AsPointer(ref this), pDstResource, pSrcResource); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[17]))((ID3D12GraphicsCommandList2*)Unsafe.AsPointer(ref this), pDstResource, pSrcResource); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(18)] + public void CopyTiles(ID3D12Resource* pTiledResource, TiledResourceCoordinate* pTileRegionStartCoordinate, TileRegionSize* pTileRegionSize, ID3D12Resource* pBuffer, ulong BufferStartOffsetInBytes, TileCopyFlags Flags) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[18]))((ID3D12GraphicsCommandList2*)Unsafe.AsPointer(ref this), pTiledResource, pTileRegionStartCoordinate, pTileRegionSize, pBuffer, BufferStartOffsetInBytes, Flags); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[18]))((ID3D12GraphicsCommandList2*)Unsafe.AsPointer(ref this), pTiledResource, pTileRegionStartCoordinate, pTileRegionSize, pBuffer, BufferStartOffsetInBytes, Flags); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(19)] + public void ResolveSubresource(ID3D12Resource* pDstResource, uint DstSubresource, ID3D12Resource* pSrcResource, uint SrcSubresource, Graphics.Dxgi.Common.Format Format) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[19]))((ID3D12GraphicsCommandList2*)Unsafe.AsPointer(ref this), pDstResource, DstSubresource, pSrcResource, SrcSubresource, Format); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[19]))((ID3D12GraphicsCommandList2*)Unsafe.AsPointer(ref this), pDstResource, DstSubresource, pSrcResource, SrcSubresource, Format); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(20)] + public void IASetPrimitiveTopology(Graphics.Direct3D.PrimitiveTopology PrimitiveTopology) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[20]))((ID3D12GraphicsCommandList2*)Unsafe.AsPointer(ref this), PrimitiveTopology); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[20]))((ID3D12GraphicsCommandList2*)Unsafe.AsPointer(ref this), PrimitiveTopology); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(21)] + public void RSSetViewports(uint NumViewports, Viewport* pViewports) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[21]))((ID3D12GraphicsCommandList2*)Unsafe.AsPointer(ref this), NumViewports, pViewports); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[21]))((ID3D12GraphicsCommandList2*)Unsafe.AsPointer(ref this), NumViewports, pViewports); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(22)] + public void RSSetScissorRects(uint NumRects, RawRect* pRects) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[22]))((ID3D12GraphicsCommandList2*)Unsafe.AsPointer(ref this), NumRects, pRects); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[22]))((ID3D12GraphicsCommandList2*)Unsafe.AsPointer(ref this), NumRects, pRects); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(23)] + public void OMSetBlendFactor(float* BlendFactor) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[23]))((ID3D12GraphicsCommandList2*)Unsafe.AsPointer(ref this), BlendFactor); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[23]))((ID3D12GraphicsCommandList2*)Unsafe.AsPointer(ref this), BlendFactor); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(24)] + public void OMSetStencilRef(uint StencilRef) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[24]))((ID3D12GraphicsCommandList2*)Unsafe.AsPointer(ref this), StencilRef); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[24]))((ID3D12GraphicsCommandList2*)Unsafe.AsPointer(ref this), StencilRef); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(25)] + public void SetPipelineState(ID3D12PipelineState* pPipelineState) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[25]))((ID3D12GraphicsCommandList2*)Unsafe.AsPointer(ref this), pPipelineState); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[25]))((ID3D12GraphicsCommandList2*)Unsafe.AsPointer(ref this), pPipelineState); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(26)] + public void ResourceBarrier(uint NumBarriers, ResourceBarrier* pBarriers) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[26]))((ID3D12GraphicsCommandList2*)Unsafe.AsPointer(ref this), NumBarriers, pBarriers); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[26]))((ID3D12GraphicsCommandList2*)Unsafe.AsPointer(ref this), NumBarriers, pBarriers); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(27)] + public void ExecuteBundle(ID3D12GraphicsCommandList* pCommandList) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[27]))((ID3D12GraphicsCommandList2*)Unsafe.AsPointer(ref this), pCommandList); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[27]))((ID3D12GraphicsCommandList2*)Unsafe.AsPointer(ref this), pCommandList); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(28)] + public void SetDescriptorHeaps(uint NumDescriptorHeaps, ID3D12DescriptorHeap* ppDescriptorHeaps) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[28]))((ID3D12GraphicsCommandList2*)Unsafe.AsPointer(ref this), NumDescriptorHeaps, ppDescriptorHeaps); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[28]))((ID3D12GraphicsCommandList2*)Unsafe.AsPointer(ref this), NumDescriptorHeaps, ppDescriptorHeaps); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(29)] + public void SetComputeRootSignature(ID3D12RootSignature* pRootSignature) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[29]))((ID3D12GraphicsCommandList2*)Unsafe.AsPointer(ref this), pRootSignature); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[29]))((ID3D12GraphicsCommandList2*)Unsafe.AsPointer(ref this), pRootSignature); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(30)] + public void SetGraphicsRootSignature(ID3D12RootSignature* pRootSignature) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[30]))((ID3D12GraphicsCommandList2*)Unsafe.AsPointer(ref this), pRootSignature); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[30]))((ID3D12GraphicsCommandList2*)Unsafe.AsPointer(ref this), pRootSignature); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(31)] + public void SetComputeRootDescriptorTable(uint RootParameterIndex, GpuDescriptorHandle* BaseDescriptor) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[31]))((ID3D12GraphicsCommandList2*)Unsafe.AsPointer(ref this), RootParameterIndex, BaseDescriptor); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[31]))((ID3D12GraphicsCommandList2*)Unsafe.AsPointer(ref this), RootParameterIndex, BaseDescriptor); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(32)] + public void SetGraphicsRootDescriptorTable(uint RootParameterIndex, GpuDescriptorHandle* BaseDescriptor) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[32]))((ID3D12GraphicsCommandList2*)Unsafe.AsPointer(ref this), RootParameterIndex, BaseDescriptor); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[32]))((ID3D12GraphicsCommandList2*)Unsafe.AsPointer(ref this), RootParameterIndex, BaseDescriptor); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(33)] + public void SetComputeRoot32BitConstant(uint RootParameterIndex, uint SrcData, uint DestOffsetIn32BitValues) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[33]))((ID3D12GraphicsCommandList2*)Unsafe.AsPointer(ref this), RootParameterIndex, SrcData, DestOffsetIn32BitValues); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[33]))((ID3D12GraphicsCommandList2*)Unsafe.AsPointer(ref this), RootParameterIndex, SrcData, DestOffsetIn32BitValues); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(34)] + public void SetGraphicsRoot32BitConstant(uint RootParameterIndex, uint SrcData, uint DestOffsetIn32BitValues) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[34]))((ID3D12GraphicsCommandList2*)Unsafe.AsPointer(ref this), RootParameterIndex, SrcData, DestOffsetIn32BitValues); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[34]))((ID3D12GraphicsCommandList2*)Unsafe.AsPointer(ref this), RootParameterIndex, SrcData, DestOffsetIn32BitValues); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(35)] + public void SetComputeRoot32BitConstants(uint RootParameterIndex, uint Num32BitValuesToSet, void* pSrcData, uint DestOffsetIn32BitValues) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[35]))((ID3D12GraphicsCommandList2*)Unsafe.AsPointer(ref this), RootParameterIndex, Num32BitValuesToSet, pSrcData, DestOffsetIn32BitValues); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[35]))((ID3D12GraphicsCommandList2*)Unsafe.AsPointer(ref this), RootParameterIndex, Num32BitValuesToSet, pSrcData, DestOffsetIn32BitValues); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(36)] + public void SetGraphicsRoot32BitConstants(uint RootParameterIndex, uint Num32BitValuesToSet, void* pSrcData, uint DestOffsetIn32BitValues) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[36]))((ID3D12GraphicsCommandList2*)Unsafe.AsPointer(ref this), RootParameterIndex, Num32BitValuesToSet, pSrcData, DestOffsetIn32BitValues); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[36]))((ID3D12GraphicsCommandList2*)Unsafe.AsPointer(ref this), RootParameterIndex, Num32BitValuesToSet, pSrcData, DestOffsetIn32BitValues); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(37)] + public void SetComputeRootConstantBufferView(uint RootParameterIndex, ulong BufferLocation) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[37]))((ID3D12GraphicsCommandList2*)Unsafe.AsPointer(ref this), RootParameterIndex, BufferLocation); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[37]))((ID3D12GraphicsCommandList2*)Unsafe.AsPointer(ref this), RootParameterIndex, BufferLocation); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(38)] + public void SetGraphicsRootConstantBufferView(uint RootParameterIndex, ulong BufferLocation) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[38]))((ID3D12GraphicsCommandList2*)Unsafe.AsPointer(ref this), RootParameterIndex, BufferLocation); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[38]))((ID3D12GraphicsCommandList2*)Unsafe.AsPointer(ref this), RootParameterIndex, BufferLocation); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(39)] + public void SetComputeRootShaderResourceView(uint RootParameterIndex, ulong BufferLocation) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[39]))((ID3D12GraphicsCommandList2*)Unsafe.AsPointer(ref this), RootParameterIndex, BufferLocation); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[39]))((ID3D12GraphicsCommandList2*)Unsafe.AsPointer(ref this), RootParameterIndex, BufferLocation); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(40)] + public void SetGraphicsRootShaderResourceView(uint RootParameterIndex, ulong BufferLocation) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[40]))((ID3D12GraphicsCommandList2*)Unsafe.AsPointer(ref this), RootParameterIndex, BufferLocation); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[40]))((ID3D12GraphicsCommandList2*)Unsafe.AsPointer(ref this), RootParameterIndex, BufferLocation); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(41)] + public void SetComputeRootUnorderedAccessView(uint RootParameterIndex, ulong BufferLocation) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[41]))((ID3D12GraphicsCommandList2*)Unsafe.AsPointer(ref this), RootParameterIndex, BufferLocation); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[41]))((ID3D12GraphicsCommandList2*)Unsafe.AsPointer(ref this), RootParameterIndex, BufferLocation); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(42)] + public void SetGraphicsRootUnorderedAccessView(uint RootParameterIndex, ulong BufferLocation) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[42]))((ID3D12GraphicsCommandList2*)Unsafe.AsPointer(ref this), RootParameterIndex, BufferLocation); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[42]))((ID3D12GraphicsCommandList2*)Unsafe.AsPointer(ref this), RootParameterIndex, BufferLocation); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(43)] + public void IASetIndexBuffer(IndexBufferView* pView) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[43]))((ID3D12GraphicsCommandList2*)Unsafe.AsPointer(ref this), pView); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[43]))((ID3D12GraphicsCommandList2*)Unsafe.AsPointer(ref this), pView); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(44)] + public void IASetVertexBuffers(uint StartSlot, uint NumViews, VertexBufferView* pViews) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[44]))((ID3D12GraphicsCommandList2*)Unsafe.AsPointer(ref this), StartSlot, NumViews, pViews); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[44]))((ID3D12GraphicsCommandList2*)Unsafe.AsPointer(ref this), StartSlot, NumViews, pViews); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(45)] + public void SOSetTargets(uint StartSlot, uint NumViews, StreamOutputBufferView* pViews) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[45]))((ID3D12GraphicsCommandList2*)Unsafe.AsPointer(ref this), StartSlot, NumViews, pViews); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[45]))((ID3D12GraphicsCommandList2*)Unsafe.AsPointer(ref this), StartSlot, NumViews, pViews); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(46)] + public void OMSetRenderTargets(uint NumRenderTargetDescriptors, CpuDescriptorHandle* pRenderTargetDescriptors, Bool32 RTsSingleHandleToDescriptorRange, CpuDescriptorHandle* pDepthStencilDescriptor) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[46]))((ID3D12GraphicsCommandList2*)Unsafe.AsPointer(ref this), NumRenderTargetDescriptors, pRenderTargetDescriptors, RTsSingleHandleToDescriptorRange, pDepthStencilDescriptor); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[46]))((ID3D12GraphicsCommandList2*)Unsafe.AsPointer(ref this), NumRenderTargetDescriptors, pRenderTargetDescriptors, RTsSingleHandleToDescriptorRange, pDepthStencilDescriptor); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(47)] + public void ClearDepthStencilView(CpuDescriptorHandle* DepthStencilView, ClearFlags ClearFlags, float Depth, byte Stencil, uint NumRects, RawRect* pRects) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[47]))((ID3D12GraphicsCommandList2*)Unsafe.AsPointer(ref this), DepthStencilView, ClearFlags, Depth, Stencil, NumRects, pRects); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[47]))((ID3D12GraphicsCommandList2*)Unsafe.AsPointer(ref this), DepthStencilView, ClearFlags, Depth, Stencil, NumRects, pRects); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(48)] + public void ClearRenderTargetView(CpuDescriptorHandle* RenderTargetView, float* ColorRGBA, uint NumRects, RawRect* pRects) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[48]))((ID3D12GraphicsCommandList2*)Unsafe.AsPointer(ref this), RenderTargetView, ColorRGBA, NumRects, pRects); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[48]))((ID3D12GraphicsCommandList2*)Unsafe.AsPointer(ref this), RenderTargetView, ColorRGBA, NumRects, pRects); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(49)] + public void ClearUnorderedAccessViewUint(GpuDescriptorHandle* ViewGPUHandleInCurrentHeap, CpuDescriptorHandle* ViewCPUHandle, ID3D12Resource* pResource, uint* Values, uint NumRects, RawRect* pRects) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[49]))((ID3D12GraphicsCommandList2*)Unsafe.AsPointer(ref this), ViewGPUHandleInCurrentHeap, ViewCPUHandle, pResource, Values, NumRects, pRects); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[49]))((ID3D12GraphicsCommandList2*)Unsafe.AsPointer(ref this), ViewGPUHandleInCurrentHeap, ViewCPUHandle, pResource, Values, NumRects, pRects); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(50)] + public void ClearUnorderedAccessViewFloat(GpuDescriptorHandle* ViewGPUHandleInCurrentHeap, CpuDescriptorHandle* ViewCPUHandle, ID3D12Resource* pResource, float* Values, uint NumRects, RawRect* pRects) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[50]))((ID3D12GraphicsCommandList2*)Unsafe.AsPointer(ref this), ViewGPUHandleInCurrentHeap, ViewCPUHandle, pResource, Values, NumRects, pRects); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[50]))((ID3D12GraphicsCommandList2*)Unsafe.AsPointer(ref this), ViewGPUHandleInCurrentHeap, ViewCPUHandle, pResource, Values, NumRects, pRects); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(51)] + public void DiscardResource(ID3D12Resource* pResource, DiscardRegion* pRegion) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[51]))((ID3D12GraphicsCommandList2*)Unsafe.AsPointer(ref this), pResource, pRegion); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[51]))((ID3D12GraphicsCommandList2*)Unsafe.AsPointer(ref this), pResource, pRegion); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(52)] + public void BeginQuery(ID3D12QueryHeap* pQueryHeap, QueryType Type, uint Index) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[52]))((ID3D12GraphicsCommandList2*)Unsafe.AsPointer(ref this), pQueryHeap, Type, Index); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[52]))((ID3D12GraphicsCommandList2*)Unsafe.AsPointer(ref this), pQueryHeap, Type, Index); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(53)] + public void EndQuery(ID3D12QueryHeap* pQueryHeap, QueryType Type, uint Index) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[53]))((ID3D12GraphicsCommandList2*)Unsafe.AsPointer(ref this), pQueryHeap, Type, Index); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[53]))((ID3D12GraphicsCommandList2*)Unsafe.AsPointer(ref this), pQueryHeap, Type, Index); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(54)] + public void ResolveQueryData(ID3D12QueryHeap* pQueryHeap, QueryType Type, uint StartIndex, uint NumQueries, ID3D12Resource* pDestinationBuffer, ulong AlignedDestinationBufferOffset) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[54]))((ID3D12GraphicsCommandList2*)Unsafe.AsPointer(ref this), pQueryHeap, Type, StartIndex, NumQueries, pDestinationBuffer, AlignedDestinationBufferOffset); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[54]))((ID3D12GraphicsCommandList2*)Unsafe.AsPointer(ref this), pQueryHeap, Type, StartIndex, NumQueries, pDestinationBuffer, AlignedDestinationBufferOffset); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(55)] + public void SetPredication(ID3D12Resource* pBuffer, ulong AlignedBufferOffset, PredicationOp Operation) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[55]))((ID3D12GraphicsCommandList2*)Unsafe.AsPointer(ref this), pBuffer, AlignedBufferOffset, Operation); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[55]))((ID3D12GraphicsCommandList2*)Unsafe.AsPointer(ref this), pBuffer, AlignedBufferOffset, Operation); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(56)] + public void SetMarker(uint Metadata, void* pData, uint Size) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[56]))((ID3D12GraphicsCommandList2*)Unsafe.AsPointer(ref this), Metadata, pData, Size); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[56]))((ID3D12GraphicsCommandList2*)Unsafe.AsPointer(ref this), Metadata, pData, Size); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(57)] + public void BeginEvent(uint Metadata, void* pData, uint Size) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[57]))((ID3D12GraphicsCommandList2*)Unsafe.AsPointer(ref this), Metadata, pData, Size); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[57]))((ID3D12GraphicsCommandList2*)Unsafe.AsPointer(ref this), Metadata, pData, Size); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(58)] + public void EndEvent() + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[58]))((ID3D12GraphicsCommandList2*)Unsafe.AsPointer(ref this)); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[58]))((ID3D12GraphicsCommandList2*)Unsafe.AsPointer(ref this)); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(59)] + public void ExecuteIndirect(ID3D12CommandSignature* pCommandSignature, uint MaxCommandCount, ID3D12Resource* pArgumentBuffer, ulong ArgumentBufferOffset, ID3D12Resource* pCountBuffer, ulong CountBufferOffset) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[59]))((ID3D12GraphicsCommandList2*)Unsafe.AsPointer(ref this), pCommandSignature, MaxCommandCount, pArgumentBuffer, ArgumentBufferOffset, pCountBuffer, CountBufferOffset); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[59]))((ID3D12GraphicsCommandList2*)Unsafe.AsPointer(ref this), pCommandSignature, MaxCommandCount, pArgumentBuffer, ArgumentBufferOffset, pCountBuffer, CountBufferOffset); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(60)] + public new Graphics.Direct3D12.CommandListType GetType() + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[60]))((ID3D12GraphicsCommandList2*)Unsafe.AsPointer(ref this)); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[60]))((ID3D12GraphicsCommandList2*)Unsafe.AsPointer(ref this)); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(61)] + public HResult GetDevice(Guid* riid, void** ppvDevice) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[61]))((ID3D12GraphicsCommandList2*)Unsafe.AsPointer(ref this), riid, ppvDevice); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[61]))((ID3D12GraphicsCommandList2*)Unsafe.AsPointer(ref this), riid, ppvDevice); +#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]))((ID3D12GraphicsCommandList2*)Unsafe.AsPointer(ref this), guid, pDataSize, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[62]))((ID3D12GraphicsCommandList2*)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]))((ID3D12GraphicsCommandList2*)Unsafe.AsPointer(ref this), guid, DataSize, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[63]))((ID3D12GraphicsCommandList2*)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]))((ID3D12GraphicsCommandList2*)Unsafe.AsPointer(ref this), guid, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[64]))((ID3D12GraphicsCommandList2*)Unsafe.AsPointer(ref this), guid, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(65)] + public HResult SetName(char** Name) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[65]))((ID3D12GraphicsCommandList2*)Unsafe.AsPointer(ref this), Name); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[65]))((ID3D12GraphicsCommandList2*)Unsafe.AsPointer(ref this), Name); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(66)] + public void WriteBufferImmediate(uint Count, WritebufferimmediateParameter* pParams, WritebufferimmediateMode* pModes) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[66]))((ID3D12GraphicsCommandList2*)Unsafe.AsPointer(ref this), Count, pParams, pModes); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[66]))((ID3D12GraphicsCommandList2*)Unsafe.AsPointer(ref this), Count, pParams, pModes); +#endif + } + + public interface Interface : ID3D12GraphicsCommandList1.Interface + { + } +} + +/// +/// ID3D12CommandQueue +[Guid("0ec870a6-5d7e-4c22-8cfc-5baae07616ed")] +[NativeTypeName("struct ID3D12CommandQueue : ID3D12Pageable")] +[NativeInheritance("ID3D12Pageable")] +public unsafe partial struct ID3D12CommandQueue : ID3D12CommandQueue.Interface +{ + public static ref readonly Guid IID_ID3D12CommandQueue + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0xA6, 0x70, 0xC8, 0x0E, + 0x7E, 0x5D, + 0x22, 0x4C, + 0x8C, + 0xFC, + 0x5B, + 0xAA, + 0xE0, + 0x76, + 0x16, + 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_ID3D12CommandQueue)); + + 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 GetDevice(Guid* riid, void** ppvDevice) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[3]))((ID3D12CommandQueue*)Unsafe.AsPointer(ref this), riid, ppvDevice); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((ID3D12CommandQueue*)Unsafe.AsPointer(ref this), riid, ppvDevice); +#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]))((ID3D12CommandQueue*)Unsafe.AsPointer(ref this), guid, pDataSize, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((ID3D12CommandQueue*)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]))((ID3D12CommandQueue*)Unsafe.AsPointer(ref this), guid, DataSize, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((ID3D12CommandQueue*)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]))((ID3D12CommandQueue*)Unsafe.AsPointer(ref this), guid, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((ID3D12CommandQueue*)Unsafe.AsPointer(ref this), guid, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(7)] + public HResult SetName(char** Name) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[7]))((ID3D12CommandQueue*)Unsafe.AsPointer(ref this), Name); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((ID3D12CommandQueue*)Unsafe.AsPointer(ref this), Name); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(8)] + public void UpdateTileMappings(ID3D12Resource* pResource, uint NumResourceRegions, TiledResourceCoordinate* pResourceRegionStartCoordinates, TileRegionSize* pResourceRegionSizes, ID3D12Heap* pHeap, uint NumRanges, TileRangeFlags* pRangeFlags, uint* pHeapRangeStartOffsets, uint* pRangeTileCounts, TileMappingFlags Flags) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[8]))((ID3D12CommandQueue*)Unsafe.AsPointer(ref this), pResource, NumResourceRegions, pResourceRegionStartCoordinates, pResourceRegionSizes, pHeap, NumRanges, pRangeFlags, pHeapRangeStartOffsets, pRangeTileCounts, Flags); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[8]))((ID3D12CommandQueue*)Unsafe.AsPointer(ref this), pResource, NumResourceRegions, pResourceRegionStartCoordinates, pResourceRegionSizes, pHeap, NumRanges, pRangeFlags, pHeapRangeStartOffsets, pRangeTileCounts, Flags); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(9)] + public void CopyTileMappings(ID3D12Resource* pDstResource, TiledResourceCoordinate* pDstRegionStartCoordinate, ID3D12Resource* pSrcResource, TiledResourceCoordinate* pSrcRegionStartCoordinate, TileRegionSize* pRegionSize, TileMappingFlags Flags) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[9]))((ID3D12CommandQueue*)Unsafe.AsPointer(ref this), pDstResource, pDstRegionStartCoordinate, pSrcResource, pSrcRegionStartCoordinate, pRegionSize, Flags); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[9]))((ID3D12CommandQueue*)Unsafe.AsPointer(ref this), pDstResource, pDstRegionStartCoordinate, pSrcResource, pSrcRegionStartCoordinate, pRegionSize, Flags); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(10)] + public void ExecuteCommandLists(uint NumCommandLists, ID3D12CommandList* ppCommandLists) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[10]))((ID3D12CommandQueue*)Unsafe.AsPointer(ref this), NumCommandLists, ppCommandLists); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[10]))((ID3D12CommandQueue*)Unsafe.AsPointer(ref this), NumCommandLists, ppCommandLists); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(11)] + public void SetMarker(uint Metadata, void* pData, uint Size) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[11]))((ID3D12CommandQueue*)Unsafe.AsPointer(ref this), Metadata, pData, Size); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[11]))((ID3D12CommandQueue*)Unsafe.AsPointer(ref this), Metadata, pData, Size); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(12)] + public void BeginEvent(uint Metadata, void* pData, uint Size) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[12]))((ID3D12CommandQueue*)Unsafe.AsPointer(ref this), Metadata, pData, Size); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[12]))((ID3D12CommandQueue*)Unsafe.AsPointer(ref this), Metadata, pData, Size); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(13)] + public void EndEvent() + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[13]))((ID3D12CommandQueue*)Unsafe.AsPointer(ref this)); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[13]))((ID3D12CommandQueue*)Unsafe.AsPointer(ref this)); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(14)] + public HResult Signal(ID3D12Fence* pFence, ulong Value) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[14]))((ID3D12CommandQueue*)Unsafe.AsPointer(ref this), pFence, Value); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[14]))((ID3D12CommandQueue*)Unsafe.AsPointer(ref this), pFence, Value); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(15)] + public HResult Wait(ID3D12Fence* pFence, ulong Value) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[15]))((ID3D12CommandQueue*)Unsafe.AsPointer(ref this), pFence, Value); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[15]))((ID3D12CommandQueue*)Unsafe.AsPointer(ref this), pFence, Value); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(16)] + public HResult GetTimestampFrequency(ulong* pFrequency) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[16]))((ID3D12CommandQueue*)Unsafe.AsPointer(ref this), pFrequency); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[16]))((ID3D12CommandQueue*)Unsafe.AsPointer(ref this), pFrequency); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(17)] + public HResult GetClockCalibration(ulong* pGpuTimestamp, ulong* pCpuTimestamp) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[17]))((ID3D12CommandQueue*)Unsafe.AsPointer(ref this), pGpuTimestamp, pCpuTimestamp); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[17]))((ID3D12CommandQueue*)Unsafe.AsPointer(ref this), pGpuTimestamp, pCpuTimestamp); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(18)] + public Graphics.Direct3D12.CommandQueueDescription GetDesc() + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[18]))((ID3D12CommandQueue*)Unsafe.AsPointer(ref this)); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[18]))((ID3D12CommandQueue*)Unsafe.AsPointer(ref this)); +#endif + } + + public interface Interface : ID3D12Pageable.Interface + { + } +} + +/// +/// ID3D12Device +[Guid("189819f1-1db6-4b57-be54-1821339b85f7")] +[NativeTypeName("struct ID3D12Device : ID3D12Object")] +[NativeInheritance("ID3D12Object")] +public unsafe partial struct ID3D12Device : ID3D12Device.Interface +{ + public static ref readonly Guid IID_ID3D12Device + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0xF1, 0x19, 0x98, 0x18, + 0xB6, 0x1D, + 0x57, 0x4B, + 0xBE, + 0x54, + 0x18, + 0x21, + 0x33, + 0x9B, + 0x85, + 0xF7 + }; + + 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_ID3D12Device)); + + 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 GetPrivateData(Guid* guid, uint* pDataSize, void* pData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[3]))((ID3D12Device*)Unsafe.AsPointer(ref this), guid, pDataSize, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((ID3D12Device*)Unsafe.AsPointer(ref this), guid, pDataSize, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public HResult SetPrivateData(Guid* guid, uint DataSize, void* pData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[4]))((ID3D12Device*)Unsafe.AsPointer(ref this), guid, DataSize, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((ID3D12Device*)Unsafe.AsPointer(ref this), guid, DataSize, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(5)] + public HResult SetPrivateDataInterface(Guid* guid, IUnknown* pData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[5]))((ID3D12Device*)Unsafe.AsPointer(ref this), guid, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((ID3D12Device*)Unsafe.AsPointer(ref this), guid, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(6)] + public HResult SetName(char** Name) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[6]))((ID3D12Device*)Unsafe.AsPointer(ref this), Name); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((ID3D12Device*)Unsafe.AsPointer(ref this), Name); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(7)] + public uint GetNodeCount() + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[7]))((ID3D12Device*)Unsafe.AsPointer(ref this)); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((ID3D12Device*)Unsafe.AsPointer(ref this)); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(8)] + public HResult CreateCommandQueue(CommandQueueDescription* pDesc, Guid* riid, void** ppCommandQueue) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[8]))((ID3D12Device*)Unsafe.AsPointer(ref this), pDesc, riid, ppCommandQueue); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[8]))((ID3D12Device*)Unsafe.AsPointer(ref this), pDesc, riid, ppCommandQueue); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(9)] + public HResult CreateCommandAllocator(CommandListType type, Guid* riid, void** ppCommandAllocator) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[9]))((ID3D12Device*)Unsafe.AsPointer(ref this), type, riid, ppCommandAllocator); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[9]))((ID3D12Device*)Unsafe.AsPointer(ref this), type, riid, ppCommandAllocator); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(10)] + public HResult CreateGraphicsPipelineState(GraphicsPipelineStateDescription* pDesc, Guid* riid, void** ppPipelineState) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[10]))((ID3D12Device*)Unsafe.AsPointer(ref this), pDesc, riid, ppPipelineState); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[10]))((ID3D12Device*)Unsafe.AsPointer(ref this), pDesc, riid, ppPipelineState); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(11)] + public HResult CreateComputePipelineState(ComputePipelineStateDescription* pDesc, Guid* riid, void** ppPipelineState) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[11]))((ID3D12Device*)Unsafe.AsPointer(ref this), pDesc, riid, ppPipelineState); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[11]))((ID3D12Device*)Unsafe.AsPointer(ref this), pDesc, riid, ppPipelineState); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(12)] + public HResult CreateCommandList(uint nodeMask, CommandListType type, ID3D12CommandAllocator* pCommandAllocator, ID3D12PipelineState* pInitialState, Guid* riid, void** ppCommandList) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[12]))((ID3D12Device*)Unsafe.AsPointer(ref this), nodeMask, type, pCommandAllocator, pInitialState, riid, ppCommandList); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[12]))((ID3D12Device*)Unsafe.AsPointer(ref this), nodeMask, type, pCommandAllocator, pInitialState, riid, ppCommandList); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(13)] + public HResult CheckFeatureSupport(Feature Feature, void* pFeatureSupportData, uint FeatureSupportDataSize) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[13]))((ID3D12Device*)Unsafe.AsPointer(ref this), Feature, pFeatureSupportData, FeatureSupportDataSize); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[13]))((ID3D12Device*)Unsafe.AsPointer(ref this), Feature, pFeatureSupportData, FeatureSupportDataSize); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(14)] + public HResult CreateDescriptorHeap(DescriptorHeapDescription* pDescriptorHeapDesc, Guid* riid, void** ppvHeap) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[14]))((ID3D12Device*)Unsafe.AsPointer(ref this), pDescriptorHeapDesc, riid, ppvHeap); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[14]))((ID3D12Device*)Unsafe.AsPointer(ref this), pDescriptorHeapDesc, riid, ppvHeap); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(15)] + public uint GetDescriptorHandleIncrementSize(DescriptorHeapType DescriptorHeapType) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[15]))((ID3D12Device*)Unsafe.AsPointer(ref this), DescriptorHeapType); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[15]))((ID3D12Device*)Unsafe.AsPointer(ref this), DescriptorHeapType); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(16)] + public HResult CreateRootSignature(uint nodeMask, void* pBlobWithRootSignature, nuint blobLengthInBytes, Guid* riid, void** ppvRootSignature) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[16]))((ID3D12Device*)Unsafe.AsPointer(ref this), nodeMask, pBlobWithRootSignature, blobLengthInBytes, riid, ppvRootSignature); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[16]))((ID3D12Device*)Unsafe.AsPointer(ref this), nodeMask, pBlobWithRootSignature, blobLengthInBytes, riid, ppvRootSignature); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(17)] + public void CreateConstantBufferView(ConstantBufferViewDescription* pDesc, CpuDescriptorHandle* DestDescriptor) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[17]))((ID3D12Device*)Unsafe.AsPointer(ref this), pDesc, DestDescriptor); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[17]))((ID3D12Device*)Unsafe.AsPointer(ref this), pDesc, DestDescriptor); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(18)] + public void CreateShaderResourceView(ID3D12Resource* pResource, ShaderResourceViewDescription* pDesc, CpuDescriptorHandle* DestDescriptor) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[18]))((ID3D12Device*)Unsafe.AsPointer(ref this), pResource, pDesc, DestDescriptor); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[18]))((ID3D12Device*)Unsafe.AsPointer(ref this), pResource, pDesc, DestDescriptor); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(19)] + public void CreateUnorderedAccessView(ID3D12Resource* pResource, ID3D12Resource* pCounterResource, UnorderedAccessViewDescription* pDesc, CpuDescriptorHandle* DestDescriptor) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[19]))((ID3D12Device*)Unsafe.AsPointer(ref this), pResource, pCounterResource, pDesc, DestDescriptor); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[19]))((ID3D12Device*)Unsafe.AsPointer(ref this), pResource, pCounterResource, pDesc, DestDescriptor); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(20)] + public void CreateRenderTargetView(ID3D12Resource* pResource, RenderTargetViewDescription* pDesc, CpuDescriptorHandle* DestDescriptor) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[20]))((ID3D12Device*)Unsafe.AsPointer(ref this), pResource, pDesc, DestDescriptor); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[20]))((ID3D12Device*)Unsafe.AsPointer(ref this), pResource, pDesc, DestDescriptor); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(21)] + public void CreateDepthStencilView(ID3D12Resource* pResource, DepthStencilViewDescription* pDesc, CpuDescriptorHandle* DestDescriptor) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[21]))((ID3D12Device*)Unsafe.AsPointer(ref this), pResource, pDesc, DestDescriptor); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[21]))((ID3D12Device*)Unsafe.AsPointer(ref this), pResource, pDesc, DestDescriptor); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(22)] + public void CreateSampler(SamplerDescription* pDesc, CpuDescriptorHandle* DestDescriptor) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[22]))((ID3D12Device*)Unsafe.AsPointer(ref this), pDesc, DestDescriptor); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[22]))((ID3D12Device*)Unsafe.AsPointer(ref this), pDesc, DestDescriptor); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(23)] + public void CopyDescriptors(uint NumDestDescriptorRanges, CpuDescriptorHandle* pDestDescriptorRangeStarts, uint* pDestDescriptorRangeSizes, uint NumSrcDescriptorRanges, CpuDescriptorHandle* pSrcDescriptorRangeStarts, uint* pSrcDescriptorRangeSizes, DescriptorHeapType DescriptorHeapsType) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[23]))((ID3D12Device*)Unsafe.AsPointer(ref this), NumDestDescriptorRanges, pDestDescriptorRangeStarts, pDestDescriptorRangeSizes, NumSrcDescriptorRanges, pSrcDescriptorRangeStarts, pSrcDescriptorRangeSizes, DescriptorHeapsType); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[23]))((ID3D12Device*)Unsafe.AsPointer(ref this), NumDestDescriptorRanges, pDestDescriptorRangeStarts, pDestDescriptorRangeSizes, NumSrcDescriptorRanges, pSrcDescriptorRangeStarts, pSrcDescriptorRangeSizes, DescriptorHeapsType); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(24)] + public void CopyDescriptorsSimple(uint NumDescriptors, CpuDescriptorHandle* DestDescriptorRangeStart, CpuDescriptorHandle* SrcDescriptorRangeStart, DescriptorHeapType DescriptorHeapsType) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[24]))((ID3D12Device*)Unsafe.AsPointer(ref this), NumDescriptors, DestDescriptorRangeStart, SrcDescriptorRangeStart, DescriptorHeapsType); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[24]))((ID3D12Device*)Unsafe.AsPointer(ref this), NumDescriptors, DestDescriptorRangeStart, SrcDescriptorRangeStart, DescriptorHeapsType); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(25)] + public Graphics.Direct3D12.ResourceAllocationInfo GetResourceAllocationInfo(uint visibleMask, uint numResourceDescs, ResourceDescription* pResourceDescs) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[25]))((ID3D12Device*)Unsafe.AsPointer(ref this), visibleMask, numResourceDescs, pResourceDescs); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[25]))((ID3D12Device*)Unsafe.AsPointer(ref this), visibleMask, numResourceDescs, pResourceDescs); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(26)] + public Graphics.Direct3D12.HeapProperties GetCustomHeapProperties(uint nodeMask, HeapType heapType) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[26]))((ID3D12Device*)Unsafe.AsPointer(ref this), nodeMask, heapType); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[26]))((ID3D12Device*)Unsafe.AsPointer(ref this), nodeMask, heapType); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(27)] + public HResult CreateCommittedResource(HeapProperties* pHeapProperties, HeapFlags HeapFlags, ResourceDescription* pDesc, ResourceStates InitialResourceState, ClearValue* pOptimizedClearValue, Guid* riidResource, void** ppvResource) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[27]))((ID3D12Device*)Unsafe.AsPointer(ref this), pHeapProperties, HeapFlags, pDesc, InitialResourceState, pOptimizedClearValue, riidResource, ppvResource); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[27]))((ID3D12Device*)Unsafe.AsPointer(ref this), pHeapProperties, HeapFlags, pDesc, InitialResourceState, pOptimizedClearValue, riidResource, ppvResource); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(28)] + public HResult CreateHeap(HeapDescription* pDesc, Guid* riid, void** ppvHeap) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[28]))((ID3D12Device*)Unsafe.AsPointer(ref this), pDesc, riid, ppvHeap); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[28]))((ID3D12Device*)Unsafe.AsPointer(ref this), pDesc, riid, ppvHeap); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(29)] + public HResult CreatePlacedResource(ID3D12Heap* pHeap, ulong HeapOffset, ResourceDescription* pDesc, ResourceStates InitialState, ClearValue* pOptimizedClearValue, Guid* riid, void** ppvResource) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[29]))((ID3D12Device*)Unsafe.AsPointer(ref this), pHeap, HeapOffset, pDesc, InitialState, pOptimizedClearValue, riid, ppvResource); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[29]))((ID3D12Device*)Unsafe.AsPointer(ref this), pHeap, HeapOffset, pDesc, InitialState, pOptimizedClearValue, riid, ppvResource); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(30)] + public HResult CreateReservedResource(ResourceDescription* pDesc, ResourceStates InitialState, ClearValue* pOptimizedClearValue, Guid* riid, void** ppvResource) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[30]))((ID3D12Device*)Unsafe.AsPointer(ref this), pDesc, InitialState, pOptimizedClearValue, riid, ppvResource); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[30]))((ID3D12Device*)Unsafe.AsPointer(ref this), pDesc, InitialState, pOptimizedClearValue, riid, ppvResource); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(31)] + public HResult CreateSharedHandle(ID3D12DeviceChild* pObject, Security.SECURITY_ATTRIBUTES* pAttributes, uint Access, char** Name, IntPtr* pHandle) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[31]))((ID3D12Device*)Unsafe.AsPointer(ref this), pObject, pAttributes, Access, Name, pHandle); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[31]))((ID3D12Device*)Unsafe.AsPointer(ref this), pObject, pAttributes, Access, Name, pHandle); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(32)] + public HResult OpenSharedHandle(IntPtr NTHandle, Guid* riid, void** ppvObj) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[32]))((ID3D12Device*)Unsafe.AsPointer(ref this), NTHandle, riid, ppvObj); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[32]))((ID3D12Device*)Unsafe.AsPointer(ref this), NTHandle, riid, ppvObj); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(33)] + public HResult OpenSharedHandleByName(char** Name, uint Access, IntPtr* pNTHandle) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[33]))((ID3D12Device*)Unsafe.AsPointer(ref this), Name, Access, pNTHandle); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[33]))((ID3D12Device*)Unsafe.AsPointer(ref this), Name, Access, pNTHandle); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(34)] + public HResult MakeResident(uint NumObjects, ID3D12Pageable* ppObjects) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[34]))((ID3D12Device*)Unsafe.AsPointer(ref this), NumObjects, ppObjects); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[34]))((ID3D12Device*)Unsafe.AsPointer(ref this), NumObjects, ppObjects); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(35)] + public HResult Evict(uint NumObjects, ID3D12Pageable* ppObjects) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[35]))((ID3D12Device*)Unsafe.AsPointer(ref this), NumObjects, ppObjects); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[35]))((ID3D12Device*)Unsafe.AsPointer(ref this), NumObjects, ppObjects); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(36)] + public HResult CreateFence(ulong InitialValue, FenceFlags Flags, Guid* riid, void** ppFence) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[36]))((ID3D12Device*)Unsafe.AsPointer(ref this), InitialValue, Flags, riid, ppFence); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[36]))((ID3D12Device*)Unsafe.AsPointer(ref this), InitialValue, Flags, riid, ppFence); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(37)] + public HResult GetDeviceRemovedReason() + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[37]))((ID3D12Device*)Unsafe.AsPointer(ref this)); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[37]))((ID3D12Device*)Unsafe.AsPointer(ref this)); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(38)] + public void GetCopyableFootprints(ResourceDescription* pResourceDesc, uint FirstSubresource, uint NumSubresources, ulong BaseOffset, PlacedSubresourceFootprint* pLayouts, uint* pNumRows, ulong* pRowSizeInBytes, ulong* pTotalBytes) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[38]))((ID3D12Device*)Unsafe.AsPointer(ref this), pResourceDesc, FirstSubresource, NumSubresources, BaseOffset, pLayouts, pNumRows, pRowSizeInBytes, pTotalBytes); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[38]))((ID3D12Device*)Unsafe.AsPointer(ref this), pResourceDesc, FirstSubresource, NumSubresources, BaseOffset, pLayouts, pNumRows, pRowSizeInBytes, pTotalBytes); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(39)] + public HResult CreateQueryHeap(QueryHeapDescription* pDesc, Guid* riid, void** ppvHeap) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[39]))((ID3D12Device*)Unsafe.AsPointer(ref this), pDesc, riid, ppvHeap); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[39]))((ID3D12Device*)Unsafe.AsPointer(ref this), pDesc, riid, ppvHeap); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(40)] + public HResult SetStablePowerState(Bool32 Enable) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[40]))((ID3D12Device*)Unsafe.AsPointer(ref this), Enable); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[40]))((ID3D12Device*)Unsafe.AsPointer(ref this), Enable); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(41)] + public HResult CreateCommandSignature(CommandSignatureDescription* pDesc, ID3D12RootSignature* pRootSignature, Guid* riid, void** ppvCommandSignature) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[41]))((ID3D12Device*)Unsafe.AsPointer(ref this), pDesc, pRootSignature, riid, ppvCommandSignature); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[41]))((ID3D12Device*)Unsafe.AsPointer(ref this), pDesc, pRootSignature, riid, ppvCommandSignature); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(42)] + public void GetResourceTiling(ID3D12Resource* pTiledResource, uint* pNumTilesForEntireResource, PackedMipInfo* pPackedMipDesc, TileShape* pStandardTileShapeForNonPackedMips, uint* pNumSubresourceTilings, uint FirstSubresourceTilingToGet, SubresourceTiling* pSubresourceTilingsForNonPackedMips) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[42]))((ID3D12Device*)Unsafe.AsPointer(ref this), pTiledResource, pNumTilesForEntireResource, pPackedMipDesc, pStandardTileShapeForNonPackedMips, pNumSubresourceTilings, FirstSubresourceTilingToGet, pSubresourceTilingsForNonPackedMips); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[42]))((ID3D12Device*)Unsafe.AsPointer(ref this), pTiledResource, pNumTilesForEntireResource, pPackedMipDesc, pStandardTileShapeForNonPackedMips, pNumSubresourceTilings, FirstSubresourceTilingToGet, pSubresourceTilingsForNonPackedMips); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(43)] + public Luid GetAdapterLuid() + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[43]))((ID3D12Device*)Unsafe.AsPointer(ref this)); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[43]))((ID3D12Device*)Unsafe.AsPointer(ref this)); +#endif + } + + public interface Interface : ID3D12Object.Interface + { + } +} + +/// +/// ID3D12PipelineLibrary +[Guid("c64226a8-9201-46af-b4cc-53fb9ff7414f")] +[NativeTypeName("struct ID3D12PipelineLibrary : ID3D12DeviceChild")] +[NativeInheritance("ID3D12DeviceChild")] +public unsafe partial struct ID3D12PipelineLibrary : ID3D12PipelineLibrary.Interface +{ + public static ref readonly Guid IID_ID3D12PipelineLibrary + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0xA8, 0x26, 0x42, 0xC6, + 0x01, 0x92, + 0xAF, 0x46, + 0xB4, + 0xCC, + 0x53, + 0xFB, + 0x9F, + 0xF7, + 0x41, + 0x4F + }; + + 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_ID3D12PipelineLibrary)); + + 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 GetDevice(Guid* riid, void** ppvDevice) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[3]))((ID3D12PipelineLibrary*)Unsafe.AsPointer(ref this), riid, ppvDevice); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((ID3D12PipelineLibrary*)Unsafe.AsPointer(ref this), riid, ppvDevice); +#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]))((ID3D12PipelineLibrary*)Unsafe.AsPointer(ref this), guid, pDataSize, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((ID3D12PipelineLibrary*)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]))((ID3D12PipelineLibrary*)Unsafe.AsPointer(ref this), guid, DataSize, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((ID3D12PipelineLibrary*)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]))((ID3D12PipelineLibrary*)Unsafe.AsPointer(ref this), guid, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((ID3D12PipelineLibrary*)Unsafe.AsPointer(ref this), guid, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(7)] + public HResult SetName(char** Name) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[7]))((ID3D12PipelineLibrary*)Unsafe.AsPointer(ref this), Name); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((ID3D12PipelineLibrary*)Unsafe.AsPointer(ref this), Name); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(8)] + public HResult StorePipeline(char** pName, ID3D12PipelineState* pPipeline) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[8]))((ID3D12PipelineLibrary*)Unsafe.AsPointer(ref this), pName, pPipeline); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[8]))((ID3D12PipelineLibrary*)Unsafe.AsPointer(ref this), pName, pPipeline); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(9)] + public HResult LoadGraphicsPipeline(char** pName, GraphicsPipelineStateDescription* pDesc, Guid* riid, void** ppPipelineState) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[9]))((ID3D12PipelineLibrary*)Unsafe.AsPointer(ref this), pName, pDesc, riid, ppPipelineState); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[9]))((ID3D12PipelineLibrary*)Unsafe.AsPointer(ref this), pName, pDesc, riid, ppPipelineState); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(10)] + public HResult LoadComputePipeline(char** pName, ComputePipelineStateDescription* pDesc, Guid* riid, void** ppPipelineState) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[10]))((ID3D12PipelineLibrary*)Unsafe.AsPointer(ref this), pName, pDesc, riid, ppPipelineState); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[10]))((ID3D12PipelineLibrary*)Unsafe.AsPointer(ref this), pName, pDesc, riid, ppPipelineState); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(11)] + public nuint GetSerializedSize() + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[11]))((ID3D12PipelineLibrary*)Unsafe.AsPointer(ref this)); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[11]))((ID3D12PipelineLibrary*)Unsafe.AsPointer(ref this)); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(12)] + public HResult Serialize(void* pData, nuint DataSizeInBytes) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[12]))((ID3D12PipelineLibrary*)Unsafe.AsPointer(ref this), pData, DataSizeInBytes); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[12]))((ID3D12PipelineLibrary*)Unsafe.AsPointer(ref this), pData, DataSizeInBytes); +#endif + } + + public interface Interface : ID3D12DeviceChild.Interface + { + } +} + +/// +/// ID3D12PipelineLibrary1 +[Guid("80eabf42-2568-4e5e-bd82-c37f86961dc3")] +[NativeTypeName("struct ID3D12PipelineLibrary1 : ID3D12PipelineLibrary")] +[NativeInheritance("ID3D12PipelineLibrary")] +public unsafe partial struct ID3D12PipelineLibrary1 : ID3D12PipelineLibrary1.Interface +{ + public static ref readonly Guid IID_ID3D12PipelineLibrary1 + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x42, 0xBF, 0xEA, 0x80, + 0x68, 0x25, + 0x5E, 0x4E, + 0xBD, + 0x82, + 0xC3, + 0x7F, + 0x86, + 0x96, + 0x1D, + 0xC3 + }; + + 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_ID3D12PipelineLibrary1)); + + 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 StorePipeline(char** pName, ID3D12PipelineState* pPipeline) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[3]))((ID3D12PipelineLibrary1*)Unsafe.AsPointer(ref this), pName, pPipeline); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((ID3D12PipelineLibrary1*)Unsafe.AsPointer(ref this), pName, pPipeline); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public HResult LoadGraphicsPipeline(char** pName, GraphicsPipelineStateDescription* pDesc, Guid* riid, void** ppPipelineState) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[4]))((ID3D12PipelineLibrary1*)Unsafe.AsPointer(ref this), pName, pDesc, riid, ppPipelineState); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((ID3D12PipelineLibrary1*)Unsafe.AsPointer(ref this), pName, pDesc, riid, ppPipelineState); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(5)] + public HResult LoadComputePipeline(char** pName, ComputePipelineStateDescription* pDesc, Guid* riid, void** ppPipelineState) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[5]))((ID3D12PipelineLibrary1*)Unsafe.AsPointer(ref this), pName, pDesc, riid, ppPipelineState); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((ID3D12PipelineLibrary1*)Unsafe.AsPointer(ref this), pName, pDesc, riid, ppPipelineState); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(6)] + public nuint GetSerializedSize() + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[6]))((ID3D12PipelineLibrary1*)Unsafe.AsPointer(ref this)); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((ID3D12PipelineLibrary1*)Unsafe.AsPointer(ref this)); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(7)] + public HResult Serialize(void* pData, nuint DataSizeInBytes) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[7]))((ID3D12PipelineLibrary1*)Unsafe.AsPointer(ref this), pData, DataSizeInBytes); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((ID3D12PipelineLibrary1*)Unsafe.AsPointer(ref this), pData, DataSizeInBytes); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(8)] + public HResult GetDevice(Guid* riid, void** ppvDevice) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[8]))((ID3D12PipelineLibrary1*)Unsafe.AsPointer(ref this), riid, ppvDevice); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[8]))((ID3D12PipelineLibrary1*)Unsafe.AsPointer(ref this), riid, ppvDevice); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(9)] + public HResult GetPrivateData(Guid* guid, uint* pDataSize, void* pData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[9]))((ID3D12PipelineLibrary1*)Unsafe.AsPointer(ref this), guid, pDataSize, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[9]))((ID3D12PipelineLibrary1*)Unsafe.AsPointer(ref this), guid, pDataSize, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(10)] + public HResult SetPrivateData(Guid* guid, uint DataSize, void* pData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[10]))((ID3D12PipelineLibrary1*)Unsafe.AsPointer(ref this), guid, DataSize, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[10]))((ID3D12PipelineLibrary1*)Unsafe.AsPointer(ref this), guid, DataSize, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(11)] + public HResult SetPrivateDataInterface(Guid* guid, IUnknown* pData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[11]))((ID3D12PipelineLibrary1*)Unsafe.AsPointer(ref this), guid, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[11]))((ID3D12PipelineLibrary1*)Unsafe.AsPointer(ref this), guid, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(12)] + public HResult SetName(char** Name) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[12]))((ID3D12PipelineLibrary1*)Unsafe.AsPointer(ref this), Name); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[12]))((ID3D12PipelineLibrary1*)Unsafe.AsPointer(ref this), Name); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(13)] + public HResult LoadPipeline(char** pName, PipelineStateStreamDescription* pDesc, Guid* riid, void** ppPipelineState) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[13]))((ID3D12PipelineLibrary1*)Unsafe.AsPointer(ref this), pName, pDesc, riid, ppPipelineState); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[13]))((ID3D12PipelineLibrary1*)Unsafe.AsPointer(ref this), pName, pDesc, riid, ppPipelineState); +#endif + } + + public interface Interface : ID3D12PipelineLibrary.Interface + { + } +} + +/// +/// ID3D12Device1 +[Guid("77acce80-638e-4e65-8895-c1f23386863e")] +[NativeTypeName("struct ID3D12Device1 : ID3D12Device")] +[NativeInheritance("ID3D12Device")] +public unsafe partial struct ID3D12Device1 : ID3D12Device1.Interface +{ + public static ref readonly Guid IID_ID3D12Device1 + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x80, 0xCE, 0xAC, 0x77, + 0x8E, 0x63, + 0x65, 0x4E, + 0x88, + 0x95, + 0xC1, + 0xF2, + 0x33, + 0x86, + 0x86, + 0x3E + }; + + 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_ID3D12Device1)); + + 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 GetNodeCount() + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[3]))((ID3D12Device1*)Unsafe.AsPointer(ref this)); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((ID3D12Device1*)Unsafe.AsPointer(ref this)); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public HResult CreateCommandQueue(CommandQueueDescription* pDesc, Guid* riid, void** ppCommandQueue) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[4]))((ID3D12Device1*)Unsafe.AsPointer(ref this), pDesc, riid, ppCommandQueue); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((ID3D12Device1*)Unsafe.AsPointer(ref this), pDesc, riid, ppCommandQueue); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(5)] + public HResult CreateCommandAllocator(CommandListType type, Guid* riid, void** ppCommandAllocator) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[5]))((ID3D12Device1*)Unsafe.AsPointer(ref this), type, riid, ppCommandAllocator); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((ID3D12Device1*)Unsafe.AsPointer(ref this), type, riid, ppCommandAllocator); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(6)] + public HResult CreateGraphicsPipelineState(GraphicsPipelineStateDescription* pDesc, Guid* riid, void** ppPipelineState) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[6]))((ID3D12Device1*)Unsafe.AsPointer(ref this), pDesc, riid, ppPipelineState); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((ID3D12Device1*)Unsafe.AsPointer(ref this), pDesc, riid, ppPipelineState); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(7)] + public HResult CreateComputePipelineState(ComputePipelineStateDescription* pDesc, Guid* riid, void** ppPipelineState) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[7]))((ID3D12Device1*)Unsafe.AsPointer(ref this), pDesc, riid, ppPipelineState); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((ID3D12Device1*)Unsafe.AsPointer(ref this), pDesc, riid, ppPipelineState); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(8)] + public HResult CreateCommandList(uint nodeMask, CommandListType type, ID3D12CommandAllocator* pCommandAllocator, ID3D12PipelineState* pInitialState, Guid* riid, void** ppCommandList) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[8]))((ID3D12Device1*)Unsafe.AsPointer(ref this), nodeMask, type, pCommandAllocator, pInitialState, riid, ppCommandList); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[8]))((ID3D12Device1*)Unsafe.AsPointer(ref this), nodeMask, type, pCommandAllocator, pInitialState, riid, ppCommandList); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(9)] + public HResult CheckFeatureSupport(Feature Feature, void* pFeatureSupportData, uint FeatureSupportDataSize) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[9]))((ID3D12Device1*)Unsafe.AsPointer(ref this), Feature, pFeatureSupportData, FeatureSupportDataSize); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[9]))((ID3D12Device1*)Unsafe.AsPointer(ref this), Feature, pFeatureSupportData, FeatureSupportDataSize); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(10)] + public HResult CreateDescriptorHeap(DescriptorHeapDescription* pDescriptorHeapDesc, Guid* riid, void** ppvHeap) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[10]))((ID3D12Device1*)Unsafe.AsPointer(ref this), pDescriptorHeapDesc, riid, ppvHeap); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[10]))((ID3D12Device1*)Unsafe.AsPointer(ref this), pDescriptorHeapDesc, riid, ppvHeap); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(11)] + public uint GetDescriptorHandleIncrementSize(DescriptorHeapType DescriptorHeapType) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[11]))((ID3D12Device1*)Unsafe.AsPointer(ref this), DescriptorHeapType); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[11]))((ID3D12Device1*)Unsafe.AsPointer(ref this), DescriptorHeapType); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(12)] + public HResult CreateRootSignature(uint nodeMask, void* pBlobWithRootSignature, nuint blobLengthInBytes, Guid* riid, void** ppvRootSignature) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[12]))((ID3D12Device1*)Unsafe.AsPointer(ref this), nodeMask, pBlobWithRootSignature, blobLengthInBytes, riid, ppvRootSignature); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[12]))((ID3D12Device1*)Unsafe.AsPointer(ref this), nodeMask, pBlobWithRootSignature, blobLengthInBytes, riid, ppvRootSignature); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(13)] + public void CreateConstantBufferView(ConstantBufferViewDescription* pDesc, CpuDescriptorHandle* DestDescriptor) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[13]))((ID3D12Device1*)Unsafe.AsPointer(ref this), pDesc, DestDescriptor); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[13]))((ID3D12Device1*)Unsafe.AsPointer(ref this), pDesc, DestDescriptor); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(14)] + public void CreateShaderResourceView(ID3D12Resource* pResource, ShaderResourceViewDescription* pDesc, CpuDescriptorHandle* DestDescriptor) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[14]))((ID3D12Device1*)Unsafe.AsPointer(ref this), pResource, pDesc, DestDescriptor); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[14]))((ID3D12Device1*)Unsafe.AsPointer(ref this), pResource, pDesc, DestDescriptor); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(15)] + public void CreateUnorderedAccessView(ID3D12Resource* pResource, ID3D12Resource* pCounterResource, UnorderedAccessViewDescription* pDesc, CpuDescriptorHandle* DestDescriptor) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[15]))((ID3D12Device1*)Unsafe.AsPointer(ref this), pResource, pCounterResource, pDesc, DestDescriptor); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[15]))((ID3D12Device1*)Unsafe.AsPointer(ref this), pResource, pCounterResource, pDesc, DestDescriptor); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(16)] + public void CreateRenderTargetView(ID3D12Resource* pResource, RenderTargetViewDescription* pDesc, CpuDescriptorHandle* DestDescriptor) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[16]))((ID3D12Device1*)Unsafe.AsPointer(ref this), pResource, pDesc, DestDescriptor); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[16]))((ID3D12Device1*)Unsafe.AsPointer(ref this), pResource, pDesc, DestDescriptor); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(17)] + public void CreateDepthStencilView(ID3D12Resource* pResource, DepthStencilViewDescription* pDesc, CpuDescriptorHandle* DestDescriptor) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[17]))((ID3D12Device1*)Unsafe.AsPointer(ref this), pResource, pDesc, DestDescriptor); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[17]))((ID3D12Device1*)Unsafe.AsPointer(ref this), pResource, pDesc, DestDescriptor); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(18)] + public void CreateSampler(SamplerDescription* pDesc, CpuDescriptorHandle* DestDescriptor) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[18]))((ID3D12Device1*)Unsafe.AsPointer(ref this), pDesc, DestDescriptor); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[18]))((ID3D12Device1*)Unsafe.AsPointer(ref this), pDesc, DestDescriptor); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(19)] + public void CopyDescriptors(uint NumDestDescriptorRanges, CpuDescriptorHandle* pDestDescriptorRangeStarts, uint* pDestDescriptorRangeSizes, uint NumSrcDescriptorRanges, CpuDescriptorHandle* pSrcDescriptorRangeStarts, uint* pSrcDescriptorRangeSizes, DescriptorHeapType DescriptorHeapsType) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[19]))((ID3D12Device1*)Unsafe.AsPointer(ref this), NumDestDescriptorRanges, pDestDescriptorRangeStarts, pDestDescriptorRangeSizes, NumSrcDescriptorRanges, pSrcDescriptorRangeStarts, pSrcDescriptorRangeSizes, DescriptorHeapsType); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[19]))((ID3D12Device1*)Unsafe.AsPointer(ref this), NumDestDescriptorRanges, pDestDescriptorRangeStarts, pDestDescriptorRangeSizes, NumSrcDescriptorRanges, pSrcDescriptorRangeStarts, pSrcDescriptorRangeSizes, DescriptorHeapsType); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(20)] + public void CopyDescriptorsSimple(uint NumDescriptors, CpuDescriptorHandle* DestDescriptorRangeStart, CpuDescriptorHandle* SrcDescriptorRangeStart, DescriptorHeapType DescriptorHeapsType) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[20]))((ID3D12Device1*)Unsafe.AsPointer(ref this), NumDescriptors, DestDescriptorRangeStart, SrcDescriptorRangeStart, DescriptorHeapsType); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[20]))((ID3D12Device1*)Unsafe.AsPointer(ref this), NumDescriptors, DestDescriptorRangeStart, SrcDescriptorRangeStart, DescriptorHeapsType); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(21)] + public Graphics.Direct3D12.ResourceAllocationInfo GetResourceAllocationInfo(uint visibleMask, uint numResourceDescs, ResourceDescription* pResourceDescs) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[21]))((ID3D12Device1*)Unsafe.AsPointer(ref this), visibleMask, numResourceDescs, pResourceDescs); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[21]))((ID3D12Device1*)Unsafe.AsPointer(ref this), visibleMask, numResourceDescs, pResourceDescs); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(22)] + public Graphics.Direct3D12.HeapProperties GetCustomHeapProperties(uint nodeMask, HeapType heapType) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[22]))((ID3D12Device1*)Unsafe.AsPointer(ref this), nodeMask, heapType); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[22]))((ID3D12Device1*)Unsafe.AsPointer(ref this), nodeMask, heapType); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(23)] + public HResult CreateCommittedResource(HeapProperties* pHeapProperties, HeapFlags HeapFlags, ResourceDescription* pDesc, ResourceStates InitialResourceState, ClearValue* pOptimizedClearValue, Guid* riidResource, void** ppvResource) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[23]))((ID3D12Device1*)Unsafe.AsPointer(ref this), pHeapProperties, HeapFlags, pDesc, InitialResourceState, pOptimizedClearValue, riidResource, ppvResource); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[23]))((ID3D12Device1*)Unsafe.AsPointer(ref this), pHeapProperties, HeapFlags, pDesc, InitialResourceState, pOptimizedClearValue, riidResource, ppvResource); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(24)] + public HResult CreateHeap(HeapDescription* pDesc, Guid* riid, void** ppvHeap) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[24]))((ID3D12Device1*)Unsafe.AsPointer(ref this), pDesc, riid, ppvHeap); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[24]))((ID3D12Device1*)Unsafe.AsPointer(ref this), pDesc, riid, ppvHeap); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(25)] + public HResult CreatePlacedResource(ID3D12Heap* pHeap, ulong HeapOffset, ResourceDescription* pDesc, ResourceStates InitialState, ClearValue* pOptimizedClearValue, Guid* riid, void** ppvResource) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[25]))((ID3D12Device1*)Unsafe.AsPointer(ref this), pHeap, HeapOffset, pDesc, InitialState, pOptimizedClearValue, riid, ppvResource); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[25]))((ID3D12Device1*)Unsafe.AsPointer(ref this), pHeap, HeapOffset, pDesc, InitialState, pOptimizedClearValue, riid, ppvResource); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(26)] + public HResult CreateReservedResource(ResourceDescription* pDesc, ResourceStates InitialState, ClearValue* pOptimizedClearValue, Guid* riid, void** ppvResource) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[26]))((ID3D12Device1*)Unsafe.AsPointer(ref this), pDesc, InitialState, pOptimizedClearValue, riid, ppvResource); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[26]))((ID3D12Device1*)Unsafe.AsPointer(ref this), pDesc, InitialState, pOptimizedClearValue, riid, ppvResource); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(27)] + public HResult CreateSharedHandle(ID3D12DeviceChild* pObject, Security.SECURITY_ATTRIBUTES* pAttributes, uint Access, char** Name, IntPtr* pHandle) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[27]))((ID3D12Device1*)Unsafe.AsPointer(ref this), pObject, pAttributes, Access, Name, pHandle); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[27]))((ID3D12Device1*)Unsafe.AsPointer(ref this), pObject, pAttributes, Access, Name, pHandle); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(28)] + public HResult OpenSharedHandle(IntPtr NTHandle, Guid* riid, void** ppvObj) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[28]))((ID3D12Device1*)Unsafe.AsPointer(ref this), NTHandle, riid, ppvObj); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[28]))((ID3D12Device1*)Unsafe.AsPointer(ref this), NTHandle, riid, ppvObj); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(29)] + public HResult OpenSharedHandleByName(char** Name, uint Access, IntPtr* pNTHandle) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[29]))((ID3D12Device1*)Unsafe.AsPointer(ref this), Name, Access, pNTHandle); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[29]))((ID3D12Device1*)Unsafe.AsPointer(ref this), Name, Access, pNTHandle); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(30)] + public HResult MakeResident(uint NumObjects, ID3D12Pageable* ppObjects) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[30]))((ID3D12Device1*)Unsafe.AsPointer(ref this), NumObjects, ppObjects); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[30]))((ID3D12Device1*)Unsafe.AsPointer(ref this), NumObjects, ppObjects); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(31)] + public HResult Evict(uint NumObjects, ID3D12Pageable* ppObjects) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[31]))((ID3D12Device1*)Unsafe.AsPointer(ref this), NumObjects, ppObjects); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[31]))((ID3D12Device1*)Unsafe.AsPointer(ref this), NumObjects, ppObjects); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(32)] + public HResult CreateFence(ulong InitialValue, FenceFlags Flags, Guid* riid, void** ppFence) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[32]))((ID3D12Device1*)Unsafe.AsPointer(ref this), InitialValue, Flags, riid, ppFence); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[32]))((ID3D12Device1*)Unsafe.AsPointer(ref this), InitialValue, Flags, riid, ppFence); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(33)] + public HResult GetDeviceRemovedReason() + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[33]))((ID3D12Device1*)Unsafe.AsPointer(ref this)); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[33]))((ID3D12Device1*)Unsafe.AsPointer(ref this)); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(34)] + public void GetCopyableFootprints(ResourceDescription* pResourceDesc, uint FirstSubresource, uint NumSubresources, ulong BaseOffset, PlacedSubresourceFootprint* pLayouts, uint* pNumRows, ulong* pRowSizeInBytes, ulong* pTotalBytes) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[34]))((ID3D12Device1*)Unsafe.AsPointer(ref this), pResourceDesc, FirstSubresource, NumSubresources, BaseOffset, pLayouts, pNumRows, pRowSizeInBytes, pTotalBytes); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[34]))((ID3D12Device1*)Unsafe.AsPointer(ref this), pResourceDesc, FirstSubresource, NumSubresources, BaseOffset, pLayouts, pNumRows, pRowSizeInBytes, pTotalBytes); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(35)] + public HResult CreateQueryHeap(QueryHeapDescription* pDesc, Guid* riid, void** ppvHeap) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[35]))((ID3D12Device1*)Unsafe.AsPointer(ref this), pDesc, riid, ppvHeap); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[35]))((ID3D12Device1*)Unsafe.AsPointer(ref this), pDesc, riid, ppvHeap); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(36)] + public HResult SetStablePowerState(Bool32 Enable) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[36]))((ID3D12Device1*)Unsafe.AsPointer(ref this), Enable); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[36]))((ID3D12Device1*)Unsafe.AsPointer(ref this), Enable); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(37)] + public HResult CreateCommandSignature(CommandSignatureDescription* pDesc, ID3D12RootSignature* pRootSignature, Guid* riid, void** ppvCommandSignature) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[37]))((ID3D12Device1*)Unsafe.AsPointer(ref this), pDesc, pRootSignature, riid, ppvCommandSignature); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[37]))((ID3D12Device1*)Unsafe.AsPointer(ref this), pDesc, pRootSignature, riid, ppvCommandSignature); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(38)] + public void GetResourceTiling(ID3D12Resource* pTiledResource, uint* pNumTilesForEntireResource, PackedMipInfo* pPackedMipDesc, TileShape* pStandardTileShapeForNonPackedMips, uint* pNumSubresourceTilings, uint FirstSubresourceTilingToGet, SubresourceTiling* pSubresourceTilingsForNonPackedMips) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[38]))((ID3D12Device1*)Unsafe.AsPointer(ref this), pTiledResource, pNumTilesForEntireResource, pPackedMipDesc, pStandardTileShapeForNonPackedMips, pNumSubresourceTilings, FirstSubresourceTilingToGet, pSubresourceTilingsForNonPackedMips); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[38]))((ID3D12Device1*)Unsafe.AsPointer(ref this), pTiledResource, pNumTilesForEntireResource, pPackedMipDesc, pStandardTileShapeForNonPackedMips, pNumSubresourceTilings, FirstSubresourceTilingToGet, pSubresourceTilingsForNonPackedMips); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(39)] + public Luid GetAdapterLuid() + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[39]))((ID3D12Device1*)Unsafe.AsPointer(ref this)); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[39]))((ID3D12Device1*)Unsafe.AsPointer(ref this)); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(40)] + public HResult GetPrivateData(Guid* guid, uint* pDataSize, void* pData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[40]))((ID3D12Device1*)Unsafe.AsPointer(ref this), guid, pDataSize, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[40]))((ID3D12Device1*)Unsafe.AsPointer(ref this), guid, pDataSize, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(41)] + public HResult SetPrivateData(Guid* guid, uint DataSize, void* pData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[41]))((ID3D12Device1*)Unsafe.AsPointer(ref this), guid, DataSize, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[41]))((ID3D12Device1*)Unsafe.AsPointer(ref this), guid, DataSize, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(42)] + public HResult SetPrivateDataInterface(Guid* guid, IUnknown* pData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[42]))((ID3D12Device1*)Unsafe.AsPointer(ref this), guid, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[42]))((ID3D12Device1*)Unsafe.AsPointer(ref this), guid, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(43)] + public HResult SetName(char** Name) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[43]))((ID3D12Device1*)Unsafe.AsPointer(ref this), Name); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[43]))((ID3D12Device1*)Unsafe.AsPointer(ref this), Name); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(44)] + public HResult CreatePipelineLibrary(void* pLibraryBlob, nuint BlobLength, Guid* riid, void** ppPipelineLibrary) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[44]))((ID3D12Device1*)Unsafe.AsPointer(ref this), pLibraryBlob, BlobLength, riid, ppPipelineLibrary); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[44]))((ID3D12Device1*)Unsafe.AsPointer(ref this), pLibraryBlob, BlobLength, riid, ppPipelineLibrary); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(45)] + public HResult SetEventOnMultipleFenceCompletion(ID3D12Fence* ppFences, ulong* pFenceValues, uint NumFences, MultipleFenceWaitFlags Flags, IntPtr hEvent) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[45]))((ID3D12Device1*)Unsafe.AsPointer(ref this), ppFences, pFenceValues, NumFences, Flags, hEvent); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[45]))((ID3D12Device1*)Unsafe.AsPointer(ref this), ppFences, pFenceValues, NumFences, Flags, hEvent); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(46)] + public HResult SetResidencyPriority(uint NumObjects, ID3D12Pageable* ppObjects, ResidencyPriority* pPriorities) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[46]))((ID3D12Device1*)Unsafe.AsPointer(ref this), NumObjects, ppObjects, pPriorities); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[46]))((ID3D12Device1*)Unsafe.AsPointer(ref this), NumObjects, ppObjects, pPriorities); +#endif + } + + public interface Interface : ID3D12Device.Interface + { + } +} + +/// +/// ID3D12Device2 +[Guid("30baa41e-b15b-475c-a0bb-1af5c5b64328")] +[NativeTypeName("struct ID3D12Device2 : ID3D12Device1")] +[NativeInheritance("ID3D12Device1")] +public unsafe partial struct ID3D12Device2 : ID3D12Device2.Interface +{ + public static ref readonly Guid IID_ID3D12Device2 + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x1E, 0xA4, 0xBA, 0x30, + 0x5B, 0xB1, + 0x5C, 0x47, + 0xA0, + 0xBB, + 0x1A, + 0xF5, + 0xC5, + 0xB6, + 0x43, + 0x28 + }; + + 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_ID3D12Device2)); + + 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 CreatePipelineLibrary(void* pLibraryBlob, nuint BlobLength, Guid* riid, void** ppPipelineLibrary) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[3]))((ID3D12Device2*)Unsafe.AsPointer(ref this), pLibraryBlob, BlobLength, riid, ppPipelineLibrary); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((ID3D12Device2*)Unsafe.AsPointer(ref this), pLibraryBlob, BlobLength, riid, ppPipelineLibrary); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public HResult SetEventOnMultipleFenceCompletion(ID3D12Fence* ppFences, ulong* pFenceValues, uint NumFences, MultipleFenceWaitFlags Flags, IntPtr hEvent) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[4]))((ID3D12Device2*)Unsafe.AsPointer(ref this), ppFences, pFenceValues, NumFences, Flags, hEvent); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((ID3D12Device2*)Unsafe.AsPointer(ref this), ppFences, pFenceValues, NumFences, Flags, hEvent); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(5)] + public HResult SetResidencyPriority(uint NumObjects, ID3D12Pageable* ppObjects, ResidencyPriority* pPriorities) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[5]))((ID3D12Device2*)Unsafe.AsPointer(ref this), NumObjects, ppObjects, pPriorities); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((ID3D12Device2*)Unsafe.AsPointer(ref this), NumObjects, ppObjects, pPriorities); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(6)] + public uint GetNodeCount() + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[6]))((ID3D12Device2*)Unsafe.AsPointer(ref this)); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((ID3D12Device2*)Unsafe.AsPointer(ref this)); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(7)] + public HResult CreateCommandQueue(CommandQueueDescription* pDesc, Guid* riid, void** ppCommandQueue) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[7]))((ID3D12Device2*)Unsafe.AsPointer(ref this), pDesc, riid, ppCommandQueue); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((ID3D12Device2*)Unsafe.AsPointer(ref this), pDesc, riid, ppCommandQueue); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(8)] + public HResult CreateCommandAllocator(CommandListType type, Guid* riid, void** ppCommandAllocator) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[8]))((ID3D12Device2*)Unsafe.AsPointer(ref this), type, riid, ppCommandAllocator); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[8]))((ID3D12Device2*)Unsafe.AsPointer(ref this), type, riid, ppCommandAllocator); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(9)] + public HResult CreateGraphicsPipelineState(GraphicsPipelineStateDescription* pDesc, Guid* riid, void** ppPipelineState) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[9]))((ID3D12Device2*)Unsafe.AsPointer(ref this), pDesc, riid, ppPipelineState); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[9]))((ID3D12Device2*)Unsafe.AsPointer(ref this), pDesc, riid, ppPipelineState); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(10)] + public HResult CreateComputePipelineState(ComputePipelineStateDescription* pDesc, Guid* riid, void** ppPipelineState) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[10]))((ID3D12Device2*)Unsafe.AsPointer(ref this), pDesc, riid, ppPipelineState); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[10]))((ID3D12Device2*)Unsafe.AsPointer(ref this), pDesc, riid, ppPipelineState); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(11)] + public HResult CreateCommandList(uint nodeMask, CommandListType type, ID3D12CommandAllocator* pCommandAllocator, ID3D12PipelineState* pInitialState, Guid* riid, void** ppCommandList) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[11]))((ID3D12Device2*)Unsafe.AsPointer(ref this), nodeMask, type, pCommandAllocator, pInitialState, riid, ppCommandList); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[11]))((ID3D12Device2*)Unsafe.AsPointer(ref this), nodeMask, type, pCommandAllocator, pInitialState, riid, ppCommandList); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(12)] + public HResult CheckFeatureSupport(Feature Feature, void* pFeatureSupportData, uint FeatureSupportDataSize) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[12]))((ID3D12Device2*)Unsafe.AsPointer(ref this), Feature, pFeatureSupportData, FeatureSupportDataSize); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[12]))((ID3D12Device2*)Unsafe.AsPointer(ref this), Feature, pFeatureSupportData, FeatureSupportDataSize); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(13)] + public HResult CreateDescriptorHeap(DescriptorHeapDescription* pDescriptorHeapDesc, Guid* riid, void** ppvHeap) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[13]))((ID3D12Device2*)Unsafe.AsPointer(ref this), pDescriptorHeapDesc, riid, ppvHeap); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[13]))((ID3D12Device2*)Unsafe.AsPointer(ref this), pDescriptorHeapDesc, riid, ppvHeap); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(14)] + public uint GetDescriptorHandleIncrementSize(DescriptorHeapType DescriptorHeapType) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[14]))((ID3D12Device2*)Unsafe.AsPointer(ref this), DescriptorHeapType); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[14]))((ID3D12Device2*)Unsafe.AsPointer(ref this), DescriptorHeapType); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(15)] + public HResult CreateRootSignature(uint nodeMask, void* pBlobWithRootSignature, nuint blobLengthInBytes, Guid* riid, void** ppvRootSignature) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[15]))((ID3D12Device2*)Unsafe.AsPointer(ref this), nodeMask, pBlobWithRootSignature, blobLengthInBytes, riid, ppvRootSignature); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[15]))((ID3D12Device2*)Unsafe.AsPointer(ref this), nodeMask, pBlobWithRootSignature, blobLengthInBytes, riid, ppvRootSignature); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(16)] + public void CreateConstantBufferView(ConstantBufferViewDescription* pDesc, CpuDescriptorHandle* DestDescriptor) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[16]))((ID3D12Device2*)Unsafe.AsPointer(ref this), pDesc, DestDescriptor); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[16]))((ID3D12Device2*)Unsafe.AsPointer(ref this), pDesc, DestDescriptor); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(17)] + public void CreateShaderResourceView(ID3D12Resource* pResource, ShaderResourceViewDescription* pDesc, CpuDescriptorHandle* DestDescriptor) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[17]))((ID3D12Device2*)Unsafe.AsPointer(ref this), pResource, pDesc, DestDescriptor); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[17]))((ID3D12Device2*)Unsafe.AsPointer(ref this), pResource, pDesc, DestDescriptor); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(18)] + public void CreateUnorderedAccessView(ID3D12Resource* pResource, ID3D12Resource* pCounterResource, UnorderedAccessViewDescription* pDesc, CpuDescriptorHandle* DestDescriptor) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[18]))((ID3D12Device2*)Unsafe.AsPointer(ref this), pResource, pCounterResource, pDesc, DestDescriptor); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[18]))((ID3D12Device2*)Unsafe.AsPointer(ref this), pResource, pCounterResource, pDesc, DestDescriptor); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(19)] + public void CreateRenderTargetView(ID3D12Resource* pResource, RenderTargetViewDescription* pDesc, CpuDescriptorHandle* DestDescriptor) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[19]))((ID3D12Device2*)Unsafe.AsPointer(ref this), pResource, pDesc, DestDescriptor); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[19]))((ID3D12Device2*)Unsafe.AsPointer(ref this), pResource, pDesc, DestDescriptor); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(20)] + public void CreateDepthStencilView(ID3D12Resource* pResource, DepthStencilViewDescription* pDesc, CpuDescriptorHandle* DestDescriptor) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[20]))((ID3D12Device2*)Unsafe.AsPointer(ref this), pResource, pDesc, DestDescriptor); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[20]))((ID3D12Device2*)Unsafe.AsPointer(ref this), pResource, pDesc, DestDescriptor); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(21)] + public void CreateSampler(SamplerDescription* pDesc, CpuDescriptorHandle* DestDescriptor) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[21]))((ID3D12Device2*)Unsafe.AsPointer(ref this), pDesc, DestDescriptor); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[21]))((ID3D12Device2*)Unsafe.AsPointer(ref this), pDesc, DestDescriptor); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(22)] + public void CopyDescriptors(uint NumDestDescriptorRanges, CpuDescriptorHandle* pDestDescriptorRangeStarts, uint* pDestDescriptorRangeSizes, uint NumSrcDescriptorRanges, CpuDescriptorHandle* pSrcDescriptorRangeStarts, uint* pSrcDescriptorRangeSizes, DescriptorHeapType DescriptorHeapsType) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[22]))((ID3D12Device2*)Unsafe.AsPointer(ref this), NumDestDescriptorRanges, pDestDescriptorRangeStarts, pDestDescriptorRangeSizes, NumSrcDescriptorRanges, pSrcDescriptorRangeStarts, pSrcDescriptorRangeSizes, DescriptorHeapsType); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[22]))((ID3D12Device2*)Unsafe.AsPointer(ref this), NumDestDescriptorRanges, pDestDescriptorRangeStarts, pDestDescriptorRangeSizes, NumSrcDescriptorRanges, pSrcDescriptorRangeStarts, pSrcDescriptorRangeSizes, DescriptorHeapsType); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(23)] + public void CopyDescriptorsSimple(uint NumDescriptors, CpuDescriptorHandle* DestDescriptorRangeStart, CpuDescriptorHandle* SrcDescriptorRangeStart, DescriptorHeapType DescriptorHeapsType) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[23]))((ID3D12Device2*)Unsafe.AsPointer(ref this), NumDescriptors, DestDescriptorRangeStart, SrcDescriptorRangeStart, DescriptorHeapsType); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[23]))((ID3D12Device2*)Unsafe.AsPointer(ref this), NumDescriptors, DestDescriptorRangeStart, SrcDescriptorRangeStart, DescriptorHeapsType); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(24)] + public Graphics.Direct3D12.ResourceAllocationInfo GetResourceAllocationInfo(uint visibleMask, uint numResourceDescs, ResourceDescription* pResourceDescs) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[24]))((ID3D12Device2*)Unsafe.AsPointer(ref this), visibleMask, numResourceDescs, pResourceDescs); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[24]))((ID3D12Device2*)Unsafe.AsPointer(ref this), visibleMask, numResourceDescs, pResourceDescs); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(25)] + public Graphics.Direct3D12.HeapProperties GetCustomHeapProperties(uint nodeMask, HeapType heapType) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[25]))((ID3D12Device2*)Unsafe.AsPointer(ref this), nodeMask, heapType); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[25]))((ID3D12Device2*)Unsafe.AsPointer(ref this), nodeMask, heapType); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(26)] + public HResult CreateCommittedResource(HeapProperties* pHeapProperties, HeapFlags HeapFlags, ResourceDescription* pDesc, ResourceStates InitialResourceState, ClearValue* pOptimizedClearValue, Guid* riidResource, void** ppvResource) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[26]))((ID3D12Device2*)Unsafe.AsPointer(ref this), pHeapProperties, HeapFlags, pDesc, InitialResourceState, pOptimizedClearValue, riidResource, ppvResource); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[26]))((ID3D12Device2*)Unsafe.AsPointer(ref this), pHeapProperties, HeapFlags, pDesc, InitialResourceState, pOptimizedClearValue, riidResource, ppvResource); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(27)] + public HResult CreateHeap(HeapDescription* pDesc, Guid* riid, void** ppvHeap) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[27]))((ID3D12Device2*)Unsafe.AsPointer(ref this), pDesc, riid, ppvHeap); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[27]))((ID3D12Device2*)Unsafe.AsPointer(ref this), pDesc, riid, ppvHeap); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(28)] + public HResult CreatePlacedResource(ID3D12Heap* pHeap, ulong HeapOffset, ResourceDescription* pDesc, ResourceStates InitialState, ClearValue* pOptimizedClearValue, Guid* riid, void** ppvResource) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[28]))((ID3D12Device2*)Unsafe.AsPointer(ref this), pHeap, HeapOffset, pDesc, InitialState, pOptimizedClearValue, riid, ppvResource); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[28]))((ID3D12Device2*)Unsafe.AsPointer(ref this), pHeap, HeapOffset, pDesc, InitialState, pOptimizedClearValue, riid, ppvResource); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(29)] + public HResult CreateReservedResource(ResourceDescription* pDesc, ResourceStates InitialState, ClearValue* pOptimizedClearValue, Guid* riid, void** ppvResource) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[29]))((ID3D12Device2*)Unsafe.AsPointer(ref this), pDesc, InitialState, pOptimizedClearValue, riid, ppvResource); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[29]))((ID3D12Device2*)Unsafe.AsPointer(ref this), pDesc, InitialState, pOptimizedClearValue, riid, ppvResource); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(30)] + public HResult CreateSharedHandle(ID3D12DeviceChild* pObject, Security.SECURITY_ATTRIBUTES* pAttributes, uint Access, char** Name, IntPtr* pHandle) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[30]))((ID3D12Device2*)Unsafe.AsPointer(ref this), pObject, pAttributes, Access, Name, pHandle); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[30]))((ID3D12Device2*)Unsafe.AsPointer(ref this), pObject, pAttributes, Access, Name, pHandle); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(31)] + public HResult OpenSharedHandle(IntPtr NTHandle, Guid* riid, void** ppvObj) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[31]))((ID3D12Device2*)Unsafe.AsPointer(ref this), NTHandle, riid, ppvObj); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[31]))((ID3D12Device2*)Unsafe.AsPointer(ref this), NTHandle, riid, ppvObj); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(32)] + public HResult OpenSharedHandleByName(char** Name, uint Access, IntPtr* pNTHandle) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[32]))((ID3D12Device2*)Unsafe.AsPointer(ref this), Name, Access, pNTHandle); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[32]))((ID3D12Device2*)Unsafe.AsPointer(ref this), Name, Access, pNTHandle); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(33)] + public HResult MakeResident(uint NumObjects, ID3D12Pageable* ppObjects) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[33]))((ID3D12Device2*)Unsafe.AsPointer(ref this), NumObjects, ppObjects); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[33]))((ID3D12Device2*)Unsafe.AsPointer(ref this), NumObjects, ppObjects); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(34)] + public HResult Evict(uint NumObjects, ID3D12Pageable* ppObjects) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[34]))((ID3D12Device2*)Unsafe.AsPointer(ref this), NumObjects, ppObjects); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[34]))((ID3D12Device2*)Unsafe.AsPointer(ref this), NumObjects, ppObjects); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(35)] + public HResult CreateFence(ulong InitialValue, FenceFlags Flags, Guid* riid, void** ppFence) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[35]))((ID3D12Device2*)Unsafe.AsPointer(ref this), InitialValue, Flags, riid, ppFence); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[35]))((ID3D12Device2*)Unsafe.AsPointer(ref this), InitialValue, Flags, riid, ppFence); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(36)] + public HResult GetDeviceRemovedReason() + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[36]))((ID3D12Device2*)Unsafe.AsPointer(ref this)); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[36]))((ID3D12Device2*)Unsafe.AsPointer(ref this)); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(37)] + public void GetCopyableFootprints(ResourceDescription* pResourceDesc, uint FirstSubresource, uint NumSubresources, ulong BaseOffset, PlacedSubresourceFootprint* pLayouts, uint* pNumRows, ulong* pRowSizeInBytes, ulong* pTotalBytes) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[37]))((ID3D12Device2*)Unsafe.AsPointer(ref this), pResourceDesc, FirstSubresource, NumSubresources, BaseOffset, pLayouts, pNumRows, pRowSizeInBytes, pTotalBytes); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[37]))((ID3D12Device2*)Unsafe.AsPointer(ref this), pResourceDesc, FirstSubresource, NumSubresources, BaseOffset, pLayouts, pNumRows, pRowSizeInBytes, pTotalBytes); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(38)] + public HResult CreateQueryHeap(QueryHeapDescription* pDesc, Guid* riid, void** ppvHeap) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[38]))((ID3D12Device2*)Unsafe.AsPointer(ref this), pDesc, riid, ppvHeap); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[38]))((ID3D12Device2*)Unsafe.AsPointer(ref this), pDesc, riid, ppvHeap); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(39)] + public HResult SetStablePowerState(Bool32 Enable) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[39]))((ID3D12Device2*)Unsafe.AsPointer(ref this), Enable); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[39]))((ID3D12Device2*)Unsafe.AsPointer(ref this), Enable); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(40)] + public HResult CreateCommandSignature(CommandSignatureDescription* pDesc, ID3D12RootSignature* pRootSignature, Guid* riid, void** ppvCommandSignature) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[40]))((ID3D12Device2*)Unsafe.AsPointer(ref this), pDesc, pRootSignature, riid, ppvCommandSignature); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[40]))((ID3D12Device2*)Unsafe.AsPointer(ref this), pDesc, pRootSignature, riid, ppvCommandSignature); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(41)] + public void GetResourceTiling(ID3D12Resource* pTiledResource, uint* pNumTilesForEntireResource, PackedMipInfo* pPackedMipDesc, TileShape* pStandardTileShapeForNonPackedMips, uint* pNumSubresourceTilings, uint FirstSubresourceTilingToGet, SubresourceTiling* pSubresourceTilingsForNonPackedMips) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[41]))((ID3D12Device2*)Unsafe.AsPointer(ref this), pTiledResource, pNumTilesForEntireResource, pPackedMipDesc, pStandardTileShapeForNonPackedMips, pNumSubresourceTilings, FirstSubresourceTilingToGet, pSubresourceTilingsForNonPackedMips); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[41]))((ID3D12Device2*)Unsafe.AsPointer(ref this), pTiledResource, pNumTilesForEntireResource, pPackedMipDesc, pStandardTileShapeForNonPackedMips, pNumSubresourceTilings, FirstSubresourceTilingToGet, pSubresourceTilingsForNonPackedMips); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(42)] + public Luid GetAdapterLuid() + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[42]))((ID3D12Device2*)Unsafe.AsPointer(ref this)); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[42]))((ID3D12Device2*)Unsafe.AsPointer(ref this)); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(43)] + public HResult GetPrivateData(Guid* guid, uint* pDataSize, void* pData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[43]))((ID3D12Device2*)Unsafe.AsPointer(ref this), guid, pDataSize, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[43]))((ID3D12Device2*)Unsafe.AsPointer(ref this), guid, pDataSize, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(44)] + public HResult SetPrivateData(Guid* guid, uint DataSize, void* pData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[44]))((ID3D12Device2*)Unsafe.AsPointer(ref this), guid, DataSize, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[44]))((ID3D12Device2*)Unsafe.AsPointer(ref this), guid, DataSize, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(45)] + public HResult SetPrivateDataInterface(Guid* guid, IUnknown* pData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[45]))((ID3D12Device2*)Unsafe.AsPointer(ref this), guid, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[45]))((ID3D12Device2*)Unsafe.AsPointer(ref this), guid, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(46)] + public HResult SetName(char** Name) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[46]))((ID3D12Device2*)Unsafe.AsPointer(ref this), Name); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[46]))((ID3D12Device2*)Unsafe.AsPointer(ref this), Name); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(47)] + public HResult CreatePipelineState(PipelineStateStreamDescription* pDesc, Guid* riid, void** ppPipelineState) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[47]))((ID3D12Device2*)Unsafe.AsPointer(ref this), pDesc, riid, ppPipelineState); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[47]))((ID3D12Device2*)Unsafe.AsPointer(ref this), pDesc, riid, ppPipelineState); +#endif + } + + public interface Interface : ID3D12Device1.Interface + { + } +} + +/// +/// ID3D12Device3 +[Guid("81dadc15-2bad-4392-93c5-101345c4aa98")] +[NativeTypeName("struct ID3D12Device3 : ID3D12Device2")] +[NativeInheritance("ID3D12Device2")] +public unsafe partial struct ID3D12Device3 : ID3D12Device3.Interface +{ + public static ref readonly Guid IID_ID3D12Device3 + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x15, 0xDC, 0xDA, 0x81, + 0xAD, 0x2B, + 0x92, 0x43, + 0x93, + 0xC5, + 0x10, + 0x13, + 0x45, + 0xC4, + 0xAA, + 0x98 + }; + + 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_ID3D12Device3)); + + 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 CreatePipelineState(PipelineStateStreamDescription* pDesc, Guid* riid, void** ppPipelineState) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[3]))((ID3D12Device3*)Unsafe.AsPointer(ref this), pDesc, riid, ppPipelineState); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((ID3D12Device3*)Unsafe.AsPointer(ref this), pDesc, riid, ppPipelineState); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public HResult CreatePipelineLibrary(void* pLibraryBlob, nuint BlobLength, Guid* riid, void** ppPipelineLibrary) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[4]))((ID3D12Device3*)Unsafe.AsPointer(ref this), pLibraryBlob, BlobLength, riid, ppPipelineLibrary); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((ID3D12Device3*)Unsafe.AsPointer(ref this), pLibraryBlob, BlobLength, riid, ppPipelineLibrary); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(5)] + public HResult SetEventOnMultipleFenceCompletion(ID3D12Fence* ppFences, ulong* pFenceValues, uint NumFences, MultipleFenceWaitFlags Flags, IntPtr hEvent) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[5]))((ID3D12Device3*)Unsafe.AsPointer(ref this), ppFences, pFenceValues, NumFences, Flags, hEvent); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((ID3D12Device3*)Unsafe.AsPointer(ref this), ppFences, pFenceValues, NumFences, Flags, hEvent); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(6)] + public HResult SetResidencyPriority(uint NumObjects, ID3D12Pageable* ppObjects, ResidencyPriority* pPriorities) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[6]))((ID3D12Device3*)Unsafe.AsPointer(ref this), NumObjects, ppObjects, pPriorities); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((ID3D12Device3*)Unsafe.AsPointer(ref this), NumObjects, ppObjects, pPriorities); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(7)] + public uint GetNodeCount() + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[7]))((ID3D12Device3*)Unsafe.AsPointer(ref this)); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((ID3D12Device3*)Unsafe.AsPointer(ref this)); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(8)] + public HResult CreateCommandQueue(CommandQueueDescription* pDesc, Guid* riid, void** ppCommandQueue) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[8]))((ID3D12Device3*)Unsafe.AsPointer(ref this), pDesc, riid, ppCommandQueue); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[8]))((ID3D12Device3*)Unsafe.AsPointer(ref this), pDesc, riid, ppCommandQueue); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(9)] + public HResult CreateCommandAllocator(CommandListType type, Guid* riid, void** ppCommandAllocator) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[9]))((ID3D12Device3*)Unsafe.AsPointer(ref this), type, riid, ppCommandAllocator); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[9]))((ID3D12Device3*)Unsafe.AsPointer(ref this), type, riid, ppCommandAllocator); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(10)] + public HResult CreateGraphicsPipelineState(GraphicsPipelineStateDescription* pDesc, Guid* riid, void** ppPipelineState) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[10]))((ID3D12Device3*)Unsafe.AsPointer(ref this), pDesc, riid, ppPipelineState); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[10]))((ID3D12Device3*)Unsafe.AsPointer(ref this), pDesc, riid, ppPipelineState); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(11)] + public HResult CreateComputePipelineState(ComputePipelineStateDescription* pDesc, Guid* riid, void** ppPipelineState) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[11]))((ID3D12Device3*)Unsafe.AsPointer(ref this), pDesc, riid, ppPipelineState); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[11]))((ID3D12Device3*)Unsafe.AsPointer(ref this), pDesc, riid, ppPipelineState); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(12)] + public HResult CreateCommandList(uint nodeMask, CommandListType type, ID3D12CommandAllocator* pCommandAllocator, ID3D12PipelineState* pInitialState, Guid* riid, void** ppCommandList) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[12]))((ID3D12Device3*)Unsafe.AsPointer(ref this), nodeMask, type, pCommandAllocator, pInitialState, riid, ppCommandList); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[12]))((ID3D12Device3*)Unsafe.AsPointer(ref this), nodeMask, type, pCommandAllocator, pInitialState, riid, ppCommandList); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(13)] + public HResult CheckFeatureSupport(Feature Feature, void* pFeatureSupportData, uint FeatureSupportDataSize) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[13]))((ID3D12Device3*)Unsafe.AsPointer(ref this), Feature, pFeatureSupportData, FeatureSupportDataSize); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[13]))((ID3D12Device3*)Unsafe.AsPointer(ref this), Feature, pFeatureSupportData, FeatureSupportDataSize); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(14)] + public HResult CreateDescriptorHeap(DescriptorHeapDescription* pDescriptorHeapDesc, Guid* riid, void** ppvHeap) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[14]))((ID3D12Device3*)Unsafe.AsPointer(ref this), pDescriptorHeapDesc, riid, ppvHeap); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[14]))((ID3D12Device3*)Unsafe.AsPointer(ref this), pDescriptorHeapDesc, riid, ppvHeap); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(15)] + public uint GetDescriptorHandleIncrementSize(DescriptorHeapType DescriptorHeapType) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[15]))((ID3D12Device3*)Unsafe.AsPointer(ref this), DescriptorHeapType); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[15]))((ID3D12Device3*)Unsafe.AsPointer(ref this), DescriptorHeapType); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(16)] + public HResult CreateRootSignature(uint nodeMask, void* pBlobWithRootSignature, nuint blobLengthInBytes, Guid* riid, void** ppvRootSignature) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[16]))((ID3D12Device3*)Unsafe.AsPointer(ref this), nodeMask, pBlobWithRootSignature, blobLengthInBytes, riid, ppvRootSignature); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[16]))((ID3D12Device3*)Unsafe.AsPointer(ref this), nodeMask, pBlobWithRootSignature, blobLengthInBytes, riid, ppvRootSignature); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(17)] + public void CreateConstantBufferView(ConstantBufferViewDescription* pDesc, CpuDescriptorHandle* DestDescriptor) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[17]))((ID3D12Device3*)Unsafe.AsPointer(ref this), pDesc, DestDescriptor); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[17]))((ID3D12Device3*)Unsafe.AsPointer(ref this), pDesc, DestDescriptor); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(18)] + public void CreateShaderResourceView(ID3D12Resource* pResource, ShaderResourceViewDescription* pDesc, CpuDescriptorHandle* DestDescriptor) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[18]))((ID3D12Device3*)Unsafe.AsPointer(ref this), pResource, pDesc, DestDescriptor); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[18]))((ID3D12Device3*)Unsafe.AsPointer(ref this), pResource, pDesc, DestDescriptor); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(19)] + public void CreateUnorderedAccessView(ID3D12Resource* pResource, ID3D12Resource* pCounterResource, UnorderedAccessViewDescription* pDesc, CpuDescriptorHandle* DestDescriptor) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[19]))((ID3D12Device3*)Unsafe.AsPointer(ref this), pResource, pCounterResource, pDesc, DestDescriptor); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[19]))((ID3D12Device3*)Unsafe.AsPointer(ref this), pResource, pCounterResource, pDesc, DestDescriptor); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(20)] + public void CreateRenderTargetView(ID3D12Resource* pResource, RenderTargetViewDescription* pDesc, CpuDescriptorHandle* DestDescriptor) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[20]))((ID3D12Device3*)Unsafe.AsPointer(ref this), pResource, pDesc, DestDescriptor); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[20]))((ID3D12Device3*)Unsafe.AsPointer(ref this), pResource, pDesc, DestDescriptor); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(21)] + public void CreateDepthStencilView(ID3D12Resource* pResource, DepthStencilViewDescription* pDesc, CpuDescriptorHandle* DestDescriptor) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[21]))((ID3D12Device3*)Unsafe.AsPointer(ref this), pResource, pDesc, DestDescriptor); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[21]))((ID3D12Device3*)Unsafe.AsPointer(ref this), pResource, pDesc, DestDescriptor); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(22)] + public void CreateSampler(SamplerDescription* pDesc, CpuDescriptorHandle* DestDescriptor) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[22]))((ID3D12Device3*)Unsafe.AsPointer(ref this), pDesc, DestDescriptor); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[22]))((ID3D12Device3*)Unsafe.AsPointer(ref this), pDesc, DestDescriptor); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(23)] + public void CopyDescriptors(uint NumDestDescriptorRanges, CpuDescriptorHandle* pDestDescriptorRangeStarts, uint* pDestDescriptorRangeSizes, uint NumSrcDescriptorRanges, CpuDescriptorHandle* pSrcDescriptorRangeStarts, uint* pSrcDescriptorRangeSizes, DescriptorHeapType DescriptorHeapsType) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[23]))((ID3D12Device3*)Unsafe.AsPointer(ref this), NumDestDescriptorRanges, pDestDescriptorRangeStarts, pDestDescriptorRangeSizes, NumSrcDescriptorRanges, pSrcDescriptorRangeStarts, pSrcDescriptorRangeSizes, DescriptorHeapsType); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[23]))((ID3D12Device3*)Unsafe.AsPointer(ref this), NumDestDescriptorRanges, pDestDescriptorRangeStarts, pDestDescriptorRangeSizes, NumSrcDescriptorRanges, pSrcDescriptorRangeStarts, pSrcDescriptorRangeSizes, DescriptorHeapsType); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(24)] + public void CopyDescriptorsSimple(uint NumDescriptors, CpuDescriptorHandle* DestDescriptorRangeStart, CpuDescriptorHandle* SrcDescriptorRangeStart, DescriptorHeapType DescriptorHeapsType) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[24]))((ID3D12Device3*)Unsafe.AsPointer(ref this), NumDescriptors, DestDescriptorRangeStart, SrcDescriptorRangeStart, DescriptorHeapsType); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[24]))((ID3D12Device3*)Unsafe.AsPointer(ref this), NumDescriptors, DestDescriptorRangeStart, SrcDescriptorRangeStart, DescriptorHeapsType); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(25)] + public Graphics.Direct3D12.ResourceAllocationInfo GetResourceAllocationInfo(uint visibleMask, uint numResourceDescs, ResourceDescription* pResourceDescs) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[25]))((ID3D12Device3*)Unsafe.AsPointer(ref this), visibleMask, numResourceDescs, pResourceDescs); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[25]))((ID3D12Device3*)Unsafe.AsPointer(ref this), visibleMask, numResourceDescs, pResourceDescs); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(26)] + public Graphics.Direct3D12.HeapProperties GetCustomHeapProperties(uint nodeMask, HeapType heapType) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[26]))((ID3D12Device3*)Unsafe.AsPointer(ref this), nodeMask, heapType); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[26]))((ID3D12Device3*)Unsafe.AsPointer(ref this), nodeMask, heapType); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(27)] + public HResult CreateCommittedResource(HeapProperties* pHeapProperties, HeapFlags HeapFlags, ResourceDescription* pDesc, ResourceStates InitialResourceState, ClearValue* pOptimizedClearValue, Guid* riidResource, void** ppvResource) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[27]))((ID3D12Device3*)Unsafe.AsPointer(ref this), pHeapProperties, HeapFlags, pDesc, InitialResourceState, pOptimizedClearValue, riidResource, ppvResource); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[27]))((ID3D12Device3*)Unsafe.AsPointer(ref this), pHeapProperties, HeapFlags, pDesc, InitialResourceState, pOptimizedClearValue, riidResource, ppvResource); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(28)] + public HResult CreateHeap(HeapDescription* pDesc, Guid* riid, void** ppvHeap) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[28]))((ID3D12Device3*)Unsafe.AsPointer(ref this), pDesc, riid, ppvHeap); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[28]))((ID3D12Device3*)Unsafe.AsPointer(ref this), pDesc, riid, ppvHeap); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(29)] + public HResult CreatePlacedResource(ID3D12Heap* pHeap, ulong HeapOffset, ResourceDescription* pDesc, ResourceStates InitialState, ClearValue* pOptimizedClearValue, Guid* riid, void** ppvResource) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[29]))((ID3D12Device3*)Unsafe.AsPointer(ref this), pHeap, HeapOffset, pDesc, InitialState, pOptimizedClearValue, riid, ppvResource); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[29]))((ID3D12Device3*)Unsafe.AsPointer(ref this), pHeap, HeapOffset, pDesc, InitialState, pOptimizedClearValue, riid, ppvResource); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(30)] + public HResult CreateReservedResource(ResourceDescription* pDesc, ResourceStates InitialState, ClearValue* pOptimizedClearValue, Guid* riid, void** ppvResource) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[30]))((ID3D12Device3*)Unsafe.AsPointer(ref this), pDesc, InitialState, pOptimizedClearValue, riid, ppvResource); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[30]))((ID3D12Device3*)Unsafe.AsPointer(ref this), pDesc, InitialState, pOptimizedClearValue, riid, ppvResource); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(31)] + public HResult CreateSharedHandle(ID3D12DeviceChild* pObject, Security.SECURITY_ATTRIBUTES* pAttributes, uint Access, char** Name, IntPtr* pHandle) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[31]))((ID3D12Device3*)Unsafe.AsPointer(ref this), pObject, pAttributes, Access, Name, pHandle); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[31]))((ID3D12Device3*)Unsafe.AsPointer(ref this), pObject, pAttributes, Access, Name, pHandle); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(32)] + public HResult OpenSharedHandle(IntPtr NTHandle, Guid* riid, void** ppvObj) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[32]))((ID3D12Device3*)Unsafe.AsPointer(ref this), NTHandle, riid, ppvObj); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[32]))((ID3D12Device3*)Unsafe.AsPointer(ref this), NTHandle, riid, ppvObj); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(33)] + public HResult OpenSharedHandleByName(char** Name, uint Access, IntPtr* pNTHandle) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[33]))((ID3D12Device3*)Unsafe.AsPointer(ref this), Name, Access, pNTHandle); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[33]))((ID3D12Device3*)Unsafe.AsPointer(ref this), Name, Access, pNTHandle); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(34)] + public HResult MakeResident(uint NumObjects, ID3D12Pageable* ppObjects) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[34]))((ID3D12Device3*)Unsafe.AsPointer(ref this), NumObjects, ppObjects); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[34]))((ID3D12Device3*)Unsafe.AsPointer(ref this), NumObjects, ppObjects); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(35)] + public HResult Evict(uint NumObjects, ID3D12Pageable* ppObjects) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[35]))((ID3D12Device3*)Unsafe.AsPointer(ref this), NumObjects, ppObjects); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[35]))((ID3D12Device3*)Unsafe.AsPointer(ref this), NumObjects, ppObjects); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(36)] + public HResult CreateFence(ulong InitialValue, FenceFlags Flags, Guid* riid, void** ppFence) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[36]))((ID3D12Device3*)Unsafe.AsPointer(ref this), InitialValue, Flags, riid, ppFence); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[36]))((ID3D12Device3*)Unsafe.AsPointer(ref this), InitialValue, Flags, riid, ppFence); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(37)] + public HResult GetDeviceRemovedReason() + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[37]))((ID3D12Device3*)Unsafe.AsPointer(ref this)); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[37]))((ID3D12Device3*)Unsafe.AsPointer(ref this)); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(38)] + public void GetCopyableFootprints(ResourceDescription* pResourceDesc, uint FirstSubresource, uint NumSubresources, ulong BaseOffset, PlacedSubresourceFootprint* pLayouts, uint* pNumRows, ulong* pRowSizeInBytes, ulong* pTotalBytes) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[38]))((ID3D12Device3*)Unsafe.AsPointer(ref this), pResourceDesc, FirstSubresource, NumSubresources, BaseOffset, pLayouts, pNumRows, pRowSizeInBytes, pTotalBytes); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[38]))((ID3D12Device3*)Unsafe.AsPointer(ref this), pResourceDesc, FirstSubresource, NumSubresources, BaseOffset, pLayouts, pNumRows, pRowSizeInBytes, pTotalBytes); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(39)] + public HResult CreateQueryHeap(QueryHeapDescription* pDesc, Guid* riid, void** ppvHeap) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[39]))((ID3D12Device3*)Unsafe.AsPointer(ref this), pDesc, riid, ppvHeap); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[39]))((ID3D12Device3*)Unsafe.AsPointer(ref this), pDesc, riid, ppvHeap); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(40)] + public HResult SetStablePowerState(Bool32 Enable) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[40]))((ID3D12Device3*)Unsafe.AsPointer(ref this), Enable); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[40]))((ID3D12Device3*)Unsafe.AsPointer(ref this), Enable); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(41)] + public HResult CreateCommandSignature(CommandSignatureDescription* pDesc, ID3D12RootSignature* pRootSignature, Guid* riid, void** ppvCommandSignature) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[41]))((ID3D12Device3*)Unsafe.AsPointer(ref this), pDesc, pRootSignature, riid, ppvCommandSignature); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[41]))((ID3D12Device3*)Unsafe.AsPointer(ref this), pDesc, pRootSignature, riid, ppvCommandSignature); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(42)] + public void GetResourceTiling(ID3D12Resource* pTiledResource, uint* pNumTilesForEntireResource, PackedMipInfo* pPackedMipDesc, TileShape* pStandardTileShapeForNonPackedMips, uint* pNumSubresourceTilings, uint FirstSubresourceTilingToGet, SubresourceTiling* pSubresourceTilingsForNonPackedMips) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[42]))((ID3D12Device3*)Unsafe.AsPointer(ref this), pTiledResource, pNumTilesForEntireResource, pPackedMipDesc, pStandardTileShapeForNonPackedMips, pNumSubresourceTilings, FirstSubresourceTilingToGet, pSubresourceTilingsForNonPackedMips); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[42]))((ID3D12Device3*)Unsafe.AsPointer(ref this), pTiledResource, pNumTilesForEntireResource, pPackedMipDesc, pStandardTileShapeForNonPackedMips, pNumSubresourceTilings, FirstSubresourceTilingToGet, pSubresourceTilingsForNonPackedMips); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(43)] + public Luid GetAdapterLuid() + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[43]))((ID3D12Device3*)Unsafe.AsPointer(ref this)); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[43]))((ID3D12Device3*)Unsafe.AsPointer(ref this)); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(44)] + public HResult GetPrivateData(Guid* guid, uint* pDataSize, void* pData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[44]))((ID3D12Device3*)Unsafe.AsPointer(ref this), guid, pDataSize, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[44]))((ID3D12Device3*)Unsafe.AsPointer(ref this), guid, pDataSize, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(45)] + public HResult SetPrivateData(Guid* guid, uint DataSize, void* pData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[45]))((ID3D12Device3*)Unsafe.AsPointer(ref this), guid, DataSize, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[45]))((ID3D12Device3*)Unsafe.AsPointer(ref this), guid, DataSize, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(46)] + public HResult SetPrivateDataInterface(Guid* guid, IUnknown* pData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[46]))((ID3D12Device3*)Unsafe.AsPointer(ref this), guid, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[46]))((ID3D12Device3*)Unsafe.AsPointer(ref this), guid, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(47)] + public HResult SetName(char** Name) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[47]))((ID3D12Device3*)Unsafe.AsPointer(ref this), Name); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[47]))((ID3D12Device3*)Unsafe.AsPointer(ref this), Name); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(48)] + public HResult OpenExistingHeapFromAddress(void* pAddress, Guid* riid, void** ppvHeap) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[48]))((ID3D12Device3*)Unsafe.AsPointer(ref this), pAddress, riid, ppvHeap); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[48]))((ID3D12Device3*)Unsafe.AsPointer(ref this), pAddress, riid, ppvHeap); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(49)] + public HResult OpenExistingHeapFromFileMapping(IntPtr hFileMapping, Guid* riid, void** ppvHeap) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[49]))((ID3D12Device3*)Unsafe.AsPointer(ref this), hFileMapping, riid, ppvHeap); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[49]))((ID3D12Device3*)Unsafe.AsPointer(ref this), hFileMapping, riid, ppvHeap); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(50)] + public HResult EnqueueMakeResident(ResidencyFlags Flags, uint NumObjects, ID3D12Pageable* ppObjects, ID3D12Fence* pFenceToSignal, ulong FenceValueToSignal) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[50]))((ID3D12Device3*)Unsafe.AsPointer(ref this), Flags, NumObjects, ppObjects, pFenceToSignal, FenceValueToSignal); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[50]))((ID3D12Device3*)Unsafe.AsPointer(ref this), Flags, NumObjects, ppObjects, pFenceToSignal, FenceValueToSignal); +#endif + } + + public interface Interface : ID3D12Device2.Interface + { + } +} + +/// +/// ID3D12ProtectedSession +[Guid("a1533d18-0ac1-4084-85b9-89a96116806b")] +[NativeTypeName("struct ID3D12ProtectedSession : ID3D12DeviceChild")] +[NativeInheritance("ID3D12DeviceChild")] +public unsafe partial struct ID3D12ProtectedSession : ID3D12ProtectedSession.Interface +{ + public static ref readonly Guid IID_ID3D12ProtectedSession + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x18, 0x3D, 0x53, 0xA1, + 0xC1, 0x0A, + 0x84, 0x40, + 0x85, + 0xB9, + 0x89, + 0xA9, + 0x61, + 0x16, + 0x80, + 0x6B + }; + + 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_ID3D12ProtectedSession)); + + 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 GetDevice(Guid* riid, void** ppvDevice) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[3]))((ID3D12ProtectedSession*)Unsafe.AsPointer(ref this), riid, ppvDevice); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((ID3D12ProtectedSession*)Unsafe.AsPointer(ref this), riid, ppvDevice); +#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]))((ID3D12ProtectedSession*)Unsafe.AsPointer(ref this), guid, pDataSize, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((ID3D12ProtectedSession*)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]))((ID3D12ProtectedSession*)Unsafe.AsPointer(ref this), guid, DataSize, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((ID3D12ProtectedSession*)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]))((ID3D12ProtectedSession*)Unsafe.AsPointer(ref this), guid, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((ID3D12ProtectedSession*)Unsafe.AsPointer(ref this), guid, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(7)] + public HResult SetName(char** Name) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[7]))((ID3D12ProtectedSession*)Unsafe.AsPointer(ref this), Name); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((ID3D12ProtectedSession*)Unsafe.AsPointer(ref this), Name); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(8)] + public HResult GetStatusFence(Guid* riid, void** ppFence) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[8]))((ID3D12ProtectedSession*)Unsafe.AsPointer(ref this), riid, ppFence); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[8]))((ID3D12ProtectedSession*)Unsafe.AsPointer(ref this), riid, ppFence); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(9)] + public Graphics.Direct3D12.ProtectedSessionStatus GetSessionStatus() + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[9]))((ID3D12ProtectedSession*)Unsafe.AsPointer(ref this)); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[9]))((ID3D12ProtectedSession*)Unsafe.AsPointer(ref this)); +#endif + } + + public interface Interface : ID3D12DeviceChild.Interface + { + } +} + +/// +/// ID3D12ProtectedResourceSession +[Guid("6cd696f4-f289-40cc-8091-5a6c0a099c3d")] +[NativeTypeName("struct ID3D12ProtectedResourceSession : ID3D12ProtectedSession")] +[NativeInheritance("ID3D12ProtectedSession")] +public unsafe partial struct ID3D12ProtectedResourceSession : ID3D12ProtectedResourceSession.Interface +{ + public static ref readonly Guid IID_ID3D12ProtectedResourceSession + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0xF4, 0x96, 0xD6, 0x6C, + 0x89, 0xF2, + 0xCC, 0x40, + 0x80, + 0x91, + 0x5A, + 0x6C, + 0x0A, + 0x09, + 0x9C, + 0x3D + }; + + 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_ID3D12ProtectedResourceSession)); + + 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 GetStatusFence(Guid* riid, void** ppFence) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[3]))((ID3D12ProtectedResourceSession*)Unsafe.AsPointer(ref this), riid, ppFence); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((ID3D12ProtectedResourceSession*)Unsafe.AsPointer(ref this), riid, ppFence); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public Graphics.Direct3D12.ProtectedSessionStatus GetSessionStatus() + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[4]))((ID3D12ProtectedResourceSession*)Unsafe.AsPointer(ref this)); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((ID3D12ProtectedResourceSession*)Unsafe.AsPointer(ref this)); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(5)] + public HResult GetDevice(Guid* riid, void** ppvDevice) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[5]))((ID3D12ProtectedResourceSession*)Unsafe.AsPointer(ref this), riid, ppvDevice); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((ID3D12ProtectedResourceSession*)Unsafe.AsPointer(ref this), riid, ppvDevice); +#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]))((ID3D12ProtectedResourceSession*)Unsafe.AsPointer(ref this), guid, pDataSize, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((ID3D12ProtectedResourceSession*)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]))((ID3D12ProtectedResourceSession*)Unsafe.AsPointer(ref this), guid, DataSize, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((ID3D12ProtectedResourceSession*)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]))((ID3D12ProtectedResourceSession*)Unsafe.AsPointer(ref this), guid, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[8]))((ID3D12ProtectedResourceSession*)Unsafe.AsPointer(ref this), guid, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(9)] + public HResult SetName(char** Name) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[9]))((ID3D12ProtectedResourceSession*)Unsafe.AsPointer(ref this), Name); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[9]))((ID3D12ProtectedResourceSession*)Unsafe.AsPointer(ref this), Name); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(10)] + public Graphics.Direct3D12.ProtectedResourceSessionDescription GetDesc() + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[10]))((ID3D12ProtectedResourceSession*)Unsafe.AsPointer(ref this)); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[10]))((ID3D12ProtectedResourceSession*)Unsafe.AsPointer(ref this)); +#endif + } + + public interface Interface : ID3D12ProtectedSession.Interface + { + } +} + +/// +/// ID3D12Device4 +[Guid("e865df17-a9ee-46f9-a463-3098315aa2e5")] +[NativeTypeName("struct ID3D12Device4 : ID3D12Device3")] +[NativeInheritance("ID3D12Device3")] +public unsafe partial struct ID3D12Device4 : ID3D12Device4.Interface +{ + public static ref readonly Guid IID_ID3D12Device4 + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x17, 0xDF, 0x65, 0xE8, + 0xEE, 0xA9, + 0xF9, 0x46, + 0xA4, + 0x63, + 0x30, + 0x98, + 0x31, + 0x5A, + 0xA2, + 0xE5 + }; + + 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_ID3D12Device4)); + + 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 OpenExistingHeapFromAddress(void* pAddress, Guid* riid, void** ppvHeap) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[3]))((ID3D12Device4*)Unsafe.AsPointer(ref this), pAddress, riid, ppvHeap); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((ID3D12Device4*)Unsafe.AsPointer(ref this), pAddress, riid, ppvHeap); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public HResult OpenExistingHeapFromFileMapping(IntPtr hFileMapping, Guid* riid, void** ppvHeap) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[4]))((ID3D12Device4*)Unsafe.AsPointer(ref this), hFileMapping, riid, ppvHeap); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((ID3D12Device4*)Unsafe.AsPointer(ref this), hFileMapping, riid, ppvHeap); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(5)] + public HResult EnqueueMakeResident(ResidencyFlags Flags, uint NumObjects, ID3D12Pageable* ppObjects, ID3D12Fence* pFenceToSignal, ulong FenceValueToSignal) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[5]))((ID3D12Device4*)Unsafe.AsPointer(ref this), Flags, NumObjects, ppObjects, pFenceToSignal, FenceValueToSignal); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((ID3D12Device4*)Unsafe.AsPointer(ref this), Flags, NumObjects, ppObjects, pFenceToSignal, FenceValueToSignal); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(6)] + public HResult CreatePipelineState(PipelineStateStreamDescription* pDesc, Guid* riid, void** ppPipelineState) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[6]))((ID3D12Device4*)Unsafe.AsPointer(ref this), pDesc, riid, ppPipelineState); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((ID3D12Device4*)Unsafe.AsPointer(ref this), pDesc, riid, ppPipelineState); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(7)] + public HResult CreatePipelineLibrary(void* pLibraryBlob, nuint BlobLength, Guid* riid, void** ppPipelineLibrary) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[7]))((ID3D12Device4*)Unsafe.AsPointer(ref this), pLibraryBlob, BlobLength, riid, ppPipelineLibrary); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((ID3D12Device4*)Unsafe.AsPointer(ref this), pLibraryBlob, BlobLength, riid, ppPipelineLibrary); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(8)] + public HResult SetEventOnMultipleFenceCompletion(ID3D12Fence* ppFences, ulong* pFenceValues, uint NumFences, MultipleFenceWaitFlags Flags, IntPtr hEvent) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[8]))((ID3D12Device4*)Unsafe.AsPointer(ref this), ppFences, pFenceValues, NumFences, Flags, hEvent); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[8]))((ID3D12Device4*)Unsafe.AsPointer(ref this), ppFences, pFenceValues, NumFences, Flags, hEvent); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(9)] + public HResult SetResidencyPriority(uint NumObjects, ID3D12Pageable* ppObjects, ResidencyPriority* pPriorities) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[9]))((ID3D12Device4*)Unsafe.AsPointer(ref this), NumObjects, ppObjects, pPriorities); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[9]))((ID3D12Device4*)Unsafe.AsPointer(ref this), NumObjects, ppObjects, pPriorities); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(10)] + public uint GetNodeCount() + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[10]))((ID3D12Device4*)Unsafe.AsPointer(ref this)); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[10]))((ID3D12Device4*)Unsafe.AsPointer(ref this)); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(11)] + public HResult CreateCommandQueue(CommandQueueDescription* pDesc, Guid* riid, void** ppCommandQueue) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[11]))((ID3D12Device4*)Unsafe.AsPointer(ref this), pDesc, riid, ppCommandQueue); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[11]))((ID3D12Device4*)Unsafe.AsPointer(ref this), pDesc, riid, ppCommandQueue); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(12)] + public HResult CreateCommandAllocator(CommandListType type, Guid* riid, void** ppCommandAllocator) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[12]))((ID3D12Device4*)Unsafe.AsPointer(ref this), type, riid, ppCommandAllocator); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[12]))((ID3D12Device4*)Unsafe.AsPointer(ref this), type, riid, ppCommandAllocator); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(13)] + public HResult CreateGraphicsPipelineState(GraphicsPipelineStateDescription* pDesc, Guid* riid, void** ppPipelineState) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[13]))((ID3D12Device4*)Unsafe.AsPointer(ref this), pDesc, riid, ppPipelineState); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[13]))((ID3D12Device4*)Unsafe.AsPointer(ref this), pDesc, riid, ppPipelineState); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(14)] + public HResult CreateComputePipelineState(ComputePipelineStateDescription* pDesc, Guid* riid, void** ppPipelineState) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[14]))((ID3D12Device4*)Unsafe.AsPointer(ref this), pDesc, riid, ppPipelineState); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[14]))((ID3D12Device4*)Unsafe.AsPointer(ref this), pDesc, riid, ppPipelineState); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(15)] + public HResult CreateCommandList(uint nodeMask, CommandListType type, ID3D12CommandAllocator* pCommandAllocator, ID3D12PipelineState* pInitialState, Guid* riid, void** ppCommandList) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[15]))((ID3D12Device4*)Unsafe.AsPointer(ref this), nodeMask, type, pCommandAllocator, pInitialState, riid, ppCommandList); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[15]))((ID3D12Device4*)Unsafe.AsPointer(ref this), nodeMask, type, pCommandAllocator, pInitialState, riid, ppCommandList); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(16)] + public HResult CheckFeatureSupport(Feature Feature, void* pFeatureSupportData, uint FeatureSupportDataSize) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[16]))((ID3D12Device4*)Unsafe.AsPointer(ref this), Feature, pFeatureSupportData, FeatureSupportDataSize); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[16]))((ID3D12Device4*)Unsafe.AsPointer(ref this), Feature, pFeatureSupportData, FeatureSupportDataSize); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(17)] + public HResult CreateDescriptorHeap(DescriptorHeapDescription* pDescriptorHeapDesc, Guid* riid, void** ppvHeap) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[17]))((ID3D12Device4*)Unsafe.AsPointer(ref this), pDescriptorHeapDesc, riid, ppvHeap); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[17]))((ID3D12Device4*)Unsafe.AsPointer(ref this), pDescriptorHeapDesc, riid, ppvHeap); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(18)] + public uint GetDescriptorHandleIncrementSize(DescriptorHeapType DescriptorHeapType) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[18]))((ID3D12Device4*)Unsafe.AsPointer(ref this), DescriptorHeapType); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[18]))((ID3D12Device4*)Unsafe.AsPointer(ref this), DescriptorHeapType); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(19)] + public HResult CreateRootSignature(uint nodeMask, void* pBlobWithRootSignature, nuint blobLengthInBytes, Guid* riid, void** ppvRootSignature) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[19]))((ID3D12Device4*)Unsafe.AsPointer(ref this), nodeMask, pBlobWithRootSignature, blobLengthInBytes, riid, ppvRootSignature); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[19]))((ID3D12Device4*)Unsafe.AsPointer(ref this), nodeMask, pBlobWithRootSignature, blobLengthInBytes, riid, ppvRootSignature); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(20)] + public void CreateConstantBufferView(ConstantBufferViewDescription* pDesc, CpuDescriptorHandle* DestDescriptor) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[20]))((ID3D12Device4*)Unsafe.AsPointer(ref this), pDesc, DestDescriptor); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[20]))((ID3D12Device4*)Unsafe.AsPointer(ref this), pDesc, DestDescriptor); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(21)] + public void CreateShaderResourceView(ID3D12Resource* pResource, ShaderResourceViewDescription* pDesc, CpuDescriptorHandle* DestDescriptor) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[21]))((ID3D12Device4*)Unsafe.AsPointer(ref this), pResource, pDesc, DestDescriptor); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[21]))((ID3D12Device4*)Unsafe.AsPointer(ref this), pResource, pDesc, DestDescriptor); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(22)] + public void CreateUnorderedAccessView(ID3D12Resource* pResource, ID3D12Resource* pCounterResource, UnorderedAccessViewDescription* pDesc, CpuDescriptorHandle* DestDescriptor) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[22]))((ID3D12Device4*)Unsafe.AsPointer(ref this), pResource, pCounterResource, pDesc, DestDescriptor); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[22]))((ID3D12Device4*)Unsafe.AsPointer(ref this), pResource, pCounterResource, pDesc, DestDescriptor); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(23)] + public void CreateRenderTargetView(ID3D12Resource* pResource, RenderTargetViewDescription* pDesc, CpuDescriptorHandle* DestDescriptor) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[23]))((ID3D12Device4*)Unsafe.AsPointer(ref this), pResource, pDesc, DestDescriptor); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[23]))((ID3D12Device4*)Unsafe.AsPointer(ref this), pResource, pDesc, DestDescriptor); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(24)] + public void CreateDepthStencilView(ID3D12Resource* pResource, DepthStencilViewDescription* pDesc, CpuDescriptorHandle* DestDescriptor) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[24]))((ID3D12Device4*)Unsafe.AsPointer(ref this), pResource, pDesc, DestDescriptor); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[24]))((ID3D12Device4*)Unsafe.AsPointer(ref this), pResource, pDesc, DestDescriptor); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(25)] + public void CreateSampler(SamplerDescription* pDesc, CpuDescriptorHandle* DestDescriptor) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[25]))((ID3D12Device4*)Unsafe.AsPointer(ref this), pDesc, DestDescriptor); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[25]))((ID3D12Device4*)Unsafe.AsPointer(ref this), pDesc, DestDescriptor); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(26)] + public void CopyDescriptors(uint NumDestDescriptorRanges, CpuDescriptorHandle* pDestDescriptorRangeStarts, uint* pDestDescriptorRangeSizes, uint NumSrcDescriptorRanges, CpuDescriptorHandle* pSrcDescriptorRangeStarts, uint* pSrcDescriptorRangeSizes, DescriptorHeapType DescriptorHeapsType) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[26]))((ID3D12Device4*)Unsafe.AsPointer(ref this), NumDestDescriptorRanges, pDestDescriptorRangeStarts, pDestDescriptorRangeSizes, NumSrcDescriptorRanges, pSrcDescriptorRangeStarts, pSrcDescriptorRangeSizes, DescriptorHeapsType); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[26]))((ID3D12Device4*)Unsafe.AsPointer(ref this), NumDestDescriptorRanges, pDestDescriptorRangeStarts, pDestDescriptorRangeSizes, NumSrcDescriptorRanges, pSrcDescriptorRangeStarts, pSrcDescriptorRangeSizes, DescriptorHeapsType); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(27)] + public void CopyDescriptorsSimple(uint NumDescriptors, CpuDescriptorHandle* DestDescriptorRangeStart, CpuDescriptorHandle* SrcDescriptorRangeStart, DescriptorHeapType DescriptorHeapsType) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[27]))((ID3D12Device4*)Unsafe.AsPointer(ref this), NumDescriptors, DestDescriptorRangeStart, SrcDescriptorRangeStart, DescriptorHeapsType); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[27]))((ID3D12Device4*)Unsafe.AsPointer(ref this), NumDescriptors, DestDescriptorRangeStart, SrcDescriptorRangeStart, DescriptorHeapsType); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(28)] + public Graphics.Direct3D12.ResourceAllocationInfo GetResourceAllocationInfo(uint visibleMask, uint numResourceDescs, ResourceDescription* pResourceDescs) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[28]))((ID3D12Device4*)Unsafe.AsPointer(ref this), visibleMask, numResourceDescs, pResourceDescs); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[28]))((ID3D12Device4*)Unsafe.AsPointer(ref this), visibleMask, numResourceDescs, pResourceDescs); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(29)] + public Graphics.Direct3D12.HeapProperties GetCustomHeapProperties(uint nodeMask, HeapType heapType) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[29]))((ID3D12Device4*)Unsafe.AsPointer(ref this), nodeMask, heapType); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[29]))((ID3D12Device4*)Unsafe.AsPointer(ref this), nodeMask, heapType); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(30)] + public HResult CreateCommittedResource(HeapProperties* pHeapProperties, HeapFlags HeapFlags, ResourceDescription* pDesc, ResourceStates InitialResourceState, ClearValue* pOptimizedClearValue, Guid* riidResource, void** ppvResource) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[30]))((ID3D12Device4*)Unsafe.AsPointer(ref this), pHeapProperties, HeapFlags, pDesc, InitialResourceState, pOptimizedClearValue, riidResource, ppvResource); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[30]))((ID3D12Device4*)Unsafe.AsPointer(ref this), pHeapProperties, HeapFlags, pDesc, InitialResourceState, pOptimizedClearValue, riidResource, ppvResource); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(31)] + public HResult CreateHeap(HeapDescription* pDesc, Guid* riid, void** ppvHeap) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[31]))((ID3D12Device4*)Unsafe.AsPointer(ref this), pDesc, riid, ppvHeap); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[31]))((ID3D12Device4*)Unsafe.AsPointer(ref this), pDesc, riid, ppvHeap); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(32)] + public HResult CreatePlacedResource(ID3D12Heap* pHeap, ulong HeapOffset, ResourceDescription* pDesc, ResourceStates InitialState, ClearValue* pOptimizedClearValue, Guid* riid, void** ppvResource) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[32]))((ID3D12Device4*)Unsafe.AsPointer(ref this), pHeap, HeapOffset, pDesc, InitialState, pOptimizedClearValue, riid, ppvResource); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[32]))((ID3D12Device4*)Unsafe.AsPointer(ref this), pHeap, HeapOffset, pDesc, InitialState, pOptimizedClearValue, riid, ppvResource); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(33)] + public HResult CreateReservedResource(ResourceDescription* pDesc, ResourceStates InitialState, ClearValue* pOptimizedClearValue, Guid* riid, void** ppvResource) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[33]))((ID3D12Device4*)Unsafe.AsPointer(ref this), pDesc, InitialState, pOptimizedClearValue, riid, ppvResource); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[33]))((ID3D12Device4*)Unsafe.AsPointer(ref this), pDesc, InitialState, pOptimizedClearValue, riid, ppvResource); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(34)] + public HResult CreateSharedHandle(ID3D12DeviceChild* pObject, Security.SECURITY_ATTRIBUTES* pAttributes, uint Access, char** Name, IntPtr* pHandle) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[34]))((ID3D12Device4*)Unsafe.AsPointer(ref this), pObject, pAttributes, Access, Name, pHandle); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[34]))((ID3D12Device4*)Unsafe.AsPointer(ref this), pObject, pAttributes, Access, Name, pHandle); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(35)] + public HResult OpenSharedHandle(IntPtr NTHandle, Guid* riid, void** ppvObj) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[35]))((ID3D12Device4*)Unsafe.AsPointer(ref this), NTHandle, riid, ppvObj); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[35]))((ID3D12Device4*)Unsafe.AsPointer(ref this), NTHandle, riid, ppvObj); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(36)] + public HResult OpenSharedHandleByName(char** Name, uint Access, IntPtr* pNTHandle) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[36]))((ID3D12Device4*)Unsafe.AsPointer(ref this), Name, Access, pNTHandle); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[36]))((ID3D12Device4*)Unsafe.AsPointer(ref this), Name, Access, pNTHandle); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(37)] + public HResult MakeResident(uint NumObjects, ID3D12Pageable* ppObjects) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[37]))((ID3D12Device4*)Unsafe.AsPointer(ref this), NumObjects, ppObjects); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[37]))((ID3D12Device4*)Unsafe.AsPointer(ref this), NumObjects, ppObjects); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(38)] + public HResult Evict(uint NumObjects, ID3D12Pageable* ppObjects) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[38]))((ID3D12Device4*)Unsafe.AsPointer(ref this), NumObjects, ppObjects); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[38]))((ID3D12Device4*)Unsafe.AsPointer(ref this), NumObjects, ppObjects); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(39)] + public HResult CreateFence(ulong InitialValue, FenceFlags Flags, Guid* riid, void** ppFence) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[39]))((ID3D12Device4*)Unsafe.AsPointer(ref this), InitialValue, Flags, riid, ppFence); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[39]))((ID3D12Device4*)Unsafe.AsPointer(ref this), InitialValue, Flags, riid, ppFence); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(40)] + public HResult GetDeviceRemovedReason() + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[40]))((ID3D12Device4*)Unsafe.AsPointer(ref this)); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[40]))((ID3D12Device4*)Unsafe.AsPointer(ref this)); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(41)] + public void GetCopyableFootprints(ResourceDescription* pResourceDesc, uint FirstSubresource, uint NumSubresources, ulong BaseOffset, PlacedSubresourceFootprint* pLayouts, uint* pNumRows, ulong* pRowSizeInBytes, ulong* pTotalBytes) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[41]))((ID3D12Device4*)Unsafe.AsPointer(ref this), pResourceDesc, FirstSubresource, NumSubresources, BaseOffset, pLayouts, pNumRows, pRowSizeInBytes, pTotalBytes); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[41]))((ID3D12Device4*)Unsafe.AsPointer(ref this), pResourceDesc, FirstSubresource, NumSubresources, BaseOffset, pLayouts, pNumRows, pRowSizeInBytes, pTotalBytes); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(42)] + public HResult CreateQueryHeap(QueryHeapDescription* pDesc, Guid* riid, void** ppvHeap) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[42]))((ID3D12Device4*)Unsafe.AsPointer(ref this), pDesc, riid, ppvHeap); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[42]))((ID3D12Device4*)Unsafe.AsPointer(ref this), pDesc, riid, ppvHeap); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(43)] + public HResult SetStablePowerState(Bool32 Enable) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[43]))((ID3D12Device4*)Unsafe.AsPointer(ref this), Enable); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[43]))((ID3D12Device4*)Unsafe.AsPointer(ref this), Enable); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(44)] + public HResult CreateCommandSignature(CommandSignatureDescription* pDesc, ID3D12RootSignature* pRootSignature, Guid* riid, void** ppvCommandSignature) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[44]))((ID3D12Device4*)Unsafe.AsPointer(ref this), pDesc, pRootSignature, riid, ppvCommandSignature); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[44]))((ID3D12Device4*)Unsafe.AsPointer(ref this), pDesc, pRootSignature, riid, ppvCommandSignature); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(45)] + public void GetResourceTiling(ID3D12Resource* pTiledResource, uint* pNumTilesForEntireResource, PackedMipInfo* pPackedMipDesc, TileShape* pStandardTileShapeForNonPackedMips, uint* pNumSubresourceTilings, uint FirstSubresourceTilingToGet, SubresourceTiling* pSubresourceTilingsForNonPackedMips) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[45]))((ID3D12Device4*)Unsafe.AsPointer(ref this), pTiledResource, pNumTilesForEntireResource, pPackedMipDesc, pStandardTileShapeForNonPackedMips, pNumSubresourceTilings, FirstSubresourceTilingToGet, pSubresourceTilingsForNonPackedMips); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[45]))((ID3D12Device4*)Unsafe.AsPointer(ref this), pTiledResource, pNumTilesForEntireResource, pPackedMipDesc, pStandardTileShapeForNonPackedMips, pNumSubresourceTilings, FirstSubresourceTilingToGet, pSubresourceTilingsForNonPackedMips); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(46)] + public Luid GetAdapterLuid() + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[46]))((ID3D12Device4*)Unsafe.AsPointer(ref this)); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[46]))((ID3D12Device4*)Unsafe.AsPointer(ref this)); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(47)] + public HResult GetPrivateData(Guid* guid, uint* pDataSize, void* pData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[47]))((ID3D12Device4*)Unsafe.AsPointer(ref this), guid, pDataSize, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[47]))((ID3D12Device4*)Unsafe.AsPointer(ref this), guid, pDataSize, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(48)] + public HResult SetPrivateData(Guid* guid, uint DataSize, void* pData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[48]))((ID3D12Device4*)Unsafe.AsPointer(ref this), guid, DataSize, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[48]))((ID3D12Device4*)Unsafe.AsPointer(ref this), guid, DataSize, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(49)] + public HResult SetPrivateDataInterface(Guid* guid, IUnknown* pData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[49]))((ID3D12Device4*)Unsafe.AsPointer(ref this), guid, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[49]))((ID3D12Device4*)Unsafe.AsPointer(ref this), guid, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(50)] + public HResult SetName(char** Name) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[50]))((ID3D12Device4*)Unsafe.AsPointer(ref this), Name); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[50]))((ID3D12Device4*)Unsafe.AsPointer(ref this), Name); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(51)] + public HResult CreateCommandList1(uint nodeMask, CommandListType type, CommandListFlags flags, Guid* riid, void** ppCommandList) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[51]))((ID3D12Device4*)Unsafe.AsPointer(ref this), nodeMask, type, flags, riid, ppCommandList); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[51]))((ID3D12Device4*)Unsafe.AsPointer(ref this), nodeMask, type, flags, riid, ppCommandList); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(52)] + public HResult CreateProtectedResourceSession(ProtectedResourceSessionDescription* pDesc, Guid* riid, void** ppSession) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[52]))((ID3D12Device4*)Unsafe.AsPointer(ref this), pDesc, riid, ppSession); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[52]))((ID3D12Device4*)Unsafe.AsPointer(ref this), pDesc, riid, ppSession); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(53)] + public HResult CreateCommittedResource1(HeapProperties* pHeapProperties, HeapFlags HeapFlags, ResourceDescription* pDesc, ResourceStates InitialResourceState, ClearValue* pOptimizedClearValue, ID3D12ProtectedResourceSession* pProtectedSession, Guid* riidResource, void** ppvResource) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[53]))((ID3D12Device4*)Unsafe.AsPointer(ref this), pHeapProperties, HeapFlags, pDesc, InitialResourceState, pOptimizedClearValue, pProtectedSession, riidResource, ppvResource); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[53]))((ID3D12Device4*)Unsafe.AsPointer(ref this), pHeapProperties, HeapFlags, pDesc, InitialResourceState, pOptimizedClearValue, pProtectedSession, riidResource, ppvResource); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(54)] + public HResult CreateHeap1(HeapDescription* pDesc, ID3D12ProtectedResourceSession* pProtectedSession, Guid* riid, void** ppvHeap) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[54]))((ID3D12Device4*)Unsafe.AsPointer(ref this), pDesc, pProtectedSession, riid, ppvHeap); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[54]))((ID3D12Device4*)Unsafe.AsPointer(ref this), pDesc, pProtectedSession, riid, ppvHeap); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(55)] + public HResult CreateReservedResource1(ResourceDescription* pDesc, ResourceStates InitialState, ClearValue* pOptimizedClearValue, ID3D12ProtectedResourceSession* pProtectedSession, Guid* riid, void** ppvResource) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[55]))((ID3D12Device4*)Unsafe.AsPointer(ref this), pDesc, InitialState, pOptimizedClearValue, pProtectedSession, riid, ppvResource); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[55]))((ID3D12Device4*)Unsafe.AsPointer(ref this), pDesc, InitialState, pOptimizedClearValue, pProtectedSession, riid, ppvResource); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(56)] + public Graphics.Direct3D12.ResourceAllocationInfo GetResourceAllocationInfo1(uint visibleMask, uint numResourceDescs, ResourceDescription* pResourceDescs, ResourceAllocationInfo1* pResourceAllocationInfo1) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[56]))((ID3D12Device4*)Unsafe.AsPointer(ref this), visibleMask, numResourceDescs, pResourceDescs, pResourceAllocationInfo1); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[56]))((ID3D12Device4*)Unsafe.AsPointer(ref this), visibleMask, numResourceDescs, pResourceDescs, pResourceAllocationInfo1); +#endif + } + + public interface Interface : ID3D12Device3.Interface + { + } +} + +/// +/// ID3D12LifetimeOwner +[Guid("e667af9f-cd56-4f46-83ce-032e595d70a8")] +[NativeTypeName("struct ID3D12LifetimeOwner : IUnknown")] +[NativeInheritance("IUnknown")] +public unsafe partial struct ID3D12LifetimeOwner : ID3D12LifetimeOwner.Interface +{ + public static ref readonly Guid IID_ID3D12LifetimeOwner + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x9F, 0xAF, 0x67, 0xE6, + 0x56, 0xCD, + 0x46, 0x4F, + 0x83, + 0xCE, + 0x03, + 0x2E, + 0x59, + 0x5D, + 0x70, + 0xA8 + }; + + 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_ID3D12LifetimeOwner)); + + 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 LifetimeStateUpdated(LifetimeState NewState) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[3]))((ID3D12LifetimeOwner*)Unsafe.AsPointer(ref this), NewState); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((ID3D12LifetimeOwner*)Unsafe.AsPointer(ref this), NewState); +#endif + } + + public interface Interface : IUnknown.Interface + { + } +} + +/// +/// ID3D12SwapChainAssistant +[Guid("f1df64b6-57fd-49cd-8807-c0eb88b45c8f")] +[NativeTypeName("struct ID3D12SwapChainAssistant : IUnknown")] +[NativeInheritance("IUnknown")] +public unsafe partial struct ID3D12SwapChainAssistant : ID3D12SwapChainAssistant.Interface +{ + public static ref readonly Guid IID_ID3D12SwapChainAssistant + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0xB6, 0x64, 0xDF, 0xF1, + 0xFD, 0x57, + 0xCD, 0x49, + 0x88, + 0x07, + 0xC0, + 0xEB, + 0x88, + 0xB4, + 0x5C, + 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_ID3D12SwapChainAssistant)); + + 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 Luid GetLUID() + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[3]))((ID3D12SwapChainAssistant*)Unsafe.AsPointer(ref this)); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((ID3D12SwapChainAssistant*)Unsafe.AsPointer(ref this)); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public HResult GetSwapChainObject(Guid* riid, void** ppv) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[4]))((ID3D12SwapChainAssistant*)Unsafe.AsPointer(ref this), riid, ppv); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((ID3D12SwapChainAssistant*)Unsafe.AsPointer(ref this), riid, ppv); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(5)] + public HResult GetCurrentResourceAndCommandQueue(Guid* riidResource, void** ppvResource, Guid* riidQueue, void** ppvQueue) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[5]))((ID3D12SwapChainAssistant*)Unsafe.AsPointer(ref this), riidResource, ppvResource, riidQueue, ppvQueue); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((ID3D12SwapChainAssistant*)Unsafe.AsPointer(ref this), riidResource, ppvResource, riidQueue, ppvQueue); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(6)] + public HResult InsertImplicitSync() + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[6]))((ID3D12SwapChainAssistant*)Unsafe.AsPointer(ref this)); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((ID3D12SwapChainAssistant*)Unsafe.AsPointer(ref this)); +#endif + } + + public interface Interface : IUnknown.Interface + { + } +} + +/// +/// ID3D12LifetimeTracker +[Guid("3fd03d36-4eb1-424a-a582-494ecb8ba813")] +[NativeTypeName("struct ID3D12LifetimeTracker : ID3D12DeviceChild")] +[NativeInheritance("ID3D12DeviceChild")] +public unsafe partial struct ID3D12LifetimeTracker : ID3D12LifetimeTracker.Interface +{ + public static ref readonly Guid IID_ID3D12LifetimeTracker + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x36, 0x3D, 0xD0, 0x3F, + 0xB1, 0x4E, + 0x4A, 0x42, + 0xA5, + 0x82, + 0x49, + 0x4E, + 0xCB, + 0x8B, + 0xA8, + 0x13 + }; + + 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_ID3D12LifetimeTracker)); + + 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 GetDevice(Guid* riid, void** ppvDevice) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[3]))((ID3D12LifetimeTracker*)Unsafe.AsPointer(ref this), riid, ppvDevice); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((ID3D12LifetimeTracker*)Unsafe.AsPointer(ref this), riid, ppvDevice); +#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]))((ID3D12LifetimeTracker*)Unsafe.AsPointer(ref this), guid, pDataSize, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((ID3D12LifetimeTracker*)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]))((ID3D12LifetimeTracker*)Unsafe.AsPointer(ref this), guid, DataSize, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((ID3D12LifetimeTracker*)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]))((ID3D12LifetimeTracker*)Unsafe.AsPointer(ref this), guid, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((ID3D12LifetimeTracker*)Unsafe.AsPointer(ref this), guid, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(7)] + public HResult SetName(char** Name) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[7]))((ID3D12LifetimeTracker*)Unsafe.AsPointer(ref this), Name); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((ID3D12LifetimeTracker*)Unsafe.AsPointer(ref this), Name); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(8)] + public HResult DestroyOwnedObject(ID3D12DeviceChild* pObject) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[8]))((ID3D12LifetimeTracker*)Unsafe.AsPointer(ref this), pObject); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[8]))((ID3D12LifetimeTracker*)Unsafe.AsPointer(ref this), pObject); +#endif + } + + public interface Interface : ID3D12DeviceChild.Interface + { + } +} + +/// +/// ID3D12StateObject +[Guid("47016943-fca8-4594-93ea-af258b55346d")] +[NativeTypeName("struct ID3D12StateObject : ID3D12Pageable")] +[NativeInheritance("ID3D12Pageable")] +public unsafe partial struct ID3D12StateObject : ID3D12StateObject.Interface +{ + public static ref readonly Guid IID_ID3D12StateObject + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x43, 0x69, 0x01, 0x47, + 0xA8, 0xFC, + 0x94, 0x45, + 0x93, + 0xEA, + 0xAF, + 0x25, + 0x8B, + 0x55, + 0x34, + 0x6D + }; + + 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_ID3D12StateObject)); + + 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 GetDevice(Guid* riid, void** ppvDevice) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[3]))((ID3D12StateObject*)Unsafe.AsPointer(ref this), riid, ppvDevice); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((ID3D12StateObject*)Unsafe.AsPointer(ref this), riid, ppvDevice); +#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]))((ID3D12StateObject*)Unsafe.AsPointer(ref this), guid, pDataSize, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((ID3D12StateObject*)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]))((ID3D12StateObject*)Unsafe.AsPointer(ref this), guid, DataSize, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((ID3D12StateObject*)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]))((ID3D12StateObject*)Unsafe.AsPointer(ref this), guid, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((ID3D12StateObject*)Unsafe.AsPointer(ref this), guid, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(7)] + public HResult SetName(char** Name) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[7]))((ID3D12StateObject*)Unsafe.AsPointer(ref this), Name); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((ID3D12StateObject*)Unsafe.AsPointer(ref this), Name); +#endif + } + + public interface Interface : ID3D12Pageable.Interface + { + } +} + +/// +/// ID3D12StateObjectProperties +[Guid("de5fa827-9bf9-4f26-89ff-d7f56fde3860")] +[NativeTypeName("struct ID3D12StateObjectProperties : IUnknown")] +[NativeInheritance("IUnknown")] +public unsafe partial struct ID3D12StateObjectProperties : ID3D12StateObjectProperties.Interface +{ + public static ref readonly Guid IID_ID3D12StateObjectProperties + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x27, 0xA8, 0x5F, 0xDE, + 0xF9, 0x9B, + 0x26, 0x4F, + 0x89, + 0xFF, + 0xD7, + 0xF5, + 0x6F, + 0xDE, + 0x38, + 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_ID3D12StateObjectProperties)); + + 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* GetShaderIdentifier(char** pExportName) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[3]))((ID3D12StateObjectProperties*)Unsafe.AsPointer(ref this), pExportName); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((ID3D12StateObjectProperties*)Unsafe.AsPointer(ref this), pExportName); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public ulong GetShaderStackSize(char** pExportName) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[4]))((ID3D12StateObjectProperties*)Unsafe.AsPointer(ref this), pExportName); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((ID3D12StateObjectProperties*)Unsafe.AsPointer(ref this), pExportName); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(5)] + public ulong GetPipelineStackSize() + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[5]))((ID3D12StateObjectProperties*)Unsafe.AsPointer(ref this)); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((ID3D12StateObjectProperties*)Unsafe.AsPointer(ref this)); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(6)] + public void SetPipelineStackSize(ulong PipelineStackSizeInBytes) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[6]))((ID3D12StateObjectProperties*)Unsafe.AsPointer(ref this), PipelineStackSizeInBytes); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((ID3D12StateObjectProperties*)Unsafe.AsPointer(ref this), PipelineStackSizeInBytes); +#endif + } + + public interface Interface : IUnknown.Interface + { + } +} + +/// +/// ID3D12Device5 +[Guid("8b4f173b-2fea-4b80-8f58-4307191ab95d")] +[NativeTypeName("struct ID3D12Device5 : ID3D12Device4")] +[NativeInheritance("ID3D12Device4")] +public unsafe partial struct ID3D12Device5 : ID3D12Device5.Interface +{ + public static ref readonly Guid IID_ID3D12Device5 + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x3B, 0x17, 0x4F, 0x8B, + 0xEA, 0x2F, + 0x80, 0x4B, + 0x8F, + 0x58, + 0x43, + 0x07, + 0x19, + 0x1A, + 0xB9, + 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_ID3D12Device5)); + + 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 CreateCommandList1(uint nodeMask, CommandListType type, CommandListFlags flags, Guid* riid, void** ppCommandList) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[3]))((ID3D12Device5*)Unsafe.AsPointer(ref this), nodeMask, type, flags, riid, ppCommandList); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((ID3D12Device5*)Unsafe.AsPointer(ref this), nodeMask, type, flags, riid, ppCommandList); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public HResult CreateProtectedResourceSession(ProtectedResourceSessionDescription* pDesc, Guid* riid, void** ppSession) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[4]))((ID3D12Device5*)Unsafe.AsPointer(ref this), pDesc, riid, ppSession); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((ID3D12Device5*)Unsafe.AsPointer(ref this), pDesc, riid, ppSession); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(5)] + public HResult CreateCommittedResource1(HeapProperties* pHeapProperties, HeapFlags HeapFlags, ResourceDescription* pDesc, ResourceStates InitialResourceState, ClearValue* pOptimizedClearValue, ID3D12ProtectedResourceSession* pProtectedSession, Guid* riidResource, void** ppvResource) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[5]))((ID3D12Device5*)Unsafe.AsPointer(ref this), pHeapProperties, HeapFlags, pDesc, InitialResourceState, pOptimizedClearValue, pProtectedSession, riidResource, ppvResource); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((ID3D12Device5*)Unsafe.AsPointer(ref this), pHeapProperties, HeapFlags, pDesc, InitialResourceState, pOptimizedClearValue, pProtectedSession, riidResource, ppvResource); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(6)] + public HResult CreateHeap1(HeapDescription* pDesc, ID3D12ProtectedResourceSession* pProtectedSession, Guid* riid, void** ppvHeap) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[6]))((ID3D12Device5*)Unsafe.AsPointer(ref this), pDesc, pProtectedSession, riid, ppvHeap); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((ID3D12Device5*)Unsafe.AsPointer(ref this), pDesc, pProtectedSession, riid, ppvHeap); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(7)] + public HResult CreateReservedResource1(ResourceDescription* pDesc, ResourceStates InitialState, ClearValue* pOptimizedClearValue, ID3D12ProtectedResourceSession* pProtectedSession, Guid* riid, void** ppvResource) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[7]))((ID3D12Device5*)Unsafe.AsPointer(ref this), pDesc, InitialState, pOptimizedClearValue, pProtectedSession, riid, ppvResource); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((ID3D12Device5*)Unsafe.AsPointer(ref this), pDesc, InitialState, pOptimizedClearValue, pProtectedSession, riid, ppvResource); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(8)] + public Graphics.Direct3D12.ResourceAllocationInfo GetResourceAllocationInfo1(uint visibleMask, uint numResourceDescs, ResourceDescription* pResourceDescs, ResourceAllocationInfo1* pResourceAllocationInfo1) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[8]))((ID3D12Device5*)Unsafe.AsPointer(ref this), visibleMask, numResourceDescs, pResourceDescs, pResourceAllocationInfo1); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[8]))((ID3D12Device5*)Unsafe.AsPointer(ref this), visibleMask, numResourceDescs, pResourceDescs, pResourceAllocationInfo1); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(9)] + public HResult OpenExistingHeapFromAddress(void* pAddress, Guid* riid, void** ppvHeap) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[9]))((ID3D12Device5*)Unsafe.AsPointer(ref this), pAddress, riid, ppvHeap); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[9]))((ID3D12Device5*)Unsafe.AsPointer(ref this), pAddress, riid, ppvHeap); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(10)] + public HResult OpenExistingHeapFromFileMapping(IntPtr hFileMapping, Guid* riid, void** ppvHeap) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[10]))((ID3D12Device5*)Unsafe.AsPointer(ref this), hFileMapping, riid, ppvHeap); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[10]))((ID3D12Device5*)Unsafe.AsPointer(ref this), hFileMapping, riid, ppvHeap); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(11)] + public HResult EnqueueMakeResident(ResidencyFlags Flags, uint NumObjects, ID3D12Pageable* ppObjects, ID3D12Fence* pFenceToSignal, ulong FenceValueToSignal) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[11]))((ID3D12Device5*)Unsafe.AsPointer(ref this), Flags, NumObjects, ppObjects, pFenceToSignal, FenceValueToSignal); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[11]))((ID3D12Device5*)Unsafe.AsPointer(ref this), Flags, NumObjects, ppObjects, pFenceToSignal, FenceValueToSignal); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(12)] + public HResult CreatePipelineState(PipelineStateStreamDescription* pDesc, Guid* riid, void** ppPipelineState) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[12]))((ID3D12Device5*)Unsafe.AsPointer(ref this), pDesc, riid, ppPipelineState); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[12]))((ID3D12Device5*)Unsafe.AsPointer(ref this), pDesc, riid, ppPipelineState); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(13)] + public HResult CreatePipelineLibrary(void* pLibraryBlob, nuint BlobLength, Guid* riid, void** ppPipelineLibrary) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[13]))((ID3D12Device5*)Unsafe.AsPointer(ref this), pLibraryBlob, BlobLength, riid, ppPipelineLibrary); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[13]))((ID3D12Device5*)Unsafe.AsPointer(ref this), pLibraryBlob, BlobLength, riid, ppPipelineLibrary); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(14)] + public HResult SetEventOnMultipleFenceCompletion(ID3D12Fence* ppFences, ulong* pFenceValues, uint NumFences, MultipleFenceWaitFlags Flags, IntPtr hEvent) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[14]))((ID3D12Device5*)Unsafe.AsPointer(ref this), ppFences, pFenceValues, NumFences, Flags, hEvent); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[14]))((ID3D12Device5*)Unsafe.AsPointer(ref this), ppFences, pFenceValues, NumFences, Flags, hEvent); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(15)] + public HResult SetResidencyPriority(uint NumObjects, ID3D12Pageable* ppObjects, ResidencyPriority* pPriorities) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[15]))((ID3D12Device5*)Unsafe.AsPointer(ref this), NumObjects, ppObjects, pPriorities); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[15]))((ID3D12Device5*)Unsafe.AsPointer(ref this), NumObjects, ppObjects, pPriorities); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(16)] + public uint GetNodeCount() + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[16]))((ID3D12Device5*)Unsafe.AsPointer(ref this)); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[16]))((ID3D12Device5*)Unsafe.AsPointer(ref this)); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(17)] + public HResult CreateCommandQueue(CommandQueueDescription* pDesc, Guid* riid, void** ppCommandQueue) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[17]))((ID3D12Device5*)Unsafe.AsPointer(ref this), pDesc, riid, ppCommandQueue); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[17]))((ID3D12Device5*)Unsafe.AsPointer(ref this), pDesc, riid, ppCommandQueue); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(18)] + public HResult CreateCommandAllocator(CommandListType type, Guid* riid, void** ppCommandAllocator) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[18]))((ID3D12Device5*)Unsafe.AsPointer(ref this), type, riid, ppCommandAllocator); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[18]))((ID3D12Device5*)Unsafe.AsPointer(ref this), type, riid, ppCommandAllocator); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(19)] + public HResult CreateGraphicsPipelineState(GraphicsPipelineStateDescription* pDesc, Guid* riid, void** ppPipelineState) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[19]))((ID3D12Device5*)Unsafe.AsPointer(ref this), pDesc, riid, ppPipelineState); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[19]))((ID3D12Device5*)Unsafe.AsPointer(ref this), pDesc, riid, ppPipelineState); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(20)] + public HResult CreateComputePipelineState(ComputePipelineStateDescription* pDesc, Guid* riid, void** ppPipelineState) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[20]))((ID3D12Device5*)Unsafe.AsPointer(ref this), pDesc, riid, ppPipelineState); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[20]))((ID3D12Device5*)Unsafe.AsPointer(ref this), pDesc, riid, ppPipelineState); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(21)] + public HResult CreateCommandList(uint nodeMask, CommandListType type, ID3D12CommandAllocator* pCommandAllocator, ID3D12PipelineState* pInitialState, Guid* riid, void** ppCommandList) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[21]))((ID3D12Device5*)Unsafe.AsPointer(ref this), nodeMask, type, pCommandAllocator, pInitialState, riid, ppCommandList); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[21]))((ID3D12Device5*)Unsafe.AsPointer(ref this), nodeMask, type, pCommandAllocator, pInitialState, riid, ppCommandList); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(22)] + public HResult CheckFeatureSupport(Feature Feature, void* pFeatureSupportData, uint FeatureSupportDataSize) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[22]))((ID3D12Device5*)Unsafe.AsPointer(ref this), Feature, pFeatureSupportData, FeatureSupportDataSize); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[22]))((ID3D12Device5*)Unsafe.AsPointer(ref this), Feature, pFeatureSupportData, FeatureSupportDataSize); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(23)] + public HResult CreateDescriptorHeap(DescriptorHeapDescription* pDescriptorHeapDesc, Guid* riid, void** ppvHeap) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[23]))((ID3D12Device5*)Unsafe.AsPointer(ref this), pDescriptorHeapDesc, riid, ppvHeap); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[23]))((ID3D12Device5*)Unsafe.AsPointer(ref this), pDescriptorHeapDesc, riid, ppvHeap); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(24)] + public uint GetDescriptorHandleIncrementSize(DescriptorHeapType DescriptorHeapType) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[24]))((ID3D12Device5*)Unsafe.AsPointer(ref this), DescriptorHeapType); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[24]))((ID3D12Device5*)Unsafe.AsPointer(ref this), DescriptorHeapType); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(25)] + public HResult CreateRootSignature(uint nodeMask, void* pBlobWithRootSignature, nuint blobLengthInBytes, Guid* riid, void** ppvRootSignature) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[25]))((ID3D12Device5*)Unsafe.AsPointer(ref this), nodeMask, pBlobWithRootSignature, blobLengthInBytes, riid, ppvRootSignature); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[25]))((ID3D12Device5*)Unsafe.AsPointer(ref this), nodeMask, pBlobWithRootSignature, blobLengthInBytes, riid, ppvRootSignature); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(26)] + public void CreateConstantBufferView(ConstantBufferViewDescription* pDesc, CpuDescriptorHandle* DestDescriptor) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[26]))((ID3D12Device5*)Unsafe.AsPointer(ref this), pDesc, DestDescriptor); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[26]))((ID3D12Device5*)Unsafe.AsPointer(ref this), pDesc, DestDescriptor); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(27)] + public void CreateShaderResourceView(ID3D12Resource* pResource, ShaderResourceViewDescription* pDesc, CpuDescriptorHandle* DestDescriptor) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[27]))((ID3D12Device5*)Unsafe.AsPointer(ref this), pResource, pDesc, DestDescriptor); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[27]))((ID3D12Device5*)Unsafe.AsPointer(ref this), pResource, pDesc, DestDescriptor); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(28)] + public void CreateUnorderedAccessView(ID3D12Resource* pResource, ID3D12Resource* pCounterResource, UnorderedAccessViewDescription* pDesc, CpuDescriptorHandle* DestDescriptor) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[28]))((ID3D12Device5*)Unsafe.AsPointer(ref this), pResource, pCounterResource, pDesc, DestDescriptor); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[28]))((ID3D12Device5*)Unsafe.AsPointer(ref this), pResource, pCounterResource, pDesc, DestDescriptor); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(29)] + public void CreateRenderTargetView(ID3D12Resource* pResource, RenderTargetViewDescription* pDesc, CpuDescriptorHandle* DestDescriptor) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[29]))((ID3D12Device5*)Unsafe.AsPointer(ref this), pResource, pDesc, DestDescriptor); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[29]))((ID3D12Device5*)Unsafe.AsPointer(ref this), pResource, pDesc, DestDescriptor); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(30)] + public void CreateDepthStencilView(ID3D12Resource* pResource, DepthStencilViewDescription* pDesc, CpuDescriptorHandle* DestDescriptor) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[30]))((ID3D12Device5*)Unsafe.AsPointer(ref this), pResource, pDesc, DestDescriptor); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[30]))((ID3D12Device5*)Unsafe.AsPointer(ref this), pResource, pDesc, DestDescriptor); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(31)] + public void CreateSampler(SamplerDescription* pDesc, CpuDescriptorHandle* DestDescriptor) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[31]))((ID3D12Device5*)Unsafe.AsPointer(ref this), pDesc, DestDescriptor); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[31]))((ID3D12Device5*)Unsafe.AsPointer(ref this), pDesc, DestDescriptor); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(32)] + public void CopyDescriptors(uint NumDestDescriptorRanges, CpuDescriptorHandle* pDestDescriptorRangeStarts, uint* pDestDescriptorRangeSizes, uint NumSrcDescriptorRanges, CpuDescriptorHandle* pSrcDescriptorRangeStarts, uint* pSrcDescriptorRangeSizes, DescriptorHeapType DescriptorHeapsType) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[32]))((ID3D12Device5*)Unsafe.AsPointer(ref this), NumDestDescriptorRanges, pDestDescriptorRangeStarts, pDestDescriptorRangeSizes, NumSrcDescriptorRanges, pSrcDescriptorRangeStarts, pSrcDescriptorRangeSizes, DescriptorHeapsType); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[32]))((ID3D12Device5*)Unsafe.AsPointer(ref this), NumDestDescriptorRanges, pDestDescriptorRangeStarts, pDestDescriptorRangeSizes, NumSrcDescriptorRanges, pSrcDescriptorRangeStarts, pSrcDescriptorRangeSizes, DescriptorHeapsType); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(33)] + public void CopyDescriptorsSimple(uint NumDescriptors, CpuDescriptorHandle* DestDescriptorRangeStart, CpuDescriptorHandle* SrcDescriptorRangeStart, DescriptorHeapType DescriptorHeapsType) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[33]))((ID3D12Device5*)Unsafe.AsPointer(ref this), NumDescriptors, DestDescriptorRangeStart, SrcDescriptorRangeStart, DescriptorHeapsType); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[33]))((ID3D12Device5*)Unsafe.AsPointer(ref this), NumDescriptors, DestDescriptorRangeStart, SrcDescriptorRangeStart, DescriptorHeapsType); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(34)] + public Graphics.Direct3D12.ResourceAllocationInfo GetResourceAllocationInfo(uint visibleMask, uint numResourceDescs, ResourceDescription* pResourceDescs) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[34]))((ID3D12Device5*)Unsafe.AsPointer(ref this), visibleMask, numResourceDescs, pResourceDescs); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[34]))((ID3D12Device5*)Unsafe.AsPointer(ref this), visibleMask, numResourceDescs, pResourceDescs); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(35)] + public Graphics.Direct3D12.HeapProperties GetCustomHeapProperties(uint nodeMask, HeapType heapType) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[35]))((ID3D12Device5*)Unsafe.AsPointer(ref this), nodeMask, heapType); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[35]))((ID3D12Device5*)Unsafe.AsPointer(ref this), nodeMask, heapType); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(36)] + public HResult CreateCommittedResource(HeapProperties* pHeapProperties, HeapFlags HeapFlags, ResourceDescription* pDesc, ResourceStates InitialResourceState, ClearValue* pOptimizedClearValue, Guid* riidResource, void** ppvResource) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[36]))((ID3D12Device5*)Unsafe.AsPointer(ref this), pHeapProperties, HeapFlags, pDesc, InitialResourceState, pOptimizedClearValue, riidResource, ppvResource); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[36]))((ID3D12Device5*)Unsafe.AsPointer(ref this), pHeapProperties, HeapFlags, pDesc, InitialResourceState, pOptimizedClearValue, riidResource, ppvResource); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(37)] + public HResult CreateHeap(HeapDescription* pDesc, Guid* riid, void** ppvHeap) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[37]))((ID3D12Device5*)Unsafe.AsPointer(ref this), pDesc, riid, ppvHeap); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[37]))((ID3D12Device5*)Unsafe.AsPointer(ref this), pDesc, riid, ppvHeap); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(38)] + public HResult CreatePlacedResource(ID3D12Heap* pHeap, ulong HeapOffset, ResourceDescription* pDesc, ResourceStates InitialState, ClearValue* pOptimizedClearValue, Guid* riid, void** ppvResource) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[38]))((ID3D12Device5*)Unsafe.AsPointer(ref this), pHeap, HeapOffset, pDesc, InitialState, pOptimizedClearValue, riid, ppvResource); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[38]))((ID3D12Device5*)Unsafe.AsPointer(ref this), pHeap, HeapOffset, pDesc, InitialState, pOptimizedClearValue, riid, ppvResource); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(39)] + public HResult CreateReservedResource(ResourceDescription* pDesc, ResourceStates InitialState, ClearValue* pOptimizedClearValue, Guid* riid, void** ppvResource) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[39]))((ID3D12Device5*)Unsafe.AsPointer(ref this), pDesc, InitialState, pOptimizedClearValue, riid, ppvResource); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[39]))((ID3D12Device5*)Unsafe.AsPointer(ref this), pDesc, InitialState, pOptimizedClearValue, riid, ppvResource); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(40)] + public HResult CreateSharedHandle(ID3D12DeviceChild* pObject, Security.SECURITY_ATTRIBUTES* pAttributes, uint Access, char** Name, IntPtr* pHandle) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[40]))((ID3D12Device5*)Unsafe.AsPointer(ref this), pObject, pAttributes, Access, Name, pHandle); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[40]))((ID3D12Device5*)Unsafe.AsPointer(ref this), pObject, pAttributes, Access, Name, pHandle); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(41)] + public HResult OpenSharedHandle(IntPtr NTHandle, Guid* riid, void** ppvObj) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[41]))((ID3D12Device5*)Unsafe.AsPointer(ref this), NTHandle, riid, ppvObj); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[41]))((ID3D12Device5*)Unsafe.AsPointer(ref this), NTHandle, riid, ppvObj); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(42)] + public HResult OpenSharedHandleByName(char** Name, uint Access, IntPtr* pNTHandle) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[42]))((ID3D12Device5*)Unsafe.AsPointer(ref this), Name, Access, pNTHandle); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[42]))((ID3D12Device5*)Unsafe.AsPointer(ref this), Name, Access, pNTHandle); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(43)] + public HResult MakeResident(uint NumObjects, ID3D12Pageable* ppObjects) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[43]))((ID3D12Device5*)Unsafe.AsPointer(ref this), NumObjects, ppObjects); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[43]))((ID3D12Device5*)Unsafe.AsPointer(ref this), NumObjects, ppObjects); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(44)] + public HResult Evict(uint NumObjects, ID3D12Pageable* ppObjects) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[44]))((ID3D12Device5*)Unsafe.AsPointer(ref this), NumObjects, ppObjects); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[44]))((ID3D12Device5*)Unsafe.AsPointer(ref this), NumObjects, ppObjects); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(45)] + public HResult CreateFence(ulong InitialValue, FenceFlags Flags, Guid* riid, void** ppFence) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[45]))((ID3D12Device5*)Unsafe.AsPointer(ref this), InitialValue, Flags, riid, ppFence); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[45]))((ID3D12Device5*)Unsafe.AsPointer(ref this), InitialValue, Flags, riid, ppFence); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(46)] + public HResult GetDeviceRemovedReason() + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[46]))((ID3D12Device5*)Unsafe.AsPointer(ref this)); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[46]))((ID3D12Device5*)Unsafe.AsPointer(ref this)); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(47)] + public void GetCopyableFootprints(ResourceDescription* pResourceDesc, uint FirstSubresource, uint NumSubresources, ulong BaseOffset, PlacedSubresourceFootprint* pLayouts, uint* pNumRows, ulong* pRowSizeInBytes, ulong* pTotalBytes) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[47]))((ID3D12Device5*)Unsafe.AsPointer(ref this), pResourceDesc, FirstSubresource, NumSubresources, BaseOffset, pLayouts, pNumRows, pRowSizeInBytes, pTotalBytes); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[47]))((ID3D12Device5*)Unsafe.AsPointer(ref this), pResourceDesc, FirstSubresource, NumSubresources, BaseOffset, pLayouts, pNumRows, pRowSizeInBytes, pTotalBytes); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(48)] + public HResult CreateQueryHeap(QueryHeapDescription* pDesc, Guid* riid, void** ppvHeap) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[48]))((ID3D12Device5*)Unsafe.AsPointer(ref this), pDesc, riid, ppvHeap); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[48]))((ID3D12Device5*)Unsafe.AsPointer(ref this), pDesc, riid, ppvHeap); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(49)] + public HResult SetStablePowerState(Bool32 Enable) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[49]))((ID3D12Device5*)Unsafe.AsPointer(ref this), Enable); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[49]))((ID3D12Device5*)Unsafe.AsPointer(ref this), Enable); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(50)] + public HResult CreateCommandSignature(CommandSignatureDescription* pDesc, ID3D12RootSignature* pRootSignature, Guid* riid, void** ppvCommandSignature) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[50]))((ID3D12Device5*)Unsafe.AsPointer(ref this), pDesc, pRootSignature, riid, ppvCommandSignature); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[50]))((ID3D12Device5*)Unsafe.AsPointer(ref this), pDesc, pRootSignature, riid, ppvCommandSignature); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(51)] + public void GetResourceTiling(ID3D12Resource* pTiledResource, uint* pNumTilesForEntireResource, PackedMipInfo* pPackedMipDesc, TileShape* pStandardTileShapeForNonPackedMips, uint* pNumSubresourceTilings, uint FirstSubresourceTilingToGet, SubresourceTiling* pSubresourceTilingsForNonPackedMips) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[51]))((ID3D12Device5*)Unsafe.AsPointer(ref this), pTiledResource, pNumTilesForEntireResource, pPackedMipDesc, pStandardTileShapeForNonPackedMips, pNumSubresourceTilings, FirstSubresourceTilingToGet, pSubresourceTilingsForNonPackedMips); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[51]))((ID3D12Device5*)Unsafe.AsPointer(ref this), pTiledResource, pNumTilesForEntireResource, pPackedMipDesc, pStandardTileShapeForNonPackedMips, pNumSubresourceTilings, FirstSubresourceTilingToGet, pSubresourceTilingsForNonPackedMips); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(52)] + public Luid GetAdapterLuid() + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[52]))((ID3D12Device5*)Unsafe.AsPointer(ref this)); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[52]))((ID3D12Device5*)Unsafe.AsPointer(ref this)); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(53)] + public HResult GetPrivateData(Guid* guid, uint* pDataSize, void* pData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[53]))((ID3D12Device5*)Unsafe.AsPointer(ref this), guid, pDataSize, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[53]))((ID3D12Device5*)Unsafe.AsPointer(ref this), guid, pDataSize, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(54)] + public HResult SetPrivateData(Guid* guid, uint DataSize, void* pData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[54]))((ID3D12Device5*)Unsafe.AsPointer(ref this), guid, DataSize, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[54]))((ID3D12Device5*)Unsafe.AsPointer(ref this), guid, DataSize, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(55)] + public HResult SetPrivateDataInterface(Guid* guid, IUnknown* pData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[55]))((ID3D12Device5*)Unsafe.AsPointer(ref this), guid, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[55]))((ID3D12Device5*)Unsafe.AsPointer(ref this), guid, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(56)] + public HResult SetName(char** Name) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[56]))((ID3D12Device5*)Unsafe.AsPointer(ref this), Name); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[56]))((ID3D12Device5*)Unsafe.AsPointer(ref this), Name); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(57)] + public HResult CreateLifetimeTracker(ID3D12LifetimeOwner* pOwner, Guid* riid, void** ppvTracker) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[57]))((ID3D12Device5*)Unsafe.AsPointer(ref this), pOwner, riid, ppvTracker); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[57]))((ID3D12Device5*)Unsafe.AsPointer(ref this), pOwner, riid, ppvTracker); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(58)] + public void RemoveDevice() + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[58]))((ID3D12Device5*)Unsafe.AsPointer(ref this)); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[58]))((ID3D12Device5*)Unsafe.AsPointer(ref this)); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(59)] + public HResult EnumerateMetaCommands(uint* pNumMetaCommands, MetaCommandDescription* pDescs) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[59]))((ID3D12Device5*)Unsafe.AsPointer(ref this), pNumMetaCommands, pDescs); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[59]))((ID3D12Device5*)Unsafe.AsPointer(ref this), pNumMetaCommands, pDescs); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(60)] + public HResult EnumerateMetaCommandParameters(Guid* CommandId, MetaCommandParameterStage Stage, uint* pTotalStructureSizeInBytes, uint* pParameterCount, MetaCommandParameterDescription* pParameterDescs) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[60]))((ID3D12Device5*)Unsafe.AsPointer(ref this), CommandId, Stage, pTotalStructureSizeInBytes, pParameterCount, pParameterDescs); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[60]))((ID3D12Device5*)Unsafe.AsPointer(ref this), CommandId, Stage, pTotalStructureSizeInBytes, pParameterCount, pParameterDescs); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(61)] + public HResult CreateMetaCommand(Guid* CommandId, uint NodeMask, void* pCreationParametersData, nuint CreationParametersDataSizeInBytes, Guid* riid, void** ppMetaCommand) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[61]))((ID3D12Device5*)Unsafe.AsPointer(ref this), CommandId, NodeMask, pCreationParametersData, CreationParametersDataSizeInBytes, riid, ppMetaCommand); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[61]))((ID3D12Device5*)Unsafe.AsPointer(ref this), CommandId, NodeMask, pCreationParametersData, CreationParametersDataSizeInBytes, riid, ppMetaCommand); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(62)] + public HResult CreateStateObject(StateObjectDescription* pDesc, Guid* riid, void** ppStateObject) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[62]))((ID3D12Device5*)Unsafe.AsPointer(ref this), pDesc, riid, ppStateObject); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[62]))((ID3D12Device5*)Unsafe.AsPointer(ref this), pDesc, riid, ppStateObject); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(63)] + public void GetRaytracingAccelerationStructurePrebuildInfo(BuildRaytracingAccelerationStructureInputs* pDesc, RaytracingAccelerationStructurePrebuildInfo* pInfo) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[63]))((ID3D12Device5*)Unsafe.AsPointer(ref this), pDesc, pInfo); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[63]))((ID3D12Device5*)Unsafe.AsPointer(ref this), pDesc, pInfo); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(64)] + public Graphics.Direct3D12.DriverMatchingIdentifierStatus CheckDriverMatchingIdentifier(SerializedDataType SerializedDataType, SerializedDataDriverMatchingIdentifier* pIdentifierToCheck) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[64]))((ID3D12Device5*)Unsafe.AsPointer(ref this), SerializedDataType, pIdentifierToCheck); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[64]))((ID3D12Device5*)Unsafe.AsPointer(ref this), SerializedDataType, pIdentifierToCheck); +#endif + } + + public interface Interface : ID3D12Device4.Interface + { + } +} + +/// +/// ID3D12DeviceRemovedExtendedDataSettings +[Guid("82bc481c-6b9b-4030-aedb-7ee3d1df1e63")] +[NativeTypeName("struct ID3D12DeviceRemovedExtendedDataSettings : IUnknown")] +[NativeInheritance("IUnknown")] +public unsafe partial struct ID3D12DeviceRemovedExtendedDataSettings : ID3D12DeviceRemovedExtendedDataSettings.Interface +{ + public static ref readonly Guid IID_ID3D12DeviceRemovedExtendedDataSettings + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x1C, 0x48, 0xBC, 0x82, + 0x9B, 0x6B, + 0x30, 0x40, + 0xAE, + 0xDB, + 0x7E, + 0xE3, + 0xD1, + 0xDF, + 0x1E, + 0x63 + }; + + 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_ID3D12DeviceRemovedExtendedDataSettings)); + + 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 SetAutoBreadcrumbsEnablement(DredEnablement Enablement) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[3]))((ID3D12DeviceRemovedExtendedDataSettings*)Unsafe.AsPointer(ref this), Enablement); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((ID3D12DeviceRemovedExtendedDataSettings*)Unsafe.AsPointer(ref this), Enablement); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public void SetPageFaultEnablement(DredEnablement Enablement) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[4]))((ID3D12DeviceRemovedExtendedDataSettings*)Unsafe.AsPointer(ref this), Enablement); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((ID3D12DeviceRemovedExtendedDataSettings*)Unsafe.AsPointer(ref this), Enablement); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(5)] + public void SetWatsonDumpEnablement(DredEnablement Enablement) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[5]))((ID3D12DeviceRemovedExtendedDataSettings*)Unsafe.AsPointer(ref this), Enablement); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((ID3D12DeviceRemovedExtendedDataSettings*)Unsafe.AsPointer(ref this), Enablement); +#endif + } + + public interface Interface : IUnknown.Interface + { + } +} + +/// +/// ID3D12DeviceRemovedExtendedDataSettings1 +[Guid("dbd5ae51-3317-4f0a-adf9-1d7cedcaae0b")] +[NativeTypeName("struct ID3D12DeviceRemovedExtendedDataSettings1 : ID3D12DeviceRemovedExtendedDataSettings")] +[NativeInheritance("ID3D12DeviceRemovedExtendedDataSettings")] +public unsafe partial struct ID3D12DeviceRemovedExtendedDataSettings1 : ID3D12DeviceRemovedExtendedDataSettings1.Interface +{ + public static ref readonly Guid IID_ID3D12DeviceRemovedExtendedDataSettings1 + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x51, 0xAE, 0xD5, 0xDB, + 0x17, 0x33, + 0x0A, 0x4F, + 0xAD, + 0xF9, + 0x1D, + 0x7C, + 0xED, + 0xCA, + 0xAE, + 0x0B + }; + + 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_ID3D12DeviceRemovedExtendedDataSettings1)); + + 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 SetAutoBreadcrumbsEnablement(DredEnablement Enablement) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[3]))((ID3D12DeviceRemovedExtendedDataSettings1*)Unsafe.AsPointer(ref this), Enablement); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((ID3D12DeviceRemovedExtendedDataSettings1*)Unsafe.AsPointer(ref this), Enablement); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public void SetPageFaultEnablement(DredEnablement Enablement) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[4]))((ID3D12DeviceRemovedExtendedDataSettings1*)Unsafe.AsPointer(ref this), Enablement); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((ID3D12DeviceRemovedExtendedDataSettings1*)Unsafe.AsPointer(ref this), Enablement); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(5)] + public void SetWatsonDumpEnablement(DredEnablement Enablement) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[5]))((ID3D12DeviceRemovedExtendedDataSettings1*)Unsafe.AsPointer(ref this), Enablement); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((ID3D12DeviceRemovedExtendedDataSettings1*)Unsafe.AsPointer(ref this), Enablement); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(6)] + public void SetBreadcrumbContextEnablement(DredEnablement Enablement) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[6]))((ID3D12DeviceRemovedExtendedDataSettings1*)Unsafe.AsPointer(ref this), Enablement); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((ID3D12DeviceRemovedExtendedDataSettings1*)Unsafe.AsPointer(ref this), Enablement); +#endif + } + + public interface Interface : ID3D12DeviceRemovedExtendedDataSettings.Interface + { + } +} + +/// +/// ID3D12DeviceRemovedExtendedData +[Guid("98931d33-5ae8-4791-aa3c-1a73a2934e71")] +[NativeTypeName("struct ID3D12DeviceRemovedExtendedData : IUnknown")] +[NativeInheritance("IUnknown")] +public unsafe partial struct ID3D12DeviceRemovedExtendedData : ID3D12DeviceRemovedExtendedData.Interface +{ + public static ref readonly Guid IID_ID3D12DeviceRemovedExtendedData + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x33, 0x1D, 0x93, 0x98, + 0xE8, 0x5A, + 0x91, 0x47, + 0xAA, + 0x3C, + 0x1A, + 0x73, + 0xA2, + 0x93, + 0x4E, + 0x71 + }; + + 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_ID3D12DeviceRemovedExtendedData)); + + 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 GetAutoBreadcrumbsOutput(DredAutoBreadcrumbsOutput* pOutput) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[3]))((ID3D12DeviceRemovedExtendedData*)Unsafe.AsPointer(ref this), pOutput); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((ID3D12DeviceRemovedExtendedData*)Unsafe.AsPointer(ref this), pOutput); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public HResult GetPageFaultAllocationOutput(DredPageFaultOutput* pOutput) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[4]))((ID3D12DeviceRemovedExtendedData*)Unsafe.AsPointer(ref this), pOutput); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((ID3D12DeviceRemovedExtendedData*)Unsafe.AsPointer(ref this), pOutput); +#endif + } + + public interface Interface : IUnknown.Interface + { + } +} + +/// +/// ID3D12DeviceRemovedExtendedData1 +[Guid("9727a022-cf1d-4dda-9eba-effa653fc506")] +[NativeTypeName("struct ID3D12DeviceRemovedExtendedData1 : ID3D12DeviceRemovedExtendedData")] +[NativeInheritance("ID3D12DeviceRemovedExtendedData")] +public unsafe partial struct ID3D12DeviceRemovedExtendedData1 : ID3D12DeviceRemovedExtendedData1.Interface +{ + public static ref readonly Guid IID_ID3D12DeviceRemovedExtendedData1 + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x22, 0xA0, 0x27, 0x97, + 0x1D, 0xCF, + 0xDA, 0x4D, + 0x9E, + 0xBA, + 0xEF, + 0xFA, + 0x65, + 0x3F, + 0xC5, + 0x06 + }; + + 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_ID3D12DeviceRemovedExtendedData1)); + + 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 GetAutoBreadcrumbsOutput(DredAutoBreadcrumbsOutput* pOutput) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[3]))((ID3D12DeviceRemovedExtendedData1*)Unsafe.AsPointer(ref this), pOutput); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((ID3D12DeviceRemovedExtendedData1*)Unsafe.AsPointer(ref this), pOutput); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public HResult GetPageFaultAllocationOutput(DredPageFaultOutput* pOutput) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[4]))((ID3D12DeviceRemovedExtendedData1*)Unsafe.AsPointer(ref this), pOutput); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((ID3D12DeviceRemovedExtendedData1*)Unsafe.AsPointer(ref this), pOutput); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(5)] + public HResult GetAutoBreadcrumbsOutput1(DredAutoBreadcrumbsOutput1* pOutput) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[5]))((ID3D12DeviceRemovedExtendedData1*)Unsafe.AsPointer(ref this), pOutput); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((ID3D12DeviceRemovedExtendedData1*)Unsafe.AsPointer(ref this), pOutput); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(6)] + public HResult GetPageFaultAllocationOutput1(DredPageFaultOutput1* pOutput) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[6]))((ID3D12DeviceRemovedExtendedData1*)Unsafe.AsPointer(ref this), pOutput); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((ID3D12DeviceRemovedExtendedData1*)Unsafe.AsPointer(ref this), pOutput); +#endif + } + + public interface Interface : ID3D12DeviceRemovedExtendedData.Interface + { + } +} + +/// +/// ID3D12DeviceRemovedExtendedData2 +[Guid("67fc5816-e4ca-4915-bf18-42541272da54")] +[NativeTypeName("struct ID3D12DeviceRemovedExtendedData2 : ID3D12DeviceRemovedExtendedData1")] +[NativeInheritance("ID3D12DeviceRemovedExtendedData1")] +public unsafe partial struct ID3D12DeviceRemovedExtendedData2 : ID3D12DeviceRemovedExtendedData2.Interface +{ + public static ref readonly Guid IID_ID3D12DeviceRemovedExtendedData2 + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x16, 0x58, 0xFC, 0x67, + 0xCA, 0xE4, + 0x15, 0x49, + 0xBF, + 0x18, + 0x42, + 0x54, + 0x12, + 0x72, + 0xDA, + 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_ID3D12DeviceRemovedExtendedData2)); + + 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 GetAutoBreadcrumbsOutput1(DredAutoBreadcrumbsOutput1* pOutput) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[3]))((ID3D12DeviceRemovedExtendedData2*)Unsafe.AsPointer(ref this), pOutput); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((ID3D12DeviceRemovedExtendedData2*)Unsafe.AsPointer(ref this), pOutput); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public HResult GetPageFaultAllocationOutput1(DredPageFaultOutput1* pOutput) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[4]))((ID3D12DeviceRemovedExtendedData2*)Unsafe.AsPointer(ref this), pOutput); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((ID3D12DeviceRemovedExtendedData2*)Unsafe.AsPointer(ref this), pOutput); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(5)] + public HResult GetAutoBreadcrumbsOutput(DredAutoBreadcrumbsOutput* pOutput) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[5]))((ID3D12DeviceRemovedExtendedData2*)Unsafe.AsPointer(ref this), pOutput); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((ID3D12DeviceRemovedExtendedData2*)Unsafe.AsPointer(ref this), pOutput); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(6)] + public HResult GetPageFaultAllocationOutput(DredPageFaultOutput* pOutput) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[6]))((ID3D12DeviceRemovedExtendedData2*)Unsafe.AsPointer(ref this), pOutput); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((ID3D12DeviceRemovedExtendedData2*)Unsafe.AsPointer(ref this), pOutput); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(7)] + public HResult GetPageFaultAllocationOutput2(DredPageFaultOutput2* pOutput) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[7]))((ID3D12DeviceRemovedExtendedData2*)Unsafe.AsPointer(ref this), pOutput); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((ID3D12DeviceRemovedExtendedData2*)Unsafe.AsPointer(ref this), pOutput); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(8)] + public Graphics.Direct3D12.DredDeviceState GetDeviceState() + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[8]))((ID3D12DeviceRemovedExtendedData2*)Unsafe.AsPointer(ref this)); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[8]))((ID3D12DeviceRemovedExtendedData2*)Unsafe.AsPointer(ref this)); +#endif + } + + public interface Interface : ID3D12DeviceRemovedExtendedData1.Interface + { + } +} + +/// +/// ID3D12Device6 +[Guid("c70b221b-40e4-4a17-89af-025a0727a6dc")] +[NativeTypeName("struct ID3D12Device6 : ID3D12Device5")] +[NativeInheritance("ID3D12Device5")] +public unsafe partial struct ID3D12Device6 : ID3D12Device6.Interface +{ + public static ref readonly Guid IID_ID3D12Device6 + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x1B, 0x22, 0x0B, 0xC7, + 0xE4, 0x40, + 0x17, 0x4A, + 0x89, + 0xAF, + 0x02, + 0x5A, + 0x07, + 0x27, + 0xA6, + 0xDC + }; + + 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_ID3D12Device6)); + + 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 CreateLifetimeTracker(ID3D12LifetimeOwner* pOwner, Guid* riid, void** ppvTracker) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[3]))((ID3D12Device6*)Unsafe.AsPointer(ref this), pOwner, riid, ppvTracker); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((ID3D12Device6*)Unsafe.AsPointer(ref this), pOwner, riid, ppvTracker); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public void RemoveDevice() + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[4]))((ID3D12Device6*)Unsafe.AsPointer(ref this)); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((ID3D12Device6*)Unsafe.AsPointer(ref this)); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(5)] + public HResult EnumerateMetaCommands(uint* pNumMetaCommands, MetaCommandDescription* pDescs) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[5]))((ID3D12Device6*)Unsafe.AsPointer(ref this), pNumMetaCommands, pDescs); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((ID3D12Device6*)Unsafe.AsPointer(ref this), pNumMetaCommands, pDescs); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(6)] + public HResult EnumerateMetaCommandParameters(Guid* CommandId, MetaCommandParameterStage Stage, uint* pTotalStructureSizeInBytes, uint* pParameterCount, MetaCommandParameterDescription* pParameterDescs) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[6]))((ID3D12Device6*)Unsafe.AsPointer(ref this), CommandId, Stage, pTotalStructureSizeInBytes, pParameterCount, pParameterDescs); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((ID3D12Device6*)Unsafe.AsPointer(ref this), CommandId, Stage, pTotalStructureSizeInBytes, pParameterCount, pParameterDescs); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(7)] + public HResult CreateMetaCommand(Guid* CommandId, uint NodeMask, void* pCreationParametersData, nuint CreationParametersDataSizeInBytes, Guid* riid, void** ppMetaCommand) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[7]))((ID3D12Device6*)Unsafe.AsPointer(ref this), CommandId, NodeMask, pCreationParametersData, CreationParametersDataSizeInBytes, riid, ppMetaCommand); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((ID3D12Device6*)Unsafe.AsPointer(ref this), CommandId, NodeMask, pCreationParametersData, CreationParametersDataSizeInBytes, riid, ppMetaCommand); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(8)] + public HResult CreateStateObject(StateObjectDescription* pDesc, Guid* riid, void** ppStateObject) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[8]))((ID3D12Device6*)Unsafe.AsPointer(ref this), pDesc, riid, ppStateObject); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[8]))((ID3D12Device6*)Unsafe.AsPointer(ref this), pDesc, riid, ppStateObject); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(9)] + public void GetRaytracingAccelerationStructurePrebuildInfo(BuildRaytracingAccelerationStructureInputs* pDesc, RaytracingAccelerationStructurePrebuildInfo* pInfo) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[9]))((ID3D12Device6*)Unsafe.AsPointer(ref this), pDesc, pInfo); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[9]))((ID3D12Device6*)Unsafe.AsPointer(ref this), pDesc, pInfo); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(10)] + public Graphics.Direct3D12.DriverMatchingIdentifierStatus CheckDriverMatchingIdentifier(SerializedDataType SerializedDataType, SerializedDataDriverMatchingIdentifier* pIdentifierToCheck) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[10]))((ID3D12Device6*)Unsafe.AsPointer(ref this), SerializedDataType, pIdentifierToCheck); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[10]))((ID3D12Device6*)Unsafe.AsPointer(ref this), SerializedDataType, pIdentifierToCheck); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(11)] + public HResult CreateCommandList1(uint nodeMask, CommandListType type, CommandListFlags flags, Guid* riid, void** ppCommandList) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[11]))((ID3D12Device6*)Unsafe.AsPointer(ref this), nodeMask, type, flags, riid, ppCommandList); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[11]))((ID3D12Device6*)Unsafe.AsPointer(ref this), nodeMask, type, flags, riid, ppCommandList); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(12)] + public HResult CreateProtectedResourceSession(ProtectedResourceSessionDescription* pDesc, Guid* riid, void** ppSession) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[12]))((ID3D12Device6*)Unsafe.AsPointer(ref this), pDesc, riid, ppSession); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[12]))((ID3D12Device6*)Unsafe.AsPointer(ref this), pDesc, riid, ppSession); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(13)] + public HResult CreateCommittedResource1(HeapProperties* pHeapProperties, HeapFlags HeapFlags, ResourceDescription* pDesc, ResourceStates InitialResourceState, ClearValue* pOptimizedClearValue, ID3D12ProtectedResourceSession* pProtectedSession, Guid* riidResource, void** ppvResource) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[13]))((ID3D12Device6*)Unsafe.AsPointer(ref this), pHeapProperties, HeapFlags, pDesc, InitialResourceState, pOptimizedClearValue, pProtectedSession, riidResource, ppvResource); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[13]))((ID3D12Device6*)Unsafe.AsPointer(ref this), pHeapProperties, HeapFlags, pDesc, InitialResourceState, pOptimizedClearValue, pProtectedSession, riidResource, ppvResource); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(14)] + public HResult CreateHeap1(HeapDescription* pDesc, ID3D12ProtectedResourceSession* pProtectedSession, Guid* riid, void** ppvHeap) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[14]))((ID3D12Device6*)Unsafe.AsPointer(ref this), pDesc, pProtectedSession, riid, ppvHeap); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[14]))((ID3D12Device6*)Unsafe.AsPointer(ref this), pDesc, pProtectedSession, riid, ppvHeap); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(15)] + public HResult CreateReservedResource1(ResourceDescription* pDesc, ResourceStates InitialState, ClearValue* pOptimizedClearValue, ID3D12ProtectedResourceSession* pProtectedSession, Guid* riid, void** ppvResource) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[15]))((ID3D12Device6*)Unsafe.AsPointer(ref this), pDesc, InitialState, pOptimizedClearValue, pProtectedSession, riid, ppvResource); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[15]))((ID3D12Device6*)Unsafe.AsPointer(ref this), pDesc, InitialState, pOptimizedClearValue, pProtectedSession, riid, ppvResource); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(16)] + public Graphics.Direct3D12.ResourceAllocationInfo GetResourceAllocationInfo1(uint visibleMask, uint numResourceDescs, ResourceDescription* pResourceDescs, ResourceAllocationInfo1* pResourceAllocationInfo1) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[16]))((ID3D12Device6*)Unsafe.AsPointer(ref this), visibleMask, numResourceDescs, pResourceDescs, pResourceAllocationInfo1); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[16]))((ID3D12Device6*)Unsafe.AsPointer(ref this), visibleMask, numResourceDescs, pResourceDescs, pResourceAllocationInfo1); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(17)] + public HResult OpenExistingHeapFromAddress(void* pAddress, Guid* riid, void** ppvHeap) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[17]))((ID3D12Device6*)Unsafe.AsPointer(ref this), pAddress, riid, ppvHeap); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[17]))((ID3D12Device6*)Unsafe.AsPointer(ref this), pAddress, riid, ppvHeap); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(18)] + public HResult OpenExistingHeapFromFileMapping(IntPtr hFileMapping, Guid* riid, void** ppvHeap) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[18]))((ID3D12Device6*)Unsafe.AsPointer(ref this), hFileMapping, riid, ppvHeap); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[18]))((ID3D12Device6*)Unsafe.AsPointer(ref this), hFileMapping, riid, ppvHeap); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(19)] + public HResult EnqueueMakeResident(ResidencyFlags Flags, uint NumObjects, ID3D12Pageable* ppObjects, ID3D12Fence* pFenceToSignal, ulong FenceValueToSignal) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[19]))((ID3D12Device6*)Unsafe.AsPointer(ref this), Flags, NumObjects, ppObjects, pFenceToSignal, FenceValueToSignal); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[19]))((ID3D12Device6*)Unsafe.AsPointer(ref this), Flags, NumObjects, ppObjects, pFenceToSignal, FenceValueToSignal); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(20)] + public HResult CreatePipelineState(PipelineStateStreamDescription* pDesc, Guid* riid, void** ppPipelineState) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[20]))((ID3D12Device6*)Unsafe.AsPointer(ref this), pDesc, riid, ppPipelineState); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[20]))((ID3D12Device6*)Unsafe.AsPointer(ref this), pDesc, riid, ppPipelineState); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(21)] + public HResult CreatePipelineLibrary(void* pLibraryBlob, nuint BlobLength, Guid* riid, void** ppPipelineLibrary) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[21]))((ID3D12Device6*)Unsafe.AsPointer(ref this), pLibraryBlob, BlobLength, riid, ppPipelineLibrary); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[21]))((ID3D12Device6*)Unsafe.AsPointer(ref this), pLibraryBlob, BlobLength, riid, ppPipelineLibrary); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(22)] + public HResult SetEventOnMultipleFenceCompletion(ID3D12Fence* ppFences, ulong* pFenceValues, uint NumFences, MultipleFenceWaitFlags Flags, IntPtr hEvent) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[22]))((ID3D12Device6*)Unsafe.AsPointer(ref this), ppFences, pFenceValues, NumFences, Flags, hEvent); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[22]))((ID3D12Device6*)Unsafe.AsPointer(ref this), ppFences, pFenceValues, NumFences, Flags, hEvent); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(23)] + public HResult SetResidencyPriority(uint NumObjects, ID3D12Pageable* ppObjects, ResidencyPriority* pPriorities) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[23]))((ID3D12Device6*)Unsafe.AsPointer(ref this), NumObjects, ppObjects, pPriorities); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[23]))((ID3D12Device6*)Unsafe.AsPointer(ref this), NumObjects, ppObjects, pPriorities); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(24)] + public uint GetNodeCount() + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[24]))((ID3D12Device6*)Unsafe.AsPointer(ref this)); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[24]))((ID3D12Device6*)Unsafe.AsPointer(ref this)); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(25)] + public HResult CreateCommandQueue(CommandQueueDescription* pDesc, Guid* riid, void** ppCommandQueue) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[25]))((ID3D12Device6*)Unsafe.AsPointer(ref this), pDesc, riid, ppCommandQueue); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[25]))((ID3D12Device6*)Unsafe.AsPointer(ref this), pDesc, riid, ppCommandQueue); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(26)] + public HResult CreateCommandAllocator(CommandListType type, Guid* riid, void** ppCommandAllocator) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[26]))((ID3D12Device6*)Unsafe.AsPointer(ref this), type, riid, ppCommandAllocator); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[26]))((ID3D12Device6*)Unsafe.AsPointer(ref this), type, riid, ppCommandAllocator); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(27)] + public HResult CreateGraphicsPipelineState(GraphicsPipelineStateDescription* pDesc, Guid* riid, void** ppPipelineState) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[27]))((ID3D12Device6*)Unsafe.AsPointer(ref this), pDesc, riid, ppPipelineState); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[27]))((ID3D12Device6*)Unsafe.AsPointer(ref this), pDesc, riid, ppPipelineState); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(28)] + public HResult CreateComputePipelineState(ComputePipelineStateDescription* pDesc, Guid* riid, void** ppPipelineState) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[28]))((ID3D12Device6*)Unsafe.AsPointer(ref this), pDesc, riid, ppPipelineState); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[28]))((ID3D12Device6*)Unsafe.AsPointer(ref this), pDesc, riid, ppPipelineState); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(29)] + public HResult CreateCommandList(uint nodeMask, CommandListType type, ID3D12CommandAllocator* pCommandAllocator, ID3D12PipelineState* pInitialState, Guid* riid, void** ppCommandList) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[29]))((ID3D12Device6*)Unsafe.AsPointer(ref this), nodeMask, type, pCommandAllocator, pInitialState, riid, ppCommandList); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[29]))((ID3D12Device6*)Unsafe.AsPointer(ref this), nodeMask, type, pCommandAllocator, pInitialState, riid, ppCommandList); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(30)] + public HResult CheckFeatureSupport(Feature Feature, void* pFeatureSupportData, uint FeatureSupportDataSize) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[30]))((ID3D12Device6*)Unsafe.AsPointer(ref this), Feature, pFeatureSupportData, FeatureSupportDataSize); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[30]))((ID3D12Device6*)Unsafe.AsPointer(ref this), Feature, pFeatureSupportData, FeatureSupportDataSize); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(31)] + public HResult CreateDescriptorHeap(DescriptorHeapDescription* pDescriptorHeapDesc, Guid* riid, void** ppvHeap) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[31]))((ID3D12Device6*)Unsafe.AsPointer(ref this), pDescriptorHeapDesc, riid, ppvHeap); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[31]))((ID3D12Device6*)Unsafe.AsPointer(ref this), pDescriptorHeapDesc, riid, ppvHeap); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(32)] + public uint GetDescriptorHandleIncrementSize(DescriptorHeapType DescriptorHeapType) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[32]))((ID3D12Device6*)Unsafe.AsPointer(ref this), DescriptorHeapType); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[32]))((ID3D12Device6*)Unsafe.AsPointer(ref this), DescriptorHeapType); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(33)] + public HResult CreateRootSignature(uint nodeMask, void* pBlobWithRootSignature, nuint blobLengthInBytes, Guid* riid, void** ppvRootSignature) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[33]))((ID3D12Device6*)Unsafe.AsPointer(ref this), nodeMask, pBlobWithRootSignature, blobLengthInBytes, riid, ppvRootSignature); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[33]))((ID3D12Device6*)Unsafe.AsPointer(ref this), nodeMask, pBlobWithRootSignature, blobLengthInBytes, riid, ppvRootSignature); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(34)] + public void CreateConstantBufferView(ConstantBufferViewDescription* pDesc, CpuDescriptorHandle* DestDescriptor) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[34]))((ID3D12Device6*)Unsafe.AsPointer(ref this), pDesc, DestDescriptor); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[34]))((ID3D12Device6*)Unsafe.AsPointer(ref this), pDesc, DestDescriptor); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(35)] + public void CreateShaderResourceView(ID3D12Resource* pResource, ShaderResourceViewDescription* pDesc, CpuDescriptorHandle* DestDescriptor) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[35]))((ID3D12Device6*)Unsafe.AsPointer(ref this), pResource, pDesc, DestDescriptor); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[35]))((ID3D12Device6*)Unsafe.AsPointer(ref this), pResource, pDesc, DestDescriptor); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(36)] + public void CreateUnorderedAccessView(ID3D12Resource* pResource, ID3D12Resource* pCounterResource, UnorderedAccessViewDescription* pDesc, CpuDescriptorHandle* DestDescriptor) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[36]))((ID3D12Device6*)Unsafe.AsPointer(ref this), pResource, pCounterResource, pDesc, DestDescriptor); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[36]))((ID3D12Device6*)Unsafe.AsPointer(ref this), pResource, pCounterResource, pDesc, DestDescriptor); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(37)] + public void CreateRenderTargetView(ID3D12Resource* pResource, RenderTargetViewDescription* pDesc, CpuDescriptorHandle* DestDescriptor) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[37]))((ID3D12Device6*)Unsafe.AsPointer(ref this), pResource, pDesc, DestDescriptor); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[37]))((ID3D12Device6*)Unsafe.AsPointer(ref this), pResource, pDesc, DestDescriptor); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(38)] + public void CreateDepthStencilView(ID3D12Resource* pResource, DepthStencilViewDescription* pDesc, CpuDescriptorHandle* DestDescriptor) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[38]))((ID3D12Device6*)Unsafe.AsPointer(ref this), pResource, pDesc, DestDescriptor); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[38]))((ID3D12Device6*)Unsafe.AsPointer(ref this), pResource, pDesc, DestDescriptor); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(39)] + public void CreateSampler(SamplerDescription* pDesc, CpuDescriptorHandle* DestDescriptor) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[39]))((ID3D12Device6*)Unsafe.AsPointer(ref this), pDesc, DestDescriptor); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[39]))((ID3D12Device6*)Unsafe.AsPointer(ref this), pDesc, DestDescriptor); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(40)] + public void CopyDescriptors(uint NumDestDescriptorRanges, CpuDescriptorHandle* pDestDescriptorRangeStarts, uint* pDestDescriptorRangeSizes, uint NumSrcDescriptorRanges, CpuDescriptorHandle* pSrcDescriptorRangeStarts, uint* pSrcDescriptorRangeSizes, DescriptorHeapType DescriptorHeapsType) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[40]))((ID3D12Device6*)Unsafe.AsPointer(ref this), NumDestDescriptorRanges, pDestDescriptorRangeStarts, pDestDescriptorRangeSizes, NumSrcDescriptorRanges, pSrcDescriptorRangeStarts, pSrcDescriptorRangeSizes, DescriptorHeapsType); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[40]))((ID3D12Device6*)Unsafe.AsPointer(ref this), NumDestDescriptorRanges, pDestDescriptorRangeStarts, pDestDescriptorRangeSizes, NumSrcDescriptorRanges, pSrcDescriptorRangeStarts, pSrcDescriptorRangeSizes, DescriptorHeapsType); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(41)] + public void CopyDescriptorsSimple(uint NumDescriptors, CpuDescriptorHandle* DestDescriptorRangeStart, CpuDescriptorHandle* SrcDescriptorRangeStart, DescriptorHeapType DescriptorHeapsType) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[41]))((ID3D12Device6*)Unsafe.AsPointer(ref this), NumDescriptors, DestDescriptorRangeStart, SrcDescriptorRangeStart, DescriptorHeapsType); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[41]))((ID3D12Device6*)Unsafe.AsPointer(ref this), NumDescriptors, DestDescriptorRangeStart, SrcDescriptorRangeStart, DescriptorHeapsType); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(42)] + public Graphics.Direct3D12.ResourceAllocationInfo GetResourceAllocationInfo(uint visibleMask, uint numResourceDescs, ResourceDescription* pResourceDescs) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[42]))((ID3D12Device6*)Unsafe.AsPointer(ref this), visibleMask, numResourceDescs, pResourceDescs); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[42]))((ID3D12Device6*)Unsafe.AsPointer(ref this), visibleMask, numResourceDescs, pResourceDescs); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(43)] + public Graphics.Direct3D12.HeapProperties GetCustomHeapProperties(uint nodeMask, HeapType heapType) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[43]))((ID3D12Device6*)Unsafe.AsPointer(ref this), nodeMask, heapType); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[43]))((ID3D12Device6*)Unsafe.AsPointer(ref this), nodeMask, heapType); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(44)] + public HResult CreateCommittedResource(HeapProperties* pHeapProperties, HeapFlags HeapFlags, ResourceDescription* pDesc, ResourceStates InitialResourceState, ClearValue* pOptimizedClearValue, Guid* riidResource, void** ppvResource) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[44]))((ID3D12Device6*)Unsafe.AsPointer(ref this), pHeapProperties, HeapFlags, pDesc, InitialResourceState, pOptimizedClearValue, riidResource, ppvResource); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[44]))((ID3D12Device6*)Unsafe.AsPointer(ref this), pHeapProperties, HeapFlags, pDesc, InitialResourceState, pOptimizedClearValue, riidResource, ppvResource); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(45)] + public HResult CreateHeap(HeapDescription* pDesc, Guid* riid, void** ppvHeap) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[45]))((ID3D12Device6*)Unsafe.AsPointer(ref this), pDesc, riid, ppvHeap); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[45]))((ID3D12Device6*)Unsafe.AsPointer(ref this), pDesc, riid, ppvHeap); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(46)] + public HResult CreatePlacedResource(ID3D12Heap* pHeap, ulong HeapOffset, ResourceDescription* pDesc, ResourceStates InitialState, ClearValue* pOptimizedClearValue, Guid* riid, void** ppvResource) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[46]))((ID3D12Device6*)Unsafe.AsPointer(ref this), pHeap, HeapOffset, pDesc, InitialState, pOptimizedClearValue, riid, ppvResource); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[46]))((ID3D12Device6*)Unsafe.AsPointer(ref this), pHeap, HeapOffset, pDesc, InitialState, pOptimizedClearValue, riid, ppvResource); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(47)] + public HResult CreateReservedResource(ResourceDescription* pDesc, ResourceStates InitialState, ClearValue* pOptimizedClearValue, Guid* riid, void** ppvResource) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[47]))((ID3D12Device6*)Unsafe.AsPointer(ref this), pDesc, InitialState, pOptimizedClearValue, riid, ppvResource); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[47]))((ID3D12Device6*)Unsafe.AsPointer(ref this), pDesc, InitialState, pOptimizedClearValue, riid, ppvResource); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(48)] + public HResult CreateSharedHandle(ID3D12DeviceChild* pObject, Security.SECURITY_ATTRIBUTES* pAttributes, uint Access, char** Name, IntPtr* pHandle) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[48]))((ID3D12Device6*)Unsafe.AsPointer(ref this), pObject, pAttributes, Access, Name, pHandle); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[48]))((ID3D12Device6*)Unsafe.AsPointer(ref this), pObject, pAttributes, Access, Name, pHandle); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(49)] + public HResult OpenSharedHandle(IntPtr NTHandle, Guid* riid, void** ppvObj) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[49]))((ID3D12Device6*)Unsafe.AsPointer(ref this), NTHandle, riid, ppvObj); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[49]))((ID3D12Device6*)Unsafe.AsPointer(ref this), NTHandle, riid, ppvObj); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(50)] + public HResult OpenSharedHandleByName(char** Name, uint Access, IntPtr* pNTHandle) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[50]))((ID3D12Device6*)Unsafe.AsPointer(ref this), Name, Access, pNTHandle); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[50]))((ID3D12Device6*)Unsafe.AsPointer(ref this), Name, Access, pNTHandle); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(51)] + public HResult MakeResident(uint NumObjects, ID3D12Pageable* ppObjects) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[51]))((ID3D12Device6*)Unsafe.AsPointer(ref this), NumObjects, ppObjects); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[51]))((ID3D12Device6*)Unsafe.AsPointer(ref this), NumObjects, ppObjects); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(52)] + public HResult Evict(uint NumObjects, ID3D12Pageable* ppObjects) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[52]))((ID3D12Device6*)Unsafe.AsPointer(ref this), NumObjects, ppObjects); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[52]))((ID3D12Device6*)Unsafe.AsPointer(ref this), NumObjects, ppObjects); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(53)] + public HResult CreateFence(ulong InitialValue, FenceFlags Flags, Guid* riid, void** ppFence) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[53]))((ID3D12Device6*)Unsafe.AsPointer(ref this), InitialValue, Flags, riid, ppFence); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[53]))((ID3D12Device6*)Unsafe.AsPointer(ref this), InitialValue, Flags, riid, ppFence); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(54)] + public HResult GetDeviceRemovedReason() + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[54]))((ID3D12Device6*)Unsafe.AsPointer(ref this)); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[54]))((ID3D12Device6*)Unsafe.AsPointer(ref this)); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(55)] + public void GetCopyableFootprints(ResourceDescription* pResourceDesc, uint FirstSubresource, uint NumSubresources, ulong BaseOffset, PlacedSubresourceFootprint* pLayouts, uint* pNumRows, ulong* pRowSizeInBytes, ulong* pTotalBytes) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[55]))((ID3D12Device6*)Unsafe.AsPointer(ref this), pResourceDesc, FirstSubresource, NumSubresources, BaseOffset, pLayouts, pNumRows, pRowSizeInBytes, pTotalBytes); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[55]))((ID3D12Device6*)Unsafe.AsPointer(ref this), pResourceDesc, FirstSubresource, NumSubresources, BaseOffset, pLayouts, pNumRows, pRowSizeInBytes, pTotalBytes); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(56)] + public HResult CreateQueryHeap(QueryHeapDescription* pDesc, Guid* riid, void** ppvHeap) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[56]))((ID3D12Device6*)Unsafe.AsPointer(ref this), pDesc, riid, ppvHeap); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[56]))((ID3D12Device6*)Unsafe.AsPointer(ref this), pDesc, riid, ppvHeap); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(57)] + public HResult SetStablePowerState(Bool32 Enable) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[57]))((ID3D12Device6*)Unsafe.AsPointer(ref this), Enable); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[57]))((ID3D12Device6*)Unsafe.AsPointer(ref this), Enable); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(58)] + public HResult CreateCommandSignature(CommandSignatureDescription* pDesc, ID3D12RootSignature* pRootSignature, Guid* riid, void** ppvCommandSignature) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[58]))((ID3D12Device6*)Unsafe.AsPointer(ref this), pDesc, pRootSignature, riid, ppvCommandSignature); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[58]))((ID3D12Device6*)Unsafe.AsPointer(ref this), pDesc, pRootSignature, riid, ppvCommandSignature); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(59)] + public void GetResourceTiling(ID3D12Resource* pTiledResource, uint* pNumTilesForEntireResource, PackedMipInfo* pPackedMipDesc, TileShape* pStandardTileShapeForNonPackedMips, uint* pNumSubresourceTilings, uint FirstSubresourceTilingToGet, SubresourceTiling* pSubresourceTilingsForNonPackedMips) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[59]))((ID3D12Device6*)Unsafe.AsPointer(ref this), pTiledResource, pNumTilesForEntireResource, pPackedMipDesc, pStandardTileShapeForNonPackedMips, pNumSubresourceTilings, FirstSubresourceTilingToGet, pSubresourceTilingsForNonPackedMips); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[59]))((ID3D12Device6*)Unsafe.AsPointer(ref this), pTiledResource, pNumTilesForEntireResource, pPackedMipDesc, pStandardTileShapeForNonPackedMips, pNumSubresourceTilings, FirstSubresourceTilingToGet, pSubresourceTilingsForNonPackedMips); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(60)] + public Luid GetAdapterLuid() + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[60]))((ID3D12Device6*)Unsafe.AsPointer(ref this)); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[60]))((ID3D12Device6*)Unsafe.AsPointer(ref this)); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(61)] + public HResult GetPrivateData(Guid* guid, uint* pDataSize, void* pData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[61]))((ID3D12Device6*)Unsafe.AsPointer(ref this), guid, pDataSize, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[61]))((ID3D12Device6*)Unsafe.AsPointer(ref this), guid, pDataSize, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(62)] + public HResult SetPrivateData(Guid* guid, uint DataSize, void* pData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[62]))((ID3D12Device6*)Unsafe.AsPointer(ref this), guid, DataSize, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[62]))((ID3D12Device6*)Unsafe.AsPointer(ref this), guid, DataSize, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(63)] + public HResult SetPrivateDataInterface(Guid* guid, IUnknown* pData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[63]))((ID3D12Device6*)Unsafe.AsPointer(ref this), guid, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[63]))((ID3D12Device6*)Unsafe.AsPointer(ref this), guid, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(64)] + public HResult SetName(char** Name) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[64]))((ID3D12Device6*)Unsafe.AsPointer(ref this), Name); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[64]))((ID3D12Device6*)Unsafe.AsPointer(ref this), Name); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(65)] + public HResult SetBackgroundProcessingMode(BackgroundProcessingMode Mode, MeasurementsAction MeasurementsAction, IntPtr hEventToSignalUponCompletion, Bool32* pbFurtherMeasurementsDesired) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[65]))((ID3D12Device6*)Unsafe.AsPointer(ref this), Mode, MeasurementsAction, hEventToSignalUponCompletion, pbFurtherMeasurementsDesired); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[65]))((ID3D12Device6*)Unsafe.AsPointer(ref this), Mode, MeasurementsAction, hEventToSignalUponCompletion, pbFurtherMeasurementsDesired); +#endif + } + + public interface Interface : ID3D12Device5.Interface + { + } +} + +/// +/// ID3D12ProtectedResourceSession1 +[Guid("d6f12dd6-76fb-406e-8961-4296eefc0409")] +[NativeTypeName("struct ID3D12ProtectedResourceSession1 : ID3D12ProtectedResourceSession")] +[NativeInheritance("ID3D12ProtectedResourceSession")] +public unsafe partial struct ID3D12ProtectedResourceSession1 : ID3D12ProtectedResourceSession1.Interface +{ + public static ref readonly Guid IID_ID3D12ProtectedResourceSession1 + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0xD6, 0x2D, 0xF1, 0xD6, + 0xFB, 0x76, + 0x6E, 0x40, + 0x89, + 0x61, + 0x42, + 0x96, + 0xEE, + 0xFC, + 0x04, + 0x09 + }; + + 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_ID3D12ProtectedResourceSession1)); + + 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 Graphics.Direct3D12.ProtectedResourceSessionDescription GetDesc() + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[3]))((ID3D12ProtectedResourceSession1*)Unsafe.AsPointer(ref this)); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((ID3D12ProtectedResourceSession1*)Unsafe.AsPointer(ref this)); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public HResult GetStatusFence(Guid* riid, void** ppFence) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[4]))((ID3D12ProtectedResourceSession1*)Unsafe.AsPointer(ref this), riid, ppFence); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((ID3D12ProtectedResourceSession1*)Unsafe.AsPointer(ref this), riid, ppFence); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(5)] + public Graphics.Direct3D12.ProtectedSessionStatus GetSessionStatus() + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[5]))((ID3D12ProtectedResourceSession1*)Unsafe.AsPointer(ref this)); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((ID3D12ProtectedResourceSession1*)Unsafe.AsPointer(ref this)); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(6)] + public HResult GetDevice(Guid* riid, void** ppvDevice) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[6]))((ID3D12ProtectedResourceSession1*)Unsafe.AsPointer(ref this), riid, ppvDevice); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((ID3D12ProtectedResourceSession1*)Unsafe.AsPointer(ref this), riid, ppvDevice); +#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]))((ID3D12ProtectedResourceSession1*)Unsafe.AsPointer(ref this), guid, pDataSize, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((ID3D12ProtectedResourceSession1*)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]))((ID3D12ProtectedResourceSession1*)Unsafe.AsPointer(ref this), guid, DataSize, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[8]))((ID3D12ProtectedResourceSession1*)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]))((ID3D12ProtectedResourceSession1*)Unsafe.AsPointer(ref this), guid, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[9]))((ID3D12ProtectedResourceSession1*)Unsafe.AsPointer(ref this), guid, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(10)] + public HResult SetName(char** Name) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[10]))((ID3D12ProtectedResourceSession1*)Unsafe.AsPointer(ref this), Name); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[10]))((ID3D12ProtectedResourceSession1*)Unsafe.AsPointer(ref this), Name); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(11)] + public Graphics.Direct3D12.ProtectedResourceSessionDescription1 GetDesc1() + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[11]))((ID3D12ProtectedResourceSession1*)Unsafe.AsPointer(ref this)); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[11]))((ID3D12ProtectedResourceSession1*)Unsafe.AsPointer(ref this)); +#endif + } + + public interface Interface : ID3D12ProtectedResourceSession.Interface + { + } +} + +/// +/// ID3D12Device7 +[Guid("5c014b53-68a1-4b9b-8bd1-dd6046b9358b")] +[NativeTypeName("struct ID3D12Device7 : ID3D12Device6")] +[NativeInheritance("ID3D12Device6")] +public unsafe partial struct ID3D12Device7 : ID3D12Device7.Interface +{ + public static ref readonly Guid IID_ID3D12Device7 + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x53, 0x4B, 0x01, 0x5C, + 0xA1, 0x68, + 0x9B, 0x4B, + 0x8B, + 0xD1, + 0xDD, + 0x60, + 0x46, + 0xB9, + 0x35, + 0x8B + }; + + 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_ID3D12Device7)); + + 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 SetBackgroundProcessingMode(BackgroundProcessingMode Mode, MeasurementsAction MeasurementsAction, IntPtr hEventToSignalUponCompletion, Bool32* pbFurtherMeasurementsDesired) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[3]))((ID3D12Device7*)Unsafe.AsPointer(ref this), Mode, MeasurementsAction, hEventToSignalUponCompletion, pbFurtherMeasurementsDesired); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((ID3D12Device7*)Unsafe.AsPointer(ref this), Mode, MeasurementsAction, hEventToSignalUponCompletion, pbFurtherMeasurementsDesired); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public HResult CreateLifetimeTracker(ID3D12LifetimeOwner* pOwner, Guid* riid, void** ppvTracker) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[4]))((ID3D12Device7*)Unsafe.AsPointer(ref this), pOwner, riid, ppvTracker); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((ID3D12Device7*)Unsafe.AsPointer(ref this), pOwner, riid, ppvTracker); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(5)] + public void RemoveDevice() + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[5]))((ID3D12Device7*)Unsafe.AsPointer(ref this)); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((ID3D12Device7*)Unsafe.AsPointer(ref this)); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(6)] + public HResult EnumerateMetaCommands(uint* pNumMetaCommands, MetaCommandDescription* pDescs) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[6]))((ID3D12Device7*)Unsafe.AsPointer(ref this), pNumMetaCommands, pDescs); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((ID3D12Device7*)Unsafe.AsPointer(ref this), pNumMetaCommands, pDescs); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(7)] + public HResult EnumerateMetaCommandParameters(Guid* CommandId, MetaCommandParameterStage Stage, uint* pTotalStructureSizeInBytes, uint* pParameterCount, MetaCommandParameterDescription* pParameterDescs) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[7]))((ID3D12Device7*)Unsafe.AsPointer(ref this), CommandId, Stage, pTotalStructureSizeInBytes, pParameterCount, pParameterDescs); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((ID3D12Device7*)Unsafe.AsPointer(ref this), CommandId, Stage, pTotalStructureSizeInBytes, pParameterCount, pParameterDescs); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(8)] + public HResult CreateMetaCommand(Guid* CommandId, uint NodeMask, void* pCreationParametersData, nuint CreationParametersDataSizeInBytes, Guid* riid, void** ppMetaCommand) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[8]))((ID3D12Device7*)Unsafe.AsPointer(ref this), CommandId, NodeMask, pCreationParametersData, CreationParametersDataSizeInBytes, riid, ppMetaCommand); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[8]))((ID3D12Device7*)Unsafe.AsPointer(ref this), CommandId, NodeMask, pCreationParametersData, CreationParametersDataSizeInBytes, riid, ppMetaCommand); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(9)] + public HResult CreateStateObject(StateObjectDescription* pDesc, Guid* riid, void** ppStateObject) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[9]))((ID3D12Device7*)Unsafe.AsPointer(ref this), pDesc, riid, ppStateObject); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[9]))((ID3D12Device7*)Unsafe.AsPointer(ref this), pDesc, riid, ppStateObject); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(10)] + public void GetRaytracingAccelerationStructurePrebuildInfo(BuildRaytracingAccelerationStructureInputs* pDesc, RaytracingAccelerationStructurePrebuildInfo* pInfo) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[10]))((ID3D12Device7*)Unsafe.AsPointer(ref this), pDesc, pInfo); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[10]))((ID3D12Device7*)Unsafe.AsPointer(ref this), pDesc, pInfo); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(11)] + public Graphics.Direct3D12.DriverMatchingIdentifierStatus CheckDriverMatchingIdentifier(SerializedDataType SerializedDataType, SerializedDataDriverMatchingIdentifier* pIdentifierToCheck) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[11]))((ID3D12Device7*)Unsafe.AsPointer(ref this), SerializedDataType, pIdentifierToCheck); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[11]))((ID3D12Device7*)Unsafe.AsPointer(ref this), SerializedDataType, pIdentifierToCheck); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(12)] + public HResult CreateCommandList1(uint nodeMask, CommandListType type, CommandListFlags flags, Guid* riid, void** ppCommandList) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[12]))((ID3D12Device7*)Unsafe.AsPointer(ref this), nodeMask, type, flags, riid, ppCommandList); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[12]))((ID3D12Device7*)Unsafe.AsPointer(ref this), nodeMask, type, flags, riid, ppCommandList); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(13)] + public HResult CreateProtectedResourceSession(ProtectedResourceSessionDescription* pDesc, Guid* riid, void** ppSession) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[13]))((ID3D12Device7*)Unsafe.AsPointer(ref this), pDesc, riid, ppSession); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[13]))((ID3D12Device7*)Unsafe.AsPointer(ref this), pDesc, riid, ppSession); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(14)] + public HResult CreateCommittedResource1(HeapProperties* pHeapProperties, HeapFlags HeapFlags, ResourceDescription* pDesc, ResourceStates InitialResourceState, ClearValue* pOptimizedClearValue, ID3D12ProtectedResourceSession* pProtectedSession, Guid* riidResource, void** ppvResource) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[14]))((ID3D12Device7*)Unsafe.AsPointer(ref this), pHeapProperties, HeapFlags, pDesc, InitialResourceState, pOptimizedClearValue, pProtectedSession, riidResource, ppvResource); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[14]))((ID3D12Device7*)Unsafe.AsPointer(ref this), pHeapProperties, HeapFlags, pDesc, InitialResourceState, pOptimizedClearValue, pProtectedSession, riidResource, ppvResource); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(15)] + public HResult CreateHeap1(HeapDescription* pDesc, ID3D12ProtectedResourceSession* pProtectedSession, Guid* riid, void** ppvHeap) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[15]))((ID3D12Device7*)Unsafe.AsPointer(ref this), pDesc, pProtectedSession, riid, ppvHeap); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[15]))((ID3D12Device7*)Unsafe.AsPointer(ref this), pDesc, pProtectedSession, riid, ppvHeap); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(16)] + public HResult CreateReservedResource1(ResourceDescription* pDesc, ResourceStates InitialState, ClearValue* pOptimizedClearValue, ID3D12ProtectedResourceSession* pProtectedSession, Guid* riid, void** ppvResource) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[16]))((ID3D12Device7*)Unsafe.AsPointer(ref this), pDesc, InitialState, pOptimizedClearValue, pProtectedSession, riid, ppvResource); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[16]))((ID3D12Device7*)Unsafe.AsPointer(ref this), pDesc, InitialState, pOptimizedClearValue, pProtectedSession, riid, ppvResource); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(17)] + public Graphics.Direct3D12.ResourceAllocationInfo GetResourceAllocationInfo1(uint visibleMask, uint numResourceDescs, ResourceDescription* pResourceDescs, ResourceAllocationInfo1* pResourceAllocationInfo1) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[17]))((ID3D12Device7*)Unsafe.AsPointer(ref this), visibleMask, numResourceDescs, pResourceDescs, pResourceAllocationInfo1); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[17]))((ID3D12Device7*)Unsafe.AsPointer(ref this), visibleMask, numResourceDescs, pResourceDescs, pResourceAllocationInfo1); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(18)] + public HResult OpenExistingHeapFromAddress(void* pAddress, Guid* riid, void** ppvHeap) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[18]))((ID3D12Device7*)Unsafe.AsPointer(ref this), pAddress, riid, ppvHeap); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[18]))((ID3D12Device7*)Unsafe.AsPointer(ref this), pAddress, riid, ppvHeap); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(19)] + public HResult OpenExistingHeapFromFileMapping(IntPtr hFileMapping, Guid* riid, void** ppvHeap) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[19]))((ID3D12Device7*)Unsafe.AsPointer(ref this), hFileMapping, riid, ppvHeap); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[19]))((ID3D12Device7*)Unsafe.AsPointer(ref this), hFileMapping, riid, ppvHeap); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(20)] + public HResult EnqueueMakeResident(ResidencyFlags Flags, uint NumObjects, ID3D12Pageable* ppObjects, ID3D12Fence* pFenceToSignal, ulong FenceValueToSignal) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[20]))((ID3D12Device7*)Unsafe.AsPointer(ref this), Flags, NumObjects, ppObjects, pFenceToSignal, FenceValueToSignal); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[20]))((ID3D12Device7*)Unsafe.AsPointer(ref this), Flags, NumObjects, ppObjects, pFenceToSignal, FenceValueToSignal); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(21)] + public HResult CreatePipelineState(PipelineStateStreamDescription* pDesc, Guid* riid, void** ppPipelineState) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[21]))((ID3D12Device7*)Unsafe.AsPointer(ref this), pDesc, riid, ppPipelineState); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[21]))((ID3D12Device7*)Unsafe.AsPointer(ref this), pDesc, riid, ppPipelineState); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(22)] + public HResult CreatePipelineLibrary(void* pLibraryBlob, nuint BlobLength, Guid* riid, void** ppPipelineLibrary) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[22]))((ID3D12Device7*)Unsafe.AsPointer(ref this), pLibraryBlob, BlobLength, riid, ppPipelineLibrary); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[22]))((ID3D12Device7*)Unsafe.AsPointer(ref this), pLibraryBlob, BlobLength, riid, ppPipelineLibrary); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(23)] + public HResult SetEventOnMultipleFenceCompletion(ID3D12Fence* ppFences, ulong* pFenceValues, uint NumFences, MultipleFenceWaitFlags Flags, IntPtr hEvent) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[23]))((ID3D12Device7*)Unsafe.AsPointer(ref this), ppFences, pFenceValues, NumFences, Flags, hEvent); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[23]))((ID3D12Device7*)Unsafe.AsPointer(ref this), ppFences, pFenceValues, NumFences, Flags, hEvent); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(24)] + public HResult SetResidencyPriority(uint NumObjects, ID3D12Pageable* ppObjects, ResidencyPriority* pPriorities) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[24]))((ID3D12Device7*)Unsafe.AsPointer(ref this), NumObjects, ppObjects, pPriorities); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[24]))((ID3D12Device7*)Unsafe.AsPointer(ref this), NumObjects, ppObjects, pPriorities); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(25)] + public uint GetNodeCount() + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[25]))((ID3D12Device7*)Unsafe.AsPointer(ref this)); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[25]))((ID3D12Device7*)Unsafe.AsPointer(ref this)); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(26)] + public HResult CreateCommandQueue(CommandQueueDescription* pDesc, Guid* riid, void** ppCommandQueue) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[26]))((ID3D12Device7*)Unsafe.AsPointer(ref this), pDesc, riid, ppCommandQueue); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[26]))((ID3D12Device7*)Unsafe.AsPointer(ref this), pDesc, riid, ppCommandQueue); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(27)] + public HResult CreateCommandAllocator(CommandListType type, Guid* riid, void** ppCommandAllocator) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[27]))((ID3D12Device7*)Unsafe.AsPointer(ref this), type, riid, ppCommandAllocator); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[27]))((ID3D12Device7*)Unsafe.AsPointer(ref this), type, riid, ppCommandAllocator); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(28)] + public HResult CreateGraphicsPipelineState(GraphicsPipelineStateDescription* pDesc, Guid* riid, void** ppPipelineState) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[28]))((ID3D12Device7*)Unsafe.AsPointer(ref this), pDesc, riid, ppPipelineState); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[28]))((ID3D12Device7*)Unsafe.AsPointer(ref this), pDesc, riid, ppPipelineState); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(29)] + public HResult CreateComputePipelineState(ComputePipelineStateDescription* pDesc, Guid* riid, void** ppPipelineState) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[29]))((ID3D12Device7*)Unsafe.AsPointer(ref this), pDesc, riid, ppPipelineState); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[29]))((ID3D12Device7*)Unsafe.AsPointer(ref this), pDesc, riid, ppPipelineState); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(30)] + public HResult CreateCommandList(uint nodeMask, CommandListType type, ID3D12CommandAllocator* pCommandAllocator, ID3D12PipelineState* pInitialState, Guid* riid, void** ppCommandList) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[30]))((ID3D12Device7*)Unsafe.AsPointer(ref this), nodeMask, type, pCommandAllocator, pInitialState, riid, ppCommandList); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[30]))((ID3D12Device7*)Unsafe.AsPointer(ref this), nodeMask, type, pCommandAllocator, pInitialState, riid, ppCommandList); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(31)] + public HResult CheckFeatureSupport(Feature Feature, void* pFeatureSupportData, uint FeatureSupportDataSize) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[31]))((ID3D12Device7*)Unsafe.AsPointer(ref this), Feature, pFeatureSupportData, FeatureSupportDataSize); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[31]))((ID3D12Device7*)Unsafe.AsPointer(ref this), Feature, pFeatureSupportData, FeatureSupportDataSize); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(32)] + public HResult CreateDescriptorHeap(DescriptorHeapDescription* pDescriptorHeapDesc, Guid* riid, void** ppvHeap) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[32]))((ID3D12Device7*)Unsafe.AsPointer(ref this), pDescriptorHeapDesc, riid, ppvHeap); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[32]))((ID3D12Device7*)Unsafe.AsPointer(ref this), pDescriptorHeapDesc, riid, ppvHeap); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(33)] + public uint GetDescriptorHandleIncrementSize(DescriptorHeapType DescriptorHeapType) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[33]))((ID3D12Device7*)Unsafe.AsPointer(ref this), DescriptorHeapType); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[33]))((ID3D12Device7*)Unsafe.AsPointer(ref this), DescriptorHeapType); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(34)] + public HResult CreateRootSignature(uint nodeMask, void* pBlobWithRootSignature, nuint blobLengthInBytes, Guid* riid, void** ppvRootSignature) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[34]))((ID3D12Device7*)Unsafe.AsPointer(ref this), nodeMask, pBlobWithRootSignature, blobLengthInBytes, riid, ppvRootSignature); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[34]))((ID3D12Device7*)Unsafe.AsPointer(ref this), nodeMask, pBlobWithRootSignature, blobLengthInBytes, riid, ppvRootSignature); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(35)] + public void CreateConstantBufferView(ConstantBufferViewDescription* pDesc, CpuDescriptorHandle* DestDescriptor) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[35]))((ID3D12Device7*)Unsafe.AsPointer(ref this), pDesc, DestDescriptor); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[35]))((ID3D12Device7*)Unsafe.AsPointer(ref this), pDesc, DestDescriptor); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(36)] + public void CreateShaderResourceView(ID3D12Resource* pResource, ShaderResourceViewDescription* pDesc, CpuDescriptorHandle* DestDescriptor) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[36]))((ID3D12Device7*)Unsafe.AsPointer(ref this), pResource, pDesc, DestDescriptor); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[36]))((ID3D12Device7*)Unsafe.AsPointer(ref this), pResource, pDesc, DestDescriptor); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(37)] + public void CreateUnorderedAccessView(ID3D12Resource* pResource, ID3D12Resource* pCounterResource, UnorderedAccessViewDescription* pDesc, CpuDescriptorHandle* DestDescriptor) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[37]))((ID3D12Device7*)Unsafe.AsPointer(ref this), pResource, pCounterResource, pDesc, DestDescriptor); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[37]))((ID3D12Device7*)Unsafe.AsPointer(ref this), pResource, pCounterResource, pDesc, DestDescriptor); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(38)] + public void CreateRenderTargetView(ID3D12Resource* pResource, RenderTargetViewDescription* pDesc, CpuDescriptorHandle* DestDescriptor) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[38]))((ID3D12Device7*)Unsafe.AsPointer(ref this), pResource, pDesc, DestDescriptor); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[38]))((ID3D12Device7*)Unsafe.AsPointer(ref this), pResource, pDesc, DestDescriptor); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(39)] + public void CreateDepthStencilView(ID3D12Resource* pResource, DepthStencilViewDescription* pDesc, CpuDescriptorHandle* DestDescriptor) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[39]))((ID3D12Device7*)Unsafe.AsPointer(ref this), pResource, pDesc, DestDescriptor); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[39]))((ID3D12Device7*)Unsafe.AsPointer(ref this), pResource, pDesc, DestDescriptor); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(40)] + public void CreateSampler(SamplerDescription* pDesc, CpuDescriptorHandle* DestDescriptor) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[40]))((ID3D12Device7*)Unsafe.AsPointer(ref this), pDesc, DestDescriptor); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[40]))((ID3D12Device7*)Unsafe.AsPointer(ref this), pDesc, DestDescriptor); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(41)] + public void CopyDescriptors(uint NumDestDescriptorRanges, CpuDescriptorHandle* pDestDescriptorRangeStarts, uint* pDestDescriptorRangeSizes, uint NumSrcDescriptorRanges, CpuDescriptorHandle* pSrcDescriptorRangeStarts, uint* pSrcDescriptorRangeSizes, DescriptorHeapType DescriptorHeapsType) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[41]))((ID3D12Device7*)Unsafe.AsPointer(ref this), NumDestDescriptorRanges, pDestDescriptorRangeStarts, pDestDescriptorRangeSizes, NumSrcDescriptorRanges, pSrcDescriptorRangeStarts, pSrcDescriptorRangeSizes, DescriptorHeapsType); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[41]))((ID3D12Device7*)Unsafe.AsPointer(ref this), NumDestDescriptorRanges, pDestDescriptorRangeStarts, pDestDescriptorRangeSizes, NumSrcDescriptorRanges, pSrcDescriptorRangeStarts, pSrcDescriptorRangeSizes, DescriptorHeapsType); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(42)] + public void CopyDescriptorsSimple(uint NumDescriptors, CpuDescriptorHandle* DestDescriptorRangeStart, CpuDescriptorHandle* SrcDescriptorRangeStart, DescriptorHeapType DescriptorHeapsType) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[42]))((ID3D12Device7*)Unsafe.AsPointer(ref this), NumDescriptors, DestDescriptorRangeStart, SrcDescriptorRangeStart, DescriptorHeapsType); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[42]))((ID3D12Device7*)Unsafe.AsPointer(ref this), NumDescriptors, DestDescriptorRangeStart, SrcDescriptorRangeStart, DescriptorHeapsType); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(43)] + public Graphics.Direct3D12.ResourceAllocationInfo GetResourceAllocationInfo(uint visibleMask, uint numResourceDescs, ResourceDescription* pResourceDescs) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[43]))((ID3D12Device7*)Unsafe.AsPointer(ref this), visibleMask, numResourceDescs, pResourceDescs); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[43]))((ID3D12Device7*)Unsafe.AsPointer(ref this), visibleMask, numResourceDescs, pResourceDescs); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(44)] + public Graphics.Direct3D12.HeapProperties GetCustomHeapProperties(uint nodeMask, HeapType heapType) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[44]))((ID3D12Device7*)Unsafe.AsPointer(ref this), nodeMask, heapType); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[44]))((ID3D12Device7*)Unsafe.AsPointer(ref this), nodeMask, heapType); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(45)] + public HResult CreateCommittedResource(HeapProperties* pHeapProperties, HeapFlags HeapFlags, ResourceDescription* pDesc, ResourceStates InitialResourceState, ClearValue* pOptimizedClearValue, Guid* riidResource, void** ppvResource) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[45]))((ID3D12Device7*)Unsafe.AsPointer(ref this), pHeapProperties, HeapFlags, pDesc, InitialResourceState, pOptimizedClearValue, riidResource, ppvResource); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[45]))((ID3D12Device7*)Unsafe.AsPointer(ref this), pHeapProperties, HeapFlags, pDesc, InitialResourceState, pOptimizedClearValue, riidResource, ppvResource); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(46)] + public HResult CreateHeap(HeapDescription* pDesc, Guid* riid, void** ppvHeap) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[46]))((ID3D12Device7*)Unsafe.AsPointer(ref this), pDesc, riid, ppvHeap); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[46]))((ID3D12Device7*)Unsafe.AsPointer(ref this), pDesc, riid, ppvHeap); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(47)] + public HResult CreatePlacedResource(ID3D12Heap* pHeap, ulong HeapOffset, ResourceDescription* pDesc, ResourceStates InitialState, ClearValue* pOptimizedClearValue, Guid* riid, void** ppvResource) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[47]))((ID3D12Device7*)Unsafe.AsPointer(ref this), pHeap, HeapOffset, pDesc, InitialState, pOptimizedClearValue, riid, ppvResource); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[47]))((ID3D12Device7*)Unsafe.AsPointer(ref this), pHeap, HeapOffset, pDesc, InitialState, pOptimizedClearValue, riid, ppvResource); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(48)] + public HResult CreateReservedResource(ResourceDescription* pDesc, ResourceStates InitialState, ClearValue* pOptimizedClearValue, Guid* riid, void** ppvResource) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[48]))((ID3D12Device7*)Unsafe.AsPointer(ref this), pDesc, InitialState, pOptimizedClearValue, riid, ppvResource); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[48]))((ID3D12Device7*)Unsafe.AsPointer(ref this), pDesc, InitialState, pOptimizedClearValue, riid, ppvResource); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(49)] + public HResult CreateSharedHandle(ID3D12DeviceChild* pObject, Security.SECURITY_ATTRIBUTES* pAttributes, uint Access, char** Name, IntPtr* pHandle) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[49]))((ID3D12Device7*)Unsafe.AsPointer(ref this), pObject, pAttributes, Access, Name, pHandle); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[49]))((ID3D12Device7*)Unsafe.AsPointer(ref this), pObject, pAttributes, Access, Name, pHandle); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(50)] + public HResult OpenSharedHandle(IntPtr NTHandle, Guid* riid, void** ppvObj) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[50]))((ID3D12Device7*)Unsafe.AsPointer(ref this), NTHandle, riid, ppvObj); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[50]))((ID3D12Device7*)Unsafe.AsPointer(ref this), NTHandle, riid, ppvObj); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(51)] + public HResult OpenSharedHandleByName(char** Name, uint Access, IntPtr* pNTHandle) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[51]))((ID3D12Device7*)Unsafe.AsPointer(ref this), Name, Access, pNTHandle); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[51]))((ID3D12Device7*)Unsafe.AsPointer(ref this), Name, Access, pNTHandle); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(52)] + public HResult MakeResident(uint NumObjects, ID3D12Pageable* ppObjects) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[52]))((ID3D12Device7*)Unsafe.AsPointer(ref this), NumObjects, ppObjects); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[52]))((ID3D12Device7*)Unsafe.AsPointer(ref this), NumObjects, ppObjects); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(53)] + public HResult Evict(uint NumObjects, ID3D12Pageable* ppObjects) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[53]))((ID3D12Device7*)Unsafe.AsPointer(ref this), NumObjects, ppObjects); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[53]))((ID3D12Device7*)Unsafe.AsPointer(ref this), NumObjects, ppObjects); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(54)] + public HResult CreateFence(ulong InitialValue, FenceFlags Flags, Guid* riid, void** ppFence) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[54]))((ID3D12Device7*)Unsafe.AsPointer(ref this), InitialValue, Flags, riid, ppFence); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[54]))((ID3D12Device7*)Unsafe.AsPointer(ref this), InitialValue, Flags, riid, ppFence); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(55)] + public HResult GetDeviceRemovedReason() + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[55]))((ID3D12Device7*)Unsafe.AsPointer(ref this)); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[55]))((ID3D12Device7*)Unsafe.AsPointer(ref this)); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(56)] + public void GetCopyableFootprints(ResourceDescription* pResourceDesc, uint FirstSubresource, uint NumSubresources, ulong BaseOffset, PlacedSubresourceFootprint* pLayouts, uint* pNumRows, ulong* pRowSizeInBytes, ulong* pTotalBytes) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[56]))((ID3D12Device7*)Unsafe.AsPointer(ref this), pResourceDesc, FirstSubresource, NumSubresources, BaseOffset, pLayouts, pNumRows, pRowSizeInBytes, pTotalBytes); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[56]))((ID3D12Device7*)Unsafe.AsPointer(ref this), pResourceDesc, FirstSubresource, NumSubresources, BaseOffset, pLayouts, pNumRows, pRowSizeInBytes, pTotalBytes); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(57)] + public HResult CreateQueryHeap(QueryHeapDescription* pDesc, Guid* riid, void** ppvHeap) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[57]))((ID3D12Device7*)Unsafe.AsPointer(ref this), pDesc, riid, ppvHeap); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[57]))((ID3D12Device7*)Unsafe.AsPointer(ref this), pDesc, riid, ppvHeap); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(58)] + public HResult SetStablePowerState(Bool32 Enable) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[58]))((ID3D12Device7*)Unsafe.AsPointer(ref this), Enable); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[58]))((ID3D12Device7*)Unsafe.AsPointer(ref this), Enable); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(59)] + public HResult CreateCommandSignature(CommandSignatureDescription* pDesc, ID3D12RootSignature* pRootSignature, Guid* riid, void** ppvCommandSignature) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[59]))((ID3D12Device7*)Unsafe.AsPointer(ref this), pDesc, pRootSignature, riid, ppvCommandSignature); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[59]))((ID3D12Device7*)Unsafe.AsPointer(ref this), pDesc, pRootSignature, riid, ppvCommandSignature); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(60)] + public void GetResourceTiling(ID3D12Resource* pTiledResource, uint* pNumTilesForEntireResource, PackedMipInfo* pPackedMipDesc, TileShape* pStandardTileShapeForNonPackedMips, uint* pNumSubresourceTilings, uint FirstSubresourceTilingToGet, SubresourceTiling* pSubresourceTilingsForNonPackedMips) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[60]))((ID3D12Device7*)Unsafe.AsPointer(ref this), pTiledResource, pNumTilesForEntireResource, pPackedMipDesc, pStandardTileShapeForNonPackedMips, pNumSubresourceTilings, FirstSubresourceTilingToGet, pSubresourceTilingsForNonPackedMips); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[60]))((ID3D12Device7*)Unsafe.AsPointer(ref this), pTiledResource, pNumTilesForEntireResource, pPackedMipDesc, pStandardTileShapeForNonPackedMips, pNumSubresourceTilings, FirstSubresourceTilingToGet, pSubresourceTilingsForNonPackedMips); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(61)] + public Luid GetAdapterLuid() + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[61]))((ID3D12Device7*)Unsafe.AsPointer(ref this)); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[61]))((ID3D12Device7*)Unsafe.AsPointer(ref this)); +#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]))((ID3D12Device7*)Unsafe.AsPointer(ref this), guid, pDataSize, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[62]))((ID3D12Device7*)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]))((ID3D12Device7*)Unsafe.AsPointer(ref this), guid, DataSize, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[63]))((ID3D12Device7*)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]))((ID3D12Device7*)Unsafe.AsPointer(ref this), guid, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[64]))((ID3D12Device7*)Unsafe.AsPointer(ref this), guid, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(65)] + public HResult SetName(char** Name) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[65]))((ID3D12Device7*)Unsafe.AsPointer(ref this), Name); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[65]))((ID3D12Device7*)Unsafe.AsPointer(ref this), Name); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(66)] + public HResult AddToStateObject(StateObjectDescription* pAddition, ID3D12StateObject* pStateObjectToGrowFrom, Guid* riid, void** ppNewStateObject) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[66]))((ID3D12Device7*)Unsafe.AsPointer(ref this), pAddition, pStateObjectToGrowFrom, riid, ppNewStateObject); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[66]))((ID3D12Device7*)Unsafe.AsPointer(ref this), pAddition, pStateObjectToGrowFrom, riid, ppNewStateObject); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(67)] + public HResult CreateProtectedResourceSession1(ProtectedResourceSessionDescription1* pDesc, Guid* riid, void** ppSession) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[67]))((ID3D12Device7*)Unsafe.AsPointer(ref this), pDesc, riid, ppSession); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[67]))((ID3D12Device7*)Unsafe.AsPointer(ref this), pDesc, riid, ppSession); +#endif + } + + public interface Interface : ID3D12Device6.Interface + { + } +} + +/// +/// ID3D12Device8 +[Guid("9218e6bb-f944-4f7e-a75c-b1b2c7b701f3")] +[NativeTypeName("struct ID3D12Device8 : ID3D12Device7")] +[NativeInheritance("ID3D12Device7")] +public unsafe partial struct ID3D12Device8 : ID3D12Device8.Interface +{ + public static ref readonly Guid IID_ID3D12Device8 + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0xBB, 0xE6, 0x18, 0x92, + 0x44, 0xF9, + 0x7E, 0x4F, + 0xA7, + 0x5C, + 0xB1, + 0xB2, + 0xC7, + 0xB7, + 0x01, + 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_ID3D12Device8)); + + 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 AddToStateObject(StateObjectDescription* pAddition, ID3D12StateObject* pStateObjectToGrowFrom, Guid* riid, void** ppNewStateObject) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[3]))((ID3D12Device8*)Unsafe.AsPointer(ref this), pAddition, pStateObjectToGrowFrom, riid, ppNewStateObject); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((ID3D12Device8*)Unsafe.AsPointer(ref this), pAddition, pStateObjectToGrowFrom, riid, ppNewStateObject); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public HResult CreateProtectedResourceSession1(ProtectedResourceSessionDescription1* pDesc, Guid* riid, void** ppSession) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[4]))((ID3D12Device8*)Unsafe.AsPointer(ref this), pDesc, riid, ppSession); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((ID3D12Device8*)Unsafe.AsPointer(ref this), pDesc, riid, ppSession); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(5)] + public HResult SetBackgroundProcessingMode(BackgroundProcessingMode Mode, MeasurementsAction MeasurementsAction, IntPtr hEventToSignalUponCompletion, Bool32* pbFurtherMeasurementsDesired) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[5]))((ID3D12Device8*)Unsafe.AsPointer(ref this), Mode, MeasurementsAction, hEventToSignalUponCompletion, pbFurtherMeasurementsDesired); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((ID3D12Device8*)Unsafe.AsPointer(ref this), Mode, MeasurementsAction, hEventToSignalUponCompletion, pbFurtherMeasurementsDesired); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(6)] + public HResult CreateLifetimeTracker(ID3D12LifetimeOwner* pOwner, Guid* riid, void** ppvTracker) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[6]))((ID3D12Device8*)Unsafe.AsPointer(ref this), pOwner, riid, ppvTracker); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((ID3D12Device8*)Unsafe.AsPointer(ref this), pOwner, riid, ppvTracker); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(7)] + public void RemoveDevice() + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[7]))((ID3D12Device8*)Unsafe.AsPointer(ref this)); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((ID3D12Device8*)Unsafe.AsPointer(ref this)); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(8)] + public HResult EnumerateMetaCommands(uint* pNumMetaCommands, MetaCommandDescription* pDescs) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[8]))((ID3D12Device8*)Unsafe.AsPointer(ref this), pNumMetaCommands, pDescs); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[8]))((ID3D12Device8*)Unsafe.AsPointer(ref this), pNumMetaCommands, pDescs); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(9)] + public HResult EnumerateMetaCommandParameters(Guid* CommandId, MetaCommandParameterStage Stage, uint* pTotalStructureSizeInBytes, uint* pParameterCount, MetaCommandParameterDescription* pParameterDescs) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[9]))((ID3D12Device8*)Unsafe.AsPointer(ref this), CommandId, Stage, pTotalStructureSizeInBytes, pParameterCount, pParameterDescs); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[9]))((ID3D12Device8*)Unsafe.AsPointer(ref this), CommandId, Stage, pTotalStructureSizeInBytes, pParameterCount, pParameterDescs); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(10)] + public HResult CreateMetaCommand(Guid* CommandId, uint NodeMask, void* pCreationParametersData, nuint CreationParametersDataSizeInBytes, Guid* riid, void** ppMetaCommand) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[10]))((ID3D12Device8*)Unsafe.AsPointer(ref this), CommandId, NodeMask, pCreationParametersData, CreationParametersDataSizeInBytes, riid, ppMetaCommand); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[10]))((ID3D12Device8*)Unsafe.AsPointer(ref this), CommandId, NodeMask, pCreationParametersData, CreationParametersDataSizeInBytes, riid, ppMetaCommand); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(11)] + public HResult CreateStateObject(StateObjectDescription* pDesc, Guid* riid, void** ppStateObject) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[11]))((ID3D12Device8*)Unsafe.AsPointer(ref this), pDesc, riid, ppStateObject); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[11]))((ID3D12Device8*)Unsafe.AsPointer(ref this), pDesc, riid, ppStateObject); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(12)] + public void GetRaytracingAccelerationStructurePrebuildInfo(BuildRaytracingAccelerationStructureInputs* pDesc, RaytracingAccelerationStructurePrebuildInfo* pInfo) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[12]))((ID3D12Device8*)Unsafe.AsPointer(ref this), pDesc, pInfo); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[12]))((ID3D12Device8*)Unsafe.AsPointer(ref this), pDesc, pInfo); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(13)] + public Graphics.Direct3D12.DriverMatchingIdentifierStatus CheckDriverMatchingIdentifier(SerializedDataType SerializedDataType, SerializedDataDriverMatchingIdentifier* pIdentifierToCheck) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[13]))((ID3D12Device8*)Unsafe.AsPointer(ref this), SerializedDataType, pIdentifierToCheck); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[13]))((ID3D12Device8*)Unsafe.AsPointer(ref this), SerializedDataType, pIdentifierToCheck); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(14)] + public HResult CreateCommandList1(uint nodeMask, CommandListType type, CommandListFlags flags, Guid* riid, void** ppCommandList) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[14]))((ID3D12Device8*)Unsafe.AsPointer(ref this), nodeMask, type, flags, riid, ppCommandList); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[14]))((ID3D12Device8*)Unsafe.AsPointer(ref this), nodeMask, type, flags, riid, ppCommandList); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(15)] + public HResult CreateProtectedResourceSession(ProtectedResourceSessionDescription* pDesc, Guid* riid, void** ppSession) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[15]))((ID3D12Device8*)Unsafe.AsPointer(ref this), pDesc, riid, ppSession); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[15]))((ID3D12Device8*)Unsafe.AsPointer(ref this), pDesc, riid, ppSession); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(16)] + public HResult CreateCommittedResource1(HeapProperties* pHeapProperties, HeapFlags HeapFlags, ResourceDescription* pDesc, ResourceStates InitialResourceState, ClearValue* pOptimizedClearValue, ID3D12ProtectedResourceSession* pProtectedSession, Guid* riidResource, void** ppvResource) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[16]))((ID3D12Device8*)Unsafe.AsPointer(ref this), pHeapProperties, HeapFlags, pDesc, InitialResourceState, pOptimizedClearValue, pProtectedSession, riidResource, ppvResource); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[16]))((ID3D12Device8*)Unsafe.AsPointer(ref this), pHeapProperties, HeapFlags, pDesc, InitialResourceState, pOptimizedClearValue, pProtectedSession, riidResource, ppvResource); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(17)] + public HResult CreateHeap1(HeapDescription* pDesc, ID3D12ProtectedResourceSession* pProtectedSession, Guid* riid, void** ppvHeap) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[17]))((ID3D12Device8*)Unsafe.AsPointer(ref this), pDesc, pProtectedSession, riid, ppvHeap); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[17]))((ID3D12Device8*)Unsafe.AsPointer(ref this), pDesc, pProtectedSession, riid, ppvHeap); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(18)] + public HResult CreateReservedResource1(ResourceDescription* pDesc, ResourceStates InitialState, ClearValue* pOptimizedClearValue, ID3D12ProtectedResourceSession* pProtectedSession, Guid* riid, void** ppvResource) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[18]))((ID3D12Device8*)Unsafe.AsPointer(ref this), pDesc, InitialState, pOptimizedClearValue, pProtectedSession, riid, ppvResource); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[18]))((ID3D12Device8*)Unsafe.AsPointer(ref this), pDesc, InitialState, pOptimizedClearValue, pProtectedSession, riid, ppvResource); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(19)] + public Graphics.Direct3D12.ResourceAllocationInfo GetResourceAllocationInfo1(uint visibleMask, uint numResourceDescs, ResourceDescription* pResourceDescs, ResourceAllocationInfo1* pResourceAllocationInfo1) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[19]))((ID3D12Device8*)Unsafe.AsPointer(ref this), visibleMask, numResourceDescs, pResourceDescs, pResourceAllocationInfo1); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[19]))((ID3D12Device8*)Unsafe.AsPointer(ref this), visibleMask, numResourceDescs, pResourceDescs, pResourceAllocationInfo1); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(20)] + public HResult OpenExistingHeapFromAddress(void* pAddress, Guid* riid, void** ppvHeap) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[20]))((ID3D12Device8*)Unsafe.AsPointer(ref this), pAddress, riid, ppvHeap); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[20]))((ID3D12Device8*)Unsafe.AsPointer(ref this), pAddress, riid, ppvHeap); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(21)] + public HResult OpenExistingHeapFromFileMapping(IntPtr hFileMapping, Guid* riid, void** ppvHeap) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[21]))((ID3D12Device8*)Unsafe.AsPointer(ref this), hFileMapping, riid, ppvHeap); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[21]))((ID3D12Device8*)Unsafe.AsPointer(ref this), hFileMapping, riid, ppvHeap); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(22)] + public HResult EnqueueMakeResident(ResidencyFlags Flags, uint NumObjects, ID3D12Pageable* ppObjects, ID3D12Fence* pFenceToSignal, ulong FenceValueToSignal) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[22]))((ID3D12Device8*)Unsafe.AsPointer(ref this), Flags, NumObjects, ppObjects, pFenceToSignal, FenceValueToSignal); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[22]))((ID3D12Device8*)Unsafe.AsPointer(ref this), Flags, NumObjects, ppObjects, pFenceToSignal, FenceValueToSignal); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(23)] + public HResult CreatePipelineState(PipelineStateStreamDescription* pDesc, Guid* riid, void** ppPipelineState) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[23]))((ID3D12Device8*)Unsafe.AsPointer(ref this), pDesc, riid, ppPipelineState); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[23]))((ID3D12Device8*)Unsafe.AsPointer(ref this), pDesc, riid, ppPipelineState); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(24)] + public HResult CreatePipelineLibrary(void* pLibraryBlob, nuint BlobLength, Guid* riid, void** ppPipelineLibrary) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[24]))((ID3D12Device8*)Unsafe.AsPointer(ref this), pLibraryBlob, BlobLength, riid, ppPipelineLibrary); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[24]))((ID3D12Device8*)Unsafe.AsPointer(ref this), pLibraryBlob, BlobLength, riid, ppPipelineLibrary); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(25)] + public HResult SetEventOnMultipleFenceCompletion(ID3D12Fence* ppFences, ulong* pFenceValues, uint NumFences, MultipleFenceWaitFlags Flags, IntPtr hEvent) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[25]))((ID3D12Device8*)Unsafe.AsPointer(ref this), ppFences, pFenceValues, NumFences, Flags, hEvent); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[25]))((ID3D12Device8*)Unsafe.AsPointer(ref this), ppFences, pFenceValues, NumFences, Flags, hEvent); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(26)] + public HResult SetResidencyPriority(uint NumObjects, ID3D12Pageable* ppObjects, ResidencyPriority* pPriorities) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[26]))((ID3D12Device8*)Unsafe.AsPointer(ref this), NumObjects, ppObjects, pPriorities); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[26]))((ID3D12Device8*)Unsafe.AsPointer(ref this), NumObjects, ppObjects, pPriorities); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(27)] + public uint GetNodeCount() + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[27]))((ID3D12Device8*)Unsafe.AsPointer(ref this)); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[27]))((ID3D12Device8*)Unsafe.AsPointer(ref this)); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(28)] + public HResult CreateCommandQueue(CommandQueueDescription* pDesc, Guid* riid, void** ppCommandQueue) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[28]))((ID3D12Device8*)Unsafe.AsPointer(ref this), pDesc, riid, ppCommandQueue); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[28]))((ID3D12Device8*)Unsafe.AsPointer(ref this), pDesc, riid, ppCommandQueue); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(29)] + public HResult CreateCommandAllocator(CommandListType type, Guid* riid, void** ppCommandAllocator) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[29]))((ID3D12Device8*)Unsafe.AsPointer(ref this), type, riid, ppCommandAllocator); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[29]))((ID3D12Device8*)Unsafe.AsPointer(ref this), type, riid, ppCommandAllocator); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(30)] + public HResult CreateGraphicsPipelineState(GraphicsPipelineStateDescription* pDesc, Guid* riid, void** ppPipelineState) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[30]))((ID3D12Device8*)Unsafe.AsPointer(ref this), pDesc, riid, ppPipelineState); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[30]))((ID3D12Device8*)Unsafe.AsPointer(ref this), pDesc, riid, ppPipelineState); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(31)] + public HResult CreateComputePipelineState(ComputePipelineStateDescription* pDesc, Guid* riid, void** ppPipelineState) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[31]))((ID3D12Device8*)Unsafe.AsPointer(ref this), pDesc, riid, ppPipelineState); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[31]))((ID3D12Device8*)Unsafe.AsPointer(ref this), pDesc, riid, ppPipelineState); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(32)] + public HResult CreateCommandList(uint nodeMask, CommandListType type, ID3D12CommandAllocator* pCommandAllocator, ID3D12PipelineState* pInitialState, Guid* riid, void** ppCommandList) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[32]))((ID3D12Device8*)Unsafe.AsPointer(ref this), nodeMask, type, pCommandAllocator, pInitialState, riid, ppCommandList); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[32]))((ID3D12Device8*)Unsafe.AsPointer(ref this), nodeMask, type, pCommandAllocator, pInitialState, riid, ppCommandList); +#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]))((ID3D12Device8*)Unsafe.AsPointer(ref this), Feature, pFeatureSupportData, FeatureSupportDataSize); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[33]))((ID3D12Device8*)Unsafe.AsPointer(ref this), Feature, pFeatureSupportData, FeatureSupportDataSize); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(34)] + public HResult CreateDescriptorHeap(DescriptorHeapDescription* pDescriptorHeapDesc, Guid* riid, void** ppvHeap) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[34]))((ID3D12Device8*)Unsafe.AsPointer(ref this), pDescriptorHeapDesc, riid, ppvHeap); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[34]))((ID3D12Device8*)Unsafe.AsPointer(ref this), pDescriptorHeapDesc, riid, ppvHeap); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(35)] + public uint GetDescriptorHandleIncrementSize(DescriptorHeapType DescriptorHeapType) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[35]))((ID3D12Device8*)Unsafe.AsPointer(ref this), DescriptorHeapType); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[35]))((ID3D12Device8*)Unsafe.AsPointer(ref this), DescriptorHeapType); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(36)] + public HResult CreateRootSignature(uint nodeMask, void* pBlobWithRootSignature, nuint blobLengthInBytes, Guid* riid, void** ppvRootSignature) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[36]))((ID3D12Device8*)Unsafe.AsPointer(ref this), nodeMask, pBlobWithRootSignature, blobLengthInBytes, riid, ppvRootSignature); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[36]))((ID3D12Device8*)Unsafe.AsPointer(ref this), nodeMask, pBlobWithRootSignature, blobLengthInBytes, riid, ppvRootSignature); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(37)] + public void CreateConstantBufferView(ConstantBufferViewDescription* pDesc, CpuDescriptorHandle* DestDescriptor) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[37]))((ID3D12Device8*)Unsafe.AsPointer(ref this), pDesc, DestDescriptor); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[37]))((ID3D12Device8*)Unsafe.AsPointer(ref this), pDesc, DestDescriptor); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(38)] + public void CreateShaderResourceView(ID3D12Resource* pResource, ShaderResourceViewDescription* pDesc, CpuDescriptorHandle* DestDescriptor) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[38]))((ID3D12Device8*)Unsafe.AsPointer(ref this), pResource, pDesc, DestDescriptor); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[38]))((ID3D12Device8*)Unsafe.AsPointer(ref this), pResource, pDesc, DestDescriptor); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(39)] + public void CreateUnorderedAccessView(ID3D12Resource* pResource, ID3D12Resource* pCounterResource, UnorderedAccessViewDescription* pDesc, CpuDescriptorHandle* DestDescriptor) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[39]))((ID3D12Device8*)Unsafe.AsPointer(ref this), pResource, pCounterResource, pDesc, DestDescriptor); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[39]))((ID3D12Device8*)Unsafe.AsPointer(ref this), pResource, pCounterResource, pDesc, DestDescriptor); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(40)] + public void CreateRenderTargetView(ID3D12Resource* pResource, RenderTargetViewDescription* pDesc, CpuDescriptorHandle* DestDescriptor) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[40]))((ID3D12Device8*)Unsafe.AsPointer(ref this), pResource, pDesc, DestDescriptor); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[40]))((ID3D12Device8*)Unsafe.AsPointer(ref this), pResource, pDesc, DestDescriptor); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(41)] + public void CreateDepthStencilView(ID3D12Resource* pResource, DepthStencilViewDescription* pDesc, CpuDescriptorHandle* DestDescriptor) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[41]))((ID3D12Device8*)Unsafe.AsPointer(ref this), pResource, pDesc, DestDescriptor); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[41]))((ID3D12Device8*)Unsafe.AsPointer(ref this), pResource, pDesc, DestDescriptor); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(42)] + public void CreateSampler(SamplerDescription* pDesc, CpuDescriptorHandle* DestDescriptor) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[42]))((ID3D12Device8*)Unsafe.AsPointer(ref this), pDesc, DestDescriptor); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[42]))((ID3D12Device8*)Unsafe.AsPointer(ref this), pDesc, DestDescriptor); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(43)] + public void CopyDescriptors(uint NumDestDescriptorRanges, CpuDescriptorHandle* pDestDescriptorRangeStarts, uint* pDestDescriptorRangeSizes, uint NumSrcDescriptorRanges, CpuDescriptorHandle* pSrcDescriptorRangeStarts, uint* pSrcDescriptorRangeSizes, DescriptorHeapType DescriptorHeapsType) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[43]))((ID3D12Device8*)Unsafe.AsPointer(ref this), NumDestDescriptorRanges, pDestDescriptorRangeStarts, pDestDescriptorRangeSizes, NumSrcDescriptorRanges, pSrcDescriptorRangeStarts, pSrcDescriptorRangeSizes, DescriptorHeapsType); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[43]))((ID3D12Device8*)Unsafe.AsPointer(ref this), NumDestDescriptorRanges, pDestDescriptorRangeStarts, pDestDescriptorRangeSizes, NumSrcDescriptorRanges, pSrcDescriptorRangeStarts, pSrcDescriptorRangeSizes, DescriptorHeapsType); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(44)] + public void CopyDescriptorsSimple(uint NumDescriptors, CpuDescriptorHandle* DestDescriptorRangeStart, CpuDescriptorHandle* SrcDescriptorRangeStart, DescriptorHeapType DescriptorHeapsType) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[44]))((ID3D12Device8*)Unsafe.AsPointer(ref this), NumDescriptors, DestDescriptorRangeStart, SrcDescriptorRangeStart, DescriptorHeapsType); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[44]))((ID3D12Device8*)Unsafe.AsPointer(ref this), NumDescriptors, DestDescriptorRangeStart, SrcDescriptorRangeStart, DescriptorHeapsType); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(45)] + public Graphics.Direct3D12.ResourceAllocationInfo GetResourceAllocationInfo(uint visibleMask, uint numResourceDescs, ResourceDescription* pResourceDescs) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[45]))((ID3D12Device8*)Unsafe.AsPointer(ref this), visibleMask, numResourceDescs, pResourceDescs); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[45]))((ID3D12Device8*)Unsafe.AsPointer(ref this), visibleMask, numResourceDescs, pResourceDescs); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(46)] + public Graphics.Direct3D12.HeapProperties GetCustomHeapProperties(uint nodeMask, HeapType heapType) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[46]))((ID3D12Device8*)Unsafe.AsPointer(ref this), nodeMask, heapType); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[46]))((ID3D12Device8*)Unsafe.AsPointer(ref this), nodeMask, heapType); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(47)] + public HResult CreateCommittedResource(HeapProperties* pHeapProperties, HeapFlags HeapFlags, ResourceDescription* pDesc, ResourceStates InitialResourceState, ClearValue* pOptimizedClearValue, Guid* riidResource, void** ppvResource) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[47]))((ID3D12Device8*)Unsafe.AsPointer(ref this), pHeapProperties, HeapFlags, pDesc, InitialResourceState, pOptimizedClearValue, riidResource, ppvResource); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[47]))((ID3D12Device8*)Unsafe.AsPointer(ref this), pHeapProperties, HeapFlags, pDesc, InitialResourceState, pOptimizedClearValue, riidResource, ppvResource); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(48)] + public HResult CreateHeap(HeapDescription* pDesc, Guid* riid, void** ppvHeap) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[48]))((ID3D12Device8*)Unsafe.AsPointer(ref this), pDesc, riid, ppvHeap); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[48]))((ID3D12Device8*)Unsafe.AsPointer(ref this), pDesc, riid, ppvHeap); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(49)] + public HResult CreatePlacedResource(ID3D12Heap* pHeap, ulong HeapOffset, ResourceDescription* pDesc, ResourceStates InitialState, ClearValue* pOptimizedClearValue, Guid* riid, void** ppvResource) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[49]))((ID3D12Device8*)Unsafe.AsPointer(ref this), pHeap, HeapOffset, pDesc, InitialState, pOptimizedClearValue, riid, ppvResource); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[49]))((ID3D12Device8*)Unsafe.AsPointer(ref this), pHeap, HeapOffset, pDesc, InitialState, pOptimizedClearValue, riid, ppvResource); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(50)] + public HResult CreateReservedResource(ResourceDescription* pDesc, ResourceStates InitialState, ClearValue* pOptimizedClearValue, Guid* riid, void** ppvResource) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[50]))((ID3D12Device8*)Unsafe.AsPointer(ref this), pDesc, InitialState, pOptimizedClearValue, riid, ppvResource); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[50]))((ID3D12Device8*)Unsafe.AsPointer(ref this), pDesc, InitialState, pOptimizedClearValue, riid, ppvResource); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(51)] + public HResult CreateSharedHandle(ID3D12DeviceChild* pObject, Security.SECURITY_ATTRIBUTES* pAttributes, uint Access, char** Name, IntPtr* pHandle) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[51]))((ID3D12Device8*)Unsafe.AsPointer(ref this), pObject, pAttributes, Access, Name, pHandle); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[51]))((ID3D12Device8*)Unsafe.AsPointer(ref this), pObject, pAttributes, Access, Name, pHandle); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(52)] + public HResult OpenSharedHandle(IntPtr NTHandle, Guid* riid, void** ppvObj) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[52]))((ID3D12Device8*)Unsafe.AsPointer(ref this), NTHandle, riid, ppvObj); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[52]))((ID3D12Device8*)Unsafe.AsPointer(ref this), NTHandle, riid, ppvObj); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(53)] + public HResult OpenSharedHandleByName(char** Name, uint Access, IntPtr* pNTHandle) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[53]))((ID3D12Device8*)Unsafe.AsPointer(ref this), Name, Access, pNTHandle); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[53]))((ID3D12Device8*)Unsafe.AsPointer(ref this), Name, Access, pNTHandle); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(54)] + public HResult MakeResident(uint NumObjects, ID3D12Pageable* ppObjects) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[54]))((ID3D12Device8*)Unsafe.AsPointer(ref this), NumObjects, ppObjects); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[54]))((ID3D12Device8*)Unsafe.AsPointer(ref this), NumObjects, ppObjects); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(55)] + public HResult Evict(uint NumObjects, ID3D12Pageable* ppObjects) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[55]))((ID3D12Device8*)Unsafe.AsPointer(ref this), NumObjects, ppObjects); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[55]))((ID3D12Device8*)Unsafe.AsPointer(ref this), NumObjects, ppObjects); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(56)] + public HResult CreateFence(ulong InitialValue, FenceFlags Flags, Guid* riid, void** ppFence) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[56]))((ID3D12Device8*)Unsafe.AsPointer(ref this), InitialValue, Flags, riid, ppFence); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[56]))((ID3D12Device8*)Unsafe.AsPointer(ref this), InitialValue, Flags, riid, ppFence); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(57)] + public HResult GetDeviceRemovedReason() + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[57]))((ID3D12Device8*)Unsafe.AsPointer(ref this)); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[57]))((ID3D12Device8*)Unsafe.AsPointer(ref this)); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(58)] + public void GetCopyableFootprints(ResourceDescription* pResourceDesc, uint FirstSubresource, uint NumSubresources, ulong BaseOffset, PlacedSubresourceFootprint* pLayouts, uint* pNumRows, ulong* pRowSizeInBytes, ulong* pTotalBytes) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[58]))((ID3D12Device8*)Unsafe.AsPointer(ref this), pResourceDesc, FirstSubresource, NumSubresources, BaseOffset, pLayouts, pNumRows, pRowSizeInBytes, pTotalBytes); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[58]))((ID3D12Device8*)Unsafe.AsPointer(ref this), pResourceDesc, FirstSubresource, NumSubresources, BaseOffset, pLayouts, pNumRows, pRowSizeInBytes, pTotalBytes); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(59)] + public HResult CreateQueryHeap(QueryHeapDescription* pDesc, Guid* riid, void** ppvHeap) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[59]))((ID3D12Device8*)Unsafe.AsPointer(ref this), pDesc, riid, ppvHeap); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[59]))((ID3D12Device8*)Unsafe.AsPointer(ref this), pDesc, riid, ppvHeap); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(60)] + public HResult SetStablePowerState(Bool32 Enable) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[60]))((ID3D12Device8*)Unsafe.AsPointer(ref this), Enable); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[60]))((ID3D12Device8*)Unsafe.AsPointer(ref this), Enable); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(61)] + public HResult CreateCommandSignature(CommandSignatureDescription* pDesc, ID3D12RootSignature* pRootSignature, Guid* riid, void** ppvCommandSignature) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[61]))((ID3D12Device8*)Unsafe.AsPointer(ref this), pDesc, pRootSignature, riid, ppvCommandSignature); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[61]))((ID3D12Device8*)Unsafe.AsPointer(ref this), pDesc, pRootSignature, riid, ppvCommandSignature); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(62)] + public void GetResourceTiling(ID3D12Resource* pTiledResource, uint* pNumTilesForEntireResource, PackedMipInfo* pPackedMipDesc, TileShape* pStandardTileShapeForNonPackedMips, uint* pNumSubresourceTilings, uint FirstSubresourceTilingToGet, SubresourceTiling* pSubresourceTilingsForNonPackedMips) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[62]))((ID3D12Device8*)Unsafe.AsPointer(ref this), pTiledResource, pNumTilesForEntireResource, pPackedMipDesc, pStandardTileShapeForNonPackedMips, pNumSubresourceTilings, FirstSubresourceTilingToGet, pSubresourceTilingsForNonPackedMips); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[62]))((ID3D12Device8*)Unsafe.AsPointer(ref this), pTiledResource, pNumTilesForEntireResource, pPackedMipDesc, pStandardTileShapeForNonPackedMips, pNumSubresourceTilings, FirstSubresourceTilingToGet, pSubresourceTilingsForNonPackedMips); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(63)] + public Luid GetAdapterLuid() + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[63]))((ID3D12Device8*)Unsafe.AsPointer(ref this)); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[63]))((ID3D12Device8*)Unsafe.AsPointer(ref this)); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(64)] + public HResult GetPrivateData(Guid* guid, uint* pDataSize, void* pData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[64]))((ID3D12Device8*)Unsafe.AsPointer(ref this), guid, pDataSize, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[64]))((ID3D12Device8*)Unsafe.AsPointer(ref this), guid, pDataSize, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(65)] + public HResult SetPrivateData(Guid* guid, uint DataSize, void* pData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[65]))((ID3D12Device8*)Unsafe.AsPointer(ref this), guid, DataSize, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[65]))((ID3D12Device8*)Unsafe.AsPointer(ref this), guid, DataSize, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(66)] + public HResult SetPrivateDataInterface(Guid* guid, IUnknown* pData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[66]))((ID3D12Device8*)Unsafe.AsPointer(ref this), guid, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[66]))((ID3D12Device8*)Unsafe.AsPointer(ref this), guid, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(67)] + public HResult SetName(char** Name) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[67]))((ID3D12Device8*)Unsafe.AsPointer(ref this), Name); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[67]))((ID3D12Device8*)Unsafe.AsPointer(ref this), Name); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(68)] + public Graphics.Direct3D12.ResourceAllocationInfo GetResourceAllocationInfo2(uint visibleMask, uint numResourceDescs, ResourceDescription1* pResourceDescs, ResourceAllocationInfo1* pResourceAllocationInfo1) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[68]))((ID3D12Device8*)Unsafe.AsPointer(ref this), visibleMask, numResourceDescs, pResourceDescs, pResourceAllocationInfo1); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[68]))((ID3D12Device8*)Unsafe.AsPointer(ref this), visibleMask, numResourceDescs, pResourceDescs, pResourceAllocationInfo1); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(69)] + public HResult CreateCommittedResource2(HeapProperties* pHeapProperties, HeapFlags HeapFlags, ResourceDescription1* pDesc, ResourceStates InitialResourceState, ClearValue* pOptimizedClearValue, ID3D12ProtectedResourceSession* pProtectedSession, Guid* riidResource, void** ppvResource) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[69]))((ID3D12Device8*)Unsafe.AsPointer(ref this), pHeapProperties, HeapFlags, pDesc, InitialResourceState, pOptimizedClearValue, pProtectedSession, riidResource, ppvResource); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[69]))((ID3D12Device8*)Unsafe.AsPointer(ref this), pHeapProperties, HeapFlags, pDesc, InitialResourceState, pOptimizedClearValue, pProtectedSession, riidResource, ppvResource); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(70)] + public HResult CreatePlacedResource1(ID3D12Heap* pHeap, ulong HeapOffset, ResourceDescription1* pDesc, ResourceStates InitialState, ClearValue* pOptimizedClearValue, Guid* riid, void** ppvResource) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[70]))((ID3D12Device8*)Unsafe.AsPointer(ref this), pHeap, HeapOffset, pDesc, InitialState, pOptimizedClearValue, riid, ppvResource); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[70]))((ID3D12Device8*)Unsafe.AsPointer(ref this), pHeap, HeapOffset, pDesc, InitialState, pOptimizedClearValue, riid, ppvResource); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(71)] + public void CreateSamplerFeedbackUnorderedAccessView(ID3D12Resource* pTargetedResource, ID3D12Resource* pFeedbackResource, CpuDescriptorHandle* DestDescriptor) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[71]))((ID3D12Device8*)Unsafe.AsPointer(ref this), pTargetedResource, pFeedbackResource, DestDescriptor); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[71]))((ID3D12Device8*)Unsafe.AsPointer(ref this), pTargetedResource, pFeedbackResource, DestDescriptor); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(72)] + public void GetCopyableFootprints1(ResourceDescription1* pResourceDesc, uint FirstSubresource, uint NumSubresources, ulong BaseOffset, PlacedSubresourceFootprint* pLayouts, uint* pNumRows, ulong* pRowSizeInBytes, ulong* pTotalBytes) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[72]))((ID3D12Device8*)Unsafe.AsPointer(ref this), pResourceDesc, FirstSubresource, NumSubresources, BaseOffset, pLayouts, pNumRows, pRowSizeInBytes, pTotalBytes); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[72]))((ID3D12Device8*)Unsafe.AsPointer(ref this), pResourceDesc, FirstSubresource, NumSubresources, BaseOffset, pLayouts, pNumRows, pRowSizeInBytes, pTotalBytes); +#endif + } + + public interface Interface : ID3D12Device7.Interface + { + } +} + +/// +/// ID3D12Resource1 +[Guid("9d5e227a-4430-4161-88b3-3eca6bb16e19")] +[NativeTypeName("struct ID3D12Resource1 : ID3D12Resource")] +[NativeInheritance("ID3D12Resource")] +public unsafe partial struct ID3D12Resource1 : ID3D12Resource1.Interface +{ + public static ref readonly Guid IID_ID3D12Resource1 + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x7A, 0x22, 0x5E, 0x9D, + 0x30, 0x44, + 0x61, 0x41, + 0x88, + 0xB3, + 0x3E, + 0xCA, + 0x6B, + 0xB1, + 0x6E, + 0x19 + }; + + 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_ID3D12Resource1)); + + 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 Map(uint Subresource, Range* pReadRange, void** ppData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[3]))((ID3D12Resource1*)Unsafe.AsPointer(ref this), Subresource, pReadRange, ppData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((ID3D12Resource1*)Unsafe.AsPointer(ref this), Subresource, pReadRange, ppData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public void Unmap(uint Subresource, Range* pWrittenRange) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[4]))((ID3D12Resource1*)Unsafe.AsPointer(ref this), Subresource, pWrittenRange); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((ID3D12Resource1*)Unsafe.AsPointer(ref this), Subresource, pWrittenRange); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(5)] + public Graphics.Direct3D12.ResourceDescription GetDesc() + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[5]))((ID3D12Resource1*)Unsafe.AsPointer(ref this)); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((ID3D12Resource1*)Unsafe.AsPointer(ref this)); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(6)] + public ulong GetGPUVirtualAddress() + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[6]))((ID3D12Resource1*)Unsafe.AsPointer(ref this)); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((ID3D12Resource1*)Unsafe.AsPointer(ref this)); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(7)] + public HResult WriteToSubresource(uint DstSubresource, Box* pDstBox, void* pSrcData, uint SrcRowPitch, uint SrcDepthPitch) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[7]))((ID3D12Resource1*)Unsafe.AsPointer(ref this), DstSubresource, pDstBox, pSrcData, SrcRowPitch, SrcDepthPitch); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((ID3D12Resource1*)Unsafe.AsPointer(ref this), DstSubresource, pDstBox, pSrcData, SrcRowPitch, SrcDepthPitch); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(8)] + public HResult ReadFromSubresource(void* pDstData, uint DstRowPitch, uint DstDepthPitch, uint SrcSubresource, Box* pSrcBox) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[8]))((ID3D12Resource1*)Unsafe.AsPointer(ref this), pDstData, DstRowPitch, DstDepthPitch, SrcSubresource, pSrcBox); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[8]))((ID3D12Resource1*)Unsafe.AsPointer(ref this), pDstData, DstRowPitch, DstDepthPitch, SrcSubresource, pSrcBox); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(9)] + public HResult GetHeapProperties(HeapProperties* pHeapProperties, HeapFlags* pHeapFlags) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[9]))((ID3D12Resource1*)Unsafe.AsPointer(ref this), pHeapProperties, pHeapFlags); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[9]))((ID3D12Resource1*)Unsafe.AsPointer(ref this), pHeapProperties, pHeapFlags); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(10)] + public HResult GetDevice(Guid* riid, void** ppvDevice) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[10]))((ID3D12Resource1*)Unsafe.AsPointer(ref this), riid, ppvDevice); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[10]))((ID3D12Resource1*)Unsafe.AsPointer(ref this), riid, ppvDevice); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(11)] + public HResult GetPrivateData(Guid* guid, uint* pDataSize, void* pData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[11]))((ID3D12Resource1*)Unsafe.AsPointer(ref this), guid, pDataSize, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[11]))((ID3D12Resource1*)Unsafe.AsPointer(ref this), guid, pDataSize, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(12)] + public HResult SetPrivateData(Guid* guid, uint DataSize, void* pData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[12]))((ID3D12Resource1*)Unsafe.AsPointer(ref this), guid, DataSize, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[12]))((ID3D12Resource1*)Unsafe.AsPointer(ref this), guid, DataSize, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(13)] + public HResult SetPrivateDataInterface(Guid* guid, IUnknown* pData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[13]))((ID3D12Resource1*)Unsafe.AsPointer(ref this), guid, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[13]))((ID3D12Resource1*)Unsafe.AsPointer(ref this), guid, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(14)] + public HResult SetName(char** Name) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[14]))((ID3D12Resource1*)Unsafe.AsPointer(ref this), Name); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[14]))((ID3D12Resource1*)Unsafe.AsPointer(ref this), Name); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(15)] + public HResult GetProtectedResourceSession(Guid* riid, void** ppProtectedSession) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[15]))((ID3D12Resource1*)Unsafe.AsPointer(ref this), riid, ppProtectedSession); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[15]))((ID3D12Resource1*)Unsafe.AsPointer(ref this), riid, ppProtectedSession); +#endif + } + + public interface Interface : ID3D12Resource.Interface + { + } +} + +/// +/// ID3D12Resource2 +[Guid("be36ec3b-ea85-4aeb-a45a-e9d76404a495")] +[NativeTypeName("struct ID3D12Resource2 : ID3D12Resource1")] +[NativeInheritance("ID3D12Resource1")] +public unsafe partial struct ID3D12Resource2 : ID3D12Resource2.Interface +{ + public static ref readonly Guid IID_ID3D12Resource2 + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x3B, 0xEC, 0x36, 0xBE, + 0x85, 0xEA, + 0xEB, 0x4A, + 0xA4, + 0x5A, + 0xE9, + 0xD7, + 0x64, + 0x04, + 0xA4, + 0x95 + }; + + 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_ID3D12Resource2)); + + 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 GetProtectedResourceSession(Guid* riid, void** ppProtectedSession) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[3]))((ID3D12Resource2*)Unsafe.AsPointer(ref this), riid, ppProtectedSession); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((ID3D12Resource2*)Unsafe.AsPointer(ref this), riid, ppProtectedSession); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public HResult Map(uint Subresource, Range* pReadRange, void** ppData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[4]))((ID3D12Resource2*)Unsafe.AsPointer(ref this), Subresource, pReadRange, ppData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((ID3D12Resource2*)Unsafe.AsPointer(ref this), Subresource, pReadRange, ppData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(5)] + public void Unmap(uint Subresource, Range* pWrittenRange) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[5]))((ID3D12Resource2*)Unsafe.AsPointer(ref this), Subresource, pWrittenRange); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((ID3D12Resource2*)Unsafe.AsPointer(ref this), Subresource, pWrittenRange); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(6)] + public Graphics.Direct3D12.ResourceDescription GetDesc() + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[6]))((ID3D12Resource2*)Unsafe.AsPointer(ref this)); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((ID3D12Resource2*)Unsafe.AsPointer(ref this)); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(7)] + public ulong GetGPUVirtualAddress() + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[7]))((ID3D12Resource2*)Unsafe.AsPointer(ref this)); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((ID3D12Resource2*)Unsafe.AsPointer(ref this)); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(8)] + public HResult WriteToSubresource(uint DstSubresource, Box* pDstBox, void* pSrcData, uint SrcRowPitch, uint SrcDepthPitch) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[8]))((ID3D12Resource2*)Unsafe.AsPointer(ref this), DstSubresource, pDstBox, pSrcData, SrcRowPitch, SrcDepthPitch); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[8]))((ID3D12Resource2*)Unsafe.AsPointer(ref this), DstSubresource, pDstBox, pSrcData, SrcRowPitch, SrcDepthPitch); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(9)] + public HResult ReadFromSubresource(void* pDstData, uint DstRowPitch, uint DstDepthPitch, uint SrcSubresource, Box* pSrcBox) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[9]))((ID3D12Resource2*)Unsafe.AsPointer(ref this), pDstData, DstRowPitch, DstDepthPitch, SrcSubresource, pSrcBox); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[9]))((ID3D12Resource2*)Unsafe.AsPointer(ref this), pDstData, DstRowPitch, DstDepthPitch, SrcSubresource, pSrcBox); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(10)] + public HResult GetHeapProperties(HeapProperties* pHeapProperties, HeapFlags* pHeapFlags) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[10]))((ID3D12Resource2*)Unsafe.AsPointer(ref this), pHeapProperties, pHeapFlags); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[10]))((ID3D12Resource2*)Unsafe.AsPointer(ref this), pHeapProperties, pHeapFlags); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(11)] + public HResult GetDevice(Guid* riid, void** ppvDevice) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[11]))((ID3D12Resource2*)Unsafe.AsPointer(ref this), riid, ppvDevice); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[11]))((ID3D12Resource2*)Unsafe.AsPointer(ref this), riid, ppvDevice); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(12)] + public HResult GetPrivateData(Guid* guid, uint* pDataSize, void* pData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[12]))((ID3D12Resource2*)Unsafe.AsPointer(ref this), guid, pDataSize, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[12]))((ID3D12Resource2*)Unsafe.AsPointer(ref this), guid, pDataSize, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(13)] + public HResult SetPrivateData(Guid* guid, uint DataSize, void* pData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[13]))((ID3D12Resource2*)Unsafe.AsPointer(ref this), guid, DataSize, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[13]))((ID3D12Resource2*)Unsafe.AsPointer(ref this), guid, DataSize, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(14)] + public HResult SetPrivateDataInterface(Guid* guid, IUnknown* pData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[14]))((ID3D12Resource2*)Unsafe.AsPointer(ref this), guid, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[14]))((ID3D12Resource2*)Unsafe.AsPointer(ref this), guid, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(15)] + public HResult SetName(char** Name) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[15]))((ID3D12Resource2*)Unsafe.AsPointer(ref this), Name); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[15]))((ID3D12Resource2*)Unsafe.AsPointer(ref this), Name); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(16)] + public Graphics.Direct3D12.ResourceDescription1 GetDesc1() + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[16]))((ID3D12Resource2*)Unsafe.AsPointer(ref this)); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[16]))((ID3D12Resource2*)Unsafe.AsPointer(ref this)); +#endif + } + + public interface Interface : ID3D12Resource1.Interface + { + } +} + +/// +/// ID3D12Heap1 +[Guid("572f7389-2168-49e3-9693-d6df5871bf6d")] +[NativeTypeName("struct ID3D12Heap1 : ID3D12Heap")] +[NativeInheritance("ID3D12Heap")] +public unsafe partial struct ID3D12Heap1 : ID3D12Heap1.Interface +{ + public static ref readonly Guid IID_ID3D12Heap1 + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x89, 0x73, 0x2F, 0x57, + 0x68, 0x21, + 0xE3, 0x49, + 0x96, + 0x93, + 0xD6, + 0xDF, + 0x58, + 0x71, + 0xBF, + 0x6D + }; + + 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_ID3D12Heap1)); + + 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 Graphics.Direct3D12.HeapDescription GetDesc() + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[3]))((ID3D12Heap1*)Unsafe.AsPointer(ref this)); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((ID3D12Heap1*)Unsafe.AsPointer(ref this)); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public HResult GetDevice(Guid* riid, void** ppvDevice) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[4]))((ID3D12Heap1*)Unsafe.AsPointer(ref this), riid, ppvDevice); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((ID3D12Heap1*)Unsafe.AsPointer(ref this), riid, ppvDevice); +#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]))((ID3D12Heap1*)Unsafe.AsPointer(ref this), guid, pDataSize, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((ID3D12Heap1*)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]))((ID3D12Heap1*)Unsafe.AsPointer(ref this), guid, DataSize, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((ID3D12Heap1*)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]))((ID3D12Heap1*)Unsafe.AsPointer(ref this), guid, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((ID3D12Heap1*)Unsafe.AsPointer(ref this), guid, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(8)] + public HResult SetName(char** Name) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[8]))((ID3D12Heap1*)Unsafe.AsPointer(ref this), Name); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[8]))((ID3D12Heap1*)Unsafe.AsPointer(ref this), Name); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(9)] + public HResult GetProtectedResourceSession(Guid* riid, void** ppProtectedSession) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[9]))((ID3D12Heap1*)Unsafe.AsPointer(ref this), riid, ppProtectedSession); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[9]))((ID3D12Heap1*)Unsafe.AsPointer(ref this), riid, ppProtectedSession); +#endif + } + + public interface Interface : ID3D12Heap.Interface + { + } +} + +/// +/// ID3D12GraphicsCommandList3 +[Guid("6fda83a7-b84c-4e38-9ac8-c7bd22016b3d")] +[NativeTypeName("struct ID3D12GraphicsCommandList3 : ID3D12GraphicsCommandList2")] +[NativeInheritance("ID3D12GraphicsCommandList2")] +public unsafe partial struct ID3D12GraphicsCommandList3 : ID3D12GraphicsCommandList3.Interface +{ + public static ref readonly Guid IID_ID3D12GraphicsCommandList3 + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0xA7, 0x83, 0xDA, 0x6F, + 0x4C, 0xB8, + 0x38, 0x4E, + 0x9A, + 0xC8, + 0xC7, + 0xBD, + 0x22, + 0x01, + 0x6B, + 0x3D + }; + + 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_ID3D12GraphicsCommandList3)); + + 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 WriteBufferImmediate(uint Count, WritebufferimmediateParameter* pParams, WritebufferimmediateMode* pModes) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[3]))((ID3D12GraphicsCommandList3*)Unsafe.AsPointer(ref this), Count, pParams, pModes); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((ID3D12GraphicsCommandList3*)Unsafe.AsPointer(ref this), Count, pParams, pModes); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public void AtomicCopyBufferUINT(ID3D12Resource* pDstBuffer, ulong DstOffset, ID3D12Resource* pSrcBuffer, ulong SrcOffset, uint Dependencies, ID3D12Resource* ppDependentResources, SubresourceRangeUint64* pDependentSubresourceRanges) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[4]))((ID3D12GraphicsCommandList3*)Unsafe.AsPointer(ref this), pDstBuffer, DstOffset, pSrcBuffer, SrcOffset, Dependencies, ppDependentResources, pDependentSubresourceRanges); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((ID3D12GraphicsCommandList3*)Unsafe.AsPointer(ref this), pDstBuffer, DstOffset, pSrcBuffer, SrcOffset, Dependencies, ppDependentResources, pDependentSubresourceRanges); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(5)] + public void AtomicCopyBufferUINT64(ID3D12Resource* pDstBuffer, ulong DstOffset, ID3D12Resource* pSrcBuffer, ulong SrcOffset, uint Dependencies, ID3D12Resource* ppDependentResources, SubresourceRangeUint64* pDependentSubresourceRanges) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[5]))((ID3D12GraphicsCommandList3*)Unsafe.AsPointer(ref this), pDstBuffer, DstOffset, pSrcBuffer, SrcOffset, Dependencies, ppDependentResources, pDependentSubresourceRanges); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((ID3D12GraphicsCommandList3*)Unsafe.AsPointer(ref this), pDstBuffer, DstOffset, pSrcBuffer, SrcOffset, Dependencies, ppDependentResources, pDependentSubresourceRanges); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(6)] + public void OMSetDepthBounds(float Min, float Max) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[6]))((ID3D12GraphicsCommandList3*)Unsafe.AsPointer(ref this), Min, Max); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((ID3D12GraphicsCommandList3*)Unsafe.AsPointer(ref this), Min, Max); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(7)] + public void SetSamplePositions(uint NumSamplesPerPixel, uint NumPixels, SamplePosition* pSamplePositions) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[7]))((ID3D12GraphicsCommandList3*)Unsafe.AsPointer(ref this), NumSamplesPerPixel, NumPixels, pSamplePositions); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((ID3D12GraphicsCommandList3*)Unsafe.AsPointer(ref this), NumSamplesPerPixel, NumPixels, pSamplePositions); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(8)] + public void ResolveSubresourceRegion(ID3D12Resource* pDstResource, uint DstSubresource, uint DstX, uint DstY, ID3D12Resource* pSrcResource, uint SrcSubresource, RawRect* pSrcRect, Graphics.Dxgi.Common.Format Format, ResolveMode ResolveMode) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[8]))((ID3D12GraphicsCommandList3*)Unsafe.AsPointer(ref this), pDstResource, DstSubresource, DstX, DstY, pSrcResource, SrcSubresource, pSrcRect, Format, ResolveMode); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[8]))((ID3D12GraphicsCommandList3*)Unsafe.AsPointer(ref this), pDstResource, DstSubresource, DstX, DstY, pSrcResource, SrcSubresource, pSrcRect, Format, ResolveMode); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(9)] + public void SetViewInstanceMask(uint Mask) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[9]))((ID3D12GraphicsCommandList3*)Unsafe.AsPointer(ref this), Mask); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[9]))((ID3D12GraphicsCommandList3*)Unsafe.AsPointer(ref this), Mask); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(10)] + public HResult Close() + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[10]))((ID3D12GraphicsCommandList3*)Unsafe.AsPointer(ref this)); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[10]))((ID3D12GraphicsCommandList3*)Unsafe.AsPointer(ref this)); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(11)] + public HResult Reset(ID3D12CommandAllocator* pAllocator, ID3D12PipelineState* pInitialState) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[11]))((ID3D12GraphicsCommandList3*)Unsafe.AsPointer(ref this), pAllocator, pInitialState); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[11]))((ID3D12GraphicsCommandList3*)Unsafe.AsPointer(ref this), pAllocator, pInitialState); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(12)] + public void ClearState(ID3D12PipelineState* pPipelineState) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[12]))((ID3D12GraphicsCommandList3*)Unsafe.AsPointer(ref this), pPipelineState); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[12]))((ID3D12GraphicsCommandList3*)Unsafe.AsPointer(ref this), pPipelineState); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(13)] + public void DrawInstanced(uint VertexCountPerInstance, uint InstanceCount, uint StartVertexLocation, uint StartInstanceLocation) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[13]))((ID3D12GraphicsCommandList3*)Unsafe.AsPointer(ref this), VertexCountPerInstance, InstanceCount, StartVertexLocation, StartInstanceLocation); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[13]))((ID3D12GraphicsCommandList3*)Unsafe.AsPointer(ref this), VertexCountPerInstance, InstanceCount, StartVertexLocation, StartInstanceLocation); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(14)] + public void DrawIndexedInstanced(uint IndexCountPerInstance, uint InstanceCount, uint StartIndexLocation, int BaseVertexLocation, uint StartInstanceLocation) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[14]))((ID3D12GraphicsCommandList3*)Unsafe.AsPointer(ref this), IndexCountPerInstance, InstanceCount, StartIndexLocation, BaseVertexLocation, StartInstanceLocation); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[14]))((ID3D12GraphicsCommandList3*)Unsafe.AsPointer(ref this), IndexCountPerInstance, InstanceCount, StartIndexLocation, BaseVertexLocation, StartInstanceLocation); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(15)] + public void Dispatch(uint ThreadGroupCountX, uint ThreadGroupCountY, uint ThreadGroupCountZ) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[15]))((ID3D12GraphicsCommandList3*)Unsafe.AsPointer(ref this), ThreadGroupCountX, ThreadGroupCountY, ThreadGroupCountZ); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[15]))((ID3D12GraphicsCommandList3*)Unsafe.AsPointer(ref this), ThreadGroupCountX, ThreadGroupCountY, ThreadGroupCountZ); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(16)] + public void CopyBufferRegion(ID3D12Resource* pDstBuffer, ulong DstOffset, ID3D12Resource* pSrcBuffer, ulong SrcOffset, ulong NumBytes) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[16]))((ID3D12GraphicsCommandList3*)Unsafe.AsPointer(ref this), pDstBuffer, DstOffset, pSrcBuffer, SrcOffset, NumBytes); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[16]))((ID3D12GraphicsCommandList3*)Unsafe.AsPointer(ref this), pDstBuffer, DstOffset, pSrcBuffer, SrcOffset, NumBytes); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(17)] + public void CopyTextureRegion(TextureCopyLocation* pDst, uint DstX, uint DstY, uint DstZ, TextureCopyLocation* pSrc, Box* pSrcBox) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[17]))((ID3D12GraphicsCommandList3*)Unsafe.AsPointer(ref this), pDst, DstX, DstY, DstZ, pSrc, pSrcBox); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[17]))((ID3D12GraphicsCommandList3*)Unsafe.AsPointer(ref this), pDst, DstX, DstY, DstZ, pSrc, pSrcBox); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(18)] + public void CopyResource(ID3D12Resource* pDstResource, ID3D12Resource* pSrcResource) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[18]))((ID3D12GraphicsCommandList3*)Unsafe.AsPointer(ref this), pDstResource, pSrcResource); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[18]))((ID3D12GraphicsCommandList3*)Unsafe.AsPointer(ref this), pDstResource, pSrcResource); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(19)] + public void CopyTiles(ID3D12Resource* pTiledResource, TiledResourceCoordinate* pTileRegionStartCoordinate, TileRegionSize* pTileRegionSize, ID3D12Resource* pBuffer, ulong BufferStartOffsetInBytes, TileCopyFlags Flags) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[19]))((ID3D12GraphicsCommandList3*)Unsafe.AsPointer(ref this), pTiledResource, pTileRegionStartCoordinate, pTileRegionSize, pBuffer, BufferStartOffsetInBytes, Flags); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[19]))((ID3D12GraphicsCommandList3*)Unsafe.AsPointer(ref this), pTiledResource, pTileRegionStartCoordinate, pTileRegionSize, pBuffer, BufferStartOffsetInBytes, Flags); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(20)] + public void ResolveSubresource(ID3D12Resource* pDstResource, uint DstSubresource, ID3D12Resource* pSrcResource, uint SrcSubresource, Graphics.Dxgi.Common.Format Format) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[20]))((ID3D12GraphicsCommandList3*)Unsafe.AsPointer(ref this), pDstResource, DstSubresource, pSrcResource, SrcSubresource, Format); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[20]))((ID3D12GraphicsCommandList3*)Unsafe.AsPointer(ref this), pDstResource, DstSubresource, pSrcResource, SrcSubresource, Format); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(21)] + public void IASetPrimitiveTopology(Graphics.Direct3D.PrimitiveTopology PrimitiveTopology) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[21]))((ID3D12GraphicsCommandList3*)Unsafe.AsPointer(ref this), PrimitiveTopology); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[21]))((ID3D12GraphicsCommandList3*)Unsafe.AsPointer(ref this), PrimitiveTopology); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(22)] + public void RSSetViewports(uint NumViewports, Viewport* pViewports) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[22]))((ID3D12GraphicsCommandList3*)Unsafe.AsPointer(ref this), NumViewports, pViewports); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[22]))((ID3D12GraphicsCommandList3*)Unsafe.AsPointer(ref this), NumViewports, pViewports); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(23)] + public void RSSetScissorRects(uint NumRects, RawRect* pRects) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[23]))((ID3D12GraphicsCommandList3*)Unsafe.AsPointer(ref this), NumRects, pRects); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[23]))((ID3D12GraphicsCommandList3*)Unsafe.AsPointer(ref this), NumRects, pRects); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(24)] + public void OMSetBlendFactor(float* BlendFactor) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[24]))((ID3D12GraphicsCommandList3*)Unsafe.AsPointer(ref this), BlendFactor); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[24]))((ID3D12GraphicsCommandList3*)Unsafe.AsPointer(ref this), BlendFactor); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(25)] + public void OMSetStencilRef(uint StencilRef) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[25]))((ID3D12GraphicsCommandList3*)Unsafe.AsPointer(ref this), StencilRef); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[25]))((ID3D12GraphicsCommandList3*)Unsafe.AsPointer(ref this), StencilRef); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(26)] + public void SetPipelineState(ID3D12PipelineState* pPipelineState) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[26]))((ID3D12GraphicsCommandList3*)Unsafe.AsPointer(ref this), pPipelineState); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[26]))((ID3D12GraphicsCommandList3*)Unsafe.AsPointer(ref this), pPipelineState); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(27)] + public void ResourceBarrier(uint NumBarriers, ResourceBarrier* pBarriers) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[27]))((ID3D12GraphicsCommandList3*)Unsafe.AsPointer(ref this), NumBarriers, pBarriers); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[27]))((ID3D12GraphicsCommandList3*)Unsafe.AsPointer(ref this), NumBarriers, pBarriers); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(28)] + public void ExecuteBundle(ID3D12GraphicsCommandList* pCommandList) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[28]))((ID3D12GraphicsCommandList3*)Unsafe.AsPointer(ref this), pCommandList); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[28]))((ID3D12GraphicsCommandList3*)Unsafe.AsPointer(ref this), pCommandList); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(29)] + public void SetDescriptorHeaps(uint NumDescriptorHeaps, ID3D12DescriptorHeap* ppDescriptorHeaps) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[29]))((ID3D12GraphicsCommandList3*)Unsafe.AsPointer(ref this), NumDescriptorHeaps, ppDescriptorHeaps); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[29]))((ID3D12GraphicsCommandList3*)Unsafe.AsPointer(ref this), NumDescriptorHeaps, ppDescriptorHeaps); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(30)] + public void SetComputeRootSignature(ID3D12RootSignature* pRootSignature) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[30]))((ID3D12GraphicsCommandList3*)Unsafe.AsPointer(ref this), pRootSignature); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[30]))((ID3D12GraphicsCommandList3*)Unsafe.AsPointer(ref this), pRootSignature); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(31)] + public void SetGraphicsRootSignature(ID3D12RootSignature* pRootSignature) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[31]))((ID3D12GraphicsCommandList3*)Unsafe.AsPointer(ref this), pRootSignature); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[31]))((ID3D12GraphicsCommandList3*)Unsafe.AsPointer(ref this), pRootSignature); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(32)] + public void SetComputeRootDescriptorTable(uint RootParameterIndex, GpuDescriptorHandle* BaseDescriptor) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[32]))((ID3D12GraphicsCommandList3*)Unsafe.AsPointer(ref this), RootParameterIndex, BaseDescriptor); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[32]))((ID3D12GraphicsCommandList3*)Unsafe.AsPointer(ref this), RootParameterIndex, BaseDescriptor); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(33)] + public void SetGraphicsRootDescriptorTable(uint RootParameterIndex, GpuDescriptorHandle* BaseDescriptor) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[33]))((ID3D12GraphicsCommandList3*)Unsafe.AsPointer(ref this), RootParameterIndex, BaseDescriptor); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[33]))((ID3D12GraphicsCommandList3*)Unsafe.AsPointer(ref this), RootParameterIndex, BaseDescriptor); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(34)] + public void SetComputeRoot32BitConstant(uint RootParameterIndex, uint SrcData, uint DestOffsetIn32BitValues) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[34]))((ID3D12GraphicsCommandList3*)Unsafe.AsPointer(ref this), RootParameterIndex, SrcData, DestOffsetIn32BitValues); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[34]))((ID3D12GraphicsCommandList3*)Unsafe.AsPointer(ref this), RootParameterIndex, SrcData, DestOffsetIn32BitValues); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(35)] + public void SetGraphicsRoot32BitConstant(uint RootParameterIndex, uint SrcData, uint DestOffsetIn32BitValues) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[35]))((ID3D12GraphicsCommandList3*)Unsafe.AsPointer(ref this), RootParameterIndex, SrcData, DestOffsetIn32BitValues); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[35]))((ID3D12GraphicsCommandList3*)Unsafe.AsPointer(ref this), RootParameterIndex, SrcData, DestOffsetIn32BitValues); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(36)] + public void SetComputeRoot32BitConstants(uint RootParameterIndex, uint Num32BitValuesToSet, void* pSrcData, uint DestOffsetIn32BitValues) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[36]))((ID3D12GraphicsCommandList3*)Unsafe.AsPointer(ref this), RootParameterIndex, Num32BitValuesToSet, pSrcData, DestOffsetIn32BitValues); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[36]))((ID3D12GraphicsCommandList3*)Unsafe.AsPointer(ref this), RootParameterIndex, Num32BitValuesToSet, pSrcData, DestOffsetIn32BitValues); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(37)] + public void SetGraphicsRoot32BitConstants(uint RootParameterIndex, uint Num32BitValuesToSet, void* pSrcData, uint DestOffsetIn32BitValues) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[37]))((ID3D12GraphicsCommandList3*)Unsafe.AsPointer(ref this), RootParameterIndex, Num32BitValuesToSet, pSrcData, DestOffsetIn32BitValues); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[37]))((ID3D12GraphicsCommandList3*)Unsafe.AsPointer(ref this), RootParameterIndex, Num32BitValuesToSet, pSrcData, DestOffsetIn32BitValues); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(38)] + public void SetComputeRootConstantBufferView(uint RootParameterIndex, ulong BufferLocation) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[38]))((ID3D12GraphicsCommandList3*)Unsafe.AsPointer(ref this), RootParameterIndex, BufferLocation); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[38]))((ID3D12GraphicsCommandList3*)Unsafe.AsPointer(ref this), RootParameterIndex, BufferLocation); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(39)] + public void SetGraphicsRootConstantBufferView(uint RootParameterIndex, ulong BufferLocation) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[39]))((ID3D12GraphicsCommandList3*)Unsafe.AsPointer(ref this), RootParameterIndex, BufferLocation); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[39]))((ID3D12GraphicsCommandList3*)Unsafe.AsPointer(ref this), RootParameterIndex, BufferLocation); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(40)] + public void SetComputeRootShaderResourceView(uint RootParameterIndex, ulong BufferLocation) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[40]))((ID3D12GraphicsCommandList3*)Unsafe.AsPointer(ref this), RootParameterIndex, BufferLocation); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[40]))((ID3D12GraphicsCommandList3*)Unsafe.AsPointer(ref this), RootParameterIndex, BufferLocation); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(41)] + public void SetGraphicsRootShaderResourceView(uint RootParameterIndex, ulong BufferLocation) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[41]))((ID3D12GraphicsCommandList3*)Unsafe.AsPointer(ref this), RootParameterIndex, BufferLocation); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[41]))((ID3D12GraphicsCommandList3*)Unsafe.AsPointer(ref this), RootParameterIndex, BufferLocation); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(42)] + public void SetComputeRootUnorderedAccessView(uint RootParameterIndex, ulong BufferLocation) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[42]))((ID3D12GraphicsCommandList3*)Unsafe.AsPointer(ref this), RootParameterIndex, BufferLocation); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[42]))((ID3D12GraphicsCommandList3*)Unsafe.AsPointer(ref this), RootParameterIndex, BufferLocation); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(43)] + public void SetGraphicsRootUnorderedAccessView(uint RootParameterIndex, ulong BufferLocation) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[43]))((ID3D12GraphicsCommandList3*)Unsafe.AsPointer(ref this), RootParameterIndex, BufferLocation); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[43]))((ID3D12GraphicsCommandList3*)Unsafe.AsPointer(ref this), RootParameterIndex, BufferLocation); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(44)] + public void IASetIndexBuffer(IndexBufferView* pView) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[44]))((ID3D12GraphicsCommandList3*)Unsafe.AsPointer(ref this), pView); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[44]))((ID3D12GraphicsCommandList3*)Unsafe.AsPointer(ref this), pView); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(45)] + public void IASetVertexBuffers(uint StartSlot, uint NumViews, VertexBufferView* pViews) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[45]))((ID3D12GraphicsCommandList3*)Unsafe.AsPointer(ref this), StartSlot, NumViews, pViews); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[45]))((ID3D12GraphicsCommandList3*)Unsafe.AsPointer(ref this), StartSlot, NumViews, pViews); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(46)] + public void SOSetTargets(uint StartSlot, uint NumViews, StreamOutputBufferView* pViews) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[46]))((ID3D12GraphicsCommandList3*)Unsafe.AsPointer(ref this), StartSlot, NumViews, pViews); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[46]))((ID3D12GraphicsCommandList3*)Unsafe.AsPointer(ref this), StartSlot, NumViews, pViews); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(47)] + public void OMSetRenderTargets(uint NumRenderTargetDescriptors, CpuDescriptorHandle* pRenderTargetDescriptors, Bool32 RTsSingleHandleToDescriptorRange, CpuDescriptorHandle* pDepthStencilDescriptor) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[47]))((ID3D12GraphicsCommandList3*)Unsafe.AsPointer(ref this), NumRenderTargetDescriptors, pRenderTargetDescriptors, RTsSingleHandleToDescriptorRange, pDepthStencilDescriptor); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[47]))((ID3D12GraphicsCommandList3*)Unsafe.AsPointer(ref this), NumRenderTargetDescriptors, pRenderTargetDescriptors, RTsSingleHandleToDescriptorRange, pDepthStencilDescriptor); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(48)] + public void ClearDepthStencilView(CpuDescriptorHandle* DepthStencilView, ClearFlags ClearFlags, float Depth, byte Stencil, uint NumRects, RawRect* pRects) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[48]))((ID3D12GraphicsCommandList3*)Unsafe.AsPointer(ref this), DepthStencilView, ClearFlags, Depth, Stencil, NumRects, pRects); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[48]))((ID3D12GraphicsCommandList3*)Unsafe.AsPointer(ref this), DepthStencilView, ClearFlags, Depth, Stencil, NumRects, pRects); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(49)] + public void ClearRenderTargetView(CpuDescriptorHandle* RenderTargetView, float* ColorRGBA, uint NumRects, RawRect* pRects) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[49]))((ID3D12GraphicsCommandList3*)Unsafe.AsPointer(ref this), RenderTargetView, ColorRGBA, NumRects, pRects); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[49]))((ID3D12GraphicsCommandList3*)Unsafe.AsPointer(ref this), RenderTargetView, ColorRGBA, NumRects, pRects); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(50)] + public void ClearUnorderedAccessViewUint(GpuDescriptorHandle* ViewGPUHandleInCurrentHeap, CpuDescriptorHandle* ViewCPUHandle, ID3D12Resource* pResource, uint* Values, uint NumRects, RawRect* pRects) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[50]))((ID3D12GraphicsCommandList3*)Unsafe.AsPointer(ref this), ViewGPUHandleInCurrentHeap, ViewCPUHandle, pResource, Values, NumRects, pRects); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[50]))((ID3D12GraphicsCommandList3*)Unsafe.AsPointer(ref this), ViewGPUHandleInCurrentHeap, ViewCPUHandle, pResource, Values, NumRects, pRects); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(51)] + public void ClearUnorderedAccessViewFloat(GpuDescriptorHandle* ViewGPUHandleInCurrentHeap, CpuDescriptorHandle* ViewCPUHandle, ID3D12Resource* pResource, float* Values, uint NumRects, RawRect* pRects) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[51]))((ID3D12GraphicsCommandList3*)Unsafe.AsPointer(ref this), ViewGPUHandleInCurrentHeap, ViewCPUHandle, pResource, Values, NumRects, pRects); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[51]))((ID3D12GraphicsCommandList3*)Unsafe.AsPointer(ref this), ViewGPUHandleInCurrentHeap, ViewCPUHandle, pResource, Values, NumRects, pRects); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(52)] + public void DiscardResource(ID3D12Resource* pResource, DiscardRegion* pRegion) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[52]))((ID3D12GraphicsCommandList3*)Unsafe.AsPointer(ref this), pResource, pRegion); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[52]))((ID3D12GraphicsCommandList3*)Unsafe.AsPointer(ref this), pResource, pRegion); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(53)] + public void BeginQuery(ID3D12QueryHeap* pQueryHeap, QueryType Type, uint Index) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[53]))((ID3D12GraphicsCommandList3*)Unsafe.AsPointer(ref this), pQueryHeap, Type, Index); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[53]))((ID3D12GraphicsCommandList3*)Unsafe.AsPointer(ref this), pQueryHeap, Type, Index); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(54)] + public void EndQuery(ID3D12QueryHeap* pQueryHeap, QueryType Type, uint Index) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[54]))((ID3D12GraphicsCommandList3*)Unsafe.AsPointer(ref this), pQueryHeap, Type, Index); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[54]))((ID3D12GraphicsCommandList3*)Unsafe.AsPointer(ref this), pQueryHeap, Type, Index); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(55)] + public void ResolveQueryData(ID3D12QueryHeap* pQueryHeap, QueryType Type, uint StartIndex, uint NumQueries, ID3D12Resource* pDestinationBuffer, ulong AlignedDestinationBufferOffset) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[55]))((ID3D12GraphicsCommandList3*)Unsafe.AsPointer(ref this), pQueryHeap, Type, StartIndex, NumQueries, pDestinationBuffer, AlignedDestinationBufferOffset); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[55]))((ID3D12GraphicsCommandList3*)Unsafe.AsPointer(ref this), pQueryHeap, Type, StartIndex, NumQueries, pDestinationBuffer, AlignedDestinationBufferOffset); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(56)] + public void SetPredication(ID3D12Resource* pBuffer, ulong AlignedBufferOffset, PredicationOp Operation) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[56]))((ID3D12GraphicsCommandList3*)Unsafe.AsPointer(ref this), pBuffer, AlignedBufferOffset, Operation); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[56]))((ID3D12GraphicsCommandList3*)Unsafe.AsPointer(ref this), pBuffer, AlignedBufferOffset, Operation); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(57)] + public void SetMarker(uint Metadata, void* pData, uint Size) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[57]))((ID3D12GraphicsCommandList3*)Unsafe.AsPointer(ref this), Metadata, pData, Size); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[57]))((ID3D12GraphicsCommandList3*)Unsafe.AsPointer(ref this), Metadata, pData, Size); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(58)] + public void BeginEvent(uint Metadata, void* pData, uint Size) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[58]))((ID3D12GraphicsCommandList3*)Unsafe.AsPointer(ref this), Metadata, pData, Size); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[58]))((ID3D12GraphicsCommandList3*)Unsafe.AsPointer(ref this), Metadata, pData, Size); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(59)] + public void EndEvent() + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[59]))((ID3D12GraphicsCommandList3*)Unsafe.AsPointer(ref this)); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[59]))((ID3D12GraphicsCommandList3*)Unsafe.AsPointer(ref this)); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(60)] + public void ExecuteIndirect(ID3D12CommandSignature* pCommandSignature, uint MaxCommandCount, ID3D12Resource* pArgumentBuffer, ulong ArgumentBufferOffset, ID3D12Resource* pCountBuffer, ulong CountBufferOffset) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[60]))((ID3D12GraphicsCommandList3*)Unsafe.AsPointer(ref this), pCommandSignature, MaxCommandCount, pArgumentBuffer, ArgumentBufferOffset, pCountBuffer, CountBufferOffset); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[60]))((ID3D12GraphicsCommandList3*)Unsafe.AsPointer(ref this), pCommandSignature, MaxCommandCount, pArgumentBuffer, ArgumentBufferOffset, pCountBuffer, CountBufferOffset); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(61)] + public new Graphics.Direct3D12.CommandListType GetType() + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[61]))((ID3D12GraphicsCommandList3*)Unsafe.AsPointer(ref this)); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[61]))((ID3D12GraphicsCommandList3*)Unsafe.AsPointer(ref this)); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(62)] + public HResult GetDevice(Guid* riid, void** ppvDevice) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[62]))((ID3D12GraphicsCommandList3*)Unsafe.AsPointer(ref this), riid, ppvDevice); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[62]))((ID3D12GraphicsCommandList3*)Unsafe.AsPointer(ref this), riid, ppvDevice); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(63)] + public HResult GetPrivateData(Guid* guid, uint* pDataSize, void* pData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[63]))((ID3D12GraphicsCommandList3*)Unsafe.AsPointer(ref this), guid, pDataSize, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[63]))((ID3D12GraphicsCommandList3*)Unsafe.AsPointer(ref this), guid, pDataSize, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(64)] + public HResult SetPrivateData(Guid* guid, uint DataSize, void* pData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[64]))((ID3D12GraphicsCommandList3*)Unsafe.AsPointer(ref this), guid, DataSize, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[64]))((ID3D12GraphicsCommandList3*)Unsafe.AsPointer(ref this), guid, DataSize, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(65)] + public HResult SetPrivateDataInterface(Guid* guid, IUnknown* pData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[65]))((ID3D12GraphicsCommandList3*)Unsafe.AsPointer(ref this), guid, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[65]))((ID3D12GraphicsCommandList3*)Unsafe.AsPointer(ref this), guid, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(66)] + public HResult SetName(char** Name) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[66]))((ID3D12GraphicsCommandList3*)Unsafe.AsPointer(ref this), Name); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[66]))((ID3D12GraphicsCommandList3*)Unsafe.AsPointer(ref this), Name); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(67)] + public void SetProtectedResourceSession(ID3D12ProtectedResourceSession* pProtectedResourceSession) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[67]))((ID3D12GraphicsCommandList3*)Unsafe.AsPointer(ref this), pProtectedResourceSession); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[67]))((ID3D12GraphicsCommandList3*)Unsafe.AsPointer(ref this), pProtectedResourceSession); +#endif + } + + public interface Interface : ID3D12GraphicsCommandList2.Interface + { + } +} + +/// +/// ID3D12MetaCommand +[Guid("dbb84c27-36ce-4fc9-b801-f048c46ac570")] +[NativeTypeName("struct ID3D12MetaCommand : ID3D12Pageable")] +[NativeInheritance("ID3D12Pageable")] +public unsafe partial struct ID3D12MetaCommand : ID3D12MetaCommand.Interface +{ + public static ref readonly Guid IID_ID3D12MetaCommand + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x27, 0x4C, 0xB8, 0xDB, + 0xCE, 0x36, + 0xC9, 0x4F, + 0xB8, + 0x01, + 0xF0, + 0x48, + 0xC4, + 0x6A, + 0xC5, + 0x70 + }; + + 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_ID3D12MetaCommand)); + + 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 GetDevice(Guid* riid, void** ppvDevice) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[3]))((ID3D12MetaCommand*)Unsafe.AsPointer(ref this), riid, ppvDevice); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((ID3D12MetaCommand*)Unsafe.AsPointer(ref this), riid, ppvDevice); +#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]))((ID3D12MetaCommand*)Unsafe.AsPointer(ref this), guid, pDataSize, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((ID3D12MetaCommand*)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]))((ID3D12MetaCommand*)Unsafe.AsPointer(ref this), guid, DataSize, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((ID3D12MetaCommand*)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]))((ID3D12MetaCommand*)Unsafe.AsPointer(ref this), guid, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((ID3D12MetaCommand*)Unsafe.AsPointer(ref this), guid, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(7)] + public HResult SetName(char** Name) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[7]))((ID3D12MetaCommand*)Unsafe.AsPointer(ref this), Name); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((ID3D12MetaCommand*)Unsafe.AsPointer(ref this), Name); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(8)] + public ulong GetRequiredParameterResourceSize(MetaCommandParameterStage Stage, uint ParameterIndex) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[8]))((ID3D12MetaCommand*)Unsafe.AsPointer(ref this), Stage, ParameterIndex); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[8]))((ID3D12MetaCommand*)Unsafe.AsPointer(ref this), Stage, ParameterIndex); +#endif + } + + public interface Interface : ID3D12Pageable.Interface + { + } +} + +/// +/// ID3D12GraphicsCommandList4 +[Guid("8754318e-d3a9-4541-98cf-645b50dc4874")] +[NativeTypeName("struct ID3D12GraphicsCommandList4 : ID3D12GraphicsCommandList3")] +[NativeInheritance("ID3D12GraphicsCommandList3")] +public unsafe partial struct ID3D12GraphicsCommandList4 : ID3D12GraphicsCommandList4.Interface +{ + public static ref readonly Guid IID_ID3D12GraphicsCommandList4 + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x8E, 0x31, 0x54, 0x87, + 0xA9, 0xD3, + 0x41, 0x45, + 0x98, + 0xCF, + 0x64, + 0x5B, + 0x50, + 0xDC, + 0x48, + 0x74 + }; + + 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_ID3D12GraphicsCommandList4)); + + 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 SetProtectedResourceSession(ID3D12ProtectedResourceSession* pProtectedResourceSession) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[3]))((ID3D12GraphicsCommandList4*)Unsafe.AsPointer(ref this), pProtectedResourceSession); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((ID3D12GraphicsCommandList4*)Unsafe.AsPointer(ref this), pProtectedResourceSession); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public void WriteBufferImmediate(uint Count, WritebufferimmediateParameter* pParams, WritebufferimmediateMode* pModes) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[4]))((ID3D12GraphicsCommandList4*)Unsafe.AsPointer(ref this), Count, pParams, pModes); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((ID3D12GraphicsCommandList4*)Unsafe.AsPointer(ref this), Count, pParams, pModes); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(5)] + public void AtomicCopyBufferUINT(ID3D12Resource* pDstBuffer, ulong DstOffset, ID3D12Resource* pSrcBuffer, ulong SrcOffset, uint Dependencies, ID3D12Resource* ppDependentResources, SubresourceRangeUint64* pDependentSubresourceRanges) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[5]))((ID3D12GraphicsCommandList4*)Unsafe.AsPointer(ref this), pDstBuffer, DstOffset, pSrcBuffer, SrcOffset, Dependencies, ppDependentResources, pDependentSubresourceRanges); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((ID3D12GraphicsCommandList4*)Unsafe.AsPointer(ref this), pDstBuffer, DstOffset, pSrcBuffer, SrcOffset, Dependencies, ppDependentResources, pDependentSubresourceRanges); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(6)] + public void AtomicCopyBufferUINT64(ID3D12Resource* pDstBuffer, ulong DstOffset, ID3D12Resource* pSrcBuffer, ulong SrcOffset, uint Dependencies, ID3D12Resource* ppDependentResources, SubresourceRangeUint64* pDependentSubresourceRanges) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[6]))((ID3D12GraphicsCommandList4*)Unsafe.AsPointer(ref this), pDstBuffer, DstOffset, pSrcBuffer, SrcOffset, Dependencies, ppDependentResources, pDependentSubresourceRanges); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((ID3D12GraphicsCommandList4*)Unsafe.AsPointer(ref this), pDstBuffer, DstOffset, pSrcBuffer, SrcOffset, Dependencies, ppDependentResources, pDependentSubresourceRanges); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(7)] + public void OMSetDepthBounds(float Min, float Max) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[7]))((ID3D12GraphicsCommandList4*)Unsafe.AsPointer(ref this), Min, Max); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((ID3D12GraphicsCommandList4*)Unsafe.AsPointer(ref this), Min, Max); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(8)] + public void SetSamplePositions(uint NumSamplesPerPixel, uint NumPixels, SamplePosition* pSamplePositions) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[8]))((ID3D12GraphicsCommandList4*)Unsafe.AsPointer(ref this), NumSamplesPerPixel, NumPixels, pSamplePositions); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[8]))((ID3D12GraphicsCommandList4*)Unsafe.AsPointer(ref this), NumSamplesPerPixel, NumPixels, pSamplePositions); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(9)] + public void ResolveSubresourceRegion(ID3D12Resource* pDstResource, uint DstSubresource, uint DstX, uint DstY, ID3D12Resource* pSrcResource, uint SrcSubresource, RawRect* pSrcRect, Graphics.Dxgi.Common.Format Format, ResolveMode ResolveMode) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[9]))((ID3D12GraphicsCommandList4*)Unsafe.AsPointer(ref this), pDstResource, DstSubresource, DstX, DstY, pSrcResource, SrcSubresource, pSrcRect, Format, ResolveMode); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[9]))((ID3D12GraphicsCommandList4*)Unsafe.AsPointer(ref this), pDstResource, DstSubresource, DstX, DstY, pSrcResource, SrcSubresource, pSrcRect, Format, ResolveMode); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(10)] + public void SetViewInstanceMask(uint Mask) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[10]))((ID3D12GraphicsCommandList4*)Unsafe.AsPointer(ref this), Mask); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[10]))((ID3D12GraphicsCommandList4*)Unsafe.AsPointer(ref this), Mask); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(11)] + public HResult Close() + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[11]))((ID3D12GraphicsCommandList4*)Unsafe.AsPointer(ref this)); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[11]))((ID3D12GraphicsCommandList4*)Unsafe.AsPointer(ref this)); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(12)] + public HResult Reset(ID3D12CommandAllocator* pAllocator, ID3D12PipelineState* pInitialState) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[12]))((ID3D12GraphicsCommandList4*)Unsafe.AsPointer(ref this), pAllocator, pInitialState); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[12]))((ID3D12GraphicsCommandList4*)Unsafe.AsPointer(ref this), pAllocator, pInitialState); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(13)] + public void ClearState(ID3D12PipelineState* pPipelineState) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[13]))((ID3D12GraphicsCommandList4*)Unsafe.AsPointer(ref this), pPipelineState); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[13]))((ID3D12GraphicsCommandList4*)Unsafe.AsPointer(ref this), pPipelineState); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(14)] + public void DrawInstanced(uint VertexCountPerInstance, uint InstanceCount, uint StartVertexLocation, uint StartInstanceLocation) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[14]))((ID3D12GraphicsCommandList4*)Unsafe.AsPointer(ref this), VertexCountPerInstance, InstanceCount, StartVertexLocation, StartInstanceLocation); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[14]))((ID3D12GraphicsCommandList4*)Unsafe.AsPointer(ref this), VertexCountPerInstance, InstanceCount, StartVertexLocation, StartInstanceLocation); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(15)] + public void DrawIndexedInstanced(uint IndexCountPerInstance, uint InstanceCount, uint StartIndexLocation, int BaseVertexLocation, uint StartInstanceLocation) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[15]))((ID3D12GraphicsCommandList4*)Unsafe.AsPointer(ref this), IndexCountPerInstance, InstanceCount, StartIndexLocation, BaseVertexLocation, StartInstanceLocation); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[15]))((ID3D12GraphicsCommandList4*)Unsafe.AsPointer(ref this), IndexCountPerInstance, InstanceCount, StartIndexLocation, BaseVertexLocation, StartInstanceLocation); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(16)] + public void Dispatch(uint ThreadGroupCountX, uint ThreadGroupCountY, uint ThreadGroupCountZ) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[16]))((ID3D12GraphicsCommandList4*)Unsafe.AsPointer(ref this), ThreadGroupCountX, ThreadGroupCountY, ThreadGroupCountZ); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[16]))((ID3D12GraphicsCommandList4*)Unsafe.AsPointer(ref this), ThreadGroupCountX, ThreadGroupCountY, ThreadGroupCountZ); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(17)] + public void CopyBufferRegion(ID3D12Resource* pDstBuffer, ulong DstOffset, ID3D12Resource* pSrcBuffer, ulong SrcOffset, ulong NumBytes) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[17]))((ID3D12GraphicsCommandList4*)Unsafe.AsPointer(ref this), pDstBuffer, DstOffset, pSrcBuffer, SrcOffset, NumBytes); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[17]))((ID3D12GraphicsCommandList4*)Unsafe.AsPointer(ref this), pDstBuffer, DstOffset, pSrcBuffer, SrcOffset, NumBytes); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(18)] + public void CopyTextureRegion(TextureCopyLocation* pDst, uint DstX, uint DstY, uint DstZ, TextureCopyLocation* pSrc, Box* pSrcBox) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[18]))((ID3D12GraphicsCommandList4*)Unsafe.AsPointer(ref this), pDst, DstX, DstY, DstZ, pSrc, pSrcBox); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[18]))((ID3D12GraphicsCommandList4*)Unsafe.AsPointer(ref this), pDst, DstX, DstY, DstZ, pSrc, pSrcBox); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(19)] + public void CopyResource(ID3D12Resource* pDstResource, ID3D12Resource* pSrcResource) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[19]))((ID3D12GraphicsCommandList4*)Unsafe.AsPointer(ref this), pDstResource, pSrcResource); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[19]))((ID3D12GraphicsCommandList4*)Unsafe.AsPointer(ref this), pDstResource, pSrcResource); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(20)] + public void CopyTiles(ID3D12Resource* pTiledResource, TiledResourceCoordinate* pTileRegionStartCoordinate, TileRegionSize* pTileRegionSize, ID3D12Resource* pBuffer, ulong BufferStartOffsetInBytes, TileCopyFlags Flags) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[20]))((ID3D12GraphicsCommandList4*)Unsafe.AsPointer(ref this), pTiledResource, pTileRegionStartCoordinate, pTileRegionSize, pBuffer, BufferStartOffsetInBytes, Flags); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[20]))((ID3D12GraphicsCommandList4*)Unsafe.AsPointer(ref this), pTiledResource, pTileRegionStartCoordinate, pTileRegionSize, pBuffer, BufferStartOffsetInBytes, Flags); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(21)] + public void ResolveSubresource(ID3D12Resource* pDstResource, uint DstSubresource, ID3D12Resource* pSrcResource, uint SrcSubresource, Graphics.Dxgi.Common.Format Format) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[21]))((ID3D12GraphicsCommandList4*)Unsafe.AsPointer(ref this), pDstResource, DstSubresource, pSrcResource, SrcSubresource, Format); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[21]))((ID3D12GraphicsCommandList4*)Unsafe.AsPointer(ref this), pDstResource, DstSubresource, pSrcResource, SrcSubresource, Format); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(22)] + public void IASetPrimitiveTopology(Graphics.Direct3D.PrimitiveTopology PrimitiveTopology) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[22]))((ID3D12GraphicsCommandList4*)Unsafe.AsPointer(ref this), PrimitiveTopology); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[22]))((ID3D12GraphicsCommandList4*)Unsafe.AsPointer(ref this), PrimitiveTopology); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(23)] + public void RSSetViewports(uint NumViewports, Viewport* pViewports) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[23]))((ID3D12GraphicsCommandList4*)Unsafe.AsPointer(ref this), NumViewports, pViewports); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[23]))((ID3D12GraphicsCommandList4*)Unsafe.AsPointer(ref this), NumViewports, pViewports); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(24)] + public void RSSetScissorRects(uint NumRects, RawRect* pRects) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[24]))((ID3D12GraphicsCommandList4*)Unsafe.AsPointer(ref this), NumRects, pRects); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[24]))((ID3D12GraphicsCommandList4*)Unsafe.AsPointer(ref this), NumRects, pRects); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(25)] + public void OMSetBlendFactor(float* BlendFactor) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[25]))((ID3D12GraphicsCommandList4*)Unsafe.AsPointer(ref this), BlendFactor); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[25]))((ID3D12GraphicsCommandList4*)Unsafe.AsPointer(ref this), BlendFactor); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(26)] + public void OMSetStencilRef(uint StencilRef) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[26]))((ID3D12GraphicsCommandList4*)Unsafe.AsPointer(ref this), StencilRef); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[26]))((ID3D12GraphicsCommandList4*)Unsafe.AsPointer(ref this), StencilRef); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(27)] + public void SetPipelineState(ID3D12PipelineState* pPipelineState) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[27]))((ID3D12GraphicsCommandList4*)Unsafe.AsPointer(ref this), pPipelineState); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[27]))((ID3D12GraphicsCommandList4*)Unsafe.AsPointer(ref this), pPipelineState); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(28)] + public void ResourceBarrier(uint NumBarriers, ResourceBarrier* pBarriers) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[28]))((ID3D12GraphicsCommandList4*)Unsafe.AsPointer(ref this), NumBarriers, pBarriers); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[28]))((ID3D12GraphicsCommandList4*)Unsafe.AsPointer(ref this), NumBarriers, pBarriers); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(29)] + public void ExecuteBundle(ID3D12GraphicsCommandList* pCommandList) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[29]))((ID3D12GraphicsCommandList4*)Unsafe.AsPointer(ref this), pCommandList); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[29]))((ID3D12GraphicsCommandList4*)Unsafe.AsPointer(ref this), pCommandList); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(30)] + public void SetDescriptorHeaps(uint NumDescriptorHeaps, ID3D12DescriptorHeap* ppDescriptorHeaps) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[30]))((ID3D12GraphicsCommandList4*)Unsafe.AsPointer(ref this), NumDescriptorHeaps, ppDescriptorHeaps); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[30]))((ID3D12GraphicsCommandList4*)Unsafe.AsPointer(ref this), NumDescriptorHeaps, ppDescriptorHeaps); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(31)] + public void SetComputeRootSignature(ID3D12RootSignature* pRootSignature) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[31]))((ID3D12GraphicsCommandList4*)Unsafe.AsPointer(ref this), pRootSignature); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[31]))((ID3D12GraphicsCommandList4*)Unsafe.AsPointer(ref this), pRootSignature); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(32)] + public void SetGraphicsRootSignature(ID3D12RootSignature* pRootSignature) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[32]))((ID3D12GraphicsCommandList4*)Unsafe.AsPointer(ref this), pRootSignature); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[32]))((ID3D12GraphicsCommandList4*)Unsafe.AsPointer(ref this), pRootSignature); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(33)] + public void SetComputeRootDescriptorTable(uint RootParameterIndex, GpuDescriptorHandle* BaseDescriptor) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[33]))((ID3D12GraphicsCommandList4*)Unsafe.AsPointer(ref this), RootParameterIndex, BaseDescriptor); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[33]))((ID3D12GraphicsCommandList4*)Unsafe.AsPointer(ref this), RootParameterIndex, BaseDescriptor); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(34)] + public void SetGraphicsRootDescriptorTable(uint RootParameterIndex, GpuDescriptorHandle* BaseDescriptor) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[34]))((ID3D12GraphicsCommandList4*)Unsafe.AsPointer(ref this), RootParameterIndex, BaseDescriptor); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[34]))((ID3D12GraphicsCommandList4*)Unsafe.AsPointer(ref this), RootParameterIndex, BaseDescriptor); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(35)] + public void SetComputeRoot32BitConstant(uint RootParameterIndex, uint SrcData, uint DestOffsetIn32BitValues) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[35]))((ID3D12GraphicsCommandList4*)Unsafe.AsPointer(ref this), RootParameterIndex, SrcData, DestOffsetIn32BitValues); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[35]))((ID3D12GraphicsCommandList4*)Unsafe.AsPointer(ref this), RootParameterIndex, SrcData, DestOffsetIn32BitValues); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(36)] + public void SetGraphicsRoot32BitConstant(uint RootParameterIndex, uint SrcData, uint DestOffsetIn32BitValues) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[36]))((ID3D12GraphicsCommandList4*)Unsafe.AsPointer(ref this), RootParameterIndex, SrcData, DestOffsetIn32BitValues); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[36]))((ID3D12GraphicsCommandList4*)Unsafe.AsPointer(ref this), RootParameterIndex, SrcData, DestOffsetIn32BitValues); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(37)] + public void SetComputeRoot32BitConstants(uint RootParameterIndex, uint Num32BitValuesToSet, void* pSrcData, uint DestOffsetIn32BitValues) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[37]))((ID3D12GraphicsCommandList4*)Unsafe.AsPointer(ref this), RootParameterIndex, Num32BitValuesToSet, pSrcData, DestOffsetIn32BitValues); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[37]))((ID3D12GraphicsCommandList4*)Unsafe.AsPointer(ref this), RootParameterIndex, Num32BitValuesToSet, pSrcData, DestOffsetIn32BitValues); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(38)] + public void SetGraphicsRoot32BitConstants(uint RootParameterIndex, uint Num32BitValuesToSet, void* pSrcData, uint DestOffsetIn32BitValues) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[38]))((ID3D12GraphicsCommandList4*)Unsafe.AsPointer(ref this), RootParameterIndex, Num32BitValuesToSet, pSrcData, DestOffsetIn32BitValues); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[38]))((ID3D12GraphicsCommandList4*)Unsafe.AsPointer(ref this), RootParameterIndex, Num32BitValuesToSet, pSrcData, DestOffsetIn32BitValues); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(39)] + public void SetComputeRootConstantBufferView(uint RootParameterIndex, ulong BufferLocation) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[39]))((ID3D12GraphicsCommandList4*)Unsafe.AsPointer(ref this), RootParameterIndex, BufferLocation); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[39]))((ID3D12GraphicsCommandList4*)Unsafe.AsPointer(ref this), RootParameterIndex, BufferLocation); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(40)] + public void SetGraphicsRootConstantBufferView(uint RootParameterIndex, ulong BufferLocation) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[40]))((ID3D12GraphicsCommandList4*)Unsafe.AsPointer(ref this), RootParameterIndex, BufferLocation); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[40]))((ID3D12GraphicsCommandList4*)Unsafe.AsPointer(ref this), RootParameterIndex, BufferLocation); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(41)] + public void SetComputeRootShaderResourceView(uint RootParameterIndex, ulong BufferLocation) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[41]))((ID3D12GraphicsCommandList4*)Unsafe.AsPointer(ref this), RootParameterIndex, BufferLocation); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[41]))((ID3D12GraphicsCommandList4*)Unsafe.AsPointer(ref this), RootParameterIndex, BufferLocation); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(42)] + public void SetGraphicsRootShaderResourceView(uint RootParameterIndex, ulong BufferLocation) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[42]))((ID3D12GraphicsCommandList4*)Unsafe.AsPointer(ref this), RootParameterIndex, BufferLocation); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[42]))((ID3D12GraphicsCommandList4*)Unsafe.AsPointer(ref this), RootParameterIndex, BufferLocation); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(43)] + public void SetComputeRootUnorderedAccessView(uint RootParameterIndex, ulong BufferLocation) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[43]))((ID3D12GraphicsCommandList4*)Unsafe.AsPointer(ref this), RootParameterIndex, BufferLocation); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[43]))((ID3D12GraphicsCommandList4*)Unsafe.AsPointer(ref this), RootParameterIndex, BufferLocation); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(44)] + public void SetGraphicsRootUnorderedAccessView(uint RootParameterIndex, ulong BufferLocation) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[44]))((ID3D12GraphicsCommandList4*)Unsafe.AsPointer(ref this), RootParameterIndex, BufferLocation); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[44]))((ID3D12GraphicsCommandList4*)Unsafe.AsPointer(ref this), RootParameterIndex, BufferLocation); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(45)] + public void IASetIndexBuffer(IndexBufferView* pView) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[45]))((ID3D12GraphicsCommandList4*)Unsafe.AsPointer(ref this), pView); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[45]))((ID3D12GraphicsCommandList4*)Unsafe.AsPointer(ref this), pView); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(46)] + public void IASetVertexBuffers(uint StartSlot, uint NumViews, VertexBufferView* pViews) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[46]))((ID3D12GraphicsCommandList4*)Unsafe.AsPointer(ref this), StartSlot, NumViews, pViews); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[46]))((ID3D12GraphicsCommandList4*)Unsafe.AsPointer(ref this), StartSlot, NumViews, pViews); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(47)] + public void SOSetTargets(uint StartSlot, uint NumViews, StreamOutputBufferView* pViews) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[47]))((ID3D12GraphicsCommandList4*)Unsafe.AsPointer(ref this), StartSlot, NumViews, pViews); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[47]))((ID3D12GraphicsCommandList4*)Unsafe.AsPointer(ref this), StartSlot, NumViews, pViews); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(48)] + public void OMSetRenderTargets(uint NumRenderTargetDescriptors, CpuDescriptorHandle* pRenderTargetDescriptors, Bool32 RTsSingleHandleToDescriptorRange, CpuDescriptorHandle* pDepthStencilDescriptor) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[48]))((ID3D12GraphicsCommandList4*)Unsafe.AsPointer(ref this), NumRenderTargetDescriptors, pRenderTargetDescriptors, RTsSingleHandleToDescriptorRange, pDepthStencilDescriptor); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[48]))((ID3D12GraphicsCommandList4*)Unsafe.AsPointer(ref this), NumRenderTargetDescriptors, pRenderTargetDescriptors, RTsSingleHandleToDescriptorRange, pDepthStencilDescriptor); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(49)] + public void ClearDepthStencilView(CpuDescriptorHandle* DepthStencilView, ClearFlags ClearFlags, float Depth, byte Stencil, uint NumRects, RawRect* pRects) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[49]))((ID3D12GraphicsCommandList4*)Unsafe.AsPointer(ref this), DepthStencilView, ClearFlags, Depth, Stencil, NumRects, pRects); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[49]))((ID3D12GraphicsCommandList4*)Unsafe.AsPointer(ref this), DepthStencilView, ClearFlags, Depth, Stencil, NumRects, pRects); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(50)] + public void ClearRenderTargetView(CpuDescriptorHandle* RenderTargetView, float* ColorRGBA, uint NumRects, RawRect* pRects) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[50]))((ID3D12GraphicsCommandList4*)Unsafe.AsPointer(ref this), RenderTargetView, ColorRGBA, NumRects, pRects); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[50]))((ID3D12GraphicsCommandList4*)Unsafe.AsPointer(ref this), RenderTargetView, ColorRGBA, NumRects, pRects); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(51)] + public void ClearUnorderedAccessViewUint(GpuDescriptorHandle* ViewGPUHandleInCurrentHeap, CpuDescriptorHandle* ViewCPUHandle, ID3D12Resource* pResource, uint* Values, uint NumRects, RawRect* pRects) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[51]))((ID3D12GraphicsCommandList4*)Unsafe.AsPointer(ref this), ViewGPUHandleInCurrentHeap, ViewCPUHandle, pResource, Values, NumRects, pRects); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[51]))((ID3D12GraphicsCommandList4*)Unsafe.AsPointer(ref this), ViewGPUHandleInCurrentHeap, ViewCPUHandle, pResource, Values, NumRects, pRects); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(52)] + public void ClearUnorderedAccessViewFloat(GpuDescriptorHandle* ViewGPUHandleInCurrentHeap, CpuDescriptorHandle* ViewCPUHandle, ID3D12Resource* pResource, float* Values, uint NumRects, RawRect* pRects) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[52]))((ID3D12GraphicsCommandList4*)Unsafe.AsPointer(ref this), ViewGPUHandleInCurrentHeap, ViewCPUHandle, pResource, Values, NumRects, pRects); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[52]))((ID3D12GraphicsCommandList4*)Unsafe.AsPointer(ref this), ViewGPUHandleInCurrentHeap, ViewCPUHandle, pResource, Values, NumRects, pRects); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(53)] + public void DiscardResource(ID3D12Resource* pResource, DiscardRegion* pRegion) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[53]))((ID3D12GraphicsCommandList4*)Unsafe.AsPointer(ref this), pResource, pRegion); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[53]))((ID3D12GraphicsCommandList4*)Unsafe.AsPointer(ref this), pResource, pRegion); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(54)] + public void BeginQuery(ID3D12QueryHeap* pQueryHeap, QueryType Type, uint Index) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[54]))((ID3D12GraphicsCommandList4*)Unsafe.AsPointer(ref this), pQueryHeap, Type, Index); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[54]))((ID3D12GraphicsCommandList4*)Unsafe.AsPointer(ref this), pQueryHeap, Type, Index); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(55)] + public void EndQuery(ID3D12QueryHeap* pQueryHeap, QueryType Type, uint Index) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[55]))((ID3D12GraphicsCommandList4*)Unsafe.AsPointer(ref this), pQueryHeap, Type, Index); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[55]))((ID3D12GraphicsCommandList4*)Unsafe.AsPointer(ref this), pQueryHeap, Type, Index); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(56)] + public void ResolveQueryData(ID3D12QueryHeap* pQueryHeap, QueryType Type, uint StartIndex, uint NumQueries, ID3D12Resource* pDestinationBuffer, ulong AlignedDestinationBufferOffset) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[56]))((ID3D12GraphicsCommandList4*)Unsafe.AsPointer(ref this), pQueryHeap, Type, StartIndex, NumQueries, pDestinationBuffer, AlignedDestinationBufferOffset); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[56]))((ID3D12GraphicsCommandList4*)Unsafe.AsPointer(ref this), pQueryHeap, Type, StartIndex, NumQueries, pDestinationBuffer, AlignedDestinationBufferOffset); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(57)] + public void SetPredication(ID3D12Resource* pBuffer, ulong AlignedBufferOffset, PredicationOp Operation) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[57]))((ID3D12GraphicsCommandList4*)Unsafe.AsPointer(ref this), pBuffer, AlignedBufferOffset, Operation); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[57]))((ID3D12GraphicsCommandList4*)Unsafe.AsPointer(ref this), pBuffer, AlignedBufferOffset, Operation); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(58)] + public void SetMarker(uint Metadata, void* pData, uint Size) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[58]))((ID3D12GraphicsCommandList4*)Unsafe.AsPointer(ref this), Metadata, pData, Size); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[58]))((ID3D12GraphicsCommandList4*)Unsafe.AsPointer(ref this), Metadata, pData, Size); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(59)] + public void BeginEvent(uint Metadata, void* pData, uint Size) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[59]))((ID3D12GraphicsCommandList4*)Unsafe.AsPointer(ref this), Metadata, pData, Size); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[59]))((ID3D12GraphicsCommandList4*)Unsafe.AsPointer(ref this), Metadata, pData, Size); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(60)] + public void EndEvent() + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[60]))((ID3D12GraphicsCommandList4*)Unsafe.AsPointer(ref this)); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[60]))((ID3D12GraphicsCommandList4*)Unsafe.AsPointer(ref this)); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(61)] + public void ExecuteIndirect(ID3D12CommandSignature* pCommandSignature, uint MaxCommandCount, ID3D12Resource* pArgumentBuffer, ulong ArgumentBufferOffset, ID3D12Resource* pCountBuffer, ulong CountBufferOffset) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[61]))((ID3D12GraphicsCommandList4*)Unsafe.AsPointer(ref this), pCommandSignature, MaxCommandCount, pArgumentBuffer, ArgumentBufferOffset, pCountBuffer, CountBufferOffset); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[61]))((ID3D12GraphicsCommandList4*)Unsafe.AsPointer(ref this), pCommandSignature, MaxCommandCount, pArgumentBuffer, ArgumentBufferOffset, pCountBuffer, CountBufferOffset); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(62)] + public new Graphics.Direct3D12.CommandListType GetType() + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[62]))((ID3D12GraphicsCommandList4*)Unsafe.AsPointer(ref this)); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[62]))((ID3D12GraphicsCommandList4*)Unsafe.AsPointer(ref this)); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(63)] + public HResult GetDevice(Guid* riid, void** ppvDevice) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[63]))((ID3D12GraphicsCommandList4*)Unsafe.AsPointer(ref this), riid, ppvDevice); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[63]))((ID3D12GraphicsCommandList4*)Unsafe.AsPointer(ref this), riid, ppvDevice); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(64)] + public HResult GetPrivateData(Guid* guid, uint* pDataSize, void* pData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[64]))((ID3D12GraphicsCommandList4*)Unsafe.AsPointer(ref this), guid, pDataSize, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[64]))((ID3D12GraphicsCommandList4*)Unsafe.AsPointer(ref this), guid, pDataSize, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(65)] + public HResult SetPrivateData(Guid* guid, uint DataSize, void* pData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[65]))((ID3D12GraphicsCommandList4*)Unsafe.AsPointer(ref this), guid, DataSize, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[65]))((ID3D12GraphicsCommandList4*)Unsafe.AsPointer(ref this), guid, DataSize, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(66)] + public HResult SetPrivateDataInterface(Guid* guid, IUnknown* pData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[66]))((ID3D12GraphicsCommandList4*)Unsafe.AsPointer(ref this), guid, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[66]))((ID3D12GraphicsCommandList4*)Unsafe.AsPointer(ref this), guid, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(67)] + public HResult SetName(char** Name) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[67]))((ID3D12GraphicsCommandList4*)Unsafe.AsPointer(ref this), Name); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[67]))((ID3D12GraphicsCommandList4*)Unsafe.AsPointer(ref this), Name); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(68)] + public void BeginRenderPass(uint NumRenderTargets, RenderPassRenderTargetDescription* pRenderTargets, RenderPassDepthStencilDescription* pDepthStencil, RenderPassFlags Flags) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[68]))((ID3D12GraphicsCommandList4*)Unsafe.AsPointer(ref this), NumRenderTargets, pRenderTargets, pDepthStencil, Flags); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[68]))((ID3D12GraphicsCommandList4*)Unsafe.AsPointer(ref this), NumRenderTargets, pRenderTargets, pDepthStencil, Flags); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(69)] + public void EndRenderPass() + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[69]))((ID3D12GraphicsCommandList4*)Unsafe.AsPointer(ref this)); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[69]))((ID3D12GraphicsCommandList4*)Unsafe.AsPointer(ref this)); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(70)] + public void InitializeMetaCommand(ID3D12MetaCommand* pMetaCommand, void* pInitializationParametersData, nuint InitializationParametersDataSizeInBytes) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[70]))((ID3D12GraphicsCommandList4*)Unsafe.AsPointer(ref this), pMetaCommand, pInitializationParametersData, InitializationParametersDataSizeInBytes); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[70]))((ID3D12GraphicsCommandList4*)Unsafe.AsPointer(ref this), pMetaCommand, pInitializationParametersData, InitializationParametersDataSizeInBytes); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(71)] + public void ExecuteMetaCommand(ID3D12MetaCommand* pMetaCommand, void* pExecutionParametersData, nuint ExecutionParametersDataSizeInBytes) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[71]))((ID3D12GraphicsCommandList4*)Unsafe.AsPointer(ref this), pMetaCommand, pExecutionParametersData, ExecutionParametersDataSizeInBytes); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[71]))((ID3D12GraphicsCommandList4*)Unsafe.AsPointer(ref this), pMetaCommand, pExecutionParametersData, ExecutionParametersDataSizeInBytes); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(72)] + public void BuildRaytracingAccelerationStructure(BuildRaytracingAccelerationStructureDescription* pDesc, uint NumPostbuildInfoDescs, RaytracingAccelerationStructurePostbuildInfoDescription* pPostbuildInfoDescs) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[72]))((ID3D12GraphicsCommandList4*)Unsafe.AsPointer(ref this), pDesc, NumPostbuildInfoDescs, pPostbuildInfoDescs); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[72]))((ID3D12GraphicsCommandList4*)Unsafe.AsPointer(ref this), pDesc, NumPostbuildInfoDescs, pPostbuildInfoDescs); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(73)] + public void EmitRaytracingAccelerationStructurePostbuildInfo(RaytracingAccelerationStructurePostbuildInfoDescription* pDesc, uint NumSourceAccelerationStructures, ulong* pSourceAccelerationStructureData) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[73]))((ID3D12GraphicsCommandList4*)Unsafe.AsPointer(ref this), pDesc, NumSourceAccelerationStructures, pSourceAccelerationStructureData); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[73]))((ID3D12GraphicsCommandList4*)Unsafe.AsPointer(ref this), pDesc, NumSourceAccelerationStructures, pSourceAccelerationStructureData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(74)] + public void CopyRaytracingAccelerationStructure(ulong DestAccelerationStructureData, ulong SourceAccelerationStructureData, RaytracingAccelerationStructureCopyMode Mode) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[74]))((ID3D12GraphicsCommandList4*)Unsafe.AsPointer(ref this), DestAccelerationStructureData, SourceAccelerationStructureData, Mode); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[74]))((ID3D12GraphicsCommandList4*)Unsafe.AsPointer(ref this), DestAccelerationStructureData, SourceAccelerationStructureData, Mode); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(75)] + public void SetPipelineState1(ID3D12StateObject* pStateObject) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[75]))((ID3D12GraphicsCommandList4*)Unsafe.AsPointer(ref this), pStateObject); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[75]))((ID3D12GraphicsCommandList4*)Unsafe.AsPointer(ref this), pStateObject); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(76)] + public void DispatchRays(DispatchRaysDescription* pDesc) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[76]))((ID3D12GraphicsCommandList4*)Unsafe.AsPointer(ref this), pDesc); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[76]))((ID3D12GraphicsCommandList4*)Unsafe.AsPointer(ref this), pDesc); +#endif + } + + public interface Interface : ID3D12GraphicsCommandList3.Interface + { + } +} + +/// +/// ID3D12ShaderCacheSession +[Guid("28e2495d-0f64-4ae4-a6ec-129255dc49a8")] +[NativeTypeName("struct ID3D12ShaderCacheSession : ID3D12DeviceChild")] +[NativeInheritance("ID3D12DeviceChild")] +public unsafe partial struct ID3D12ShaderCacheSession : ID3D12ShaderCacheSession.Interface +{ + public static ref readonly Guid IID_ID3D12ShaderCacheSession + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x5D, 0x49, 0xE2, 0x28, + 0x64, 0x0F, + 0xE4, 0x4A, + 0xA6, + 0xEC, + 0x12, + 0x92, + 0x55, + 0xDC, + 0x49, + 0xA8 + }; + + 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_ID3D12ShaderCacheSession)); + + 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 GetDevice(Guid* riid, void** ppvDevice) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[3]))((ID3D12ShaderCacheSession*)Unsafe.AsPointer(ref this), riid, ppvDevice); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((ID3D12ShaderCacheSession*)Unsafe.AsPointer(ref this), riid, ppvDevice); +#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]))((ID3D12ShaderCacheSession*)Unsafe.AsPointer(ref this), guid, pDataSize, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((ID3D12ShaderCacheSession*)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]))((ID3D12ShaderCacheSession*)Unsafe.AsPointer(ref this), guid, DataSize, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((ID3D12ShaderCacheSession*)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]))((ID3D12ShaderCacheSession*)Unsafe.AsPointer(ref this), guid, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((ID3D12ShaderCacheSession*)Unsafe.AsPointer(ref this), guid, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(7)] + public HResult SetName(char** Name) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[7]))((ID3D12ShaderCacheSession*)Unsafe.AsPointer(ref this), Name); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((ID3D12ShaderCacheSession*)Unsafe.AsPointer(ref this), Name); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(8)] + public HResult FindValue(void* pKey, uint KeySize, void* pValue, uint* pValueSize) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[8]))((ID3D12ShaderCacheSession*)Unsafe.AsPointer(ref this), pKey, KeySize, pValue, pValueSize); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[8]))((ID3D12ShaderCacheSession*)Unsafe.AsPointer(ref this), pKey, KeySize, pValue, pValueSize); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(9)] + public HResult StoreValue(void* pKey, uint KeySize, void* pValue, uint ValueSize) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[9]))((ID3D12ShaderCacheSession*)Unsafe.AsPointer(ref this), pKey, KeySize, pValue, ValueSize); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[9]))((ID3D12ShaderCacheSession*)Unsafe.AsPointer(ref this), pKey, KeySize, pValue, ValueSize); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(10)] + public void SetDeleteOnDestroy() + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[10]))((ID3D12ShaderCacheSession*)Unsafe.AsPointer(ref this)); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[10]))((ID3D12ShaderCacheSession*)Unsafe.AsPointer(ref this)); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(11)] + public Graphics.Direct3D12.ShaderCacheSessionDescription GetDesc() + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[11]))((ID3D12ShaderCacheSession*)Unsafe.AsPointer(ref this)); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[11]))((ID3D12ShaderCacheSession*)Unsafe.AsPointer(ref this)); +#endif + } + + public interface Interface : ID3D12DeviceChild.Interface + { + } +} + +/// +/// ID3D12Device9 +[Guid("4c80e962-f032-4f60-bc9e-ebc2cfa1d83c")] +[NativeTypeName("struct ID3D12Device9 : ID3D12Device8")] +[NativeInheritance("ID3D12Device8")] +public unsafe partial struct ID3D12Device9 : ID3D12Device9.Interface +{ + public static ref readonly Guid IID_ID3D12Device9 + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x62, 0xE9, 0x80, 0x4C, + 0x32, 0xF0, + 0x60, 0x4F, + 0xBC, + 0x9E, + 0xEB, + 0xC2, + 0xCF, + 0xA1, + 0xD8, + 0x3C + }; + + 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_ID3D12Device9)); + + 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 Graphics.Direct3D12.ResourceAllocationInfo GetResourceAllocationInfo2(uint visibleMask, uint numResourceDescs, ResourceDescription1* pResourceDescs, ResourceAllocationInfo1* pResourceAllocationInfo1) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[3]))((ID3D12Device9*)Unsafe.AsPointer(ref this), visibleMask, numResourceDescs, pResourceDescs, pResourceAllocationInfo1); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((ID3D12Device9*)Unsafe.AsPointer(ref this), visibleMask, numResourceDescs, pResourceDescs, pResourceAllocationInfo1); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public HResult CreateCommittedResource2(HeapProperties* pHeapProperties, HeapFlags HeapFlags, ResourceDescription1* pDesc, ResourceStates InitialResourceState, ClearValue* pOptimizedClearValue, ID3D12ProtectedResourceSession* pProtectedSession, Guid* riidResource, void** ppvResource) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[4]))((ID3D12Device9*)Unsafe.AsPointer(ref this), pHeapProperties, HeapFlags, pDesc, InitialResourceState, pOptimizedClearValue, pProtectedSession, riidResource, ppvResource); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((ID3D12Device9*)Unsafe.AsPointer(ref this), pHeapProperties, HeapFlags, pDesc, InitialResourceState, pOptimizedClearValue, pProtectedSession, riidResource, ppvResource); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(5)] + public HResult CreatePlacedResource1(ID3D12Heap* pHeap, ulong HeapOffset, ResourceDescription1* pDesc, ResourceStates InitialState, ClearValue* pOptimizedClearValue, Guid* riid, void** ppvResource) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[5]))((ID3D12Device9*)Unsafe.AsPointer(ref this), pHeap, HeapOffset, pDesc, InitialState, pOptimizedClearValue, riid, ppvResource); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((ID3D12Device9*)Unsafe.AsPointer(ref this), pHeap, HeapOffset, pDesc, InitialState, pOptimizedClearValue, riid, ppvResource); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(6)] + public void CreateSamplerFeedbackUnorderedAccessView(ID3D12Resource* pTargetedResource, ID3D12Resource* pFeedbackResource, CpuDescriptorHandle* DestDescriptor) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[6]))((ID3D12Device9*)Unsafe.AsPointer(ref this), pTargetedResource, pFeedbackResource, DestDescriptor); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((ID3D12Device9*)Unsafe.AsPointer(ref this), pTargetedResource, pFeedbackResource, DestDescriptor); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(7)] + public void GetCopyableFootprints1(ResourceDescription1* pResourceDesc, uint FirstSubresource, uint NumSubresources, ulong BaseOffset, PlacedSubresourceFootprint* pLayouts, uint* pNumRows, ulong* pRowSizeInBytes, ulong* pTotalBytes) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[7]))((ID3D12Device9*)Unsafe.AsPointer(ref this), pResourceDesc, FirstSubresource, NumSubresources, BaseOffset, pLayouts, pNumRows, pRowSizeInBytes, pTotalBytes); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((ID3D12Device9*)Unsafe.AsPointer(ref this), pResourceDesc, FirstSubresource, NumSubresources, BaseOffset, pLayouts, pNumRows, pRowSizeInBytes, pTotalBytes); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(8)] + public HResult AddToStateObject(StateObjectDescription* pAddition, ID3D12StateObject* pStateObjectToGrowFrom, Guid* riid, void** ppNewStateObject) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[8]))((ID3D12Device9*)Unsafe.AsPointer(ref this), pAddition, pStateObjectToGrowFrom, riid, ppNewStateObject); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[8]))((ID3D12Device9*)Unsafe.AsPointer(ref this), pAddition, pStateObjectToGrowFrom, riid, ppNewStateObject); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(9)] + public HResult CreateProtectedResourceSession1(ProtectedResourceSessionDescription1* pDesc, Guid* riid, void** ppSession) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[9]))((ID3D12Device9*)Unsafe.AsPointer(ref this), pDesc, riid, ppSession); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[9]))((ID3D12Device9*)Unsafe.AsPointer(ref this), pDesc, riid, ppSession); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(10)] + public HResult SetBackgroundProcessingMode(BackgroundProcessingMode Mode, MeasurementsAction MeasurementsAction, IntPtr hEventToSignalUponCompletion, Bool32* pbFurtherMeasurementsDesired) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[10]))((ID3D12Device9*)Unsafe.AsPointer(ref this), Mode, MeasurementsAction, hEventToSignalUponCompletion, pbFurtherMeasurementsDesired); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[10]))((ID3D12Device9*)Unsafe.AsPointer(ref this), Mode, MeasurementsAction, hEventToSignalUponCompletion, pbFurtherMeasurementsDesired); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(11)] + public HResult CreateLifetimeTracker(ID3D12LifetimeOwner* pOwner, Guid* riid, void** ppvTracker) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[11]))((ID3D12Device9*)Unsafe.AsPointer(ref this), pOwner, riid, ppvTracker); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[11]))((ID3D12Device9*)Unsafe.AsPointer(ref this), pOwner, riid, ppvTracker); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(12)] + public void RemoveDevice() + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[12]))((ID3D12Device9*)Unsafe.AsPointer(ref this)); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[12]))((ID3D12Device9*)Unsafe.AsPointer(ref this)); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(13)] + public HResult EnumerateMetaCommands(uint* pNumMetaCommands, MetaCommandDescription* pDescs) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[13]))((ID3D12Device9*)Unsafe.AsPointer(ref this), pNumMetaCommands, pDescs); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[13]))((ID3D12Device9*)Unsafe.AsPointer(ref this), pNumMetaCommands, pDescs); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(14)] + public HResult EnumerateMetaCommandParameters(Guid* CommandId, MetaCommandParameterStage Stage, uint* pTotalStructureSizeInBytes, uint* pParameterCount, MetaCommandParameterDescription* pParameterDescs) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[14]))((ID3D12Device9*)Unsafe.AsPointer(ref this), CommandId, Stage, pTotalStructureSizeInBytes, pParameterCount, pParameterDescs); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[14]))((ID3D12Device9*)Unsafe.AsPointer(ref this), CommandId, Stage, pTotalStructureSizeInBytes, pParameterCount, pParameterDescs); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(15)] + public HResult CreateMetaCommand(Guid* CommandId, uint NodeMask, void* pCreationParametersData, nuint CreationParametersDataSizeInBytes, Guid* riid, void** ppMetaCommand) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[15]))((ID3D12Device9*)Unsafe.AsPointer(ref this), CommandId, NodeMask, pCreationParametersData, CreationParametersDataSizeInBytes, riid, ppMetaCommand); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[15]))((ID3D12Device9*)Unsafe.AsPointer(ref this), CommandId, NodeMask, pCreationParametersData, CreationParametersDataSizeInBytes, riid, ppMetaCommand); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(16)] + public HResult CreateStateObject(StateObjectDescription* pDesc, Guid* riid, void** ppStateObject) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[16]))((ID3D12Device9*)Unsafe.AsPointer(ref this), pDesc, riid, ppStateObject); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[16]))((ID3D12Device9*)Unsafe.AsPointer(ref this), pDesc, riid, ppStateObject); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(17)] + public void GetRaytracingAccelerationStructurePrebuildInfo(BuildRaytracingAccelerationStructureInputs* pDesc, RaytracingAccelerationStructurePrebuildInfo* pInfo) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[17]))((ID3D12Device9*)Unsafe.AsPointer(ref this), pDesc, pInfo); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[17]))((ID3D12Device9*)Unsafe.AsPointer(ref this), pDesc, pInfo); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(18)] + public Graphics.Direct3D12.DriverMatchingIdentifierStatus CheckDriverMatchingIdentifier(SerializedDataType SerializedDataType, SerializedDataDriverMatchingIdentifier* pIdentifierToCheck) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[18]))((ID3D12Device9*)Unsafe.AsPointer(ref this), SerializedDataType, pIdentifierToCheck); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[18]))((ID3D12Device9*)Unsafe.AsPointer(ref this), SerializedDataType, pIdentifierToCheck); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(19)] + public HResult CreateCommandList1(uint nodeMask, CommandListType type, CommandListFlags flags, Guid* riid, void** ppCommandList) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[19]))((ID3D12Device9*)Unsafe.AsPointer(ref this), nodeMask, type, flags, riid, ppCommandList); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[19]))((ID3D12Device9*)Unsafe.AsPointer(ref this), nodeMask, type, flags, riid, ppCommandList); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(20)] + public HResult CreateProtectedResourceSession(ProtectedResourceSessionDescription* pDesc, Guid* riid, void** ppSession) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[20]))((ID3D12Device9*)Unsafe.AsPointer(ref this), pDesc, riid, ppSession); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[20]))((ID3D12Device9*)Unsafe.AsPointer(ref this), pDesc, riid, ppSession); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(21)] + public HResult CreateCommittedResource1(HeapProperties* pHeapProperties, HeapFlags HeapFlags, ResourceDescription* pDesc, ResourceStates InitialResourceState, ClearValue* pOptimizedClearValue, ID3D12ProtectedResourceSession* pProtectedSession, Guid* riidResource, void** ppvResource) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[21]))((ID3D12Device9*)Unsafe.AsPointer(ref this), pHeapProperties, HeapFlags, pDesc, InitialResourceState, pOptimizedClearValue, pProtectedSession, riidResource, ppvResource); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[21]))((ID3D12Device9*)Unsafe.AsPointer(ref this), pHeapProperties, HeapFlags, pDesc, InitialResourceState, pOptimizedClearValue, pProtectedSession, riidResource, ppvResource); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(22)] + public HResult CreateHeap1(HeapDescription* pDesc, ID3D12ProtectedResourceSession* pProtectedSession, Guid* riid, void** ppvHeap) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[22]))((ID3D12Device9*)Unsafe.AsPointer(ref this), pDesc, pProtectedSession, riid, ppvHeap); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[22]))((ID3D12Device9*)Unsafe.AsPointer(ref this), pDesc, pProtectedSession, riid, ppvHeap); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(23)] + public HResult CreateReservedResource1(ResourceDescription* pDesc, ResourceStates InitialState, ClearValue* pOptimizedClearValue, ID3D12ProtectedResourceSession* pProtectedSession, Guid* riid, void** ppvResource) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[23]))((ID3D12Device9*)Unsafe.AsPointer(ref this), pDesc, InitialState, pOptimizedClearValue, pProtectedSession, riid, ppvResource); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[23]))((ID3D12Device9*)Unsafe.AsPointer(ref this), pDesc, InitialState, pOptimizedClearValue, pProtectedSession, riid, ppvResource); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(24)] + public Graphics.Direct3D12.ResourceAllocationInfo GetResourceAllocationInfo1(uint visibleMask, uint numResourceDescs, ResourceDescription* pResourceDescs, ResourceAllocationInfo1* pResourceAllocationInfo1) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[24]))((ID3D12Device9*)Unsafe.AsPointer(ref this), visibleMask, numResourceDescs, pResourceDescs, pResourceAllocationInfo1); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[24]))((ID3D12Device9*)Unsafe.AsPointer(ref this), visibleMask, numResourceDescs, pResourceDescs, pResourceAllocationInfo1); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(25)] + public HResult OpenExistingHeapFromAddress(void* pAddress, Guid* riid, void** ppvHeap) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[25]))((ID3D12Device9*)Unsafe.AsPointer(ref this), pAddress, riid, ppvHeap); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[25]))((ID3D12Device9*)Unsafe.AsPointer(ref this), pAddress, riid, ppvHeap); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(26)] + public HResult OpenExistingHeapFromFileMapping(IntPtr hFileMapping, Guid* riid, void** ppvHeap) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[26]))((ID3D12Device9*)Unsafe.AsPointer(ref this), hFileMapping, riid, ppvHeap); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[26]))((ID3D12Device9*)Unsafe.AsPointer(ref this), hFileMapping, riid, ppvHeap); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(27)] + public HResult EnqueueMakeResident(ResidencyFlags Flags, uint NumObjects, ID3D12Pageable* ppObjects, ID3D12Fence* pFenceToSignal, ulong FenceValueToSignal) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[27]))((ID3D12Device9*)Unsafe.AsPointer(ref this), Flags, NumObjects, ppObjects, pFenceToSignal, FenceValueToSignal); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[27]))((ID3D12Device9*)Unsafe.AsPointer(ref this), Flags, NumObjects, ppObjects, pFenceToSignal, FenceValueToSignal); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(28)] + public HResult CreatePipelineState(PipelineStateStreamDescription* pDesc, Guid* riid, void** ppPipelineState) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[28]))((ID3D12Device9*)Unsafe.AsPointer(ref this), pDesc, riid, ppPipelineState); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[28]))((ID3D12Device9*)Unsafe.AsPointer(ref this), pDesc, riid, ppPipelineState); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(29)] + public HResult CreatePipelineLibrary(void* pLibraryBlob, nuint BlobLength, Guid* riid, void** ppPipelineLibrary) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[29]))((ID3D12Device9*)Unsafe.AsPointer(ref this), pLibraryBlob, BlobLength, riid, ppPipelineLibrary); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[29]))((ID3D12Device9*)Unsafe.AsPointer(ref this), pLibraryBlob, BlobLength, riid, ppPipelineLibrary); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(30)] + public HResult SetEventOnMultipleFenceCompletion(ID3D12Fence* ppFences, ulong* pFenceValues, uint NumFences, MultipleFenceWaitFlags Flags, IntPtr hEvent) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[30]))((ID3D12Device9*)Unsafe.AsPointer(ref this), ppFences, pFenceValues, NumFences, Flags, hEvent); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[30]))((ID3D12Device9*)Unsafe.AsPointer(ref this), ppFences, pFenceValues, NumFences, Flags, hEvent); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(31)] + public HResult SetResidencyPriority(uint NumObjects, ID3D12Pageable* ppObjects, ResidencyPriority* pPriorities) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[31]))((ID3D12Device9*)Unsafe.AsPointer(ref this), NumObjects, ppObjects, pPriorities); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[31]))((ID3D12Device9*)Unsafe.AsPointer(ref this), NumObjects, ppObjects, pPriorities); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(32)] + public uint GetNodeCount() + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[32]))((ID3D12Device9*)Unsafe.AsPointer(ref this)); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[32]))((ID3D12Device9*)Unsafe.AsPointer(ref this)); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(33)] + public HResult CreateCommandQueue(CommandQueueDescription* pDesc, Guid* riid, void** ppCommandQueue) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[33]))((ID3D12Device9*)Unsafe.AsPointer(ref this), pDesc, riid, ppCommandQueue); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[33]))((ID3D12Device9*)Unsafe.AsPointer(ref this), pDesc, riid, ppCommandQueue); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(34)] + public HResult CreateCommandAllocator(CommandListType type, Guid* riid, void** ppCommandAllocator) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[34]))((ID3D12Device9*)Unsafe.AsPointer(ref this), type, riid, ppCommandAllocator); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[34]))((ID3D12Device9*)Unsafe.AsPointer(ref this), type, riid, ppCommandAllocator); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(35)] + public HResult CreateGraphicsPipelineState(GraphicsPipelineStateDescription* pDesc, Guid* riid, void** ppPipelineState) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[35]))((ID3D12Device9*)Unsafe.AsPointer(ref this), pDesc, riid, ppPipelineState); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[35]))((ID3D12Device9*)Unsafe.AsPointer(ref this), pDesc, riid, ppPipelineState); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(36)] + public HResult CreateComputePipelineState(ComputePipelineStateDescription* pDesc, Guid* riid, void** ppPipelineState) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[36]))((ID3D12Device9*)Unsafe.AsPointer(ref this), pDesc, riid, ppPipelineState); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[36]))((ID3D12Device9*)Unsafe.AsPointer(ref this), pDesc, riid, ppPipelineState); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(37)] + public HResult CreateCommandList(uint nodeMask, CommandListType type, ID3D12CommandAllocator* pCommandAllocator, ID3D12PipelineState* pInitialState, Guid* riid, void** ppCommandList) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[37]))((ID3D12Device9*)Unsafe.AsPointer(ref this), nodeMask, type, pCommandAllocator, pInitialState, riid, ppCommandList); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[37]))((ID3D12Device9*)Unsafe.AsPointer(ref this), nodeMask, type, pCommandAllocator, pInitialState, riid, ppCommandList); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(38)] + public HResult CheckFeatureSupport(Feature Feature, void* pFeatureSupportData, uint FeatureSupportDataSize) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[38]))((ID3D12Device9*)Unsafe.AsPointer(ref this), Feature, pFeatureSupportData, FeatureSupportDataSize); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[38]))((ID3D12Device9*)Unsafe.AsPointer(ref this), Feature, pFeatureSupportData, FeatureSupportDataSize); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(39)] + public HResult CreateDescriptorHeap(DescriptorHeapDescription* pDescriptorHeapDesc, Guid* riid, void** ppvHeap) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[39]))((ID3D12Device9*)Unsafe.AsPointer(ref this), pDescriptorHeapDesc, riid, ppvHeap); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[39]))((ID3D12Device9*)Unsafe.AsPointer(ref this), pDescriptorHeapDesc, riid, ppvHeap); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(40)] + public uint GetDescriptorHandleIncrementSize(DescriptorHeapType DescriptorHeapType) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[40]))((ID3D12Device9*)Unsafe.AsPointer(ref this), DescriptorHeapType); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[40]))((ID3D12Device9*)Unsafe.AsPointer(ref this), DescriptorHeapType); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(41)] + public HResult CreateRootSignature(uint nodeMask, void* pBlobWithRootSignature, nuint blobLengthInBytes, Guid* riid, void** ppvRootSignature) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[41]))((ID3D12Device9*)Unsafe.AsPointer(ref this), nodeMask, pBlobWithRootSignature, blobLengthInBytes, riid, ppvRootSignature); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[41]))((ID3D12Device9*)Unsafe.AsPointer(ref this), nodeMask, pBlobWithRootSignature, blobLengthInBytes, riid, ppvRootSignature); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(42)] + public void CreateConstantBufferView(ConstantBufferViewDescription* pDesc, CpuDescriptorHandle* DestDescriptor) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[42]))((ID3D12Device9*)Unsafe.AsPointer(ref this), pDesc, DestDescriptor); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[42]))((ID3D12Device9*)Unsafe.AsPointer(ref this), pDesc, DestDescriptor); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(43)] + public void CreateShaderResourceView(ID3D12Resource* pResource, ShaderResourceViewDescription* pDesc, CpuDescriptorHandle* DestDescriptor) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[43]))((ID3D12Device9*)Unsafe.AsPointer(ref this), pResource, pDesc, DestDescriptor); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[43]))((ID3D12Device9*)Unsafe.AsPointer(ref this), pResource, pDesc, DestDescriptor); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(44)] + public void CreateUnorderedAccessView(ID3D12Resource* pResource, ID3D12Resource* pCounterResource, UnorderedAccessViewDescription* pDesc, CpuDescriptorHandle* DestDescriptor) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[44]))((ID3D12Device9*)Unsafe.AsPointer(ref this), pResource, pCounterResource, pDesc, DestDescriptor); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[44]))((ID3D12Device9*)Unsafe.AsPointer(ref this), pResource, pCounterResource, pDesc, DestDescriptor); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(45)] + public void CreateRenderTargetView(ID3D12Resource* pResource, RenderTargetViewDescription* pDesc, CpuDescriptorHandle* DestDescriptor) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[45]))((ID3D12Device9*)Unsafe.AsPointer(ref this), pResource, pDesc, DestDescriptor); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[45]))((ID3D12Device9*)Unsafe.AsPointer(ref this), pResource, pDesc, DestDescriptor); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(46)] + public void CreateDepthStencilView(ID3D12Resource* pResource, DepthStencilViewDescription* pDesc, CpuDescriptorHandle* DestDescriptor) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[46]))((ID3D12Device9*)Unsafe.AsPointer(ref this), pResource, pDesc, DestDescriptor); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[46]))((ID3D12Device9*)Unsafe.AsPointer(ref this), pResource, pDesc, DestDescriptor); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(47)] + public void CreateSampler(SamplerDescription* pDesc, CpuDescriptorHandle* DestDescriptor) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[47]))((ID3D12Device9*)Unsafe.AsPointer(ref this), pDesc, DestDescriptor); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[47]))((ID3D12Device9*)Unsafe.AsPointer(ref this), pDesc, DestDescriptor); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(48)] + public void CopyDescriptors(uint NumDestDescriptorRanges, CpuDescriptorHandle* pDestDescriptorRangeStarts, uint* pDestDescriptorRangeSizes, uint NumSrcDescriptorRanges, CpuDescriptorHandle* pSrcDescriptorRangeStarts, uint* pSrcDescriptorRangeSizes, DescriptorHeapType DescriptorHeapsType) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[48]))((ID3D12Device9*)Unsafe.AsPointer(ref this), NumDestDescriptorRanges, pDestDescriptorRangeStarts, pDestDescriptorRangeSizes, NumSrcDescriptorRanges, pSrcDescriptorRangeStarts, pSrcDescriptorRangeSizes, DescriptorHeapsType); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[48]))((ID3D12Device9*)Unsafe.AsPointer(ref this), NumDestDescriptorRanges, pDestDescriptorRangeStarts, pDestDescriptorRangeSizes, NumSrcDescriptorRanges, pSrcDescriptorRangeStarts, pSrcDescriptorRangeSizes, DescriptorHeapsType); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(49)] + public void CopyDescriptorsSimple(uint NumDescriptors, CpuDescriptorHandle* DestDescriptorRangeStart, CpuDescriptorHandle* SrcDescriptorRangeStart, DescriptorHeapType DescriptorHeapsType) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[49]))((ID3D12Device9*)Unsafe.AsPointer(ref this), NumDescriptors, DestDescriptorRangeStart, SrcDescriptorRangeStart, DescriptorHeapsType); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[49]))((ID3D12Device9*)Unsafe.AsPointer(ref this), NumDescriptors, DestDescriptorRangeStart, SrcDescriptorRangeStart, DescriptorHeapsType); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(50)] + public Graphics.Direct3D12.ResourceAllocationInfo GetResourceAllocationInfo(uint visibleMask, uint numResourceDescs, ResourceDescription* pResourceDescs) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[50]))((ID3D12Device9*)Unsafe.AsPointer(ref this), visibleMask, numResourceDescs, pResourceDescs); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[50]))((ID3D12Device9*)Unsafe.AsPointer(ref this), visibleMask, numResourceDescs, pResourceDescs); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(51)] + public Graphics.Direct3D12.HeapProperties GetCustomHeapProperties(uint nodeMask, HeapType heapType) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[51]))((ID3D12Device9*)Unsafe.AsPointer(ref this), nodeMask, heapType); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[51]))((ID3D12Device9*)Unsafe.AsPointer(ref this), nodeMask, heapType); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(52)] + public HResult CreateCommittedResource(HeapProperties* pHeapProperties, HeapFlags HeapFlags, ResourceDescription* pDesc, ResourceStates InitialResourceState, ClearValue* pOptimizedClearValue, Guid* riidResource, void** ppvResource) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[52]))((ID3D12Device9*)Unsafe.AsPointer(ref this), pHeapProperties, HeapFlags, pDesc, InitialResourceState, pOptimizedClearValue, riidResource, ppvResource); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[52]))((ID3D12Device9*)Unsafe.AsPointer(ref this), pHeapProperties, HeapFlags, pDesc, InitialResourceState, pOptimizedClearValue, riidResource, ppvResource); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(53)] + public HResult CreateHeap(HeapDescription* pDesc, Guid* riid, void** ppvHeap) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[53]))((ID3D12Device9*)Unsafe.AsPointer(ref this), pDesc, riid, ppvHeap); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[53]))((ID3D12Device9*)Unsafe.AsPointer(ref this), pDesc, riid, ppvHeap); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(54)] + public HResult CreatePlacedResource(ID3D12Heap* pHeap, ulong HeapOffset, ResourceDescription* pDesc, ResourceStates InitialState, ClearValue* pOptimizedClearValue, Guid* riid, void** ppvResource) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[54]))((ID3D12Device9*)Unsafe.AsPointer(ref this), pHeap, HeapOffset, pDesc, InitialState, pOptimizedClearValue, riid, ppvResource); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[54]))((ID3D12Device9*)Unsafe.AsPointer(ref this), pHeap, HeapOffset, pDesc, InitialState, pOptimizedClearValue, riid, ppvResource); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(55)] + public HResult CreateReservedResource(ResourceDescription* pDesc, ResourceStates InitialState, ClearValue* pOptimizedClearValue, Guid* riid, void** ppvResource) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[55]))((ID3D12Device9*)Unsafe.AsPointer(ref this), pDesc, InitialState, pOptimizedClearValue, riid, ppvResource); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[55]))((ID3D12Device9*)Unsafe.AsPointer(ref this), pDesc, InitialState, pOptimizedClearValue, riid, ppvResource); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(56)] + public HResult CreateSharedHandle(ID3D12DeviceChild* pObject, Security.SECURITY_ATTRIBUTES* pAttributes, uint Access, char** Name, IntPtr* pHandle) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[56]))((ID3D12Device9*)Unsafe.AsPointer(ref this), pObject, pAttributes, Access, Name, pHandle); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[56]))((ID3D12Device9*)Unsafe.AsPointer(ref this), pObject, pAttributes, Access, Name, pHandle); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(57)] + public HResult OpenSharedHandle(IntPtr NTHandle, Guid* riid, void** ppvObj) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[57]))((ID3D12Device9*)Unsafe.AsPointer(ref this), NTHandle, riid, ppvObj); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[57]))((ID3D12Device9*)Unsafe.AsPointer(ref this), NTHandle, riid, ppvObj); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(58)] + public HResult OpenSharedHandleByName(char** Name, uint Access, IntPtr* pNTHandle) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[58]))((ID3D12Device9*)Unsafe.AsPointer(ref this), Name, Access, pNTHandle); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[58]))((ID3D12Device9*)Unsafe.AsPointer(ref this), Name, Access, pNTHandle); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(59)] + public HResult MakeResident(uint NumObjects, ID3D12Pageable* ppObjects) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[59]))((ID3D12Device9*)Unsafe.AsPointer(ref this), NumObjects, ppObjects); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[59]))((ID3D12Device9*)Unsafe.AsPointer(ref this), NumObjects, ppObjects); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(60)] + public HResult Evict(uint NumObjects, ID3D12Pageable* ppObjects) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[60]))((ID3D12Device9*)Unsafe.AsPointer(ref this), NumObjects, ppObjects); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[60]))((ID3D12Device9*)Unsafe.AsPointer(ref this), NumObjects, ppObjects); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(61)] + public HResult CreateFence(ulong InitialValue, FenceFlags Flags, Guid* riid, void** ppFence) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[61]))((ID3D12Device9*)Unsafe.AsPointer(ref this), InitialValue, Flags, riid, ppFence); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[61]))((ID3D12Device9*)Unsafe.AsPointer(ref this), InitialValue, Flags, riid, ppFence); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(62)] + public HResult GetDeviceRemovedReason() + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[62]))((ID3D12Device9*)Unsafe.AsPointer(ref this)); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[62]))((ID3D12Device9*)Unsafe.AsPointer(ref this)); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(63)] + public void GetCopyableFootprints(ResourceDescription* pResourceDesc, uint FirstSubresource, uint NumSubresources, ulong BaseOffset, PlacedSubresourceFootprint* pLayouts, uint* pNumRows, ulong* pRowSizeInBytes, ulong* pTotalBytes) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[63]))((ID3D12Device9*)Unsafe.AsPointer(ref this), pResourceDesc, FirstSubresource, NumSubresources, BaseOffset, pLayouts, pNumRows, pRowSizeInBytes, pTotalBytes); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[63]))((ID3D12Device9*)Unsafe.AsPointer(ref this), pResourceDesc, FirstSubresource, NumSubresources, BaseOffset, pLayouts, pNumRows, pRowSizeInBytes, pTotalBytes); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(64)] + public HResult CreateQueryHeap(QueryHeapDescription* pDesc, Guid* riid, void** ppvHeap) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[64]))((ID3D12Device9*)Unsafe.AsPointer(ref this), pDesc, riid, ppvHeap); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[64]))((ID3D12Device9*)Unsafe.AsPointer(ref this), pDesc, riid, ppvHeap); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(65)] + public HResult SetStablePowerState(Bool32 Enable) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[65]))((ID3D12Device9*)Unsafe.AsPointer(ref this), Enable); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[65]))((ID3D12Device9*)Unsafe.AsPointer(ref this), Enable); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(66)] + public HResult CreateCommandSignature(CommandSignatureDescription* pDesc, ID3D12RootSignature* pRootSignature, Guid* riid, void** ppvCommandSignature) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[66]))((ID3D12Device9*)Unsafe.AsPointer(ref this), pDesc, pRootSignature, riid, ppvCommandSignature); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[66]))((ID3D12Device9*)Unsafe.AsPointer(ref this), pDesc, pRootSignature, riid, ppvCommandSignature); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(67)] + public void GetResourceTiling(ID3D12Resource* pTiledResource, uint* pNumTilesForEntireResource, PackedMipInfo* pPackedMipDesc, TileShape* pStandardTileShapeForNonPackedMips, uint* pNumSubresourceTilings, uint FirstSubresourceTilingToGet, SubresourceTiling* pSubresourceTilingsForNonPackedMips) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[67]))((ID3D12Device9*)Unsafe.AsPointer(ref this), pTiledResource, pNumTilesForEntireResource, pPackedMipDesc, pStandardTileShapeForNonPackedMips, pNumSubresourceTilings, FirstSubresourceTilingToGet, pSubresourceTilingsForNonPackedMips); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[67]))((ID3D12Device9*)Unsafe.AsPointer(ref this), pTiledResource, pNumTilesForEntireResource, pPackedMipDesc, pStandardTileShapeForNonPackedMips, pNumSubresourceTilings, FirstSubresourceTilingToGet, pSubresourceTilingsForNonPackedMips); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(68)] + public Luid GetAdapterLuid() + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[68]))((ID3D12Device9*)Unsafe.AsPointer(ref this)); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[68]))((ID3D12Device9*)Unsafe.AsPointer(ref this)); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(69)] + public HResult GetPrivateData(Guid* guid, uint* pDataSize, void* pData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[69]))((ID3D12Device9*)Unsafe.AsPointer(ref this), guid, pDataSize, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[69]))((ID3D12Device9*)Unsafe.AsPointer(ref this), guid, pDataSize, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(70)] + public HResult SetPrivateData(Guid* guid, uint DataSize, void* pData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[70]))((ID3D12Device9*)Unsafe.AsPointer(ref this), guid, DataSize, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[70]))((ID3D12Device9*)Unsafe.AsPointer(ref this), guid, DataSize, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(71)] + public HResult SetPrivateDataInterface(Guid* guid, IUnknown* pData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[71]))((ID3D12Device9*)Unsafe.AsPointer(ref this), guid, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[71]))((ID3D12Device9*)Unsafe.AsPointer(ref this), guid, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(72)] + public HResult SetName(char** Name) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[72]))((ID3D12Device9*)Unsafe.AsPointer(ref this), Name); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[72]))((ID3D12Device9*)Unsafe.AsPointer(ref this), Name); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(73)] + public HResult CreateShaderCacheSession(ShaderCacheSessionDescription* pDesc, Guid* riid, void** ppvSession) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[73]))((ID3D12Device9*)Unsafe.AsPointer(ref this), pDesc, riid, ppvSession); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[73]))((ID3D12Device9*)Unsafe.AsPointer(ref this), pDesc, riid, ppvSession); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(74)] + public HResult ShaderCacheControl(ShaderCacheKindFlags Kinds, ShaderCacheControlFlags Control) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[74]))((ID3D12Device9*)Unsafe.AsPointer(ref this), Kinds, Control); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[74]))((ID3D12Device9*)Unsafe.AsPointer(ref this), Kinds, Control); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(75)] + public HResult CreateCommandQueue1(CommandQueueDescription* pDesc, Guid* CreatorID, Guid* riid, void** ppCommandQueue) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[75]))((ID3D12Device9*)Unsafe.AsPointer(ref this), pDesc, CreatorID, riid, ppCommandQueue); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[75]))((ID3D12Device9*)Unsafe.AsPointer(ref this), pDesc, CreatorID, riid, ppCommandQueue); +#endif + } + + public interface Interface : ID3D12Device8.Interface + { + } +} + +/// +/// ID3D12Tools +[Guid("7071e1f0-e84b-4b33-974f-12fa49de65c5")] +[NativeTypeName("struct ID3D12Tools : IUnknown")] +[NativeInheritance("IUnknown")] +public unsafe partial struct ID3D12Tools : ID3D12Tools.Interface +{ + public static ref readonly Guid IID_ID3D12Tools + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0xF0, 0xE1, 0x71, 0x70, + 0x4B, 0xE8, + 0x33, 0x4B, + 0x97, + 0x4F, + 0x12, + 0xFA, + 0x49, + 0xDE, + 0x65, + 0xC5 + }; + + 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_ID3D12Tools)); + + 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 EnableShaderInstrumentation(Bool32 bEnable) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[3]))((ID3D12Tools*)Unsafe.AsPointer(ref this), bEnable); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((ID3D12Tools*)Unsafe.AsPointer(ref this), bEnable); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public Bool32 ShaderInstrumentationEnabled() + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[4]))((ID3D12Tools*)Unsafe.AsPointer(ref this)); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((ID3D12Tools*)Unsafe.AsPointer(ref this)); +#endif + } + + public interface Interface : IUnknown.Interface + { + } +} + +/// +/// ID3D12Debug +[Guid("344488b7-6846-474b-b989-f027448245e0")] +[NativeTypeName("struct ID3D12Debug : IUnknown")] +[NativeInheritance("IUnknown")] +public unsafe partial struct ID3D12Debug : ID3D12Debug.Interface +{ + public static ref readonly Guid IID_ID3D12Debug + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0xB7, 0x88, 0x44, 0x34, + 0x46, 0x68, + 0x4B, 0x47, + 0xB9, + 0x89, + 0xF0, + 0x27, + 0x44, + 0x82, + 0x45, + 0xE0 + }; + + 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_ID3D12Debug)); + + 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 EnableDebugLayer() + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[3]))((ID3D12Debug*)Unsafe.AsPointer(ref this)); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((ID3D12Debug*)Unsafe.AsPointer(ref this)); +#endif + } + + public interface Interface : IUnknown.Interface + { + } +} + +/// +/// ID3D12Debug1 +[Guid("affaa4ca-63fe-4d8e-b8ad-159000af4304")] +[NativeTypeName("struct ID3D12Debug1 : IUnknown")] +[NativeInheritance("IUnknown")] +public unsafe partial struct ID3D12Debug1 : ID3D12Debug1.Interface +{ + public static ref readonly Guid IID_ID3D12Debug1 + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0xCA, 0xA4, 0xFA, 0xAF, + 0xFE, 0x63, + 0x8E, 0x4D, + 0xB8, + 0xAD, + 0x15, + 0x90, + 0x00, + 0xAF, + 0x43, + 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_ID3D12Debug1)); + + 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 EnableDebugLayer() + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[3]))((ID3D12Debug1*)Unsafe.AsPointer(ref this)); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((ID3D12Debug1*)Unsafe.AsPointer(ref this)); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public void SetEnableGPUBasedValidation(Bool32 Enable) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[4]))((ID3D12Debug1*)Unsafe.AsPointer(ref this), Enable); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((ID3D12Debug1*)Unsafe.AsPointer(ref this), Enable); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(5)] + public void SetEnableSynchronizedCommandQueueValidation(Bool32 Enable) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[5]))((ID3D12Debug1*)Unsafe.AsPointer(ref this), Enable); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((ID3D12Debug1*)Unsafe.AsPointer(ref this), Enable); +#endif + } + + public interface Interface : IUnknown.Interface + { + } +} + +/// +/// ID3D12Debug2 +[Guid("93a665c4-a3b2-4e5d-b692-a26ae14e3374")] +[NativeTypeName("struct ID3D12Debug2 : IUnknown")] +[NativeInheritance("IUnknown")] +public unsafe partial struct ID3D12Debug2 : ID3D12Debug2.Interface +{ + public static ref readonly Guid IID_ID3D12Debug2 + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0xC4, 0x65, 0xA6, 0x93, + 0xB2, 0xA3, + 0x5D, 0x4E, + 0xB6, + 0x92, + 0xA2, + 0x6A, + 0xE1, + 0x4E, + 0x33, + 0x74 + }; + + 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_ID3D12Debug2)); + + 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 SetGPUBasedValidationFlags(GpuBasedValidationFlags Flags) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[3]))((ID3D12Debug2*)Unsafe.AsPointer(ref this), Flags); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((ID3D12Debug2*)Unsafe.AsPointer(ref this), Flags); +#endif + } + + public interface Interface : IUnknown.Interface + { + } +} + +/// +/// ID3D12Debug3 +[Guid("5cf4e58f-f671-4ff1-a542-3686e3d153d1")] +[NativeTypeName("struct ID3D12Debug3 : ID3D12Debug")] +[NativeInheritance("ID3D12Debug")] +public unsafe partial struct ID3D12Debug3 : ID3D12Debug3.Interface +{ + public static ref readonly Guid IID_ID3D12Debug3 + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x8F, 0xE5, 0xF4, 0x5C, + 0x71, 0xF6, + 0xF1, 0x4F, + 0xA5, + 0x42, + 0x36, + 0x86, + 0xE3, + 0xD1, + 0x53, + 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_ID3D12Debug3)); + + 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 EnableDebugLayer() + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[3]))((ID3D12Debug3*)Unsafe.AsPointer(ref this)); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((ID3D12Debug3*)Unsafe.AsPointer(ref this)); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public void SetEnableGPUBasedValidation(Bool32 Enable) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[4]))((ID3D12Debug3*)Unsafe.AsPointer(ref this), Enable); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((ID3D12Debug3*)Unsafe.AsPointer(ref this), Enable); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(5)] + public void SetEnableSynchronizedCommandQueueValidation(Bool32 Enable) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[5]))((ID3D12Debug3*)Unsafe.AsPointer(ref this), Enable); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((ID3D12Debug3*)Unsafe.AsPointer(ref this), Enable); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(6)] + public void SetGPUBasedValidationFlags(GpuBasedValidationFlags Flags) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[6]))((ID3D12Debug3*)Unsafe.AsPointer(ref this), Flags); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((ID3D12Debug3*)Unsafe.AsPointer(ref this), Flags); +#endif + } + + public interface Interface : ID3D12Debug.Interface + { + } +} + +/// +/// ID3D12Debug4 +[Guid("014b816e-9ec5-4a2f-a845-ffbe441ce13a")] +[NativeTypeName("struct ID3D12Debug4 : ID3D12Debug3")] +[NativeInheritance("ID3D12Debug3")] +public unsafe partial struct ID3D12Debug4 : ID3D12Debug4.Interface +{ + public static ref readonly Guid IID_ID3D12Debug4 + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x6E, 0x81, 0x4B, 0x01, + 0xC5, 0x9E, + 0x2F, 0x4A, + 0xA8, + 0x45, + 0xFF, + 0xBE, + 0x44, + 0x1C, + 0xE1, + 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_ID3D12Debug4)); + + 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 SetEnableGPUBasedValidation(Bool32 Enable) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[3]))((ID3D12Debug4*)Unsafe.AsPointer(ref this), Enable); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((ID3D12Debug4*)Unsafe.AsPointer(ref this), Enable); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public void SetEnableSynchronizedCommandQueueValidation(Bool32 Enable) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[4]))((ID3D12Debug4*)Unsafe.AsPointer(ref this), Enable); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((ID3D12Debug4*)Unsafe.AsPointer(ref this), Enable); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(5)] + public void SetGPUBasedValidationFlags(GpuBasedValidationFlags Flags) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[5]))((ID3D12Debug4*)Unsafe.AsPointer(ref this), Flags); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((ID3D12Debug4*)Unsafe.AsPointer(ref this), Flags); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(6)] + public void EnableDebugLayer() + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[6]))((ID3D12Debug4*)Unsafe.AsPointer(ref this)); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((ID3D12Debug4*)Unsafe.AsPointer(ref this)); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(7)] + public void DisableDebugLayer() + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[7]))((ID3D12Debug4*)Unsafe.AsPointer(ref this)); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((ID3D12Debug4*)Unsafe.AsPointer(ref this)); +#endif + } + + public interface Interface : ID3D12Debug3.Interface + { + } +} + +/// +/// ID3D12Debug5 +[Guid("548d6b12-09fa-40e0-9069-5dcd589a52c9")] +[NativeTypeName("struct ID3D12Debug5 : ID3D12Debug4")] +[NativeInheritance("ID3D12Debug4")] +public unsafe partial struct ID3D12Debug5 : ID3D12Debug5.Interface +{ + public static ref readonly Guid IID_ID3D12Debug5 + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x12, 0x6B, 0x8D, 0x54, + 0xFA, 0x09, + 0xE0, 0x40, + 0x90, + 0x69, + 0x5D, + 0xCD, + 0x58, + 0x9A, + 0x52, + 0xC9 + }; + + 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_ID3D12Debug5)); + + 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 DisableDebugLayer() + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[3]))((ID3D12Debug5*)Unsafe.AsPointer(ref this)); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((ID3D12Debug5*)Unsafe.AsPointer(ref this)); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public void SetEnableGPUBasedValidation(Bool32 Enable) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[4]))((ID3D12Debug5*)Unsafe.AsPointer(ref this), Enable); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((ID3D12Debug5*)Unsafe.AsPointer(ref this), Enable); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(5)] + public void SetEnableSynchronizedCommandQueueValidation(Bool32 Enable) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[5]))((ID3D12Debug5*)Unsafe.AsPointer(ref this), Enable); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((ID3D12Debug5*)Unsafe.AsPointer(ref this), Enable); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(6)] + public void SetGPUBasedValidationFlags(GpuBasedValidationFlags Flags) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[6]))((ID3D12Debug5*)Unsafe.AsPointer(ref this), Flags); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((ID3D12Debug5*)Unsafe.AsPointer(ref this), Flags); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(7)] + public void EnableDebugLayer() + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[7]))((ID3D12Debug5*)Unsafe.AsPointer(ref this)); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((ID3D12Debug5*)Unsafe.AsPointer(ref this)); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(8)] + public void SetEnableAutoName(Bool32 Enable) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[8]))((ID3D12Debug5*)Unsafe.AsPointer(ref this), Enable); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[8]))((ID3D12Debug5*)Unsafe.AsPointer(ref this), Enable); +#endif + } + + public interface Interface : ID3D12Debug4.Interface + { + } +} + +/// +/// ID3D12DebugDevice1 +[Guid("a9b71770-d099-4a65-a698-3dee10020f88")] +[NativeTypeName("struct ID3D12DebugDevice1 : IUnknown")] +[NativeInheritance("IUnknown")] +public unsafe partial struct ID3D12DebugDevice1 : ID3D12DebugDevice1.Interface +{ + public static ref readonly Guid IID_ID3D12DebugDevice1 + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x70, 0x17, 0xB7, 0xA9, + 0x99, 0xD0, + 0x65, 0x4A, + 0xA6, + 0x98, + 0x3D, + 0xEE, + 0x10, + 0x02, + 0x0F, + 0x88 + }; + + 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_ID3D12DebugDevice1)); + + 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 SetDebugParameter(DebugDeviceParameterType Type, void* pData, uint DataSize) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[3]))((ID3D12DebugDevice1*)Unsafe.AsPointer(ref this), Type, pData, DataSize); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((ID3D12DebugDevice1*)Unsafe.AsPointer(ref this), Type, pData, DataSize); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public HResult GetDebugParameter(DebugDeviceParameterType Type, void* pData, uint DataSize) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[4]))((ID3D12DebugDevice1*)Unsafe.AsPointer(ref this), Type, pData, DataSize); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((ID3D12DebugDevice1*)Unsafe.AsPointer(ref this), Type, pData, DataSize); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(5)] + public HResult ReportLiveDeviceObjects(RldoFlags Flags) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[5]))((ID3D12DebugDevice1*)Unsafe.AsPointer(ref this), Flags); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((ID3D12DebugDevice1*)Unsafe.AsPointer(ref this), Flags); +#endif + } + + public interface Interface : IUnknown.Interface + { + } +} + +/// +/// ID3D12DebugDevice +[Guid("3febd6dd-4973-4787-8194-e45f9e28923e")] +[NativeTypeName("struct ID3D12DebugDevice : IUnknown")] +[NativeInheritance("IUnknown")] +public unsafe partial struct ID3D12DebugDevice : ID3D12DebugDevice.Interface +{ + public static ref readonly Guid IID_ID3D12DebugDevice + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0xDD, 0xD6, 0xEB, 0x3F, + 0x73, 0x49, + 0x87, 0x47, + 0x81, + 0x94, + 0xE4, + 0x5F, + 0x9E, + 0x28, + 0x92, + 0x3E + }; + + 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_ID3D12DebugDevice)); + + 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(DebugFeature Mask) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[3]))((ID3D12DebugDevice*)Unsafe.AsPointer(ref this), Mask); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((ID3D12DebugDevice*)Unsafe.AsPointer(ref this), Mask); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public Graphics.Direct3D12.DebugFeature GetFeatureMask() + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[4]))((ID3D12DebugDevice*)Unsafe.AsPointer(ref this)); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((ID3D12DebugDevice*)Unsafe.AsPointer(ref this)); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(5)] + public HResult ReportLiveDeviceObjects(RldoFlags Flags) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[5]))((ID3D12DebugDevice*)Unsafe.AsPointer(ref this), Flags); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((ID3D12DebugDevice*)Unsafe.AsPointer(ref this), Flags); +#endif + } + + public interface Interface : IUnknown.Interface + { + } +} + +/// +/// ID3D12DebugDevice2 +[Guid("60eccbc1-378d-4df1-894c-f8ac5ce4d7dd")] +[NativeTypeName("struct ID3D12DebugDevice2 : ID3D12DebugDevice")] +[NativeInheritance("ID3D12DebugDevice")] +public unsafe partial struct ID3D12DebugDevice2 : ID3D12DebugDevice2.Interface +{ + public static ref readonly Guid IID_ID3D12DebugDevice2 + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0xC1, 0xCB, 0xEC, 0x60, + 0x8D, 0x37, + 0xF1, 0x4D, + 0x89, + 0x4C, + 0xF8, + 0xAC, + 0x5C, + 0xE4, + 0xD7, + 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_ID3D12DebugDevice2)); + + 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(DebugFeature Mask) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[3]))((ID3D12DebugDevice2*)Unsafe.AsPointer(ref this), Mask); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((ID3D12DebugDevice2*)Unsafe.AsPointer(ref this), Mask); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public Graphics.Direct3D12.DebugFeature GetFeatureMask() + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[4]))((ID3D12DebugDevice2*)Unsafe.AsPointer(ref this)); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((ID3D12DebugDevice2*)Unsafe.AsPointer(ref this)); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(5)] + public HResult ReportLiveDeviceObjects(RldoFlags Flags) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[5]))((ID3D12DebugDevice2*)Unsafe.AsPointer(ref this), Flags); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((ID3D12DebugDevice2*)Unsafe.AsPointer(ref this), Flags); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(6)] + public HResult SetDebugParameter(DebugDeviceParameterType Type, void* pData, uint DataSize) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[6]))((ID3D12DebugDevice2*)Unsafe.AsPointer(ref this), Type, pData, DataSize); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((ID3D12DebugDevice2*)Unsafe.AsPointer(ref this), Type, pData, DataSize); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(7)] + public HResult GetDebugParameter(DebugDeviceParameterType Type, void* pData, uint DataSize) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[7]))((ID3D12DebugDevice2*)Unsafe.AsPointer(ref this), Type, pData, DataSize); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((ID3D12DebugDevice2*)Unsafe.AsPointer(ref this), Type, pData, DataSize); +#endif + } + + public interface Interface : ID3D12DebugDevice.Interface + { + } +} + +/// +/// ID3D12DebugCommandQueue +[Guid("09e0bf36-54ac-484f-8847-4baeeab6053a")] +[NativeTypeName("struct ID3D12DebugCommandQueue : IUnknown")] +[NativeInheritance("IUnknown")] +public unsafe partial struct ID3D12DebugCommandQueue : ID3D12DebugCommandQueue.Interface +{ + public static ref readonly Guid IID_ID3D12DebugCommandQueue + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x36, 0xBF, 0xE0, 0x09, + 0xAC, 0x54, + 0x4F, 0x48, + 0x88, + 0x47, + 0x4B, + 0xAE, + 0xEA, + 0xB6, + 0x05, + 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_ID3D12DebugCommandQueue)); + + 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 AssertResourceState(ID3D12Resource* pResource, uint Subresource, uint State) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[3]))((ID3D12DebugCommandQueue*)Unsafe.AsPointer(ref this), pResource, Subresource, State); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((ID3D12DebugCommandQueue*)Unsafe.AsPointer(ref this), pResource, Subresource, State); +#endif + } + + public interface Interface : IUnknown.Interface + { + } +} + +/// +/// ID3D12DebugCommandList1 +[Guid("102ca951-311b-4b01-b11f-ecb83e061b37")] +[NativeTypeName("struct ID3D12DebugCommandList1 : IUnknown")] +[NativeInheritance("IUnknown")] +public unsafe partial struct ID3D12DebugCommandList1 : ID3D12DebugCommandList1.Interface +{ + public static ref readonly Guid IID_ID3D12DebugCommandList1 + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x51, 0xA9, 0x2C, 0x10, + 0x1B, 0x31, + 0x01, 0x4B, + 0xB1, + 0x1F, + 0xEC, + 0xB8, + 0x3E, + 0x06, + 0x1B, + 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_ID3D12DebugCommandList1)); + + 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 AssertResourceState(ID3D12Resource* pResource, uint Subresource, uint State) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[3]))((ID3D12DebugCommandList1*)Unsafe.AsPointer(ref this), pResource, Subresource, State); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((ID3D12DebugCommandList1*)Unsafe.AsPointer(ref this), pResource, Subresource, State); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public HResult SetDebugParameter(DebugCommandListParameterType Type, void* pData, uint DataSize) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[4]))((ID3D12DebugCommandList1*)Unsafe.AsPointer(ref this), Type, pData, DataSize); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((ID3D12DebugCommandList1*)Unsafe.AsPointer(ref this), Type, pData, DataSize); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(5)] + public HResult GetDebugParameter(DebugCommandListParameterType Type, void* pData, uint DataSize) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[5]))((ID3D12DebugCommandList1*)Unsafe.AsPointer(ref this), Type, pData, DataSize); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((ID3D12DebugCommandList1*)Unsafe.AsPointer(ref this), Type, pData, DataSize); +#endif + } + + public interface Interface : IUnknown.Interface + { + } +} + +/// +/// ID3D12DebugCommandList +[Guid("09e0bf36-54ac-484f-8847-4baeeab6053f")] +[NativeTypeName("struct ID3D12DebugCommandList : IUnknown")] +[NativeInheritance("IUnknown")] +public unsafe partial struct ID3D12DebugCommandList : ID3D12DebugCommandList.Interface +{ + public static ref readonly Guid IID_ID3D12DebugCommandList + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x36, 0xBF, 0xE0, 0x09, + 0xAC, 0x54, + 0x4F, 0x48, + 0x88, + 0x47, + 0x4B, + 0xAE, + 0xEA, + 0xB6, + 0x05, + 0x3F + }; + + 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_ID3D12DebugCommandList)); + + 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 AssertResourceState(ID3D12Resource* pResource, uint Subresource, uint State) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[3]))((ID3D12DebugCommandList*)Unsafe.AsPointer(ref this), pResource, Subresource, State); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((ID3D12DebugCommandList*)Unsafe.AsPointer(ref this), pResource, Subresource, State); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public HResult SetFeatureMask(DebugFeature Mask) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[4]))((ID3D12DebugCommandList*)Unsafe.AsPointer(ref this), Mask); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((ID3D12DebugCommandList*)Unsafe.AsPointer(ref this), Mask); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(5)] + public Graphics.Direct3D12.DebugFeature GetFeatureMask() + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[5]))((ID3D12DebugCommandList*)Unsafe.AsPointer(ref this)); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((ID3D12DebugCommandList*)Unsafe.AsPointer(ref this)); +#endif + } + + public interface Interface : IUnknown.Interface + { + } +} + +/// +/// ID3D12DebugCommandList2 +[Guid("aeb575cf-4e06-48be-ba3b-c450fc96652e")] +[NativeTypeName("struct ID3D12DebugCommandList2 : ID3D12DebugCommandList")] +[NativeInheritance("ID3D12DebugCommandList")] +public unsafe partial struct ID3D12DebugCommandList2 : ID3D12DebugCommandList2.Interface +{ + public static ref readonly Guid IID_ID3D12DebugCommandList2 + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0xCF, 0x75, 0xB5, 0xAE, + 0x06, 0x4E, + 0xBE, 0x48, + 0xBA, + 0x3B, + 0xC4, + 0x50, + 0xFC, + 0x96, + 0x65, + 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_ID3D12DebugCommandList2)); + + 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 AssertResourceState(ID3D12Resource* pResource, uint Subresource, uint State) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[3]))((ID3D12DebugCommandList2*)Unsafe.AsPointer(ref this), pResource, Subresource, State); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((ID3D12DebugCommandList2*)Unsafe.AsPointer(ref this), pResource, Subresource, State); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public HResult SetFeatureMask(DebugFeature Mask) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[4]))((ID3D12DebugCommandList2*)Unsafe.AsPointer(ref this), Mask); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((ID3D12DebugCommandList2*)Unsafe.AsPointer(ref this), Mask); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(5)] + public Graphics.Direct3D12.DebugFeature GetFeatureMask() + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[5]))((ID3D12DebugCommandList2*)Unsafe.AsPointer(ref this)); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((ID3D12DebugCommandList2*)Unsafe.AsPointer(ref this)); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(6)] + public HResult SetDebugParameter(DebugCommandListParameterType Type, void* pData, uint DataSize) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[6]))((ID3D12DebugCommandList2*)Unsafe.AsPointer(ref this), Type, pData, DataSize); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((ID3D12DebugCommandList2*)Unsafe.AsPointer(ref this), Type, pData, DataSize); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(7)] + public HResult GetDebugParameter(DebugCommandListParameterType Type, void* pData, uint DataSize) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[7]))((ID3D12DebugCommandList2*)Unsafe.AsPointer(ref this), Type, pData, DataSize); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((ID3D12DebugCommandList2*)Unsafe.AsPointer(ref this), Type, pData, DataSize); +#endif + } + + public interface Interface : ID3D12DebugCommandList.Interface + { + } +} + +/// +/// ID3D12SharingContract +[Guid("0adf7d52-929c-4e61-addb-ffed30de66ef")] +[NativeTypeName("struct ID3D12SharingContract : IUnknown")] +[NativeInheritance("IUnknown")] +public unsafe partial struct ID3D12SharingContract : ID3D12SharingContract.Interface +{ + public static ref readonly Guid IID_ID3D12SharingContract + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x52, 0x7D, 0xDF, 0x0A, + 0x9C, 0x92, + 0x61, 0x4E, + 0xAD, + 0xDB, + 0xFF, + 0xED, + 0x30, + 0xDE, + 0x66, + 0xEF + }; + + 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_ID3D12SharingContract)); + + 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 Present(ID3D12Resource* pResource, uint Subresource, IntPtr window) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[3]))((ID3D12SharingContract*)Unsafe.AsPointer(ref this), pResource, Subresource, window); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((ID3D12SharingContract*)Unsafe.AsPointer(ref this), pResource, Subresource, window); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public void SharedFenceSignal(ID3D12Fence* pFence, ulong FenceValue) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[4]))((ID3D12SharingContract*)Unsafe.AsPointer(ref this), pFence, FenceValue); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((ID3D12SharingContract*)Unsafe.AsPointer(ref this), pFence, FenceValue); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(5)] + public void BeginCapturableWork(Guid* guid) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[5]))((ID3D12SharingContract*)Unsafe.AsPointer(ref this), guid); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((ID3D12SharingContract*)Unsafe.AsPointer(ref this), guid); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(6)] + public void EndCapturableWork(Guid* guid) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[6]))((ID3D12SharingContract*)Unsafe.AsPointer(ref this), guid); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((ID3D12SharingContract*)Unsafe.AsPointer(ref this), guid); +#endif + } + + public interface Interface : IUnknown.Interface + { + } +} + +/// +/// ID3D12InfoQueue +[Guid("0742a90b-c387-483f-b946-30a7e4e61458")] +[NativeTypeName("struct ID3D12InfoQueue : IUnknown")] +[NativeInheritance("IUnknown")] +public unsafe partial struct ID3D12InfoQueue : ID3D12InfoQueue.Interface +{ + public static ref readonly Guid IID_ID3D12InfoQueue + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x0B, 0xA9, 0x42, 0x07, + 0x87, 0xC3, + 0x3F, 0x48, + 0xB9, + 0x46, + 0x30, + 0xA7, + 0xE4, + 0xE6, + 0x14, + 0x58 + }; + + 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_ID3D12InfoQueue)); + + 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]))((ID3D12InfoQueue*)Unsafe.AsPointer(ref this), MessageCountLimit); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((ID3D12InfoQueue*)Unsafe.AsPointer(ref this), MessageCountLimit); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public void ClearStoredMessages() + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[4]))((ID3D12InfoQueue*)Unsafe.AsPointer(ref this)); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((ID3D12InfoQueue*)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]))((ID3D12InfoQueue*)Unsafe.AsPointer(ref this), MessageIndex, pMessage, pMessageByteLength); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((ID3D12InfoQueue*)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]))((ID3D12InfoQueue*)Unsafe.AsPointer(ref this)); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((ID3D12InfoQueue*)Unsafe.AsPointer(ref this)); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(7)] + public ulong GetNumMessagesDeniedByStorageFilter() + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[7]))((ID3D12InfoQueue*)Unsafe.AsPointer(ref this)); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((ID3D12InfoQueue*)Unsafe.AsPointer(ref this)); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(8)] + public ulong GetNumStoredMessages() + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[8]))((ID3D12InfoQueue*)Unsafe.AsPointer(ref this)); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[8]))((ID3D12InfoQueue*)Unsafe.AsPointer(ref this)); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(9)] + public ulong GetNumStoredMessagesAllowedByRetrievalFilter() + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[9]))((ID3D12InfoQueue*)Unsafe.AsPointer(ref this)); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[9]))((ID3D12InfoQueue*)Unsafe.AsPointer(ref this)); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(10)] + public ulong GetNumMessagesDiscardedByMessageCountLimit() + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[10]))((ID3D12InfoQueue*)Unsafe.AsPointer(ref this)); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[10]))((ID3D12InfoQueue*)Unsafe.AsPointer(ref this)); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(11)] + public ulong GetMessageCountLimit() + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[11]))((ID3D12InfoQueue*)Unsafe.AsPointer(ref this)); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[11]))((ID3D12InfoQueue*)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]))((ID3D12InfoQueue*)Unsafe.AsPointer(ref this), pFilter); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[12]))((ID3D12InfoQueue*)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]))((ID3D12InfoQueue*)Unsafe.AsPointer(ref this), pFilter, pFilterByteLength); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[13]))((ID3D12InfoQueue*)Unsafe.AsPointer(ref this), pFilter, pFilterByteLength); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(14)] + public void ClearStorageFilter() + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[14]))((ID3D12InfoQueue*)Unsafe.AsPointer(ref this)); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[14]))((ID3D12InfoQueue*)Unsafe.AsPointer(ref this)); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(15)] + public HResult PushEmptyStorageFilter() + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[15]))((ID3D12InfoQueue*)Unsafe.AsPointer(ref this)); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[15]))((ID3D12InfoQueue*)Unsafe.AsPointer(ref this)); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(16)] + public HResult PushCopyOfStorageFilter() + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[16]))((ID3D12InfoQueue*)Unsafe.AsPointer(ref this)); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[16]))((ID3D12InfoQueue*)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]))((ID3D12InfoQueue*)Unsafe.AsPointer(ref this), pFilter); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[17]))((ID3D12InfoQueue*)Unsafe.AsPointer(ref this), pFilter); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(18)] + public void PopStorageFilter() + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[18]))((ID3D12InfoQueue*)Unsafe.AsPointer(ref this)); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[18]))((ID3D12InfoQueue*)Unsafe.AsPointer(ref this)); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(19)] + public uint GetStorageFilterStackSize() + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[19]))((ID3D12InfoQueue*)Unsafe.AsPointer(ref this)); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[19]))((ID3D12InfoQueue*)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]))((ID3D12InfoQueue*)Unsafe.AsPointer(ref this), pFilter); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[20]))((ID3D12InfoQueue*)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]))((ID3D12InfoQueue*)Unsafe.AsPointer(ref this), pFilter, pFilterByteLength); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[21]))((ID3D12InfoQueue*)Unsafe.AsPointer(ref this), pFilter, pFilterByteLength); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(22)] + public void ClearRetrievalFilter() + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[22]))((ID3D12InfoQueue*)Unsafe.AsPointer(ref this)); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[22]))((ID3D12InfoQueue*)Unsafe.AsPointer(ref this)); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(23)] + public HResult PushEmptyRetrievalFilter() + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[23]))((ID3D12InfoQueue*)Unsafe.AsPointer(ref this)); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[23]))((ID3D12InfoQueue*)Unsafe.AsPointer(ref this)); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(24)] + public HResult PushCopyOfRetrievalFilter() + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[24]))((ID3D12InfoQueue*)Unsafe.AsPointer(ref this)); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[24]))((ID3D12InfoQueue*)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]))((ID3D12InfoQueue*)Unsafe.AsPointer(ref this), pFilter); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[25]))((ID3D12InfoQueue*)Unsafe.AsPointer(ref this), pFilter); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(26)] + public void PopRetrievalFilter() + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[26]))((ID3D12InfoQueue*)Unsafe.AsPointer(ref this)); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[26]))((ID3D12InfoQueue*)Unsafe.AsPointer(ref this)); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(27)] + public uint GetRetrievalFilterStackSize() + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[27]))((ID3D12InfoQueue*)Unsafe.AsPointer(ref this)); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[27]))((ID3D12InfoQueue*)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]))((ID3D12InfoQueue*)Unsafe.AsPointer(ref this), Category, Severity, ID, pDescription); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[28]))((ID3D12InfoQueue*)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]))((ID3D12InfoQueue*)Unsafe.AsPointer(ref this), Severity, pDescription); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[29]))((ID3D12InfoQueue*)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]))((ID3D12InfoQueue*)Unsafe.AsPointer(ref this), Category, bEnable); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[30]))((ID3D12InfoQueue*)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]))((ID3D12InfoQueue*)Unsafe.AsPointer(ref this), Severity, bEnable); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[31]))((ID3D12InfoQueue*)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]))((ID3D12InfoQueue*)Unsafe.AsPointer(ref this), ID, bEnable); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[32]))((ID3D12InfoQueue*)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]))((ID3D12InfoQueue*)Unsafe.AsPointer(ref this), Category); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[33]))((ID3D12InfoQueue*)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]))((ID3D12InfoQueue*)Unsafe.AsPointer(ref this), Severity); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[34]))((ID3D12InfoQueue*)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]))((ID3D12InfoQueue*)Unsafe.AsPointer(ref this), ID); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[35]))((ID3D12InfoQueue*)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]))((ID3D12InfoQueue*)Unsafe.AsPointer(ref this), bMute); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[36]))((ID3D12InfoQueue*)Unsafe.AsPointer(ref this), bMute); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(37)] + public Bool32 GetMuteDebugOutput() + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[37]))((ID3D12InfoQueue*)Unsafe.AsPointer(ref this)); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[37]))((ID3D12InfoQueue*)Unsafe.AsPointer(ref this)); +#endif + } + + public interface Interface : IUnknown.Interface + { + } +} + +/// +/// ID3D12InfoQueue1 +[Guid("2852dd88-b484-4c0c-b6b1-67168500e600")] +[NativeTypeName("struct ID3D12InfoQueue1 : ID3D12InfoQueue")] +[NativeInheritance("ID3D12InfoQueue")] +public unsafe partial struct ID3D12InfoQueue1 : ID3D12InfoQueue1.Interface +{ + public static ref readonly Guid IID_ID3D12InfoQueue1 + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x88, 0xDD, 0x52, 0x28, + 0x84, 0xB4, + 0x0C, 0x4C, + 0xB6, + 0xB1, + 0x67, + 0x16, + 0x85, + 0x00, + 0xE6, + 0x00 + }; + + 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_ID3D12InfoQueue1)); + + 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]))((ID3D12InfoQueue1*)Unsafe.AsPointer(ref this), MessageCountLimit); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((ID3D12InfoQueue1*)Unsafe.AsPointer(ref this), MessageCountLimit); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public void ClearStoredMessages() + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[4]))((ID3D12InfoQueue1*)Unsafe.AsPointer(ref this)); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((ID3D12InfoQueue1*)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]))((ID3D12InfoQueue1*)Unsafe.AsPointer(ref this), MessageIndex, pMessage, pMessageByteLength); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((ID3D12InfoQueue1*)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]))((ID3D12InfoQueue1*)Unsafe.AsPointer(ref this)); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((ID3D12InfoQueue1*)Unsafe.AsPointer(ref this)); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(7)] + public ulong GetNumMessagesDeniedByStorageFilter() + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[7]))((ID3D12InfoQueue1*)Unsafe.AsPointer(ref this)); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((ID3D12InfoQueue1*)Unsafe.AsPointer(ref this)); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(8)] + public ulong GetNumStoredMessages() + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[8]))((ID3D12InfoQueue1*)Unsafe.AsPointer(ref this)); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[8]))((ID3D12InfoQueue1*)Unsafe.AsPointer(ref this)); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(9)] + public ulong GetNumStoredMessagesAllowedByRetrievalFilter() + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[9]))((ID3D12InfoQueue1*)Unsafe.AsPointer(ref this)); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[9]))((ID3D12InfoQueue1*)Unsafe.AsPointer(ref this)); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(10)] + public ulong GetNumMessagesDiscardedByMessageCountLimit() + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[10]))((ID3D12InfoQueue1*)Unsafe.AsPointer(ref this)); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[10]))((ID3D12InfoQueue1*)Unsafe.AsPointer(ref this)); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(11)] + public ulong GetMessageCountLimit() + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[11]))((ID3D12InfoQueue1*)Unsafe.AsPointer(ref this)); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[11]))((ID3D12InfoQueue1*)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]))((ID3D12InfoQueue1*)Unsafe.AsPointer(ref this), pFilter); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[12]))((ID3D12InfoQueue1*)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]))((ID3D12InfoQueue1*)Unsafe.AsPointer(ref this), pFilter, pFilterByteLength); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[13]))((ID3D12InfoQueue1*)Unsafe.AsPointer(ref this), pFilter, pFilterByteLength); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(14)] + public void ClearStorageFilter() + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[14]))((ID3D12InfoQueue1*)Unsafe.AsPointer(ref this)); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[14]))((ID3D12InfoQueue1*)Unsafe.AsPointer(ref this)); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(15)] + public HResult PushEmptyStorageFilter() + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[15]))((ID3D12InfoQueue1*)Unsafe.AsPointer(ref this)); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[15]))((ID3D12InfoQueue1*)Unsafe.AsPointer(ref this)); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(16)] + public HResult PushCopyOfStorageFilter() + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[16]))((ID3D12InfoQueue1*)Unsafe.AsPointer(ref this)); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[16]))((ID3D12InfoQueue1*)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]))((ID3D12InfoQueue1*)Unsafe.AsPointer(ref this), pFilter); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[17]))((ID3D12InfoQueue1*)Unsafe.AsPointer(ref this), pFilter); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(18)] + public void PopStorageFilter() + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[18]))((ID3D12InfoQueue1*)Unsafe.AsPointer(ref this)); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[18]))((ID3D12InfoQueue1*)Unsafe.AsPointer(ref this)); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(19)] + public uint GetStorageFilterStackSize() + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[19]))((ID3D12InfoQueue1*)Unsafe.AsPointer(ref this)); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[19]))((ID3D12InfoQueue1*)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]))((ID3D12InfoQueue1*)Unsafe.AsPointer(ref this), pFilter); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[20]))((ID3D12InfoQueue1*)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]))((ID3D12InfoQueue1*)Unsafe.AsPointer(ref this), pFilter, pFilterByteLength); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[21]))((ID3D12InfoQueue1*)Unsafe.AsPointer(ref this), pFilter, pFilterByteLength); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(22)] + public void ClearRetrievalFilter() + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[22]))((ID3D12InfoQueue1*)Unsafe.AsPointer(ref this)); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[22]))((ID3D12InfoQueue1*)Unsafe.AsPointer(ref this)); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(23)] + public HResult PushEmptyRetrievalFilter() + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[23]))((ID3D12InfoQueue1*)Unsafe.AsPointer(ref this)); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[23]))((ID3D12InfoQueue1*)Unsafe.AsPointer(ref this)); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(24)] + public HResult PushCopyOfRetrievalFilter() + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[24]))((ID3D12InfoQueue1*)Unsafe.AsPointer(ref this)); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[24]))((ID3D12InfoQueue1*)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]))((ID3D12InfoQueue1*)Unsafe.AsPointer(ref this), pFilter); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[25]))((ID3D12InfoQueue1*)Unsafe.AsPointer(ref this), pFilter); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(26)] + public void PopRetrievalFilter() + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[26]))((ID3D12InfoQueue1*)Unsafe.AsPointer(ref this)); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[26]))((ID3D12InfoQueue1*)Unsafe.AsPointer(ref this)); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(27)] + public uint GetRetrievalFilterStackSize() + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[27]))((ID3D12InfoQueue1*)Unsafe.AsPointer(ref this)); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[27]))((ID3D12InfoQueue1*)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]))((ID3D12InfoQueue1*)Unsafe.AsPointer(ref this), Category, Severity, ID, pDescription); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[28]))((ID3D12InfoQueue1*)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]))((ID3D12InfoQueue1*)Unsafe.AsPointer(ref this), Severity, pDescription); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[29]))((ID3D12InfoQueue1*)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]))((ID3D12InfoQueue1*)Unsafe.AsPointer(ref this), Category, bEnable); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[30]))((ID3D12InfoQueue1*)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]))((ID3D12InfoQueue1*)Unsafe.AsPointer(ref this), Severity, bEnable); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[31]))((ID3D12InfoQueue1*)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]))((ID3D12InfoQueue1*)Unsafe.AsPointer(ref this), ID, bEnable); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[32]))((ID3D12InfoQueue1*)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]))((ID3D12InfoQueue1*)Unsafe.AsPointer(ref this), Category); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[33]))((ID3D12InfoQueue1*)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]))((ID3D12InfoQueue1*)Unsafe.AsPointer(ref this), Severity); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[34]))((ID3D12InfoQueue1*)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]))((ID3D12InfoQueue1*)Unsafe.AsPointer(ref this), ID); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[35]))((ID3D12InfoQueue1*)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]))((ID3D12InfoQueue1*)Unsafe.AsPointer(ref this), bMute); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[36]))((ID3D12InfoQueue1*)Unsafe.AsPointer(ref this), bMute); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(37)] + public Bool32 GetMuteDebugOutput() + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[37]))((ID3D12InfoQueue1*)Unsafe.AsPointer(ref this)); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[37]))((ID3D12InfoQueue1*)Unsafe.AsPointer(ref this)); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(38)] + public HResult RegisterMessageCallback(delegate* unmanaged[Stdcall] CallbackFunc, MessageCallbackFlags CallbackFilterFlags, void* pContext, uint* pCallbackCookie) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged, MessageCallbackFlags, void*, uint*, int>)(lpVtbl[38]))((ID3D12InfoQueue1*)Unsafe.AsPointer(ref this), CallbackFunc, CallbackFilterFlags, pContext, pCallbackCookie); +#else + return ((delegate* unmanaged[Stdcall], MessageCallbackFlags, void*, uint*, int>)(lpVtbl[38]))((ID3D12InfoQueue1*)Unsafe.AsPointer(ref this), CallbackFunc, CallbackFilterFlags, pContext, pCallbackCookie); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(39)] + public HResult UnregisterMessageCallback(uint CallbackCookie) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[39]))((ID3D12InfoQueue1*)Unsafe.AsPointer(ref this), CallbackCookie); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[39]))((ID3D12InfoQueue1*)Unsafe.AsPointer(ref this), CallbackCookie); +#endif + } + + public interface Interface : ID3D12InfoQueue.Interface + { + } +} + +/// +/// ID3D12SDKConfiguration +[Guid("e9eb5314-33aa-42b2-a718-d77f58b1f1c7")] +[NativeTypeName("struct ID3D12SDKConfiguration : IUnknown")] +[NativeInheritance("IUnknown")] +public unsafe partial struct ID3D12SDKConfiguration : ID3D12SDKConfiguration.Interface +{ + public static ref readonly Guid IID_ID3D12SDKConfiguration + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x14, 0x53, 0xEB, 0xE9, + 0xAA, 0x33, + 0xB2, 0x42, + 0xA7, + 0x18, + 0xD7, + 0x7F, + 0x58, + 0xB1, + 0xF1, + 0xC7 + }; + + 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_ID3D12SDKConfiguration)); + + 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 SetSDKVersion(uint SDKVersion, byte** SDKPath) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[3]))((ID3D12SDKConfiguration*)Unsafe.AsPointer(ref this), SDKVersion, SDKPath); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((ID3D12SDKConfiguration*)Unsafe.AsPointer(ref this), SDKVersion, SDKPath); +#endif + } + + public interface Interface : IUnknown.Interface + { + } +} + +/// +/// ID3D12GraphicsCommandList5 +[Guid("55050859-4024-474c-87f5-6472eaee44ea")] +[NativeTypeName("struct ID3D12GraphicsCommandList5 : ID3D12GraphicsCommandList4")] +[NativeInheritance("ID3D12GraphicsCommandList4")] +public unsafe partial struct ID3D12GraphicsCommandList5 : ID3D12GraphicsCommandList5.Interface +{ + public static ref readonly Guid IID_ID3D12GraphicsCommandList5 + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x59, 0x08, 0x05, 0x55, + 0x24, 0x40, + 0x4C, 0x47, + 0x87, + 0xF5, + 0x64, + 0x72, + 0xEA, + 0xEE, + 0x44, + 0xEA + }; + + 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_ID3D12GraphicsCommandList5)); + + 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 BeginRenderPass(uint NumRenderTargets, RenderPassRenderTargetDescription* pRenderTargets, RenderPassDepthStencilDescription* pDepthStencil, RenderPassFlags Flags) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[3]))((ID3D12GraphicsCommandList5*)Unsafe.AsPointer(ref this), NumRenderTargets, pRenderTargets, pDepthStencil, Flags); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((ID3D12GraphicsCommandList5*)Unsafe.AsPointer(ref this), NumRenderTargets, pRenderTargets, pDepthStencil, Flags); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public void EndRenderPass() + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[4]))((ID3D12GraphicsCommandList5*)Unsafe.AsPointer(ref this)); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((ID3D12GraphicsCommandList5*)Unsafe.AsPointer(ref this)); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(5)] + public void InitializeMetaCommand(ID3D12MetaCommand* pMetaCommand, void* pInitializationParametersData, nuint InitializationParametersDataSizeInBytes) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[5]))((ID3D12GraphicsCommandList5*)Unsafe.AsPointer(ref this), pMetaCommand, pInitializationParametersData, InitializationParametersDataSizeInBytes); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((ID3D12GraphicsCommandList5*)Unsafe.AsPointer(ref this), pMetaCommand, pInitializationParametersData, InitializationParametersDataSizeInBytes); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(6)] + public void ExecuteMetaCommand(ID3D12MetaCommand* pMetaCommand, void* pExecutionParametersData, nuint ExecutionParametersDataSizeInBytes) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[6]))((ID3D12GraphicsCommandList5*)Unsafe.AsPointer(ref this), pMetaCommand, pExecutionParametersData, ExecutionParametersDataSizeInBytes); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((ID3D12GraphicsCommandList5*)Unsafe.AsPointer(ref this), pMetaCommand, pExecutionParametersData, ExecutionParametersDataSizeInBytes); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(7)] + public void BuildRaytracingAccelerationStructure(BuildRaytracingAccelerationStructureDescription* pDesc, uint NumPostbuildInfoDescs, RaytracingAccelerationStructurePostbuildInfoDescription* pPostbuildInfoDescs) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[7]))((ID3D12GraphicsCommandList5*)Unsafe.AsPointer(ref this), pDesc, NumPostbuildInfoDescs, pPostbuildInfoDescs); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((ID3D12GraphicsCommandList5*)Unsafe.AsPointer(ref this), pDesc, NumPostbuildInfoDescs, pPostbuildInfoDescs); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(8)] + public void EmitRaytracingAccelerationStructurePostbuildInfo(RaytracingAccelerationStructurePostbuildInfoDescription* pDesc, uint NumSourceAccelerationStructures, ulong* pSourceAccelerationStructureData) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[8]))((ID3D12GraphicsCommandList5*)Unsafe.AsPointer(ref this), pDesc, NumSourceAccelerationStructures, pSourceAccelerationStructureData); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[8]))((ID3D12GraphicsCommandList5*)Unsafe.AsPointer(ref this), pDesc, NumSourceAccelerationStructures, pSourceAccelerationStructureData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(9)] + public void CopyRaytracingAccelerationStructure(ulong DestAccelerationStructureData, ulong SourceAccelerationStructureData, RaytracingAccelerationStructureCopyMode Mode) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[9]))((ID3D12GraphicsCommandList5*)Unsafe.AsPointer(ref this), DestAccelerationStructureData, SourceAccelerationStructureData, Mode); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[9]))((ID3D12GraphicsCommandList5*)Unsafe.AsPointer(ref this), DestAccelerationStructureData, SourceAccelerationStructureData, Mode); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(10)] + public void SetPipelineState1(ID3D12StateObject* pStateObject) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[10]))((ID3D12GraphicsCommandList5*)Unsafe.AsPointer(ref this), pStateObject); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[10]))((ID3D12GraphicsCommandList5*)Unsafe.AsPointer(ref this), pStateObject); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(11)] + public void DispatchRays(DispatchRaysDescription* pDesc) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[11]))((ID3D12GraphicsCommandList5*)Unsafe.AsPointer(ref this), pDesc); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[11]))((ID3D12GraphicsCommandList5*)Unsafe.AsPointer(ref this), pDesc); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(12)] + public void SetProtectedResourceSession(ID3D12ProtectedResourceSession* pProtectedResourceSession) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[12]))((ID3D12GraphicsCommandList5*)Unsafe.AsPointer(ref this), pProtectedResourceSession); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[12]))((ID3D12GraphicsCommandList5*)Unsafe.AsPointer(ref this), pProtectedResourceSession); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(13)] + public void WriteBufferImmediate(uint Count, WritebufferimmediateParameter* pParams, WritebufferimmediateMode* pModes) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[13]))((ID3D12GraphicsCommandList5*)Unsafe.AsPointer(ref this), Count, pParams, pModes); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[13]))((ID3D12GraphicsCommandList5*)Unsafe.AsPointer(ref this), Count, pParams, pModes); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(14)] + public void AtomicCopyBufferUINT(ID3D12Resource* pDstBuffer, ulong DstOffset, ID3D12Resource* pSrcBuffer, ulong SrcOffset, uint Dependencies, ID3D12Resource* ppDependentResources, SubresourceRangeUint64* pDependentSubresourceRanges) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[14]))((ID3D12GraphicsCommandList5*)Unsafe.AsPointer(ref this), pDstBuffer, DstOffset, pSrcBuffer, SrcOffset, Dependencies, ppDependentResources, pDependentSubresourceRanges); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[14]))((ID3D12GraphicsCommandList5*)Unsafe.AsPointer(ref this), pDstBuffer, DstOffset, pSrcBuffer, SrcOffset, Dependencies, ppDependentResources, pDependentSubresourceRanges); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(15)] + public void AtomicCopyBufferUINT64(ID3D12Resource* pDstBuffer, ulong DstOffset, ID3D12Resource* pSrcBuffer, ulong SrcOffset, uint Dependencies, ID3D12Resource* ppDependentResources, SubresourceRangeUint64* pDependentSubresourceRanges) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[15]))((ID3D12GraphicsCommandList5*)Unsafe.AsPointer(ref this), pDstBuffer, DstOffset, pSrcBuffer, SrcOffset, Dependencies, ppDependentResources, pDependentSubresourceRanges); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[15]))((ID3D12GraphicsCommandList5*)Unsafe.AsPointer(ref this), pDstBuffer, DstOffset, pSrcBuffer, SrcOffset, Dependencies, ppDependentResources, pDependentSubresourceRanges); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(16)] + public void OMSetDepthBounds(float Min, float Max) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[16]))((ID3D12GraphicsCommandList5*)Unsafe.AsPointer(ref this), Min, Max); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[16]))((ID3D12GraphicsCommandList5*)Unsafe.AsPointer(ref this), Min, Max); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(17)] + public void SetSamplePositions(uint NumSamplesPerPixel, uint NumPixels, SamplePosition* pSamplePositions) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[17]))((ID3D12GraphicsCommandList5*)Unsafe.AsPointer(ref this), NumSamplesPerPixel, NumPixels, pSamplePositions); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[17]))((ID3D12GraphicsCommandList5*)Unsafe.AsPointer(ref this), NumSamplesPerPixel, NumPixels, pSamplePositions); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(18)] + public void ResolveSubresourceRegion(ID3D12Resource* pDstResource, uint DstSubresource, uint DstX, uint DstY, ID3D12Resource* pSrcResource, uint SrcSubresource, RawRect* pSrcRect, Graphics.Dxgi.Common.Format Format, ResolveMode ResolveMode) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[18]))((ID3D12GraphicsCommandList5*)Unsafe.AsPointer(ref this), pDstResource, DstSubresource, DstX, DstY, pSrcResource, SrcSubresource, pSrcRect, Format, ResolveMode); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[18]))((ID3D12GraphicsCommandList5*)Unsafe.AsPointer(ref this), pDstResource, DstSubresource, DstX, DstY, pSrcResource, SrcSubresource, pSrcRect, Format, ResolveMode); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(19)] + public void SetViewInstanceMask(uint Mask) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[19]))((ID3D12GraphicsCommandList5*)Unsafe.AsPointer(ref this), Mask); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[19]))((ID3D12GraphicsCommandList5*)Unsafe.AsPointer(ref this), Mask); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(20)] + public HResult Close() + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[20]))((ID3D12GraphicsCommandList5*)Unsafe.AsPointer(ref this)); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[20]))((ID3D12GraphicsCommandList5*)Unsafe.AsPointer(ref this)); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(21)] + public HResult Reset(ID3D12CommandAllocator* pAllocator, ID3D12PipelineState* pInitialState) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[21]))((ID3D12GraphicsCommandList5*)Unsafe.AsPointer(ref this), pAllocator, pInitialState); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[21]))((ID3D12GraphicsCommandList5*)Unsafe.AsPointer(ref this), pAllocator, pInitialState); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(22)] + public void ClearState(ID3D12PipelineState* pPipelineState) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[22]))((ID3D12GraphicsCommandList5*)Unsafe.AsPointer(ref this), pPipelineState); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[22]))((ID3D12GraphicsCommandList5*)Unsafe.AsPointer(ref this), pPipelineState); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(23)] + public void DrawInstanced(uint VertexCountPerInstance, uint InstanceCount, uint StartVertexLocation, uint StartInstanceLocation) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[23]))((ID3D12GraphicsCommandList5*)Unsafe.AsPointer(ref this), VertexCountPerInstance, InstanceCount, StartVertexLocation, StartInstanceLocation); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[23]))((ID3D12GraphicsCommandList5*)Unsafe.AsPointer(ref this), VertexCountPerInstance, InstanceCount, StartVertexLocation, StartInstanceLocation); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(24)] + public void DrawIndexedInstanced(uint IndexCountPerInstance, uint InstanceCount, uint StartIndexLocation, int BaseVertexLocation, uint StartInstanceLocation) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[24]))((ID3D12GraphicsCommandList5*)Unsafe.AsPointer(ref this), IndexCountPerInstance, InstanceCount, StartIndexLocation, BaseVertexLocation, StartInstanceLocation); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[24]))((ID3D12GraphicsCommandList5*)Unsafe.AsPointer(ref this), IndexCountPerInstance, InstanceCount, StartIndexLocation, BaseVertexLocation, StartInstanceLocation); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(25)] + public void Dispatch(uint ThreadGroupCountX, uint ThreadGroupCountY, uint ThreadGroupCountZ) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[25]))((ID3D12GraphicsCommandList5*)Unsafe.AsPointer(ref this), ThreadGroupCountX, ThreadGroupCountY, ThreadGroupCountZ); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[25]))((ID3D12GraphicsCommandList5*)Unsafe.AsPointer(ref this), ThreadGroupCountX, ThreadGroupCountY, ThreadGroupCountZ); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(26)] + public void CopyBufferRegion(ID3D12Resource* pDstBuffer, ulong DstOffset, ID3D12Resource* pSrcBuffer, ulong SrcOffset, ulong NumBytes) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[26]))((ID3D12GraphicsCommandList5*)Unsafe.AsPointer(ref this), pDstBuffer, DstOffset, pSrcBuffer, SrcOffset, NumBytes); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[26]))((ID3D12GraphicsCommandList5*)Unsafe.AsPointer(ref this), pDstBuffer, DstOffset, pSrcBuffer, SrcOffset, NumBytes); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(27)] + public void CopyTextureRegion(TextureCopyLocation* pDst, uint DstX, uint DstY, uint DstZ, TextureCopyLocation* pSrc, Box* pSrcBox) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[27]))((ID3D12GraphicsCommandList5*)Unsafe.AsPointer(ref this), pDst, DstX, DstY, DstZ, pSrc, pSrcBox); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[27]))((ID3D12GraphicsCommandList5*)Unsafe.AsPointer(ref this), pDst, DstX, DstY, DstZ, pSrc, pSrcBox); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(28)] + public void CopyResource(ID3D12Resource* pDstResource, ID3D12Resource* pSrcResource) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[28]))((ID3D12GraphicsCommandList5*)Unsafe.AsPointer(ref this), pDstResource, pSrcResource); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[28]))((ID3D12GraphicsCommandList5*)Unsafe.AsPointer(ref this), pDstResource, pSrcResource); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(29)] + public void CopyTiles(ID3D12Resource* pTiledResource, TiledResourceCoordinate* pTileRegionStartCoordinate, TileRegionSize* pTileRegionSize, ID3D12Resource* pBuffer, ulong BufferStartOffsetInBytes, TileCopyFlags Flags) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[29]))((ID3D12GraphicsCommandList5*)Unsafe.AsPointer(ref this), pTiledResource, pTileRegionStartCoordinate, pTileRegionSize, pBuffer, BufferStartOffsetInBytes, Flags); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[29]))((ID3D12GraphicsCommandList5*)Unsafe.AsPointer(ref this), pTiledResource, pTileRegionStartCoordinate, pTileRegionSize, pBuffer, BufferStartOffsetInBytes, Flags); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(30)] + public void ResolveSubresource(ID3D12Resource* pDstResource, uint DstSubresource, ID3D12Resource* pSrcResource, uint SrcSubresource, Graphics.Dxgi.Common.Format Format) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[30]))((ID3D12GraphicsCommandList5*)Unsafe.AsPointer(ref this), pDstResource, DstSubresource, pSrcResource, SrcSubresource, Format); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[30]))((ID3D12GraphicsCommandList5*)Unsafe.AsPointer(ref this), pDstResource, DstSubresource, pSrcResource, SrcSubresource, Format); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(31)] + public void IASetPrimitiveTopology(Graphics.Direct3D.PrimitiveTopology PrimitiveTopology) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[31]))((ID3D12GraphicsCommandList5*)Unsafe.AsPointer(ref this), PrimitiveTopology); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[31]))((ID3D12GraphicsCommandList5*)Unsafe.AsPointer(ref this), PrimitiveTopology); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(32)] + public void RSSetViewports(uint NumViewports, Viewport* pViewports) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[32]))((ID3D12GraphicsCommandList5*)Unsafe.AsPointer(ref this), NumViewports, pViewports); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[32]))((ID3D12GraphicsCommandList5*)Unsafe.AsPointer(ref this), NumViewports, pViewports); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(33)] + public void RSSetScissorRects(uint NumRects, RawRect* pRects) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[33]))((ID3D12GraphicsCommandList5*)Unsafe.AsPointer(ref this), NumRects, pRects); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[33]))((ID3D12GraphicsCommandList5*)Unsafe.AsPointer(ref this), NumRects, pRects); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(34)] + public void OMSetBlendFactor(float* BlendFactor) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[34]))((ID3D12GraphicsCommandList5*)Unsafe.AsPointer(ref this), BlendFactor); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[34]))((ID3D12GraphicsCommandList5*)Unsafe.AsPointer(ref this), BlendFactor); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(35)] + public void OMSetStencilRef(uint StencilRef) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[35]))((ID3D12GraphicsCommandList5*)Unsafe.AsPointer(ref this), StencilRef); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[35]))((ID3D12GraphicsCommandList5*)Unsafe.AsPointer(ref this), StencilRef); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(36)] + public void SetPipelineState(ID3D12PipelineState* pPipelineState) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[36]))((ID3D12GraphicsCommandList5*)Unsafe.AsPointer(ref this), pPipelineState); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[36]))((ID3D12GraphicsCommandList5*)Unsafe.AsPointer(ref this), pPipelineState); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(37)] + public void ResourceBarrier(uint NumBarriers, ResourceBarrier* pBarriers) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[37]))((ID3D12GraphicsCommandList5*)Unsafe.AsPointer(ref this), NumBarriers, pBarriers); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[37]))((ID3D12GraphicsCommandList5*)Unsafe.AsPointer(ref this), NumBarriers, pBarriers); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(38)] + public void ExecuteBundle(ID3D12GraphicsCommandList* pCommandList) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[38]))((ID3D12GraphicsCommandList5*)Unsafe.AsPointer(ref this), pCommandList); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[38]))((ID3D12GraphicsCommandList5*)Unsafe.AsPointer(ref this), pCommandList); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(39)] + public void SetDescriptorHeaps(uint NumDescriptorHeaps, ID3D12DescriptorHeap* ppDescriptorHeaps) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[39]))((ID3D12GraphicsCommandList5*)Unsafe.AsPointer(ref this), NumDescriptorHeaps, ppDescriptorHeaps); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[39]))((ID3D12GraphicsCommandList5*)Unsafe.AsPointer(ref this), NumDescriptorHeaps, ppDescriptorHeaps); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(40)] + public void SetComputeRootSignature(ID3D12RootSignature* pRootSignature) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[40]))((ID3D12GraphicsCommandList5*)Unsafe.AsPointer(ref this), pRootSignature); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[40]))((ID3D12GraphicsCommandList5*)Unsafe.AsPointer(ref this), pRootSignature); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(41)] + public void SetGraphicsRootSignature(ID3D12RootSignature* pRootSignature) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[41]))((ID3D12GraphicsCommandList5*)Unsafe.AsPointer(ref this), pRootSignature); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[41]))((ID3D12GraphicsCommandList5*)Unsafe.AsPointer(ref this), pRootSignature); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(42)] + public void SetComputeRootDescriptorTable(uint RootParameterIndex, GpuDescriptorHandle* BaseDescriptor) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[42]))((ID3D12GraphicsCommandList5*)Unsafe.AsPointer(ref this), RootParameterIndex, BaseDescriptor); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[42]))((ID3D12GraphicsCommandList5*)Unsafe.AsPointer(ref this), RootParameterIndex, BaseDescriptor); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(43)] + public void SetGraphicsRootDescriptorTable(uint RootParameterIndex, GpuDescriptorHandle* BaseDescriptor) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[43]))((ID3D12GraphicsCommandList5*)Unsafe.AsPointer(ref this), RootParameterIndex, BaseDescriptor); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[43]))((ID3D12GraphicsCommandList5*)Unsafe.AsPointer(ref this), RootParameterIndex, BaseDescriptor); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(44)] + public void SetComputeRoot32BitConstant(uint RootParameterIndex, uint SrcData, uint DestOffsetIn32BitValues) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[44]))((ID3D12GraphicsCommandList5*)Unsafe.AsPointer(ref this), RootParameterIndex, SrcData, DestOffsetIn32BitValues); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[44]))((ID3D12GraphicsCommandList5*)Unsafe.AsPointer(ref this), RootParameterIndex, SrcData, DestOffsetIn32BitValues); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(45)] + public void SetGraphicsRoot32BitConstant(uint RootParameterIndex, uint SrcData, uint DestOffsetIn32BitValues) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[45]))((ID3D12GraphicsCommandList5*)Unsafe.AsPointer(ref this), RootParameterIndex, SrcData, DestOffsetIn32BitValues); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[45]))((ID3D12GraphicsCommandList5*)Unsafe.AsPointer(ref this), RootParameterIndex, SrcData, DestOffsetIn32BitValues); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(46)] + public void SetComputeRoot32BitConstants(uint RootParameterIndex, uint Num32BitValuesToSet, void* pSrcData, uint DestOffsetIn32BitValues) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[46]))((ID3D12GraphicsCommandList5*)Unsafe.AsPointer(ref this), RootParameterIndex, Num32BitValuesToSet, pSrcData, DestOffsetIn32BitValues); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[46]))((ID3D12GraphicsCommandList5*)Unsafe.AsPointer(ref this), RootParameterIndex, Num32BitValuesToSet, pSrcData, DestOffsetIn32BitValues); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(47)] + public void SetGraphicsRoot32BitConstants(uint RootParameterIndex, uint Num32BitValuesToSet, void* pSrcData, uint DestOffsetIn32BitValues) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[47]))((ID3D12GraphicsCommandList5*)Unsafe.AsPointer(ref this), RootParameterIndex, Num32BitValuesToSet, pSrcData, DestOffsetIn32BitValues); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[47]))((ID3D12GraphicsCommandList5*)Unsafe.AsPointer(ref this), RootParameterIndex, Num32BitValuesToSet, pSrcData, DestOffsetIn32BitValues); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(48)] + public void SetComputeRootConstantBufferView(uint RootParameterIndex, ulong BufferLocation) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[48]))((ID3D12GraphicsCommandList5*)Unsafe.AsPointer(ref this), RootParameterIndex, BufferLocation); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[48]))((ID3D12GraphicsCommandList5*)Unsafe.AsPointer(ref this), RootParameterIndex, BufferLocation); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(49)] + public void SetGraphicsRootConstantBufferView(uint RootParameterIndex, ulong BufferLocation) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[49]))((ID3D12GraphicsCommandList5*)Unsafe.AsPointer(ref this), RootParameterIndex, BufferLocation); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[49]))((ID3D12GraphicsCommandList5*)Unsafe.AsPointer(ref this), RootParameterIndex, BufferLocation); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(50)] + public void SetComputeRootShaderResourceView(uint RootParameterIndex, ulong BufferLocation) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[50]))((ID3D12GraphicsCommandList5*)Unsafe.AsPointer(ref this), RootParameterIndex, BufferLocation); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[50]))((ID3D12GraphicsCommandList5*)Unsafe.AsPointer(ref this), RootParameterIndex, BufferLocation); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(51)] + public void SetGraphicsRootShaderResourceView(uint RootParameterIndex, ulong BufferLocation) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[51]))((ID3D12GraphicsCommandList5*)Unsafe.AsPointer(ref this), RootParameterIndex, BufferLocation); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[51]))((ID3D12GraphicsCommandList5*)Unsafe.AsPointer(ref this), RootParameterIndex, BufferLocation); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(52)] + public void SetComputeRootUnorderedAccessView(uint RootParameterIndex, ulong BufferLocation) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[52]))((ID3D12GraphicsCommandList5*)Unsafe.AsPointer(ref this), RootParameterIndex, BufferLocation); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[52]))((ID3D12GraphicsCommandList5*)Unsafe.AsPointer(ref this), RootParameterIndex, BufferLocation); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(53)] + public void SetGraphicsRootUnorderedAccessView(uint RootParameterIndex, ulong BufferLocation) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[53]))((ID3D12GraphicsCommandList5*)Unsafe.AsPointer(ref this), RootParameterIndex, BufferLocation); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[53]))((ID3D12GraphicsCommandList5*)Unsafe.AsPointer(ref this), RootParameterIndex, BufferLocation); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(54)] + public void IASetIndexBuffer(IndexBufferView* pView) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[54]))((ID3D12GraphicsCommandList5*)Unsafe.AsPointer(ref this), pView); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[54]))((ID3D12GraphicsCommandList5*)Unsafe.AsPointer(ref this), pView); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(55)] + public void IASetVertexBuffers(uint StartSlot, uint NumViews, VertexBufferView* pViews) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[55]))((ID3D12GraphicsCommandList5*)Unsafe.AsPointer(ref this), StartSlot, NumViews, pViews); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[55]))((ID3D12GraphicsCommandList5*)Unsafe.AsPointer(ref this), StartSlot, NumViews, pViews); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(56)] + public void SOSetTargets(uint StartSlot, uint NumViews, StreamOutputBufferView* pViews) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[56]))((ID3D12GraphicsCommandList5*)Unsafe.AsPointer(ref this), StartSlot, NumViews, pViews); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[56]))((ID3D12GraphicsCommandList5*)Unsafe.AsPointer(ref this), StartSlot, NumViews, pViews); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(57)] + public void OMSetRenderTargets(uint NumRenderTargetDescriptors, CpuDescriptorHandle* pRenderTargetDescriptors, Bool32 RTsSingleHandleToDescriptorRange, CpuDescriptorHandle* pDepthStencilDescriptor) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[57]))((ID3D12GraphicsCommandList5*)Unsafe.AsPointer(ref this), NumRenderTargetDescriptors, pRenderTargetDescriptors, RTsSingleHandleToDescriptorRange, pDepthStencilDescriptor); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[57]))((ID3D12GraphicsCommandList5*)Unsafe.AsPointer(ref this), NumRenderTargetDescriptors, pRenderTargetDescriptors, RTsSingleHandleToDescriptorRange, pDepthStencilDescriptor); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(58)] + public void ClearDepthStencilView(CpuDescriptorHandle* DepthStencilView, ClearFlags ClearFlags, float Depth, byte Stencil, uint NumRects, RawRect* pRects) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[58]))((ID3D12GraphicsCommandList5*)Unsafe.AsPointer(ref this), DepthStencilView, ClearFlags, Depth, Stencil, NumRects, pRects); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[58]))((ID3D12GraphicsCommandList5*)Unsafe.AsPointer(ref this), DepthStencilView, ClearFlags, Depth, Stencil, NumRects, pRects); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(59)] + public void ClearRenderTargetView(CpuDescriptorHandle* RenderTargetView, float* ColorRGBA, uint NumRects, RawRect* pRects) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[59]))((ID3D12GraphicsCommandList5*)Unsafe.AsPointer(ref this), RenderTargetView, ColorRGBA, NumRects, pRects); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[59]))((ID3D12GraphicsCommandList5*)Unsafe.AsPointer(ref this), RenderTargetView, ColorRGBA, NumRects, pRects); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(60)] + public void ClearUnorderedAccessViewUint(GpuDescriptorHandle* ViewGPUHandleInCurrentHeap, CpuDescriptorHandle* ViewCPUHandle, ID3D12Resource* pResource, uint* Values, uint NumRects, RawRect* pRects) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[60]))((ID3D12GraphicsCommandList5*)Unsafe.AsPointer(ref this), ViewGPUHandleInCurrentHeap, ViewCPUHandle, pResource, Values, NumRects, pRects); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[60]))((ID3D12GraphicsCommandList5*)Unsafe.AsPointer(ref this), ViewGPUHandleInCurrentHeap, ViewCPUHandle, pResource, Values, NumRects, pRects); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(61)] + public void ClearUnorderedAccessViewFloat(GpuDescriptorHandle* ViewGPUHandleInCurrentHeap, CpuDescriptorHandle* ViewCPUHandle, ID3D12Resource* pResource, float* Values, uint NumRects, RawRect* pRects) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[61]))((ID3D12GraphicsCommandList5*)Unsafe.AsPointer(ref this), ViewGPUHandleInCurrentHeap, ViewCPUHandle, pResource, Values, NumRects, pRects); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[61]))((ID3D12GraphicsCommandList5*)Unsafe.AsPointer(ref this), ViewGPUHandleInCurrentHeap, ViewCPUHandle, pResource, Values, NumRects, pRects); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(62)] + public void DiscardResource(ID3D12Resource* pResource, DiscardRegion* pRegion) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[62]))((ID3D12GraphicsCommandList5*)Unsafe.AsPointer(ref this), pResource, pRegion); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[62]))((ID3D12GraphicsCommandList5*)Unsafe.AsPointer(ref this), pResource, pRegion); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(63)] + public void BeginQuery(ID3D12QueryHeap* pQueryHeap, QueryType Type, uint Index) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[63]))((ID3D12GraphicsCommandList5*)Unsafe.AsPointer(ref this), pQueryHeap, Type, Index); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[63]))((ID3D12GraphicsCommandList5*)Unsafe.AsPointer(ref this), pQueryHeap, Type, Index); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(64)] + public void EndQuery(ID3D12QueryHeap* pQueryHeap, QueryType Type, uint Index) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[64]))((ID3D12GraphicsCommandList5*)Unsafe.AsPointer(ref this), pQueryHeap, Type, Index); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[64]))((ID3D12GraphicsCommandList5*)Unsafe.AsPointer(ref this), pQueryHeap, Type, Index); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(65)] + public void ResolveQueryData(ID3D12QueryHeap* pQueryHeap, QueryType Type, uint StartIndex, uint NumQueries, ID3D12Resource* pDestinationBuffer, ulong AlignedDestinationBufferOffset) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[65]))((ID3D12GraphicsCommandList5*)Unsafe.AsPointer(ref this), pQueryHeap, Type, StartIndex, NumQueries, pDestinationBuffer, AlignedDestinationBufferOffset); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[65]))((ID3D12GraphicsCommandList5*)Unsafe.AsPointer(ref this), pQueryHeap, Type, StartIndex, NumQueries, pDestinationBuffer, AlignedDestinationBufferOffset); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(66)] + public void SetPredication(ID3D12Resource* pBuffer, ulong AlignedBufferOffset, PredicationOp Operation) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[66]))((ID3D12GraphicsCommandList5*)Unsafe.AsPointer(ref this), pBuffer, AlignedBufferOffset, Operation); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[66]))((ID3D12GraphicsCommandList5*)Unsafe.AsPointer(ref this), pBuffer, AlignedBufferOffset, Operation); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(67)] + public void SetMarker(uint Metadata, void* pData, uint Size) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[67]))((ID3D12GraphicsCommandList5*)Unsafe.AsPointer(ref this), Metadata, pData, Size); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[67]))((ID3D12GraphicsCommandList5*)Unsafe.AsPointer(ref this), Metadata, pData, Size); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(68)] + public void BeginEvent(uint Metadata, void* pData, uint Size) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[68]))((ID3D12GraphicsCommandList5*)Unsafe.AsPointer(ref this), Metadata, pData, Size); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[68]))((ID3D12GraphicsCommandList5*)Unsafe.AsPointer(ref this), Metadata, pData, Size); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(69)] + public void EndEvent() + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[69]))((ID3D12GraphicsCommandList5*)Unsafe.AsPointer(ref this)); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[69]))((ID3D12GraphicsCommandList5*)Unsafe.AsPointer(ref this)); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(70)] + public void ExecuteIndirect(ID3D12CommandSignature* pCommandSignature, uint MaxCommandCount, ID3D12Resource* pArgumentBuffer, ulong ArgumentBufferOffset, ID3D12Resource* pCountBuffer, ulong CountBufferOffset) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[70]))((ID3D12GraphicsCommandList5*)Unsafe.AsPointer(ref this), pCommandSignature, MaxCommandCount, pArgumentBuffer, ArgumentBufferOffset, pCountBuffer, CountBufferOffset); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[70]))((ID3D12GraphicsCommandList5*)Unsafe.AsPointer(ref this), pCommandSignature, MaxCommandCount, pArgumentBuffer, ArgumentBufferOffset, pCountBuffer, CountBufferOffset); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(71)] + public new Graphics.Direct3D12.CommandListType GetType() + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[71]))((ID3D12GraphicsCommandList5*)Unsafe.AsPointer(ref this)); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[71]))((ID3D12GraphicsCommandList5*)Unsafe.AsPointer(ref this)); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(72)] + public HResult GetDevice(Guid* riid, void** ppvDevice) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[72]))((ID3D12GraphicsCommandList5*)Unsafe.AsPointer(ref this), riid, ppvDevice); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[72]))((ID3D12GraphicsCommandList5*)Unsafe.AsPointer(ref this), riid, ppvDevice); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(73)] + public HResult GetPrivateData(Guid* guid, uint* pDataSize, void* pData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[73]))((ID3D12GraphicsCommandList5*)Unsafe.AsPointer(ref this), guid, pDataSize, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[73]))((ID3D12GraphicsCommandList5*)Unsafe.AsPointer(ref this), guid, pDataSize, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(74)] + public HResult SetPrivateData(Guid* guid, uint DataSize, void* pData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[74]))((ID3D12GraphicsCommandList5*)Unsafe.AsPointer(ref this), guid, DataSize, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[74]))((ID3D12GraphicsCommandList5*)Unsafe.AsPointer(ref this), guid, DataSize, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(75)] + public HResult SetPrivateDataInterface(Guid* guid, IUnknown* pData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[75]))((ID3D12GraphicsCommandList5*)Unsafe.AsPointer(ref this), guid, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[75]))((ID3D12GraphicsCommandList5*)Unsafe.AsPointer(ref this), guid, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(76)] + public HResult SetName(char** Name) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[76]))((ID3D12GraphicsCommandList5*)Unsafe.AsPointer(ref this), Name); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[76]))((ID3D12GraphicsCommandList5*)Unsafe.AsPointer(ref this), Name); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(77)] + public void RSSetShadingRate(ShadingRate baseShadingRate, ShadingRateCombiner* combiners) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[77]))((ID3D12GraphicsCommandList5*)Unsafe.AsPointer(ref this), baseShadingRate, combiners); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[77]))((ID3D12GraphicsCommandList5*)Unsafe.AsPointer(ref this), baseShadingRate, combiners); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(78)] + public void RSSetShadingRateImage(ID3D12Resource* shadingRateImage) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[78]))((ID3D12GraphicsCommandList5*)Unsafe.AsPointer(ref this), shadingRateImage); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[78]))((ID3D12GraphicsCommandList5*)Unsafe.AsPointer(ref this), shadingRateImage); +#endif + } + + public interface Interface : ID3D12GraphicsCommandList4.Interface + { + } +} + +/// +/// ID3D12GraphicsCommandList6 +[Guid("c3827890-e548-4cfa-96cf-5689a9370f80")] +[NativeTypeName("struct ID3D12GraphicsCommandList6 : ID3D12GraphicsCommandList5")] +[NativeInheritance("ID3D12GraphicsCommandList5")] +public unsafe partial struct ID3D12GraphicsCommandList6 : ID3D12GraphicsCommandList6.Interface +{ + public static ref readonly Guid IID_ID3D12GraphicsCommandList6 + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x90, 0x78, 0x82, 0xC3, + 0x48, 0xE5, + 0xFA, 0x4C, + 0x96, + 0xCF, + 0x56, + 0x89, + 0xA9, + 0x37, + 0x0F, + 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_ID3D12GraphicsCommandList6)); + + 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 RSSetShadingRate(ShadingRate baseShadingRate, ShadingRateCombiner* combiners) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[3]))((ID3D12GraphicsCommandList6*)Unsafe.AsPointer(ref this), baseShadingRate, combiners); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((ID3D12GraphicsCommandList6*)Unsafe.AsPointer(ref this), baseShadingRate, combiners); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public void RSSetShadingRateImage(ID3D12Resource* shadingRateImage) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[4]))((ID3D12GraphicsCommandList6*)Unsafe.AsPointer(ref this), shadingRateImage); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((ID3D12GraphicsCommandList6*)Unsafe.AsPointer(ref this), shadingRateImage); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(5)] + public void BeginRenderPass(uint NumRenderTargets, RenderPassRenderTargetDescription* pRenderTargets, RenderPassDepthStencilDescription* pDepthStencil, RenderPassFlags Flags) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[5]))((ID3D12GraphicsCommandList6*)Unsafe.AsPointer(ref this), NumRenderTargets, pRenderTargets, pDepthStencil, Flags); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((ID3D12GraphicsCommandList6*)Unsafe.AsPointer(ref this), NumRenderTargets, pRenderTargets, pDepthStencil, Flags); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(6)] + public void EndRenderPass() + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[6]))((ID3D12GraphicsCommandList6*)Unsafe.AsPointer(ref this)); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((ID3D12GraphicsCommandList6*)Unsafe.AsPointer(ref this)); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(7)] + public void InitializeMetaCommand(ID3D12MetaCommand* pMetaCommand, void* pInitializationParametersData, nuint InitializationParametersDataSizeInBytes) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[7]))((ID3D12GraphicsCommandList6*)Unsafe.AsPointer(ref this), pMetaCommand, pInitializationParametersData, InitializationParametersDataSizeInBytes); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((ID3D12GraphicsCommandList6*)Unsafe.AsPointer(ref this), pMetaCommand, pInitializationParametersData, InitializationParametersDataSizeInBytes); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(8)] + public void ExecuteMetaCommand(ID3D12MetaCommand* pMetaCommand, void* pExecutionParametersData, nuint ExecutionParametersDataSizeInBytes) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[8]))((ID3D12GraphicsCommandList6*)Unsafe.AsPointer(ref this), pMetaCommand, pExecutionParametersData, ExecutionParametersDataSizeInBytes); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[8]))((ID3D12GraphicsCommandList6*)Unsafe.AsPointer(ref this), pMetaCommand, pExecutionParametersData, ExecutionParametersDataSizeInBytes); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(9)] + public void BuildRaytracingAccelerationStructure(BuildRaytracingAccelerationStructureDescription* pDesc, uint NumPostbuildInfoDescs, RaytracingAccelerationStructurePostbuildInfoDescription* pPostbuildInfoDescs) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[9]))((ID3D12GraphicsCommandList6*)Unsafe.AsPointer(ref this), pDesc, NumPostbuildInfoDescs, pPostbuildInfoDescs); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[9]))((ID3D12GraphicsCommandList6*)Unsafe.AsPointer(ref this), pDesc, NumPostbuildInfoDescs, pPostbuildInfoDescs); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(10)] + public void EmitRaytracingAccelerationStructurePostbuildInfo(RaytracingAccelerationStructurePostbuildInfoDescription* pDesc, uint NumSourceAccelerationStructures, ulong* pSourceAccelerationStructureData) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[10]))((ID3D12GraphicsCommandList6*)Unsafe.AsPointer(ref this), pDesc, NumSourceAccelerationStructures, pSourceAccelerationStructureData); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[10]))((ID3D12GraphicsCommandList6*)Unsafe.AsPointer(ref this), pDesc, NumSourceAccelerationStructures, pSourceAccelerationStructureData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(11)] + public void CopyRaytracingAccelerationStructure(ulong DestAccelerationStructureData, ulong SourceAccelerationStructureData, RaytracingAccelerationStructureCopyMode Mode) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[11]))((ID3D12GraphicsCommandList6*)Unsafe.AsPointer(ref this), DestAccelerationStructureData, SourceAccelerationStructureData, Mode); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[11]))((ID3D12GraphicsCommandList6*)Unsafe.AsPointer(ref this), DestAccelerationStructureData, SourceAccelerationStructureData, Mode); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(12)] + public void SetPipelineState1(ID3D12StateObject* pStateObject) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[12]))((ID3D12GraphicsCommandList6*)Unsafe.AsPointer(ref this), pStateObject); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[12]))((ID3D12GraphicsCommandList6*)Unsafe.AsPointer(ref this), pStateObject); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(13)] + public void DispatchRays(DispatchRaysDescription* pDesc) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[13]))((ID3D12GraphicsCommandList6*)Unsafe.AsPointer(ref this), pDesc); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[13]))((ID3D12GraphicsCommandList6*)Unsafe.AsPointer(ref this), pDesc); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(14)] + public void SetProtectedResourceSession(ID3D12ProtectedResourceSession* pProtectedResourceSession) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[14]))((ID3D12GraphicsCommandList6*)Unsafe.AsPointer(ref this), pProtectedResourceSession); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[14]))((ID3D12GraphicsCommandList6*)Unsafe.AsPointer(ref this), pProtectedResourceSession); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(15)] + public void WriteBufferImmediate(uint Count, WritebufferimmediateParameter* pParams, WritebufferimmediateMode* pModes) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[15]))((ID3D12GraphicsCommandList6*)Unsafe.AsPointer(ref this), Count, pParams, pModes); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[15]))((ID3D12GraphicsCommandList6*)Unsafe.AsPointer(ref this), Count, pParams, pModes); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(16)] + public void AtomicCopyBufferUINT(ID3D12Resource* pDstBuffer, ulong DstOffset, ID3D12Resource* pSrcBuffer, ulong SrcOffset, uint Dependencies, ID3D12Resource* ppDependentResources, SubresourceRangeUint64* pDependentSubresourceRanges) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[16]))((ID3D12GraphicsCommandList6*)Unsafe.AsPointer(ref this), pDstBuffer, DstOffset, pSrcBuffer, SrcOffset, Dependencies, ppDependentResources, pDependentSubresourceRanges); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[16]))((ID3D12GraphicsCommandList6*)Unsafe.AsPointer(ref this), pDstBuffer, DstOffset, pSrcBuffer, SrcOffset, Dependencies, ppDependentResources, pDependentSubresourceRanges); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(17)] + public void AtomicCopyBufferUINT64(ID3D12Resource* pDstBuffer, ulong DstOffset, ID3D12Resource* pSrcBuffer, ulong SrcOffset, uint Dependencies, ID3D12Resource* ppDependentResources, SubresourceRangeUint64* pDependentSubresourceRanges) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[17]))((ID3D12GraphicsCommandList6*)Unsafe.AsPointer(ref this), pDstBuffer, DstOffset, pSrcBuffer, SrcOffset, Dependencies, ppDependentResources, pDependentSubresourceRanges); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[17]))((ID3D12GraphicsCommandList6*)Unsafe.AsPointer(ref this), pDstBuffer, DstOffset, pSrcBuffer, SrcOffset, Dependencies, ppDependentResources, pDependentSubresourceRanges); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(18)] + public void OMSetDepthBounds(float Min, float Max) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[18]))((ID3D12GraphicsCommandList6*)Unsafe.AsPointer(ref this), Min, Max); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[18]))((ID3D12GraphicsCommandList6*)Unsafe.AsPointer(ref this), Min, Max); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(19)] + public void SetSamplePositions(uint NumSamplesPerPixel, uint NumPixels, SamplePosition* pSamplePositions) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[19]))((ID3D12GraphicsCommandList6*)Unsafe.AsPointer(ref this), NumSamplesPerPixel, NumPixels, pSamplePositions); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[19]))((ID3D12GraphicsCommandList6*)Unsafe.AsPointer(ref this), NumSamplesPerPixel, NumPixels, pSamplePositions); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(20)] + public void ResolveSubresourceRegion(ID3D12Resource* pDstResource, uint DstSubresource, uint DstX, uint DstY, ID3D12Resource* pSrcResource, uint SrcSubresource, RawRect* pSrcRect, Graphics.Dxgi.Common.Format Format, ResolveMode ResolveMode) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[20]))((ID3D12GraphicsCommandList6*)Unsafe.AsPointer(ref this), pDstResource, DstSubresource, DstX, DstY, pSrcResource, SrcSubresource, pSrcRect, Format, ResolveMode); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[20]))((ID3D12GraphicsCommandList6*)Unsafe.AsPointer(ref this), pDstResource, DstSubresource, DstX, DstY, pSrcResource, SrcSubresource, pSrcRect, Format, ResolveMode); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(21)] + public void SetViewInstanceMask(uint Mask) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[21]))((ID3D12GraphicsCommandList6*)Unsafe.AsPointer(ref this), Mask); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[21]))((ID3D12GraphicsCommandList6*)Unsafe.AsPointer(ref this), Mask); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(22)] + public HResult Close() + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[22]))((ID3D12GraphicsCommandList6*)Unsafe.AsPointer(ref this)); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[22]))((ID3D12GraphicsCommandList6*)Unsafe.AsPointer(ref this)); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(23)] + public HResult Reset(ID3D12CommandAllocator* pAllocator, ID3D12PipelineState* pInitialState) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[23]))((ID3D12GraphicsCommandList6*)Unsafe.AsPointer(ref this), pAllocator, pInitialState); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[23]))((ID3D12GraphicsCommandList6*)Unsafe.AsPointer(ref this), pAllocator, pInitialState); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(24)] + public void ClearState(ID3D12PipelineState* pPipelineState) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[24]))((ID3D12GraphicsCommandList6*)Unsafe.AsPointer(ref this), pPipelineState); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[24]))((ID3D12GraphicsCommandList6*)Unsafe.AsPointer(ref this), pPipelineState); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(25)] + public void DrawInstanced(uint VertexCountPerInstance, uint InstanceCount, uint StartVertexLocation, uint StartInstanceLocation) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[25]))((ID3D12GraphicsCommandList6*)Unsafe.AsPointer(ref this), VertexCountPerInstance, InstanceCount, StartVertexLocation, StartInstanceLocation); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[25]))((ID3D12GraphicsCommandList6*)Unsafe.AsPointer(ref this), VertexCountPerInstance, InstanceCount, StartVertexLocation, StartInstanceLocation); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(26)] + public void DrawIndexedInstanced(uint IndexCountPerInstance, uint InstanceCount, uint StartIndexLocation, int BaseVertexLocation, uint StartInstanceLocation) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[26]))((ID3D12GraphicsCommandList6*)Unsafe.AsPointer(ref this), IndexCountPerInstance, InstanceCount, StartIndexLocation, BaseVertexLocation, StartInstanceLocation); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[26]))((ID3D12GraphicsCommandList6*)Unsafe.AsPointer(ref this), IndexCountPerInstance, InstanceCount, StartIndexLocation, BaseVertexLocation, StartInstanceLocation); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(27)] + public void Dispatch(uint ThreadGroupCountX, uint ThreadGroupCountY, uint ThreadGroupCountZ) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[27]))((ID3D12GraphicsCommandList6*)Unsafe.AsPointer(ref this), ThreadGroupCountX, ThreadGroupCountY, ThreadGroupCountZ); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[27]))((ID3D12GraphicsCommandList6*)Unsafe.AsPointer(ref this), ThreadGroupCountX, ThreadGroupCountY, ThreadGroupCountZ); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(28)] + public void CopyBufferRegion(ID3D12Resource* pDstBuffer, ulong DstOffset, ID3D12Resource* pSrcBuffer, ulong SrcOffset, ulong NumBytes) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[28]))((ID3D12GraphicsCommandList6*)Unsafe.AsPointer(ref this), pDstBuffer, DstOffset, pSrcBuffer, SrcOffset, NumBytes); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[28]))((ID3D12GraphicsCommandList6*)Unsafe.AsPointer(ref this), pDstBuffer, DstOffset, pSrcBuffer, SrcOffset, NumBytes); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(29)] + public void CopyTextureRegion(TextureCopyLocation* pDst, uint DstX, uint DstY, uint DstZ, TextureCopyLocation* pSrc, Box* pSrcBox) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[29]))((ID3D12GraphicsCommandList6*)Unsafe.AsPointer(ref this), pDst, DstX, DstY, DstZ, pSrc, pSrcBox); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[29]))((ID3D12GraphicsCommandList6*)Unsafe.AsPointer(ref this), pDst, DstX, DstY, DstZ, pSrc, pSrcBox); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(30)] + public void CopyResource(ID3D12Resource* pDstResource, ID3D12Resource* pSrcResource) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[30]))((ID3D12GraphicsCommandList6*)Unsafe.AsPointer(ref this), pDstResource, pSrcResource); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[30]))((ID3D12GraphicsCommandList6*)Unsafe.AsPointer(ref this), pDstResource, pSrcResource); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(31)] + public void CopyTiles(ID3D12Resource* pTiledResource, TiledResourceCoordinate* pTileRegionStartCoordinate, TileRegionSize* pTileRegionSize, ID3D12Resource* pBuffer, ulong BufferStartOffsetInBytes, TileCopyFlags Flags) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[31]))((ID3D12GraphicsCommandList6*)Unsafe.AsPointer(ref this), pTiledResource, pTileRegionStartCoordinate, pTileRegionSize, pBuffer, BufferStartOffsetInBytes, Flags); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[31]))((ID3D12GraphicsCommandList6*)Unsafe.AsPointer(ref this), pTiledResource, pTileRegionStartCoordinate, pTileRegionSize, pBuffer, BufferStartOffsetInBytes, Flags); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(32)] + public void ResolveSubresource(ID3D12Resource* pDstResource, uint DstSubresource, ID3D12Resource* pSrcResource, uint SrcSubresource, Graphics.Dxgi.Common.Format Format) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[32]))((ID3D12GraphicsCommandList6*)Unsafe.AsPointer(ref this), pDstResource, DstSubresource, pSrcResource, SrcSubresource, Format); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[32]))((ID3D12GraphicsCommandList6*)Unsafe.AsPointer(ref this), pDstResource, DstSubresource, pSrcResource, SrcSubresource, Format); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(33)] + public void IASetPrimitiveTopology(Graphics.Direct3D.PrimitiveTopology PrimitiveTopology) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[33]))((ID3D12GraphicsCommandList6*)Unsafe.AsPointer(ref this), PrimitiveTopology); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[33]))((ID3D12GraphicsCommandList6*)Unsafe.AsPointer(ref this), PrimitiveTopology); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(34)] + public void RSSetViewports(uint NumViewports, Viewport* pViewports) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[34]))((ID3D12GraphicsCommandList6*)Unsafe.AsPointer(ref this), NumViewports, pViewports); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[34]))((ID3D12GraphicsCommandList6*)Unsafe.AsPointer(ref this), NumViewports, pViewports); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(35)] + public void RSSetScissorRects(uint NumRects, RawRect* pRects) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[35]))((ID3D12GraphicsCommandList6*)Unsafe.AsPointer(ref this), NumRects, pRects); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[35]))((ID3D12GraphicsCommandList6*)Unsafe.AsPointer(ref this), NumRects, pRects); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(36)] + public void OMSetBlendFactor(float* BlendFactor) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[36]))((ID3D12GraphicsCommandList6*)Unsafe.AsPointer(ref this), BlendFactor); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[36]))((ID3D12GraphicsCommandList6*)Unsafe.AsPointer(ref this), BlendFactor); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(37)] + public void OMSetStencilRef(uint StencilRef) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[37]))((ID3D12GraphicsCommandList6*)Unsafe.AsPointer(ref this), StencilRef); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[37]))((ID3D12GraphicsCommandList6*)Unsafe.AsPointer(ref this), StencilRef); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(38)] + public void SetPipelineState(ID3D12PipelineState* pPipelineState) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[38]))((ID3D12GraphicsCommandList6*)Unsafe.AsPointer(ref this), pPipelineState); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[38]))((ID3D12GraphicsCommandList6*)Unsafe.AsPointer(ref this), pPipelineState); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(39)] + public void ResourceBarrier(uint NumBarriers, ResourceBarrier* pBarriers) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[39]))((ID3D12GraphicsCommandList6*)Unsafe.AsPointer(ref this), NumBarriers, pBarriers); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[39]))((ID3D12GraphicsCommandList6*)Unsafe.AsPointer(ref this), NumBarriers, pBarriers); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(40)] + public void ExecuteBundle(ID3D12GraphicsCommandList* pCommandList) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[40]))((ID3D12GraphicsCommandList6*)Unsafe.AsPointer(ref this), pCommandList); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[40]))((ID3D12GraphicsCommandList6*)Unsafe.AsPointer(ref this), pCommandList); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(41)] + public void SetDescriptorHeaps(uint NumDescriptorHeaps, ID3D12DescriptorHeap* ppDescriptorHeaps) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[41]))((ID3D12GraphicsCommandList6*)Unsafe.AsPointer(ref this), NumDescriptorHeaps, ppDescriptorHeaps); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[41]))((ID3D12GraphicsCommandList6*)Unsafe.AsPointer(ref this), NumDescriptorHeaps, ppDescriptorHeaps); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(42)] + public void SetComputeRootSignature(ID3D12RootSignature* pRootSignature) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[42]))((ID3D12GraphicsCommandList6*)Unsafe.AsPointer(ref this), pRootSignature); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[42]))((ID3D12GraphicsCommandList6*)Unsafe.AsPointer(ref this), pRootSignature); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(43)] + public void SetGraphicsRootSignature(ID3D12RootSignature* pRootSignature) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[43]))((ID3D12GraphicsCommandList6*)Unsafe.AsPointer(ref this), pRootSignature); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[43]))((ID3D12GraphicsCommandList6*)Unsafe.AsPointer(ref this), pRootSignature); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(44)] + public void SetComputeRootDescriptorTable(uint RootParameterIndex, GpuDescriptorHandle* BaseDescriptor) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[44]))((ID3D12GraphicsCommandList6*)Unsafe.AsPointer(ref this), RootParameterIndex, BaseDescriptor); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[44]))((ID3D12GraphicsCommandList6*)Unsafe.AsPointer(ref this), RootParameterIndex, BaseDescriptor); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(45)] + public void SetGraphicsRootDescriptorTable(uint RootParameterIndex, GpuDescriptorHandle* BaseDescriptor) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[45]))((ID3D12GraphicsCommandList6*)Unsafe.AsPointer(ref this), RootParameterIndex, BaseDescriptor); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[45]))((ID3D12GraphicsCommandList6*)Unsafe.AsPointer(ref this), RootParameterIndex, BaseDescriptor); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(46)] + public void SetComputeRoot32BitConstant(uint RootParameterIndex, uint SrcData, uint DestOffsetIn32BitValues) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[46]))((ID3D12GraphicsCommandList6*)Unsafe.AsPointer(ref this), RootParameterIndex, SrcData, DestOffsetIn32BitValues); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[46]))((ID3D12GraphicsCommandList6*)Unsafe.AsPointer(ref this), RootParameterIndex, SrcData, DestOffsetIn32BitValues); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(47)] + public void SetGraphicsRoot32BitConstant(uint RootParameterIndex, uint SrcData, uint DestOffsetIn32BitValues) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[47]))((ID3D12GraphicsCommandList6*)Unsafe.AsPointer(ref this), RootParameterIndex, SrcData, DestOffsetIn32BitValues); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[47]))((ID3D12GraphicsCommandList6*)Unsafe.AsPointer(ref this), RootParameterIndex, SrcData, DestOffsetIn32BitValues); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(48)] + public void SetComputeRoot32BitConstants(uint RootParameterIndex, uint Num32BitValuesToSet, void* pSrcData, uint DestOffsetIn32BitValues) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[48]))((ID3D12GraphicsCommandList6*)Unsafe.AsPointer(ref this), RootParameterIndex, Num32BitValuesToSet, pSrcData, DestOffsetIn32BitValues); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[48]))((ID3D12GraphicsCommandList6*)Unsafe.AsPointer(ref this), RootParameterIndex, Num32BitValuesToSet, pSrcData, DestOffsetIn32BitValues); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(49)] + public void SetGraphicsRoot32BitConstants(uint RootParameterIndex, uint Num32BitValuesToSet, void* pSrcData, uint DestOffsetIn32BitValues) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[49]))((ID3D12GraphicsCommandList6*)Unsafe.AsPointer(ref this), RootParameterIndex, Num32BitValuesToSet, pSrcData, DestOffsetIn32BitValues); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[49]))((ID3D12GraphicsCommandList6*)Unsafe.AsPointer(ref this), RootParameterIndex, Num32BitValuesToSet, pSrcData, DestOffsetIn32BitValues); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(50)] + public void SetComputeRootConstantBufferView(uint RootParameterIndex, ulong BufferLocation) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[50]))((ID3D12GraphicsCommandList6*)Unsafe.AsPointer(ref this), RootParameterIndex, BufferLocation); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[50]))((ID3D12GraphicsCommandList6*)Unsafe.AsPointer(ref this), RootParameterIndex, BufferLocation); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(51)] + public void SetGraphicsRootConstantBufferView(uint RootParameterIndex, ulong BufferLocation) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[51]))((ID3D12GraphicsCommandList6*)Unsafe.AsPointer(ref this), RootParameterIndex, BufferLocation); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[51]))((ID3D12GraphicsCommandList6*)Unsafe.AsPointer(ref this), RootParameterIndex, BufferLocation); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(52)] + public void SetComputeRootShaderResourceView(uint RootParameterIndex, ulong BufferLocation) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[52]))((ID3D12GraphicsCommandList6*)Unsafe.AsPointer(ref this), RootParameterIndex, BufferLocation); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[52]))((ID3D12GraphicsCommandList6*)Unsafe.AsPointer(ref this), RootParameterIndex, BufferLocation); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(53)] + public void SetGraphicsRootShaderResourceView(uint RootParameterIndex, ulong BufferLocation) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[53]))((ID3D12GraphicsCommandList6*)Unsafe.AsPointer(ref this), RootParameterIndex, BufferLocation); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[53]))((ID3D12GraphicsCommandList6*)Unsafe.AsPointer(ref this), RootParameterIndex, BufferLocation); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(54)] + public void SetComputeRootUnorderedAccessView(uint RootParameterIndex, ulong BufferLocation) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[54]))((ID3D12GraphicsCommandList6*)Unsafe.AsPointer(ref this), RootParameterIndex, BufferLocation); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[54]))((ID3D12GraphicsCommandList6*)Unsafe.AsPointer(ref this), RootParameterIndex, BufferLocation); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(55)] + public void SetGraphicsRootUnorderedAccessView(uint RootParameterIndex, ulong BufferLocation) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[55]))((ID3D12GraphicsCommandList6*)Unsafe.AsPointer(ref this), RootParameterIndex, BufferLocation); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[55]))((ID3D12GraphicsCommandList6*)Unsafe.AsPointer(ref this), RootParameterIndex, BufferLocation); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(56)] + public void IASetIndexBuffer(IndexBufferView* pView) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[56]))((ID3D12GraphicsCommandList6*)Unsafe.AsPointer(ref this), pView); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[56]))((ID3D12GraphicsCommandList6*)Unsafe.AsPointer(ref this), pView); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(57)] + public void IASetVertexBuffers(uint StartSlot, uint NumViews, VertexBufferView* pViews) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[57]))((ID3D12GraphicsCommandList6*)Unsafe.AsPointer(ref this), StartSlot, NumViews, pViews); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[57]))((ID3D12GraphicsCommandList6*)Unsafe.AsPointer(ref this), StartSlot, NumViews, pViews); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(58)] + public void SOSetTargets(uint StartSlot, uint NumViews, StreamOutputBufferView* pViews) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[58]))((ID3D12GraphicsCommandList6*)Unsafe.AsPointer(ref this), StartSlot, NumViews, pViews); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[58]))((ID3D12GraphicsCommandList6*)Unsafe.AsPointer(ref this), StartSlot, NumViews, pViews); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(59)] + public void OMSetRenderTargets(uint NumRenderTargetDescriptors, CpuDescriptorHandle* pRenderTargetDescriptors, Bool32 RTsSingleHandleToDescriptorRange, CpuDescriptorHandle* pDepthStencilDescriptor) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[59]))((ID3D12GraphicsCommandList6*)Unsafe.AsPointer(ref this), NumRenderTargetDescriptors, pRenderTargetDescriptors, RTsSingleHandleToDescriptorRange, pDepthStencilDescriptor); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[59]))((ID3D12GraphicsCommandList6*)Unsafe.AsPointer(ref this), NumRenderTargetDescriptors, pRenderTargetDescriptors, RTsSingleHandleToDescriptorRange, pDepthStencilDescriptor); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(60)] + public void ClearDepthStencilView(CpuDescriptorHandle* DepthStencilView, ClearFlags ClearFlags, float Depth, byte Stencil, uint NumRects, RawRect* pRects) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[60]))((ID3D12GraphicsCommandList6*)Unsafe.AsPointer(ref this), DepthStencilView, ClearFlags, Depth, Stencil, NumRects, pRects); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[60]))((ID3D12GraphicsCommandList6*)Unsafe.AsPointer(ref this), DepthStencilView, ClearFlags, Depth, Stencil, NumRects, pRects); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(61)] + public void ClearRenderTargetView(CpuDescriptorHandle* RenderTargetView, float* ColorRGBA, uint NumRects, RawRect* pRects) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[61]))((ID3D12GraphicsCommandList6*)Unsafe.AsPointer(ref this), RenderTargetView, ColorRGBA, NumRects, pRects); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[61]))((ID3D12GraphicsCommandList6*)Unsafe.AsPointer(ref this), RenderTargetView, ColorRGBA, NumRects, pRects); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(62)] + public void ClearUnorderedAccessViewUint(GpuDescriptorHandle* ViewGPUHandleInCurrentHeap, CpuDescriptorHandle* ViewCPUHandle, ID3D12Resource* pResource, uint* Values, uint NumRects, RawRect* pRects) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[62]))((ID3D12GraphicsCommandList6*)Unsafe.AsPointer(ref this), ViewGPUHandleInCurrentHeap, ViewCPUHandle, pResource, Values, NumRects, pRects); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[62]))((ID3D12GraphicsCommandList6*)Unsafe.AsPointer(ref this), ViewGPUHandleInCurrentHeap, ViewCPUHandle, pResource, Values, NumRects, pRects); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(63)] + public void ClearUnorderedAccessViewFloat(GpuDescriptorHandle* ViewGPUHandleInCurrentHeap, CpuDescriptorHandle* ViewCPUHandle, ID3D12Resource* pResource, float* Values, uint NumRects, RawRect* pRects) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[63]))((ID3D12GraphicsCommandList6*)Unsafe.AsPointer(ref this), ViewGPUHandleInCurrentHeap, ViewCPUHandle, pResource, Values, NumRects, pRects); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[63]))((ID3D12GraphicsCommandList6*)Unsafe.AsPointer(ref this), ViewGPUHandleInCurrentHeap, ViewCPUHandle, pResource, Values, NumRects, pRects); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(64)] + public void DiscardResource(ID3D12Resource* pResource, DiscardRegion* pRegion) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[64]))((ID3D12GraphicsCommandList6*)Unsafe.AsPointer(ref this), pResource, pRegion); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[64]))((ID3D12GraphicsCommandList6*)Unsafe.AsPointer(ref this), pResource, pRegion); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(65)] + public void BeginQuery(ID3D12QueryHeap* pQueryHeap, QueryType Type, uint Index) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[65]))((ID3D12GraphicsCommandList6*)Unsafe.AsPointer(ref this), pQueryHeap, Type, Index); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[65]))((ID3D12GraphicsCommandList6*)Unsafe.AsPointer(ref this), pQueryHeap, Type, Index); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(66)] + public void EndQuery(ID3D12QueryHeap* pQueryHeap, QueryType Type, uint Index) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[66]))((ID3D12GraphicsCommandList6*)Unsafe.AsPointer(ref this), pQueryHeap, Type, Index); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[66]))((ID3D12GraphicsCommandList6*)Unsafe.AsPointer(ref this), pQueryHeap, Type, Index); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(67)] + public void ResolveQueryData(ID3D12QueryHeap* pQueryHeap, QueryType Type, uint StartIndex, uint NumQueries, ID3D12Resource* pDestinationBuffer, ulong AlignedDestinationBufferOffset) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[67]))((ID3D12GraphicsCommandList6*)Unsafe.AsPointer(ref this), pQueryHeap, Type, StartIndex, NumQueries, pDestinationBuffer, AlignedDestinationBufferOffset); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[67]))((ID3D12GraphicsCommandList6*)Unsafe.AsPointer(ref this), pQueryHeap, Type, StartIndex, NumQueries, pDestinationBuffer, AlignedDestinationBufferOffset); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(68)] + public void SetPredication(ID3D12Resource* pBuffer, ulong AlignedBufferOffset, PredicationOp Operation) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[68]))((ID3D12GraphicsCommandList6*)Unsafe.AsPointer(ref this), pBuffer, AlignedBufferOffset, Operation); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[68]))((ID3D12GraphicsCommandList6*)Unsafe.AsPointer(ref this), pBuffer, AlignedBufferOffset, Operation); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(69)] + public void SetMarker(uint Metadata, void* pData, uint Size) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[69]))((ID3D12GraphicsCommandList6*)Unsafe.AsPointer(ref this), Metadata, pData, Size); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[69]))((ID3D12GraphicsCommandList6*)Unsafe.AsPointer(ref this), Metadata, pData, Size); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(70)] + public void BeginEvent(uint Metadata, void* pData, uint Size) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[70]))((ID3D12GraphicsCommandList6*)Unsafe.AsPointer(ref this), Metadata, pData, Size); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[70]))((ID3D12GraphicsCommandList6*)Unsafe.AsPointer(ref this), Metadata, pData, Size); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(71)] + public void EndEvent() + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[71]))((ID3D12GraphicsCommandList6*)Unsafe.AsPointer(ref this)); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[71]))((ID3D12GraphicsCommandList6*)Unsafe.AsPointer(ref this)); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(72)] + public void ExecuteIndirect(ID3D12CommandSignature* pCommandSignature, uint MaxCommandCount, ID3D12Resource* pArgumentBuffer, ulong ArgumentBufferOffset, ID3D12Resource* pCountBuffer, ulong CountBufferOffset) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[72]))((ID3D12GraphicsCommandList6*)Unsafe.AsPointer(ref this), pCommandSignature, MaxCommandCount, pArgumentBuffer, ArgumentBufferOffset, pCountBuffer, CountBufferOffset); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[72]))((ID3D12GraphicsCommandList6*)Unsafe.AsPointer(ref this), pCommandSignature, MaxCommandCount, pArgumentBuffer, ArgumentBufferOffset, pCountBuffer, CountBufferOffset); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(73)] + public new Graphics.Direct3D12.CommandListType GetType() + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[73]))((ID3D12GraphicsCommandList6*)Unsafe.AsPointer(ref this)); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[73]))((ID3D12GraphicsCommandList6*)Unsafe.AsPointer(ref this)); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(74)] + public HResult GetDevice(Guid* riid, void** ppvDevice) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[74]))((ID3D12GraphicsCommandList6*)Unsafe.AsPointer(ref this), riid, ppvDevice); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[74]))((ID3D12GraphicsCommandList6*)Unsafe.AsPointer(ref this), riid, ppvDevice); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(75)] + public HResult GetPrivateData(Guid* guid, uint* pDataSize, void* pData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[75]))((ID3D12GraphicsCommandList6*)Unsafe.AsPointer(ref this), guid, pDataSize, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[75]))((ID3D12GraphicsCommandList6*)Unsafe.AsPointer(ref this), guid, pDataSize, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(76)] + public HResult SetPrivateData(Guid* guid, uint DataSize, void* pData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[76]))((ID3D12GraphicsCommandList6*)Unsafe.AsPointer(ref this), guid, DataSize, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[76]))((ID3D12GraphicsCommandList6*)Unsafe.AsPointer(ref this), guid, DataSize, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(77)] + public HResult SetPrivateDataInterface(Guid* guid, IUnknown* pData) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[77]))((ID3D12GraphicsCommandList6*)Unsafe.AsPointer(ref this), guid, pData); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[77]))((ID3D12GraphicsCommandList6*)Unsafe.AsPointer(ref this), guid, pData); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(78)] + public HResult SetName(char** Name) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[78]))((ID3D12GraphicsCommandList6*)Unsafe.AsPointer(ref this), Name); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[78]))((ID3D12GraphicsCommandList6*)Unsafe.AsPointer(ref this), Name); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(79)] + public void DispatchMesh(uint ThreadGroupCountX, uint ThreadGroupCountY, uint ThreadGroupCountZ) + { +#if NET6_0_OR_GREATER + ((delegate* unmanaged)(lpVtbl[79]))((ID3D12GraphicsCommandList6*)Unsafe.AsPointer(ref this), ThreadGroupCountX, ThreadGroupCountY, ThreadGroupCountZ); +#else + ((delegate* unmanaged[Stdcall])(lpVtbl[79]))((ID3D12GraphicsCommandList6*)Unsafe.AsPointer(ref this), ThreadGroupCountX, ThreadGroupCountY, ThreadGroupCountZ); +#endif + } + + public interface Interface : ID3D12GraphicsCommandList5.Interface + { + } +} + +/// +/// ID3D12ShaderReflectionType +[Guid("e913c351-783d-48ca-a1d1-4f306284ad56")] +public unsafe partial struct ID3D12ShaderReflectionType : ID3D12ShaderReflectionType.Interface +{ + public static ref readonly Guid IID_ID3D12ShaderReflectionType + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x51, 0xC3, 0x13, 0xE9, + 0x3D, 0x78, + 0xCA, 0x48, + 0xA1, + 0xD1, + 0x4F, + 0x30, + 0x62, + 0x84, + 0xAD, + 0x56 + }; + + 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_ID3D12ShaderReflectionType)); + + public void** lpVtbl; + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(0)] + public HResult GetDesc(ShaderTypeDescription* pDesc) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[0]))((ID3D12ShaderReflectionType*)Unsafe.AsPointer(ref this), pDesc); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[0]))((ID3D12ShaderReflectionType*)Unsafe.AsPointer(ref this), pDesc); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(1)] + public Graphics.Direct3D12.ID3D12ShaderReflectionType GetMemberTypeByIndex(uint Index) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[1]))((ID3D12ShaderReflectionType*)Unsafe.AsPointer(ref this), Index); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[1]))((ID3D12ShaderReflectionType*)Unsafe.AsPointer(ref this), Index); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(2)] + public Graphics.Direct3D12.ID3D12ShaderReflectionType GetMemberTypeByName(byte** Name) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[2]))((ID3D12ShaderReflectionType*)Unsafe.AsPointer(ref this), Name); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[2]))((ID3D12ShaderReflectionType*)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]))((ID3D12ShaderReflectionType*)Unsafe.AsPointer(ref this), Index); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((ID3D12ShaderReflectionType*)Unsafe.AsPointer(ref this), Index); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public HResult IsEqual(ID3D12ShaderReflectionType* pType) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[4]))((ID3D12ShaderReflectionType*)Unsafe.AsPointer(ref this), pType); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((ID3D12ShaderReflectionType*)Unsafe.AsPointer(ref this), pType); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(5)] + public Graphics.Direct3D12.ID3D12ShaderReflectionType GetSubType() + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[5]))((ID3D12ShaderReflectionType*)Unsafe.AsPointer(ref this)); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((ID3D12ShaderReflectionType*)Unsafe.AsPointer(ref this)); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(6)] + public Graphics.Direct3D12.ID3D12ShaderReflectionType GetBaseClass() + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[6]))((ID3D12ShaderReflectionType*)Unsafe.AsPointer(ref this)); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((ID3D12ShaderReflectionType*)Unsafe.AsPointer(ref this)); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(7)] + public uint GetNumInterfaces() + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[7]))((ID3D12ShaderReflectionType*)Unsafe.AsPointer(ref this)); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((ID3D12ShaderReflectionType*)Unsafe.AsPointer(ref this)); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(8)] + public Graphics.Direct3D12.ID3D12ShaderReflectionType GetInterfaceByIndex(uint uIndex) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[8]))((ID3D12ShaderReflectionType*)Unsafe.AsPointer(ref this), uIndex); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[8]))((ID3D12ShaderReflectionType*)Unsafe.AsPointer(ref this), uIndex); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(9)] + public HResult IsOfType(ID3D12ShaderReflectionType* pType) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[9]))((ID3D12ShaderReflectionType*)Unsafe.AsPointer(ref this), pType); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[9]))((ID3D12ShaderReflectionType*)Unsafe.AsPointer(ref this), pType); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(10)] + public HResult ImplementsInterface(ID3D12ShaderReflectionType* pBase) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[10]))((ID3D12ShaderReflectionType*)Unsafe.AsPointer(ref this), pBase); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[10]))((ID3D12ShaderReflectionType*)Unsafe.AsPointer(ref this), pBase); +#endif + } + + public interface Interface + { + } +} + +/// +/// ID3D12ShaderReflectionVariable +[Guid("8337a8a6-a216-444a-b2f4-314733a73aea")] +public unsafe partial struct ID3D12ShaderReflectionVariable : ID3D12ShaderReflectionVariable.Interface +{ + public static ref readonly Guid IID_ID3D12ShaderReflectionVariable + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0xA6, 0xA8, 0x37, 0x83, + 0x16, 0xA2, + 0x4A, 0x44, + 0xB2, + 0xF4, + 0x31, + 0x47, + 0x33, + 0xA7, + 0x3A, + 0xEA + }; + + 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_ID3D12ShaderReflectionVariable)); + + public void** lpVtbl; + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(0)] + public HResult GetDesc(ShaderVariableDescription* pDesc) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[0]))((ID3D12ShaderReflectionVariable*)Unsafe.AsPointer(ref this), pDesc); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[0]))((ID3D12ShaderReflectionVariable*)Unsafe.AsPointer(ref this), pDesc); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(1)] + public new Graphics.Direct3D12.ID3D12ShaderReflectionType GetType() + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[1]))((ID3D12ShaderReflectionVariable*)Unsafe.AsPointer(ref this)); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[1]))((ID3D12ShaderReflectionVariable*)Unsafe.AsPointer(ref this)); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(2)] + public Graphics.Direct3D12.ID3D12ShaderReflectionConstantBuffer GetBuffer() + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[2]))((ID3D12ShaderReflectionVariable*)Unsafe.AsPointer(ref this)); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[2]))((ID3D12ShaderReflectionVariable*)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]))((ID3D12ShaderReflectionVariable*)Unsafe.AsPointer(ref this), uArrayIndex); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((ID3D12ShaderReflectionVariable*)Unsafe.AsPointer(ref this), uArrayIndex); +#endif + } + + public interface Interface + { + } +} + +/// +/// ID3D12ShaderReflectionConstantBuffer +[Guid("c59598b4-48b3-4869-b9b1-b1618b14a8b7")] +public unsafe partial struct ID3D12ShaderReflectionConstantBuffer : ID3D12ShaderReflectionConstantBuffer.Interface +{ + public static ref readonly Guid IID_ID3D12ShaderReflectionConstantBuffer + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0xB4, 0x98, 0x95, 0xC5, + 0xB3, 0x48, + 0x69, 0x48, + 0xB9, + 0xB1, + 0xB1, + 0x61, + 0x8B, + 0x14, + 0xA8, + 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_ID3D12ShaderReflectionConstantBuffer)); + + public void** lpVtbl; + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(0)] + public HResult GetDesc(ShaderBufferDescription* pDesc) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[0]))((ID3D12ShaderReflectionConstantBuffer*)Unsafe.AsPointer(ref this), pDesc); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[0]))((ID3D12ShaderReflectionConstantBuffer*)Unsafe.AsPointer(ref this), pDesc); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(1)] + public Graphics.Direct3D12.ID3D12ShaderReflectionVariable GetVariableByIndex(uint Index) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[1]))((ID3D12ShaderReflectionConstantBuffer*)Unsafe.AsPointer(ref this), Index); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[1]))((ID3D12ShaderReflectionConstantBuffer*)Unsafe.AsPointer(ref this), Index); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(2)] + public Graphics.Direct3D12.ID3D12ShaderReflectionVariable GetVariableByName(byte** Name) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[2]))((ID3D12ShaderReflectionConstantBuffer*)Unsafe.AsPointer(ref this), Name); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[2]))((ID3D12ShaderReflectionConstantBuffer*)Unsafe.AsPointer(ref this), Name); +#endif + } + + public interface Interface + { + } +} + +/// +/// ID3D12ShaderReflection +[Guid("5a58797d-a72c-478d-8ba2-efc6b0efe88e")] +[NativeTypeName("struct ID3D12ShaderReflection : IUnknown")] +[NativeInheritance("IUnknown")] +public unsafe partial struct ID3D12ShaderReflection : ID3D12ShaderReflection.Interface +{ + public static ref readonly Guid IID_ID3D12ShaderReflection + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x7D, 0x79, 0x58, 0x5A, + 0x2C, 0xA7, + 0x8D, 0x47, + 0x8B, + 0xA2, + 0xEF, + 0xC6, + 0xB0, + 0xEF, + 0xE8, + 0x8E + }; + + 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_ID3D12ShaderReflection)); + + 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]))((ID3D12ShaderReflection*)Unsafe.AsPointer(ref this), pDesc); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((ID3D12ShaderReflection*)Unsafe.AsPointer(ref this), pDesc); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public Graphics.Direct3D12.ID3D12ShaderReflectionConstantBuffer GetConstantBufferByIndex(uint Index) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[4]))((ID3D12ShaderReflection*)Unsafe.AsPointer(ref this), Index); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((ID3D12ShaderReflection*)Unsafe.AsPointer(ref this), Index); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(5)] + public Graphics.Direct3D12.ID3D12ShaderReflectionConstantBuffer GetConstantBufferByName(byte** Name) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[5]))((ID3D12ShaderReflection*)Unsafe.AsPointer(ref this), Name); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((ID3D12ShaderReflection*)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]))((ID3D12ShaderReflection*)Unsafe.AsPointer(ref this), ResourceIndex, pDesc); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((ID3D12ShaderReflection*)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]))((ID3D12ShaderReflection*)Unsafe.AsPointer(ref this), ParameterIndex, pDesc); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((ID3D12ShaderReflection*)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]))((ID3D12ShaderReflection*)Unsafe.AsPointer(ref this), ParameterIndex, pDesc); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[8]))((ID3D12ShaderReflection*)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]))((ID3D12ShaderReflection*)Unsafe.AsPointer(ref this), ParameterIndex, pDesc); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[9]))((ID3D12ShaderReflection*)Unsafe.AsPointer(ref this), ParameterIndex, pDesc); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(10)] + public Graphics.Direct3D12.ID3D12ShaderReflectionVariable GetVariableByName(byte** Name) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[10]))((ID3D12ShaderReflection*)Unsafe.AsPointer(ref this), Name); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[10]))((ID3D12ShaderReflection*)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]))((ID3D12ShaderReflection*)Unsafe.AsPointer(ref this), Name, pDesc); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[11]))((ID3D12ShaderReflection*)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]))((ID3D12ShaderReflection*)Unsafe.AsPointer(ref this)); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[12]))((ID3D12ShaderReflection*)Unsafe.AsPointer(ref this)); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(13)] + public uint GetMovcInstructionCount() + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[13]))((ID3D12ShaderReflection*)Unsafe.AsPointer(ref this)); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[13]))((ID3D12ShaderReflection*)Unsafe.AsPointer(ref this)); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(14)] + public uint GetConversionInstructionCount() + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[14]))((ID3D12ShaderReflection*)Unsafe.AsPointer(ref this)); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[14]))((ID3D12ShaderReflection*)Unsafe.AsPointer(ref this)); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(15)] + public uint GetBitwiseInstructionCount() + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[15]))((ID3D12ShaderReflection*)Unsafe.AsPointer(ref this)); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[15]))((ID3D12ShaderReflection*)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]))((ID3D12ShaderReflection*)Unsafe.AsPointer(ref this)); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[16]))((ID3D12ShaderReflection*)Unsafe.AsPointer(ref this)); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(17)] + public Bool32 IsSampleFrequencyShader() + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[17]))((ID3D12ShaderReflection*)Unsafe.AsPointer(ref this)); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[17]))((ID3D12ShaderReflection*)Unsafe.AsPointer(ref this)); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(18)] + public uint GetNumInterfaceSlots() + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[18]))((ID3D12ShaderReflection*)Unsafe.AsPointer(ref this)); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[18]))((ID3D12ShaderReflection*)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]))((ID3D12ShaderReflection*)Unsafe.AsPointer(ref this), pLevel); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[19]))((ID3D12ShaderReflection*)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]))((ID3D12ShaderReflection*)Unsafe.AsPointer(ref this), pSizeX, pSizeY, pSizeZ); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[20]))((ID3D12ShaderReflection*)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]))((ID3D12ShaderReflection*)Unsafe.AsPointer(ref this)); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[21]))((ID3D12ShaderReflection*)Unsafe.AsPointer(ref this)); +#endif + } + + public interface Interface : IUnknown.Interface + { + } +} + +/// +/// ID3D12LibraryReflection +[Guid("8e349d19-54db-4a56-9dc9-119d87bdb804")] +[NativeTypeName("struct ID3D12LibraryReflection : IUnknown")] +[NativeInheritance("IUnknown")] +public unsafe partial struct ID3D12LibraryReflection : ID3D12LibraryReflection.Interface +{ + public static ref readonly Guid IID_ID3D12LibraryReflection + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x19, 0x9D, 0x34, 0x8E, + 0xDB, 0x54, + 0x56, 0x4A, + 0x9D, + 0xC9, + 0x11, + 0x9D, + 0x87, + 0xBD, + 0xB8, + 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_ID3D12LibraryReflection)); + + 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]))((ID3D12LibraryReflection*)Unsafe.AsPointer(ref this), pDesc); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((ID3D12LibraryReflection*)Unsafe.AsPointer(ref this), pDesc); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public Graphics.Direct3D12.ID3D12FunctionReflection GetFunctionByIndex(int FunctionIndex) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[4]))((ID3D12LibraryReflection*)Unsafe.AsPointer(ref this), FunctionIndex); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((ID3D12LibraryReflection*)Unsafe.AsPointer(ref this), FunctionIndex); +#endif + } + + public interface Interface : IUnknown.Interface + { + } +} + +/// +/// ID3D12FunctionReflection +[Guid("1108795c-2772-4ba9-b2a8-d464dc7e2799")] +public unsafe partial struct ID3D12FunctionReflection : ID3D12FunctionReflection.Interface +{ + public static ref readonly Guid IID_ID3D12FunctionReflection + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x5C, 0x79, 0x08, 0x11, + 0x72, 0x27, + 0xA9, 0x4B, + 0xB2, + 0xA8, + 0xD4, + 0x64, + 0xDC, + 0x7E, + 0x27, + 0x99 + }; + + 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_ID3D12FunctionReflection)); + + public void** lpVtbl; + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(0)] + public HResult GetDesc(FunctionDescription* pDesc) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[0]))((ID3D12FunctionReflection*)Unsafe.AsPointer(ref this), pDesc); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[0]))((ID3D12FunctionReflection*)Unsafe.AsPointer(ref this), pDesc); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(1)] + public Graphics.Direct3D12.ID3D12ShaderReflectionConstantBuffer GetConstantBufferByIndex(uint BufferIndex) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[1]))((ID3D12FunctionReflection*)Unsafe.AsPointer(ref this), BufferIndex); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[1]))((ID3D12FunctionReflection*)Unsafe.AsPointer(ref this), BufferIndex); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(2)] + public Graphics.Direct3D12.ID3D12ShaderReflectionConstantBuffer GetConstantBufferByName(byte** Name) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[2]))((ID3D12FunctionReflection*)Unsafe.AsPointer(ref this), Name); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[2]))((ID3D12FunctionReflection*)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]))((ID3D12FunctionReflection*)Unsafe.AsPointer(ref this), ResourceIndex, pDesc); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((ID3D12FunctionReflection*)Unsafe.AsPointer(ref this), ResourceIndex, pDesc); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public Graphics.Direct3D12.ID3D12ShaderReflectionVariable GetVariableByName(byte** Name) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[4]))((ID3D12FunctionReflection*)Unsafe.AsPointer(ref this), Name); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((ID3D12FunctionReflection*)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]))((ID3D12FunctionReflection*)Unsafe.AsPointer(ref this), Name, pDesc); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((ID3D12FunctionReflection*)Unsafe.AsPointer(ref this), Name, pDesc); +#endif + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(6)] + public Graphics.Direct3D12.ID3D12FunctionParameterReflection GetFunctionParameter(int ParameterIndex) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[6]))((ID3D12FunctionReflection*)Unsafe.AsPointer(ref this), ParameterIndex); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((ID3D12FunctionReflection*)Unsafe.AsPointer(ref this), ParameterIndex); +#endif + } + + public interface Interface + { + } +} + +/// +/// ID3D12FunctionParameterReflection +[Guid("ec25f42d-7006-4f2b-b33e-02cc3375733f")] +public unsafe partial struct ID3D12FunctionParameterReflection : ID3D12FunctionParameterReflection.Interface +{ + public static ref readonly Guid IID_ID3D12FunctionParameterReflection + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x2D, 0xF4, 0x25, 0xEC, + 0x06, 0x70, + 0x2B, 0x4F, + 0xB3, + 0x3E, + 0x02, + 0xCC, + 0x33, + 0x75, + 0x73, + 0x3F + }; + + 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_ID3D12FunctionParameterReflection)); + + public void** lpVtbl; + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(0)] + public HResult GetDesc(ParameterDescription* pDesc) + { +#if NET6_0_OR_GREATER + return ((delegate* unmanaged)(lpVtbl[0]))((ID3D12FunctionParameterReflection*)Unsafe.AsPointer(ref this), pDesc); +#else + return ((delegate* unmanaged[Stdcall])(lpVtbl[0]))((ID3D12FunctionParameterReflection*)Unsafe.AsPointer(ref this), pDesc); +#endif + } + + public interface Interface + { + } +} + +#endregion Com Types +#region Functions +public static unsafe partial class Apis +{ + [DllImport("d3d12", ExactSpelling = true)] + public static extern HResult D3D12SerializeRootSignature(RootSignatureDescription* pRootSignature, RootSignatureVersion Version, Graphics.Direct3D.ID3DBlob* ppBlob, Graphics.Direct3D.ID3DBlob* ppErrorBlob); + + [DllImport("d3d12", ExactSpelling = true)] + public static extern HResult D3D12CreateRootSignatureDeserializer(void* pSrcData, nuint SrcDataSizeInBytes, Guid* pRootSignatureDeserializerInterface, void** ppRootSignatureDeserializer); + + [DllImport("d3d12", ExactSpelling = true)] + public static extern HResult D3D12SerializeVersionedRootSignature(VersionedRootSignatureDescription* pRootSignature, Graphics.Direct3D.ID3DBlob* ppBlob, Graphics.Direct3D.ID3DBlob* ppErrorBlob); + + [DllImport("d3d12", ExactSpelling = true)] + public static extern HResult D3D12CreateVersionedRootSignatureDeserializer(void* pSrcData, nuint SrcDataSizeInBytes, Guid* pRootSignatureDeserializerInterface, void** ppRootSignatureDeserializer); + + [DllImport("d3d12", ExactSpelling = true)] + public static extern HResult D3D12CreateDevice(IUnknown* pAdapter, Graphics.Direct3D.FeatureLevel MinimumFeatureLevel, Guid* riid, void** ppDevice); + + [DllImport("d3d12", ExactSpelling = true)] + public static extern HResult D3D12GetDebugInterface(Guid* riid, void** ppvDebug); + + [DllImport("d3d12", ExactSpelling = true)] + public static extern HResult D3D12EnableExperimentalFeatures(uint NumFeatures, Guid* pIIDs, void* pConfigurationStructs, uint* pConfigurationStructSizes); + + [DllImport("d3d12", ExactSpelling = true)] + public static extern HResult D3D12GetInterface(Guid* rclsid, Guid* riid, void** ppvDebug); + +} +#endregion Functions diff --git a/src/Vortice.Win32/Graphics/Direct3D12/DepthStencilValue.cs b/src/Vortice.Win32/Graphics/Direct3D12/DepthStencilValue.cs new file mode 100644 index 0000000..ea34510 --- /dev/null +++ b/src/Vortice.Win32/Graphics/Direct3D12/DepthStencilValue.cs @@ -0,0 +1,13 @@ +// Copyright Amer Koleci and Contributors. +// Licensed under the MIT License (MIT). See LICENSE in the repository root for more information. + +namespace Win32.Graphics.Direct3D12; + +public partial struct DepthStencilValue +{ + public DepthStencilValue(float depth, byte stencil) + { + Depth = depth; + Stencil = stencil; + } +} diff --git a/src/Vortice.Win32/Luid.cs b/src/Vortice.Win32/Luid.cs index cbcfac5..36fe117 100644 --- a/src/Vortice.Win32/Luid.cs +++ b/src/Vortice.Win32/Luid.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; using System.Runtime.CompilerServices; namespace Win32; @@ -8,7 +9,7 @@ namespace Win32; /// /// A locally unique identifier for a graphics device. /// -public readonly struct Luid : IEquatable +public struct Luid : IEquatable #if NET6_0_OR_GREATER , ISpanFormattable #endif @@ -16,20 +17,20 @@ public readonly struct Luid : IEquatable /// /// The low bits of the luid. /// - private readonly uint _lowPart; + public uint LowPart; /// /// The high bits of the luid. /// - private readonly int _highPart; + public int HighPart; /// [MethodImpl(MethodImplOptions.AggressiveInlining)] public bool Equals(Luid other) { return - _lowPart == other._lowPart && - _highPart == other._highPart; + LowPart == other.LowPart && + HighPart == other.HighPart; } /// @@ -42,26 +43,45 @@ public readonly struct Luid : IEquatable [MethodImpl(MethodImplOptions.AggressiveInlining)] public override int GetHashCode() { - return HashCode.Combine(_lowPart, _highPart); + return HashCode.Combine(LowPart, HighPart); } /// public override string ToString() { - return (((long)this._highPart) << 32 | this._lowPart).ToString(); + return (((long)HighPart) << 32 | LowPart).ToString(); + } + + public long ToInt64() + { + LargeInterger val = new(); + val.Anonymous.LowPart = LowPart; + val.Anonymous.HighPart = HighPart; + return val.QuadPart; + } + + public static Luid FromInt64(long Int64) + { + LargeInterger val = new(); + val.QuadPart = Int64; + + Luid luid = new(); + luid.LowPart = val.Anonymous.LowPart; + luid.HighPart = val.Anonymous.HighPart; + return luid; } #if NET6_0_OR_GREATER /// public string ToString(string? format, IFormatProvider? formatProvider) { - return (((long)_highPart) << 32 | _lowPart).ToString(format, formatProvider); + return (((long)HighPart) << 32 | LowPart).ToString(format, formatProvider); } /// public bool TryFormat(Span destination, out int charsWritten, ReadOnlySpan format, IFormatProvider? provider) { - return (((long)_highPart) << 32 | _lowPart).TryFormat(destination, out charsWritten, format, provider); + return (((long)HighPart) << 32 | LowPart).TryFormat(destination, out charsWritten, format, provider); } #endif