Direct3D 12 Graphics

Overview of the Direct3D 12 Graphics technology.

To develop Direct3D 12 Graphics, you need these headers:

For programming guidance for this technology, see:

Enumerations

 
D3D_ROOT_SIGNATURE_VERSION

Specifies the version of root signature layout.
D3D_SHADER_MODEL

Specifies a shader model.
D3D12_AUTO_BREADCRUMB_OP

Defines constants that specify render/compute GPU operations.
D3D12_AXIS_SHADING_RATE

Defines constants that specify the shading rate (for variable-rate shading, or VRS) along a horizontal or vertical axis.
D3D12_BACKGROUND_PROCESSING_MODE

Defines constants that specify a level of dynamic optimization to apply to GPU work that's subsequently submitted.
D3D12_BLEND

Specifies blend factors, which modulate values for the pixel shader and render target.
D3D12_BLEND_OP

Specifies RGB or alpha blending operations.
D3D12_BUFFER_SRV_FLAGS

Identifies how to view a buffer resource.
D3D12_BUFFER_UAV_FLAGS

Identifies unordered-access view options for a buffer resource.
D3D12_CLEAR_FLAGS

Specifies what to clear from the depth stencil view.
D3D12_COLOR_WRITE_ENABLE

Identifies which components of each pixel of a render target are writable during blending.
D3D12_COMMAND_LIST_FLAGS

D3D12_COMMAND_LIST_SUPPORT_FLAGS

Used to determine which kinds of command lists are capable of supporting various operations.
D3D12_COMMAND_LIST_TYPE

Specifies the type of a command list.
D3D12_COMMAND_QUEUE_FLAGS

Specifies flags to be used when creating a command queue.
D3D12_COMMAND_QUEUE_PRIORITY

Defines priority levels for a command queue.
D3D12_COMPARISON_FUNC

Specifies comparison options.
D3D12_CONSERVATIVE_RASTERIZATION_MODE

Identifies whether conservative rasterization is on or off.
D3D12_CONSERVATIVE_RASTERIZATION_TIER

Identifies the tier level of conservative rasterization.
D3D12_CPU_PAGE_PROPERTY

Specifies the CPU-page properties for the heap.
D3D12_CROSS_NODE_SHARING_TIER

Specifies the level of sharing across nodes of an adapter, such as Tier 1 Emulated, Tier 1, or Tier 2.
D3D12_CULL_MODE

Specifies triangles facing a particular direction are not drawn.
D3D12_DEBUG_COMMAND_LIST_PARAMETER_TYPE

Indicates the debug parameter type used by ID3D12DebugCommandList1::SetDebugParameter and ID3D12DebugCommandList1::GetDebugParameter.
D3D12_DEBUG_DEVICE_PARAMETER_TYPE

Specifies the data type of the memory pointed to by the pData parameter of ID3D12DebugDevice1::SetDebugParameter and ID3D12DebugDevice1::GetDebugParameter.
D3D12_DEBUG_FEATURE

Flags for optional D3D12 Debug Layer features.
D3D12_DEPTH_WRITE_MASK

Identifies the portion of a depth-stencil buffer for writing depth data.
D3D12_DESCRIPTOR_HEAP_FLAGS

Specifies options for a heap.
D3D12_DESCRIPTOR_HEAP_TYPE

Specifies a type of descriptor heap.
D3D12_DESCRIPTOR_RANGE_FLAGS

Specifies the volatility of both descriptors and the data they reference in a Root Signature 1.1 description, which can enable some driver optimizations.
D3D12_DESCRIPTOR_RANGE_TYPE

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.
D3D12_DRED_ALLOCATION_TYPE

Congruent with, and numerically equivalent to, 3D12DDI_HANDLETYPE enumeration values.
D3D12_DRED_ENABLEMENT

Defines constants that specify render/compute GPU operations.
D3D12_DRED_FLAGS

Defines constants used in the D3D12_DEVICE_REMOVED_EXTENDED_DATA structure to specify control flags for the Direct3D runtime.
D3D12_DRED_VERSION

Defines constants that specify a version of Device Removed Extended Data (DRED), as used by the D3D12_VERSIONED_DEVICE_REMOVED_EXTENDED_DATA structure.
D3D12_DRIVER_MATCHING_IDENTIFIER_STATUS

Specifies the result of a call to ID3D12Device5::CheckDriverMatchingIdentifier which queries whether serialized data is compatible with the current device and driver version.
D3D12_DSV_DIMENSION

Specifies how to access a resource used in a depth-stencil view.
D3D12_DSV_FLAGS

Specifies depth-stencil view options.
D3D12_ELEMENTS_LAYOUT

Describes how the locations of elements are identified.
D3D12_EXPORT_FLAGS

The flags to apply when exporting symbols from a state subobject.
D3D12_FEATURE

Defines constants that specify a Direct3D 12 feature or feature set to query about.
D3D12_FENCE_FLAGS

Specifies fence options.
D3D12_FILL_MODE

Specifies the fill mode to use when rendering triangles.
D3D12_FILTER

Specifies filtering options during texture sampling.
D3D12_FILTER_REDUCTION_TYPE

Specifies the type of filter reduction.
D3D12_FILTER_TYPE

Specifies the type of magnification or minification sampler filters.
D3D12_FORMAT_SUPPORT1

Specifies resources that are supported for a provided format.
D3D12_FORMAT_SUPPORT2

Specifies which unordered resource options are supported for a provided format.
D3D12_GPU_BASED_VALIDATION_FLAGS

Describes the level of GPU-based validation to perform at runtime.
D3D12_GPU_BASED_VALIDATION_PIPELINE_STATE_CREATE_FLAGS

Specifies how GPU-Based Validation handles patched pipeline states during ID3D12Device::CreateGraphicsPipelineState and ID3D12Device::CreateComputePipelineState.
D3D12_GPU_BASED_VALIDATION_SHADER_PATCH_MODE

Specifies the type of shader patching used by GPU-Based Validation at either the device or command list level.
D3D12_GRAPHICS_STATES

Defines flags that specify states related to a graphics command list. Values can be bitwise OR'd together.
D3D12_HEAP_FLAGS

Specifies heap options, such as whether the heap can contain textures, and whether resources are shared across adapters.
D3D12_HEAP_SERIALIZATION_TIER

Defines constants that specify heap serialization support.
D3D12_HEAP_TYPE

Specifies the type of heap. When resident, heaps reside in a particular physical memory pool with certain CPU cache properties.
D3D12_HIT_GROUP_TYPE

Specifies the type of a raytracing hit group state subobject. Use a value from this enumeration with the D3D12_HIT_GROUP_DESC structure.
D3D12_INDEX_BUFFER_STRIP_CUT_VALUE

When using triangle strip primitive topology, vertex positions are interpreted as vertices of a continuous triangle “strip”.
D3D12_INDIRECT_ARGUMENT_TYPE

Specifies the type of the indirect parameter.
D3D12_INPUT_CLASSIFICATION

Identifies the type of data contained in an input slot.
D3D12_LIFETIME_STATE

Defines constants that specify the lifetime state of a lifetime-tracked object.
D3D12_LOGIC_OP

Specifies logical operations to configure for a render target.
D3D12_MEASUREMENTS_ACTION

Defines constants that specify what should be done with the results of earlier workload instrumentation.
D3D12_MEMORY_POOL

Specifies the memory pool for the heap.
D3D12_MESH_SHADER_TIER

Defines constants that specify mesh and amplification shader support.
D3D12_MESSAGE_CATEGORY

Specifies categories of debug messages.
D3D12_MESSAGE_ID

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.
D3D12_MESSAGE_SEVERITY

Debug message severity levels for an information queue.
D3D12_META_COMMAND_PARAMETER_FLAGS

Defines constants that specify the flags for a parameter to a meta command. Values can be bitwise OR'd together.
D3D12_META_COMMAND_PARAMETER_STAGE

Defines constants that specify the stage of a parameter to a meta command.
D3D12_META_COMMAND_PARAMETER_TYPE

Defines constants that specify the data type of a parameter to a meta command.
D3D12_MULTIPLE_FENCE_WAIT_FLAGS

Specifies multiple wait flags for multiple fences.
D3D12_MULTISAMPLE_QUALITY_LEVEL_FLAGS

Specifies options for determining quality levels.
D3D12_PIPELINE_STATE_FLAGS

Flags to control pipeline state.
D3D12_PIPELINE_STATE_SUBOBJECT_TYPE

Specifies the type of a sub-object in a pipeline state stream description.
D3D12_PREDICATION_OP

Specifies the predication operation to apply.
D3D12_PRIMITIVE_TOPOLOGY_TYPE

Specifies how the pipeline interprets geometry or hull shader input primitives.
D3D12_PROGRAMMABLE_SAMPLE_POSITIONS_TIER

Specifies the level of support for programmable sample positions that's offered by the adapter.
D3D12_PROTECTED_RESOURCE_SESSION_FLAGS

Defines constants that specify protected resource session flags.
D3D12_PROTECTED_RESOURCE_SESSION_SUPPORT_FLAGS

Defines constants that specify protected resource session support.
D3D12_PROTECTED_SESSION_STATUS

Defines constants that specify protected session status.
D3D12_QUERY_HEAP_TYPE

Specifies the type of query heap to create.
D3D12_QUERY_TYPE

Specifies the type of query.
D3D12_RAY_FLAGS

Flags passed to the TraceRay function to override transparency, culling, and early-out behavior.
D3D12_RAYTRACING_ACCELERATION_STRUCTURE_BUILD_FLAGS

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.
D3D12_RAYTRACING_ACCELERATION_STRUCTURE_COPY_MODE

Specifies the type of copy operation performed when calling CopyRaytracingAccelerationStructure.
D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_TYPE

Specifies the type of acceleration structure post-build info that can be retrieved with calls to EmitRaytracingAccelerationStructurePostbuildInfo and BuildRaytracingAccelerationStructure.
D3D12_RAYTRACING_ACCELERATION_STRUCTURE_TYPE

Specifies the type of a raytracing acceleration structure.
D3D12_RAYTRACING_GEOMETRY_FLAGS

Specifies flags for raytracing geometry in a D3D12_RAYTRACING_GEOMETRY_DESC structure.
D3D12_RAYTRACING_GEOMETRY_TYPE

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.
D3D12_RAYTRACING_INSTANCE_FLAGS

Flags for a raytracing acceleration structure instance. These flags can be used to override D3D12_RAYTRACING_GEOMETRY_FLAGS for individual instances.
D3D12_RAYTRACING_PIPELINE_FLAGS

Defines constants that specify configuration flags for a raytracing pipeline.
D3D12_RAYTRACING_TIER

Specifies the level of ray tracing support on the graphics device.
D3D12_RENDER_PASS_BEGINNING_ACCESS_TYPE

Specifies the type of access that an application is given to the specified resource(s) at the transition into a render pass.
D3D12_RENDER_PASS_ENDING_ACCESS_TYPE

Specifies the type of access that an application is given to the specified resource(s) at the transition out of a render pass.
D3D12_RENDER_PASS_FLAGS

Specifies the nature of the render pass; for example, whether it is a suspending or a resuming render pass.
D3D12_RENDER_PASS_TIER

Specifies the level of support for render passes on a graphics device.
D3D12_RESIDENCY_FLAGS

Used with the EnqueuMakeResident function to choose how residency operations proceed when the memory budget is exceeded.
D3D12_RESIDENCY_PRIORITY

Specifies broad residency priority buckets useful for quickly establishing an application priority scheme.
D3D12_RESOLVE_MODE

Specifies a resolve operation.
D3D12_RESOURCE_BARRIER_FLAGS

Flags for setting split resource barriers.
D3D12_RESOURCE_BARRIER_TYPE

Specifies a type of resource barrier (transition in resource use) description.
D3D12_RESOURCE_BINDING_TIER

Identifies the tier of resource binding being used.
D3D12_RESOURCE_DIMENSION

Identifies the type of resource being used.
D3D12_RESOURCE_FLAGS

Specifies options for working with resources.
D3D12_RESOURCE_HEAP_TIER

Specifies which resource heap tier the hardware and driver support.
D3D12_RESOURCE_STATES

Defines constants that specify the state of a resource regarding how the resource is being used.
D3D12_RLDO_FLAGS

Specifies options for the amount of information to report about a live device object's lifetime.
D3D12_ROOT_DESCRIPTOR_FLAGS

Specifies the volatility of the data referenced by descriptors in a Root Signature 1.1 description, which can enable some driver optimizations.
D3D12_ROOT_PARAMETER_TYPE

Specifies the type of root signature slot.
D3D12_ROOT_SIGNATURE_FLAGS

Specifies options for root signature layout.
D3D12_RTV_DIMENSION

Identifies the type of resource to view as a render target.
D3D12_SAMPLER_FEEDBACK_TIER

Defines constants that specify sampler feedback support.
D3D12_SERIALIZED_DATA_TYPE

Specifies the type of serialized data. Use a value from this enumeration when calling ID3D12Device5::CheckDriverMatchingIdentifier.
D3D12_SHADER_CACHE_CONTROL_FLAGS

Defines constants that specify shader cache control options.
D3D12_SHADER_CACHE_FLAGS

Defines constants that specify shader cache flags.
D3D12_SHADER_CACHE_KIND_FLAGS

Defines constants that specify a kind of shader cache.
D3D12_SHADER_CACHE_MODE

Defines constants that specify a shader cache's mode.
D3D12_SHADER_CACHE_SUPPORT_FLAGS

Describes the level of support for shader caching in the current graphics driver.
D3D12_SHADER_COMPONENT_MAPPING

Specifies how memory gets routed by a shader resource view (SRV).
D3D12_SHADER_MIN_PRECISION_SUPPORT

Describes minimum precision support options for shaders in the current graphics driver.
D3D12_SHADER_VERSION_TYPE

Enumerates the types of shaders that Direct3D recognizes. Used to encode the Version member of the D3D12_SHADER_DESC structure.
D3D12_SHADER_VISIBILITY

Specifies the shaders that can access the contents of a given root signature slot.
D3D12_SHADING_RATE

Defines constants that specify the shading rate (for variable-rate shading, or VRS).
D3D12_SHADING_RATE_COMBINER

Defines constants that specify a shading rate combiner (for variable-rate shading, or VRS).
D3D12_SHARED_RESOURCE_COMPATIBILITY_TIER

Defines constants that specify a cross-API sharing support tier.
D3D12_SRV_DIMENSION

Identifies the type of resource that will be viewed as a shader resource.
D3D12_STATE_OBJECT_FLAGS

Specifies constraints for state objects. Use values from this enumeration in the D3D12_STATE_OBJECT_CONFIG structure.
D3D12_STATE_OBJECT_TYPE

Specifies the type of a state object. Use with D3D12_STATE_OBJECT_DESC.
D3D12_STATE_SUBOBJECT_TYPE

The type of a state subobject. Use with D3D12_STATE_SUBOBJECT.
D3D12_STATIC_BORDER_COLOR

Specifies the border color for a static sampler.
D3D12_STENCIL_OP

Identifies the stencil operations that can be performed during depth-stencil testing.
D3D12_TEXTURE_ADDRESS_MODE

Identifies a technique for resolving texture coordinates that are outside of the boundaries of a texture.
D3D12_TEXTURE_COPY_TYPE

Specifies what type of texture copy is to take place.
D3D12_TEXTURE_LAYOUT

Specifies texture layout options.
D3D12_TILE_COPY_FLAGS

Specifies how to copy a tile.
D3D12_TILE_MAPPING_FLAGS

Specifies how to perform a tile-mapping operation.
D3D12_TILE_RANGE_FLAGS

Specifies a range of tile mappings.
D3D12_TILED_RESOURCES_TIER

Identifies the tier level at which tiled resources are supported.
D3D12_UAV_DIMENSION

Identifies unordered-access view options.
D3D12_VARIABLE_SHADING_RATE_TIER

Defines constants that specify a shading rate tier (for variable-rate shading, or VRS).
D3D12_VIEW_INSTANCING_FLAGS

Specifies options for view instancing.
D3D12_VIEW_INSTANCING_TIER

Indicates the tier level at which view instancing is supported.
D3D12_WAVE_MMA_TIER

Defines constants that specify a level of support for WaveMMA (wave_matrix) operations.
D3D12_WRITEBUFFERIMMEDIATE_MODE

Specifies the mode used by a WriteBufferImmediate operation.

Functions

 
AcquireDirect3D12BufferResource

Acquires a Direct3D 12 buffer resource.
AcquireDirect3D12BufferResource

Acquires a Direct3D 12 buffer resource.
AcquireDirect3D12BufferResourceWithTimeout

Acquires a Direct3D 12 buffer resource, with an optional timeout.
AcquireDirect3D12BufferResourceWithTimeout

Acquires a Direct3D 12 buffer resource, with an optional timeout.
AcquireWrappedResources

Acquires D3D11 resources for use with D3D 11on12. Indicates that rendering to the wrapped resources can begin again.
AddApplicationMessage

Adds a user-defined message to the message queue and sends that message to debug output.
AddMessage

Adds a debug message to the message queue and sends that message to debug output.
AddRetrievalFilterEntries

Add storage filters to the top of the retrieval-filter stack.
AddStorageFilterEntries

Add storage filters to the top of the storage-filter stack.
AddToStateObject

Incrementally add to an existing state object. This incurs lower CPU overhead than creating a state object from scratch that is a superset of an existing one.
AssertResourceState

Checks whether a resource, or subresource, is in a specified state, or not.
AssertResourceState

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.
AssertResourceState

Checks whether a resource, or subresource, is in a specified state, or not.
AtomicCopyBufferUINT

Atomically copies a primary data element of type UINT from one resource to another, along with optional dependent resources.
AtomicCopyBufferUINT64

Atomically copies a primary data element of type UINT64 from one resource to another, along with optional dependent resources.
BeginEvent

Not intended to be called directly.  Use the PIX event runtime to insert events into a command queue.
BeginEvent

Not intended to be called directly.  Use the PIX event runtime to insert events into a command list.
BeginQuery

Starts a query running.
BeginRenderPass

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).
BuildRaytracingAccelerationStructure

Performs a raytracing acceleration structure build on the GPU and optionally outputs post-build information immediately after the build.
CheckDriverMatchingIdentifier

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.
CheckFeatureSupport

Gets information about the features that are supported by the current graphics driver.
ClearDepthStencilView

Clears the depth-stencil resource.
ClearRenderTargetView

Sets all the elements in a render target to one value.
ClearRetrievalFilter

Remove a retrieval filter from the top of the retrieval-filter stack.
ClearState

Resets the state of a direct command list back to the state it was in when the command list was created.
ClearStorageFilter

Remove a storage filter from the top of the storage-filter stack.
ClearStoredMessages

Clear all messages from the message queue.
ClearUnorderedAccessViewFloat

Sets all the elements in a unordered access view to the specified float values.
ClearUnorderedAccessViewUint

Sets all the elements in a unordered-access view (UAV) to the specified integer values.
Close

Indicates that recording to the command list has finished.
CommitDirect3D12Resource

Commits a Direct3D 12 buffer for presentation on outputs associated with the HolographicCamera.
CommitDirect3D12Resource

Commits a Direct3D 12 buffer for presentation on outputs associated with any HolographicCamera to which the quad layer is attached.
CommitDirect3D12ResourceWithDepthData

Commits a Direct3D 12 buffer for presentation on outputs associated with the HolographicCamera.
CopyBufferRegion

Copies a region of a buffer from one resource to another.
CopyDescriptors

Copies descriptors from a source to a destination.
CopyDescriptorsSimple

Copies descriptors from a source to a destination.
CopyRaytracingAccelerationStructure

Copies a source acceleration structure to destination memory while applying the specified transformation.
CopyResource

Copies the entire contents of the source resource to the destination resource.
CopyTextureRegion

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.
CopyTileMappings

Copies mappings from a source reserved resource to a destination reserved resource.
CopyTiles

Copies tiles from buffer to tiled resource or vice versa.
CreateCommandAllocator

Creates a command allocator object.
CreateCommandList

Creates a command list.
CreateCommandList1

Creates a command list in the closed state.
CreateCommandQueue

Creates a command queue.
CreateCommandQueue1

Creates a command queue with a creator ID.
CreateCommandSignature

This method creates a command signature.
CreateCommittedResource

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.
CreateCommittedResource1

Creates both a resource and an implicit heap (optionally for a protected session), such that the heap is big enough to contain the entire resource, and the resource is mapped to the heap.
CreateCommittedResource2

Creates both a resource and an implicit heap (optionally for a protected session), such that the heap is big enough to contain the entire resource, and the resource is mapped to the heap.
CreateComputePipelineState

Creates a compute pipeline state object.
CreateConstantBufferView

Creates a constant-buffer view for accessing resource data.
CreateDepthStencilView

Creates a depth-stencil view for accessing resource data.
CreateDescriptorHeap

Creates a descriptor heap object.
CreateDirect3D12BackBufferResource

Creates a Direct3D 12 resource for use as a content buffer for the camera.
CreateDirect3D12ContentBufferResource

Creates a Direct3D 12 resource for use as a content buffer for the layer.
CreateDirect3D12HardwareProtectedBackBufferResource

Creates a Direct3D 12 resource for use as a content buffer for the camera, with optional hardware protection.
CreateDirect3D12HardwareProtectedContentBufferResource

Creates a Direct3D 12 resource for use as a content buffer for the camera, with optional hardware protection.
CreateFence

Creates a fence object.
CreateGraphicsPipelineState

Creates a graphics pipeline state object.
CreateHeap

Creates a heap that can be used with placed resources and reserved resources.
CreateHeap1

Creates a heap (optionally for a protected session) that can be used with placed resources and reserved resources.
CreateLifetimeTracker

Creates a lifetime tracker associated with an application-defined callback; the callback receives notifications when the lifetime of a tracked object is changed.
CreateMetaCommand

Creates an instance of the specified meta command.
CreatePipelineLibrary

Creates a cached pipeline library.
CreatePipelineState

Creates a pipeline state object from a pipeline state stream description.
CreatePlacedResource

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.
CreatePlacedResource1

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.
CreateProtectedResourceSession

Creates an object that represents a session for content protection.
CreateProtectedResourceSession1

Revises the ID3D12Device4::CreateProtectedResourceSession method with provision GUID that indicates the type of protected resource session.
CreateQueryHeap

Creates a query heap. A query heap contains an array of queries.
CreateRenderTargetView

Creates a render-target view for accessing resource data.
CreateReservedResource

Creates a resource that is reserved, and not yet mapped to any pages in a heap.
CreateReservedResource1

Creates a resource (optionally for a protected session) that is reserved, and not yet mapped to any pages in a heap.
CreateRootSignature

Creates a root signature layout.
CreateSampler

Create a sampler object that encapsulates sampling information for a texture.
CreateSamplerFeedbackUnorderedAccessView

For purposes of sampler feedback, creates a descriptor suitable for binding.
CreateShaderCacheSession

Creates an object that grants access to a shader cache, potentially opening an existing cache or creating a new one.
CreateShaderResourceView

Creates a shader-resource view for accessing data in a resource.
CreateSharedHandle

Creates a shared handle to a heap, resource, or fence object.
CreateStateObject

Creates an ID3D12StateObject.
CreateUnorderedAccessView

Creates a view for unordered accessing.
CreateWrappedResource

This method creates D3D11 resources for use with D3D 11on12.
D3D11On12CreateDevice

Creates a device that uses Direct3D 11 functionality in Direct3D 12, specifying a pre-existing Direct3D 12 device to use for Direct3D 11 interop.
D3D12CreateDevice

Creates a device that represents the display adapter.
D3D12CreateRootSignatureDeserializer

Deserializes a root signature so you can determine the layout definition (D3D12_ROOT_SIGNATURE_DESC).
D3D12CreateVersionedRootSignatureDeserializer

Generates an interface that can return the deserialized data structure, via GetUnconvertedRootSignatureDesc.
D3D12EnableExperimentalFeatures

Enables a list of experimental features.
D3D12GetDebugInterface

Gets a debug interface.
D3D12GetInterface

Selects an SDK version at runtime when the system is in Windows Developer Mode.
D3D12SerializeRootSignature

Serializes a root signature version 1.0 that can be passed to ID3D12Device::CreateRootSignature.
D3D12SerializeVersionedRootSignature

Serializes a root signature of any version that can be passed to ID3D12Device::CreateRootSignature.
DestroyOwnedObject

Destroys a lifetime-tracked object.
DisableDebugLayer

Disables the debug layer.
DiscardResource

Discards a resource.
Dispatch

Executes a compute shader on a thread group.
DispatchRays

Launch the threads of a ray generation shader.
DrawIndexedInstanced

Draws indexed, instanced primitives.
DrawInstanced

Draws non-indexed, instanced primitives.
EmitRaytracingAccelerationStructurePostbuildInfo

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.
EnableDebugLayer

Enables the debug layer.
EnableDebugLayer

Enables the debug layer.
EnableShaderInstrumentation

This method enables tools such as PIX to instrument shaders.
EndEvent

Not intended to be called directly.  Use the PIX event runtime to insert events into a command queue.
EndEvent

Not intended to be called directly.  Use the PIX event runtime to insert events into a command list.
EndQuery

Ends a running query.
EndRenderPass

Marks the ending of a render pass.
EnqueueMakeResident

Asynchronously makes objects resident for the device.
EnumerateMetaCommandParameters

Queries reflection metadata about the parameters of the specified meta command.
EnumerateMetaCommands

Queries reflection metadata about available meta commands.
Evict

Enables the page-out of data, which precludes GPU access of that data.
ExecuteBundle

Executes a bundle.
ExecuteCommandLists

Submits an array of command lists for execution.
ExecuteIndirect

Apps perform indirect draws/dispatches using the ExecuteIndirect method.
ExecuteMetaCommand

Records the execution (or invocation) of the specified meta command into a graphics command list.
FindValue

Looks up an entry in the cache whose key exactly matches the provided key.
GetAdapterLuid

Gets a locally unique identifier for the current device (adapter).
GetAutoBreadcrumbsOutput

Retrieves the Device Removed Extended Data (DRED) auto-breadcrumbs output after device removal.
GetBaseClass

Gets an ID3D12ShaderReflectionType Interface interface containing the variable base class type.
GetBitwiseInstructionCount

Gets the number of bitwise instructions.
GetBreakOnCategory

Get a message category to break on when a message with that category passes through the storage filter.
GetBreakOnID

Get a message identifier to break on when a message with that identifier passes through the storage filter.
GetBreakOnSeverity

Get a message severity level to break on when a message with that severity level passes through the storage filter.
GetBuffer

Returns the ID3D12ShaderReflectionConstantBuffer of the present ID3D12ShaderReflectionVariable.
GetCachedBlob

Gets the cached blob representing the pipeline state.
GetClockCalibration

This method samples the CPU and GPU timestamp counters at the same moment in time.
GetCompletedValue

Gets the current value of the fence.
GetConstantBufferByIndex

Gets a constant buffer by index for a function.
GetConstantBufferByIndex

Gets a constant buffer by index.
GetConstantBufferByName

Gets a constant buffer by name for a function.
GetConstantBufferByName

Gets a constant buffer by name.
GetConversionInstructionCount

Gets the number of conversion instructions.
GetCopyableFootprints

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.
GetCopyableFootprints1

Gets a resource layout that can be copied. Helps your app fill in D3D12_PLACED_SUBRESOURCE_FOOTPRINT and D3D12_SUBRESOURCE_FOOTPRINT when suballocating space in upload heaps.
GetCPUDescriptorHandleForHeapStart

Gets the CPU descriptor handle that represents the start of the heap.
GetCreationFlags

Gets the flags used to create the fence represented by the current instance.
GetCustomHeapProperties

Divulges the equivalent custom heap properties that are used for non-custom heap types, based on the adapter's architectural properties.
GetD3D12Device

Retrieves the Direct3D 12 device being interoperated with.
GetDebugParameter

Gets optional Command List Debug Layer settings.
GetDebugParameter

Gets optional device-wide Debug Layer settings.
GetDesc

Gets the description of the command queue.
GetDesc

Gets the descriptor heap description.
GetDesc

Gets the heap description.
GetDesc

Retrieves a description of the protected resource session.
GetDesc

Gets the resource description.
GetDesc

Retrieves the description used to create the cache session.
GetDesc

Fills the parameter descriptor structure for the function's parameter.
GetDesc

Fills the function descriptor structure for the function.
GetDesc

Fills the library descriptor structure for the library reflection.
GetDesc

Gets a shader description.
GetDesc

Gets a constant-buffer description.
GetDesc

Gets the description of a shader-reflection-variable type.
GetDesc

Gets a shader-variable description.
GetDesc1

Retrieves a description of the protected resource session.
GetDescriptorHandleIncrementSize

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.
GetDevice

Gets a pointer to the device that created this interface.
GetDeviceRemovedReason

Gets the reason that the device was removed.
GetFeatureMask

Returns the debug feature flags that have been set on a command list.
GetFeatureMask

Gets a bit field of flags that indicates which debug features are on or off.
GetFunctionByIndex

Gets the function reflector.
GetFunctionParameter

Gets the function parameter reflector.
GetGPUDescriptorHandleForHeapStart

Gets the GPU descriptor handle that represents the start of the heap.
GetGPUVirtualAddress

This method returns the GPU virtual address of a buffer resource.
GetGSInputPrimitive

Gets the geometry-shader input-primitive description.
GetHeapProperties

Retrieves the properties of the resource heap, for placed and committed resources.
GetInputParameterDesc

Gets an input-parameter description for a shader.
GetInterfaceByIndex

Gets an interface by index.
GetInterfaceSlot

Gets the corresponding interface slot for a variable that represents an interface pointer.
GetMemberTypeByIndex

Gets a shader-reflection-variable type by index.
GetMemberTypeByName

Gets a shader-reflection-variable type by name.
GetMemberTypeName

Gets a shader-reflection-variable type.
GetMessage

Get a message from the message queue.
GetMessageCountLimit

Get the maximum number of messages that can be added to the message queue.
GetMinFeatureLevel

Gets the minimum feature level.
GetMovcInstructionCount

Gets the number of Movc instructions.
GetMovInstructionCount

Gets the number of Mov instructions.
GetMuteDebugOutput

Get a boolean that determines if debug output is on or off.
GetNodeCount

Reports the number of physical adapters (nodes) that are associated with this device.
GetNumInterfaces

Gets the number of interfaces.
GetNumInterfaceSlots

Gets the number of interface slots in a shader.
GetNumMessagesAllowedByStorageFilter

Get the number of messages that were allowed to pass through a storage filter.
GetNumMessagesDeniedByStorageFilter

Get the number of messages that were denied passage through a storage filter.
GetNumMessagesDiscardedByMessageCountLimit

Get the number of messages that were discarded due to the message count limit.
GetNumStoredMessages

Get the number of messages currently stored in the message queue.
GetNumStoredMessagesAllowedByRetrievalFilter

Get the number of messages that are able to pass through a retrieval filter.
GetOutputParameterDesc

Gets an output-parameter description for a shader.
GetPageFaultAllocationOutput

Retrieves the Device Removed Extended Data (DRED) page fault data.
GetPatchConstantParameterDesc

Gets a patch-constant parameter description for a shader.
GetPipelineStackSize

Gets the current pipeline stack size.
GetPrivateData

Gets application-defined data from a device object.
GetRaytracingAccelerationStructurePrebuildInfo

Query the driver for resource requirements to build an acceleration structure.
GetRequiredParameterResourceSize

Retrieves the amount of memory required for the specified runtime parameter resource for a meta command, for the specified stage.
GetRequiresFlags

Gets a group of flags that indicates the requirements of a shader.
GetResourceAllocationInfo

Gets the size and alignment of memory required for a collection of resources on this adapter.
GetResourceAllocationInfo1

Gets rich info about the size and alignment of memory required for a collection of resources on this adapter.
GetResourceAllocationInfo2

Gets rich info about the size and alignment of memory required for a collection of resources on this adapter.
GetResourceBindingDesc

Gets a description of how a resource is bound to a function.
GetResourceBindingDesc

Gets a description of how a resource is bound to a shader.
GetResourceBindingDescByName

Gets a description of how a resource is bound to a function.
GetResourceBindingDescByName

Gets a description of how a resource is bound to a shader.
GetResourceTiling

Gets info about how a tiled resource is broken into tiles.
GetRetrievalFilter

Get the retrieval filter at the top of the retrieval-filter stack.
GetRetrievalFilterStackSize

Get the size of the retrieval-filter stack in bytes.
GetRootSignatureDesc

Gets the layout of the root signature.
GetRootSignatureDescAtVersion

Converts root signature description structures to a requested version.
GetSerializedSize

Returns the amount of memory required to serialize the current contents of the database.
GetSessionStatus

Gets the status of the protected session.
GetShaderIdentifier

Retrieves the unique identifier for a shader that can be used in a shader record.
GetShaderStackSize

Gets the amount of stack memory required to invoke a raytracing shader in HLSL.
GetStatusFence

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.
GetStorageFilter

Get the storage filter at the top of the storage-filter stack.
GetStorageFilterStackSize

Get the size of the storage-filter stack in bytes.
GetSubType

Gets the base class of a class.
GetThreadGroupSize

Retrieves the sizes, in units of threads, of the X, Y, and Z dimensions of the shader's thread-group grid.
GetTimestampFrequency

This method is used to determine the rate at which the GPU timestamp counter increments.
GetType

Gets the type of the command list, such as direct, bundle, compute, or copy.
GetType

Gets a shader-variable type.
GetUnconvertedRootSignatureDesc

Gets the layout of the root signature, without converting between root signature versions.
GetVariableByIndex

Gets a shader-reflection variable by index.
GetVariableByName

Gets a variable by name.
GetVariableByName

Gets a variable by name.
GetVariableByName

Gets a shader-reflection variable by name.
IASetIndexBuffer

Sets the view for the index buffer.
IASetPrimitiveTopology

Bind information about the primitive type, and data order that describes input data for the input assembler stage.
IASetVertexBuffers

Sets a CPU descriptor handle for the vertex buffers.
ImplementsInterface

Indicates whether a class type implements an interface.
InitializeMetaCommand

Initializes the specified meta command.
IsEqual

Indicates whether two ID3D12ShaderReflectionType Interface pointers have the same underlying type.
IsOfType

Indicates whether a variable is of the specified type.
IsSampleFrequencyShader

Indicates whether a shader is a sample frequency shader.
LifetimeStateUpdated

Called when the lifetime state of a lifetime-tracked object changes.
LoadComputePipeline

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.
LoadGraphicsPipeline

Retrieves the requested PSO from the library.
LoadPipeline

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.
MakeResident

Makes objects resident for the device.
Map

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.
OMSetBlendFactor

Sets the blend factor that modulate values for a pixel shader, render target, or both.
OMSetDepthBounds

This method enables you to change the depth bounds dynamically.
OMSetRenderTargets

Sets CPU descriptor handles for the render targets and depth stencil.
OMSetStencilRef

Sets the reference value for depth stencil tests.
OpenExistingHeapFromAddress

Creates a special-purpose diagnostic heap in system memory from an address. The created heap can persist even in the event of a GPU-fault or device-removed scenario.
OpenExistingHeapFromFileMapping

Creates a special-purpose diagnostic heap in system memory from a file mapping object. The created heap can persist even in the event of a GPU-fault or device-removed scenario.
OpenSharedHandle

Opens a handle for shared resources, shared heaps, and shared fences, by using HANDLE and REFIID.
OpenSharedHandleByName

Opens a handle for shared resources, shared heaps, and shared fences, by using Name and Access.
PopRetrievalFilter

Pop a retrieval filter from the top of the retrieval-filter stack.
PopStorageFilter

Pop a storage filter from the top of the storage-filter stack.
Present

Shares a resource (or subresource) between the D3D layers and diagnostics tools.
PushCopyOfRetrievalFilter

Push a copy of retrieval filter currently on the top of the retrieval-filter stack onto the retrieval-filter stack.
PushCopyOfStorageFilter

Push a copy of storage filter currently on the top of the storage-filter stack onto the storage-filter stack.
PushEmptyRetrievalFilter

Push an empty retrieval filter onto the retrieval-filter stack.
PushEmptyStorageFilter

Push an empty storage filter onto the storage-filter stack.
PushRetrievalFilter

Push a retrieval filter onto the retrieval-filter stack.
PushStorageFilter

Push a storage filter onto the storage-filter stack.
ReadFromSubresource

Uses the CPU to copy data from a subresource, enabling the CPU to read the contents of most textures with undefined layouts.
ReleaseWrappedResources

Releases D3D11 resources that were wrapped for D3D 11on12.
RemoveDevice

You can call RemoveDevice to indicate to the Direct3D 12 runtime that the GPU device encountered a problem, and can no longer be used.
ReportLiveDeviceObjects

Reports information about a device object's lifetime.
ReportLiveDeviceObjects

Specifies the amount of information to report on a device object's lifetime.
Reset

Indicates to re-use the memory that is associated with the command allocator.
Reset

Resets a command list back to its initial state as if a new command list was just created.
ResolveQueryData

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). .
ResolveSubresource

Copy a multi-sampled resource into a non-multi-sampled resource.
ResolveSubresourceRegion

Copy a region of a multisampled or compressed resource into a non-multisampled or non-compressed resource.
ResourceBarrier

Notifies the driver that it needs to synchronize multiple accesses to resources.
ReturnUnderlyingResource

With this method, you can return a Direct3D 11 resource object to Direct3D11On12, and indicate when the resource will be ready to consume.
RSSetScissorRects

Binds an array of scissor rectangles to the rasterizer stage.
RSSetShadingRate

RSSetShadingRateImage

RSSetViewports

Bind an array of viewports to the rasterizer stage of the pipeline.
Serialize

Writes the contents of the library to the provided memory, to be provided back to the runtime at a later time.
SetAutoBreadcrumbsEnablement

Configures the enablement settings for Device Removed Extended Data (DRED) auto-breadcrumbs.
SetBackgroundProcessingMode

Sets the mode for driver background processing optimizations.
SetBreakOnCategory

Set a message category to break on when a message with that category passes through the storage filter.
SetBreakOnID

Set a message identifier to break on when a message with that identifier passes through the storage filter.
SetBreakOnSeverity

Set a message severity level to break on when a message with that severity level passes through the storage filter.
SetComputeRoot32BitConstant

Sets a constant in the compute root signature.
SetComputeRoot32BitConstants

Sets a group of constants in the compute root signature.
SetComputeRootConstantBufferView

Sets a CPU descriptor handle for the constant buffer in the compute root signature.
SetComputeRootDescriptorTable

Sets a descriptor table into the compute root signature.
SetComputeRootShaderResourceView

Sets a CPU descriptor handle for the shader resource in the compute root signature.
SetComputeRootSignature

Sets the layout of the compute root signature.
SetComputeRootUnorderedAccessView

Sets a CPU descriptor handle for the unordered-access-view resource in the compute root signature.
SetDebugParameter

Modifies optional Debug Layer settings of a command list.
SetDebugParameter

Modifies the D3D12 optional device-wide Debug Layer settings.
SetDeleteOnDestroy

When all cache session objects corresponding to a given cache are destroyed, the cache is cleared.
SetDescriptorHeaps

Changes the currently bound descriptor heaps that are associated with a command list.
SetEnableAutoName

Configures the auto-naming of objects.
SetEnableGPUBasedValidation

This method enables or disables GPU-Based Validation (GBV) before creating a device with the debug layer enabled.
SetEnableGPUBasedValidation

This method enables or disables GPU-based validation (GBV) before creating a device with the debug layer enabled.
SetEnableSynchronizedCommandQueueValidation

Enables or disables dependent command queue synchronization when using a D3D12 device with the debug layer enabled.
SetEnableSynchronizedCommandQueueValidation

Enables or disables dependent command queue synchronization when using a Direct3D 12 device with the debug layer enabled.
SetEventOnCompletion

Specifies an event that should be fired when the fence reaches a certain value.
SetEventOnMultipleFenceCompletion

Specifies an event that should be fired when one or more of a collection of fences reach specific values.
SetFeatureMask

Turns the debug features for a command list on or off.
SetFeatureMask

Set a bit field of flags that will turn debug features on and off.
SetGPUBasedValidationFlags

This method configures the level of GPU-based validation that the debug device is to perform at runtime.
SetGPUBasedValidationFlags

This method configures the level of GPU-based validation that the debug device is to perform at runtime.
SetGraphicsRoot32BitConstant

Sets a constant in the graphics root signature.
SetGraphicsRoot32BitConstants

Sets a group of constants in the graphics root signature.
SetGraphicsRootConstantBufferView

Sets a CPU descriptor handle for the constant buffer in the graphics root signature.
SetGraphicsRootDescriptorTable

Sets a descriptor table into the graphics root signature.
SetGraphicsRootShaderResourceView

Sets a CPU descriptor handle for the shader resource in the graphics root signature.
SetGraphicsRootSignature

Sets the layout of the graphics root signature.
SetGraphicsRootUnorderedAccessView

Sets a CPU descriptor handle for the unordered-access-view resource in the graphics root signature.
SetMarker

Not intended to be called directly.  Use the PIX event runtime to insert events into a command queue.
SetMarker

Not intended to be called directly.  Use the PIX event runtime to insert events into a command list.
SetMessageCountLimit

Set the maximum number of messages that can be added to the message queue.
SetMuteDebugOutput

Set a boolean that turns the debug output on or off.
SetName

Associates a name with the device object. This name is for use in debug diagnostics and tools.
SetPageFaultEnablement

Configures the enablement settings for Device Removed Extended Data (DRED) page fault reporting.
SetPipelineStackSize

Set the current pipeline stack size.
SetPipelineState

Sets all shaders and programs most of the fixed-function state of the graphics processing unit (GPU) pipeline.
SetPipelineState1

Sets a state object on the command list.
SetPredication

Sets a rendering predicate.
SetPrivateData

Sets application-defined data to a device object and associates that data with an application-defined GUID.
SetPrivateDataInterface

Associates an IUnknown-derived interface with the device object and associates that interface with an application-defined GUID.
SetProtectedResourceSession

Specifies whether or not protected resources can be accessed by subsequent commands in the command list.
SetResidencyPriority

This method sets residency priorities of a specified list of objects.
SetSamplePositions

This method configures the sample positions used by subsequent draw, copy, resolve, and similar operations.
SetSDKVersion

Configures the SDK version to use.
SetStablePowerState

A development-time aid for certain types of profiling and experimental prototyping.
SetViewInstanceMask

Set a mask that controls which view instances are enabled for subsequent draws.
SetWatsonDumpEnablement

Configures the enablement settings for Device Removed Extended Data (DRED) Watson dump creation.
ShaderCacheControl

Modifies the behavior of caches used internally by Direct3D or by the driver.
ShaderInstrumentationEnabled

Determines whether shader instrumentation is enabled.
SharedFenceSignal

Signals a shared fence between the D3D layers and diagnostics tools.
Signal

Updates a fence to a specified value.
Signal

Sets the fence to the specified value.
SOSetTargets

Sets the stream output buffer views.
StorePipeline

Adds the input PSO to an internal database with the corresponding name.
StoreValue

Adds an entry to the cache.
UnacquireDirect3D12BufferResource

Un-acquires a Direct3D 12 buffer resource.
UnacquireDirect3D12BufferResource

Un-acquires a Direct3D 12 buffer resource.
Unmap

Invalidates the CPU pointer to the specified subresource in the resource.
UnwrapUnderlyingResource

Unwraps a Direct3D 11 resource object, and retrieves it as a Direct3D 12 resource object.
UpdateTileMappings

Updates mappings of tile locations in reserved resources to memory locations in a resource heap.
Wait

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.
WriteBufferImmediate

Writes a number of 32-bit immediate values to the specified buffer locations directly from the command stream.
WriteToSubresource

Uses the CPU to copy data into a subresource, enabling the CPU to modify the contents of most textures with undefined layouts.

Interfaces

 
ID3D11On12Device

Handles the creation, wrapping, and releasing of D3D11 resources for Direct3D11on12.
ID3D11On12Device1

Enables better interoperability with a component that might be handed a Direct3D 11 device, but which wants to leverage Direct3D 12 instead.
ID3D11On12Device2

Enables you to take resources created through the Direct3D 11 APIs, and use them in Direct3D 12.
ID3D12CommandAllocator

Represents the allocations of storage for graphics processing unit (GPU) commands.
ID3D12CommandList

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).
ID3D12CommandQueue

Provides methods for submitting command lists, synchronizing command list execution, instrumenting the command queue, and updating resource tile mappings.
ID3D12CommandSignature

A command signature object enables apps to specify indirect drawing, including the buffer format, command type and resource bindings to be used.
ID3D12Debug

An interface used to turn on the debug layer.
ID3D12Debug1

Adds GPU-Based Validation and Dependent Command Queue Synchronization to the debug layer.
ID3D12Debug2

Adds configurable levels of GPU-based validation to the debug layer.
ID3D12Debug3

Adds configurable levels of GPU-based validation to the debug layer.
ID3D12Debug4

Adds the ability to disable the debug layer.
ID3D12Debug5

Adds to the debug layer the ability to configure the auto-naming of objects.
ID3D12DebugCommandList

Provides methods to monitor and debug a command list.
ID3D12DebugCommandList1

This interface enables modification of additional command list debug layer settings.
ID3D12DebugCommandQueue

Provides methods to monitor and debug a command queue.
ID3D12DebugDevice

This interface represents a graphics device for debugging.
ID3D12DebugDevice1

Specifies device-wide debug layer settings.
ID3D12DescriptorHeap

A descriptor heap is a collection of contiguous allocations of descriptors, one allocation for every descriptor.
ID3D12Device

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.
ID3D12Device1

Represents a virtual adapter, and expands on the range of methods provided by ID3D12Device.
ID3D12Device2

Represents a virtual adapter. This interface extends ID3D12Device1 to create pipeline state objects from pipeline state stream descriptions.
ID3D12Device3

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.
ID3D12Device4

Represents a virtual adapter. This interface extends ID3D12Device3.
ID3D12Device5

Represents a virtual adapter. This interface extends ID3D12Device4.
ID3D12Device6

Represents a virtual adapter. This interface extends ID3D12Device5.
ID3D12Device7

Represents a virtual adapter. This interface extends ID3D12Device6.
ID3D12Device8

Represents a virtual adapter. This interface extends ID3D12Device7.
ID3D12Device9

Represents a virtual adapter. This interface extends ID3D12Device8 to add methods to manage shader caches.
ID3D12DeviceChild

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.
ID3D12DeviceRemovedExtendedData

Provides runtime access to Device Removed Extended Data (DRED) data.
ID3D12DeviceRemovedExtendedDataSettings

This interface controls Device Removed Extended Data (DRED) settings.
ID3D12Fence

Represents a fence, an object used for synchronization of the CPU and one or more GPUs.
ID3D12Fence1

Represents a fence. This interface extends ID3D12Fence, and supports the retrieval of the flags used to create the original fence.
ID3D12FunctionParameterReflection

A function-parameter-reflection interface accesses function-parameter info.
ID3D12FunctionReflection

A function-reflection interface accesses function info.
ID3D12GraphicsCommandList

Encapsulates a list of graphics commands for rendering. Includes APIs for instrumenting the command list execution, and for setting and clearing the pipeline state.
ID3D12GraphicsCommandList1

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.
ID3D12GraphicsCommandList2

Encapsulates a list of graphics commands for rendering, extending the interface to support writing immediate values directly to a buffer.
ID3D12GraphicsCommandList3

Encapsulates a list of graphics commands for rendering.
ID3D12GraphicsCommandList4

Encapsulates a list of graphics commands for rendering, extending the interface to support ray tracing and render passes.
ID3D12GraphicsCommandList5

Encapsulates a list of graphics commands for rendering, extending the interface to support variable-rate shading (VRS).
ID3D12Heap

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.
ID3D12InfoQueue

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.
ID3D12LibraryReflection

A library-reflection interface accesses library info.
ID3D12LifetimeOwner

Represents an application-defined callback used for being notified of lifetime changes of an object.
ID3D12LifetimeTracker

Represents facilities for controlling the lifetime a lifetime-tracked object.
ID3D12MetaCommand

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.
ID3D12Object

An interface from which ID3D12Device and ID3D12DeviceChild inherit from. It provides methods to associate private data and annotate object names.
ID3D12Pageable

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.
ID3D12PipelineLibrary

Manages a pipeline library, in particular loading and retrieving individual PSOs.
ID3D12PipelineLibrary1

Manages a pipeline library. This interface extends ID3D12PipelineLibrary to load PSOs from a pipeline state stream description.
ID3D12PipelineState

Represents the state of all currently set shaders as well as certain fixed function state objects.
ID3D12ProtectedResourceSession

Monitors the validity of a protected resource session.
ID3D12ProtectedResourceSession1

Monitors the validity of a protected resource session.
ID3D12ProtectedSession

Offers base functionality that allows for a consistent way to monitor the validity of a session across the different types of sessions.
ID3D12QueryHeap

Manages a query heap. A query heap holds an array of queries, referenced by indexes.
ID3D12Resource

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.
ID3D12RootSignature

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.
ID3D12RootSignatureDeserializer

Contains a method to return the deserialized D3D12_ROOT_SIGNATURE_DESC data structure, of a serialized root signature version 1.0.
ID3D12SDKConfiguration

Provides SDK configuration methods.
ID3D12ShaderCacheSession

Represents a shader cache session.
ID3D12ShaderReflection

A shader-reflection interface accesses shader information.
ID3D12ShaderReflectionConstantBuffer

This shader-reflection interface provides access to a constant buffer.
ID3D12ShaderReflectionType

This shader-reflection interface provides access to variable type.
ID3D12ShaderReflectionVariable

This shader-reflection interface provides access to a variable.
ID3D12SharingContract

Part of a contract between D3D11On12 diagnostic layers and graphics diagnostics tools.
ID3D12StateObject

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.
ID3D12StateObjectProperties

Provides methods for getting and setting the properties of an ID3D12StateObject.
ID3D12Tools

This interface is used to configure the runtime for tools such as PIX. Its not intended or supported for any other scenario.
ID3D12VersionedRootSignatureDeserializer

Contains methods to return the deserialized D3D12_ROOT_SIGNATURE_DESC1 data structure, of any version of a serialized root signature.
IHolographicCameraInterop

Extends HolographicCamera to allow 2D texture resources to be created and used as back buffers for holographic rendering in Direct3D 12.
IHolographicCameraRenderingParametersInterop

A nano-COM interface that allows COM interop with the HolographicCameraRenderingParameters class for applications that use Direct3D 12 for holographic rendering.
IHolographicQuadLayerInterop

A nano-COM interface that allows COM interop with the HolographicQuadLayer Windows Runtime class for apps that use Direct3D 12 for holographic rendering.
IHolographicQuadLayerUpdateParametersInterop

A nano-COM interface that allows COM interop with the HolographicQuadLayerUpdateParameters class for applications that use Direct3D 12 for holographic rendering.

Structures

 
D3D11_RESOURCE_FLAGS

Used with ID3D11On12Device::CreateWrappedResourceto override flags that would be inferred by the resource properties or heap properties, including bind flags, misc flags, and CPU access flags.
D3D12_AUTO_BREADCRUMB_NODE

Represents Device Removed Extended Data (DRED) auto-breadcrumb data as a node in a linked list.
D3D12_BLEND_DESC

Describes the blend state.
D3D12_BOX

Describes a 3D box.
D3D12_BUFFER_RTV

Describes the elements in a buffer resource to use in a render-target view.
D3D12_BUFFER_SRV

Describes the elements in a buffer resource to use in a shader-resource view.
D3D12_BUFFER_UAV

Describes the elements in a buffer to use in a unordered-access view.
D3D12_BUILD_RAYTRACING_ACCELERATION_STRUCTURE_DESC

Describes a raytracing acceleration structure. Pass this structure into ID3D12GraphicsCommandList4::BuildRaytracingAccelerationStructure to describe the acceleration structure to be built.
D3D12_BUILD_RAYTRACING_ACCELERATION_STRUCTURE_INPUTS

Defines the inputs for a raytracing acceleration structure build operation. This structure is used by ID3D12GraphicsCommandList4::BuildRaytracingAccelerationStructure and ID3D12Device5::GetRaytracingAccelerationStructurePrebuildInfo.
D3D12_BUILD_RAYTRACING_ACCELERATION_STRUCTURE_TOOLS_VISUALIZATION_HEADER

Describes the GPU memory layout of an acceleration structure visualization.
D3D12_CACHED_PIPELINE_STATE

Stores a pipeline state.
D3D12_CLEAR_VALUE

Describes a value used to optimize clear operations for a particular resource.
D3D12_COMMAND_QUEUE_DESC

Describes a command queue.
D3D12_COMMAND_SIGNATURE_DESC

Describes the arguments (parameters) of a command signature.
D3D12_COMPUTE_PIPELINE_STATE_DESC

Describes a compute pipeline state object.
D3D12_CONSTANT_BUFFER_VIEW_DESC

Describes a constant buffer to view.
D3D12_CPU_DESCRIPTOR_HANDLE

Describes a CPU descriptor handle.
D3D12_DEBUG_COMMAND_LIST_GPU_BASED_VALIDATION_SETTINGS

Describes per-command-list settings used by GPU-Based Validation.
D3D12_DEBUG_DEVICE_GPU_BASED_VALIDATION_SETTINGS

Describes settings used by GPU-Based Validation.
D3D12_DEBUG_DEVICE_GPU_SLOWDOWN_PERFORMANCE_FACTOR

Describes the amount of artificial slowdown inserted by the debug device to simulate lower-performance graphics adapters.
D3D12_DEPTH_STENCIL_DESC

Describes depth-stencil state.
D3D12_DEPTH_STENCIL_DESC1

Describes depth-stencil state.
D3D12_DEPTH_STENCIL_VALUE

Specifies a depth and stencil value.
D3D12_DEPTH_STENCIL_VIEW_DESC

Describes the subresources of a texture that are accessible from a depth-stencil view.
D3D12_DEPTH_STENCILOP_DESC

Describes stencil operations that can be performed based on the results of stencil test.
D3D12_DESCRIPTOR_HEAP_DESC

Describes the descriptor heap.
D3D12_DESCRIPTOR_RANGE

Describes a descriptor range.
D3D12_DESCRIPTOR_RANGE1

Describes a descriptor range, with flags to determine their volatility.
D3D12_DEVICE_REMOVED_EXTENDED_DATA

Represents Device Removed Extended Data (DRED) version 1.0 data.
D3D12_DEVICE_REMOVED_EXTENDED_DATA1

Represents Device Removed Extended Data (DRED) version 1.1 data.
D3D12_DISCARD_REGION

Describes details for the discard-resource operation.
D3D12_DISPATCH_ARGUMENTS

Describes dispatch parameters, for use by the compute shader.
D3D12_DISPATCH_RAYS_DESC

Describes the properties of a ray dispatch operation initiated with a call to ID3D12GraphicsCommandList4::DispatchRays.
D3D12_DRAW_ARGUMENTS

Describes parameters for drawing instances.
D3D12_DRAW_INDEXED_ARGUMENTS

Describes parameters for drawing indexed instances.
D3D12_DRED_ALLOCATION_NODE

Describes, as a node in a linked list, data about an allocation tracked by Device Removed Extended Data (DRED).
D3D12_DRED_AUTO_BREADCRUMBS_OUTPUT

Contains a pointer to the head of a linked list of D3D12_AUTO_BREADCRUMB_NODE objects.
D3D12_DRED_PAGE_FAULT_OUTPUT

Describes allocation data related to a GPU page fault on a given virtual address (VA).
D3D12_DXIL_LIBRARY_DESC

Describes a DXIL library state subobject that can be included in a state object.
D3D12_DXIL_SUBOBJECT_TO_EXPORTS_ASSOCIATION

This subobject is unsupported in the current release.
D3D12_EXISTING_COLLECTION_DESC

A state subobject describing an existing collection that can be included in a state object.
D3D12_EXPORT_DESC

Describes an export from a state subobject such as a DXIL library or a collection state object.
D3D12_FEATURE_DATA_ARCHITECTURE

Provides detail about the adapter architecture, so that your application can better optimize for certain adapter properties.
D3D12_FEATURE_DATA_ARCHITECTURE1

Provides detail about each adapter's architectural details, so that your application can better optimize for certain adapter properties.
D3D12_FEATURE_DATA_COMMAND_QUEUE_PRIORITY

Details the adapter's support for prioritization of different command queue types.
D3D12_FEATURE_DATA_CROSS_NODE

Indicates the level of support for the sharing of resources between different adapters—for example, multiple GPUs.
D3D12_FEATURE_DATA_D3D12_OPTIONS

Describes Direct3D 12 feature options in the current graphics driver.
D3D12_FEATURE_DATA_D3D12_OPTIONS1

Describes the level of support for HLSL 6.0 wave operations.
D3D12_FEATURE_DATA_D3D12_OPTIONS10

Indicates whether or not the SUM combiner can be used, and whether or not SV_ShadingRate can be set from a mesh shader.
D3D12_FEATURE_DATA_D3D12_OPTIONS11

Indicates whether or not 64-bit integer atomics on resources in descriptor heaps are supported.
D3D12_FEATURE_DATA_D3D12_OPTIONS2

Indicates the level of support that the adapter provides for depth-bounds tests and programmable sample positions.
D3D12_FEATURE_DATA_D3D12_OPTIONS3

Indicates the level of support that the adapter provides for timestamp queries, format-casting, immediate write, view instancing, and barycentrics.
D3D12_FEATURE_DATA_D3D12_OPTIONS4

Indicates the level of support for 64KB-aligned MSAA textures, cross-API sharing, and native 16-bit shader operations.
D3D12_FEATURE_DATA_D3D12_OPTIONS5

Indicates the level of support that the adapter provides for render passes, ray tracing, and shader-resource view tier 3 tiled resources.
D3D12_FEATURE_DATA_D3D12_OPTIONS6

Indicates the level of support that the adapter provides for variable-rate shading (VRS), and indicates whether or not background processing is supported.
D3D12_FEATURE_DATA_D3D12_OPTIONS7

Indicates the level of support that the adapter provides for mesh and amplification shaders, and for sampler feedback.
D3D12_FEATURE_DATA_D3D12_OPTIONS8

Indicates whether or not unaligned block-compressed textures are supported.
D3D12_FEATURE_DATA_D3D12_OPTIONS9

Indicates whether or not support exists for mesh shaders, values of SV_RenderTargetArrayIndex that are 8 or greater, typed resource 64-bit integer atomics, derivative and derivative-dependent texture sample operations, and the level of support for WaveMMA (wave_matrix) operations.
D3D12_FEATURE_DATA_DISPLAYABLE

This feature is currently in preview.
D3D12_FEATURE_DATA_EXISTING_HEAPS

Provides detail about whether the adapter supports creating heaps from existing system memory.
D3D12_FEATURE_DATA_FEATURE_LEVELS

Describes info about the feature levels supported by the current graphics driver.
D3D12_FEATURE_DATA_FORMAT_INFO

Describes a DXGI data format and plane count.
D3D12_FEATURE_DATA_FORMAT_SUPPORT

Describes which resources are supported by the current graphics driver for a given format.
D3D12_FEATURE_DATA_GPU_VIRTUAL_ADDRESS_SUPPORT

Details the adapter's GPU virtual address space limitations, including maximum address bits per resource and per process.
D3D12_FEATURE_DATA_MULTISAMPLE_QUALITY_LEVELS

Describes the multi-sampling image quality levels for a given format and sample count.
D3D12_FEATURE_DATA_PROTECTED_RESOURCE_SESSION_SUPPORT

Indicates the level of support for protected resource sessions.
D3D12_FEATURE_DATA_PROTECTED_RESOURCE_SESSION_TYPE_COUNT

Indicates a count of protected resource session types.
D3D12_FEATURE_DATA_PROTECTED_RESOURCE_SESSION_TYPES

Indicates a list of protected resource session types.
D3D12_FEATURE_DATA_QUERY_META_COMMAND

Indicates the level of support that the adapter provides for metacommands.
D3D12_FEATURE_DATA_ROOT_SIGNATURE

Indicates root signature version support.
D3D12_FEATURE_DATA_SERIALIZATION

Indicates the level of support for heap serialization.
D3D12_FEATURE_DATA_SHADER_CACHE

Describes the level of shader caching supported in the current graphics driver.
D3D12_FEATURE_DATA_SHADER_MODEL

Contains the supported shader model.
D3D12_FUNCTION_DESC

Describes a function.
D3D12_GLOBAL_ROOT_SIGNATURE

Defines a global root signature state suboject that will be used with associated shaders.
D3D12_GPU_DESCRIPTOR_HANDLE

Describes a GPU descriptor handle.
D3D12_GPU_VIRTUAL_ADDRESS_AND_STRIDE

Represents a GPU virtual address and indexing stride.
D3D12_GPU_VIRTUAL_ADDRESS_RANGE

Represents a GPU virtual address range.
D3D12_GPU_VIRTUAL_ADDRESS_RANGE_AND_STRIDE

Represents a GPU virtual address range and stride.
D3D12_GRAPHICS_PIPELINE_STATE_DESC

Describes a graphics pipeline state object.
D3D12_HEAP_DESC

Describes a heap.
D3D12_HEAP_PROPERTIES

Describes heap properties.
D3D12_HIT_GROUP_DESC

Describes a raytracing hit group state subobject that can be included in a state object.
D3D12_INDEX_BUFFER_VIEW

Describes the index buffer to view.
D3D12_INDIRECT_ARGUMENT_DESC

Describes an indirect argument (an indirect parameter), for use with a command signature.
D3D12_INFO_QUEUE_FILTER

Debug message filter; contains a lists of message types to allow or deny.
D3D12_INFO_QUEUE_FILTER_DESC

Allow or deny certain types of messages to pass through a filter.
D3D12_INPUT_ELEMENT_DESC

Describes a single element for the input-assembler stage of the graphics pipeline.
D3D12_INPUT_LAYOUT_DESC

Describes the input-buffer data for the input-assembler stage.
D3D12_LIBRARY_DESC

Describes a library.
D3D12_LOCAL_ROOT_SIGNATURE

Defines a local root signature state subobject that will be used with associated shaders.
D3D12_MEMCPY_DEST

Describes the destination of a memory copy operation.
D3D12_MESSAGE

A debug message in the Information Queue.
D3D12_META_COMMAND_DESC

Describes a meta command.
D3D12_META_COMMAND_PARAMETER_DESC

Describes a parameter to a meta command.
D3D12_MIP_REGION

Describes the dimensions of a mip region.
D3D12_NODE_MASK

A state subobject that identifies the GPU nodes to which the state object applies.
D3D12_PACKED_MIP_INFO

Describes the tile structure of a tiled resource with mipmaps.
D3D12_PARAMETER_DESC

Describes a function parameter.
D3D12_PIPELINE_STATE_STREAM_DESC

Describes a pipeline state stream.
D3D12_PLACED_SUBRESOURCE_FOOTPRINT

Describes the footprint of a placed subresource, including the offset and the D3D12_SUBRESOURCE_FOOTPRINT.
D3D12_PROTECTED_RESOURCE_SESSION_DESC

Describes flags for a protected resource session, per adapter.
D3D12_PROTECTED_RESOURCE_SESSION_DESC1

Describes flags and protection type for a protected resource session, per adapter.
D3D12_QUERY_DATA_PIPELINE_STATISTICS

Query information about graphics-pipeline activity in between calls to BeginQuery and EndQuery.
D3D12_QUERY_DATA_SO_STATISTICS

Describes query data for stream output.
D3D12_QUERY_HEAP_DESC

Describes the purpose of a query heap. A query heap contains an array of individual queries.
D3D12_RANGE

Describes a memory range.
D3D12_RANGE_UINT64

Describes a memory range in a 64-bit address space.
D3D12_RASTERIZER_DESC

Describes rasterizer state.
D3D12_RAYTRACING_AABB

Represents an axis-aligned bounding box (AABB) used as raytracing geometry.
D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_COMPACTED_SIZE_DESC

Describes the space requirement for acceleration structure after compaction.
D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_CURRENT_SIZE_DESC

Describes the space currently used by an acceleration structure..
D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_DESC

Description of the post-build information to generate from an acceleration structure. Use this structure in calls to EmitRaytracingAccelerationStructurePostbuildInfo and BuildRaytracingAccelerationStructure.
D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_SERIALIZATION_DESC

Describes the size and layout of the serialized acceleration structure and header.
D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_TOOLS_VISUALIZATION_DESC

Describes the space requirement for decoding an acceleration structure into a form that can be visualized by tools.
D3D12_RAYTRACING_ACCELERATION_STRUCTURE_PREBUILD_INFO

Represents prebuild information about a raytracing acceleration structure. Get an instance of this structure by calling GetRaytracingAccelerationStructurePrebuildInfo.
D3D12_RAYTRACING_ACCELERATION_STRUCTURE_SRV

A shader resource view (SRV) structure for storing a raytracing acceleration structure.
D3D12_RAYTRACING_GEOMETRY_AABBS_DESC

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.
D3D12_RAYTRACING_GEOMETRY_DESC

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.
D3D12_RAYTRACING_GEOMETRY_TRIANGLES_DESC

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.
D3D12_RAYTRACING_INSTANCE_DESC

Describes an instance of a raytracing acceleration structure used in GPU memory during the acceleration structure build process.
D3D12_RAYTRACING_PIPELINE_CONFIG

A state subobject that represents a raytracing pipeline configuration.
D3D12_RAYTRACING_PIPELINE_CONFIG1

A state subobject that represents a raytracing pipeline configuration, with flags.
D3D12_RAYTRACING_SHADER_CONFIG

A state subobject that represents a shader configuration.
D3D12_RENDER_PASS_BEGINNING_ACCESS

Describes the access to resource(s) that is requested by an application at the transition into a render pass.
D3D12_RENDER_PASS_BEGINNING_ACCESS_CLEAR_PARAMETERS

Describes the clear value to which resource(s) should be cleared at the beginning of a render pass.
D3D12_RENDER_PASS_DEPTH_STENCIL_DESC

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.
D3D12_RENDER_PASS_ENDING_ACCESS

Describes the access to resource(s) that is requested by an application at the transition out of a render pass.
D3D12_RENDER_PASS_ENDING_ACCESS_RESOLVE_PARAMETERS

Describes a resource to resolve to at the conclusion of a render pass.
D3D12_RENDER_PASS_ENDING_ACCESS_RESOLVE_SUBRESOURCE_PARAMETERS

Describes the subresources involved in resolving at the conclusion of a render pass.
D3D12_RENDER_PASS_RENDER_TARGET_DESC

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.
D3D12_RENDER_TARGET_BLEND_DESC

Describes the blend state for a render target.
D3D12_RENDER_TARGET_VIEW_DESC

Describes the subresources from a resource that are accessible by using a render-target view.
D3D12_RESOURCE_ALIASING_BARRIER

Describes the transition between usages of two different resources that have mappings into the same heap.
D3D12_RESOURCE_ALLOCATION_INFO

Describes parameters needed to allocate resources.
D3D12_RESOURCE_ALLOCATION_INFO1

Describes parameters needed to allocate resources, including offset.
D3D12_RESOURCE_BARRIER

Describes a resource barrier (transition in resource use).
D3D12_RESOURCE_DESC

Describes a resource, such as a texture. This structure is used extensively.
D3D12_RESOURCE_DESC1

Describes a resource, such as a texture, including a mip region. This structure is used in several methods.
D3D12_RESOURCE_TRANSITION_BARRIER

Describes the transition of subresources between different usages.
D3D12_RESOURCE_UAV_BARRIER

Represents a resource in which all UAV accesses must complete before any future UAV accesses can begin.
D3D12_ROOT_CONSTANTS

Describes constants inline in the root signature that appear in shaders as one constant buffer.
D3D12_ROOT_DESCRIPTOR

Describes descriptors inline in the root signature version 1.0 that appear in shaders.
D3D12_ROOT_DESCRIPTOR_TABLE

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.
D3D12_ROOT_DESCRIPTOR_TABLE1

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.
D3D12_ROOT_DESCRIPTOR1

Describes descriptors inline in the root signature version 1.1 that appear in shaders.
D3D12_ROOT_PARAMETER

Describes the slot of a root signature version 1.0.
D3D12_ROOT_PARAMETER1

Describes the slot of a root signature version 1.1.
D3D12_ROOT_SIGNATURE_DESC

Describes the layout of a root signature version 1.0.
D3D12_ROOT_SIGNATURE_DESC1

Describes the layout of a root signature version 1.1.
D3D12_RT_FORMAT_ARRAY

Wraps an array of render target formats.
D3D12_SAMPLE_POSITION

Describes a sub-pixel sample position for use with programmable sample positions.
D3D12_SAMPLER_DESC

Describes a sampler state.
D3D12_SERIALIZED_DATA_DRIVER_MATCHING_IDENTIFIER

Opaque data structure describing driver versioning for a serialized acceleration structure.
D3D12_SERIALIZED_RAYTRACING_ACCELERATION_STRUCTURE_HEADER

Defines the header for a serialized raytracing acceleration structure.
D3D12_SHADER_BUFFER_DESC

Describes a shader constant-buffer.
D3D12_SHADER_BYTECODE

Describes shader data.
D3D12_SHADER_CACHE_SESSION_DESC

Describes a shader cache session.
D3D12_SHADER_DESC

Describes a shader.
D3D12_SHADER_INPUT_BIND_DESC

Describes how a shader resource is bound to a shader input.
D3D12_SHADER_RESOURCE_VIEW_DESC

Describes a shader-resource view.
D3D12_SHADER_TYPE_DESC

Describes a shader-variable type.
D3D12_SHADER_VARIABLE_DESC

Describes a shader variable.
D3D12_SIGNATURE_PARAMETER_DESC

Describes a shader signature.
D3D12_SO_DECLARATION_ENTRY

Describes a vertex element in a vertex buffer in an output slot.
D3D12_STATE_OBJECT_CONFIG

Defines general properties of a state object.
D3D12_STATE_OBJECT_DESC

Description of a state object. Pass this structure into ID3D12Device::CreateStateObject.
D3D12_STATE_SUBOBJECT

Represents a subobject within a state object description. Use with D3D12_STATE_OBJECT_DESC.
D3D12_STATIC_SAMPLER_DESC

Describes a static sampler.
D3D12_STREAM_OUTPUT_BUFFER_VIEW

Describes a stream output buffer.
D3D12_STREAM_OUTPUT_DESC

Describes a streaming output buffer.
D3D12_SUBOBJECT_TO_EXPORTS_ASSOCIATION

Associates a subobject defined directly in a state object with shader exports.
D3D12_SUBRESOURCE_DATA

Describes subresource data.
D3D12_SUBRESOURCE_FOOTPRINT

Describes the format, width, height, depth, and row-pitch of the subresource into the parent resource.
D3D12_SUBRESOURCE_INFO

Describes subresource data.
D3D12_SUBRESOURCE_RANGE_UINT64

Describes a subresource memory range.
D3D12_SUBRESOURCE_TILING

Describes a tiled subresource volume.
D3D12_TEX1D_ARRAY_DSV

Describes the subresources from an array of 1D textures to use in a depth-stencil view.
D3D12_TEX1D_ARRAY_RTV

Describes the subresources from an array of 1D textures to use in a render-target view.
D3D12_TEX1D_ARRAY_SRV

Describes the subresources from an array of 1D textures to use in a shader-resource view.
D3D12_TEX1D_ARRAY_UAV

Describes an array of unordered-access 1D texture resources.
D3D12_TEX1D_DSV

Describes the subresource from a 1D texture that is accessible to a depth-stencil view.
D3D12_TEX1D_RTV

Describes the subresource from a 1D texture to use in a render-target view.
D3D12_TEX1D_SRV

Specifies the subresource from a 1D texture to use in a shader-resource view.
D3D12_TEX1D_UAV

Describes a unordered-access 1D texture resource.
D3D12_TEX2D_ARRAY_DSV

Describes the subresources from an array of 2D textures that are accessible to a depth-stencil view.
D3D12_TEX2D_ARRAY_RTV

Describes the subresources from an array of 2D textures to use in a render-target view.
D3D12_TEX2D_ARRAY_SRV

Describes the subresources from an array of 2D textures to use in a shader-resource view.
D3D12_TEX2D_ARRAY_UAV

Describes an array of unordered-access 2D texture resources.
D3D12_TEX2D_DSV

Describes the subresource from a 2D texture that is accessible to a depth-stencil view.
D3D12_TEX2D_RTV

Describes the subresource from a 2D texture to use in a render-target view.
D3D12_TEX2D_SRV

Describes the subresource from a 2D texture to use in a shader-resource view.
D3D12_TEX2D_UAV

Describes a unordered-access 2D texture resource.
D3D12_TEX2DMS_ARRAY_DSV

Describes the subresources from an array of multi sampled 2D textures for a depth-stencil view.
D3D12_TEX2DMS_ARRAY_RTV

Describes the subresources from an array of multi sampled 2D textures to use in a render-target view.
D3D12_TEX2DMS_ARRAY_SRV

Describes the subresources from an array of multi sampled 2D textures to use in a shader-resource view.
D3D12_TEX2DMS_DSV

Describes the subresource from a multi sampled 2D texture that is accessible to a depth-stencil view.
D3D12_TEX2DMS_RTV

Describes the subresource from a multi sampled 2D texture to use in a render-target view.
D3D12_TEX2DMS_SRV

Describes the subresources from a multi sampled 2D texture to use in a shader-resource view.
D3D12_TEX3D_RTV

Describes the subresources from a 3D texture to use in a render-target view.
D3D12_TEX3D_SRV

Describes the subresources from a 3D texture to use in a shader-resource view.
D3D12_TEX3D_UAV

Describes a unordered-access 3D texture resource.
D3D12_TEXCUBE_ARRAY_SRV

Describes the subresources from an array of cube textures to use in a shader-resource view.
D3D12_TEXCUBE_SRV

Describes the subresource from a cube texture to use in a shader-resource view.
D3D12_TEXTURE_COPY_LOCATION

Describes a portion of a texture for the purpose of texture copies.
D3D12_TILE_REGION_SIZE

Describes the size of a tiled region.
D3D12_TILE_SHAPE

Describes the shape of a tile by specifying its dimensions.
D3D12_TILED_RESOURCE_COORDINATE

Describes the coordinates of a tiled resource.
D3D12_UNORDERED_ACCESS_VIEW_DESC

Describes the subresources from a resource that are accessible by using an unordered-access view.
D3D12_VERSIONED_DEVICE_REMOVED_EXTENDED_DATA

Represents versioned Device Removed Extended Data (DRED) data.
D3D12_VERSIONED_ROOT_SIGNATURE_DESC

Holds any version of a root signature description, and is designed to be used with serialization/deserialization functions.
D3D12_VERTEX_BUFFER_VIEW

Describes a vertex buffer view.
D3D12_VIEW_INSTANCE_LOCATION

Specifies the viewport/stencil and render target associated with a view instance.
D3D12_VIEW_INSTANCING_DESC

Specifies parameters used during view instancing configuration.
D3D12_VIEWPORT

Describes the dimensions of a viewport.
D3D12_WRITEBUFFERIMMEDIATE_PARAMETER

Specifies the immediate value and destination address written using ID3D12CommandList2::WriteBufferImmediate.