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

Title Description
D3D_ROOT_SIGNATURE_VERSION Specifies the version of root signature layout.
D3D_SHADER_MODEL Specifies a shader model.
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_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_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 Specifies a Direct3D 12 feature or feature set to query about. When you want to query for the level to which an adapter supports a feature, pass one of these values to ID3D12Device::CheckFeatureSupport.
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_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_LOGIC_OP Specifies logical operations to configure for a render target.
D3D12_MEMORY_POOL Specifies the memory pool for the heap.
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_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_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 Specifies 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_SERIALIZED_DATA_TYPE Specifies the type of serialized data. Use a value from this enumeration when calling ID3D12Device5::CheckDriverMatchingIdentifier.
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_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_VIEW_INSTANCING_FLAGS Specifies options for view instancing.
D3D12_VIEW_INSTANCING_TIER Indicates the tier level at which view instancing is supported.
D3D12_WRITEBUFFERIMMEDIATE_MODE Specifies the mode used by a WriteBufferImmediate operation.
DML_BINDING_TYPE Defines constants that specify the nature of the resource(s) referred to by a binding description (a DML_BINDING_DESC structure).
DML_CONVOLUTION_DIRECTION Defines constants that specify a direction for the DirectML convolution operator (as described by the DML_CONVOLUTION_OPERATOR_DESC structure).
DML_CONVOLUTION_MODE Defines constants that specify a mode for the DirectML convolution operator (as described by the DML_CONVOLUTION_OPERATOR_DESC structure).
DML_CREATE_DEVICE_FLAGS Supplies additional device creation options to DMLCreateDevice. Values can be bitwise OR'd together.
DML_EXECUTION_FLAGS Supplies options to DirectML to control execution of operators. These flags can be bitwise OR'd together to specify multiple flags at once.
DML_FEATURE Defines a set of optional features and capabilities that can be queried from the DirectML device.
DML_INTERPOLATION_MODE Defines constants that specify a mode for the DirectML upsample 2-D operator (as described by the DML_UPSAMPLE_2D_OPERATOR_DESC structure).
DML_MATRIX_TRANSFORM Defines constants that specify a matrix transform to be applied to a DirectML tensor.
DML_OPERATOR_TYPE Defines the type of an operator description.
DML_PADDING_MODE Defines constants that specify a mode for the DirectML pad operator (as described by the DML_PADDING_OPERATOR_DESC structure).
DML_RECURRENT_NETWORK_DIRECTION Defines constants that specify a direction for a recurrent DirectML operator.
DML_REDUCE_FUNCTION Defines constants that specify the specific reduction algorithm to use for the DirectML reduce operator (as described by the DML_REDUCE_OPERATOR_DESC structure).
DML_TENSOR_DATA_TYPE Specifies the data type of the values in a tensor. DirectML operators may not support all data types; see the documentation for each specific operator to find which data types it supports.
DML_TENSOR_FLAGS Specifies additional options in a tensor description. Values can be bitwise OR'd together.
DML_TENSOR_TYPE Identifies a type of tensor description.

Functions

Title Description
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.
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).
BindInputs Binds a set of resources as input tensors.
BindOutputs Binds a set of resources as output tensors.
BindPersistentResource Binds a buffer as a persistent resource. You can determine the required size of this buffer range by calling IDMLDispatchable::GetBindingProperties.
BindTemporaryResource Binds a buffer to use as temporary scratch memory. You can determine the required size of this buffer range by calling IDMLDispatchable::GetBindingProperties.
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.
CheckFeatureSupport Gets information about the optional features and capabilities that are supported by the DirectML device.
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 to the specified integer values.
Close Indicates that recording to the command list has finished.
CompileOperator Compiles an operator into an object that can be dispatched to the GPU.
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.
CreateBindingTable Creates a binding table, which is an object that can be used to bind resources (such as tensors) to the pipeline.
CreateCommandAllocator Creates a command allocator object.
CreateCommandList Creates a command list.
CreateCommandQueue Creates a command queue.
CreateCommandRecorder Creates a DirectML command recorder.
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.
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.
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.
CreateMetaCommand Creates an instance of the specified meta command.
CreateOperator Creates a DirectML operator.
CreateOperatorInitializer Creates an object that can be used to initialize compiled operators.
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.
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, which is 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.
CreateShaderResourceView Creates a shader-resource view for accessing data in a resource.
CreateSharedHandle Creates a shared handle to an 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 D3D12 device to use for D3D11 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.
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.
DiscardResource Discards a resource.
Dispatch Executes a command list from a thread group.
DispatchRays Launch the threads of a ray generation shader.
DMLCreateDevice Creates a DirectML device for a given Direct3D 12 device.
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.
Evict Evicts one or more pageable objects from GPU memory. Also see IDMLDevice::MakeResident.
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.
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.
GetBindingProperties Retrieves the binding properties for a dispatchable object (an operator initializer, or a compiled operator).
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.
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.
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 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.
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.
GetDevice Retrieves the DirectML device that was used to create this object.
GetDeviceRemovedReason Gets the reason that the device was removed.
GetDeviceRemovedReason Retrieves the reason that the DirectML 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.
GetParentDevice Retrieves the Direct3D 12 device that was used to create this DirectML device.
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.
GetPrivateData Gets application-defined data from a DirectML 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.
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.
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.
MakeResident Causes one or more pageable objects to become resident in GPU memory. Also see IDMLDevice::Evict.
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.
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.
RecordDispatch Records execution of a dispatchable object (an operator initializer, or a compiled operator) onto a command list.
ReleaseWrappedResources Releases D3D11 resources that were wrapped for D3D 11on12.
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.
Reset Resets the binding table to wrap a new range of descriptors, potentially for a different operator or initializer. This allows dynamic reuse of the binding table.
Reset Resets the initializer to handle initialization of a new set of operators.
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.
RSSetScissorRects Binds an array of scissor rectangles to the rasterizer stage.
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.
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.
SetDescriptorHeaps Changes the currently bound descriptor heaps that are associated with a command list.
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.
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.
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.
SetMuteDebugOutput Determine whether to mute DirectML from sending messages to the ID3D12InfoQueue.
SetName Associates a name with the device object. This name is for use in debug diagnostics and tools.
SetName Associates a name with the DirectML 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.
SetPrivateData Sets application-defined data to a DirectML 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.
SetPrivateDataInterface Associates an IUnknown-derived interface with the DirectML 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.
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.
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.
Unmap 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.
UpdateTileMappings Updates mappings of tile locations in reserved resources to memory locations in a resource heap.
Wait 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

Title Description
ID3D11On12Device Handles the creation, wrapping, and releasing of D3D11 resources for Direct3D11on12.
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 A debug interface controls debug settings and validates pipeline state. It can only be used if the debug layer is turned on.
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.
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.
ID3D12Device5 Represents a virtual adapter. This interface extends ID3D12Device4.
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.
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.
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.
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.
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.
IDMLBindingTable Wraps a range of an application-managed descriptor heap, and is used by DirectML to create bindings for resources. To create this object, call IDMLDevice::CreateBindingTable.
IDMLCommandRecorder Records dispatches of DirectML work into a Direct3D 12 command list.
IDMLCompiledOperator Represents a compiled, efficient form of an operator suitable for execution on the GPU. To create this object, call IDMLDevice::CompileOperator.
IDMLDebugDevice Controls the DirectML debug layers.
IDMLDevice Represents a DirectML device, which is used to create operators, binding tables, command recorders, and other objects.
IDMLDeviceChild An interface implemented by all objects created from the DirectML device.
IDMLDispatchable Implemented by objects that can be recorded into a command list for dispatch on the GPU, using IDMLCommandRecorder::RecordDispatch.
IDMLObject An interface from which IDMLDevice and IDMLDeviceChild inherit directly (and all other interfaces, indirectly).
IDMLOperator Represents a DirectML operator.
IDMLOperatorInitializer Represents a specialized object whose purpose is to initialize compiled operators. To create an instance of this object, call IDMLDevice::CreateOperatorInitializer.
IDMLPageable Implemented by objects that can be evicted from GPU memory, and hence that can be supplied to IDMLDevice::Evict and IDMLDevice::MakeResident.

Structures

Title Description
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_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_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_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_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_ROOT_SIGNATURE Indicates root signature version support.
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_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_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 stucture 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_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_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_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 appear one after the other in a descriptor heap.
D3D12_ROOT_DESCRIPTOR_TABLE1 Describes the root signature 1.1 layout of a descriptor table as a collection of descriptor ranges that appear one after the other in a descriptor heap.
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_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 with in 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.
DML_ACTIVATION_ELU_OPERATOR_DESC Describes a DirectML operator that performs an exponential linear unit (ELU) activation function on every element in the input, f(x) = if x >= 0 then x else (exp(x) - 1) * alpha.
DML_ACTIVATION_HARD_SIGMOID_OPERATOR_DESC Describes a DirectML activation operator that performs a hard sigmoid function on every element in the input, f(x) = max(0, min(alpha * x + beta, 1)).
DML_ACTIVATION_HARDMAX_OPERATOR_DESC Describes a DirectML activation operator that performs a hardmax function on the input, f(x) = if x_i == max(x) then 1 else 0 (but only for the first element in the axis).
DML_ACTIVATION_IDENTITY_OPERATOR_DESC Describes a DirectML activation operator that performs the identity function f(x) = x. The operator effectively copies its input tensor to the output.
DML_ACTIVATION_LEAKY_RELU_OPERATOR_DESC Describes a DirectML operator that performs a leaky rectified linear unit (ReLU) activation function on every element in the input, f(x) = if x >= 0 then x else x * alpha.
DML_ACTIVATION_LINEAR_OPERATOR_DESC Describes a DirectML operator that performs a linear activation function on every element in the input, f(x) = alpha * x + beta.
DML_ACTIVATION_LOG_SOFTMAX_OPERATOR_DESC Describes a DirectML operator that performs a log-of-softmax activation function on the input, f(x_i) = log(exp(x_i - max(X)) / sum(exp(X - max(X)))) = (x_i - max(X)) - log(sum(exp(x - max(X)))).
DML_ACTIVATION_PARAMETERIZED_RELU_OPERATOR_DESC Describes a DirectML operator that performs a parameterized rectified linear unit (ReLU) activation function on every element in the input, f(x) = if x >= 0 then x else slope * x.
DML_ACTIVATION_PARAMETRIC_SOFTPLUS_OPERATOR_DESC Describes a DirectML operator that performs a parametric softplus activation function on every element in the input, f(x) = alpha * loge(1 + expe(beta * x)).
DML_ACTIVATION_RELU_OPERATOR_DESC Describes a DirectML operator that performs a rectified linear unit (ReLU) activation function on every element in the input, f(x) = max(0, x).
DML_ACTIVATION_SCALED_ELU_OPERATOR_DESC Describes a DirectML operator that performs a scaled exponential linear unit (ELU) activation function on every element in the input, f(x) = if x > 0 then gamma * x else gamma * (alpha * e^x - alpha).
DML_ACTIVATION_SCALED_TANH_OPERATOR_DESC Describes a DirectML operator that performs a scaled hyperbolic tangent activation function on every element in the input, f(x) = alpha * tanh(beta * x).
DML_ACTIVATION_SIGMOID_OPERATOR_DESC Describes a DirectML operator that performs a sigmoid activation function on every element in the input, f(x) = 1 / (1 + exp(-x)).
DML_ACTIVATION_SOFTMAX_OPERATOR_DESC Describes a DirectML operator that performs a softmax activation function on the input, f(x_i) = expe(x_i) / sum(expe(X)) = exp(x_i - max(X)) / sum(expe(x - max(X))).
DML_ACTIVATION_SOFTPLUS_OPERATOR_DESC Describes a DirectML operator that performs a softplus activation function on every element in the input, f(x) = ln(1 + expe(x)).
DML_ACTIVATION_SOFTSIGN_OPERATOR_DESC Describes a DirectML operator that performs a softsign activation function on every element in the input, f(x) = x / (1 + abs(x)).
DML_ACTIVATION_TANH_OPERATOR_DESC Describes a DirectML operator that performs a hyperbolic tangent activation function on every element in the input, f(x) = (1 - exp(-2 * x)) / (1 + exp(-2 * x)).
DML_ACTIVATION_THRESHOLDED_RELU_OPERATOR_DESC Describes a DirectML operator that performs a thresholded rectified linear unit (ReLU) activation function on every element in the input, f(x) = if x > alpha then x else 0.
DML_AVERAGE_POOLING_OPERATOR_DESC Describes a DirectML operator that performs an average pooling function on the input, y = (x1 + x2 + …) / pool_size.
DML_BATCH_NORMALIZATION_OPERATOR_DESC Describes a DirectML operator that performs a batch normalization function on the input, y = scale * (x - batchMean) / sqrt(batchVariance + epsilon) + bias.
DML_BINDING_DESC Contains the description of a binding so that you can add it to the binding table via a call to one of the IDMLBindingTable methods.
DML_BINDING_PROPERTIES Contains information about the binding requirements of a particular compiled operator, or operator initializer. This struct is retrieved from IDMLDispatchable::GetBindingProperties.
DML_BINDING_TABLE_DESC Specifies parameters to IDMLDevice::CreateBindingTable and IDMLBindingTable::Reset.
DML_BUFFER_ARRAY_BINDING Specifies a resource binding that is an array of individual buffer bindings.
DML_BUFFER_BINDING Specifies a resource binding described by a range of bytes in a Direct3D 12 buffer, represented by an offset and size into an ID3D12Resource.
DML_BUFFER_TENSOR_DESC Describes a tensor that will be stored in a Direct3D 12 buffer resource.
DML_CAST_OPERATOR_DESC Describes a DirectML data reorganization operator that performs the cast function f(x) = cast(x), casting each element in the input to the data type of the output tensor, and storing the result in the corresponding element in the output.
DML_CONVOLUTION_OPERATOR_DESC Describes a DirectML matrix multiplication operator that performs a convolution function on the input, out[j] = x[i]*w[0] + x[i+1]*w[1] + x[i+2]*w[2] + ... + x[i+k]*w[k] + bias.
DML_DEPTH_TO_SPACE_OPERATOR_DESC Describes a DirectML data reorganization operator that rearranges (permutes) data from depth into blocks of spatial data.
DML_ELEMENT_WISE_ABS_OPERATOR_DESC Describes a DirectML math operator that performs the element-wise absolute value function f(x) = abs(x * scale + bias), where the scale and bias terms are optional. The absolute value of x is its magnitude without regard to its sign.
DML_ELEMENT_WISE_ACOS_OPERATOR_DESC Describes a DirectML trigonometric operator that performs the element-wise arccosine function f(x) = acos(x * scale + bias), where the scale and bias terms are optional.
DML_ELEMENT_WISE_ADD_OPERATOR_DESC Describes a DirectML math operator that performs the function of adding every element in ATensor to its corresponding element in BTensor, f(a, b) = a + b.
DML_ELEMENT_WISE_ASIN_OPERATOR_DESC Describes a DirectML trigonometric operator that performs the element-wise arcsine function f(x) = asin(x * scale + bias), where the scale and bias terms are optional.
DML_ELEMENT_WISE_ATAN_OPERATOR_DESC Describes a DirectML trigonometric operator that performs the element-wise arctangent function f(x) = atan(x * scale + bias), where the scale and bias terms are optional.
DML_ELEMENT_WISE_CEIL_OPERATOR_DESC Describes a DirectML math operator that performs the element-wise ceiling function f(x) = ceil(x * scale + bias), where the scale and bias terms are optional. The ceiling of x is the smallest integer that is greater than or equal to x.
DML_ELEMENT_WISE_CLIP_OPERATOR_DESC Describes a DirectML math operator that performs the element-wise clip function f(x) = clamp(x * scale + bias, minValue, maxValue), where the scale and bias terms are optional, and where clamp(x) = min(maxValue, max(minValue, x)).
DML_ELEMENT_WISE_CONSTANT_POW_OPERATOR_DESC Describes a DirectML operator that performs the element-wise constant power function f(x) = pow(x * scale + bias, exponent), where the scale and bias terms are optional. The power function raises every element in the input to the power of the exponent.
DML_ELEMENT_WISE_COS_OPERATOR_DESC Describes a DirectML trigonometric operator that performs the element-wise cosine function f(x) = cos(x * scale + bias), where the scale and bias terms are optional.
DML_ELEMENT_WISE_DEQUANTIZE_LINEAR_OPERATOR_DESC Describes a DirectML operator that performs the linear dequantize function on every element in InputTensor with respect to its corresponding element in ScaleTensor and ZeroPointTensor, f(input, scale, zero_point) = (input - zero_point) * scale.
DML_ELEMENT_WISE_DIVIDE_OPERATOR_DESC Describes a DirectML math operator that performs the function of dividing every element in ATensor by its corresponding element in BTensor, f(a, b) = a / b.
DML_ELEMENT_WISE_EXP_OPERATOR_DESC Describes a DirectML math operator that performs the element-wise natural exponential function f(x) = exp(x * scale + bias), where the scale and bias terms are optional.
DML_ELEMENT_WISE_FLOOR_OPERATOR_DESC Describes a DirectML math operator that performs the element-wise floor function f(x) = floor(x * scale + bias), where the scale and bias terms are optional. The floor of x is the largest integer that is less than or equal to x.
DML_ELEMENT_WISE_IDENTITY_OPERATOR_DESC Describes a DirectML generic operator that performs the element-wise identity function f(x) = x * scale + bias. The operator effectively copies its input tensor to the output, while applying optional scale and bias terms.
DML_ELEMENT_WISE_LOG_OPERATOR_DESC Describes a DirectML math operator that performs the element-wise natural logarithm function f(x) = log(x * scale + bias), where the scale and bias terms are optional.
DML_ELEMENT_WISE_LOGICAL_AND_OPERATOR_DESC Describes a DirectML math operator that performs a logical AND function between every element in ATensor and its corresponding element in BTensor, f(a, b) = a && b.
DML_ELEMENT_WISE_LOGICAL_EQUALS_OPERATOR_DESC Describes a DirectML math operator that performs a logical equality function between every element in ATensor and its corresponding element in BTensor, f(a, b) = (a == b).
DML_ELEMENT_WISE_LOGICAL_GREATER_THAN_OPERATOR_DESC Describes a DirectML math operator that performs a logical greater-than function between every element in ATensor and its corresponding element in BTensor, f(a, b) = (a > b).
DML_ELEMENT_WISE_LOGICAL_LESS_THAN_OPERATOR_DESC Describes a DirectML math operator that performs a logical less-than function between every element in ATensor and its corresponding element in BTensor, f(a, b) = (a < b).
DML_ELEMENT_WISE_LOGICAL_NOT_OPERATOR_DESC Describes a DirectML math operator that performs a logical NOT function on every element in the input, f(x) = !x.
DML_ELEMENT_WISE_LOGICAL_OR_OPERATOR_DESC Describes a DirectML math operator that performs a logical OR function between every element in ATensor and its corresponding element in BTensor, f(a, b) = a b.
DML_ELEMENT_WISE_LOGICAL_XOR_OPERATOR_DESC Describes a DirectML math operator that performs a logical exclusive OR (XOR) function between every element in ATensor and its corresponding element in BTensor, f(a, b) = a xor b.
DML_ELEMENT_WISE_MAX_OPERATOR_DESC Describes a DirectML math reduction operator that performs a maximum function between every element in ATensor and its corresponding element in BTensor, f(a, b) = max(a, b).
DML_ELEMENT_WISE_MEAN_OPERATOR_DESC Describes a DirectML math reduction operator that performs an arithmetic mean function between every element in ATensor and its corresponding element in BTensor, f(a, b) = (a + b) / 2.
DML_ELEMENT_WISE_MIN_OPERATOR_DESC Describes a DirectML math reduction operator that performs a minimum function between every element in ATensor and its corresponding element in BTensor, f(a, b) = min(a, b).
DML_ELEMENT_WISE_MULTIPLY_OPERATOR_DESC Describes a DirectML math operator that performs the function of multiplying every element in ATensor by its corresponding element in BTensor, f(a, b) = a * b.
DML_ELEMENT_WISE_POW_OPERATOR_DESC Describes a DirectML math operator that performs the element-wise power function f(x, exponent) = pow(x * scale + bias, exponent), where the scale and bias terms are optional.
DML_ELEMENT_WISE_QUANTIZE_LINEAR_OPERATOR_DESC Describes a DirectML operator that performs the linear quantize function on every element in InputTensor with respect to its corresponding element in ScaleTensor and ZeroPointTensor, f(input, scale, zero_point) = clamp(round(input / scale) + zero_point, 0, 255).
DML_ELEMENT_WISE_RECIP_OPERATOR_DESC Describes a DirectML math operator that performs a reciprocal function on every element in the input, f(x) = 1 / (x * scale + bias), where the scale and bias terms are optional.
DML_ELEMENT_WISE_SIN_OPERATOR_DESC Describes a DirectML trigonometric operator that performs the element-wise sine function f(x) = sin(x * scale + bias), where the scale and bias terms are optional.
DML_ELEMENT_WISE_SQRT_OPERATOR_DESC Describes a DirectML math operator that performs a square root function on every element in the input, f(x) = sqrt(x * scale + bias), where the scale and bias terms are optional.
DML_ELEMENT_WISE_SUBTRACT_OPERATOR_DESC Describes a DirectML math operator that performs the function of subtracting every element in BTensor from its corresponding element in ATensor, f(a, b) = a - b.
DML_ELEMENT_WISE_TAN_OPERATOR_DESC Describes a DirectML trigonometric operator that performs the element-wise tangent function f(x) = tan(x * scale + bias), where the scale and bias terms are optional.
DML_ELEMENT_WISE_THRESHOLD_OPERATOR_DESC Describes a DirectML math operator that performs the element-wise threshold function f(x) = max(x * scale + bias, min), where the scale and bias terms are optional. The threshold of x with respect to min is the larger of the two values.
DML_FEATURE_DATA_TENSOR_DATA_TYPE_SUPPORT Provides detail about whether a DirectML device supports a particular data type within tensors.
DML_FEATURE_QUERY_TENSOR_DATA_TYPE_SUPPORT Used to query a DirectML device for its support for a particular data type within tensors.
DML_GATHER_OPERATOR_DESC Describes a DirectML data reorganization operator which, when given a data tensor of rank r >= 1, and an indices tensor of rank q, gathers the entries in the axis dimension of the data (by default, the outermost one is axis == 0) indexed by indices, and concatenates them in an output tensor of rank q + (r - 1).
DML_GEMM_OPERATOR_DESC Describes a DirectML operator that performs a general matrix multiplication function on the input, y = alpha * transposeA(A) * transposeB(B) + beta * C .
DML_GRU_OPERATOR_DESC Describes a DirectML deep learning operator that performs a (standard layers) one-layer gated recurrent unit (GRU) function on the input.
DML_JOIN_OPERATOR_DESC Describes a DirectML operator that performs a join function on an array of input tensors.
DML_LOCAL_RESPONSE_NORMALIZATION_OPERATOR_DESC Describes a DirectML operator that performs a local response normalization (LRN) function on the input, y = x / (bias + (alpha / size) * sum(xi^2 for every xi in the local region))^beta.
DML_LP_NORMALIZATION_OPERATOR_DESC Describes a DirectML operator that performs an Lp-normalization function along the specified axis of the input tensor.
DML_LP_POOLING_OPERATOR_DESC Describes a DirectML operator that performs an Lp pooling function across the input tensor (according to kernel sizes, stride sizes, and pad lengths), y = (x1^p + x2^p + ... + xn^p) ^ (1/p) where X -> Y reduced for each kernel.
DML_LSTM_OPERATOR_DESC Describes a DirectML deep learning operator that performs a one-layer long short term memory (LSTM) function on the input.
DML_MAX_POOLING_OPERATOR_DESC Describes a DirectML operator that performs a max pooling function across the input tensor (according to kernel sizes, stride sizes, and pad lengths), y = max(x1 + x2 + … x_pool_size).
DML_MEAN_VARIANCE_NORMALIZATION_OPERATOR_DESC Describes a DirectML operator that performs a mean variance normalization function on the input tensor.
DML_OPERATOR_DESC A generic container for an operator description. You construct DirectML operators using the parameters specified in this struct. See IDMLDevice::CreateOperator for additional details.
DML_PADDING_OPERATOR_DESC Describes a DirectML data reorganization operator that inflates the input tensor with zeroes (or some other value) on the edges.
DML_REDUCE_OPERATOR_DESC Describes a DirectML operator that performs the specified reduction function on the input.
DML_RNN_OPERATOR_DESC Describes a DirectML deep learning operator that performs a one-layer simple recurrent neural network (RNN) function on the input, Y = Activation(clip( X * Transpose(W) + Initial_h * Transpose(R) + b)).
DML_ROI_POOLING_OPERATOR_DESC Describes a DirectML operator that performs a pooling function across the input tensor (according to regions of interest, or ROIs).
DML_SCALE_BIAS Contains the values of scale and bias terms supplied to a DirectML operator. Scale and bias have the effect of applying the function g(x) = x * Scale + Bias.
DML_SIZE_2D Contains values that can represent the size (as supplied to a DirectML operator) of a 2-D plane of elements within a tensor, or a 2-D scale, or any 2-D width/height value.
DML_SLICE_OPERATOR_DESC Describes a DirectML data reorganization operator that produces a slice of the input tensor along multiple axes.
DML_SPACE_TO_DEPTH_OPERATOR_DESC Describes a DirectML data reorganization operator that rearranges blocks of spatial data into depth. The operator outputs a copy of the input tensor where values from the height and width dimensions are moved to the depth dimension.
DML_SPLIT_OPERATOR_DESC Describes a DirectML data reorganization operator that splits the input tensor into multiple output tensors, along the specified axis.
DML_TENSOR_DESC A generic container for a DirectML tensor description.
DML_TILE_OPERATOR_DESC Describes a DirectML data reorganization operator that constructs an output tensor by tiling the input tensor.
DML_TOP_K_OPERATOR_DESC Describes a DirectML reduction operator that retrieves the top K elements along a specified axis.
DML_UPSAMPLE_2D_OPERATOR_DESC Describes a DirectML imaging operator that upsamples the image contained in the input tensor. Each dimension value of the output tensor is output_dimension = floor(input_dimension * scale).
DML_VALUE_SCALE_2D_OPERATOR_DESC Describes a DirectML operator that performs an element-wise scale-and-bias function on the values in the input tensor.