Type of data contained in an input slot.

Use these values to specify the type of data for a particular input element (see {{D3D11_INPUT_ELEMENT_DESC}}) of an input-layout object.

<dd> Input data is per-vertex data. </dd>

<dd> Input data is per-instance data. </dd>

Determines the fill mode to use when rendering triangles.

This enumeration is part of a rasterizer-state object description (see {{D3D11_RASTERIZER_DESC}}).

<dd> Draw lines connecting the vertices. Adjacent vertices are not drawn. </dd>

<dd> Fill the triangles formed by the vertices. Adjacent vertices are not drawn. </dd>

Indicates triangles facing a particular direction are not drawn.

This enumeration is part of a rasterizer-state object description (see {{D3D11_RASTERIZER_DESC}}).

<dd> Always draw all triangles. </dd>

<dd> Do not draw triangles that are front-facing. </dd>

<dd> Do not draw triangles that are back-facing. </dd>

Identifies the type of resource being used.

This enumeration is used in {{ID3D11Resource::GetType}}.

<dd> Resource is of unknown type. </dd>

<dd> Resource is a buffer. </dd>

<dd> Resource is a 1D texture. </dd>

<dd> Resource is a 2D texture. </dd>

<dd> Resource is a 3D texture. </dd>

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

This enumeration is used in {{D3D11_DEPTH_STENCIL_VIEW_DESC}} to create a depth-stencil view.

<dd> {{D3D11_DSV_DIMENSION_UNKNOWN}} is not a valid value for {{D3D11_DEPTH_STENCIL_VIEW_DESC}} and is not used. </dd>

<dd> The resource will be accessed as a 1D texture. </dd>

<dd> The resource will be accessed as an array of 1D textures. </dd>

<dd> The resource will be accessed as a 2D texture. </dd>

<dd> The resource will be accessed as an array of 2D textures. </dd>

<dd> The resource will be accessed as a 2D texture with multisampling. </dd>

<dd> The resource will be accessed as an array of 2D textures with multisampling. </dd>

These flags identify the type of resource that will be viewed as a render target.

This enumeration is used in {{D3D11_RENDER_TARGET_VIEW_DESC}} to create a render-target view.

<dd> Do not use this value, as it will cause {{ID3D11Device::CreateRenderTargetView}} to fail. </dd>

<dd> The resource will be accessed as a buffer. </dd>

<dd> The resource will be accessed as a 1D texture. </dd>

<dd> The resource will be accessed as an array of 1D textures. </dd>

<dd> The resource will be accessed as a 2D texture. </dd>

<dd> The resource will be accessed as an array of 2D textures. </dd>

<dd> The resource will be accessed as a 2D texture with multisampling. </dd>

<dd> The resource will be accessed as an array of 2D textures with multisampling. </dd>

<dd> The resource will be accessed as a 3D texture. </dd>

Unordered-access view options.

This enumeration is used by a unordered access-view description (see {{D3D11_UNORDERED_ACCESS_VIEW_DESC}}).

<dd> The view type is unknown. </dd>

<dd> View the resource as a buffer. </dd>

<dd> View the resource as a 1D texture. </dd>

<dd> View the resource as a 1D texture array. </dd>

<dd> View the resource as a 2D texture. </dd>

<dd> View the resource as a 2D texture array. </dd>

<dd> View the resource as a 3D texture array. </dd>

Identifies expected resource use during rendering. The usage directly reflects whether a resource is accessible by the {{CPU}} and/or the graphics processing unit ({{GPU}}).

An application identifies the way a resource is intended to be used (its usage) in a resource description. There are several structures for creating resources including: {{D3D11_TEXTURE1D_DESC}}, {{D3D11_TEXTURE2D_DESC}}, {{D3D11_TEXTURE3D_DESC}}, and {{D3D11_BUFFER_DESC}}.<table> <tr><td> Differences between Direct3D 9 and Direct3D 10/11: In Direct3D 9, you specify the type of memory a resource should be created in at resource creation time (using {{D3DPOOL}}). It was an application's job to decide what memory pool would provide the best combination of functionality and performance. In Direct3D 10/11, an application no longer specifies what type of memory (the pool) to create a resource in. Instead, you specify the intended usage of the resource, and let the runtime (in concert with the driver and a memory manager) choose the type of memory that will achieve the best performance. </td></tr> </table>?

<dd> A resource that requires read and write access by the {{GPU}}. This is likely to be the most common usage choice. </dd>

<dd> A resource that can only be read by the {{GPU}}. It cannot be written by the {{GPU}}, and cannot be accessed at all by the {{CPU}}. This type of resource must be initialized when it is created, since it cannot be changed after creation. </dd>

<dd> A resource that is accessible by both the {{GPU}} (read only) and the {{CPU}} (write only). A dynamic resource is a good choice for a resource that will be updated by the {{CPU}} at least once per frame. To update a dynamic resource, use a Map method. For info about how to use dynamic resources, see How to: Use dynamic resources. </dd>

<dd> A resource that supports data transfer (copy) from the {{GPU}} to the {{CPU}}. </dd>

Identifies how to bind a resource to the pipeline.

In general, binding flags can be combined using a logical {{OR}} (except the constant-buffer flag); however, you should use a single flag to allow the device to optimize the resource usage.This enumeration is used by a:<ul> <li> Buffer description when creating a buffer.</li> <li>Texture description when creating a texture (see {{D3D11_TEXTURE1D_DESC}} or {{D3D11_TEXTURE2D_DESC}} or {{D3D11_TEXTURE3D_DESC}}).</li> </ul>A shader-resource buffer is {{NOT}} a constant buffer; rather, it is a texture or buffer resource that is bound to a shader, that contains texture or buffer data (it is not limited to a single element type in the buffer). A shader-resource buffer is created with the {{D3D11_BIND_SHADER_RESOURCE}} flag and is bound to the pipeline using one of these {{APIs:}} {{ID3D11DeviceContext::GSSetShaderResources}}, {{ID3D11DeviceContext::PSSetShaderResources}}, or {{ID3D11DeviceContext::VSSetShaderResources}}. Furthermore, a shader-resource buffer cannot use the {{D3D11_MAP_WRITE_NO_OVERWRITE}} flag.Note??The Direct3D 11.1 runtime, which is available starting with Windows?8, enables mapping dynamic constant buffers and shader resource views ({{SRVs}}) of dynamic buffers with {{D3D11_MAP_WRITE_NO_OVERWRITE}}. The Direct3D 11 and earlier runtimes limited mapping to vertex or index buffers. To determine if a Direct3D device supports these features, call {{ID3D11Device::CheckFeatureSupport}} with {{D3D11_FEATURE_D3D11_OPTIONS}}. CheckFeatureSupport fills members of a {{D3D11_FEATURE_DATA_D3D11_OPTIONS}} structure with the device's features. The relevant members here are MapNoOverwriteOnDynamicConstantBuffer and MapNoOverwriteOnDynamicBufferSRV.?

<dd> Bind a buffer as a vertex buffer to the input-assembler stage. </dd>

<dd> Bind a buffer as an index buffer to the input-assembler stage. </dd>

<dd> Bind a buffer as a constant buffer to a shader stage; this flag may {{NOT}} be combined with any other bind flag. </dd>

<dd> Bind a buffer or texture to a shader stage; this flag cannot be used with the {{D3D11_MAP_WRITE_NO_OVERWRITE}} flag. Note??The Direct3D 11.1 runtime, which is available starting with Windows?8, enables mapping dynamic constant buffers and shader resource views ({{SRVs}}) of dynamic buffers with {{D3D11_MAP_WRITE_NO_OVERWRITE}}. The Direct3D 11 and earlier runtimes limited mapping to vertex or index buffers. To determine if a Direct3D device supports these features, call {{ID3D11Device::CheckFeatureSupport}} with {{D3D11_FEATURE_D3D11_OPTIONS}}. CheckFeatureSupport fills members of a {{D3D11_FEATURE_DATA_D3D11_OPTIONS}} structure with the device's features. The relevant members here are MapNoOverwriteOnDynamicConstantBuffer and MapNoOverwriteOnDynamicBufferSRV. ? </dd>

<dd> Bind an output buffer for the stream-output stage. </dd>

<dd> Bind a texture as a render target for the output-merger stage. </dd>

<dd> Bind a texture as a depth-stencil target for the output-merger stage. </dd>

<dd> Bind an unordered access resource. </dd>

<dd> Set this flag to indicate that a 2D texture is used to receive output from the decoder {{API}}. The common way to create resources for a decoder output is by calling the {{ID3D11Device::CreateTexture2D}} method to create an array of 2D textures. However, you cannot use texture arrays that are created with this flag in calls to {{ID3D11Device::CreateShaderResourceView}}. Direct3D 11:??This value is not supported until Direct3D 11.1. </dd>

<dd> Set this flag to indicate that a 2D texture is used to receive input from the video encoder {{API}}. The common way to create resources for a video encoder is by calling the {{ID3D11Device::CreateTexture2D}} method to create an array of 2D textures. However, you cannot use texture arrays that are created with this flag in calls to {{ID3D11Device::CreateShaderResourceView}}. Direct3D 11:??This value is not supported until Direct3D 11.1. </dd>

Specifies the types of {{CPU}} access allowed for a resource.

This enumeration is used in {{D3D11_BUFFER_DESC}}, {{D3D11_TEXTURE1D_DESC}}, {{D3D11_TEXTURE2D_DESC}}, {{D3D11_TEXTURE3D_DESC}}. Applications may combine one or more of these flags with a logical {{OR}}. When possible, create resources with no {{CPU}} access flags, as this enables better resource optimization.The {{D3D11_RESOURCE_MISC_FLAG}} cannot be used when creating resources with {{D3D11_CPU_ACCESS}} flags.

<dd> The resource is to be mappable so that the {{CPU}} can change its contents. Resources created with this flag cannot be set as outputs of the pipeline and must be created with either dynamic or staging usage (see {{D3D11_USAGE}}). </dd>

<dd> The resource is to be mappable so that the {{CPU}} can read its contents. Resources created with this flag cannot be set as either inputs or outputs to the pipeline and must be created with staging usage (see {{D3D11_USAGE}}). </dd>

Identifies options for resources.

This enumeration is used in {{D3D11_BUFFER_DESC}}, {{D3D11_TEXTURE1D_DESC}}, {{D3D11_TEXTURE2D_DESC}}, {{D3D11_TEXTURE3D_DESC}}. These flags can be combined by bitwise {{OR}}. The {{D3D11_RESOURCE_MISC_FLAG}} cannot be used when creating resources with {{D3D11_CPU_ACCESS}} flags.

<dd> Enables {{MIP}} map generation by using {{ID3D11DeviceContext::GenerateMips}} on a texture resource. The resource must be created with the bind flags that specify that the resource is a render target and a shader resource. </dd>

<dd> Enables resource data sharing between two or more Direct3D devices. The only resources that can be shared are 2D non-mipmapped textures. {{D3D11_RESOURCE_MISC_SHARED}} and {{D3D11_RESOURCE_MISC_SHARED_KEYEDMUTEX}} are mutually exclusive. {{WARP}} and {{REF}} devices do not support shared resources. If you try to create a resource with this flag on either a {{WARP}} or {{REF}} device, the create method will return an {{E_OUTOFMEMORY}} error code. Note?? Starting with Windows?8, {{WARP}} devices fully support shared resources. ? Note?? Starting with Windows?8, we recommend that you enable resource data sharing between two or more Direct3D devices by using a combination of the {{D3D11_RESOURCE_MISC_SHARED_NTHANDLE}} and {{D3D11_RESOURCE_MISC_SHARED_KEYEDMUTEX}} flags instead. ? </dd>

<dd> Sets a resource to be a cube texture created from a Texture2DArray that contains 6 textures. </dd>

<dd> Enables instancing of {{GPU}}-generated content. </dd>

<dd> Enables a resource as a byte address buffer. </dd>

<dd> Enables a resource as a structured buffer. </dd>

<dd> Enables a resource with {{MIP}} map clamping for use with {{ID3D11DeviceContext::SetResourceMinLOD}}. </dd>

<dd> Enables the resource to be synchronized by using the {{IDXGIKeyedMutex::AcquireSync}} and {{IDXGIKeyedMutex::ReleaseSync}} {{APIs}}. The following Direct3D?11 resource creation {{APIs}}, that take {{D3D11_RESOURCE_MISC_FLAG}} parameters, have been extended to support the new flag. <ul> <li> {{ID3D11Device::CreateTexture1D}} </li> <li> {{ID3D11Device::CreateTexture2D}} </li> <li> {{ID3D11Device::CreateTexture3D}} </li> <li> {{ID3D11Device::CreateBuffer}} </li> </ul> If you call any of these methods with the {{D3D11_RESOURCE_MISC_SHARED_KEYEDMUTEX}} flag set, the interface returned will support the {{IDXGIKeyedMutex}} interface. You can retrieve a reference to the {{IDXGIKeyedMutex}} interface from the resource by using {{IUnknown::QueryInterface}}. The {{IDXGIKeyedMutex}} interface implements the {{IDXGIKeyedMutex::AcquireSync}} and {{IDXGIKeyedMutex::ReleaseSync}} {{APIs}} to synchronize access to the surface. The device that creates the surface, and any other device that opens the surface by using OpenSharedResource, must call {{IDXGIKeyedMutex::AcquireSync}} before they issue any rendering commands to the surface. When those devices finish rendering, they must call {{IDXGIKeyedMutex::ReleaseSync}}. {{D3D11_RESOURCE_MISC_SHARED}} and {{D3D11_RESOURCE_MISC_SHARED_KEYEDMUTEX}} are mutually exclusive. {{WARP}} and {{REF}} devices do not support shared resources. If you try to create a resource with this flag on either a {{WARP}} or {{REF}} device, the create method will return an {{E_OUTOFMEMORY}} error code. Note?? Starting with Windows?8, {{WARP}} devices fully support shared resources. ? </dd>

<dd> Enables a resource compatible with {{GDI}}. You must set the {{D3D11_RESOURCE_MISC_GDI_COMPATIBLE}} flag on surfaces that you use with {{GDI}}. Setting the {{D3D11_RESOURCE_MISC_GDI_COMPATIBLE}} flag allows {{GDI}} rendering on the surface via {{IDXGISurface1::GetDC}}. Consider the following programming tips for using {{D3D11_RESOURCE_MISC_GDI_COMPATIBLE}} when you create a texture or use that texture in a swap chain: <ul> <li>{{D3D11_RESOURCE_MISC_SHARED_KEYEDMUTEX}} and {{D3D11_RESOURCE_MISC_GDI_COMPATIBLE}} are mutually exclusive. Therefore, do not use them together.</li> <li>{{D3D11_RESOURCE_MISC_RESOURCE_CLAMP}} and {{D3D11_RESOURCE_MISC_GDI_COMPATIBLE}} are mutually exclusive. Therefore, do not use them together.</li> <li> You must bind the texture as a render target for the output-merger stage. For example, set the {{D3D11_BIND_RENDER_TARGET}} flag in the BindFlags member of the {{D3D11_TEXTURE2D_DESC}} structure. </li> <li> You must set the maximum number of {{MIP}} map levels to 1. For example, set the MipLevels member of the {{D3D11_TEXTURE2D_DESC}} structure to 1. </li> <li> You must specify that the texture requires read and write access by the {{GPU}}. For example, set the Usage member of the {{D3D11_TEXTURE2D_DESC}} structure to {{D3D11_USAGE_DEFAULT}}. </li> <li> You must set the texture format to one of the following types. <ul> <li>{{DXGI_FORMAT_B8G8R8A8_UNORM}}</li> <li>{{DXGI_FORMAT_B8G8R8A8_TYPELESS}}</li> <li>{{DXGI_FORMAT_B8G8R8A8_UNORM_SRGB}}</li> </ul> For example, set the Format member of the {{D3D11_TEXTURE2D_DESC}} structure to one of these types. </li> <li> You cannot use {{D3D11_RESOURCE_MISC_GDI_COMPATIBLE}} with multisampling. Therefore, set the Count member of the {{DXGI_SAMPLE_DESC}} structure to 1. Then, set the SampleDesc member of the {{D3D11_TEXTURE2D_DESC}} structure to this {{DXGI_SAMPLE_DESC}} structure. </li> </ul> </dd>

<dd> Set this flag to enable the use of {{NT}} {{HANDLE}} values when you create a shared resource. By enabling this flag, you deprecate the use of existing {{HANDLE}} values. When you use this flag, you must combine it with the {{D3D11_RESOURCE_MISC_SHARED_KEYEDMUTEX}} flag by using a bitwise {{OR}} operation. The resulting value specifies a new shared resource type that directs the runtime to use {{NT}} {{HANDLE}} values for the shared resource. The runtime then must confirm that the shared resource works on all hardware at the specified feature level. Without this flag set, the runtime does not strictly validate shared resource parameters (that is, formats, flags, usage, and so on). When the runtime does not validate shared resource parameters, behavior of much of the Direct3D {{API}} might be undefined and might vary from driver to driver. Direct3D 11 and earlier:??This value is not supported until Direct3D 11.1. </dd>

<dd> Set this flag to indicate that the resource might contain protected content; therefore, the operating system should use the resource only when the driver and hardware support content protection. If the driver and hardware do not support content protection and you try to create a resource with this flag, the resource creation fails. Direct3D 11:??This value is not supported until Direct3D 11.1. </dd>

<dd> Set this flag to indicate that the operating system restricts access to the shared surface. You can use this flag together with the {{D3D11_RESOURCE_MISC_RESTRICT_SHARED_RESOURCE_DRIVER}} flag and only when you create a shared surface. The process that creates the shared resource can always open the shared resource. Direct3D 11:??This value is not supported until Direct3D 11.1. </dd>

<dd> Set this flag to indicate that the driver restricts access to the shared surface. You can use this flag in conjunction with the {{D3D11_RESOURCE_MISC_RESTRICT_SHARED_RESOURCE}} flag and only when you create a shared surface. The process that creates the shared resource can always open the shared resource. Direct3D 11:??This value is not supported until Direct3D 11.1. </dd>

<dd> Set this flag to indicate that the resource is guarded. Such a resource is returned by the {{IDCompositionSurface::BeginDraw}} (DirectComposition) and {{ISurfaceImageSourceNative::BeginDraw}} (Windows Runtime) {{APIs}}. For these {{APIs}}, you provide a region of interest ({{ROI}}) on a surface to update. This surface isn't compatible with multiple render targets ({{MRT}}). A guarded resource automatically restricts all writes to the region that is related to one of the preceding {{APIs}}. Additionally, the resource enforces access to the {{ROI}} with these restrictions: <ul> <li> Copy operations from the resource by using {{ID3D11DeviceContext::CopyResource}} or {{ID3D11DeviceContext::CopySubresourceRegion}} are restricted to only copy from the {{ROI}}. </li> <li>When a guarded resource is set as a render target, it must be the only target.</li> </ul> Direct3D 11:??This value is not supported until Direct3D 11.1. </dd>

<dd> Set this flag to indicate that the resource is a tile pool. Direct3D 11:??This value is not supported until Direct3D 11.2. </dd>

<dd> Set this flag to indicate that the resource is a tiled resource. Direct3D 11:??This value is not supported until Direct3D 11.2. </dd>

<dd> Set this flag to indicate that the resource should be created such that it will be protected by the hardware. Resource creation will fail if hardware content protection is not supported. This flag has the following restrictions: <ul> <li> This flag cannot be used with the following {{D3D11_USAGE}} values:<ul> <li>{{D3D11_USAGE_DYNAMIC}}</li> <li>{{D3D11_USAGE_STAGING}}</li> </ul> </li> <li> This flag cannot be used with the following {{D3D11_BIND_FLAG}} values.<ul> <li>{{D3D11_BIND_VERTEX_BUFFER}}</li> <li>{{D3D11_BIND_INDEX_BUFFER}}</li> </ul> </li> <li>No {{CPU}} access flags can be specified.</li> </ul> Note??Creating a texture using this flag does not automatically guarantee that hardware protection will be enabled for the underlying allocation. Some implementations require that the {{DRM}} components are first initialized prior to any guarantees of protection. ? Note?? This enumeration value is supported starting with Windows?10. </dd>

Identifies a resource to be accessed for reading and writing by the {{CPU}}. Applications may combine one or more of these flags.

This enumeration is used in {{ID3D11DeviceContext::Map}}.These remarks are divided into the following topics: <ul> <li>{{Meaning}}</li> <li>{{Common}}</li> </ul>

<dd> Resource is mapped for reading. The resource must have been created with read access (see {{D3D11_CPU_ACCESS_READ}}). </dd>

<dd> Resource is mapped for writing. The resource must have been created with write access (see {{D3D11_CPU_ACCESS_WRITE}}). </dd>

<dd> Resource is mapped for reading and writing. The resource must have been created with read and write access (see {{D3D11_CPU_ACCESS_READ}} and {{D3D11_CPU_ACCESS_WRITE}}). </dd>

<dd> Resource is mapped for writing; the previous contents of the resource will be undefined. The resource must have been created with write access and dynamic usage (See {{D3D11_CPU_ACCESS_WRITE}} and {{D3D11_USAGE_DYNAMIC}}). </dd>

<dd> Resource is mapped for writing; the existing contents of the resource cannot be overwritten (see Remarks). This flag is only valid on vertex and index buffers. The resource must have been created with write access (see {{D3D11_CPU_ACCESS_WRITE}}). Cannot be used on a resource created with the {{D3D11_BIND_CONSTANT_BUFFER}} flag. Note??The Direct3D 11.1 runtime, which is available starting with Windows?8, enables mapping dynamic constant buffers and shader resource views ({{SRVs}}) of dynamic buffers with {{D3D11_MAP_WRITE_NO_OVERWRITE}}. The Direct3D 11 and earlier runtimes limited mapping to vertex or index buffers. To determine if a Direct3D device supports these features, call {{ID3D11Device::CheckFeatureSupport}} with {{D3D11_FEATURE_D3D11_OPTIONS}}. CheckFeatureSupport fills members of a {{D3D11_FEATURE_DATA_D3D11_OPTIONS}} structure with the device's features. The relevant members here are MapNoOverwriteOnDynamicConstantBuffer and MapNoOverwriteOnDynamicBufferSRV. ? </dd>

Specifies how the {{CPU}} should respond when an application calls the {{ID3D11DeviceContext::Map}} method on a resource that is being used by the {{GPU}}.

This enumeration is used by {{ID3D11DeviceContext::Map}}.{{D3D11_MAP_FLAG_DO_NOT_WAIT}} cannot be used with {{D3D11_MAP_WRITE_DISCARD}} or {{D3D11_MAP_WRITE_NOOVERWRITE}}.

Option(s) for raising an error to a non-continuable exception.

These flags are used by {{ID3D11Device::GetExceptionMode}} and {{ID3D11Device::SetExceptionMode}}. Use 0 to indicate no flags; multiple flags can be logically {{OR}}'ed together.

<dd> Raise an internal driver error to a non-continuable exception. </dd>

Specifies the parts of the depth stencil to clear.

These flags are used when calling {{ID3D11DeviceContext::ClearDepthStencilView}}; the flags can be combined with a bitwise {{OR}}.

<dd> Clear the depth buffer, using fast clear if possible, then place the resource in a compressed state. </dd>

<dd> Clear the stencil buffer, using fast clear if possible, then place the resource in a compressed state. </dd>

Comparison options.

A comparison option determines whether how the runtime compares source (new) data against destination (existing) data before storing the new data. The comparison option is declared in a description before an object is created. The {{API}} allows you to set a comparison option for a depth-stencil buffer (see {{D3D11_DEPTH_STENCIL_DESC}}), depth-stencil operations (see {{D3D11_DEPTH_STENCILOP_DESC}}), or sampler state (see {{D3D11_SAMPLER_DESC}}).

<dd> Never pass the comparison. </dd>

<dd> If the source data is less than the destination data, the comparison passes. </dd>

<dd> If the source data is equal to the destination data, the comparison passes. </dd>

<dd> If the source data is less than or equal to the destination data, the comparison passes. </dd>

<dd> If the source data is greater than the destination data, the comparison passes. </dd>

<dd> If the source data is not equal to the destination data, the comparison passes. </dd>

<dd> If the source data is greater than or equal to the destination data, the comparison passes. </dd>

<dd> Always pass the comparison. </dd>

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

<dd> Turn off writes to the depth-stencil buffer. </dd>

<dd> Turn on writes to the depth-stencil buffer. </dd>

The stencil operations that can be performed during depth-stencil testing.

<dd> Keep the existing stencil data. </dd>

<dd> Set the stencil data to 0. </dd>

<dd> Set the stencil data to the reference value set by calling {{ID3D11DeviceContext::OMSetDepthStencilState}}. </dd>

<dd> Increment the stencil value by 1, and clamp the result. </dd>

<dd> Decrement the stencil value by 1, and clamp the result. </dd>

<dd> Invert the stencil data. </dd>

<dd> Increment the stencil value by 1, and wrap the result if necessary. </dd>

<dd> Decrement the stencil value by 1, and wrap the result if necessary. </dd>

Blend factors, which modulate values for the pixel shader and render target.

Blend operations are specified in a blend description.

<dd> The blend factor is (0, 0, 0, 0). No pre-blend operation. </dd>

<dd> The blend factor is (1, 1, 1, 1). No pre-blend operation. </dd>

<dd> The blend factor is (R?, G?, B?, A?), that is color data ({{RGB}}) from a pixel shader. No pre-blend operation. </dd>

<dd> The blend factor is (1 - R?, 1 - G?, 1 - B?, 1 - A?), that is color data ({{RGB}}) from a pixel shader. The pre-blend operation inverts the data, generating 1 - {{RGB}}. </dd>

<dd> The blend factor is (A?, A?, A?, A?), that is alpha data (A) from a pixel shader. No pre-blend operation. </dd>

<dd> The blend factor is ( 1 - A?, 1 - A?, 1 - A?, 1 - A?), that is alpha data (A) from a pixel shader. The pre-blend operation inverts the data, generating 1 - A. </dd>

<dd> The blend factor is (Ad Ad Ad Ad), that is alpha data from a render target. No pre-blend operation. </dd>

<dd> The blend factor is (1 - Ad 1 - Ad 1 - Ad 1 - Ad), that is alpha data from a render target. The pre-blend operation inverts the data, generating 1 - A. </dd>

<dd> The blend factor is (Rd, Gd, Bd, Ad), that is color data from a render target. No pre-blend operation. </dd>

<dd> The blend factor is (1 - Rd, 1 - Gd, 1 - Bd, 1 - Ad), that is color data from a render target. The pre-blend operation inverts the data, generating 1 - {{RGB}}. </dd>

<dd> The blend factor is (f, f, f, 1); where f = min(A?, 1 - Ad). The pre-blend operation clamps the data to 1 or less. </dd>

<dd> The blend factor is the blend factor set with {{ID3D11DeviceContext::OMSetBlendState}}. No pre-blend operation. </dd>

<dd> The blend factor is the blend factor set with {{ID3D11DeviceContext::OMSetBlendState}}. The pre-blend operation inverts the blend factor, generating 1 - blend_factor. </dd>

<dd> The blend factor is data sources both as color data output by a pixel shader. There is no pre-blend operation. This blend factor supports dual-source color blending. </dd>

<dd> The blend factor is data sources both as color data output by a pixel shader. The pre-blend operation inverts the data, generating 1 - {{RGB}}. This blend factor supports dual-source color blending. </dd>

<dd> The blend factor is data sources as alpha data output by a pixel shader. There is no pre-blend operation. This blend factor supports dual-source color blending. </dd>

<dd> The blend factor is data sources as alpha data output by a pixel shader. The pre-blend operation inverts the data, generating 1 - A. This blend factor supports dual-source color blending. </dd>

{{RGB}} or alpha blending operation.

The runtime implements {{RGB}} blending and alpha blending separately. Therefore, blend state requires separate blend operations for {{RGB}} data and alpha data. These blend operations are specified in a blend description. The two sources ?source 1 and source 2? are shown in the blending block diagram.Blend state is used by the output-merger stage to determine how to blend together two {{RGB}} pixel values and two alpha values. The two {{RGB}} pixel values and two alpha values are the {{RGB}} pixel value and alpha value that the pixel shader outputs and the {{RGB}} pixel value and alpha value already in the output render target. The blend option controls the data source that the blending stage uses to modulate values for the pixel shader, render target, or both. The blend operation controls how the blending stage mathematically combines these modulated values.

<dd> Add source 1 and source 2. </dd>

<dd> Subtract source 1 from source 2. </dd>

<dd> Subtract source 2 from source 1. </dd>

<dd> Find the minimum of source 1 and source 2. </dd>

<dd> Find the maximum of source 1 and source 2. </dd>

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

These flags can be combined with a bitwise {{OR}}.

<dd> Allow data to be stored in the red component. </dd>

<dd> Allow data to be stored in the green component. </dd>

<dd> Allow data to be stored in the blue component. </dd>

<dd> Allow data to be stored in the alpha component. </dd>

<dd> Allow data to be stored in all components. </dd>

The different faces of a cube texture.

<dd> Positive X face. </dd>

<dd> Negative X face. </dd>

<dd> Positive Y face. </dd>

<dd> Negative Y face. </dd>

<dd> Positive Z face. </dd>

<dd> Negative Z face. </dd>

Identifies how to view a buffer resource.

This enumeration is used by {{D3D11_BUFFEREX_SRV}}

<dd> View the buffer as raw. For more info about raw viewing of buffers, see Raw Views of Buffers. </dd>

Depth-stencil view options.

This enumeration is used by {{D3D11_DEPTH_STENCIL_VIEW_DESC}}.Limiting a depth-stencil buffer to read-only access allows more than one depth-stencil view to be bound to the pipeline simultaneously, since it is not possible to have a read/write conflicts between separate views.

<dd> Indicates that depth values are read only. </dd>

<dd> Indicates that stencil values are read only. </dd>

Identifies unordered-access view options for a buffer resource.

<dd> Resource contains raw, unstructured data. Requires the {{UAV}} format to be {{DXGI_FORMAT_R32_TYPELESS}}. For more info about raw viewing of buffers, see Raw Views of Buffers. </dd>

<dd> Allow data to be appended to the end of the buffer. {{D3D11_BUFFER_UAV_FLAG_APPEND}} flag must also be used for any view that will be used as a AppendStructuredBuffer or a ConsumeStructuredBuffer. Requires the {{UAV}} format to be {{DXGI_FORMAT_UNKNOWN}}. </dd>

<dd> Adds a counter to the unordered-access-view buffer. {{D3D11_BUFFER_UAV_FLAG_COUNTER}} can only be used on a {{UAV}} that is a {{RWStructuredBuffer}} and it enables the functionality needed for the IncrementCounter and DecrementCounter methods in {{HLSL}}. Requires the {{UAV}} format to be {{DXGI_FORMAT_UNKNOWN}}. </dd>

Filtering options during texture sampling.

Note??If you use different filter types for min versus mag filter, undefined behavior occurs in certain cases where the choice between whether magnification or minification happens is ambiguous. To prevent this undefined behavior, use filter modes that use similar filter operations for both min and mag (or use anisotropic filtering, which avoids the issue as well).?During texture sampling, one or more texels are read and combined (this is calling filtering) to produce a single value. Point sampling reads a single texel while linear sampling reads two texels (endpoints) and linearly interpolates a third value between the endpoints.{{HLSL}} texture-sampling functions also support comparison filtering during texture sampling. Comparison filtering compares each sampled texel against a comparison value. The boolean result is blended the same way that normal texture filtering is blended.You can use {{HLSL}} intrinsic texture-sampling functions that implement texture filtering only or companion functions that use texture filtering with comparison filtering.<table> <tr><th>Texture Sampling Function</th><th>Texture Sampling Function with Comparison Filtering</th></tr> <tr><td>sample</td><td>samplecmp or samplecmplevelzero</td></tr> </table>?Comparison filters only work with textures that have the following {{DXGI}} formats: {{R32_FLOAT_X8X24_TYPELESS}}, {{R32_FLOAT}}, {{R24_UNORM_X8_TYPELESS}}, {{R16_UNORM}}.

<dd> Use point sampling for minification, magnification, and mip-level sampling. </dd>

<dd> Use point sampling for minification and magnification; use linear interpolation for mip-level sampling. </dd>

<dd> Use point sampling for minification; use linear interpolation for magnification; use point sampling for mip-level sampling. </dd>

<dd> Use point sampling for minification; use linear interpolation for magnification and mip-level sampling. </dd>

<dd> Use linear interpolation for minification; use point sampling for magnification and mip-level sampling. </dd>

<dd> Use linear interpolation for minification; use point sampling for magnification; use linear interpolation for mip-level sampling. </dd>

<dd> Use linear interpolation for minification and magnification; use point sampling for mip-level sampling. </dd>

<dd> Use linear interpolation for minification, magnification, and mip-level sampling. </dd>

<dd> Use anisotropic interpolation for minification, magnification, and mip-level sampling. </dd>

<dd> Use point sampling for minification, magnification, and mip-level sampling. Compare the result to the comparison value. </dd>

<dd> Use point sampling for minification and magnification; use linear interpolation for mip-level sampling. Compare the result to the comparison value. </dd>

<dd> Use point sampling for minification; use linear interpolation for magnification; use point sampling for mip-level sampling. Compare the result to the comparison value. </dd>

<dd> Use point sampling for minification; use linear interpolation for magnification and mip-level sampling. Compare the result to the comparison value. </dd>

<dd> Use linear interpolation for minification; use point sampling for magnification and mip-level sampling. Compare the result to the comparison value. </dd>

<dd> Use linear interpolation for minification; use point sampling for magnification; use linear interpolation for mip-level sampling. Compare the result to the comparison value. </dd>

<dd> Use linear interpolation for minification and magnification; use point sampling for mip-level sampling. Compare the result to the comparison value. </dd>

<dd> Use linear interpolation for minification, magnification, and mip-level sampling. Compare the result to the comparison value. </dd>

<dd> Use anisotropic interpolation for minification, magnification, and mip-level sampling. Compare the result to the comparison value. </dd>

<dd> Fetch the same set of texels as {{D3D11_FILTER_MIN_MAG_MIP_POINT}} and instead of filtering them return the minimum of the texels. Texels that are weighted 0 during filtering aren't counted towards the minimum. You can query support for this filter type from the MinMaxFiltering member in the {{D3D11_FEATURE_DATA_D3D11_OPTIONS1}} structure. </dd>

<dd> Fetch the same set of texels as {{D3D11_FILTER_MIN_MAG_POINT_MIP_LINEAR}} and instead of filtering them return the minimum of the texels. Texels that are weighted 0 during filtering aren't counted towards the minimum. You can query support for this filter type from the MinMaxFiltering member in the {{D3D11_FEATURE_DATA_D3D11_OPTIONS1}} structure. </dd>

<dd> Fetch the same set of texels as {{D3D11_FILTER_MIN_POINT_MAG_LINEAR_MIP_POINT}} and instead of filtering them return the minimum of the texels. Texels that are weighted 0 during filtering aren't counted towards the minimum. You can query support for this filter type from the MinMaxFiltering member in the {{D3D11_FEATURE_DATA_D3D11_OPTIONS1}} structure. </dd>

<dd> Fetch the same set of texels as {{D3D11_FILTER_MIN_POINT_MAG_MIP_LINEAR}} and instead of filtering them return the minimum of the texels. Texels that are weighted 0 during filtering aren't counted towards the minimum. You can query support for this filter type from the MinMaxFiltering member in the {{D3D11_FEATURE_DATA_D3D11_OPTIONS1}} structure. </dd>

<dd> Fetch the same set of texels as {{D3D11_FILTER_MIN_LINEAR_MAG_MIP_POINT}} and instead of filtering them return the minimum of the texels. Texels that are weighted 0 during filtering aren't counted towards the minimum. You can query support for this filter type from the MinMaxFiltering member in the {{D3D11_FEATURE_DATA_D3D11_OPTIONS1}} structure. </dd>

<dd> Fetch the same set of texels as {{D3D11_FILTER_MIN_LINEAR_MAG_POINT_MIP_LINEAR}} and instead of filtering them return the minimum of the texels. Texels that are weighted 0 during filtering aren't counted towards the minimum. You can query support for this filter type from the MinMaxFiltering member in the {{D3D11_FEATURE_DATA_D3D11_OPTIONS1}} structure. </dd>

<dd> Fetch the same set of texels as {{D3D11_FILTER_MIN_MAG_LINEAR_MIP_POINT}} and instead of filtering them return the minimum of the texels. Texels that are weighted 0 during filtering aren't counted towards the minimum. You can query support for this filter type from the MinMaxFiltering member in the {{D3D11_FEATURE_DATA_D3D11_OPTIONS1}} structure. </dd>

<dd> Fetch the same set of texels as {{D3D11_FILTER_MIN_MAG_MIP_LINEAR}} and instead of filtering them return the minimum of the texels. Texels that are weighted 0 during filtering aren't counted towards the minimum. You can query support for this filter type from the MinMaxFiltering member in the {{D3D11_FEATURE_DATA_D3D11_OPTIONS1}} structure. </dd>

<dd> Fetch the same set of texels as {{D3D11_FILTER_ANISOTROPIC}} and instead of filtering them return the minimum of the texels. Texels that are weighted 0 during filtering aren't counted towards the minimum. You can query support for this filter type from the MinMaxFiltering member in the {{D3D11_FEATURE_DATA_D3D11_OPTIONS1}} structure. </dd>

<dd> Fetch the same set of texels as {{D3D11_FILTER_MIN_MAG_MIP_POINT}} and instead of filtering them return the maximum of the texels. Texels that are weighted 0 during filtering aren't counted towards the maximum. You can query support for this filter type from the MinMaxFiltering member in the {{D3D11_FEATURE_DATA_D3D11_OPTIONS1}} structure. </dd>

<dd> Fetch the same set of texels as {{D3D11_FILTER_MIN_MAG_POINT_MIP_LINEAR}} and instead of filtering them return the maximum of the texels. Texels that are weighted 0 during filtering aren't counted towards the maximum. You can query support for this filter type from the MinMaxFiltering member in the {{D3D11_FEATURE_DATA_D3D11_OPTIONS1}} structure. </dd>

<dd> Fetch the same set of texels as {{D3D11_FILTER_MIN_POINT_MAG_LINEAR_MIP_POINT}} and instead of filtering them return the maximum of the texels. Texels that are weighted 0 during filtering aren't counted towards the maximum. You can query support for this filter type from the MinMaxFiltering member in the {{D3D11_FEATURE_DATA_D3D11_OPTIONS1}} structure. </dd>

<dd> Fetch the same set of texels as {{D3D11_FILTER_MIN_POINT_MAG_MIP_LINEAR}} and instead of filtering them return the maximum of the texels. Texels that are weighted 0 during filtering aren't counted towards the maximum. You can query support for this filter type from the MinMaxFiltering member in the {{D3D11_FEATURE_DATA_D3D11_OPTIONS1}} structure. </dd>

<dd> Fetch the same set of texels as {{D3D11_FILTER_MIN_LINEAR_MAG_MIP_POINT}} and instead of filtering them return the maximum of the texels. Texels that are weighted 0 during filtering aren't counted towards the maximum. You can query support for this filter type from the MinMaxFiltering member in the {{D3D11_FEATURE_DATA_D3D11_OPTIONS1}} structure. </dd>

<dd> Fetch the same set of texels as {{D3D11_FILTER_MIN_LINEAR_MAG_POINT_MIP_LINEAR}} and instead of filtering them return the maximum of the texels. Texels that are weighted 0 during filtering aren't counted towards the maximum. You can query support for this filter type from the MinMaxFiltering member in the {{D3D11_FEATURE_DATA_D3D11_OPTIONS1}} structure. </dd>

<dd> Fetch the same set of texels as {{D3D11_FILTER_MIN_MAG_LINEAR_MIP_POINT}} and instead of filtering them return the maximum of the texels. Texels that are weighted 0 during filtering aren't counted towards the maximum. You can query support for this filter type from the MinMaxFiltering member in the {{D3D11_FEATURE_DATA_D3D11_OPTIONS1}} structure. </dd>

<dd> Fetch the same set of texels as {{D3D11_FILTER_MIN_MAG_MIP_LINEAR}} and instead of filtering them return the maximum of the texels. Texels that are weighted 0 during filtering aren't counted towards the maximum. You can query support for this filter type from the MinMaxFiltering member in the {{D3D11_FEATURE_DATA_D3D11_OPTIONS1}} structure. </dd>

<dd> Fetch the same set of texels as {{D3D11_FILTER_ANISOTROPIC}} and instead of filtering them return the maximum of the texels. Texels that are weighted 0 during filtering aren't counted towards the maximum. You can query support for this filter type from the MinMaxFiltering member in the {{D3D11_FEATURE_DATA_D3D11_OPTIONS1}} structure. </dd>

Types of magnification or minification sampler filters.

<dd> Point filtering used as a texture magnification or minification filter. The texel with coordinates nearest to the desired pixel value is used. The texture filter to be used between mipmap levels is nearest-point mipmap filtering. The rasterizer uses the color from the texel of the nearest mipmap texture. </dd>

<dd> Bilinear interpolation filtering used as a texture magnification or minification filter. A weighted average of a 2 x 2 area of texels surrounding the desired pixel is used. The texture filter to use between mipmap levels is trilinear mipmap interpolation. The rasterizer linearly interpolates pixel color, using the texels of the two nearest mipmap textures. </dd>

Specifies the type of sampler filter reduction.

This enum is used by the {{D3D11_SAMPLER_DESC}} structure.

<dd> Indicates standard (default) filter reduction. </dd>

<dd> Indicates a comparison filter reduction. </dd>

<dd> Indicates minimum filter reduction. </dd>

<dd> Indicates maximum filter reduction. </dd>

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

<dd> Tile the texture at every (u,v) integer junction. For example, for u values between 0 and 3, the texture is repeated three times. </dd>

<dd> Flip the texture at every (u,v) integer junction. For u values between 0 and 1, for example, the texture is addressed normally; between 1 and 2, the texture is flipped (mirrored); between 2 and 3, the texture is normal again; and so on. </dd>

<dd> Texture coordinates outside the range [0.0, 1.0] are set to the texture color at 0.0 or 1.0, respectively. </dd>

<dd> Texture coordinates outside the range [0.0, 1.0] are set to the border color specified in {{D3D11_SAMPLER_DESC}} or {{HLSL}} code. </dd>

<dd> Similar to {{D3D11_TEXTURE_ADDRESS_MIRROR}} and {{D3D11_TEXTURE_ADDRESS_CLAMP}}. Takes the absolute value of the texture coordinate (thus, mirroring around 0), and then clamps to the maximum value. </dd>

Which resources are supported for a given format and given device (see {{ID3D11Device::CheckFormatSupport}} and {{ID3D11Device::CheckFeatureSupport}}).

Unordered resource support options for a compute shader resource (see {{ID3D11Device::CheckFeatureSupport}}).

Optional flags that control the behavior of {{ID3D11DeviceContext::GetData}}.

Query types.

Create a query with {{ID3D11Device::CreateQuery}}.

<dd> Determines whether or not the {{GPU}} is finished processing commands. When the {{GPU}} is finished processing commands {{ID3D11DeviceContext::GetData}} will return {{S_OK}}, and pData will point to a {{BOOL}} with a value of {{TRUE}}. When using this type of query, {{ID3D11DeviceContext::Begin}} is disabled. </dd>

<dd> Get the number of samples that passed the depth and stencil tests in between {{ID3D11DeviceContext::Begin}} and {{ID3D11DeviceContext::End}}. {{ID3D11DeviceContext::GetData}} returns a {{UINT64}}. If a depth or stencil test is disabled, then each of those tests will be counted as a pass. </dd>

<dd> Get a timestamp value where {{ID3D11DeviceContext::GetData}} returns a {{UINT64}}. This kind of query is only useful if two timestamp queries are done in the middle of a {{D3D11_QUERY_TIMESTAMP_DISJOINT}} query. The difference of two timestamps can be used to determine how many ticks have elapsed, and the {{D3D11_QUERY_TIMESTAMP_DISJOINT}} query will determine if that difference is a reliable value and also has a value that shows how to convert the number of ticks into seconds. See {{D3D11_QUERY_DATA_TIMESTAMP_DISJOINT}}. When using this type of query, {{ID3D11DeviceContext::Begin}} is disabled. </dd>

<dd> Determines whether or not a {{D3D11_QUERY_TIMESTAMP}} is returning reliable values, and also gives the frequency of the processor enabling you to convert the number of elapsed ticks into seconds. {{ID3D11DeviceContext::GetData}} will return a {{D3D11_QUERY_DATA_TIMESTAMP_DISJOINT}}. This type of query should only be invoked once per frame or less. </dd>

<dd> Get pipeline statistics, such as the number of pixel shader invocations in between {{ID3D11DeviceContext::Begin}} and {{ID3D11DeviceContext::End}}. {{ID3D11DeviceContext::GetData}} will return a {{D3D11_QUERY_DATA_PIPELINE_STATISTICS}}. </dd>

<dd> Similar to {{D3D11_QUERY_OCCLUSION}}, except {{ID3D11DeviceContext::GetData}} returns a {{BOOL}} indicating whether or not any samples passed the depth and stencil tests - {{TRUE}} meaning at least one passed, {{FALSE}} meaning none passed. </dd>

<dd> Get streaming output statistics, such as the number of primitives streamed out in between {{ID3D11DeviceContext::Begin}} and {{ID3D11DeviceContext::End}}. {{ID3D11DeviceContext::GetData}} will return a {{D3D11_QUERY_DATA_SO_STATISTICS}} structure. </dd>

<dd> Determines whether or not any of the streaming output buffers overflowed in between {{ID3D11DeviceContext::Begin}} and {{ID3D11DeviceContext::End}}. {{ID3D11DeviceContext::GetData}} returns a {{BOOL}} - {{TRUE}} meaning there was an overflow, {{FALSE}} meaning there was not an overflow. If streaming output writes to multiple buffers, and one of the buffers overflows, then it will stop writing to all the output buffers. When an overflow is detected by Direct3D it is prevented from happening - no memory is corrupted. This predication may be used in conjunction with an {{SO_STATISTICS}} query so that when an overflow occurs the {{SO_STATISTIC}} query will let the application know how much memory was needed to prevent an overflow. </dd>

<dd> Get streaming output statistics for stream 0, such as the number of primitives streamed out in between {{ID3D11DeviceContext::Begin}} and {{ID3D11DeviceContext::End}}. {{ID3D11DeviceContext::GetData}} will return a {{D3D11_QUERY_DATA_SO_STATISTICS}} structure. </dd>

<dd> Determines whether or not the stream 0 output buffers overflowed in between {{ID3D11DeviceContext::Begin}} and {{ID3D11DeviceContext::End}}. {{ID3D11DeviceContext::GetData}} returns a {{BOOL}} - {{TRUE}} meaning there was an overflow, {{FALSE}} meaning there was not an overflow. If streaming output writes to multiple buffers, and one of the buffers overflows, then it will stop writing to all the output buffers. When an overflow is detected by Direct3D it is prevented from happening - no memory is corrupted. This predication may be used in conjunction with an {{SO_STATISTICS}} query so that when an overflow occurs the {{SO_STATISTIC}} query will let the application know how much memory was needed to prevent an overflow. </dd>

<dd> Get streaming output statistics for stream 1, such as the number of primitives streamed out in between {{ID3D11DeviceContext::Begin}} and {{ID3D11DeviceContext::End}}. {{ID3D11DeviceContext::GetData}} will return a {{D3D11_QUERY_DATA_SO_STATISTICS}} structure. </dd>

<dd> Determines whether or not the stream 1 output buffers overflowed in between {{ID3D11DeviceContext::Begin}} and {{ID3D11DeviceContext::End}}. {{ID3D11DeviceContext::GetData}} returns a {{BOOL}} - {{TRUE}} meaning there was an overflow, {{FALSE}} meaning there was not an overflow. If streaming output writes to multiple buffers, and one of the buffers overflows, then it will stop writing to all the output buffers. When an overflow is detected by Direct3D it is prevented from happening - no memory is corrupted. This predication may be used in conjunction with an {{SO_STATISTICS}} query so that when an overflow occurs the {{SO_STATISTIC}} query will let the application know how much memory was needed to prevent an overflow. </dd>

<dd> Get streaming output statistics for stream 2, such as the number of primitives streamed out in between {{ID3D11DeviceContext::Begin}} and {{ID3D11DeviceContext::End}}. {{ID3D11DeviceContext::GetData}} will return a {{D3D11_QUERY_DATA_SO_STATISTICS}} structure. </dd>

<dd> Determines whether or not the stream 2 output buffers overflowed in between {{ID3D11DeviceContext::Begin}} and {{ID3D11DeviceContext::End}}. {{ID3D11DeviceContext::GetData}} returns a {{BOOL}} - {{TRUE}} meaning there was an overflow, {{FALSE}} meaning there was not an overflow. If streaming output writes to multiple buffers, and one of the buffers overflows, then it will stop writing to all the output buffers. When an overflow is detected by Direct3D it is prevented from happening - no memory is corrupted. This predication may be used in conjunction with an {{SO_STATISTICS}} query so that when an overflow occurs the {{SO_STATISTIC}} query will let the application know how much memory was needed to prevent an overflow. </dd>

<dd> Get streaming output statistics for stream 3, such as the number of primitives streamed out in between {{ID3D11DeviceContext::Begin}} and {{ID3D11DeviceContext::End}}. {{ID3D11DeviceContext::GetData}} will return a {{D3D11_QUERY_DATA_SO_STATISTICS}} structure. </dd>

<dd> Determines whether or not the stream 3 output buffers overflowed in between {{ID3D11DeviceContext::Begin}} and {{ID3D11DeviceContext::End}}. {{ID3D11DeviceContext::GetData}} returns a {{BOOL}} - {{TRUE}} meaning there was an overflow, {{FALSE}} meaning there was not an overflow. If streaming output writes to multiple buffers, and one of the buffers overflows, then it will stop writing to all the output buffers. When an overflow is detected by Direct3D it is prevented from happening - no memory is corrupted. This predication may be used in conjunction with an {{SO_STATISTICS}} query so that when an overflow occurs the {{SO_STATISTIC}} query will let the application know how much memory was needed to prevent an overflow. </dd>

Flags that describe miscellaneous query behavior.

This flag is part of a query description (see {{D3D11_QUERY_DESC}}).

<dd> Tell the hardware that if it is not yet sure if something is hidden or not to draw it anyway. This is only used with an occlusion predicate. Predication data cannot be returned to your application via {{ID3D11DeviceContext::GetData}} when using this flag. </dd>

Options for performance counters.

Independent hardware vendors may define their own set of performance counters for their devices, by giving the enumeration value a number that is greater than the value for {{D3D11_COUNTER_DEVICE_DEPENDENT_0}}.This enumeration is used by {{D3D11_COUNTER_DESC}} and {{D3D11_COUNTER_INFO}}.

<dd> Define a performance counter that is dependent on the hardware device. </dd>

Data type of a performance counter.

These flags are an output parameter in {{ID3D11Device::CheckCounter}}.

<dd> 32-bit floating point. </dd>

<dd> 16-bit unsigned integer. </dd>

<dd> 32-bit unsigned integer. </dd>

<dd> 64-bit unsigned integer. </dd>

Specifies a multi-sample pattern type.

An app calls {{ID3D11Device::CheckMultisampleQualityLevels}} to get the number of quality levels available during multisampling. A 0 quality level means the hardware does not support multisampling for the particular format. If the number of quality levels is greater than 0 and the hardware supports the fixed sample patterns for the sample count, the app can request the fixed patterns by specifying quality level as either {{D3D11_STANDARD_MULTISAMPLE_PATTERN}} or {{D3D11_CENTER_MULTISAMPLE_PATTERN}}. The app can call {{ID3D11Device::CheckFormatSupport}} to check for support of the standard fixed patterns. If the hardware only supports the fixed patterns but no additional vendor-specific patterns, the runtime can report the number of quality levels as 1, and the hardware can pretend 0 quality level behaves the same as quality level equal to {{D3D11_STANDARD_MULTISAMPLE_PATTERN}}.The runtime defines the following standard sample patterns for 1(trivial), 2, 4, 8, and 16 sample counts. Hardware must support 1, 4, and 8 sample counts. Hardware vendors can expose more sample counts beyond these. However, if vendors support 2, 4(required), 8(required), or 16, they must also support the corresponding standard pattern or center pattern for each of those sample counts.

<dd> Pre-defined multi-sample patterns required for Direct3D?11 and Direct3D?10.1 hardware. </dd>

<dd> Pattern where all of the samples are located at the pixel center. </dd>

Device context options.

This enumeration is used by {{ID3D11DeviceContext::GetType}}.

<dd> The device context is an immediate context. </dd>

<dd> The device context is a deferred context. </dd>

Direct3D 11 feature options.

This enumeration is used when querying a driver about support for these features by calling {{ID3D11Device::CheckFeatureSupport}}. Each value in this enumeration has a corresponding data structure that is required to be passed to the pFeatureSupportData parameter of {{ID3D11Device::CheckFeatureSupport}}.

<dd> The driver supports multithreading. To see an example of testing a driver for multithread support, see How To: Check for Driver Support. Refer to {{D3D11_FEATURE_DATA_THREADING}}. </dd>

<dd> Supports the use of the double-precision shaders in {{HLSL}}. Refer to {{D3D11_FEATURE_DATA_DOUBLES}}. </dd>

<dd> Supports the formats in {{D3D11_FORMAT_SUPPORT}}. Refer to {{D3D11_FEATURE_DATA_FORMAT_SUPPORT}}. </dd>

<dd> Supports the formats in {{D3D11_FORMAT_SUPPORT2}}. Refer to {{D3D11_FEATURE_DATA_FORMAT_SUPPORT2}}. </dd>

<dd> Supports compute shaders and raw and structured buffers. Refer to {{D3D11_FEATURE_DATA_D3D10_X_HARDWARE_OPTIONS}}. </dd>

<dd> Supports Direct3D 11.1 feature options. Refer to {{D3D11_FEATURE_DATA_D3D11_OPTIONS}}. Direct3D 11:??This value is not supported until Direct3D 11.1. </dd>

<dd> Supports specific adapter architecture. Refer to {{D3D11_FEATURE_DATA_ARCHITECTURE_INFO}}. Direct3D 11:??This value is not supported until Direct3D 11.1. </dd>

<dd> Supports Direct3D?9 feature options. Refer to {{D3D11_FEATURE_DATA_D3D9_OPTIONS}}. Direct3D 11:??This value is not supported until Direct3D 11.1. </dd>

<dd> Supports minimum precision of shaders. For more info about {{HLSL}} minimum precision, see using {{HLSL}} minimum precision. Refer to {{D3D11_FEATURE_DATA_SHADER_MIN_PRECISION_SUPPORT}}. Direct3D 11:??This value is not supported until Direct3D 11.1. </dd>

<dd> Supports Direct3D?9 shadowing feature. Refer to {{D3D11_FEATURE_DATA_D3D9_SHADOW_SUPPORT}}. Direct3D 11:??This value is not supported until Direct3D 11.1. </dd>

<dd> Supports Direct3D 11.2 feature options. Refer to {{D3D11_FEATURE_DATA_D3D11_OPTIONS1}}. Direct3D 11:??This value is not supported until Direct3D 11.2. </dd>

<dd> Supports Direct3D 11.2 instancing options. Refer to {{D3D11_FEATURE_DATA_D3D9_SIMPLE_INSTANCING_SUPPORT}}. Direct3D 11:??This value is not supported until Direct3D 11.2. </dd>

<dd> Supports Direct3D 11.2 marker options. Refer to {{D3D11_FEATURE_DATA_MARKER_SUPPORT}}. Direct3D 11:??This value is not supported until Direct3D 11.2. </dd>

<dd> Supports Direct3D?9 feature options, which includes the Direct3D?9 shadowing feature and instancing support. Refer to {{D3D11_FEATURE_DATA_D3D9_OPTIONS1}}. Direct3D 11:??This value is not supported until Direct3D 11.2. </dd>

<dd> Supports Direct3D 11.3 conservative rasterization feature options. Refer to {{D3D11_FEATURE_DATA_D3D11_OPTIONS2}}. Direct3D 11:??This value is not supported until Direct3D 11.3. </dd>

<dd> Supports Direct3D 11.4 conservative rasterization feature options. Refer to {{D3D11_FEATURE_DATA_D3D11_OPTIONS3}}. Direct3D 11:??This value is not supported until Direct3D 11.4. </dd>

<dd> Supports {{GPU}} virtual addresses. Refer to {{D3D11_FEATURE_DATA_GPU_VIRTUAL_ADDRESS_SUPPORT}}. </dd>

<dd> Supports a single boolean for {{NV12}} shared textures. Refer to {{D3D11_FEATURE_DATA_D3D11_OPTIONS4}}. Direct3D 11:??This value is not supported until Direct3D 11.4. </dd>

Note??This enumeration is supported by the Direct3D 11.1 runtime, which is available on Windows?8 and later operating systems.?Values that specify minimum precision levels at shader stages.

<dd> Minimum precision level is 10-bit. </dd>

<dd> Minimum precision level is 16-bit. </dd>

Indicates the tier level at which tiled resources are supported.

<dd> Tiled resources are not supported. </dd>

<dd> Tier_1 tiled resources are supported. The device supports calls to CreateTexture2D and so on with the {{D3D11_RESOURCE_MISC_TILED}} flag. The device supports calls to CreateBuffer with the {{D3D11_RESOURCE_MISC_TILE_POOL}} flag. If you access tiles (read or write) that are {{NULL}}-mapped, you get undefined behavior, which includes device-removed. Apps can map all tiles to a single "default" tile to avoid this condition. </dd>

<dd> Tier_2 tiled resources are supported. Superset of Tier_1 functionality, which includes this additional support: <ul> <li> On Tier_1, if the size of a texture mipmap level is an integer multiple of the standard tile shape for its format, it is guaranteed to be nonpacked. On Tier_2, this guarantee is expanded to include mipmap levels whose size is at least one standard tile shape. For more info, see {{D3D11_PACKED_MIP_DESC}}. </li> <li> Shader instructions are available for clamping level-of-detail ({{LOD}}) and for obtaining status about the shader operation. For info about one of these shader instructions, see Sample(S,float,int,float,uint). </li> <li> Reading from {{NULL}}-mapped tiles treat that sampled value as zero. Writes to {{NULL}}-mapped tiles are discarded. </li> </ul> </dd>

<dd> Tier_3 tiled resources are supported. Superset of Tier_2 functionality, Tier 3 is essentially Tier 2 but with the additional support of Texture3D for Tiled Resources. </dd>

Specifies if the hardware and driver support conservative rasterization and at what tier level.

<dd> Conservative rasterization isn't supported. </dd>

<dd> Tier_1 conservative rasterization is supported. </dd>

<dd> Tier_2 conservative rasterization is supported. </dd>

<dd> Tier_3 conservative rasterization is supported. </dd>

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

This enum is used by the {{D3D_FEATURE_DATA_SHADER_CACHE}} structure.

<dd> Indicates that the driver does not support shader caching. </dd>

<dd> Indicates that the driver supports an {{OS}}-managed shader cache that stores compiled shaders in memory during the current run of the application. </dd>

<dd> Indicates that the driver supports an {{OS}}-managed shader cache that stores compiled shaders on disk to accelerate future runs of the application. </dd>

Specifies a type of compressed buffer for decoding.

<dd> Picture decoding parameter buffer. </dd>

<dd> Macroblock control command buffer. </dd>

<dd> Residual difference block data buffer. </dd>

<dd> Deblocking filter control command buffer. </dd>

<dd> Inverse quantization matrix buffer. </dd>

<dd> Slice-control buffer. </dd>

<dd> Bitstream data buffer. </dd>

<dd> Motion vector buffer. </dd>

<dd> Film grain synthesis data buffer. </dd>

Specifies how a video format can be used for video processing.

<dd> The format can be used as the input to the video processor. </dd>

<dd> The format can be used as the output from the video processor. </dd>

Defines video processing capabilities for a Microsoft Direct3D?11 video processor.

<dd> The video processor can blend video content in linear color space. Most video content is gamma corrected, resulting in nonlinear values. This capability flag means that the video processor converts colors to linear space before blending, which produces better results. </dd>

<dd> The video processor supports the xvYCC color space for {{YCbCr}} data. </dd>

<dd> The video processor can perform range conversion when the input and output are both {{RGB}} but use different color ranges (0-255 or 16-235, for 8-bit {{RGB}}). </dd>

<dd> The video processor can apply a matrix conversion to {{YCbCr}} values when the input and output are both {{YCbCr}}. For example, the driver can convert colors from {{BT}}.601 to {{BT}}.709. </dd>

<dd> The video processor supports {{YUV}} nominal range . Supported in Windows?8.1 and later. </dd>

Defines features that a Microsoft Direct3D?11 video processor can support.

<dd> The video processor can set alpha values on the output pixels. For more information, see {{ID3D11VideoContext::VideoProcessorSetOutputAlphaFillMode}}. </dd>

<dd> The video processor can downsample the video output. For more information, see {{ID3D11VideoContext::VideoProcessorSetOutputConstriction}}. </dd>

<dd> The video processor can perform luma keying. For more information, see {{ID3D11VideoContext::VideoProcessorSetStreamLumaKey}}. </dd>

<dd> The video processor can apply alpha values from color palette entries. </dd>

<dd> The driver does not support full video processing capabilities. If this capability flag is set, the video processor has the following limitations: <ul> <li>A maximum of two streams are supported:<ul> <li>The first stream must be either {{NV12}} or {{YUY2}}.</li> <li>The second stream must be {{AYUV}}, {{AI44}}, or {{IA44}}.</li> </ul> </li> <li>Image adjustment (proc amp) controls are applied to the entire video processing blit, rather than per stream.</li> <li>Support for per-stream planar alpha is not reliable. (Per-pixel alpha is supported, however.)</li> </ul> </dd>

<dd> The video processor can support 3D stereo video. For more information, see {{ID3D11VideoContext::VideoProcessorSetStreamStereoFormat}}. All drivers setting this caps must support the following stereo formats: {{D3D11_VIDEO_PROCESSOR_STEREO_FORMAT_HORIZONTAL}}, {{D3D11_VIDEO_PROCESSOR_STEREO_FORMAT_VERTICAL}}, and {{D3D11_VIDEO_PROCESSOR_STEREO_FORMAT_SEPARATE}}. </dd>

<dd> The driver can rotate the input data either 90, 180, or 270 degrees clockwise as part of the video processing operation. </dd>

<dd> The driver supports the VideoProcessorSetStreamAlpha call. </dd>

<dd> The driver supports the VideoProcessorSetStreamPixelAspectRatio call. </dd>

Defines image filter capabilities for a Microsoft Direct3D?11 video processor.

These capability flags indicate support for the image filters defined by the {{D3D11_VIDEO_PROCESSOR_FILTER}} enumeration. To apply a particular filter, call the {{ID3D11VideoContext::VideoProcessorSetStreamFilter}} method.

<dd> The video processor can adjust the brightness level. </dd>

<dd> The video processor can adjust the contrast level. </dd>

<dd> The video processor can adjust hue. </dd>

<dd> The video processor can adjust the saturation level. </dd>

<dd> The video processor can perform noise reduction. </dd>

<dd> The video processor can perform edge enhancement. </dd>

<dd> The video processor can perform anamorphic scaling. Anamorphic scaling can be used to stretch 4:3 content to a widescreen 16:9 aspect ratio. </dd>

<dd> For stereo 3D video, the video processor can adjust the offset between the left and right views, allowing the user to reduce potential eye strain. </dd>

Defines capabilities related to input formats for a Microsoft Direct3D?11 video processor.

These flags define video processing capabilities that usually are not needed, and that video devices are therefore not required to support. The first three flags relate to {{RGB}} support for functions that are normally applied to {{YCbCr}} video: deinterlacing, color adjustment, and luma keying. A device that supports these functions for {{YCbCr}} is not required to support them for {{RGB}} input. Supporting {{RGB}} input for these functions is an additional capability, reflected by these constants. Note that the driver might convert the input to another color space, perform the indicated function, and then convert the result back to {{RGB}}. Similarly, a device that supports deinterlacing is not required to support deinterlacing of palettized formats. This capability is indicated by the {{D3D11_VIDEO_PROCESSOR_FORMAT_CAPS_PALETTE_INTERLACED}} flag.

<dd> The video processor can deinterlace an input stream that contains interlaced {{RGB}} video. </dd>

<dd> The video processor can perform color adjustment on {{RGB}} video. </dd>

<dd> The video processor can perform luma keying on {{RGB}} video. </dd>

<dd> The video processor can deinterlace input streams with palettized color formats. </dd>

Specifies the automatic image processing capabilities of the video processor.

<dd> Denoise. </dd>

<dd> Deringing. </dd>

<dd> Edge enhancement. </dd>

<dd> Color correction. </dd>

<dd> Flesh-tone mapping. </dd>

<dd> Image stabilization. </dd>

<dd> Enhanced image resolution. </dd>

<dd> Anamorphic scaling. </dd>

Defines stereo 3D capabilities for a Microsoft Direct3D?11 video processor.

<dd> The video processor supports the {{D3D11_VIDEO_PROCESSOR_STEREO_FORMAT_MONO_OFFSET}} format. </dd>

<dd> The video processor supports the {{D3D11_VIDEO_PROCESSOR_STEREO_FORMAT_ROW_INTERLEAVED}} format. </dd>

<dd> The video processor supports the {{D3D11_VIDEO_PROCESSOR_STEREO_FORMAT_COLUMN_INTERLEAVED}} format. </dd>

<dd> The video processor supports the {{D3D11_VIDEO_PROCESSOR_STEREO_FORMAT_CHECKERBOARD}} format. </dd>

<dd> The video processor can flip one or both views. For more information, see {{D3D11_VIDEO_PROCESSOR_STEREO_FLIP_MODE}}. </dd>

Specifies video processing capabilities that relate to deinterlacing, inverse telecine ({{IVTC}}), and frame-rate conversion.

<dd> The video processor can perform blend deinterlacing. In blend deinterlacing, the two fields from an interlaced frame are blended into a single progressive frame. A video processor uses blend deinterlacing when it deinterlaces at half rate, as when converting 60i to 30p. Blend deinterlacing does not require reference frames. </dd>

<dd> The video processor can perform bob deinterlacing. In bob deinterlacing, missing field lines are interpolated from the lines above and below. Bob deinterlacing does not require reference frames. </dd>

<dd> The video processor can perform adaptive deinterlacing. Adaptive deinterlacing uses spatial or temporal interpolation, and switches between the two on a field-by-field basis, depending on the amount of motion. If the video processor does not receive enough reference frames to perform adaptive deinterlacing, it falls back to bob deinterlacing. </dd>

<dd> The video processor can perform motion-compensated deinterlacing. Motion-compensated deinterlacing uses motion vectors to recreate missing lines. If the video processor does not receive enough reference frames to perform motion-compensated deinterlacing, it falls back to bob deinterlacing. </dd>

<dd> The video processor can perform inverse telecine ({{IVTC}}). If the video processor supports this capability, the {{ITelecineCaps}} member of the {{D3D11_VIDEO_PROCESSOR_RATE_CONVERSION_CAPS}} structure specifies which {{IVTC}} modes are supported. </dd>

<dd> The video processor can convert the frame rate by interpolating frames. </dd>

Specifies the inverse telecine ({{IVTC}}) capabilities of a video processor.

<dd> The video processor can reverse 3:2 pulldown. </dd>

<dd> The video processor can reverse 2:2 pulldown. </dd>

<dd> The video processor can reverse 2:2:2:4 pulldown. </dd>

<dd> The video processor can reverse 2:3:3:2 pulldown. </dd>

<dd> The video processor can reverse 3:2:3:2:2 pulldown. </dd>

<dd> The video processor can reverse 5:5 pulldown. </dd>

<dd> The video processor can reverse 6:4 pulldown. </dd>

<dd> The video processor can reverse 8:7 pulldown. </dd>

<dd> The video processor can reverse 2:2:2:2:2:2:2:2:2:2:2:3 pulldown. </dd>

<dd> The video processor can reverse other telecine modes not listed here. </dd>

Contains flags that describe content-protection capabilities.

<dd> The content protection is implemented in software by the driver. </dd>

<dd> The content protection is implemented in hardware by the {{GPU}}. </dd>

<dd> Content protection is always applied to a protected surface, regardless of whether the application explicitly enables protection. </dd>

<dd> The driver can use partially encrypted buffers. If this capability is not present, the entire buffer must be either encrypted or clear. </dd>

<dd> The driver can encrypt data using a separate content key that is encrypted using the session key. </dd>

<dd> The driver can refresh the session key without renegotiating the key. </dd>

<dd> The driver can read back encrypted data from a protected surface. For more information, see {{ID3D11VideoContext::EncryptionBlt}}. </dd>

<dd> The driver requires a separate key to read encrypted data from a protected surface. </dd>

<dd> If the encryption type is {{D3DCRYPTOTYPE_AES128_CTR}}, the application must use a sequential count in the {{D3D11_AES_CTR_IV}} structure. </dd>

<dd> The driver supports encrypted slice data, but does not support any other encrypted data in the compressed buffer. The caller should not encrypt any data within the buffer other than the slice data. Note??The driver should only report this flag for the specific profiles that have this limitation. ? </dd>

<dd> The driver can copy encrypted data from one resource to another, decrypting the data as part of the process. </dd>

<dd> The hardware supports the protection of specific resources. This means that: <ul> <li>The contents of a protected allocation can never be read by the {{CPU}}.</li> <li>The hardware can ensure a protected resource cannot be copied to an unprotected resource.</li> </ul> Note??This enumeration value is supported starting with Windows?10. </dd>

<dd> Physical pages of a protected resource can be evicted and potentially paged to disk in low memory conditions without losing the contents of the resource when paged back in. Note??This enumeration value is supported starting with Windows?10. </dd>

<dd> The hardware supports an automatic teardown mechanism that could trigger hardware keys or protected content to become lost in some conditions. The application can register to be notified when these events occur. Note??This enumeration value is supported starting with Windows?10. </dd>

<dd> The secure environment is tightly coupled with the {{GPU}} and an {{ID3D11CryptoSession}} should be used for communication between the user mode {{DRM}} component and the secure execution environment. Note??This enumeration value is supported starting with Windows?10. </dd>

Identifies a video processor filter.

<dd> Brightness filter. </dd>

<dd> Contrast filter. </dd>

<dd> Hue filter. </dd>

<dd> Saturation filter. </dd>

<dd> Noise reduction filter. </dd>

<dd> Edge enhancement filter. </dd>

<dd> Anamorphic scaling filter. </dd>

<dd> Stereo adjustment filter. When stereo 3D video is enabled, this filter adjusts the offset between the left and right views, allowing the user to reduce potential eye strain. The filter value indicates the amount by which the left and right views are adjusted. A positive value shifts the images away from each other: the left image toward the left, and the right image toward the right. A negative value shifts the images in the opposite directions, closer to each other. </dd>

Describes how a video stream is interlaced.

<dd> Frames are progressive. </dd>

<dd> Frames are interlaced. The top field of each frame is displayed first. </dd>

<dd> Frame are interlaced. The bottom field of each frame is displayed first. </dd>

Specifies the intended use for a video processor.

<dd> Normal video playback. The graphics driver should expose a set of capabilities that are appropriate for real-time video playback. </dd>

<dd> Optimal speed. The graphics driver should expose a minimal set of capabilities that are optimized for performance. Use this setting if you want better performance and can accept some reduction in video quality. For example, you might use this setting in power-saving mode or to play video thumbnails. </dd>

<dd> Optimal quality. The grahics driver should expose its maximum set of capabilities. Specify this setting to get the best video quality possible. It is appropriate for tasks such as video editing, when quality is more important than speed. It is not appropriate for real-time playback. </dd>

Specifies values for the luminance range of {{YUV}} data.

<dd> Driver defaults are used, which should be Studio luminance range [16-235], </dd>

<dd> Studio luminance range [16-235] </dd>

<dd> Full luminance range [0-255] </dd>

Specifies the alpha fill mode for video processing.

<dd> Alpha values inside the target rectangle are set to opaque. </dd>

<dd> Alpha values inside the target rectangle are set to the alpha value specified in the background color. To set the background color, call the {{ID3D11VideoContext::VideoProcessorSetOutputBackgroundColor}} method. </dd>

<dd> Existing alpha values remain unchanged in the output surface. </dd>

<dd> Alpha values are taken from an input stream, scaled, and copied to the corresponding destination rectangle for that stream. The input stream is specified in the StreamIndex parameter of the {{ID3D11VideoContext::VideoProcessorSetOutputAlphaFillMode}} method. If the input stream does not have alpha data, the video processor sets the alpha values in the target rectangle to opaque. If the input stream is disabled or the source rectangle is empty, the alpha values in the target rectangle are not modified. </dd>

Specifies the rate at which the video processor produces output frames from an input stream.

<dd> The output is the normal frame rate. </dd>

<dd> The output is half the frame rate. </dd>

<dd> The output is a custom frame rate. </dd>

Specifies the layout in memory of a stereo 3D video frame.

This enumeration designates the two stereo views as "frame 0" and "frame 1". The LeftViewFrame0 parameter of the VideoProcessorSetStreamStereoFormat method specifies which view is the left view, and which is the right view.For packed formats, if the source rectangle clips part of the surface, the driver interprets the rectangle in logical coordinates relative to the stereo view, rather than absolute pixel coordinates. The result is that frame 0 and frame 1 are clipped proportionately.To query whether the device supports stereo 3D video, call {{ID3D11VideoProcessorEnumerator::GetVideoProcessorCaps}} and check for the {{D3D11_VIDEO_PROCESSOR_FEATURE_CAPS_STEREO}} flag in the FeatureCaps member of the {{D3D11_VIDEO_PROCESSOR_CAPS}} structure. If this capability flag is present, it means that the driver supports all of the stereo formats that are not listed as optional. To find out which optional formats are supported, call GetVideoProcessorCaps and check the StereoCaps member of the structure.

<dd> The sample does not contain stereo data. If the stereo format is not specified, this value is the default. </dd>

<dd> Frame 0 and frame 1 are packed side-by-side, as shown in the following diagram. All drivers that support stereo video must support this format. </dd>

<dd> Frame 0 and frame 1 are packed top-to-bottom, as shown in the following diagram. All drivers that support stereo video must support this format. </dd>

<dd> Frame 0 and frame 1 are placed in separate resources or in separate texture array elements within the same resource. All drivers that support stereo video must support this format. </dd>

<dd> The sample contains non-stereo data. However, the driver should create a left/right output of this sample using a specified offset. The offset is specified in the MonoOffset parameter of the {{ID3D11VideoContext::VideoProcessorSetStreamStereoFormat}} method. This format is primarily intended for subtitles and other subpicture data, where the entire sample is presented on the same plane. Support for this stereo format is optional. </dd>

<dd> Frame 0 and frame 1 are packed into interleaved rows, as shown in the following diagram. Support for this stereo format is optional. </dd>

<dd> Frame 0 and frame 1 are packed into interleaved columns, as shown in the following diagram. Support for this stereo format is optional. </dd>

<dd> Frame 0 and frame 1 are packed in a checkerboard format, as shown in the following diagram. Support for this stereo format is optional. </dd>

For stereo 3D video, specifies whether the data in frame 0 or frame 1 is flipped, either horizontally or vertically.

<dd> Neither frame is flipped. </dd>

<dd> The data in frame 0 is flipped. </dd>

<dd> The data in frame 1 is flipped. </dd>

Specifies the video rotation states.

<dd> The video is not rotated. </dd>

<dd> The video is rotated 90 degrees clockwise. </dd>

<dd> The video is rotated 180 degrees clockwise. </dd>

<dd> The video is rotated 270 degrees clockwise. </dd>

Specifies the type of Microsoft Direct3D authenticated channel.

<dd> Direct3D?11 channel. This channel provides communication with the Direct3D runtime. </dd>

<dd> Software driver channel. This channel provides communication with a driver that implements content protection mechanisms in software. </dd>

<dd> Hardware driver channel. This channel provides communication with a driver that implements content protection mechanisms in the {{GPU}} hardware. </dd>

Specifies the type of process that is identified in the {{D3D11_AUTHENTICATED_QUERY_RESTRICTED_SHARED_RESOURCE_PROCESS_OUTPUT}} structure.

Specifies the type of I/O bus that is used by the graphics adapter.

<dd> Indicates a type of bus other than the types listed here. </dd>

<dd> {{PCI}} Express bus. </dd>

<dd> Accelerated Graphics Port ({{AGP}}) bus. </dd>

<dd> The implementation for the graphics adapter is in a motherboard chipset's north bridge. This flag implies that data never goes over an expansion bus (such as {{PCI}} or {{AGP}}) when it is transferred from main memory to the graphics adapter. </dd>

<dd> Indicates that the graphics adapter is connected to a motherboard chipset's north bridge by tracks on the motherboard, and all of the graphics adapter's chips are soldered to the motherboard. This flag implies that data never goes over an expansion bus (such as {{PCI}} or {{AGP}}) when it is transferred from main memory to the graphics adapter. </dd>

<dd> The graphics adapter is connected to a motherboard chipset's north bridge by tracks on the motherboard, and all of the graphics adapter's chips are connected through sockets to the motherboard. </dd>

<dd> The graphics adapter is connected to the motherboard through a daughterboard connector. </dd>

<dd> The graphics adapter is connected to the motherboard through a daughterboard connector, and the graphics adapter is inside an enclosure that is not user accessible. </dd>

<dd> One of the {{D3D11_BUS_IMPL_MODIFIER_Xxx}} flags is set. </dd>

Specifies how to access a resource that is used in a video decoding output view.

This enumeration is used with the {{D3D11_VIDEO_DECODER_OUTPUT_VIEW_DESC}} structure.

<dd> Not a valid value. </dd>

<dd> The resource will be accessed as a 2D texture. </dd>

Specifies how to access a resource that is used in a video processor input view.

This enumeration is used with the {{D3D11_VIDEO_PROCESSOR_INPUT_VIEW_DESC}} structure.

<dd> Not a valid value. </dd>

<dd> The resource will be accessed as a 2D texture. </dd>

Specifies how to access a resource that is used in a video processor output view.

This enumeration is used with the {{D3D11_VIDEO_PROCESSOR_OUTPUT_VIEW_DESC}} structure.

<dd> Not a valid value. </dd>

<dd> The resource will be accessed as a 2D texture. </dd>

<dd> The resource will be accessed as an array of 2D textures. </dd>

Describes parameters that are used to create a device.

Device creation flags are used by {{D3D11CreateDevice}} and {{D3D11CreateDeviceAndSwapChain}}.An application might dynamically create (and destroy) threads to improve performance especially on a machine with multiple {{CPU}} cores. There may be cases, however, when an application needs to prevent extra threads from being created. This can happen when you want to simplify debugging, profile code or develop a tool for instance. For these cases, use {{D3D11_CREATE_DEVICE_PREVENT_INTERNAL_THREADING_OPTIMIZATIONS}} to request that the runtime and video driver not create any additional threads that might interfere with the application.

<dd> Use this flag if your application will only call methods of Direct3D?11 interfaces from a single thread. By default, the {{ID3D11Device}} object is thread-safe. By using this flag, you can increase performance. However, if you use this flag and your application calls methods of Direct3D?11 interfaces from multiple threads, undefined behavior might result. </dd>

<dd> Creates a device that supports the debug layer. To use this flag, you must have {{D3D11}}*{{SDKLayers}}.dll installed; otherwise, device creation fails. To get {{D3D11_1SDKLayers}}.dll, install the {{SDK}} for Windows?8. </dd>

<dd> Note??This flag is not supported in Direct3D?11. ? </dd>

<dd> Prevents multiple threads from being created. When this flag is used with a Windows Advanced Rasterization Platform ({{WARP}}) device, no additional threads will be created by {{WARP}} and all rasterization will occur on the calling thread. This flag is not recommended for general use. See remarks. </dd>

<dd> Creates a device that supports {{BGRA}} formats ({{DXGI_FORMAT_B8G8R8A8_UNORM}} and {{DXGI_FORMAT_B8G8R8A8_UNORM_SRGB}}). All 10level9 and higher hardware with {{WDDM}} 1.1+ drivers support {{BGRA}} formats. Note??Required for Direct2D interoperability with Direct3D resources. ? </dd>

<dd> Causes the device and driver to keep information that you can use for shader debugging. The exact impact from this flag will vary from driver to driver. To use this flag, you must have {{D3D11_1SDKLayers}}.dll installed; otherwise, device creation fails. The created device supports the debug layer. To get {{D3D11_1SDKLayers}}.dll, install the {{SDK}} for Windows?8. If you use this flag and the current driver does not support shader debugging, device creation fails. Shader debugging requires a driver that is implemented to the {{WDDM}} for Windows?8 ({{WDDM}} 1.2). Direct3D 11:??This value is not supported until Direct3D 11.1. </dd>

<dd> Causes the Direct3D runtime to ignore registry settings that turn on the debug layer. You can turn on the debug layer by using the DirectX Control Panel that was included as part of the DirectX {{SDK}}. We shipped the last version of the DirectX {{SDK}} in June 2010; you can download it from the Microsoft Download Center. You can set this flag in your app, typically in release builds only, to prevent end users from using the DirectX Control Panel to monitor how the app uses Direct3D. Note??You can also set this flag in your app to prevent Direct3D debugging tools, such as Visual Studio Ultimate?2012, from hooking your app. ? Windows?8.1:??This flag doesn't prevent Visual Studio?2013 and later running on Windows?8.1 and later from hooking your app; instead use {{ID3D11DeviceContext2::IsAnnotationEnabled}}. This flag still prevents Visual Studio?2013 and later running on Windows?8 and earlier from hooking your app. Direct3D 11:??This value is not supported until Direct3D 11.1. </dd>

<dd> Use this flag if the device will produce {{GPU}} workloads that take more than two seconds to complete, and you want the operating system to allow them to successfully finish. If this flag is not set, the operating system performs timeout detection and recovery when it detects a {{GPU}} packet that took more than two seconds to execute. If this flag is set, the operating system allows such a long running packet to execute without resetting the {{GPU}}. We recommend not to set this flag if your device needs to be highly responsive so that the operating system can detect and recover from {{GPU}} timeouts. We recommend to set this flag if your device needs to perform time consuming background tasks such as compute, image recognition, and video encoding to allow such tasks to successfully finish. Direct3D 11:??This value is not supported until Direct3D 11.1. </dd>

<dd> Forces the creation of the Direct3D device to fail if the display driver is not implemented to the {{WDDM}} for Windows?8 ({{WDDM}} 1.2). When the display driver is not implemented to {{WDDM}} 1.2, only a Direct3D device that is created with feature level 9.1, 9.2, or 9.3 supports video; therefore, if this flag is set, the runtime creates the Direct3D device only for feature level 9.1, 9.2, or 9.3. We recommend not to specify this flag for applications that want to favor Direct3D capability over video. If feature level 10 and higher is available, the runtime will use that feature level regardless of video support. If this flag is set, device creation on the Basic Render Device ({{BRD}}) will succeed regardless of the {{BRD}}'s missing support for video decode. This is because the Media Foundation video stack operates in software mode on {{BRD}}. In this situation, if you force the video stack to create the Direct3D device twice (create the device once with this flag, next discover {{BRD}}, then again create the device without the flag), you actually degrade performance. If you attempt to create a Direct3D device with driver type {{D3D_DRIVER_TYPE_NULL}}, {{D3D_DRIVER_TYPE_REFERENCE}}, or {{D3D_DRIVER_TYPE_SOFTWARE}}, device creation fails at any feature level because none of the associated drivers provide video capability. If you attempt to create a Direct3D device with driver type {{D3D_DRIVER_TYPE_WARP}}, device creation succeeds to allow software fallback for video. Direct3D 11:??This value is not supported until Direct3D 11.1. </dd>

A description of a single element for the input-assembler stage.

An input-layout object contains an array of structures, each structure defines one element being read from an input slot. Create an input-layout object by calling {{ID3D11Device::CreateInputLayout}}. For an example, see the "Create the Input-Layout Object" subtopic under the Getting Started with the Input-Assembler Stage topic.

<dd> The {{HLSL}} semantic associated with this element in a shader input-signature. </dd>

<dd> The semantic index for the element. A semantic index modifies a semantic, with an integer index number. A semantic index is only needed in a case where there is more than one element with the same semantic. For example, a 4x4 matrix would have four components each with the semantic name <pre>matrix</pre> , however each of the four component would have different semantic indices (0, 1, 2, and 3). </dd>

<dd> The data type of the element data. See {{DXGI_FORMAT}}. </dd>

<dd> An integer value that identifies the input-assembler (see input slot). Valid values are between 0 and 15, defined in {{D3D11}}.h. </dd>

<dd> Optional. Offset (in bytes) between each element. Use {{D3D11_APPEND_ALIGNED_ELEMENT}} for convenience to define the current element directly after the previous one, including any packing if necessary. </dd>

<dd> Identifies the input data class for a single input slot (see {{D3D11_INPUT_CLASSIFICATION}}). </dd>

<dd> The number of instances to draw using the same per-instance data before advancing in the buffer by one element. This value must be 0 for an element that contains per-vertex data (the slot class is set to {{D3D11_INPUT_PER_VERTEX_DATA}}). </dd>

Description of a vertex element in a vertex buffer in an output slot.

<dd> Zero-based, stream number. </dd>

<dd> Type of output element; possible values include: "{{POSITION}}", "{{NORMAL}}", or "{{TEXCOORD0}}". Note that if SemanticName is {{NULL}} then ComponentCount can be greater than 4 and the described entry will be a gap in the stream out where no data will be written. </dd>

<dd> Output element's zero-based index. Should be used if, for example, you have more than one texture coordinate stored in each vertex. </dd>

<dd> Which component of the entry to begin writing out to. Valid values are 0 to 3. For example, if you only wish to output to the y and z components of a position, then StartComponent should be 1 and ComponentCount should be 2. </dd>

<dd> The number of components of the entry to write out to. Valid values are 1 to 4. For example, if you only wish to output to the y and z components of a position, then StartComponent should be 1 and ComponentCount should be 2. Note that if SemanticName is {{NULL}} then ComponentCount can be greater than 4 and the described entry will be a gap in the stream out where no data will be written. </dd>

<dd> The associated stream output buffer that is bound to the pipeline (see {{ID3D11DeviceContext::SOSetTargets}}). The valid range for OutputSlot is 0 to 3. </dd>

Defines the dimensions of a viewport.

In all cases, Width and Height must be >= 0 and TopLeftX + Width and TopLeftY + Height must be <= {{D3D11_VIEWPORT_BOUNDS_MAX}}.<table> <tr><td> Viewport Sizes and Feature Level Support Differences between Direct3D 11 and Direct3D 10: The range for the minimum and maximum viewport size is dependent on the feature level defined by {{D3D_FEATURE_LEVEL}}. <ul> <li>Direct3D 11 supports fractional viewports; the parameter types are floating-point numbers. The feature level, {{D3D_FEATURE_LEVEL_11_0}}, supports ({{D3D11_VIEWPORT_BOUNDS_MIN}}, {{D3D11_VIEWPORT_BOUNDS_MAX}}) values between (-32768, 32,767).</li> <li>Direct3D 10 does not support fractional viewports. The feature levels, {{D3D_FEATURE_LEVEL_10_1}} (or below), supports ({{D3D10_VIEWPORT_BOUNDS_MIN}}, {{D3D10_VIEWPORT_BOUNDS_MAX}}) values between (-16384, 16383).</li> </ul> </td></tr> </table>?Note??Even though you specify float values to the members of the {{D3D11_VIEWPORT}} structure for the pViewports array in a call to {{ID3D11DeviceContext::RSSetViewports}} for feature levels 9_x, {{RSSetViewports}} uses {{DWORDs}} internally. Because of this behavior, when you use a negative top left corner for the viewport, the call to {{RSSetViewports}} for feature levels 9_x fails. This failure occurs because {{RSSetViewports}} for 9_x casts the floating point values into unsigned integers without validation, which results in integer overflow.?

<dd> X position of the left hand side of the viewport. Ranges between {{D3D11_VIEWPORT_BOUNDS_MIN}} and {{D3D11_VIEWPORT_BOUNDS_MAX}}. </dd>

<dd> Y position of the top of the viewport. Ranges between {{D3D11_VIEWPORT_BOUNDS_MIN}} and {{D3D11_VIEWPORT_BOUNDS_MAX}}. </dd>

<dd> Width of the viewport. </dd>

<dd> Height of the viewport. </dd>

<dd> Minimum depth of the viewport. Ranges between 0 and 1. </dd>

<dd> Maximum depth of the viewport. Ranges between 0 and 1. </dd>

Arguments for draw instanced indirect.

The members of this structure serve the same purpose as the parameters of {{ID3D11DeviceContext::DrawInstanced}}.

<dd> The number of vertices to draw. </dd>

<dd> The number of instances to draw. </dd>

<dd> The index of the first vertex. </dd>

<dd> A value added to each index before reading per-instance data from a vertex buffer. </dd>

Arguments for draw indexed instanced indirect.

The members of this structure serve the same purpose as the parameters of {{ID3D11DeviceContext::DrawIndexedInstanced}}.

<dd> The number of indices read from the index buffer for each instance. </dd>

<dd> The number of instances to draw. </dd>

<dd> The location of the first index read by the {{GPU}} from the index buffer. </dd>

<dd> A value added to each index before reading a vertex from the vertex buffer. </dd>

<dd> A value added to each index before reading per-instance data from a vertex buffer. </dd>

Defines a 3D box.

The following diagram shows a 3D box, where the origin is the left, front, top corner.The values for right, bottom, and back are each one pixel past the end of the pixels that are included in the box region. That is, the values for left, top, and front are included in the box region while the values for right, bottom, and back are excluded from the box region. For example, for a box that is one pixel wide, (right - left) == 1; the box region includes the left pixel but not the right pixel.Coordinates of a box are in bytes for buffers and in texels for textures.

<dd> The x position of the left hand side of the box. </dd>

<dd> The y position of the top of the box. </dd>

<dd> The z position of the front of the box. </dd>

<dd> The x position of the right hand side of the box. </dd>

<dd> The y position of the bottom of the box. </dd>

<dd> The z position of the back of the box. </dd>

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

All stencil operations are specified as a {{D3D11_STENCIL_OP}}. The stencil operation can be set differently based on the outcome of the stencil test (which is referred to as StencilFunc in the stencil test portion of depth-stencil testing.This structure is a member of a depth-stencil description.

<dd> The stencil operation to perform when stencil testing fails. </dd>

<dd> The stencil operation to perform when stencil testing passes and depth testing fails. </dd>

<dd> The stencil operation to perform when stencil testing and depth testing both pass. </dd>

<dd> A function that compares stencil data against existing stencil data. The function options are listed in {{D3D11_COMPARISON_FUNC}}. </dd>

Describes depth-stencil state.

Pass a reference to {{D3D11_DEPTH_STENCIL_DESC}} to the {{ID3D11Device::CreateDepthStencilState}} method to create the depth-stencil state object.Depth-stencil state controls how depth-stencil testing is performed by the output-merger stage.The following table shows the default values of depth-stencil states.<table> <tr><th>State</th><th>Default Value</th></tr> <tr><td>DepthEnable</td><td>{{TRUE}}</td></tr> <tr><td>DepthWriteMask</td><td>{{D3D11_DEPTH_WRITE_MASK_ALL}}</td></tr> <tr><td>DepthFunc</td><td>{{D3D11_COMPARISON_LESS}}</td></tr> <tr><td>StencilEnable</td><td>{{FALSE}}</td></tr> <tr><td>StencilReadMask</td><td>{{D3D11_DEFAULT_STENCIL_READ_MASK}}</td></tr> <tr><td>StencilWriteMask</td><td>{{D3D11_DEFAULT_STENCIL_WRITE_MASK}}</td></tr> <tr><td> FrontFace.StencilFunc and BackFace.StencilFunc </td><td>{{D3D11_COMPARISON_ALWAYS}}</td></tr> <tr><td> FrontFace.StencilDepthFailOp and BackFace.StencilDepthFailOp </td><td>{{D3D11_STENCIL_OP_KEEP}}</td></tr> <tr><td> FrontFace.StencilPassOp and BackFace.StencilPassOp </td><td>{{D3D11_STENCIL_OP_KEEP}}</td></tr> <tr><td> FrontFace.StencilFailOp and BackFace.StencilFailOp </td><td>{{D3D11_STENCIL_OP_KEEP}}</td></tr> </table>?The formats that support stenciling are {{DXGI_FORMAT_D24_UNORM_S8_UINT}} and {{DXGI_FORMAT_D32_FLOAT_S8X24_UINT}}.

<dd> Enable depth testing. </dd>

<dd> Identify a portion of the depth-stencil buffer that can be modified by depth data (see {{D3D11_DEPTH_WRITE_MASK}}). </dd>

<dd> A function that compares depth data against existing depth data. The function options are listed in {{D3D11_COMPARISON_FUNC}}. </dd>

<dd> Enable stencil testing. </dd>

<dd> Identify a portion of the depth-stencil buffer for reading stencil data. </dd>

<dd> Identify a portion of the depth-stencil buffer for writing stencil data. </dd>

<dd> Identify how to use the results of the depth test and the stencil test for pixels whose surface normal is facing towards the camera (see {{D3D11_DEPTH_STENCILOP_DESC}}). </dd>

<dd> Identify how to use the results of the depth test and the stencil test for pixels whose surface normal is facing away from the camera (see {{D3D11_DEPTH_STENCILOP_DESC}}). </dd>

Describes the blend state for a render target.

You specify an array of {{D3D11_RENDER_TARGET_BLEND_DESC}} structures in the RenderTarget member of the {{D3D11_BLEND_DESC}} structure to describe the blend states for render targets; you can bind up to eight render targets to the output-merger stage at one time.For info about how blending is done, see the output-merger stage.Here are the default values for blend state.<table> <tr><th>State</th><th>Default Value</th></tr> <tr><td>BlendEnable</td><td>{{FALSE}}</td></tr> <tr><td>SrcBlend</td><td>{{D3D11_BLEND_ONE}}</td></tr> <tr><td>DestBlend</td><td>{{D3D11_BLEND_ZERO}}</td></tr> <tr><td>BlendOp</td><td>{{D3D11_BLEND_OP_ADD}}</td></tr> <tr><td>SrcBlendAlpha</td><td>{{D3D11_BLEND_ONE}}</td></tr> <tr><td>DestBlendAlpha</td><td>{{D3D11_BLEND_ZERO}}</td></tr> <tr><td>BlendOpAlpha</td><td>{{D3D11_BLEND_OP_ADD}}</td></tr> <tr><td>RenderTargetWriteMask</td><td>{{D3D11_COLOR_WRITE_ENABLE_ALL}}</td></tr> </table>?

<dd> Enable (or disable) blending. </dd>

<dd> This blend option specifies the operation to perform on the {{RGB}} value that the pixel shader outputs. The BlendOp member defines how to combine the SrcBlend and DestBlend operations. </dd>

<dd> This blend option specifies the operation to perform on the current {{RGB}} value in the render target. The BlendOp member defines how to combine the SrcBlend and DestBlend operations. </dd>

<dd> This blend operation defines how to combine the SrcBlend and DestBlend operations. </dd>

<dd> This blend option specifies the operation to perform on the alpha value that the pixel shader outputs. Blend options that end in _COLOR are not allowed. The BlendOpAlpha member defines how to combine the SrcBlendAlpha and DestBlendAlpha operations. </dd>

<dd> This blend option specifies the operation to perform on the current alpha value in the render target. Blend options that end in _COLOR are not allowed. The BlendOpAlpha member defines how to combine the SrcBlendAlpha and DestBlendAlpha operations. </dd>

<dd> This blend operation defines how to combine the SrcBlendAlpha and DestBlendAlpha operations. </dd>

<dd> A write mask. </dd>

Describes the blend state that you use in a call to {{ID3D11Device::CreateBlendState}} to create a blend-state object.

Describes rasterizer state.

Rasterizer state defines the behavior of the rasterizer stage. To create a rasterizer-state object, call {{ID3D11Device::CreateRasterizerState}}. To set rasterizer state, call {{ID3D11DeviceContext::RSSetState}}.If you do not specify some rasterizer state, the Direct3D runtime uses the following default values for rasterizer state.<table> <tr><th>State</th><th>Default Value</th></tr> <tr><td>FillMode</td><td>Solid</td></tr> <tr><td>CullMode</td><td>Back</td></tr> <tr><td>FrontCounterClockwise</td><td>{{FALSE}}</td></tr> <tr><td>DepthBias</td><td>0</td></tr> <tr><td>SlopeScaledDepthBias</td><td>0.0f</td></tr> <tr><td>DepthBiasClamp</td><td>0.0f</td></tr> <tr><td>DepthClipEnable</td><td>{{TRUE}}</td></tr> <tr><td>ScissorEnable</td><td>{{FALSE}}</td></tr> <tr><td>MultisampleEnable</td><td>{{FALSE}}</td></tr> <tr><td>AntialiasedLineEnable</td><td>{{FALSE}}</td></tr> </table>?Note??For feature levels 9.1, 9.2, 9.3, and 10.0, if you set MultisampleEnable to {{FALSE}}, the runtime renders all points, lines, and triangles without anti-aliasing even for render targets with a sample count greater than 1. For feature levels 10.1 and higher, the setting of MultisampleEnable has no effect on points and triangles with regard to {{MSAA}} and impacts only the selection of the line-rendering algorithm as shown in this table:? <table> <tr><th>Line-rendering algorithm</th><th>MultisampleEnable</th><th>AntialiasedLineEnable</th></tr> <tr><td>Aliased</td><td>{{FALSE}}</td><td>{{FALSE}}</td></tr> <tr><td>Alpha antialiased</td><td>{{FALSE}}</td><td>{{TRUE}}</td></tr> <tr><td>Quadrilateral</td><td>{{TRUE}}</td><td>{{FALSE}}</td></tr> <tr><td>Quadrilateral</td><td>{{TRUE}}</td><td>{{TRUE}}</td></tr> </table>?The settings of the MultisampleEnable and AntialiasedLineEnable members apply only to multisample antialiasing ({{MSAA}}) render targets (that is, render targets with sample counts greater than 1). Because of the differences in feature-level behavior and as long as you aren?t performing any line drawing or don?t mind that lines render as quadrilaterals, we recommend that you always set MultisampleEnable to {{TRUE}} whenever you render on {{MSAA}} render targets.

<dd> Determines the fill mode to use when rendering (see {{D3D11_FILL_MODE}}). </dd>

<dd> Indicates triangles facing the specified direction are not drawn (see {{D3D11_CULL_MODE}}). </dd>

<dd> Determines if a triangle is front- or back-facing. If this parameter is {{TRUE}}, a triangle will be considered front-facing if its vertices are counter-clockwise on the render target and considered back-facing if they are clockwise. If this parameter is {{FALSE}}, the opposite is true. </dd>

<dd> Depth value added to a given pixel. For info about depth bias, see Depth Bias. </dd>

<dd> Maximum depth bias of a pixel. For info about depth bias, see Depth Bias. </dd>

<dd> Scalar on a given pixel's slope. For info about depth bias, see Depth Bias. </dd>

<dd> Enable clipping based on distance. The hardware always performs x and y clipping of rasterized coordinates. When DepthClipEnable is set to the default?{{TRUE}}, the hardware also clips the z value (that is, the hardware performs the last step of the following algorithm). <code> 0 < w -w <= x <= w (or arbitrarily wider range if implementation uses a guard band to reduce clipping burden) -w <= y <= w (or arbitrarily wider range if implementation uses a guard band to reduce clipping burden) 0 <= z <= w </code> When you set DepthClipEnable to {{FALSE}}, the hardware skips the z clipping (that is, the last step in the preceding algorithm). However, the hardware still performs the "0 < w" clipping. When z clipping is disabled, improper depth ordering at the pixel level might result. However, when z clipping is disabled, stencil shadow implementations are simplified. In other words, you can avoid complex special-case handling for geometry that goes beyond the back clipping plane. </dd>

<dd> Enable scissor-rectangle culling. All pixels outside an active scissor rectangle are culled. </dd>

<dd> Specifies whether to use the quadrilateral or alpha line anti-aliasing algorithm on multisample antialiasing ({{MSAA}}) render targets. Set to {{TRUE}} to use the quadrilateral line anti-aliasing algorithm and to {{FALSE}} to use the alpha line anti-aliasing algorithm. For more info about this member, see Remarks. </dd>

<dd> Specifies whether to enable line antialiasing; only applies if doing line drawing and MultisampleEnable is {{FALSE}}. For more info about this member, see Remarks. </dd>

Specifies data for initializing a subresource.

This structure is used in calls to create buffers ({{ID3D11Device::CreateBuffer}}) and textures ({{ID3D11Device::CreateTexture1D}}, {{ID3D11Device::CreateTexture2D}}, and {{ID3D11Device::CreateTexture3D}}). If the resource you create does not require a system-memory pitch or a system-memory-slice pitch, you can use those members to pass size information, which might help you when you debug a problem with creating a resource.A subresource is a single mipmap-level surface. You can pass an array of subresources to one of the preceding methods to create the resource. A subresource can be 1D, 2D, or 3D. How you set the members of {{D3D11_SUBRESOURCE_DATA}} depend on whether the subresource is 1D, 2D, or 3D.<dl> <dt>1D</dt> <dd> You set SysMemPitch to the length of the 1D surface in bytes. pSysMem points to the start of the 1D surface. You don't need to set SysMemSlicePitch. To access a specific pixel, you use: <pre>(const char*)pSysMem + (x * BytesPerPixel)</pre> </dd> <dt>2D</dt> <dd> You set SysMemPitch to the distance between any two adjacent pixels on different lines. You set SysMemSlicePitch to the size of the entire 2D surface in bytes. To access a specific pixel, you use: <pre>(const char*)pSysMem + SysMemPitch*y + (x * BytesPerPixel)</pre> </dd> <dt>3D</dt> <dd> You set SysMemPitch to the distance between any two adjacent pixels on different lines. You set SysMemSlicePitch to the distance between any two adjacent 2D slices of the 3D surface. To access a specific pixel, you use: <pre>(const char*)pSysMem + SysMemSlicePitch*d + SysMemPitch*y + (x * BytesPerPixel)</pre> </dd> </dl>The x, y, and d values are 0-based indices and BytesPerPixel depends on the pixel format. For mipmapped 3D surfaces, the number of depth slices in each level is half the number of the previous level (minimum 1) and rounded down if dividing by two results in a non-whole number.Note??An application must not rely on SysMemPitch being exactly equal to the number of texels in a line times the size of a texel. In some cases, SysMemPitch will include padding to skip past additional data in a line. This could be padding for alignment or the texture could be a subsection of a larger texture. For example, the {{D3D11_SUBRESOURCE_DATA}} structure could represent a 32 by 32 subsection of a 128 by 128 texture. The value for SysMemSlicePitch will reflect any padding included in SysMemPitch.?

<dd> Pointer to the initialization data. </dd>

<dd> The distance (in bytes) from the beginning of one line of a texture to the next line. System-memory pitch is used only for 2D and 3D texture data as it is has no meaning for the other resource types. Specify the distance from the first pixel of one 2D slice of a 3D texture to the first pixel of the next 2D slice in that texture in the SysMemSlicePitch member. </dd>

<dd> The distance (in bytes) from the beginning of one depth level to the next. System-memory-slice pitch is only used for 3D texture data as it has no meaning for the other resource types. </dd>

Provides access to subresource data.

This structure is used in a call to {{ID3D11DeviceContext::Map}}.The values in these members tell you how much data you can view:<ul> <li>pData points to row 0 and depth slice 0.</li> <li>RowPitch contains the value that the runtime adds to pData to move from row to row, where each row contains multiple pixels.</li> <li>DepthPitch contains the value that the runtime adds to pData to move from depth slice to depth slice, where each depth slice contains multiple rows.</li> </ul>When RowPitch and DepthPitch are not appropriate for the resource type, the runtime might set their values to 0. So, don't use these values for anything other than iterating over rows and depth. Here are some examples:<ul> <li>For Buffer and Texture1D, the runtime assigns values that aren't 0 to RowPitch and DepthPitch. For example, if a Buffer contains 8 bytes, the runtime assigns values to RowPitch and DepthPitch that are greater than or equal to 8.</li> <li>For Texture2D, the runtime still assigns a value that isn't 0 to DepthPitch, assuming that the field isn't used.</li> </ul>Note?? The runtime might assign values to RowPitch and DepthPitch that are larger than anticipated because there might be padding between rows and depth.?

<dd> Pointer to the data. When {{ID3D11DeviceContext::Map}} provides the reference, the runtime ensures that the reference has a specific alignment, depending on the following feature levels: <ul> <li>For {{D3D_FEATURE_LEVEL_10_0}} and higher, the reference is aligned to 16 bytes.</li> <li>For lower than {{D3D_FEATURE_LEVEL_10_0}}, the reference is aligned to 4 bytes.</li> </ul> </dd>

<dd> The row pitch, or width, or physical size (in bytes) of the data. </dd>

<dd> The depth pitch, or width, or physical size (in bytes)of the data. </dd>

Describes a buffer resource.

This structure is used by {{ID3D11Device::CreateBuffer}} to create buffer resources.In addition to this structure, you can also use the {{CD3D11_BUFFER_DESC}} derived structure, which is defined in {{D3D11}}.h and behaves like an inherited class, to help create a buffer description.If the bind flag is {{D3D11_BIND_CONSTANT_BUFFER}}, you must set the ByteWidth value in multiples of 16, and less than or equal to {{D3D11_REQ_CONSTANT_BUFFER_ELEMENT_COUNT}}.

<dd> Size of the buffer in bytes. </dd>

<dd> Identify how the buffer is expected to be read from and written to. Frequency of update is a key factor. The most common value is typically {{D3D11_USAGE_DEFAULT}}; see {{D3D11_USAGE}} for all possible values. </dd>

<dd> Identify how the buffer will be bound to the pipeline. Flags (see {{D3D11_BIND_FLAG}}) can be combined with a logical {{OR}}. </dd>

<dd> {{CPU}} access flags (see {{D3D11_CPU_ACCESS_FLAG}}) or 0 if no {{CPU}} access is necessary. Flags can be combined with a logical {{OR}}. </dd>

<dd> Miscellaneous flags (see {{D3D11_RESOURCE_MISC_FLAG}}) or 0 if unused. Flags can be combined with a logical {{OR}}. </dd>

<dd> The size of each element in the buffer structure (in bytes) when the buffer represents a structured buffer. For more info about structured buffers, see Structured Buffer. The size value in StructureByteStride must match the size of the format that you use for views of the buffer. For example, if you use a shader resource view ({{SRV}}) to read a buffer in a pixel shader, the {{SRV}} format size must match the size value in StructureByteStride. </dd>

Describes a 1D texture.

This structure is used in a call to {{ID3D11Device::CreateTexture1D}}.In addition to this structure, you can also use the {{CD3D11_TEXTURE1D_DESC}} derived structure, which is defined in {{D3D11}}.h and behaves like an inherited class, to help create a texture description.The texture size range is determined by the feature level at which you create the device and not the Microsoft Direct3D interface version. For example, if you use Microsoft Direct3D?10 hardware at feature level 10 ({{D3D_FEATURE_LEVEL_10_0}}) and call {{D3D11CreateDevice}} to create an {{ID3D11Device}}, you must constrain the maximum texture size to {{D3D10_REQ_TEXTURE1D_U_DIMENSION}} (8192) when you create your 1D texture.

<dd> Texture width (in texels). The range is from 1 to {{D3D11_REQ_TEXTURE1D_U_DIMENSION}} (16384). However, the range is actually constrained by the feature level at which you create the rendering device. For more information about restrictions, see Remarks. </dd>

<dd> The maximum number of mipmap levels in the texture. See the remarks in {{D3D11_TEX1D_SRV}}. Use 1 for a multisampled texture; or 0 to generate a full set of subtextures. </dd>

<dd> Number of textures in the array. The range is from 1 to {{D3D11_REQ_TEXTURE1D_ARRAY_AXIS_DIMENSION}} (2048). However, the range is actually constrained by the feature level at which you create the rendering device. For more information about restrictions, see Remarks. </dd>

<dd> Texture format (see {{DXGI_FORMAT}}). </dd>

<dd> Value that identifies how the texture is to be read from and written to. The most common value is {{D3D11_USAGE_DEFAULT}}; see {{D3D11_USAGE}} for all possible values. </dd>

<dd> Flags (see {{D3D11_BIND_FLAG}}) for binding to pipeline stages. The flags can be combined by a logical {{OR}}. For a 1D texture, the allowable values are: {{D3D11_BIND_SHADER_RESOURCE}}, {{D3D11_BIND_RENDER_TARGET}} and {{D3D11_BIND_DEPTH_STENCIL}}. </dd>

<dd> Flags (see {{D3D11_CPU_ACCESS_FLAG}}) to specify the types of {{CPU}} access allowed. Use 0 if {{CPU}} access is not required. These flags can be combined with a logical {{OR}}. </dd>

Describes a 2D texture.

This structure is used in a call to {{ID3D11Device::CreateTexture2D}}.In addition to this structure, you can also use the {{CD3D11_TEXTURE2D_DESC}} derived structure, which is defined in {{D3D11}}.h and behaves like an inherited class, to help create a texture description.The device places some size restrictions (must be multiples of a minimum size) for a subsampled, block compressed, or bit-format resource.The texture size range is determined by the feature level at which you create the device and not the Microsoft Direct3D interface version. For example, if you use Microsoft Direct3D?10 hardware at feature level 10 ({{D3D_FEATURE_LEVEL_10_0}}) and call {{D3D11CreateDevice}} to create an {{ID3D11Device}}, you must constrain the maximum texture size to {{D3D10_REQ_TEXTURE2D_U_OR_V_DIMENSION}} (8192) when you create your 2D texture.

<dd> Texture width (in texels). The range is from 1 to {{D3D11_REQ_TEXTURE2D_U_OR_V_DIMENSION}} (16384). For a texture cube-map, the range is from 1 to {{D3D11_REQ_TEXTURECUBE_DIMENSION}} (16384). However, the range is actually constrained by the feature level at which you create the rendering device. For more information about restrictions, see Remarks. </dd>

<dd> Texture height (in texels). The range is from 1 to {{D3D11_REQ_TEXTURE2D_U_OR_V_DIMENSION}} (16384). For a texture cube-map, the range is from 1 to {{D3D11_REQ_TEXTURECUBE_DIMENSION}} (16384). However, the range is actually constrained by the feature level at which you create the rendering device. For more information about restrictions, see Remarks. </dd>

<dd> Number of textures in the texture array. The range is from 1 to {{D3D11_REQ_TEXTURE2D_ARRAY_AXIS_DIMENSION}} (2048). For a texture cube-map, this value is a multiple of 6 (that is, 6 times the value in the NumCubes member of {{D3D11_TEXCUBE_ARRAY_SRV}}), and the range is from 6 to 2046. The range is actually constrained by the feature level at which you create the rendering device. For more information about restrictions, see Remarks. </dd>

<dd> Texture format (see {{DXGI_FORMAT}}). </dd>

<dd> Structure that specifies multisampling parameters for the texture. See {{DXGI_SAMPLE_DESC}}. </dd>

<dd> Flags (see {{D3D11_BIND_FLAG}}) for binding to pipeline stages. The flags can be combined by a logical {{OR}}. </dd>

<dd> Flags (see {{D3D11_RESOURCE_MISC_FLAG}}) that identify other, less common resource options. Use 0 if none of these flags apply. These flags can be combined by using a logical {{OR}}. For a texture cube-map, set the {{D3D11_RESOURCE_MISC_TEXTURECUBE}} flag. Cube-map arrays (that is, ArraySize > 6) require feature level {{D3D_FEATURE_LEVEL_10_1}} or higher. </dd>

Describes a 3D texture.

This structure is used in a call to {{ID3D11Device::CreateTexture3D}}.In addition to this structure, you can also use the {{CD3D11_TEXTURE3D_DESC}} derived structure, which is defined in {{D3D11}}.h and behaves like an inherited class, to help create a texture description.The device restricts the size of subsampled, block compressed, and bit format resources to be multiples of sizes specific to each format.The texture size range is determined by the feature level at which you create the device and not the Microsoft Direct3D interface version. For example, if you use Microsoft Direct3D?10 hardware at feature level 10 ({{D3D_FEATURE_LEVEL_10_0}}) and call {{D3D11CreateDevice}} to create an {{ID3D11Device}}, you must constrain the maximum texture size to {{D3D10_REQ_TEXTURE3D_U_V_OR_W_DIMENSION}} (2048) when you create your 3D texture.

<dd> Texture width (in texels). The range is from 1 to {{D3D11_REQ_TEXTURE3D_U_V_OR_W_DIMENSION}} (2048). However, the range is actually constrained by the feature level at which you create the rendering device. For more information about restrictions, see Remarks. </dd>

<dd> Texture height (in texels). The range is from 1 to {{D3D11_REQ_TEXTURE3D_U_V_OR_W_DIMENSION}} (2048). However, the range is actually constrained by the feature level at which you create the rendering device. For more information about restrictions, see Remarks. </dd>

<dd> Texture depth (in texels). The range is from 1 to {{D3D11_REQ_TEXTURE3D_U_V_OR_W_DIMENSION}} (2048). However, the range is actually constrained by the feature level at which you create the rendering device. For more information about restrictions, see Remarks. </dd>

<dd> Texture format (see {{DXGI_FORMAT}}). </dd>

<dd> Flags (see {{D3D11_BIND_FLAG}}) for binding to pipeline stages. The flags can be combined by a logical {{OR}}. </dd>

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

The {{D3D11_BUFFER_SRV}} structure is a member of the {{D3D11_SHADER_RESOURCE_VIEW_DESC}} structure, which represents a shader-resource view description. You can create a shader-resource view by calling the {{ID3D11Device::CreateShaderResourceView}} method.

<dd> Number of bytes between the beginning of the buffer and the first element to access. </dd>

<dd> The offset of the first element in the view to access, relative to element 0. </dd>

<dd> The total number of elements in the view. </dd>

<dd> The width of each element (in bytes). This can be determined from the format stored in the shader-resource-view description. </dd>

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

This structure is used by {{D3D11_SHADER_RESOURCE_VIEW_DESC}} to create a raw view of a buffer.

<dd> The index of the first element to be accessed by the view. </dd>

<dd> The number of elements in the resource. </dd>

<dd> A {{D3D11_BUFFEREX_SRV_FLAG}}-typed value that identifies view options for the buffer. Currently, the only option is to identify a raw view of the buffer. For more info about raw viewing of buffers, see Raw Views of Buffers. </dd>

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

This structure is one member of a shader-resource-view description (see {{D3D11_SHADER_RESOURCE_VIEW_DESC}}).As an example, assuming MostDetailedMip = 6 and MipLevels = 2, the view will have access to 2 mipmap levels, 6 and 7, of the original texture for which {{ID3D11Device::CreateShaderResourceView}} creates the view. In this situation, MostDetailedMip is greater than the MipLevels in the view. However, MostDetailedMip is not greater than the MipLevels in the original resource.

<dd> Index of the most detailed mipmap level to use; this number is between 0 and MipLevels (from the original Texture1D for which {{ID3D11Device::CreateShaderResourceView}} creates a view) -1. </dd>

<dd> The maximum number of mipmap levels for the view of the texture. See the remarks. Set to -1 to indicate all the mipmap levels from MostDetailedMip on down to least detailed. </dd>

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

This structure is one member of a shader-resource-view description (see {{D3D11_SHADER_RESOURCE_VIEW_DESC}}).

<dd> The maximum number of mipmap levels for the view of the texture. See the remarks in {{D3D11_TEX1D_SRV}}. Set to -1 to indicate all the mipmap levels from MostDetailedMip on down to least detailed. </dd>

<dd> The index of the first texture to use in an array of textures. </dd>

<dd> Number of textures in the array. </dd>

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

This structure is one member of a shader-resource-view description (see {{D3D11_SHADER_RESOURCE_VIEW_DESC}}).

<dd> Index of the most detailed mipmap level to use; this number is between 0 and MipLevels (from the original Texture2D for which {{ID3D11Device::CreateShaderResourceView}} creates a view) -1. </dd>

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

This structure is one member of a shader-resource-view description (see {{D3D11_SHADER_RESOURCE_VIEW_DESC}}).

<dd> The index of the first texture to use in an array of textures. </dd>

<dd> Number of textures in the array. </dd>

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

This structure is one member of a shader-resource-view description (see {{D3D11_SHADER_RESOURCE_VIEW_DESC}}).

<dd> Index of the most detailed mipmap level to use; this number is between 0 and MipLevels (from the original Texture3D for which {{ID3D11Device::CreateShaderResourceView}} creates a view) -1. </dd>

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

This structure is one member of a shader-resource-view description (see {{D3D11_SHADER_RESOURCE_VIEW_DESC}}).

<dd> Index of the most detailed mipmap level to use; this number is between 0 and MipLevels (from the original TextureCube for which {{ID3D11Device::CreateShaderResourceView}} creates a view) -1. </dd>

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

This structure is one member of a shader-resource-view description (see {{D3D11_SHADER_RESOURCE_VIEW_DESC}}).

<dd> Index of the first 2D texture to use. </dd>

<dd> Number of cube textures in the array. </dd>

Specifies the subresources from a multisampled 2D texture to use in a shader-resource view.

Since a multisampled 2D texture contains a single subresource, there is actually nothing to specify in {{D3D11_TEX2DMS_RTV}}. Consequently, UnusedField_NothingToDefine is included so that this structure will compile in C.

<dd> Integer of any value. See remarks. </dd>

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

This structure is one member of a shader-resource-view description (see {{D3D11_SHADER_RESOURCE_VIEW_DESC}}).

<dd> The index of the first texture to use in an array of textures. </dd>

<dd> Number of textures to use. </dd>

Describes a shader-resource view.

A view is a format-specific way to look at the data in a resource. The view determines what data to look at, and how it is cast when read.When viewing a resource, the resource-view description must specify a typed format, that is compatible with the resource format. So that means that you cannot create a resource-view description using any format with _TYPELESS in the name. You can however view a typeless resource by specifying a typed format for the view. For example, a {{DXGI_FORMAT_R32G32B32_TYPELESS}} resource can be viewed with one of these typed formats: {{DXGI_FORMAT_R32G32B32_FLOAT}}, {{DXGI_FORMAT_R32G32B32_UINT}}, and {{DXGI_FORMAT_R32G32B32_SINT}}, since these typed formats are compatible with the typeless resource.Create a shader-resource-view description by calling {{ID3D11Device::CreateShaderResourceView}}. To view a shader-resource-view description, call {{ID3D11ShaderResourceView::GetDesc}}.

<dd> A {{DXGI_FORMAT}} specifying the viewing format. See remarks. </dd>

<dd> The resource type of the view. See {{D3D11_SRV_DIMENSION}}. This should be the same as the resource type of the underlying resource. This parameter also determines which _SRV to use in the union below. </dd>

<dd> View the resource as a buffer using information from a shader-resource view (see {{D3D11_BUFFER_SRV}}). </dd>

<dd> View the resource as a 1D texture using information from a shader-resource view (see {{D3D11_TEX1D_SRV}}). </dd>

<dd> View the resource as a 1D-texture array using information from a shader-resource view (see {{D3D11_TEX1D_ARRAY_SRV}}). </dd>

<dd> View the resource as a 2D-texture using information from a shader-resource view (see {{D3D11_TEX2D_SRV}}). </dd>

<dd> View the resource as a 2D-texture array using information from a shader-resource view (see {{D3D11_TEX2D_ARRAY_SRV}}). </dd>

<dd> View the resource as a 2D-multisampled texture using information from a shader-resource view (see {{D3D11_TEX2DMS_SRV}}). </dd>

<dd> View the resource as a 2D-multisampled-texture array using information from a shader-resource view (see {{D3D11_TEX2DMS_ARRAY_SRV}}). </dd>

<dd> View the resource as a 3D texture using information from a shader-resource view (see {{D3D11_TEX3D_SRV}}). </dd>

<dd> View the resource as a 3D-cube texture using information from a shader-resource view (see {{D3D11_TEXCUBE_SRV}}). </dd>

<dd> View the resource as a 3D-cube-texture array using information from a shader-resource view (see {{D3D11_TEXCUBE_ARRAY_SRV}}). </dd>

<dd> View the resource as a raw buffer using information from a shader-resource view (see {{D3D11_BUFFEREX_SRV}}). For more info about raw viewing of buffers, see Raw Views of Buffers. </dd>

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

A render-target view is a member of a render-target-view description (see {{D3D11_RENDER_TARGET_VIEW_DESC}}). Create a render-target view by calling {{ID3D11Device::CreateRenderTargetView}}.

<dd> Number of bytes between the beginning of the buffer and the first element to access. </dd>

<dd> The offset of the first element in the view to access, relative to element 0. </dd>

<dd> The total number of elements in the view. </dd>

<dd> The width of each element (in bytes). This can be determined from the format stored in the render-target-view description. </dd>

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

This structure is one member of a render-target-view description (see {{D3D11_RENDER_TARGET_VIEW_DESC}}).

<dd> The index of the mipmap level to use mip slice. </dd>

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

This structure is one member of a render-target-view description (see {{D3D11_RENDER_TARGET_VIEW_DESC}}).

<dd> The index of the mipmap level to use mip slice. </dd>

<dd> The index of the first texture to use in an array of textures. </dd>

<dd> Number of textures to use. </dd>

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

This structure is one member of a render-target-view description (see {{D3D11_RENDER_TARGET_VIEW_DESC}}).

<dd> The index of the mipmap level to use mip slice. </dd>

Specifies the subresource from a multisampled 2D texture to use in a render-target view.

<dd> Integer of any value. See remarks. </dd>

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

This structure is one member of a render-target-view description (see {{D3D11_RENDER_TARGET_VIEW_DESC}}).

<dd> The index of the mipmap level to use mip slice. </dd>

<dd> The index of the first texture to use in an array of textures. </dd>

<dd> Number of textures in the array to use in the render target view, starting from FirstArraySlice. </dd>

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

This structure is one member of a render-target-view description (see {{D3D11_RENDER_TARGET_VIEW_DESC}}).

<dd> The index of the first texture to use in an array of textures. </dd>

<dd> Number of textures to use. </dd>

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

This structure is one member of a render target view. See {{D3D11_RENDER_TARGET_VIEW_DESC}}.

<dd> The index of the mipmap level to use mip slice. </dd>

<dd> First depth level to use. </dd>

<dd> Number of depth levels to use in the render-target view, starting from FirstWSlice. A value of -1 indicates all of the slices along the w axis, starting from FirstWSlice. </dd>

Specifies the subresources from a resource that are accessible using a render-target view.

A render-target-view description is passed into {{ID3D11Device::CreateRenderTargetView}} to create a render target.A render-target-view cannot use the following formats:<ul> <li>Any typeless format.</li> <li>{{DXGI_FORMAT_R32G32B32}} if the view will be used to bind a buffer (vertex, index, constant, or stream-output).</li> </ul>If the format is set to {{DXGI_FORMAT_UNKNOWN}}, then the format of the resource that the view binds to the pipeline will be used.

<dd> The data format (see {{DXGI_FORMAT}}). </dd>

<dd> The resource type (see {{D3D11_RTV_DIMENSION}}), which specifies how the render-target resource will be accessed. </dd>

<dd> Specifies which buffer elements can be accessed (see {{D3D11_BUFFER_RTV}}). </dd>

<dd> Specifies the subresources in a 1D texture that can be accessed (see {{D3D11_TEX1D_RTV}}). </dd>

<dd> Specifies the subresources in a 1D texture array that can be accessed (see {{D3D11_TEX1D_ARRAY_RTV}}). </dd>

<dd> Specifies the subresources in a 2D texture that can be accessed (see {{D3D11_TEX2D_RTV}}). </dd>

<dd> Specifies the subresources in a 2D texture array that can be accessed (see {{D3D11_TEX2D_ARRAY_RTV}}). </dd>

<dd> Specifies a single subresource because a multisampled 2D texture only contains one subresource (see {{D3D11_TEX2DMS_RTV}}). </dd>

<dd> Specifies the subresources in a multisampled 2D texture array that can be accessed (see {{D3D11_TEX2DMS_ARRAY_RTV}}). </dd>

<dd> Specifies subresources in a 3D texture that can be accessed (see {{D3D11_TEX3D_RTV}}). </dd>

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

This structure is one member of a depth-stencil-view description (see {{D3D11_DEPTH_STENCIL_VIEW_DESC}}).

<dd> The index of the first mipmap level to use. </dd>

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

This structure is one member of a depth-stencil-view description (see {{D3D11_DEPTH_STENCIL_VIEW_DESC}}).

<dd> The index of the first mipmap level to use. </dd>

<dd> The index of the first texture to use in an array of textures. </dd>

<dd> Number of textures to use. </dd>

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

This structure is one member of a depth-stencil-view description (see {{D3D11_DEPTH_STENCIL_VIEW_DESC}}).

<dd> The index of the first mipmap level to use. </dd>

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

This structure is one member of a depth-stencil-view description (see {{D3D11_DEPTH_STENCIL_VIEW_DESC}}).

<dd> The index of the first mipmap level to use. </dd>

<dd> The index of the first texture to use in an array of textures. </dd>

<dd> Number of textures to use. </dd>

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

Because a multisampled 2D texture contains a single subtexture, there is nothing to specify; this unused member is included so that this structure will compile in C.

<dd> Unused. </dd>

Specifies the subresources from an array of multisampled 2D textures for a depth-stencil view.

This structure is one member of a depth-stencil-view description (see {{D3D11_DEPTH_STENCIL_VIEW_DESC}}).

<dd> The index of the first texture to use in an array of textures. </dd>

<dd> Number of textures to use. </dd>

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

These are valid formats for a depth-stencil view:<ul> <li>{{DXGI_FORMAT_D16_UNORM}}</li> <li>{{DXGI_FORMAT_D24_UNORM_S8_UINT}}</li> <li>{{DXGI_FORMAT_D32_FLOAT}}</li> <li>{{DXGI_FORMAT_D32_FLOAT_S8X24_UINT}}</li> <li>{{DXGI_FORMAT_UNKNOWN}}</li> </ul>A depth-stencil view cannot use a typeless format. If the format chosen is {{DXGI_FORMAT_UNKNOWN}}, then the format of the parent resource is used.A depth-stencil-view description is needed when calling {{ID3D11Device::CreateDepthStencilView}}.

<dd> Resource data format (see {{DXGI_FORMAT}}). See remarks for allowable formats. </dd>

<dd> Type of resource (see {{D3D11_DSV_DIMENSION}}). Specifies how a depth-stencil resource will be accessed; the value is stored in the union in this structure. </dd>

<dd> A value that describes whether the texture is read only. Pass 0 to specify that it is not read only; otherwise, pass one of the members of the {{D3D11_DSV_FLAG}} enumerated type. </dd>

<dd> Specifies a 1D texture subresource (see {{D3D11_TEX1D_DSV}}). </dd>

<dd> Specifies an array of 1D texture subresources (see {{D3D11_TEX1D_ARRAY_DSV}}). </dd>

<dd> Specifies a 2D texture subresource (see {{D3D11_TEX2D_DSV}}). </dd>

<dd> Specifies an array of 2D texture subresources (see {{D3D11_TEX2D_ARRAY_DSV}}). </dd>

<dd> Specifies a multisampled 2D texture (see {{D3D11_TEX2DMS_DSV}}). </dd>

<dd> Specifies an array of multisampled 2D textures (see {{D3D11_TEX2DMS_ARRAY_DSV}}). </dd>

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

This structure is used by a {{D3D11_UNORDERED_ACCESS_VIEW_DESC}}.

<dd> The zero-based index of the first element to be accessed. </dd>

<dd> The number of elements in the resource. For structured buffers, this is the number of structures in the buffer. </dd>

<dd> View options for the resource (see {{D3D11_BUFFER_UAV_FLAG}}). </dd>

Describes a unordered-access 1D texture resource.

This structure is used by a {{D3D11_UNORDERED_ACCESS_VIEW_DESC}}.

<dd> The mipmap slice index. </dd>

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

This structure is used by a {{D3D11_UNORDERED_ACCESS_VIEW_DESC}}.

<dd> The mipmap slice index. </dd>

<dd> The zero-based index of the first array slice to be accessed. </dd>

<dd> The number of slices in the array. </dd>

Describes a unordered-access 2D texture resource.

This structure is used by a {{D3D11_UNORDERED_ACCESS_VIEW_DESC}}.

<dd> The mipmap slice index. </dd>

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

This structure is used by a {{D3D11_UNORDERED_ACCESS_VIEW_DESC}}.

<dd> The mipmap slice index. </dd>

<dd> The zero-based index of the first array slice to be accessed. </dd>

<dd> The number of slices in the array. </dd>

Describes a unordered-access 3D texture resource.

This structure is used by a {{D3D11_UNORDERED_ACCESS_VIEW_DESC}}.

<dd> The mipmap slice index. </dd>

<dd> The zero-based index of the first depth slice to be accessed. </dd>

<dd> The number of depth slices. </dd>

Specifies the subresources from a resource that are accessible using an unordered-access view.

An unordered-access-view description is passed into {{ID3D11Device::CreateUnorderedAccessView}} to create a view.

<dd> The data format (see {{DXGI_FORMAT}}). </dd>

<dd> The resource type (see {{D3D11_UAV_DIMENSION}}), which specifies how the resource will be accessed. </dd>

<dd> Specifies which buffer elements can be accessed (see {{D3D11_BUFFER_UAV}}). </dd>

<dd> Specifies the subresources in a 1D texture that can be accessed (see {{D3D11_TEX1D_UAV}}). </dd>

<dd> Specifies the subresources in a 1D texture array that can be accessed (see {{D3D11_TEX1D_ARRAY_UAV}}). </dd>

<dd> Specifies the subresources in a 2D texture that can be accessed (see {{D3D11_TEX2D_UAV}}). </dd>

<dd> Specifies the subresources in a 2D texture array that can be accessed (see {{D3D11_TEX2D_ARRAY_UAV}}). </dd>

<dd> Specifies subresources in a 3D texture that can be accessed (see {{D3D11_TEX3D_UAV}}). </dd>

Describes a sampler state.

These are the default values for sampler state.<table> <tr><th>State</th><th>Default Value</th></tr> <tr><td>Filter</td><td>{{D3D11_FILTER_MIN_MAG_MIP_LINEAR}}</td></tr> <tr><td>AddressU</td><td>{{D3D11_TEXTURE_ADDRESS_CLAMP}}</td></tr> <tr><td>AddressV</td><td>{{D3D11_TEXTURE_ADDRESS_CLAMP}}</td></tr> <tr><td>AddressW</td><td>{{D3D11_TEXTURE_ADDRESS_CLAMP}}</td></tr> <tr><td>MinLOD</td><td>-3.402823466e+38F (-{{FLT_MAX}})</td></tr> <tr><td>MaxLOD</td><td>3.402823466e+38F ({{FLT_MAX}})</td></tr> <tr><td>MipMapLODBias</td><td>0.0f</td></tr> <tr><td>MaxAnisotropy</td><td>1</td></tr> <tr><td>ComparisonFunc</td><td>{{D3D11_COMPARISON_NEVER}}</td></tr> <tr><td>BorderColor</td><td>float4(1.0f,1.0f,1.0f,1.0f)</td></tr> <tr><td>Texture</td><td>N/A</td></tr> </table>?

<dd> Filtering method to use when sampling a texture (see {{D3D11_FILTER}}). </dd>

<dd> Method to use for resolving a u texture coordinate that is outside the 0 to 1 range (see {{D3D11_TEXTURE_ADDRESS_MODE}}). </dd>

<dd> Method to use for resolving a v texture coordinate that is outside the 0 to 1 range. </dd>

<dd> Method to use for resolving a w texture coordinate that is outside the 0 to 1 range. </dd>

<dd> Offset from the calculated mipmap level. For example, if Direct3D calculates that a texture should be sampled at mipmap level 3 and MipLODBias is 2, then the texture will be sampled at mipmap level 5. </dd>

<dd> Clamping value used if {{D3D11_FILTER_ANISOTROPIC}} or {{D3D11_FILTER_COMPARISON_ANISOTROPIC}} is specified in Filter. Valid values are between 1 and 16. </dd>

<dd> A function that compares sampled data against existing sampled data. The function options are listed in {{D3D11_COMPARISON_FUNC}}. </dd>

<dd> Border color to use if {{D3D11_TEXTURE_ADDRESS_BORDER}} is specified for AddressU, AddressV, or AddressW. Range must be between 0.0 and 1.0 inclusive. </dd>

<dd> Lower end of the mipmap range to clamp access to, where 0 is the largest and most detailed mipmap level and any level higher than that is less detailed. </dd>

<dd> Upper end of the mipmap range to clamp access to, where 0 is the largest and most detailed mipmap level and any level higher than that is less detailed. This value must be greater than or equal to MinLOD. To have no upper limit on {{LOD}} set this to a large value such as {{D3D11_FLOAT32_MAX}}. </dd>

Describes a query.

<dd> Type of query (see {{D3D11_QUERY}}). </dd>

<dd> Miscellaneous flags (see {{D3D11_QUERY_MISC_FLAG}}). </dd>

Query information about the reliability of a timestamp query.

For a list of query types see {{D3D11_QUERY}}.

<dd> How frequently the {{GPU}} counter increments in Hz. </dd>

<dd> If this is {{TRUE}}, something occurred in between the query's {{ID3D11DeviceContext::Begin}} and {{ID3D11DeviceContext::End}} calls that caused the timestamp counter to become discontinuous or disjoint, such as unplugging the {{AC}} cord on a laptop, overheating, or throttling up/down due to laptop savings events. The timestamp returned by {{ID3D11DeviceContext::GetData}} for a timestamp query is only reliable if Disjoint is {{FALSE}}. </dd>

Query information about graphics-pipeline activity in between calls to {{ID3D11DeviceContext::Begin}} and {{ID3D11DeviceContext::End}}.

Query information about the amount of data streamed out to the stream-output buffers in between {{ID3D11DeviceContext::Begin}} and {{ID3D11DeviceContext::End}}.

Describes a counter.

This structure is used by {{ID3D11Counter::GetDesc}}, {{ID3D11Device::CheckCounter}} and {{ID3D11Device::CreateCounter}}.

<dd> Type of counter (see {{D3D11_COUNTER}}). </dd>

<dd> Reserved. </dd>

Information about the video card's performance counter capabilities.

This structure is returned by {{ID3D11Device::CheckCounterInfo}}.

<dd> Largest device-dependent counter {{ID}} that the device supports. If none are supported, this value will be 0. Otherwise it will be greater than or equal to {{D3D11_COUNTER_DEVICE_DEPENDENT_0}}. See {{D3D11_COUNTER}}. </dd>

<dd> Number of counters that can be simultaneously supported. </dd>

<dd> Number of detectable parallel units that the counter is able to discern. Values are 1 ~ 4. Use NumDetectableParallelUnits to interpret the values of the {{VERTEX_PROCESSING}}, {{GEOMETRY_PROCESSING}}, {{PIXEL_PROCESSING}}, and {{OTHER_GPU_PROCESSING}} counters. </dd>

Describes an {{HLSL}} class instance.

The {{D3D11_CLASS_INSTANCE_DESC}} structure is returned by the {{ID3D11ClassInstance::GetDesc}} method.The members of this structure except InstanceIndex are valid (non default values) if they describe a class instance aquired using {{ID3D11ClassLinkage::CreateClassInstance}}. The InstanceIndex member is only valid when the class instance is aquired using {{ID3D11ClassLinkage::GetClassInstance}}.

<dd> The instance {{ID}} of an {{HLSL}} class; the default value is 0. </dd>

<dd> The instance index of an {{HLSL}} class; the default value is 0. </dd>

<dd> The type {{ID}} of an {{HLSL}} class; the default value is 0. </dd>

<dd> Describes the constant buffer associated with an {{HLSL}} class; the default value is 0. </dd>

<dd> The base constant buffer offset associated with an {{HLSL}} class; the default value is 0. </dd>

<dd> The base texture associated with an {{HLSL}} class; the default value is 127. </dd>

<dd> The base sampler associated with an {{HLSL}} class; the default value is 15. </dd>

<dd> True if the class was created; the default value is false. </dd>

Describes the multi-threading features that are supported by the current graphics driver.

Use the {{D3D11_FEATURE_DATA_THREADING}} structure with the {{ID3D11Device::CheckFeatureSupport}} method to determine multi-threading support.

<dd> {{TRUE}} means resources can be created concurrently on multiple threads while drawing; {{FALSE}} means that the presence of coarse synchronization will prevent concurrency. </dd>

<dd> {{TRUE}} means command lists are supported by the current driver; {{FALSE}} means that the {{API}} will emulate deferred contexts and command lists with software. </dd>

Describes double data type support in the current graphics driver.

If the runtime sets DoublePrecisionFloatShaderOps to {{TRUE}}, the hardware and driver support the following Shader Model 5 instructions:<ul> <li> dadd </li> <li> dmax </li> <li> dmin </li> <li> dmul </li> <li> deq </li> <li> dge </li> <li> dlt </li> <li> dne </li> <li> dmov </li> <li> dmovc </li> <li> dtof </li> <li> ftod </li> </ul>Note??If DoublePrecisionFloatShaderOps is {{TRUE}}, the hardware and driver do not necessarily support double-precision division.?

<dd> Specifies whether double types are allowed. If {{TRUE}}, double types are allowed; otherwise {{FALSE}}. The runtime must set DoublePrecisionFloatShaderOps to {{TRUE}} in order for you to use any {{HLSL}} shader that is compiled with a double type. </dd>

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

<dd> {{DXGI_FORMAT}} to return information on. </dd>

<dd> Combination of {{D3D11_FORMAT_SUPPORT}} flags indicating which resources are supported. </dd>

Describes which unordered resource options are supported by the current graphics driver for a given format.

<dd> {{DXGI_FORMAT}} to return information on. </dd>

<dd> Combination of {{D3D11_FORMAT_SUPPORT2}} flags indicating which unordered resource options are supported. </dd>

Describes compute shader and raw and structured buffer support in the current graphics driver.

Direct3D 11 devices ({{D3D_FEATURE_LEVEL_11_0}}) are required to support Compute Shader model 5.0. Direct3D 10.x devices ({{D3D_FEATURE_LEVEL_10_0}}, {{D3D_FEATURE_LEVEL_10_1}}) can optionally support Compute Shader model 4.0 or 4.1.

<dd> {{TRUE}} if compute shaders and raw and structured buffers are supported; otherwise {{FALSE}}. </dd>

Note??This structure is supported by the Direct3D 11.1 runtime, which is available on Windows?8 and later operating systems.?Describes Direct3D 11.1 feature options in the current graphics driver.

If a Microsoft Direct3D device supports feature level 11.1 ({{D3D_FEATURE_LEVEL_11_1}}), when you call {{ID3D11Device::CheckFeatureSupport}} with {{D3D11_FEATURE_D3D11_OPTIONS}}, CheckFeatureSupport returns a reference to {{D3D11_FEATURE_DATA_D3D11_OPTIONS}} with all member set to {{TRUE}} except the {{SAD4ShaderInstructions}} and ExtendedDoublesShaderInstructions members, which are optionally supported by the hardware and driver and therefore can be {{TRUE}} or {{FALSE}}.Feature level 11.1 provides the following additional features:<ul> <li>{{UAVs}} at every shader stage with 64 {{UAV}} bind slots instead of 8.</li> <li>Target-independent rasterization, which enables you to set the ForcedSampleCount member of {{D3D11_RASTERIZER_DESC1}} to 1, 4, 8, or 16 and to render to {{RTVs}} with a single sample.</li> <li>{{UAV}}-only rendering with the ForcedSampleCount member of {{D3D11_RASTERIZER_DESC1}} set to up to 16 (only up to 8 for feature level 11).</li> </ul>The runtime always sets the following groupings of members identically. That is, all the values in a grouping are {{TRUE}} or {{FALSE}} together:<ul> <li>DiscardAPIsSeenByDriver and FlagsForUpdateAndCopySeenByDriver</li> <li>ClearView, CopyWithOverlap, ConstantBufferPartialUpdate, ConstantBufferOffsetting, and MapNoOverwriteOnDynamicConstantBuffer</li> <li>MapNoOverwriteOnDynamicBufferSRV and MultisampleRTVWithForcedSampleCountOne</li> </ul>

<dd> Specifies whether logic operations are available in blend state. The runtime sets this member to {{TRUE}} if logic operations are available in blend state and {{FALSE}} otherwise. This member is {{FALSE}} for feature level 9.1, 9.2, and 9.3. This member is optional for feature level 10, 10.1, and 11. This member is {{TRUE}} for feature level 11.1. </dd>

<dd> Specifies whether the driver can render with no render target views ({{RTVs}}) or depth stencil views ({{DSVs}}), and only unordered access views ({{UAVs}}) bound. The runtime sets this member to {{TRUE}} if the driver can render with no {{RTVs}} or {{DSVs}} and only {{UAVs}} bound and {{FALSE}} otherwise. If {{TRUE}}, you can set the ForcedSampleCount member of {{D3D11_RASTERIZER_DESC1}} to 1, 4, or 8 when you render with no {{RTVs}} or {{DSV}} and only {{UAVs}} bound. For feature level 11.1, this member is always {{TRUE}} and you can also set ForcedSampleCount to 16 in addition to 1, 4, or 8. The default value of ForcedSampleCount is 0, which means the same as if the value is set to 1. You can always set ForcedSampleCount to 0 or 1 for {{UAV}}-only rendering independently of how this member is set. </dd>

<dd> Specifies whether the driver supports the {{ID3D11DeviceContext1::DiscardView}} and {{ID3D11DeviceContext1::DiscardResource}} methods. The runtime sets this member to {{TRUE}} if the driver supports these methods and {{FALSE}} otherwise. How this member is set does not indicate whether the driver actually uses these methods; that is, the driver might ignore these methods if they are not useful to the hardware. If {{FALSE}}, the runtime does not expose these methods to the driver because the driver does not support them. You can monitor this member during development to rule out legacy drivers on hardware where these methods might have otherwise been beneficial. You are not required to write separate code paths based on whether this member is {{TRUE}} or {{FALSE}}; you can call these methods whenever applicable. </dd>

<dd> Specifies whether the driver supports new semantics for copy and update that are exposed by the {{ID3D11DeviceContext1::CopySubresourceRegion1}} and {{ID3D11DeviceContext1::UpdateSubresource1}} methods. The runtime sets this member to {{TRUE}} if the driver supports new semantics for copy and update. The runtime sets this member to {{FALSE}} only for legacy drivers. The runtime handles this member similarly to the DiscardAPIsSeenByDriver member. </dd>

<dd> Specifies whether the driver supports the {{ID3D11DeviceContext1::ClearView}} method. The runtime sets this member to {{TRUE}} if the driver supports this method and {{FALSE}} otherwise. If {{FALSE}}, the runtime does not expose this method to the driver because the driver does not support it. Note??For feature level 9.1, 9.2, and 9.3, this member is always {{TRUE}} because the option is emulated by the runtime. ? </dd>

<dd> Specifies whether you can call {{ID3D11DeviceContext1::CopySubresourceRegion1}} with overlapping source and destination rectangles. The runtime sets this member to {{TRUE}} if you can call CopySubresourceRegion1 with overlapping source and destination rectangles and {{FALSE}} otherwise. If {{FALSE}}, the runtime does not expose this method to the driver because the driver does not support it. Note??For feature level 9.1, 9.2, and 9.3, this member is always {{TRUE}} because drivers already support the option for these feature levels. ? </dd>

<dd> Specifies whether the driver supports partial updates of constant buffers. The runtime sets this member to {{TRUE}} if the driver supports partial updates of constant buffers and {{FALSE}} otherwise. If {{FALSE}}, the runtime does not expose this operation to the driver because the driver does not support it. Note??For feature level 9.1, 9.2, and 9.3, this member is always {{TRUE}} because the option is emulated by the runtime. ? </dd>

<dd> Specifies whether the driver supports new semantics for setting offsets in constant buffers for a shader. The runtime sets this member to {{TRUE}} if the driver supports allowing you to specify offsets when you call new methods like the {{ID3D11DeviceContext1::VSSetConstantBuffers1}} method and {{FALSE}} otherwise. If {{FALSE}}, the runtime does not expose this operation to the driver because the driver does not support it. Note??For feature level 9.1, 9.2, and 9.3, this member is always {{TRUE}} because the option is emulated by the runtime. ? </dd>

<dd> Specifies whether you can call {{ID3D11DeviceContext::Map}} with {{D3D11_MAP_WRITE_NO_OVERWRITE}} on a dynamic constant buffer (that is, whether the driver supports this operation). The runtime sets this member to {{TRUE}} if the driver supports this operation and {{FALSE}} otherwise. If {{FALSE}}, the runtime fails this method because the driver does not support the operation. Note??For feature level 9.1, 9.2, and 9.3, this member is always {{TRUE}} because the option is emulated by the runtime. ? </dd>

<dd> Specifies whether you can call {{ID3D11DeviceContext::Map}} with {{D3D11_MAP_WRITE_NO_OVERWRITE}} on a dynamic buffer {{SRV}} (that is, whether the driver supports this operation). The runtime sets this member to {{TRUE}} if the driver supports this operation and {{FALSE}} otherwise. If {{FALSE}}, the runtime fails this method because the driver does not support the operation. </dd>

<dd> Specifies whether the driver supports multisample rendering when you render with {{RTVs}} bound. If {{TRUE}}, you can set the ForcedSampleCount member of {{D3D11_RASTERIZER_DESC1}} to 1 with a multisample {{RTV}} bound. The driver can support this option on feature level 10 and higher. If {{FALSE}}, the rasterizer-state creation will fail because the driver is legacy or the feature level is too low. </dd>

<dd> Specifies whether the hardware and driver support the msad4 intrinsic function in shaders. The runtime sets this member to {{TRUE}} if the hardware and driver support calls to msad4 intrinsic functions in shaders. If {{FALSE}}, the driver is legacy or the hardware does not support the option; the runtime will fail shader creation for shaders that use msad4. </dd>

<dd> Specifies whether the hardware and driver support the fma intrinsic function and other extended doubles instructions ({{DDIV}} and {{DRCP}}) in shaders. The fma intrinsic function emits an extended doubles {{DFMA}} instruction. The runtime sets this member to {{TRUE}} if the hardware and driver support extended doubles instructions in shaders (shader model 5 and higher). Support of this option implies support of basic double-precision shader instructions as well. You can use the {{D3D11_FEATURE_DOUBLES}} value to query for support of double-precision shaders. If {{FALSE}}, the hardware and driver do not support the option; the runtime will fail shader creation for shaders that use extended doubles instructions. </dd>

<dd> Specifies whether the hardware and driver support sharing a greater variety of Texture2D resource types and formats. The runtime sets this member to {{TRUE}} if the hardware and driver support extended Texture2D resource sharing. </dd>

Note??This structure is supported by the Direct3D 11.1 runtime, which is available on Windows?8 and later operating systems.?Describes information about Direct3D 11.1 adapter architecture.

<dd> Specifies whether a rendering device batches rendering commands and performs multipass rendering into tiles or bins over a render area. Certain {{API}} usage patterns that are fine for TileBasedDefferredRenderers ({{TBDRs}}) can perform worse on non-{{TBDRs}} and vice versa. Applications that are careful about rendering can be friendly to both {{TBDR}} and non-{{TBDR}} architectures. {{TRUE}} if the rendering device batches rendering commands and {{FALSE}} otherwise. </dd>

Note??This structure is supported by the Direct3D 11.1 runtime, which is available on Windows?8 and later operating systems.?Describes Direct3D 9 feature options in the current graphics driver.

<dd> Specifies whether the driver supports the nonpowers-of-2-unconditionally feature. For more information about this feature, see feature level. The runtime sets this member to {{TRUE}} for hardware at Direct3D 10 and higher feature levels. For hardware at Direct3D 9.3 and lower feature levels, the runtime sets this member to {{FALSE}} if the hardware and driver support the powers-of-2 (2D textures must have widths and heights specified as powers of two) feature or the nonpowers-of-2-conditionally feature. For more information about this feature, see feature level. </dd>

Note??This structure is supported by the Direct3D 11.1 runtime, which is available on Windows?8 and later operating systems.?Describes Direct3D?9 shadow support in the current graphics driver.

Shadows are an important element in realistic 3D scenes. You can use the shadow buffer technique to render shadows. The basic principle of the technique is to use a depth buffer to store the scene depth info from the perspective of the light source, and then compare each point rendered in the scene with that buffer to determine if it is in shadow.To render objects into the scene with shadows on them, you create sampler state objects with comparison filtering set and the comparison mode (ComparisonFunc) to LessEqual. You can also set BorderColor addressing on this depth sampler, even though BorderColor isn't typically allowed on feature levels 9.1 and 9.2. By using the border color and picking 0.0 or 1.0 as the border color value, you can control whether the regions off the edge of the shadow map appear to be always in shadow or never in shadow respectively. You can control the shadow filter quality by the Mag and Min filter settings in the comparison sampler. Point sampling will produce shadows with non-anti-aliased edges. Linear filter sampler settings will result in higher quality shadow edges, but might affect performance on some power-optimized devices.Note??If you use a separate setting for Mag versus Min filter options, you produce an undefined result. Anisotropic filtering is not supported. The Mip filter choice is not relevant because feature level 9.x does not allow mipmapped depth buffers.?Note??On feature level 9.x, you can't compile a shader with the SampleCmp and SampleCmpLevelZero intrinsic functions by using older versions of the compiler. For example, you can't use the fxc.exe compiler that ships with the DirectX {{SDK}} or use the {{D3DCompile}}** functions (like {{D3DCompileFromFile}}) that are implemented in {{D3DCompiler_43}}.dll and earlier. These intrinsic functions on feature level 9.x are only supported in the fxc.exe compiler that ships with the Windows?8 {{SDK}} and later and with the {{D3DCompile}}** functions that are implemented in {{D3DCompiler_44}}.dll and later. But these intrinsic functions are present in shader models for feature levels higher than 9.x.?

<dd> Specifies whether the driver supports the shadowing feature with the comparison-filtering mode set to less than or equal to. The runtime sets this member to {{TRUE}} for hardware at Direct3D 10 and higher feature levels. For hardware at Direct3D 9.3 and lower feature levels, the runtime sets this member to {{TRUE}} only if the hardware and driver support the shadowing feature; otherwise {{FALSE}}. </dd>

Note??This structure is supported by the Direct3D 11.1 runtime, which is available on Windows?8 and later operating systems.?Describes precision support options for shaders in the current graphics driver.

For hardware at Direct3D 10 and higher feature levels, the runtime sets both members identically. For hardware at Direct3D 9.3 and lower feature levels, the runtime can set a lower precision support in the PixelShaderMinPrecision member than the AllOtherShaderStagesMinPrecision member; for 9.3 and lower, all other shader stages represent only the vertex shader.For more info about {{HLSL}} minimum precision, see using {{HLSL}} minimum precision.

<dd> A combination of {{D3D11_SHADER_MIN_PRECISION_SUPPORT}}-typed values that are combined by using a bitwise {{OR}} operation. The resulting value specifies minimum precision levels that the driver supports for the pixel shader. A value of zero indicates that the driver supports only full 32-bit precision for the pixel shader. </dd>

<dd> A combination of {{D3D11_SHADER_MIN_PRECISION_SUPPORT}}-typed values that are combined by using a bitwise {{OR}} operation. The resulting value specifies minimum precision levels that the driver supports for all other shader stages. A value of zero indicates that the driver supports only full 32-bit precision for all other shader stages. </dd>

Note?? This structure is supported by the Direct3D 11.2 runtime, which is available on Windows?8.1 and later operating systems.?Describes Direct3D 11.2 feature options in the current graphics driver.

<dd> Specifies whether the hardware and driver support tiled resources. The runtime sets this member to a {{D3D11_TILED_RESOURCES_TIER}}-typed value that indicates if the hardware and driver support tiled resources and at what tier level. </dd>

<dd> Specifies whether the hardware and driver support the filtering options ({{D3D11_FILTER}}) of comparing the result to the minimum or maximum value during texture sampling. The runtime sets this member to {{TRUE}} if the hardware and driver support these filtering options. </dd>

<dd> Specifies whether the hardware and driver also support the {{ID3D11DeviceContext1::ClearView}} method on depth formats. For info about valid depth formats, see {{D3D11_DEPTH_STENCIL_VIEW_DESC}}. </dd>

<dd> Specifies support for creating {{ID3D11Buffer}} resources that can be passed to the {{ID3D11DeviceContext::Map}} and {{ID3D11DeviceContext::Unmap}} methods. This means that the {{CPUAccessFlags}} member of the {{D3D11_BUFFER_DESC}} structure may be set with the desired {{D3D11_CPU_ACCESS_FLAG}} elements when the Usage member of {{D3D11_BUFFER_DESC}} is set to {{D3D11_USAGE_DEFAULT}}. The runtime sets this member to {{TRUE}} if the hardware is capable of at least {{D3D_FEATURE_LEVEL_11_0}} and the graphics device driver supports mappable default buffers. </dd>

Note?? This structure is supported by the Direct3D 11.2 runtime, which is available on Windows?8.1 and later operating systems.?Describes whether simple instancing is supported.

If the Direct3D {{API}} is the Direct3D 11.2 runtime and can support 11.2 features, {{ID3D11Device::CheckFeatureSupport}} for {{D3D11_FEATURE_D3D9_SIMPLE_INSTANCING_SUPPORT}} will return a {{SUCCESS}} code when valid parameters are passed. The SimpleInstancingSupported member of {{D3D11_FEATURE_DATA_D3D9_SIMPLE_INSTANCING_SUPPORT}} will be set to {{TRUE}} or {{FALSE}}. Simple instancing means that instancing is supported with the caveat that the InstanceDataStepRate member of the {{D3D11_INPUT_ELEMENT_DESC}} structure must be equal to 1. This does not change the full instancing support provided by hardware at feature level 9.3 and above, and is meant to expose the instancing support that may be available on feature level 9.2 and 9.1 hardware.

<dd> Specifies whether the hardware and driver support simple instancing. The runtime sets this member to {{TRUE}} if the hardware and driver support simple instancing. </dd>

Note??This structure is supported by the Direct3D 11.2 runtime, which is available on Windows?8.1 and later operating systems.?Describes whether a {{GPU}} profiling technique is supported.

<dd> Specifies whether the hardware and driver support a {{GPU}} profiling technique that can be used with development tools. The runtime sets this member to {{TRUE}} if the hardware and driver support data marking. </dd>

Note??This structure is supported by the Direct3D 11.2 runtime, which is available on Windows?8.1 and later operating systems.?Describes Direct3D 9 feature options in the current graphics driver.

You can use the {{D3D11_FEATURE_D3D9_OPTIONS1}} enumeration value with {{ID3D11Device::CheckFeatureSupport}} to query a driver about support for Direct3D 9 feature options rather than making multiple calls to {{ID3D11Device::CheckFeatureSupport}} by using {{D3D11_FEATURE_D3D9_OPTIONS}}, {{D3D11_FEATURE_D3D9_SHADOW_SUPPORT}}, and {{D3D11_FEATURE_D3D9_SIMPLE_INSTANCING_SUPPORT}}, which provide identical info about supported Direct3D 9 feature options.

<dd> Specifies whether the driver supports the nonpowers-of-2-unconditionally feature. For more info about this feature, see feature level. The runtime sets this member to {{TRUE}} for hardware at Direct3D 10 and higher feature levels. For hardware at Direct3D 9.3 and lower feature levels, the runtime sets this member to {{FALSE}} if the hardware and driver support the powers-of-2 (2D textures must have widths and heights specified as powers of two) feature or the nonpowers-of-2-conditionally feature. </dd>

<dd> Specifies whether the hardware and driver support simple instancing. The runtime sets this member to {{TRUE}} if the hardware and driver support simple instancing. </dd>

<dd> Specifies whether the hardware and driver support setting a single face of a TextureCube as a render target while the depth stencil surface that is bound alongside can be a Texture2D (as opposed to TextureCube). The runtime sets this member to {{TRUE}} if the hardware and driver support this feature; otherwise {{FALSE}}. If the hardware and driver don't support this feature, the app must match the render target surface type with the depth stencil surface type. Because hardware at Direct3D 9.3 and lower feature levels doesn't allow TextureCube depth surfaces, the only way to render a scene into a TextureCube while having depth buffering enabled is to render each TextureCube face separately to a Texture2D render target first (because that can be matched with a Texture2D depth), and then copy the results into the TextureCube. If the hardware and driver support this feature, the app can just render to the TextureCube faces directly while getting depth buffering out of a Texture2D depth buffer. You only need to query this feature from hardware at Direct3D 9.3 and lower feature levels because hardware at Direct3D 10.0 and higher feature levels allow TextureCube depth surfaces. </dd>

Describes Direct3D 11.3 feature options in the current graphics driver.

<dd> Whether to use the {{VP}} and {{RT}} array index from any shader feeding the rasterizer. </dd>

Describes feature data {{GPU}} virtual address support, including maximum address bits per resource and per process.

See {{D3D11_FEATURE}}.

<dd> The maximum {{GPU}} virtual address bits per resource. </dd>

<dd> The maximum {{GPU}} virtual address bits per process. </dd>

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

<dd> The stencil operation to perform when stencil testing fails. </dd>

<dd> The stencil operation to perform when stencil testing passes and depth testing fails. </dd>

<dd> The stencil operation to perform when stencil testing and depth testing both pass. </dd>

<dd> A function that compares stencil data against existing stencil data. The function options are listed in {{D3D11_COMPARISON_FUNC}}. </dd>

Describes a video stream for a Microsoft Direct3D?11 video decoder or video processor.

<dd> The decoding profile. To get the list of profiles supported by the device, call the {{ID3D11VideoDevice::GetVideoDecoderProfile}} method. </dd>

<dd> The width of the video frame, in pixels. </dd>

<dd> The height of the video frame, in pixels. </dd>

<dd> The output surface format, specified as a {{DXGI_FORMAT}} value. </dd>

Describes the configuration of a Microsoft Direct3D?11 decoder device for DirectX Video Acceleration ({{DXVA}}).

<dd> If the bitstream data buffers are encrypted using the {{D3D11CryptoSession}} mechanism, this {{GUID}} should be set to zero. If no encryption is applied, the value is {{DXVA_NoEncrypt}}. If ConfigBitstreamRaw is 0, the value must be {{DXVA_NoEncrypt}}. </dd>

<dd> If the macroblock control data buffers are encrypted using the {{D3D11CryptoSession}} mechanism, this {{GUID}} should be set to zero. If no encryption is applied, the value is {{DXVA_NoEncrypt}}. If ConfigBitstreamRaw is 1, the value must be {{DXVA_NoEncrypt}}. </dd>

<dd> If the residual difference decoding data buffers are encrypted using the {{D3D11CryptoSession}} mechanism, this {{GUID}} should be set to zero. If no encryption is applied, the value is {{DXVA_NoEncrypt}}. If ConfigBitstreamRaw is 1, the value must be {{DXVA_NoEncrypt}}. </dd>

<dd> Indicates whether the host-decoder sends raw bit-stream data. If the value is 1, the data for the pictures will be sent in bit-stream buffers as raw bit-stream content. If the value is 0, picture data will be sent using macroblock control command buffers. If either ConfigResidDiffHost or ConfigResidDiffAccelerator is 1, the value must be 0. </dd>

<dd> Specifies whether macroblock control commands are in raster scan order or in arbitrary order. If the value is 1, the macroblock control commands within each macroblock control command buffer are in raster-scan order. If the value is 0, the order is arbitrary. For some types of bit streams, forcing raster order either greatly increases the number of required macroblock control buffers that must be processed, or requires host reordering of the control information. Therefore, supporting arbitrary order can be more efficient. </dd>

<dd> Contains the host residual difference configuration. If the value is 1, some residual difference decoding data may be sent as blocks in the spatial domain from the host. If the value is 0, spatial domain data will not be sent. </dd>

<dd> Indicates the word size used to represent residual difference spatial-domain blocks for predicted (non-intra) pictures when using host-based residual difference decoding. If ConfigResidDiffHost is 1 and ConfigSpatialResid8 is 1, the host will send residual difference spatial-domain blocks for non-intra macroblocks using 8-bit signed samples and for intra macroblocks in predicted (non-intra) pictures in a format that depends on the value of ConfigIntraResidUnsigned: <ul> <li> If ConfigIntraResidUnsigned is 0, spatial-domain blocks for intra macroblocks are sent as 8-bit signed integer values relative to a constant reference value of 2^({{BPP}}?1). </li> <li> If ConfigIntraResidUnsigned is 1, spatial-domain blocks for intra macroblocks are sent as 8-bit unsigned integer values relative to a constant reference value of 0. </li> </ul> If ConfigResidDiffHost is 1 and ConfigSpatialResid8 is 0, the host will send residual difference spatial-domain blocks of data for non-intra macroblocks using 16-bit signed samples and for intra macroblocks in predicted (non-intra) pictures in a format that depends on the value of ConfigIntraResidUnsigned: <ul> <li> If ConfigIntraResidUnsigned is 0, spatial domain blocks for intra macroblocks are sent as 16-bit signed integer values relative to a constant reference value of 2^({{BPP}}?1). </li> <li> If ConfigIntraResidUnsigned is 1, spatial domain blocks for intra macroblocks are sent as 16-bit unsigned integer values relative to a constant reference value of 0. </li> </ul> If ConfigResidDiffHost is 0, ConfigSpatialResid8 must be 0. For intra pictures, spatial-domain blocks must be sent using 8-bit samples if bits-per-pixel ({{BPP}}) is 8, and using 16-bit samples if {{BPP}} > 8. If ConfigIntraResidUnsigned is 0, these samples are sent as signed integer values relative to a constant reference value of 2^({{BPP}}?1), and if ConfigIntraResidUnsigned is 1, these samples are sent as unsigned integer values relative to a constant reference value of 0. </dd>

<dd> If the value is 1, 8-bit difference overflow blocks are subtracted rather than added. The value must be 0 unless ConfigSpatialResid8 is 1. The ability to subtract differences rather than add them enables 8-bit difference decoding to be fully compliant with the full ?255 range of values required in video decoder specifications, because +255 cannot be represented as the addition of two signed 8-bit numbers, but any number in the range ?255 can be represented as the difference between two signed 8-bit numbers (+255 = +127 minus ?128). </dd>

<dd> If the value is 1, spatial-domain blocks for intra macroblocks must be clipped to an 8-bit range on the host and spatial-domain blocks for non-intra macroblocks must be clipped to a 9-bit range on the host. If the value is 0, no such clipping is necessary by the host. The value must be 0 unless ConfigSpatialResid8 is 0 and ConfigResidDiffHost is 1. </dd>

<dd> If the value is 1, any spatial-domain residual difference data must be sent in a chrominance-interleaved form matching the {{YUV}} format chrominance interleaving pattern. The value must be 0 unless ConfigResidDiffHost is 1 and the {{YUV}} format is {{NV12}} or {{NV21}}. </dd>

<dd> Indicates the method of representation of spatial-domain blocks of residual difference data for intra blocks when using host-based difference decoding. If ConfigResidDiffHost is 1 and ConfigIntraResidUnsigned is 0, spatial-domain residual difference data blocks for intra macroblocks must be sent as follows: <ul> <li> In a non-intra picture, if ConfigSpatialResid8 is 0, the spatial-domain residual difference data blocks for intra macroblocks are sent as 16-bit signed integer values relative to a constant reference value of 2^({{BPP}}?1). </li> <li> In a non-intra picture, if ConfigSpatialResid8 is 1, the spatial-domain residual difference data blocks for intra macroblocks are sent as 8-bit signed integer values relative to a constant reference value of 2^({{BPP}}?1). </li> <li> In an intra picture, if {{BPP}} is 8, the spatial-domain residual difference data blocks for intra macroblocks are sent as 8-bit signed integer values relative to a constant reference value of 2^({{BPP}}?1), regardless of the value of ConfigSpatialResid8. </li> </ul> If ConfigResidDiffHost is 1 and ConfigIntraResidUnsigned is 1, spatial-domain residual difference data blocks for intra macroblocks must be sent as follows: <ul> <li> In a non-intra picture, if ConfigSpatialResid8 is 0, the spatial-domain residual difference data blocks for intra macroblocks must be sent as 16-bit unsigned integer values relative to a constant reference value of 0. </li> <li> In a non-intra picture, if ConfigSpatialResid8 is 1, the spatial-domain residual difference data blocks for intra macroblocks are sent as 8-bit unsigned integer values relative to a constant reference value of 0. </li> <li> In an intra picture, if {{BPP}} is 8, the spatial-domain residual difference data blocks for intra macroblocks are sent as 8-bit unsigned integer values relative to a constant reference value of 0, regardless of the value of ConfigSpatialResid8. </li> </ul> The value of the member must be 0 unless ConfigResidDiffHost is 1. </dd>

<dd> If the value is 1, transform-domain blocks of coefficient data may be sent from the host for accelerator-based {{IDCT}}. If the value is 0, accelerator-based {{IDCT}} will not be used. If both ConfigResidDiffHost and ConfigResidDiffAccelerator are 1, this indicates that some residual difference decoding will be done on the host and some on the accelerator, as indicated by macroblock-level control commands. The value must be 0 if ConfigBitstreamRaw is 1. </dd>

<dd> If the value is 1, the inverse scan for transform-domain block processing will be performed on the host, and absolute indices will be sent instead for any transform coefficients. If the value is 0, the inverse scan will be performed on the accelerator. The value must be 0 if ConfigResidDiffAccelerator is 0 or if Config4GroupedCoefs is 1. </dd>

<dd> If the value is 1, the {{IDCT}} specified in Annex W of {{ITU}}-T Recommendation H.263 is used. If the value is 0, any compliant {{IDCT}} can be used for off-host {{IDCT}}. The H.263 annex does not comply with the {{IDCT}} requirements of {{MPEG}}-2 corrigendum 2, so the value must not be 1 for use with {{MPEG}}-2 video. The value must be 0 if ConfigResidDiffAccelerator is 0, indicating purely host-based residual difference decoding. </dd>

<dd> If the value is 1, transform coefficients for off-host {{IDCT}} will be sent using the {{DXVA_TCoef4Group}} structure. If the value is 0, the {{DXVA_TCoefSingle}} structure is used. The value must be 0 if ConfigResidDiffAccelerator is 0 or if ConfigHostInverseScan is 1. </dd>

<dd> Specifies how many frames the decoder device processes at any one time. </dd>

<dd> Contains decoder-specific configuration information. </dd>

Contains an initialization vector ({{IV}}) for 128-bit Advanced Encryption Standard {{CTR}} mode ({{AES}}-{{CTR}}) block cipher encryption.

<dd> The {{IV}}, in big-endian format. </dd>

<dd> The block count, in big-endian format. </dd>

Specifies which bytes in a video surface are encrypted.

<dd> The number of bytes that are encrypted at the start of the buffer. </dd>

<dd> The number of bytes that are skipped after the first NumEncryptedBytesAtBeginning bytes, and then after each block of NumBytesInEncryptPattern bytes. Skipped bytes are not encrypted. </dd>

<dd> The number of bytes that are encrypted after each block of skipped bytes. </dd>

Describes a compressed buffer for decoding.

<dd> The type of buffer, specified as a member of the {{D3D11_VIDEO_DECODER_BUFFER_TYPE}} enumeration. </dd>

<dd> Reserved. </dd>

<dd> The offset of the relevant data from the beginning of the buffer, in bytes. This value must be zero. </dd>

<dd> The macroblock address of the first macroblock in the buffer. The macroblock address is given in raster scan order. </dd>

<dd> The number of macroblocks of data in the buffer. This count includes skipped macroblocks. </dd>

<dd> Reserved. Set to zero. </dd>

<dd> A reference to a buffer that contains an initialization vector ({{IV}}) for encrypted data. If the decode buffer does not contain encrypted data, set this member to {{NULL}}. </dd>

<dd> The size of the buffer specified in the pIV parameter. If pIV is {{NULL}}, set this member to zero. </dd>

<dd> If {{TRUE}}, the video surfaces are partially encrypted. </dd>

<dd> A {{D3D11_ENCRYPTED_BLOCK_INFO}} structure that specifies which bytes of the surface are encrypted. </dd>

Contains driver-specific data for the {{ID3D11VideoContext::DecoderExtension}} method.

The exact meaning of each structure member depends on the value of Function.

Describes the capabilities of a Microsoft Direct3D?11 video processor.

The video processor stores state information for each input stream. These states persist between blits. With each blit, the application selects which streams to enable or disable. Disabling a stream does not affect the state information for that stream.The MaxStreamStates member gives the maximum number of stream states that can be saved. The MaxInputStreams member gives the maximum number of streams that can be enabled during a blit. These two values can differ.

<dd> A bitwise {{OR}} of zero or more flags from the {{D3D11_VIDEO_PROCESSOR_DEVICE_CAPS}} enumeration. </dd>

<dd> A bitwise {{OR}} of zero or more flags from the {{D3D11_VIDEO_PROCESSOR_FEATURE_CAPS}} enumeration. </dd>

<dd> A bitwise {{OR}} of zero or more flags from the {{D3D11_VIDEO_PROCESSPR_FILTER_CAPS}} enumeration. </dd>

<dd> A bitwise {{OR}} of zero or more flags from the {{D3D11_VIDEO_PROCESSOR_FORMAT_CAPS}} enumeration. </dd>

<dd> A bitwise {{OR}} of zero or more flags from the {{D3D11_VIDEO_PROCESSOR_AUTO_STREAM_CAPS}} enumeration. </dd>

<dd> A bitwise {{OR}} of zero or more flags from the {{D3D11_VIDEO_PROCESSOR_STEREO_CAPS}} enumeration. </dd>

<dd> The number of frame-rate conversion capabilities. To enumerate the frame-rate conversion capabilities, call the {{ID3D11VideoProcessorEnumerator::GetVideoProcessorRateConversionCaps}} method. </dd>

<dd> The maximum number of input streams that can be enabled at the same time. </dd>

<dd> The maximum number of input streams for which the device can store state data. </dd>

Defines a group of video processor capabilities that are associated with frame-rate conversion, including deinterlacing and inverse telecine.

<dd> The number of past reference frames required to perform the optimal video processing. </dd>

<dd> The number of future reference frames required to perform the optimal video processing. </dd>

<dd> A bitwise {{OR}} of zero or more flags from the {{D3D11_VIDEO_PROCESSOR_PROCESSOR_CAPS}} enumeration. </dd>

<dd> A bitwise {{OR}} of zero or more flags from the {{D3D11_VIDEO_PROCESSOR_ITELECINE_CAPS}} enumeration. </dd>

<dd> The number of custom frame rates that the driver supports. To get the list of custom frame rates, call the {{ID3D11VideoProcessorEnumerator::GetVideoProcessorCustomRate}} method. </dd>

Describes the content-protection capabilities of a graphics driver.

<dd> A bitwise {{OR}} of zero or more flags from the {{D3D11_CONTENT_PROTECTION_CAPS}} enumeration. </dd>

<dd> The number of cryptographic key-exchange types that are supported by the driver. To get the list of key-exchange types, call the {{ID3D11VideoDevice::CheckCryptoKeyExchange}} method. </dd>

<dd> The encyrption block size, in bytes. The size of data to be encrypted must be a multiple of this value. </dd>

<dd> The total amount of memory, in bytes, that can be used to hold protected surfaces. </dd>

Specifies a custom rate for frame-rate conversion or inverse telecine ({{IVTC}}).

The CustomRate member gives the rate conversion factor, while the remaining members define the pattern of input and output samples.

<dd> The ratio of the output frame rate to the input frame rate, expressed as a {{DXGI_RATIONAL}} structure that holds a rational number. </dd>

<dd> The number of output frames that will be generated for every N input samples, where N = InputFramesOrFields. </dd>

<dd> If {{TRUE}}, the input stream must be interlaced. Otherwise, the input stream must be progressive. </dd>

<dd> The number of input fields or frames for every N output frames that will be generated, where N = OutputFrames. </dd>

Defines the range of supported values for an image filter.

The multiplier enables the filter range to have a fractional step value.For example, a hue filter might have an actual range of [?180.0 ... +180.0] with a step size of 0.25. The device would report the following range and multiplier:<ul> <li>Minimum: ?720</li> <li>Maximum: +720</li> <li>Multiplier: 0.25</li> </ul>In this case, a filter value of 2 would be interpreted by the device as 0.50 (or 2 ? 0.25).The device should use a multiplier that can be represented exactly as a base-2 fraction.

<dd> The minimum value of the filter. </dd>

<dd> The maximum value of the filter. </dd>

<dd> The default value of the filter. </dd>

<dd> A multiplier. Use the following formula to translate the filter setting into the actual filter value: Actual Value = Set Value???Multiplier. </dd>

Describes a video stream for a video processor.

<dd> A member of the {{D3D11_VIDEO_FRAME_FORMAT}} enumeration that describes how the video stream is interlaced. </dd>

<dd> The frame rate of the input video stream, specified as a {{DXGI_RATIONAL}} structure. </dd>

<dd> The width of the input frames, in pixels. </dd>

<dd> The height of the input frames, in pixels. </dd>

<dd> The frame rate of the output video stream, specified as a {{DXGI_RATIONAL}} structure. </dd>

<dd> The width of the output frames, in pixels. </dd>

<dd> The height of the output frames, in pixels. </dd>

<dd> A member of the {{D3D11_VIDEO_USAGE}} enumeration that describes how the video processor will be used. The value indicates the desired trade-off between speed and video quality. The driver uses this flag as a hint when it creates the video processor. </dd>

Specifies an {{RGB}} color value.

The {{RGB}} values have a nominal range of [0...1]. For an {{RGB}} format with n bits per channel, the value of each color component is calculated as follows:<code>val = f * ((1 << n)-1)</code>For example, for {{RGB}}-32 (8 bits per channel), <code>val = {{BYTE}}(f * 255.0)</code>.

<dd> The red value. </dd>

<dd> The green value. </dd>

<dd> The blue value. </dd>

<dd> The alpha value. Values range from 0 (transparent) to 1 (opaque). </dd>

Defines a color value for Microsoft Direct3D?11 video.

The anonymous union can represent both {{RGB}} and {{YCbCr}} colors. The interpretation of the union depends on the context.

<dd> A {{D3D11_VIDEO_COLOR_YCbCrA}} structure that contains a {{YCbCr}} color value. </dd>

<dd> A {{D3D11_VIDEO_COLOR_RGBA}} structure that contains an {{RGB}} color value. </dd>

Specifies the color space for video processing.

The {{RGB_Range}} member applies to {{RGB}} output, while the {{YCbCr_Matrix}} and {{YCbCr_xvYCC}} members apply to {{YCbCr}} output. If the driver performs color-space conversion on the background color, it uses the values that apply to both color spaces. If the driver supports extended {{YCbCr}} (xvYCC), it returns the {{D3D11_VIDEO_PROCESSOR_DEVICE_CAPS_xvYCC}} capabilities flag in the {{ID3D11VideoProcessorEnumerator::GetVideoProcessorCaps}} method. Otherwise, the driver ignores the value of {{YCbCr_xvYCC}} and treats all {{YCbCr}} output as conventional {{YCbCr}}. If extended {{YCbCr}} is supported, it can be used with either transfer matrix. Extended {{YCbCr}} does not change the black point or white point?the black point is still 16 and the white point is still 235. However, extended {{YCbCr}} explicitly allows blacker-than-black values in the range 1?15, and whiter-than-white values in the range 236?254. When extended {{YCbCr}} is used, the driver should not clip the luma values to the nominal 16?235 range.

<dd> Specifies whether the output is intended for playback or video processing (such as editing or authoring). The device can optimize the processing based on the type. The default state value is 0 (playback). <table> <tr><th>Value</th><th>Meaning</th></tr> <tr><td> <dl> <dt>0</dt> </dl> </td><td> Playback </td></tr> <tr><td> <dl> <dt>1</dt> </dl> </td><td> Video processing </td></tr> </table> ? </dd>

<dd> Specifies the {{RGB}} color range. The default state value is 0 (full range). <table> <tr><th>Value</th><th>Meaning</th></tr> <tr><td> <dl> <dt>0</dt> </dl> </td><td> Full range (0-255) </td></tr> <tr><td> <dl> <dt>1</dt> </dl> </td><td> Limited range (16-235) </td></tr> </table> ? </dd>

<dd> Specifies the {{YCbCr}} transfer matrix. The default state value is 0 ({{BT}}.601). <table> <tr><th>Value</th><th>Meaning</th></tr> <tr><td> <dl> <dt>0</dt> </dl> </td><td> {{ITU}}-R {{BT}}.601 </td></tr> <tr><td> <dl> <dt>1</dt> </dl> </td><td> {{ITU}}-R {{BT}}.709 </td></tr> </table> ? </dd>

<dd> Specifies whether the output uses conventional {{YCbCr}} or extended {{YCbCr}} (xvYCC). The default state value is zero (conventional {{YCbCr}}). <table> <tr><th>Value</th><th>Meaning</th></tr> <tr><td> <dl> <dt>0</dt> </dl> </td><td> Conventional {{YCbCr}} </td></tr> <tr><td> <dl> <dt>1</dt> </dl> </td><td> Extended {{YCbCr}} (xvYCC) </td></tr> </table> ? </dd>

<dd> Specifies the {{D3D11_VIDEO_PROCESSOR_NOMINAL_RANGE}}. Introduced in Windows?8.1. </dd>

<dd> Reserved. Set to zero. </dd>

Contains stream-level data for the {{ID3D11VideoContext::VideoProcessorBlt}} method.

If the stereo 3D format is {{D3D11_VIDEO_PROCESSOR_STEREO_FORMAT_SEPARATE}}, the ppPastSurfaces, pInputSurface, and ppFutureSurfaces members contain the left view.

Contains a Message Authentication Code ({{MAC}}).

<dd> A byte array that contains the cryptographic {{MAC}} value of the message. </dd>

Contains input data for the {{ID3D11VideoContext::QueryAuthenticatedChannel}} method.

Contains a response from the {{ID3D11VideoContext::QueryAuthenticatedChannel}} method.

Specifies the protection level for video content.

<dd> <dl> <dt>ProtectionEnabled</dt> <dd> If 1, video content protection is enabled. </dd> <dt>OverlayOrFullscreenRequired</dt> <dd> If 1, the application requires video to be displayed using either a hardware overlay or full-screen exclusive mode. </dd> <dt>Reserved </dt> <dd> Reserved. Set all bits to zero. </dd> </dl> </dd>

<dd> Use this member to access all of the bits in the union. </dd>

Contains the response to a {{D3D11_AUTHENTICATED_QUERY_PROTECTION}} query.

<dd> A {{D3D11_AUTHENTICATED_QUERY_OUTPUT}} structure that contains a Message Authentication Code ({{MAC}}) and other data. </dd>

<dd> A {{D3D11_AUTHENTICATED_PROTECTION_FLAGS}} union that specifies the protection level. </dd>

Contains the response to a {{D3D11_AUTHENTICATED_QUERY_CHANNEL_TYPE}} query.

<dd> A {{D3D11_AUTHENTICATED_QUERY_OUTPUT}} structure that contains a Message Authentication Code ({{MAC}}) and other data. </dd>

<dd> A {{D3D11_AUTHENTICATED_CHANNEL_TYPE}} value that specifies the channel type. </dd>

Contains the response to a {{D3D11_AUTHENTICATED_QUERY_DEVICE_HANDLE}} query.

<dd> A {{D3D11_AUTHENTICATED_QUERY_OUTPUT}} structure that contains a Message Authentication Code ({{MAC}}) and other data. </dd>

<dd> A handle to the device. </dd>

Contains input data for a {{D3D11_AUTHENTICATED_QUERY_CRYPTO_SESSION}} query.

<dd> A {{D3D11_AUTHENTICATED_QUERY_INPUT}} structure that contains the {{GUID}} for the query and other data. </dd>

<dd> A handle to a decoder device. </dd>

Contains the response to a {{D3D11_AUTHENTICATED_QUERY_CRYPTO_SESSION}} query.

<dd> A {{D3D11_AUTHENTICATED_QUERY_OUTPUT}} structure that contains a Message Authentication Code ({{MAC}}) and other data. </dd>

<dd> A handle to a decoder device. </dd>

<dd> A handle to the cryptographic session that is associated with the decoder device. </dd>

<dd> A handle to the Direct3D device that is associated with the decoder device. </dd>

Contains the response to a {{D3D11_AUTHENTICATED_QUERY_RESTRICTED_SHARED_RESOURCE_PROCESS_COUNT}} query.

<dd> A {{D3D11_AUTHENTICATED_QUERY_OUTPUT}} structure that contains a Message Authentication Code ({{MAC}}) and other data. </dd>

<dd> The number of processes that are allowed to open shared resources that have restricted access. A process cannot open such a resource unless the process has been granted access. </dd>

Contains input data for a {{D3D11_AUTHENTICATED_QUERY_RESTRICTED_SHARED_RESOURCE_PROCESS}} query.

<dd> A {{D3D11_AUTHENTICATED_QUERY_INPUT}} structure that contains the {{GUID}} for the query and other data. </dd>

<dd> The index of the process. </dd>

Contains the response to a {{D3D11_AUTHENTICATED_QUERY_RESTRICTED_SHARED_RESOURCE_PROCESS}} query.

The Desktop Window Manager ({{DWM}}) process is identified by setting ProcessIdentifier equal to {{D3D11_PROCESSIDTYPE_DWM}}. Other processes are identified by setting the process handle in ProcessHandle and setting ProcessIdentifier equal to {{D3D11_PROCESSIDTYPE_HANDLE}}.

<dd> A {{D3D11_AUTHENTICATED_QUERY_OUTPUT}} structure that contains a Message Authentication Code ({{MAC}}) and other data. </dd>

<dd> The index of the process in the list of processes. </dd>

<dd> A {{D3D11_AUTHENTICATED_PROCESS_IDENTIFIER_TYPE}} value that specifies the type of process. </dd>

<dd> A process handle. If the ProcessIdentifier member equals {{D3D11_PROCESSIDTYPE_HANDLE}}, the ProcessHandle member contains a valid handle to a process. Otherwise, this member is ignored. </dd>

Contains the response to a {{D3D11_AUTHENTICATED_QUERY_UNRESTRICTED_PROTECTED_SHARED_RESOURCE_COUNT}} query.

<dd> A {{D3D11_AUTHENTICATED_QUERY_OUTPUT}} structure that contains a Message Authentication Code ({{MAC}}) and other data. </dd>

<dd> The number of protected, shared resources that can be opened by any process without restrictions. </dd>

Contains input data for a {{D3D11_AUTHENTICATED_QUERY_OUTPUT_ID_COUNT}} query.

<dd> A {{D3D11_AUTHENTICATED_QUERY_INPUT}} structure that contains the {{GUID}} for the query and other data. </dd>

<dd> A handle to the device. </dd>

<dd> A handle to the cryptographic session. </dd>

Contains the response to a {{D3D11_AUTHENTICATED_QUERY_OUTPUT_ID_COUNT}} query.

<dd> A {{D3D11_AUTHENTICATED_QUERY_OUTPUT}} structure that contains a Message Authentication Code ({{MAC}}) and other data. </dd>

<dd> A handle to the device. </dd>

<dd> A handle to the cryptographic session. </dd>

<dd> The number of output {{IDs}} associated with the specified device and cryptographic session. </dd>

Contains input data for a {{D3D11_AUTHENTICATED_QUERY_OUTPUT_ID}} query.

<dd> A {{D3D11_AUTHENTICATED_QUERY_INPUT}} structure that contains the {{GUID}} for the query and other data. </dd>

<dd> A handle to the device. </dd>

<dd> A handle to the cryptographic session. </dd>

<dd> The index of the output {{ID}}. </dd>

Contains the response to a {{D3D11_AUTHENTICATED_QUERY_OUTPUT_ID}} query.

<dd> A {{D3D11_AUTHENTICATED_QUERY_OUTPUT}} structure that contains a Message Authentication Code ({{MAC}}) and other data. </dd>

<dd> A handle to the device. </dd>

<dd> A handle to the cryptographic session. </dd>

<dd> The index of the output {{ID}}. </dd>

<dd> An output {{ID}} that is associated with the specified device and cryptographic session. </dd>

Contains the response to a {{D3D11_AUTHENTICATED_QUERY_ENCRYPTION_WHEN_ACCESSIBLE_GUID_COUNT}} query.

<dd> A {{D3D11_AUTHENTICATED_QUERY_OUTPUT}} structure that contains a Message Authentication Code ({{MAC}}) and other data. </dd>

<dd> The number of encryption {{GUIDs}}. </dd>

Contains input data for a {{D3D11_AUTHENTICATED_QUERY_ENCRYPTION_WHEN_ACCESSIBLE_GUID}} query.

<dd> A {{D3D11_AUTHENTICATED_QUERY_INPUT}} structure that contains the {{GUID}} for the query and other data. </dd>

<dd> The index of the encryption {{GUID}}. </dd>

Contains the response to a {{D3D11_AUTHENTICATED_QUERY_ENCRYPTION_WHEN_ACCESSIBLE_GUID}} query.

<dd> A {{D3D11_AUTHENTICATED_QUERY_OUTPUT}} structure that contains a Message Authentication Code ({{MAC}}) and other data. </dd>

<dd> The index of the encryption {{GUID}}. </dd>

<dd> A {{GUID}} that specifies a supported encryption type. </dd>

Contains the response to a {{D3D11_AUTHENTICATED_QUERY_CURRENT_ENCRYPTION_WHEN_ACCESSIBLE}} query.

<dd> A {{D3D11_AUTHENTICATED_QUERY_OUTPUT}} structure that contains a Message Authentication Code ({{MAC}}) and other data. </dd>

<dd> A {{GUID}} that specifies the current encryption type. </dd>

Contains input data for the {{ID3D11VideoContext::ConfigureAuthenticatedChannel}} method.

Contains the response from the {{ID3D11VideoContext::ConfigureAuthenticatedChannel}} method.

Contains input data for a {{D3D11_AUTHENTICATED_CONFIGURE_INITIALIZE}} command.

<dd> A {{D3D11_AUTHENTICATED_CONFIGURE_INPUT}} structure that contains the command {{GUID}} and other data. </dd>

<dd> The initial sequence number for queries. </dd>

<dd> The initial sequence number for commands. </dd>

Contains input data for a {{D3D11_AUTHENTICATED_CONFIGURE_PROTECTION}} command.

<dd> A {{D3D11_AUTHENTICATED_CONFIGURE_INPUT}} structure that contains the command {{GUID}} and other data. </dd>

<dd> A {{D3D11_AUTHENTICATED_PROTECTION_FLAGS}} union that specifies the protection level. </dd>

Contains input data for a {{D3D11_AUTHENTICATED_CONFIGURE_CRYPTO_SESSION}} command.

<dd> A {{D3D11_AUTHENTICATED_CONFIGURE_INPUT}} structure that contains the command {{GUID}} and other data. </dd>

<dd> A handle to the decoder device. Get this from {{ID3D11VideoDecoder::GetDriverHandle}}. </dd>

<dd> A handle to the cryptographic session. Get this from {{ID3D11CryptoSession::GetCryptoSessionHandle}}. </dd>

<dd> A handle to the Direct3D device. Get this from {{D3D11VideoContext::QueryAuthenticatedChannel}} using {{D3D11_AUTHENTICATED_QUERY_DEVICE_HANDLE}}. </dd>

Contains input data for a {{D3D11_AUTHENTICATED_CONFIGURE_SHARED_RESOURCE}} command.

<dd> A {{D3D11_AUTHENTICATED_CONFIGURE_INPUT}} structure that contains the command {{GUID}} and other data. </dd>

<dd> A {{D3D11_AUTHENTICATED_PROCESS_IDENTIFIER_TYPE}} value that specifies the type of process. To specify the Desktop Window Manager ({{DWM}}) process, set this member to {{D3D11_PROCESSIDTYPE_DWM}}. Otherwise, set this member to {{D3D11_PROCESSIDTYPE_HANDLE}} and set the ProcessHandle member to a valid handle. </dd>

<dd> A process handle. If the ProcessType member equals {{D3D11_PROCESSIDTYPE_HANDLE}}, the ProcessHandle member specifies a handle to a process. Otherwise, the value is ignored. </dd>

<dd> If {{TRUE}}, the specified process has access to restricted shared resources. </dd>

Contains input data for a {{D3D11_AUTHENTICATED_CONFIGURE_ENCRYPTION_WHEN_ACCESSIBLE}} command.

<dd> A {{D3D11_AUTHENTICATED_CONFIGURE_INPUT}} structure that contains the command {{GUID}} and other data. </dd>

<dd> A {{GUID}} that specifies the type of encryption to apply. </dd>

Identifies the texture resource for a video decoder output view.

<dd> The zero-based index of the texture. </dd>

Describes a video decoder output view.

<dd> The decoding profile. To get the list of profiles supported by the device, call the {{ID3D11VideoDevice::GetVideoDecoderProfile}} method. </dd>

<dd> The resource type of the view, specified as a member of the {{D3D11_VDOV_DIMENSION}} enumeration. </dd>

<dd> A {{D3D11_TEX2D_VDOV}} structure that identifies the texture resource for the output view. </dd>

Identifies the texture resource for a video processor input view.

<dd> The zero-based index into the array of subtextures. </dd>

<dd> The zero-based index of the texture. </dd>

Describes a video processor input view.

<dd> The surface format. If zero, the driver uses the {{DXGI}} format that was used to create the resource. If you are using feature level 9, the value must be zero. </dd>

<dd> The resource type of the view, specified as a member of the {{D3D11_VPIV_DIMENSION}} enumeration. </dd>

<dd> A {{D3D11_TEX2D_VPIV}} structure that identifies the texture resource. </dd>

Identifies a texture resource for a video processor output view.

<dd> The zero-based index into the array of subtextures. </dd>

Identifies a texture resource for a video processor output view.

<dd> The zero-based index into the array of subtextures. </dd>

<dd> The index of the first texture to use. </dd>

<dd> The number of textures in the array. </dd>

Describes a video processor output view.

<dd> The resource type of the view, specified as a member of the {{D3D11_VPOV_DIMENSION}} enumeration. </dd>

<dd> A {{D3D11_TEX2D_VPOV}} structure that identifies the texture resource for the output view. Use this member of the union when ViewDimension equals {{D3D11_VPOV_DIMENSION_TEXTURE2D}}. </dd>

<dd> A {{D3D11_TEX2D_ARRAY_VPOV}} structure that identifies the texture array for the output view. Use this member of the union when ViewDimension equals {{D3D11_VPOV_DIMENSION_TEXTURE2DARRAY}}. </dd>

A device-child interface accesses data used by a device.

There are several types of device child interfaces, all of which inherit this interface. They include shaders, state objects, and input layouts.Windows?Phone?8: This {{API}} is supported.

Get a reference to the device that created this interface.

Any returned interfaces will have their reference count incremented by one, so be sure to call ::release() on the returned reference(s) before they are freed or else you will have a memory leak. Returns nothing.

<dd> Address of a reference to a device (see {{ID3D11Device}}). </dd>

Get application-defined data from a device child.

The data stored in the device child is set by calling {{ID3D11DeviceChild::SetPrivateData}}. Windows?Phone?8: This {{API}} is supported. This method returns one of the Direct3D 11 Return Codes.

<dd> Guid associated with the data. </dd>

<dd> A reference to a variable that on input contains the size, in bytes, of the buffer that pData points to, and on output contains the size, in bytes, of the amount of data that GetPrivateData retrieved. </dd>

<dd> A reference to a buffer that GetPrivateData fills with data from the device child if pDataSize points to a value that specifies a buffer large enough to hold the data. </dd>

Set application-defined data to a device child and associate that data with an application-defined guid.

The data stored in the device child with this method can be retrieved with {{ID3D11DeviceChild::GetPrivateData}}.The debug layer reports memory leaks by outputting a list of object interface references along with their friendly names. The default friendly name is "<unnamed>". You can set the friendly name so that you can determine if the corresponding object interface reference caused the leak. To set the friendly name, use the SetPrivateData method and the {{WKPDID_D3DDebugObjectName}} {{GUID}} that is in {{D3Dcommon}}.h. For example, to give pContext a friendly name of My name, use the following code:<pre> static const char c_szName[] = "My name"; hr = pContext->SetPrivateData( {{WKPDID_D3DDebugObjectName}}, sizeof( c_szName ) - 1, c_szName ); </pre> This method returns one of the following Direct3D 11 Return Codes.

<dd> Guid associated with the data. </dd>

<dd> Pointer to the data to be stored with this device child. If pData is {{NULL}}, DataSize must also be 0, and any data previously associated with the specified guid will be destroyed. </dd>

Associate an {{IUnknown}}-derived interface with this device child and associate that interface with an application-defined guid.

When this method is called ::addref() will be called on the {{IUnknown}}-derived interface, and when the device child is detroyed ::release() will be called on the {{IUnknown}}-derived interface. This method returns one of the following Direct3D 11 Return Codes.

<dd> Guid associated with the interface. </dd>

<dd> Pointer to an {{IUnknown}}-derived interface to be associated with the device child. </dd>

The depth-stencil-state interface holds a description for depth-stencil state that you can bind to the output-merger stage.

To create a depth-stencil-state object, call {{ID3D11Device::CreateDepthStencilState}}. To bind the depth-stencil-state object to the output-merger stage, call {{ID3D11DeviceContext::OMSetDepthStencilState}}.

Gets the description for depth-stencil state that you used to create the depth-stencil-state object.

You use the description for depth-stencil state in a call to the {{ID3D11Device::CreateDepthStencilState}} method to create the depth-stencil-state object. Returns nothing.

<dd> A reference to a {{D3D11_DEPTH_STENCIL_DESC}} structure that receives a description of the depth-stencil state. </dd>

The blend-state interface holds a description for blending state that you can bind to the output-merger stage.

Blending applies a simple function to combine output values from a pixel shader with data in a render target. You have control over how the pixels are blended by using a predefined set of blending operations and preblending operations.To create a blend-state object, call {{ID3D11Device::CreateBlendState}}. To bind the blend-state object to the output-merger stage, call {{ID3D11DeviceContext::OMSetBlendState}}.

Gets the description for blending state that you used to create the blend-state object.

You use the description for blending state in a call to the {{ID3D11Device::CreateBlendState}} method to create the blend-state object. Returns nothing.

<dd> A reference to a {{D3D11_BLEND_DESC}} structure that receives a description of the blend state. </dd>

The rasterizer-state interface holds a description for rasterizer state that you can bind to the rasterizer stage.

To create a rasterizer-state object, call {{ID3D11Device::CreateRasterizerState}}. To bind the rasterizer-state object to the rasterizer stage, call {{ID3D11DeviceContext::RSSetState}}.

Gets the description for rasterizer state that you used to create the rasterizer-state object.

You use the description for rasterizer state in a call to the {{ID3D11Device::CreateRasterizerState}} method to create the rasterizer-state object. Returns nothing.

<dd> A reference to a {{D3D11_RASTERIZER_DESC}} structure that receives a description of the rasterizer state. </dd>

A resource interface provides common actions on all resources.

You don't directly create a resource interface; instead, you create buffers and textures that inherit from a resource interface. For more info, see How to: Create a Vertex Buffer, How to: Create an Index Buffer, How to: Create a Constant Buffer, and How to: Create a Texture.

Get the type of the resource.

Windows?Phone?8: This {{API}} is supported. Returns nothing.

<dd> Pointer to the resource type (see {{D3D11_RESOURCE_DIMENSION}}). </dd>

Set the eviction priority of a resource.

Resource priorities determine which resource to evict from video memory when the system has run out of video memory. The resource will not be lost; it will be removed from video memory and placed into system memory, or possibly placed onto the hard drive. The resource will be loaded back into video memory when it is required.A resource that is set to the maximum priority, {{DXGI_RESOURCE_PRIORITY_MAXIMUM}}, is only evicted if there is no other way of resolving the incoming memory request. The Windows Display Driver Model ({{WDDM}}) tries to split an incoming memory request to its minimum size and evict lower-priority resources before evicting a resource with maximum priority.Changing the priorities of resources should be done carefully. The wrong eviction priorities could be a detriment to performance rather than an improvement. Returns nothing.

<dd> Eviction priority for the resource, which is one of the following values: <ul> <li>{{DXGI_RESOURCE_PRIORITY_MINIMUM}}</li> <li>{{DXGI_RESOURCE_PRIORITY_LOW}}</li> <li>{{DXGI_RESOURCE_PRIORITY_NORMAL}}</li> <li>{{DXGI_RESOURCE_PRIORITY_HIGH}}</li> <li>{{DXGI_RESOURCE_PRIORITY_MAXIMUM}}</li> </ul> </dd>

Get the eviction priority of a resource.

One of the following values, which specifies the eviction priority for the resource:<ul> <li>{{DXGI_RESOURCE_PRIORITY_MINIMUM}}</li> <li>{{DXGI_RESOURCE_PRIORITY_LOW}}</li> <li>{{DXGI_RESOURCE_PRIORITY_NORMAL}}</li> <li>{{DXGI_RESOURCE_PRIORITY_HIGH}}</li> <li>{{DXGI_RESOURCE_PRIORITY_MAXIMUM}}</li> </ul>

A buffer interface accesses a buffer resource, which is unstructured memory. Buffers typically store vertex or index data.

There are three types of buffers: vertex, index, or a shader-constant buffer. Create a buffer resource by calling {{ID3D11Device::CreateBuffer}}.A buffer must be bound to the pipeline before it can be accessed. Buffers can be bound to the input-assembler stage by calls to {{ID3D11DeviceContext::IASetVertexBuffers}} and {{ID3D11DeviceContext::IASetIndexBuffer}}, to the stream-output stage by a call to {{ID3D11DeviceContext::SOSetTargets}}, and to a shader stage by calling the appropriate shader method (such as {{ID3D11DeviceContext::VSSetConstantBuffers}} for example).Buffers can be bound to multiple pipeline stages simultaneously for reading. A buffer can also be bound to a single pipeline stage for writing; however, the same buffer cannot be bound for reading and writing simultaneously.

Get the properties of a buffer resource.

Returns nothing.

<dd> Pointer to a resource description (see {{D3D11_BUFFER_DESC}}) filled in by the method. </dd>

A 1D texture interface accesses texel data, which is structured memory.

To create an empty 1D texture, call {{ID3D11Device::CreateTexture1D}}. For info about how to create a 2D texture, which is similar to creating a 1D texture, see How to: Create a Texture. Textures cannot be bound directly to the pipeline; instead, a view must be created and bound. Using a view, texture data can be interpreted at run time within certain restrictions. To use the texture as a render target or depth-stencil resource, call {{ID3D11Device::CreateRenderTargetView}}, and {{ID3D11Device::CreateDepthStencilView}}, respectively. To use the texture as an input to a shader, create a by calling {{ID3D11Device::CreateShaderResourceView}}.

Get the properties of the texture resource.

Returns nothing.

<dd> Pointer to a resource description (see {{D3D11_TEXTURE1D_DESC}}). </dd>

A 2D texture interface manages texel data, which is structured memory.

To create an empty Texture2D resource, call {{ID3D11Device::CreateTexture2D}}. For info about how to create a 2D texture, see How to: Create a Texture. Textures cannot be bound directly to the pipeline; instead, a view must be created and bound. Using a view, texture data can be interpreted at run time within certain restrictions. To use the texture as a render target or depth-stencil resource, call {{ID3D11Device::CreateRenderTargetView}}, and {{ID3D11Device::CreateDepthStencilView}}, respectively. To use the texture as an input to a shader, create a by calling {{ID3D11Device::CreateShaderResourceView}}.

Get the properties of the texture resource.

Returns nothing.

<dd> Pointer to a resource description (see {{D3D11_TEXTURE2D_DESC}}). </dd>

A 3D texture interface accesses texel data, which is structured memory.

To create an empty Texture3D resource, call {{ID3D11Device::CreateTexture3D}}. For info about how to create a 2D texture, which is similar to creating a 3D texture, see How to: Create a Texture. Textures cannot be bound directly to the pipeline; instead, a view must be created and bound. Using a view, texture data can be interpreted at run time within certain restrictions. To use the texture as a render target or depth-stencil resource, call {{ID3D11Device::CreateRenderTargetView}}, and {{ID3D11Device::CreateDepthStencilView}}, respectively. To use the texture as an input to a shader, create a by calling {{ID3D11Device::CreateShaderResourceView}}.

Get the properties of the texture resource.

Returns nothing.

<dd> Pointer to a resource description (see {{D3D11_TEXTURE3D_DESC}}). </dd>

A view interface specifies the parts of a resource the pipeline can access during rendering.

A view interface is the base interface for all views. There are four types of views; a depth-stencil view, a render-target view, a shader-resource view, and an unordered-access view.<ul> <li>To create a render-target view, call {{ID3D11Device::CreateRenderTargetView}}.</li> <li>To create a depth-stencil view, call {{ID3D11Device::CreateDepthStencilView}}.</li> <li>To create a shader-resource view, call {{ID3D11Device::CreateShaderResourceView}}.</li> <li>To create an unordered-access view, call {{ID3D11Device::CreateUnorderedAccessView}}.</li> </ul>All resources must be bound to the pipeline before they can be accessed.<ul> <li>To bind a render-target view or a depth-stencil view, call {{ID3D11DeviceContext::OMSetRenderTargets}}.</li> <li>To bind a shader resource, call {{ID3D11DeviceContext::VSSetShaderResources}}.</li> </ul>

Get the resource that is accessed through this view.

This function increments the reference count of the resource by one, so it is necessary to call Release on the returned reference when the application is done with it. Destroying (or losing) the returned reference before Release is called will result in a memory leak. Returns nothing.

<dd> Address of a reference to the resource that is accessed through this view. (See {{ID3D11Resource}}.) </dd>

A shader-resource-view interface specifies the subresources a shader can access during rendering. Examples of shader resources include a constant buffer, a texture buffer, and a texture.

To create a shader-resource view, call {{ID3D11Device::CreateShaderResourceView}}.A shader-resource view is required when binding a resource to a shader stage; the binding occurs by calling {{ID3D11DeviceContext::GSSetShaderResources}}, {{ID3D11DeviceContext::VSSetShaderResources}} or {{ID3D11DeviceContext::PSSetShaderResources}}.

Get the shader resource view's description.

Returns nothing.

<dd> A reference to a {{D3D11_SHADER_RESOURCE_VIEW_DESC}} structure to be filled with data about the shader resource view. </dd>

A render-target-view interface identifies the render-target subresources that can be accessed during rendering.

To create a render-target view, call {{ID3D11Device::CreateRenderTargetView}}. To bind a render-target view to the pipeline, call {{ID3D11DeviceContext::OMSetRenderTargets}}.A rendertarget is a resource that can be written by the output-merger stage at the end of a render pass. Each render-target should also have a corresponding depth-stencil view.

Get the properties of a render target view.

Returns nothing.

<dd> Pointer to the description of a render target view (see {{D3D11_RENDER_TARGET_VIEW_DESC}}). </dd>

A depth-stencil-view interface accesses a texture resource during depth-stencil testing.

To create a depth-stencil view, call {{ID3D11Device::CreateDepthStencilView}}.To bind a depth-stencil view to the pipeline, call {{ID3D11DeviceContext::OMSetRenderTargets}}.

A depth-stencil-view interface accesses a texture resource during depth-stencil testing.

A view interface specifies the parts of a resource the pipeline can access during rendering.

To create a view for an unordered access resource, call {{ID3D11Device::CreateUnorderedAccessView}}.All resources must be bound to the pipeline before they can be accessed. Call {{ID3D11DeviceContext::CSSetUnorderedAccessViews}} to bind an unordered access view to a compute shader; call {{ID3D11DeviceContext::OMSetRenderTargetsAndUnorderedAccessViews}} to bind an unordered access view to a pixel shader.

Get a description of the resource.

Returns nothing.

<dd> Pointer to a resource description (see {{D3D11_UNORDERED_ACCESS_VIEW_DESC}}.) </dd>

A vertex-shader interface manages an executable program (a vertex shader) that controls the vertex-shader stage.

The vertex-shader interface has no methods; use {{HLSL}} to implement your shader functionality. All shaders are implemented from a common set of features referred to as the common-shader core..To create a vertex shader interface, call {{ID3D11Device::CreateVertexShader}}. Before using a vertex shader you must bind it to the device by calling {{ID3D11DeviceContext::VSSetShader}}.This interface is defined in {{D3D11}}.h.

A hull-shader interface manages an executable program (a hull shader) that controls the hull-shader stage.

The hull-shader interface has no methods; use {{HLSL}} to implement your shader functionality. All shaders are implemented from a common set of features referred to as the common-shader core..To create a hull-shader interface, call {{ID3D11Device::CreateHullShader}}. Before using a hull shader you must bind it to the device by calling {{ID3D11DeviceContext::HSSetShader}}.This interface is defined in {{D3D11}}.h.

A domain-shader interface manages an executable program (a domain shader) that controls the domain-shader stage.

The domain-shader interface has no methods; use {{HLSL}} to implement your shader functionality. All shaders are implemented from a common set of features referred to as the common-shader core..To create a domain-shader interface, call {{ID3D11Device::CreateDomainShader}}. Before using a domain shader you must bind it to the device by calling {{ID3D11DeviceContext::DSSetShader}}.This interface is defined in {{D3D11}}.h.

A geometry-shader interface manages an executable program (a geometry shader) that controls the geometry-shader stage.

The geometry-shader interface has no methods; use {{HLSL}} to implement your shader functionality. All shaders are implemented from a common set of features referred to as the common-shader core..To create a geometry shader interface, call either {{ID3D11Device::CreateGeometryShader}} or {{ID3D11Device::CreateGeometryShaderWithStreamOutput}}. Before using a geometry shader you must bind it to the device by calling {{ID3D11DeviceContext::GSSetShader}}.This interface is defined in {{D3D11}}.h.

A pixel-shader interface manages an executable program (a pixel shader) that controls the pixel-shader stage.

The pixel-shader interface has no methods; use {{HLSL}} to implement your shader functionality. All shaders in are implemented from a common set of features referred to as the common-shader core..To create a pixel shader interface, call {{ID3D11Device::CreatePixelShader}}. Before using a pixel shader you must bind it to the device by calling {{ID3D11DeviceContext::PSSetShader}}.This interface is defined in {{D3D11}}.h.

A compute-shader interface manages an executable program (a compute shader) that controls the compute-shader stage.

The compute-shader interface has no methods; use {{HLSL}} to implement your shader functionality. All shaders are implemented from a common set of features referred to as the common-shader core..To create a compute-shader interface, call {{ID3D11Device::CreateComputeShader}}. Before using a compute shader you must bind it to the device by calling {{ID3D11DeviceContext::CSSetShader}}.This interface is defined in {{D3D11}}.h.

An input-layout interface holds a definition of how to feed vertex data that is laid out in memory into the input-assembler stage of the graphics pipeline.

To create an input-layout object, call {{ID3D11Device::CreateInputLayout}}. To bind the input-layout object to the input-assembler stage, call {{ID3D11DeviceContext::IASetInputLayout}}.

The sampler-state interface holds a description for sampler state that you can bind to any shader stage of the pipeline for reference by texture sample operations.

To create a sampler-state object, call {{ID3D11Device::CreateSamplerState}}.To bind a sampler-state object to any pipeline shader stage, call the following methods:<ul> <li> {{ID3D11DeviceContext::VSSetSamplers}} </li> <li> {{ID3D11DeviceContext::HSSetSamplers}} </li> <li> {{ID3D11DeviceContext::DSSetSamplers}} </li> <li> {{ID3D11DeviceContext::GSSetSamplers}} </li> <li> {{ID3D11DeviceContext::PSSetSamplers}} </li> <li> {{ID3D11DeviceContext::CSSetSamplers}} </li> </ul>You can bind the same sampler-state object to multiple shader stages simultaneously.

Gets the description for sampler state that you used to create the sampler-state object.

You use the description for sampler state in a call to the {{ID3D11Device::CreateSamplerState}} method to create the sampler-state object. Returns nothing.

<dd> A reference to a {{D3D11_SAMPLER_DESC}} structure that receives a description of the sampler state. </dd>

This interface encapsulates methods for retrieving data from the {{GPU}} asynchronously.

There are three types of asynchronous interfaces, all of which inherit this interface:<ul> <li> {{ID3D11Query}} - Queries information from the {{GPU}}.</li> <li> {{ID3D11Predicate}} - Determines whether a piece of geometry should be processed or not depending on the results of a previous draw call.</li> <li> {{ID3D11Counter}} - Measures {{GPU}} performance.</li> </ul>

Get the size of the data (in bytes) that is output when calling {{ID3D11DeviceContext::GetData}}.

Size of the data (in bytes) that is output when calling GetData.

A query interface queries information from the {{GPU}}.

A query can be created with {{ID3D11Device::CreateQuery}}.Query data is typically gathered by issuing an {{ID3D11DeviceContext::Begin}} command, issuing some graphics commands, issuing an {{ID3D11DeviceContext::End}} command, and then calling {{ID3D11DeviceContext::GetData}} to get data about what happened in between the Begin and End calls. The data returned by GetData will be different depending on the type of query.There are, however, some queries that do not require calls to Begin. For a list of possible queries see {{D3D11_QUERY}}.A query is typically executed as shown in the following code:<pre> {{D3D11_QUERY_DESC}} queryDesc; ... // Fill out queryDesc structure {{ID3D11Query}} * pQuery; pDevice->CreateQuery(&queryDesc, &pQuery); pDeviceContext->Begin(pQuery); ... // Issue graphics commands pDeviceContext->End(pQuery); {{UINT64}} queryData; // This data type is different depending on the query type while( {{S_OK}} != pDeviceContext->GetData(pQuery, &queryData, sizeof({{UINT64}}), 0) ) { } </pre>When using a query that does not require a call to Begin, it still requires a call to End. The call to End causes the data returned by GetData to be accurate up until the last call to End.

Get a query description.

Returns nothing.

<dd> Pointer to a query description (see {{D3D11_QUERY_DESC}}). </dd>

A predicate interface determines whether geometry should be processed depending on the results of a previous draw call.

To create a predicate object, call {{ID3D11Device::CreatePredicate}}. To set the predicate object, call {{ID3D11DeviceContext::SetPredication}}.There are two types of predicates: stream-output-overflow predicates and occlusion predicates. Stream-output-overflow predicates cause any geometry residing in stream-output buffers that were overflowed to not be processed. Occlusion predicates cause any geometry that did not have a single sample pass the depth/stencil tests to not be processed.

This interface encapsulates methods for measuring {{GPU}} performance.

A counter can be created with {{ID3D11Device::CreateCounter}}.This is a derived class of {{ID3D11Asynchronous}}.Counter data is gathered by issuing an {{ID3D11DeviceContext::Begin}} command, issuing some graphics commands, issuing an {{ID3D11DeviceContext::End}} command, and then calling {{ID3D11DeviceContext::GetData}} to get data about what happened in between the Begin and End calls. The data returned by GetData will be different depending on the type of counter. The call to End causes the data returned by GetData to be accurate up until the last call to End.Counters are best suited for profiling.For a list of the types of performance counters, see {{D3D11_COUNTER}}.

Get a counter description.

Returns nothing.

<dd> Pointer to a counter description (see {{D3D11_COUNTER_DESC}}). </dd>

This interface encapsulates an {{HLSL}} class.

This interface is created by calling {{ID3D11ClassLinkage::CreateClassInstance}}. The interface is used when binding shader resources to the pipeline using {{APIs}} such as {{ID3D11DeviceContext::VSSetShader}}.

Gets the {{ID3D11ClassLinkage}} object associated with the current {{HLSL}} class.

For more information about using the {{ID3D11ClassInstance}} interface, see Dynamic Linking. Windows?Phone?8: This {{API}} is supported. This method does not return a value.

Gets a description of the current {{HLSL}} class.

For more information about using the {{ID3D11ClassInstance}} interface, see Dynamic Linking. An instance is not restricted to being used for a single type in a single shader. An instance is flexible and can be used for any shader that used the same type name or instance name when the instance was generated. <ul> <li> A created instance will work for any shader that contains a type of the same type name. For instance, a class instance created with the type name DefaultShader would work in any shader that contained a type DefaultShader even though several shaders could describe a different type. </li> <li> A gotten instance maps directly to an instance name/index in a shader. A class instance aquired using GetClassInstance will work for any shader that contains a class instance of the name used to generate the runtime instance, the instance does not have to be the same type in all of the shaders it's used in. </li> </ul> An instance does not replace the importance of reflection for a particular shader since a gotten instance will not know its slot location and a created instance only specifies a type name. Windows?Phone?8: This {{API}} is supported. This method does not return a value.

<dd> A reference to a {{D3D11_CLASS_INSTANCE_DESC}} structure that describes the current {{HLSL}} class. </dd>

Gets the instance name of the current {{HLSL}} class.

GetInstanceName will return a valid name only for instances acquired using {{ID3D11ClassLinkage::GetClassInstance}}. For more information about using the {{ID3D11ClassInstance}} interface, see Dynamic Linking. Windows?Phone?8: This {{API}} is supported. This method does not return a value.

<dd> The instance name of the current {{HLSL}} class. </dd>

<dd> The length of the pInstanceName parameter. </dd>

Gets the type of the current {{HLSL}} class.

GetTypeName will return a valid name only for instances acquired using {{ID3D11ClassLinkage::GetClassInstance}}. For more information about using the {{ID3D11ClassInstance}} interface, see Dynamic Linking. Windows?Phone?8: This {{API}} is supported. This method does not return a value.

<dd> Type of the current {{HLSL}} class. </dd>

<dd> The length of the pTypeName parameter. </dd>

This interface encapsulates an {{HLSL}} dynamic linkage.

A class linkage object can hold up to 64K gotten instances. A gotten instance is a handle that references a variable name in any shader that is created with that linkage object. When you create a shader with a class linkage object, the runtime gathers these instances and stores them in the class linkage object. For more information about how a class linkage object is used, see Storing Variables and Types for Shaders to Share.An {{ID3D11ClassLinkage}} object is created using the {{ID3D11Device::CreateClassLinkage}} method.

Gets the class-instance object that represents the specified {{HLSL}} class.

For more information about using the {{ID3D11ClassLinkage}} interface, see Dynamic Linking. A class instance must have at least 1 data member in order to be available for the runtime to use with {{ID3D11ClassLinkage::GetClassInstance}}. Any instance with no members will be optimized out of a compiled shader blob as a zero-sized object. If you have a class with no data members, use {{ID3D11ClassLinkage::CreateClassInstance}} instead. Windows?Phone?8: This {{API}} is supported. Returns {{S_OK}} if successful; otherwise, returns one of the Direct3D 11 Return Codes.

<dd> The name of a class for which to get the class instance. </dd>

<dd> The index of the class instance. </dd>

<dd> The address of a reference to an {{ID3D11ClassInstance}} interface to initialize. </dd>

Initializes a class-instance object that represents an {{HLSL}} class instance.

Instances can be created (or gotten) before or after a shader is created. Use the same shader linkage object to acquire a class instance and create the shader the instance is going to be used in. For more information about using the {{ID3D11ClassLinkage}} interface, see Dynamic Linking. Windows?Phone?8: This {{API}} is supported. Returns {{S_OK}} if successful; otherwise, returns one of the following Direct3D 11 Return Codes.

<dd> The type name of a class to initialize. </dd>

<dd> Identifies the constant buffer that contains the class data. </dd>

<dd> The four-component vector offset from the start of the constant buffer where the class data will begin. Consequently, this is not a byte offset. </dd>

<dd> The texture slot for the first texture; there may be multiple textures following the offset. </dd>

<dd> The sampler slot for the first sampler; there may be multiple samplers following the offset. </dd>

<dd> The address of a reference to an {{ID3D11ClassInstance}} interface to initialize. </dd>

The {{ID3D11CommandList}} interface encapsulates a list of graphics commands for play back.

There is no explicit creation method, simply declare an {{ID3D11CommandList}} interface, then call {{ID3D11DeviceContext::FinishCommandList}} to record commands or {{ID3D11DeviceContext::ExecuteCommandList}} to play back commands.

Gets the initialization flags associated with the deferred context that created the command list.

The GetContextFlags method gets the flags that were supplied to the ContextFlags parameter of {{ID3D11Device::CreateDeferredContext}}; however, the context flag is reserved for future use. The context flag is reserved for future use and is always 0.

The {{ID3D11DeviceContext}} interface represents a device context which generates rendering commands.

Sets the constant buffers used by the vertex shader pipeline stage.

The method will hold a reference to the interfaces passed in. This differs from the device state behavior in Direct3D 10. The Direct3D 11.1 runtime, which is available starting with Windows?8, can bind a larger number of {{ID3D11Buffer}} resources to the shader than the maximum constant buffer size that is supported by shaders (4096 constants ? 4*32-bit components each). When you bind such a large buffer, the shader can access only the first 4096 4*32-bit component constants in the buffer, as if 4096 constants is the full size of the buffer. If the application wants the shader to access other parts of the buffer, it must call the {{VSSetConstantBuffers1}} method instead. Windows?Phone?8: This {{API}} is supported. This method does not return a value.

<dd> Index into the device's zero-based array to begin setting constant buffers to (ranges from 0 to {{D3D11_COMMONSHADER_CONSTANT_BUFFER_API_SLOT_COUNT}} - 1). </dd>

<dd> Number of buffers to set (ranges from 0 to {{D3D11_COMMONSHADER_CONSTANT_BUFFER_API_SLOT_COUNT}} - StartSlot). </dd>

<dd> Array of constant buffers (see {{ID3D11Buffer}}) being given to the device. </dd>

Bind an array of shader resources to the pixel shader stage.

If an overlapping resource view is already bound to an output slot, such as a rendertarget, then this {{API}} will fill the destination shader resource slot with {{NULL}}.For information about creating shader-resource views, see {{ID3D11Device::CreateShaderResourceView}}. The method will hold a reference to the interfaces passed in. This differs from the device state behavior in Direct3D 10. Returns nothing.

<dd> Index into the device's zero-based array to begin setting shader resources to (ranges from 0 to {{D3D11_COMMONSHADER_INPUT_RESOURCE_SLOT_COUNT}} - 1). </dd>

<dd> Number of shader resources to set. Up to a maximum of 128 slots are available for shader resources (ranges from 0 to {{D3D11_COMMONSHADER_INPUT_RESOURCE_SLOT_COUNT}} - StartSlot). </dd>

<dd> Array of shader resource view interfaces to set to the device. </dd>

Sets a pixel shader to the device.

The method will hold a reference to the interfaces passed in. This differs from the device state behavior in Direct3D 10. The maximum number of instances a shader can have is 256. Set ppClassInstances to {{NULL}} if no interfaces are used in the shader. If it is not {{NULL}}, the number of class instances must match the number of interfaces used in the shader. Furthermore, each interface reference must have a corresponding class instance or the assigned shader will be disabled. Windows?Phone?8: This {{API}} is supported. This method does not return a value.

<dd> Pointer to a pixel shader (see {{ID3D11PixelShader}}). Passing in {{NULL}} disables the shader for this pipeline stage. </dd>

<dd> A reference to an array of class-instance interfaces (see {{ID3D11ClassInstance}}). Each interface used by a shader must have a corresponding class instance or the shader will get disabled. Set ppClassInstances to {{NULL}} if the shader does not use any interfaces. </dd>

<dd> The number of class-instance interfaces in the array. </dd>

Set an array of sampler states to the pixel shader pipeline stage.

Any sampler may be set to {{NULL}}; this invokes the default state, which is defined to be the following.<table> <tr><th>State</th><th>Default Value</th></tr> <tr><td>Filter</td><td>{{D3D11_FILTER_MIN_MAG_MIP_LINEAR}}</td></tr> <tr><td>AddressU</td><td>{{D3D11_TEXTURE_ADDRESS_CLAMP}}</td></tr> <tr><td>AddressV</td><td>{{D3D11_TEXTURE_ADDRESS_CLAMP}}</td></tr> <tr><td>AddressW</td><td>{{D3D11_TEXTURE_ADDRESS_CLAMP}}</td></tr> <tr><td>MipLODBias</td><td>0</td></tr> <tr><td>MaxAnisotropy</td><td>1</td></tr> <tr><td>ComparisonFunc</td><td>{{D3D11_COMPARISON_NEVER}}</td></tr> <tr><td>BorderColor[0]</td><td>1.0f</td></tr> <tr><td>BorderColor[1]</td><td>1.0f</td></tr> <tr><td>BorderColor[2]</td><td>1.0f</td></tr> <tr><td>BorderColor[3]</td><td>1.0f</td></tr> <tr><td>MinLOD</td><td>-{{FLT_MAX}}</td></tr> <tr><td>MaxLOD</td><td>{{FLT_MAX}}</td></tr> </table>? The method will hold a reference to the interfaces passed in. This differs from the device state behavior in Direct3D 10. This method does not return a value.

<dd> Index into the device's zero-based array to begin setting samplers to (ranges from 0 to {{D3D11_COMMONSHADER_SAMPLER_SLOT_COUNT}} - 1). </dd>

<dd> Number of samplers in the array. Each pipeline stage has a total of 16 sampler slots available (ranges from 0 to {{D3D11_COMMONSHADER_SAMPLER_SLOT_COUNT}} - StartSlot). </dd>

<dd> Pointer to an array of sampler-state interfaces (see {{ID3D11SamplerState}}). See Remarks. </dd>

Set a vertex shader to the device.

<dd> Pointer to a vertex shader (see {{ID3D11VertexShader}}). Passing in {{NULL}} disables the shader for this pipeline stage. </dd>

<dd> A reference to an array of class-instance interfaces (see {{ID3D11ClassInstance}}). Each interface used by a shader must have a corresponding class instance or the shader will get disabled. Set ppClassInstances to {{NULL}} if the shader does not use any interfaces. </dd>

<dd> The number of class-instance interfaces in the array. </dd>

Draw indexed, non-instanced primitives.

A draw {{API}} submits work to the rendering pipeline.If the sum of both indices is negative, the result of the function call is undefined. Returns nothing.

<dd> Number of indices to draw. </dd>

<dd> The location of the first index read by the {{GPU}} from the index buffer. </dd>

<dd> A value added to each index before reading a vertex from the vertex buffer. </dd>

Draw non-indexed, non-instanced primitives.

Draw submits work to the rendering pipeline.The vertex data for a draw call normally comes from a vertex buffer that is bound to the pipeline.Even without any vertex buffer bound to the pipeline, you can generate your own vertex data in your vertex shader by using the {{SV_VertexID}} system-value semantic to determine the current vertex that the runtime is processing. Returns nothing.

<dd> Number of vertices to draw. </dd>

<dd> Index of the first vertex, which is usually an offset in a vertex buffer. </dd>

Gets a reference to the data contained in a subresource, and denies the {{GPU}} access to that subresource.

If you call Map on a deferred context, you can only pass {{D3D11_MAP_WRITE_DISCARD}}, {{D3D11_MAP_WRITE_NO_OVERWRITE}}, or both to the MapType parameter. Other {{D3D11_MAP}}-typed values are not supported for a deferred context. Note?? The Direct3D 11.1 runtime, which is available starting with Windows?8, enables mapping dynamic constant buffers and shader resource views ({{SRVs}}) of dynamic buffers with {{D3D11_MAP_WRITE_NO_OVERWRITE}}. The Direct3D 11 and earlier runtimes limited mapping to vertex or index buffers. To determine if a Direct3D device supports these features, call {{ID3D11Device::CheckFeatureSupport}} with {{D3D11_FEATURE_D3D11_OPTIONS}}. CheckFeatureSupport fills members of a {{D3D11_FEATURE_DATA_D3D11_OPTIONS}} structure with the device's features. The relevant members here are MapNoOverwriteOnDynamicConstantBuffer and MapNoOverwriteOnDynamicBufferSRV.? For info about how to use Map, see How to: Use dynamic resources. This method returns one of the Direct3D 11 Return Codes. This method also returns {{DXGI_ERROR_WAS_STILL_DRAWING}} if MapFlags specifies {{D3D11_MAP_FLAG_DO_NOT_WAIT}} and the {{GPU}} is not yet finished with the resource. This method also returns {{DXGI_ERROR_DEVICE_REMOVED}} if MapType allows any {{CPU}} read access and the video card has been removed. For more information about these error codes, see {{DXGI_ERROR}}.

Invalidate the reference to a resource and reenable the {{GPU}}'s access to that resource.

For info about how to use Unmap, see How to: Use dynamic resources. Windows?Phone?8: This {{API}} is supported. Returns nothing.

<dd> A reference to a {{ID3D11Resource}} interface. </dd>

<dd> A subresource to be unmapped. </dd>

Sets the constant buffers used by the pixel shader pipeline stage.

The method will hold a reference to the interfaces passed in. This differs from the device state behavior in Direct3D 10. The Direct3D 11.1 runtime, which is available on Windows?8 and later operating systems, can bind a larger number of {{ID3D11Buffer}} resources to the shader than the maximum constant buffer size that is supported by shaders (4096 constants ? 4*32-bit components each). When you bind such a large buffer, the shader can access only the first 4096 4*32-bit component constants in the buffer, as if 4096 constants is the full size of the buffer. To enable the shader to access other parts of the buffer, call {{PSSetConstantBuffers1}} instead of {{PSSetConstantBuffers}}. {{PSSetConstantBuffers1}} has additional parameters pFirstConstant and pNumConstants. This method does not return a value.

<dd> Index into the device's zero-based array to begin setting constant buffers to (ranges from 0 to {{D3D11_COMMONSHADER_CONSTANT_BUFFER_API_SLOT_COUNT}} - 1). </dd>

<dd> Number of buffers to set (ranges from 0 to {{D3D11_COMMONSHADER_CONSTANT_BUFFER_API_SLOT_COUNT}} - StartSlot). </dd>

<dd> Array of constant buffers (see {{ID3D11Buffer}}) being given to the device. </dd>

Bind an input-layout object to the input-assembler stage.

Input-layout objects describe how vertex buffer data is streamed into the {{IA}} pipeline stage. To create an input-layout object, call {{ID3D11Device::CreateInputLayout}}. The method will hold a reference to the interfaces passed in. This differs from the device state behavior in Direct3D 10. Returns nothing.

<dd> A reference to the input-layout object (see {{ID3D11InputLayout}}), which describes the input buffers that will be read by the {{IA}} stage. </dd>

Bind an array of vertex buffers to the input-assembler stage.

For info about creating vertex buffers, see How to: Create a Vertex Buffer. Calling this method using a buffer that is currently bound for writing (that is, bound to the stream output pipeline stage) will effectively bind {{NULL}} instead because a buffer can't be bound as both an input and an output at the same time. The debug layer will generate a warning whenever a resource is prevented from being bound simultaneously as an input and an output, but this will not prevent invalid data from being used by the runtime. The method will hold a reference to the interfaces passed in. This differs from the device state behavior in Direct3D 10. Windows?Phone?8: This {{API}} is supported. This method does not return a value.

Bind an index buffer to the input-assembler stage.

For information about creating index buffers, see How to: Create an Index Buffer. Calling this method using a buffer that is currently bound for writing (i.e. bound to the stream output pipeline stage) will effectively bind {{NULL}} instead because a buffer cannot be bound as both an input and an output at the same time. The debug layer will generate a warning whenever a resource is prevented from being bound simultaneously as an input and an output, but this will not prevent invalid data from being used by the runtime. The method will hold a reference to the interfaces passed in. This differs from the device state behavior in Direct3D 10. Windows?Phone?8: This {{API}} is supported. Returns nothing.

<dd> A reference to an {{ID3D11Buffer}} object, that contains indices. The index buffer must have been created with the {{D3D11_BIND_INDEX_BUFFER}} flag. </dd>

<dd> A {{DXGI_FORMAT}} that specifies the format of the data in the index buffer. The only formats allowed for index buffer data are 16-bit ({{DXGI_FORMAT_R16_UINT}}) and 32-bit ({{DXGI_FORMAT_R32_UINT}}) integers. </dd>

<dd> Offset (in bytes) from the start of the index buffer to the first index to use. </dd>

Draw indexed, instanced primitives.

A draw {{API}} submits work to the rendering pipeline.Instancing may extend performance by reusing the same geometry to draw multiple objects in a scene. One example of instancing could be to draw the same object with different positions and colors. Instancing requires multiple vertex buffers: at least one for per-vertex data and a second buffer for per-instance data. Returns nothing.

<dd> Number of indices read from the index buffer for each instance. </dd>

<dd> Number of instances to draw. </dd>

<dd> The location of the first index read by the {{GPU}} from the index buffer. </dd>

<dd> A value added to each index before reading a vertex from the vertex buffer. </dd>

<dd> A value added to each index before reading per-instance data from a vertex buffer. </dd>

Draw non-indexed, instanced primitives.

A draw {{API}} submits work to the rendering pipeline.Instancing may extend performance by reusing the same geometry to draw multiple objects in a scene. One example of instancing could be to draw the same object with different positions and colors.The vertex data for an instanced draw call normally comes from a vertex buffer that is bound to the pipeline. However, you could also provide the vertex data from a shader that has instanced data identified with a system-value semantic ({{SV_InstanceID}}). Returns nothing.

<dd> Number of vertices to draw. </dd>

<dd> Number of instances to draw. </dd>

<dd> Index of the first vertex. </dd>

<dd> A value added to each index before reading per-instance data from a vertex buffer. </dd>

Sets the constant buffers used by the geometry shader pipeline stage.

The method will hold a reference to the interfaces passed in. This differs from the device state behavior in Direct3D 10. You can't use the {{ID3D11ShaderReflectionConstantBuffer}} interface to get information about what is currently bound to the pipeline in the device context. But you can use {{ID3D11ShaderReflectionConstantBuffer}} to get information from a compiled shader. For example, you can use {{ID3D11ShaderReflectionConstantBuffer}} and {{ID3D11ShaderReflectionVariable}} to determine the slot in which a geometry shader expects a constant buffer. You can then pass this slot number to {{GSSetConstantBuffers}} to set the constant buffer. You can call the {{D3D11Reflect}} function to retrieve the address of a reference to the {{ID3D11ShaderReflection}} interface and then call {{ID3D11ShaderReflection::GetConstantBufferByName}} to get a reference to {{ID3D11ShaderReflectionConstantBuffer}}.The Direct3D 11.1 runtime, which is available starting with Windows?8, can bind a larger number of {{ID3D11Buffer}} resources to the shader than the maximum constant buffer size that is supported by shaders (4096 constants ? 4*32-bit components each). When you bind such a large buffer, the shader can access only the first 4096 4*32-bit component constants in the buffer, as if 4096 constants is the full size of the buffer. If the application wants the shader to access other parts of the buffer, it must call the {{GSSetConstantBuffers1}} method instead. This method does not return a value.

<dd> Index into the device's zero-based array to begin setting constant buffers to (ranges from 0 to {{D3D11_COMMONSHADER_CONSTANT_BUFFER_API_SLOT_COUNT}} - 1). </dd>

<dd> Number of buffers to set (ranges from 0 to {{D3D11_COMMONSHADER_CONSTANT_BUFFER_API_SLOT_COUNT}} - StartSlot). </dd>

<dd> Array of constant buffers (see {{ID3D11Buffer}}) being given to the device. </dd>

Set a geometry shader to the device.

<dd> Pointer to a geometry shader (see {{ID3D11GeometryShader}}). Passing in {{NULL}} disables the shader for this pipeline stage. </dd>

<dd> A reference to an array of class-instance interfaces (see {{ID3D11ClassInstance}}). Each interface used by a shader must have a corresponding class instance or the shader will get disabled. Set ppClassInstances to {{NULL}} if the shader does not use any interfaces. </dd>

<dd> The number of class-instance interfaces in the array. </dd>

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

Windows?Phone?8: This {{API}} is supported. This method does not return a value.

<dd> The type of primitive and ordering of the primitive data (see {{D3D11_PRIMITIVE_TOPOLOGY}}). </dd>

Bind an array of shader resources to the vertex-shader stage.

<dd> Index into the device's zero-based array to begin setting shader resources to (range is from 0 to {{D3D11_COMMONSHADER_INPUT_RESOURCE_SLOT_COUNT}} - 1). </dd>

<dd> Number of shader resources to set. Up to a maximum of 128 slots are available for shader resources (range is from 0 to {{D3D11_COMMONSHADER_INPUT_RESOURCE_SLOT_COUNT}} - StartSlot). </dd>

<dd> Array of shader resource view interfaces to set to the device. </dd>

Set an array of sampler states to the vertex shader pipeline stage.

Any sampler may be set to {{NULL}}; this invokes the default state, which is defined to be the following.<pre> //Default sampler state: {{D3D11_SAMPLER_DESC}} SamplerDesc; SamplerDesc.Filter = {{D3D11_FILTER_MIN_MAG_MIP_LINEAR}}; SamplerDesc.AddressU = {{D3D11_TEXTURE_ADDRESS_CLAMP}}; SamplerDesc.AddressV = {{D3D11_TEXTURE_ADDRESS_CLAMP}}; SamplerDesc.AddressW = {{D3D11_TEXTURE_ADDRESS_CLAMP}}; SamplerDesc.MipLODBias = 0; SamplerDesc.MaxAnisotropy = 1; SamplerDesc.ComparisonFunc = {{D3D11_COMPARISON_NEVER}}; SamplerDesc.BorderColor[0] = 1.0f; SamplerDesc.BorderColor[1] = 1.0f; SamplerDesc.BorderColor[2] = 1.0f; SamplerDesc.BorderColor[3] = 1.0f; SamplerDesc.MinLOD = -{{FLT_MAX}}; SamplerDesc.MaxLOD = {{FLT_MAX}}; </pre> The method will hold a reference to the interfaces passed in. This differs from the device state behavior in Direct3D 10. This method does not return a value.

<dd> Index into the device's zero-based array to begin setting samplers to (ranges from 0 to {{D3D11_COMMONSHADER_SAMPLER_SLOT_COUNT}} - 1). </dd>

<dd> Number of samplers in the array. Each pipeline stage has a total of 16 sampler slots available (ranges from 0 to {{D3D11_COMMONSHADER_SAMPLER_SLOT_COUNT}} - StartSlot). </dd>

<dd> Pointer to an array of sampler-state interfaces (see {{ID3D11SamplerState}}). See Remarks. </dd>

Mark the beginning of a series of commands.

Use {{ID3D11DeviceContext::End}} to mark the ending of the series of commands. Returns nothing.

<dd> A reference to an {{ID3D11Asynchronous}} interface. </dd>

Mark the end of a series of commands.

Use {{ID3D11DeviceContext::Begin}} to mark the beginning of the series of commands. Returns nothing.

<dd> A reference to an {{ID3D11Asynchronous}} interface. </dd>

Get data from the graphics processing unit ({{GPU}}) asynchronously.

Queries in a deferred context are limited to predicated drawing. That is, you cannot call {{ID3D11DeviceContext::GetData}} on a deferred context to get data about a query; you can only call GetData on the immediate context to get data about a query. For predicated drawing, the results of a predication-type query are used by the {{GPU}} and not returned to an application. For more information about predication and predicated drawing, see {{D3D11DeviceContext::SetPredication}}.GetData retrieves the data that the runtime collected between calls to {{ID3D11DeviceContext::Begin}} and {{ID3D11DeviceContext::End}}. Certain queries only require a call to {{ID3D11DeviceContext::End}} in which case the data returned by GetData is accurate up to the last call to {{ID3D11DeviceContext::End}}. For information about the queries that only require a call to {{ID3D11DeviceContext::End}} and about the type of data that GetData retrieves for each query, see {{D3D11_QUERY}}.If DataSize is 0, GetData is only used to check status.An application gathers counter data by calling {{ID3D11DeviceContext::Begin}}, issuing some graphics commands, calling {{ID3D11DeviceContext::End}}, and then calling {{ID3D11DeviceContext::GetData}} to get data about what happened in between the Begin and End calls. For information about performance counter types, see {{D3D11_COUNTER}}. This method returns one of the Direct3D 11 Return Codes. A return value of {{S_OK}} indicates that the data at pData is available for the calling application to access. A return value of {{S_FALSE}} indicates that the data is not yet available. If the data is not yet available, the application must call GetData until the data is available.

<dd> A reference to an {{ID3D11Asynchronous}} interface for the object about which GetData retrieves data. </dd>

<dd> Address of memory that will receive the data. If {{NULL}}, GetData will be used only to check status. The type of data output depends on the type of asynchronous interface. </dd>

<dd> Size of the data to retrieve or 0. Must be 0 when pData is {{NULL}}. </dd>

<dd> Optional flags. Can be 0 or any combination of the flags enumerated by {{D3D11_ASYNC_GETDATA_FLAG}}. </dd>

Set a rendering predicate.

The predicate must be in the "issued" or "signaled" state to be used for predication. While the predicate is set for predication, calls to {{ID3D11DeviceContext::Begin}} and {{ID3D11DeviceContext::End}} are invalid.Use this method to denote that subsequent rendering and resource manipulation commands are not actually performed if the resulting predicate data of the predicate is equal to the PredicateValue. However, some predicates are only hints, so they may not actually prevent operations from being performed. The primary usefulness of predication is to allow an application to issue rendering and resource manipulation commands without taking the performance hit of spinning, waiting for {{ID3D11DeviceContext::GetData}} to return. So, predication can occur while {{ID3D11DeviceContext::GetData}} returns {{S_FALSE}}. Another way to think of it: an application can also use predication as a fallback, if it is possible that {{ID3D11DeviceContext::GetData}} returns {{S_FALSE}}. If {{ID3D11DeviceContext::GetData}} returns {{S_OK}}, the application can skip calling the rendering and resource manipulation commands manually with it's own application logic.Rendering and resource manipulation commands for Direct3D?11 include these Draw, Dispatch, Copy, Update, Clear, Generate, and Resolve operations.<ul> <li> Draw </li> <li> DrawAuto </li> <li> DrawIndexed </li> <li> DrawIndexedInstanced </li> <li> DrawIndexedInstancedIndirect </li> <li> DrawInstanced </li> <li> DrawInstancedIndirect </li> <li> Dispatch </li> <li> DispatchIndirect </li> <li> CopyResource </li> <li> CopyStructureCount </li> <li> CopySubresourceRegion </li> <li> CopySubresourceRegion1 </li> <li> CopyTiles </li> <li> CopyTileMappings </li> <li> UpdateSubresource </li> <li> UpdateSubresource1 </li> <li> UpdateTiles </li> <li> UpdateTileMappings </li> <li> ClearRenderTargetView </li> <li> ClearUnorderedAccessViewFloat </li> <li> ClearUnorderedAccessViewUint </li> <li> ClearView </li> <li> ClearDepthStencilView </li> <li> GenerateMips </li> <li> ResolveSubresource </li> </ul>You can set a rendering predicate on an immediate or a deferred context. For info about immediate and deferred contexts, see Immediate and Deferred Rendering. Returns nothing.

<dd> A reference to the {{ID3D11Predicate}} interface that represents the rendering predicate. A {{NULL}} value indicates "no" predication; in this case, the value of PredicateValue is irrelevant but will be preserved for {{ID3D11DeviceContext::GetPredication}}. </dd>

<dd> If {{TRUE}}, rendering will be affected by when the predicate's conditions are met. If {{FALSE}}, rendering will be affected when the conditions are not met. </dd>

Bind an array of shader resources to the geometry shader stage.

If an overlapping resource view is already bound to an output slot, such as a render target, then the method will fill the destination shader resource slot with {{NULL}}.For information about creating shader-resource views, see {{ID3D11Device::CreateShaderResourceView}}. The method will hold a reference to the interfaces passed in. This differs from the device state behavior in Direct3D 10. This method does not return a value.

<dd> Index into the device's zero-based array to begin setting shader resources to (ranges from 0 to {{D3D11_COMMONSHADER_INPUT_RESOURCE_SLOT_COUNT}} - 1). </dd>

<dd> Number of shader resources to set. Up to a maximum of 128 slots are available for shader resources(ranges from 0 to {{D3D11_COMMONSHADER_INPUT_RESOURCE_SLOT_COUNT}} - StartSlot). </dd>

<dd> Array of shader resource view interfaces to set to the device. </dd>

Set an array of sampler states to the geometry shader pipeline stage.

<dd> Index into the device's zero-based array to begin setting samplers to (ranges from 0 to {{D3D11_COMMONSHADER_SAMPLER_SLOT_COUNT}} - 1). </dd>

<dd> Number of samplers in the array. Each pipeline stage has a total of 16 sampler slots available (ranges from 0 to {{D3D11_COMMONSHADER_SAMPLER_SLOT_COUNT}} - StartSlot). </dd>

<dd> Pointer to an array of sampler-state interfaces (see {{ID3D11SamplerState}}). See Remarks. </dd>

Bind one or more render targets atomically and the depth-stencil buffer to the output-merger stage.

The maximum number of active render targets a device can have active at any given time is set by a #define in {{D3D11}}.h called {{D3D11_SIMULTANEOUS_RENDER_TARGET_COUNT}}. It is invalid to try to set the same subresource to multiple render target slots. Any render targets not defined by this call are set to {{NULL}}.If any subresources are also currently bound for reading in a different stage or writing (perhaps in a different part of the pipeline), those bind points will be set to {{NULL}}, in order to prevent the same subresource from being read and written simultaneously in a single rendering operation. The method will hold a reference to the interfaces passed in. This differs from the device state behavior in Direct3D 10. If the render-target views were created from an array resource type, all of the render-target views must have the same array size. This restriction also applies to the depth-stencil view, its array size must match that of the render-target views being bound.The pixel shader must be able to simultaneously render to at least eight separate render targets. All of these render targets must access the same type of resource: Buffer, Texture1D, Texture1DArray, Texture2D, Texture2DArray, Texture3D, or TextureCube. All render targets must have the same size in all dimensions (width and height, and depth for 3D or array size for *Array types). If render targets use multisample anti-aliasing, all bound render targets and depth buffer must be the same form of multisample resource (that is, the sample counts must be the same). Each render target can have a different data format. These render target formats are not required to have identical bit-per-element counts.Any combination of the eight slots for render targets can have a render target set or not set.The same resource view cannot be bound to multiple render target slots simultaneously. However, you can set multiple non-overlapping resource views of a single resource as simultaneous multiple render targets. Returns nothing.

Binds resources to the output-merger stage.

For pixel shaders, the render targets and unordered-access views share the same resource slots when being written out. This means that {{UAVs}} must be given an offset so that they are placed in the slots after the render target views that are being bound. Note??{{RTVs}}, {{DSV}}, and {{UAVs}} cannot be set independently; they all need to be set at the same time.?Two {{RTVs}} conflict if they share a subresource (and therefore share the same resource).Two {{UAVs}} conflict if they share a subresource (and therefore share the same resource).An {{RTV}} conflicts with a {{UAV}} if they share a subresource or share a bind point.{{OMSetRenderTargetsAndUnorderedAccessViews}} operates properly in the following situations: <ol> <li> NumRTVs != {{D3D11_KEEP_RENDER_TARGETS_AND_DEPTH_STENCIL}} and NumUAVs != {{D3D11_KEEP_UNORDERED_ACCESS_VIEWS}} The following conditions must be true for {{OMSetRenderTargetsAndUnorderedAccessViews}} to succeed and for the runtime to pass the bind information to the driver: <ul> <li>NumRTVs <= 8 </li> <li>{{UAVStartSlot}} >= NumRTVs</li> <li>{{UAVStartSlot}} + NumUAVs <= 8 </li> <li> There must be no conflicts in the set of all ppRenderTargetViews and ppUnorderedAccessViews. </li> <li>ppDepthStencilView must match the render-target views. For more information about resource views, see Introduction to a Resource in Direct3D 11. </li> </ul> {{OMSetRenderTargetsAndUnorderedAccessViews}} performs the following tasks: <ul> <li>Unbinds all currently bound conflicting resources (stream-output target resources ({{SOTargets}}), compute shader ({{CS}}) {{UAVs}}, shader-resource views ({{SRVs}})).</li> <li> Binds ppRenderTargetViews, ppDepthStencilView, and ppUnorderedAccessViews. </li> </ul> </li> <li> NumRTVs == {{D3D11_KEEP_RENDER_TARGETS_AND_DEPTH_STENCIL}} In this situation, {{OMSetRenderTargetsAndUnorderedAccessViews}} binds only {{UAVs}}. The following conditions must be true for {{OMSetRenderTargetsAndUnorderedAccessViews}} to succeed and for the runtime to pass the bind information to the driver: <ul> <li>{{UAVStartSlot}} + NumUAVs <= 8 </li> <li> There must be no conflicts in ppUnorderedAccessViews. </li> </ul> {{OMSetRenderTargetsAndUnorderedAccessViews}} unbinds the following items: <ul> <li> All {{RTVs}} in slots >= {{UAVStartSlot}}</li> <li> All {{RTVs}} that conflict with any {{UAVs}} in ppUnorderedAccessViews</li> <li> All currently bound resources ({{SOTargets}}, {{CS}} {{UAVs}}, {{SRVs}}) that conflict with ppUnorderedAccessViews</li> </ul> {{OMSetRenderTargetsAndUnorderedAccessViews}} binds ppUnorderedAccessViews. {{OMSetRenderTargetsAndUnorderedAccessViews}} ignores ppDepthStencilView, and the current depth-stencil view remains bound. </li> <li> NumUAVs == {{D3D11_KEEP_UNORDERED_ACCESS_VIEWS}} In this situation, {{OMSetRenderTargetsAndUnorderedAccessViews}} binds only {{RTVs}} and {{DSV}}. The following conditions must be true for {{OMSetRenderTargetsAndUnorderedAccessViews}} to succeed and for the runtime to pass the bind information to the driver: <ul> <li>NumRTVs <= 8 </li> <li> There must be no conflicts in ppRenderTargetViews. </li> <li>ppDepthStencilView must match the render-target views. For more information about resource views, see Introduction to a Resource in Direct3D 11. </li> </ul> {{OMSetRenderTargetsAndUnorderedAccessViews}} unbinds the following items: <ul> <li> All {{UAVs}} in slots < NumRTVs</li> <li> All {{UAVs}} that conflict with any {{RTVs}} in ppRenderTargetViews</li> <li> All currently bound resources ({{SOTargets}}, {{CS}} {{UAVs}}, {{SRVs}}) that conflict with ppRenderTargetViews</li> </ul> {{OMSetRenderTargetsAndUnorderedAccessViews}} binds ppRenderTargetViews and ppDepthStencilView. {{OMSetRenderTargetsAndUnorderedAccessViews}} ignores {{UAVStartSlot}}. </li> </ol>Windows?Phone?8: This {{API}} is supported. This method does not return a value.

<dd> Number of render targets to bind (ranges between 0 and {{D3D11_SIMULTANEOUS_RENDER_TARGET_COUNT}}). If this parameter is nonzero, the number of entries in the array to which ppRenderTargetViews points must equal the number in this parameter. If you set NumRTVs to {{D3D11_KEEP_RENDER_TARGETS_AND_DEPTH_STENCIL}} (0xffffffff), this method does not modify the currently bound render-target views ({{RTVs}}) and also does not modify depth-stencil view ({{DSV}}). </dd>

<dd> Pointer to an array of {{ID3D11RenderTargetView}}s that represent the render targets to bind to the device. If this parameter is {{NULL}} and NumRTVs is 0, no render targets are bound. </dd>

<dd> Pointer to a {{ID3D11DepthStencilView}} that represents the depth-stencil view to bind to the device. If this parameter is {{NULL}}, the depth-stencil state is not bound. </dd>

<dd> Index into a zero-based array to begin setting unordered-access views (ranges from 0 to {{D3D11_PS_CS_UAV_REGISTER_COUNT}} - 1). For the Direct3D 11.1 runtime, which is available starting with Windows?8, this value can range from 0 to {{D3D11_1_UAV_SLOT_COUNT}} - 1. {{D3D11_1_UAV_SLOT_COUNT}} is defined as 64. For pixel shaders, {{UAVStartSlot}} should be equal to the number of render-target views being bound. </dd>

<dd> Number of unordered-access views ({{UAVs}}) in ppUnorderedAccessViews. If you set NumUAVs to {{D3D11_KEEP_UNORDERED_ACCESS_VIEWS}} (0xffffffff), this method does not modify the currently bound unordered-access views. For the Direct3D 11.1 runtime, which is available starting with Windows?8, this value can range from 0 to {{D3D11_1_UAV_SLOT_COUNT}} - {{UAVStartSlot}}. </dd>

<dd> Pointer to an array of {{ID3D11UnorderedAccessView}}s that represent the unordered-access views to bind to the device. If this parameter is {{NULL}} and NumUAVs is 0, no unordered-access views are bound. </dd>

<dd> An array of append and consume buffer offsets. A value of -1 indicates to keep the current offset. Any other values set the hidden counter for that appendable and consumable {{UAV}}. pUAVInitialCounts is relevant only for {{UAVs}} that were created with either {{D3D11_BUFFER_UAV_FLAG_APPEND}} or {{D3D11_BUFFER_UAV_FLAG_COUNTER}} specified when the {{UAV}} was created; otherwise, the argument is ignored. </dd>

Set the blend state of the output-merger stage.

Blend state is used by the output-merger stage to determine how to blend together two {{RGB}} pixel values and two alpha values. The two {{RGB}} pixel values and two alpha values are the {{RGB}} pixel value and alpha value that the pixel shader outputs and the {{RGB}} pixel value and alpha value already in the output render target. The blend option controls the data source that the blending stage uses to modulate values for the pixel shader, render target, or both. The blend operation controls how the blending stage mathematically combines these modulated values.To create a blend-state interface, call {{ID3D11Device::CreateBlendState}}.Passing in {{NULL}} for the blend-state interface indicates to the runtime to set a default blending state. The following table indicates the default blending parameters.<table> <tr><th>State</th><th>Default Value</th></tr> <tr><td>AlphaToCoverageEnable</td><td>{{FALSE}}</td></tr> <tr><td>IndependentBlendEnable</td><td>{{FALSE}}</td></tr> <tr><td>RenderTarget[0].BlendEnable</td><td>{{FALSE}}</td></tr> <tr><td>RenderTarget[0].SrcBlend</td><td>{{D3D11_BLEND_ONE}}</td></tr> <tr><td>RenderTarget[0].DestBlend</td><td>{{D3D11_BLEND_ZERO}}</td></tr> <tr><td>RenderTarget[0].BlendOp</td><td>{{D3D11_BLEND_OP_ADD}}</td></tr> <tr><td>RenderTarget[0].SrcBlendAlpha</td><td>{{D3D11_BLEND_ONE}}</td></tr> <tr><td>RenderTarget[0].DestBlendAlpha</td><td>{{D3D11_BLEND_ZERO}}</td></tr> <tr><td>RenderTarget[0].BlendOpAlpha</td><td>{{D3D11_BLEND_OP_ADD}}</td></tr> <tr><td>RenderTarget[0].RenderTargetWriteMask</td><td>{{D3D11_COLOR_WRITE_ENABLE_ALL}}</td></tr> </table>?A sample mask determines which samples get updated in all the active render targets. The mapping of bits in a sample mask to samples in a multisample render target is the responsibility of an individual application. A sample mask is always applied; it is independent of whether multisampling is enabled, and does not depend on whether an application uses multisample render targets. The method will hold a reference to the interfaces passed in. This differs from the device state behavior in Direct3D 10. Returns nothing.

<dd> Pointer to a blend-state interface (see {{ID3D11BlendState}}). Pass {{NULL}} for a default blend state. For more info about default blend state, see Remarks. </dd>

<dd> Array of blend factors, one for each {{RGBA}} component. The blend factors modulate values for the pixel shader, render target, or both. If you created the blend-state object with {{D3D11_BLEND_BLEND_FACTOR}} or {{D3D11_BLEND_INV_BLEND_FACTOR}}, the blending stage uses the non-{{NULL}} array of blend factors. If you didn't create the blend-state object with {{D3D11_BLEND_BLEND_FACTOR}} or {{D3D11_BLEND_INV_BLEND_FACTOR}}, the blending stage does not use the non-{{NULL}} array of blend factors; the runtime stores the blend factors, and you can later call {{ID3D11DeviceContext::OMGetBlendState}} to retrieve the blend factors. If you pass {{NULL}}, the runtime uses or stores a blend factor equal to { 1, 1, 1, 1 }. </dd>

<dd> 32-bit sample coverage. The default value is 0xffffffff. See remarks. </dd>

Sets the depth-stencil state of the output-merger stage.

To create a depth-stencil state interface, call {{ID3D11Device::CreateDepthStencilState}}. The method will hold a reference to the interfaces passed in. This differs from the device state behavior in Direct3D 10. Returns nothing.

<dd> Pointer to a depth-stencil state interface (see {{ID3D11DepthStencilState}}) to bind to the device. Set this to {{NULL}} to use the default state listed in {{D3D11_DEPTH_STENCIL_DESC}}. </dd>

<dd> Reference value to perform against when doing a depth-stencil test. See remarks. </dd>

Set the target output buffers for the stream-output stage of the pipeline.

An offset of -1 will cause the stream output buffer to be appended, continuing after the last location written to the buffer in a previous stream output pass. Calling this method using a buffer that is currently bound for writing will effectively bind {{NULL}} instead because a buffer cannot be bound as both an input and an output at the same time. The debug layer will generate a warning whenever a resource is prevented from being bound simultaneously as an input and an output, but this will not prevent invalid data from being used by the runtime. The method will hold a reference to the interfaces passed in. This differs from the device state behavior in Direct3D 10. Windows?Phone?8: This {{API}} is supported. This method does not return a value.

<dd> The number of buffer to bind to the device. A maximum of four output buffers can be set. If less than four are defined by the call, the remaining buffer slots are set to {{NULL}}. See Remarks. </dd>

<dd> The array of output buffers (see {{ID3D11Buffer}}) to bind to the device. The buffers must have been created with the {{D3D11_BIND_STREAM_OUTPUT}} flag. </dd>

<dd> Array of offsets to the output buffers from ppSOTargets, one offset for each buffer. The offset values must be in bytes. </dd>

Draw geometry of an unknown size.

A draw {{API}} submits work to the rendering pipeline. This {{API}} submits work of an unknown size that was processed by the input assembler, vertex shader, and stream-output stages; the work may or may not have gone through the geometry-shader stage.After data has been streamed out to stream-output stage buffers, those buffers can be again bound to the Input Assembler stage at input slot 0 and DrawAuto will draw them without the application needing to know the amount of data that was written to the buffers. A measurement of the amount of data written to the {{SO}} stage buffers is maintained internally when the data is streamed out. This means that the {{CPU}} does not need to fetch the measurement before re-binding the data that was streamed as input data. Although this amount is tracked internally, it is still the responsibility of applications to use input layouts to describe the format of the data in the {{SO}} stage buffers so that the layouts are available when the buffers are again bound to the input assembler.The following diagram shows the DrawAuto process.Calling DrawAuto does not change the state of the streaming-output buffers that were bound again as inputs.DrawAuto only works when drawing with one input buffer bound as an input to the {{IA}} stage at slot 0. Applications must create the {{SO}} buffer resource with both binding flags, {{D3D11_BIND_VERTEX_BUFFER}} and {{D3D11_BIND_STREAM_OUTPUT}}.This {{API}} does not support indexing or instancing.If an application needs to retrieve the size of the streaming-output buffer, it can query for statistics on streaming output by using {{D3D11_QUERY_SO_STATISTICS}}. Returns nothing.

Draw indexed, instanced, {{GPU}}-generated primitives.

When an application creates a buffer that is associated with the {{ID3D11Buffer}} interface that pBufferForArgs points to, the application must set the {{D3D11_RESOURCE_MISC_DRAWINDIRECT_ARGS}} flag in the MiscFlags member of the {{D3D11_BUFFER_DESC}} structure that describes the buffer. To create the buffer, the application calls the {{ID3D11Device::CreateBuffer}} method and in this call passes a reference to {{D3D11_BUFFER_DESC}} in the pDesc parameter. Windows?Phone?8: This {{API}} is supported. Returns nothing.

<dd> A reference to an {{ID3D11Buffer}}, which is a buffer containing the {{GPU}} generated primitives. </dd>

<dd> Offset in pBufferForArgs to the start of the {{GPU}} generated primitives. </dd>

Draw instanced, {{GPU}}-generated primitives.

When an application creates a buffer that is associated with the {{ID3D11Buffer}} interface that pBufferForArgs points to, the application must set the {{D3D11_RESOURCE_MISC_DRAWINDIRECT_ARGS}} flag in the MiscFlags member of the {{D3D11_BUFFER_DESC}} structure that describes the buffer. To create the buffer, the application calls the {{ID3D11Device::CreateBuffer}} method and in this call passes a reference to {{D3D11_BUFFER_DESC}} in the pDesc parameter. Returns nothing.

<dd> A reference to an {{ID3D11Buffer}}, which is a buffer containing the {{GPU}} generated primitives. </dd>

<dd> Offset in pBufferForArgs to the start of the {{GPU}} generated primitives. </dd>

Execute a command list from a thread group.

You call the Dispatch method to execute commands in a compute shader. A compute shader can be run on many threads in parallel, within a thread group. Index a particular thread, within a thread group using a 3D vector given by (x,y,z).In the following illustration, assume a thread group with 50 threads where the size of the group is given by (5,5,2). A single thread is identified from a thread group with 50 threads in it, using the vector (4,1,1).The following illustration shows the relationship between the parameters passed to {{ID3D11DeviceContext::Dispatch}}, Dispatch(5,3,2), the values specified in the numthreads attribute, numthreads(10,8,3), and values that will passed to the compute shader for the thread-related system values ({{SV_GroupIndex}},{{SV_DispatchThreadID}},{{SV_GroupThreadID}},{{SV_GroupID}}). Returns nothing.

<dd> The number of groups dispatched in the x direction. ThreadGroupCountX must be less than or equal to {{D3D11_CS_DISPATCH_MAX_THREAD_GROUPS_PER_DIMENSION}} (65535). </dd>

<dd> The number of groups dispatched in the y direction. ThreadGroupCountY must be less than or equal to {{D3D11_CS_DISPATCH_MAX_THREAD_GROUPS_PER_DIMENSION}} (65535). </dd>

<dd> The number of groups dispatched in the z direction. ThreadGroupCountZ must be less than or equal to {{D3D11_CS_DISPATCH_MAX_THREAD_GROUPS_PER_DIMENSION}} (65535). In feature level 10 the value for ThreadGroupCountZ must be 1. </dd>

Execute a command list over one or more thread groups.

You call the DispatchIndirect method to execute commands in a compute shader.When an application creates a buffer that is associated with the {{ID3D11Buffer}} interface that pBufferForArgs points to, the application must set the {{D3D11_RESOURCE_MISC_DRAWINDIRECT_ARGS}} flag in the MiscFlags member of the {{D3D11_BUFFER_DESC}} structure that describes the buffer. To create the buffer, the application calls the {{ID3D11Device::CreateBuffer}} method and in this call passes a reference to {{D3D11_BUFFER_DESC}} in the pDesc parameter. Returns nothing.

<dd> A reference to an {{ID3D11Buffer}}, which must be loaded with data that matches the argument list for {{ID3D11DeviceContext::Dispatch}}. </dd>

<dd> A byte-aligned offset between the start of the buffer and the arguments. </dd>

Set the rasterizer state for the rasterizer stage of the pipeline.

To create a rasterizer state interface, call {{ID3D11Device::CreateRasterizerState}}. The method will hold a reference to the interfaces passed in. This differs from the device state behavior in Direct3D 10. Returns nothing.

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

All viewports must be set atomically as one operation. Any viewports not defined by the call are disabled.Which viewport to use is determined by the {{SV_ViewportArrayIndex}} semantic output by a geometry shader; if a geometry shader does not specify the semantic, Direct3D will use the first viewport in the array.Note??Even though you specify float values to the members of the {{D3D11_VIEWPORT}} structure for the pViewports array in a call to {{ID3D11DeviceContext::RSSetViewports}} for feature levels 9_x, {{RSSetViewports}} uses {{DWORDs}} internally. Because of this behavior, when you use a negative top left corner for the viewport, the call to {{RSSetViewports}} for feature levels 9_x fails. This failure occurs because {{RSSetViewports}} for 9_x casts the floating point values into unsigned integers without validation, which results in integer overflow.? Returns nothing.

<dd> Number of viewports to bind. </dd>

<dd> An array of {{D3D11_VIEWPORT}} structures to bind to the device. See the structure page for details about how the viewport size is dependent on the device feature level which has changed between Direct3D 11 and Direct3D 10. </dd>

Bind an array of scissor rectangles to the rasterizer stage.

All scissor rects must be set atomically as one operation. Any scissor rects not defined by the call are disabled. The scissor rectangles will only be used if ScissorEnable is set to true in the rasterizer state (see {{D3D11_RASTERIZER_DESC}}). Which scissor rectangle to use is determined by the {{SV_ViewportArrayIndex}} semantic output by a geometry shader (see shader semantic syntax). If a geometry shader does not make use of the {{SV_ViewportArrayIndex}} semantic then Direct3D will use the first scissor rectangle in the array. Each scissor rectangle in the array corresponds to a viewport in an array of viewports (see {{ID3D11DeviceContext::RSSetViewports}}). Windows?Phone?8: This {{API}} is supported. Returns nothing.

<dd> Number of scissor rectangles to bind. </dd>

<dd> An array of scissor rectangles (see {{D3D11_RECT}}). </dd>

Copy a region from a source resource to a destination resource.

The source box must be within the size of the source resource. The destination offsets, (x, y, and z), allow the source box to be offset when writing into the destination resource; however, the dimensions of the source box and the offsets must be within the size of the resource. If you try and copy outside the destination resource or specify a source box that is larger than the source resource, the behavior of CopySubresourceRegion is undefined. If you created a device that supports the debug layer, the debug output reports an error on this invalid CopySubresourceRegion call. Invalid parameters to CopySubresourceRegion cause undefined behavior and might result in incorrect rendering, clipping, no copy, or even the removal of the rendering device.If the resources are buffers, all coordinates are in bytes; if the resources are textures, all coordinates are in texels. {{D3D11CalcSubresource}} is a helper function for calculating subresource indexes.CopySubresourceRegion performs the copy on the {{GPU}} (similar to a memcpy by the {{CPU}}). As a consequence, the source and destination resources:<ul> <li>Must be different subresources (although they can be from the same resource).</li> <li>Must be the same type.</li> <li>Must have compatible {{DXGI}} formats (identical or from the same type group). For example, a {{DXGI_FORMAT_R32G32B32_FLOAT}} texture can be copied to an {{DXGI_FORMAT_R32G32B32_UINT}} texture since both of these formats are in the {{DXGI_FORMAT_R32G32B32_TYPELESS}} group. CopySubresourceRegion can copy between a few format types. For more info, see Format Conversion using Direct3D 10.1.</li> <li>May not be currently mapped.</li> </ul>CopySubresourceRegion only supports copy; it does not support any stretch, color key, or blend. CopySubresourceRegion can reinterpret the resource data between a few format types. For more info, see Format Conversion using Direct3D 10.1. If your app needs to copy an entire resource, we recommend to use {{ID3D11DeviceContext::CopyResource}} instead. CopySubresourceRegion is an asynchronous call, which may be added to the command-buffer queue, this attempts to remove pipeline stalls that may occur when copying data. For more information about pipeline stalls, see performance considerations.Note??Applies only to feature level 9_x hardware If you use {{ID3D11DeviceContext::UpdateSubresource}} or CopySubresourceRegion to copy from a staging resource to a default resource, you can corrupt the destination contents. This occurs if you pass a {{NULL}} source box and if the source resource has different dimensions from those of the destination resource or if you use destination offsets, (x, y, and z). In this situation, always pass a source box that is the full size of the source resource.?Note??Applies only to feature level 9_x hardware You can't use CopySubresourceRegion to copy mipmapped volume textures.?Note??Applies only to feature levels 9_x Subresources created with the {{D3D11_BIND_DEPTH_STENCIL}} flag can only be used as a source for CopySubresourceRegion.?Note??If you use CopySubresourceRegion with a depth-stencil buffer or a multisampled resource, you must copy the whole subresource. In this situation, you must pass 0 to the DstX, DstY, and DstZ parameters and {{NULL}} to the pSrcBox parameter. In addition, source and destination resources, which are represented by the pSrcResource and pDstResource parameters, should have identical sample count values.? Returns nothing

<dd> A reference to the destination resource (see {{ID3D11Resource}}). </dd>

<dd> Destination subresource index. </dd>

<dd> The x-coordinate of the upper left corner of the destination region. </dd>

<dd> The y-coordinate of the upper left corner of the destination region. For a 1D subresource, this must be zero. </dd>

<dd> The z-coordinate of the upper left corner of the destination region. For a 1D or 2D subresource, this must be zero. </dd>

<dd> A reference to the source resource (see {{ID3D11Resource}}). </dd>

<dd> Source subresource index. </dd>

<dd> A reference to a 3D box (see {{D3D11_BOX}}) that defines the source subresource that can be copied. If {{NULL}}, the entire source subresource is copied. The box must fit within the source resource. An empty box results in a no-op. A box is empty if the top value is greater than or equal to the bottom value, or the left value is greater than or equal to the right value, or the front value is greater than or equal to the back value. When the box is empty, CopySubresourceRegion doesn't perform a copy operation. </dd>

Copy the entire contents of the source resource to the destination resource using the {{GPU}}.

This method is unusual in that it causes the {{GPU}} to perform the copy operation (similar to a memcpy by the {{CPU}}). As a result, it has a few restrictions designed for improving performance. For instance, the source and destination resources:<ul> <li>Must be different resources.</li> <li>Must be the same type.</li> <li>Must have identical dimensions (including width, height, depth, and size as appropriate).</li> <li>Must have compatible {{DXGI}} formats, which means the formats must be identical or at least from the same type group. For example, a {{DXGI_FORMAT_R32G32B32_FLOAT}} texture can be copied to an {{DXGI_FORMAT_R32G32B32_UINT}} texture since both of these formats are in the {{DXGI_FORMAT_R32G32B32_TYPELESS}} group. CopyResource can copy between a few format types. For more info, see Format Conversion using Direct3D 10.1.</li> <li>Can't be currently mapped.</li> </ul>CopyResource only supports copy; it doesn't support any stretch, color key, or blend. CopyResource can reinterpret the resource data between a few format types. For more info, see Format Conversion using Direct3D 10.1.You can't use an Immutable resource as a destination. You can use a depth-stencil resource as either a source or a destination provided that the feature level is {{D3D_FEATURE_LEVEL_10_1}} or greater. For feature levels 9_x, resources created with the {{D3D11_BIND_DEPTH_STENCIL}} flag can only be used as a source for CopyResource. Resources created with multisampling capability (see {{DXGI_SAMPLE_DESC}}) can be used as source and destination only if both source and destination have identical multisampled count and quality. If source and destination differ in multisampled count and quality or if one is multisampled and the other is not multisampled, the call to {{ID3D11DeviceContext::CopyResource}} fails. Use {{ID3D11DeviceContext::ResolveSubresource}} to resolve a multisampled resource to a resource that is not multisampled.The method is an asynchronous call, which may be added to the command-buffer queue. This attempts to remove pipeline stalls that may occur when copying data. For more info, see performance considerations.We recommend to use {{ID3D11DeviceContext::CopySubresourceRegion}} instead if you only need to copy a portion of the data in a resource. Returns nothing

<dd> A reference to the {{ID3D11Resource}} interface that represents the destination resource. </dd>

<dd> A reference to the {{ID3D11Resource}} interface that represents the source resource. </dd>

The {{CPU}} copies data from memory to a subresource created in non-mappable memory.

For a shader-constant buffer; set pDstBox to {{NULL}}. It is not possible to use this method to partially update a shader-constant buffer.A resource cannot be used as a destination if:<ul> <li>the resource is created with immutable or dynamic usage.</li> <li>the resource is created as a depth-stencil resource.</li> <li>the resource is created with multisampling capability (see {{DXGI_SAMPLE_DESC}}).</li> </ul>When UpdateSubresource returns, the application is free to change or even free the data pointed to by pSrcData because the method has already copied/snapped away the original contents.The performance of UpdateSubresource depends on whether or not there is contention for the destination resource. For example, contention for a vertex buffer resource occurs when the application executes a Draw call and later calls UpdateSubresource on the same vertex buffer before the Draw call is actually executed by the {{GPU}}.<ul> <li>When there is contention for the resource, UpdateSubresource will perform 2 copies of the source data. First, the data is copied by the {{CPU}} to a temporary storage space accessible by the command buffer. This copy happens before the method returns. A second copy is then performed by the {{GPU}} to copy the source data into non-mappable memory. This second copy happens asynchronously because it is executed by {{GPU}} when the command buffer is flushed.</li> <li>When there is no resource contention, the behavior of UpdateSubresource is dependent on which is faster (from the {{CPU}}'s perspective): copying the data to the command buffer and then having a second copy execute when the command buffer is flushed, or having the {{CPU}} copy the data to the final resource location. This is dependent on the architecture of the underlying system.</li> </ul>Note??Applies only to feature level 9_x hardware If you use UpdateSubresource or {{ID3D11DeviceContext::CopySubresourceRegion}} to copy from a staging resource to a default resource, you can corrupt the destination contents. This occurs if you pass a {{NULL}} source box and if the source resource has different dimensions from those of the destination resource or if you use destination offsets, (x, y, and z). In this situation, always pass a source box that is the full size of the source resource.?To better understand the source row pitch and source depth pitch parameters, the following illustration shows a 3D volume texture.Each block in this visual represents an element of data, and the size of each element is dependent on the resource's format. For example, if the resource format is {{DXGI_FORMAT_R32G32B32A32_FLOAT}}, the size of each element would be 128 bits, or 16 bytes. This 3D volume texture has a width of two, a height of three, and a depth of four.To calculate the source row pitch and source depth pitch for a given resource, use the following formulas:<ul> <li>Source Row Pitch = [size of one element in bytes] * [number of elements in one row]</li> <li>Source Depth Pitch = [Source Row Pitch] * [number of rows (height)]</li> </ul>In the case of this example 3D volume texture where the size of each element is 16 bytes, the formulas are as follows:<ul> <li>Source Row Pitch = 16 * 2 = 32</li> <li>Source Depth Pitch = 16 * 2 * 3 = 96</li> </ul>The following illustration shows the resource as it is laid out in memory.For example, the following code snippet shows how to specify a destination region in a 2D texture. Assume the destination texture is 512x512 and the operation will copy the data pointed to by pData to [(120,100)..(200,220)] in the destination texture. Also assume that rowPitch has been initialized with the proper value (as explained above). front and back are set to 0 and 1 respectively, because by having front equal to back, the box is technically empty.<pre> {{D3D11_BOX}} destRegion; destRegion.left = 120; destRegion.right = 200; destRegion.top = 100; destRegion.bottom = 220; destRegion.front = 0; destRegion.back = 1; pd3dDeviceContext->UpdateSubresource( pDestTexture, 0, &destRegion, pData, rowPitch, 0 ); </pre>The 1D case is similar. The following snippet shows how to specify a destination region in a 1D texture. Use the same assumptions as above, except that the texture is 512 in length.<pre> {{D3D11_BOX}} destRegion; destRegion.left = 120; destRegion.right = 200; destRegion.top = 0; destRegion.bottom = 1; destRegion.front = 0; destRegion.back = 1; pd3dDeviceContext->UpdateSubresource( pDestTexture, 0, &destRegion, pData, rowPitch, 0 ); </pre>For info about various resource types and how UpdateSubresource might work with each resource type, see Introduction to a Resource in Direct3D 11. Returns nothing

<dd> A reference to the destination resource (see {{ID3D11Resource}}). </dd>

<dd> A zero-based index, that identifies the destination subresource. See {{D3D11CalcSubresource}} for more details. </dd>

<dd> A reference to a box that defines the portion of the destination subresource to copy the resource data into. Coordinates are in bytes for buffers and in texels for textures. If {{NULL}}, the data is written to the destination subresource with no offset. The dimensions of the source must fit the destination (see {{D3D11_BOX}}). An empty box results in a no-op. A box is empty if the top value is greater than or equal to the bottom value, or the left value is greater than or equal to the right value, or the front value is greater than or equal to the back value. When the box is empty, UpdateSubresource doesn't perform an update operation. </dd>

<dd> A reference to the source data in memory. </dd>

<dd> The size of one row of the source data. </dd>

<dd> The size of one depth slice of source data. </dd>

Copies data from a buffer holding variable length data.

Returns nothing.

<dd> Pointer to {{ID3D11Buffer}}. This can be any buffer resource that other copy commands, such as {{ID3D11DeviceContext::CopyResource}} or {{ID3D11DeviceContext::CopySubresourceRegion}}, are able to write to. </dd>

<dd> Offset from the start of pDstBuffer to write 32-bit {{UINT}} structure (vertex) count from pSrcView. </dd>

<dd> Pointer to an {{ID3D11UnorderedAccessView}} of a Structured Buffer resource created with either {{D3D11_BUFFER_UAV_FLAG_APPEND}} or {{D3D11_BUFFER_UAV_FLAG_COUNTER}} specified when the {{UAV}} was created. These types of resources have hidden counters tracking "how many" records have been written. </dd>

Set all the elements in a render target to one value.

Applications that wish to clear a render target to a specific integer value bit pattern should render a screen-aligned quad instead of using this method. The reason for this is because this method accepts as input a floating point value, which may not have the same bit pattern as the original integer.<table> <tr><td> Differences between Direct3D 9 and Direct3D 11/10: Unlike Direct3D 9, the full extent of the resource view is always cleared. Viewport and scissor settings are not applied. </td></tr> </table>?When using {{D3D_FEATURE_LEVEL_9_x}}, ClearRenderTargetView only clears the first array slice in the render target view. This can impact (for example) cube map rendering scenarios. Applications should create a render target view for each face or array slice, then clear each view individually. Returns nothing.

<dd> Pointer to the render target. </dd>

<dd> A 4-component array that represents the color to fill the render target with. </dd>

Clears an unordered access resource with bit-precise values.

This {{API}} copies the lower ni bits from each array element i to the corresponding channel, where ni is the number of bits in the ith channel of the resource format (for example, {{R8G8B8_FLOAT}} has 8 bits for the first 3 channels). This works on any {{UAV}} with no format conversion. For a raw or structured buffer view, only the first array element value is used. Returns nothing.

Clears an unordered access resource with a float value.

This {{API}} works on {{FLOAT}}, {{UNORM}}, and {{SNORM}} unordered access views ({{UAVs}}), with format conversion from {{FLOAT}} to *{{NORM}} where appropriate. On other {{UAVs}}, the operation is invalid and the call will not reach the driver. Returns nothing.

Clears the depth-stencil resource.

<table> <tr><td> Differences between Direct3D 9 and Direct3D 11/10: Unlike Direct3D 9, the full extent of the resource view is always cleared. Viewport and scissor settings are not applied. </td></tr> </table>? Returns nothing.

<dd> Pointer to the depth stencil to be cleared. </dd>

<dd> Identify the type of data to clear (see {{D3D11_CLEAR_FLAG}}). </dd>

<dd> Clear the depth buffer with this value. This value will be clamped between 0 and 1. </dd>

<dd> Clear the stencil buffer with this value. </dd>

Generates mipmaps for the given shader resource.

You can call GenerateMips on any shader-resource view to generate the lower mipmap levels for the shader resource. GenerateMips uses the largest mipmap level of the view to recursively generate the lower levels of the mip and stops with the smallest level that is specified by the view. If the base resource wasn't created with {{D3D11_BIND_RENDER_TARGET}}, {{D3D11_BIND_SHADER_RESOURCE}}, and {{D3D11_RESOURCE_MISC_GENERATE_MIPS}}, the call to GenerateMips has no effect.Feature levels 9.1, 9.2, and 9.3 can't support automatic generation of mipmaps for 3D (volume) textures.Video adapters that support feature level 9.1 and higher support generating mipmaps if you use any of these formats:<pre> {{DXGI_FORMAT_R8G8B8A8_UNORM}} {{DXGI_FORMAT_R8G8B8A8_UNORM_SRGB}} {{DXGI_FORMAT_B5G6R5_UNORM}} {{DXGI_FORMAT_B8G8R8A8_UNORM}} {{DXGI_FORMAT_B8G8R8A8_UNORM_SRGB}} {{DXGI_FORMAT_B8G8R8X8_UNORM}} {{DXGI_FORMAT_B8G8R8X8_UNORM_SRGB}} </pre>Video adapters that support feature level 9.2 and higher support generating mipmaps if you use any of these formats in addition to any of the formats for feature level 9.1:<pre> {{DXGI_FORMAT_R16G16B16A16_FLOAT}} {{DXGI_FORMAT_R16G16B16A16_UNORM}} {{DXGI_FORMAT_R16G16_FLOAT}} {{DXGI_FORMAT_R16G16_UNORM}} {{DXGI_FORMAT_R32_FLOAT}} </pre>Video adapters that support feature level 9.3 and higher support generating mipmaps if you use any of these formats in addition to any of the formats for feature levels 9.1 and 9.2:<pre> {{DXGI_FORMAT_R32G32B32A32_FLOAT}} {{DXGI_FORMAT_B4G4R4A4}} (optional) </pre>Video adapters that support feature level 10 and higher support generating mipmaps if you use any of these formats in addition to any of the formats for feature levels 9.1, 9.2, and 9.3:<pre> {{DXGI_FORMAT_R32G32B32_FLOAT}} (optional) {{DXGI_FORMAT_R16G16B16A16_SNORM}} {{DXGI_FORMAT_R32G32_FLOAT}} {{DXGI_FORMAT_R10G10B10A2_UNORM}} {{DXGI_FORMAT_R11G11B10_FLOAT}} {{DXGI_FORMAT_R8G8B8A8_SNORM}} {{DXGI_FORMAT_R16G16_SNORM}} {{DXGI_FORMAT_R8G8_UNORM}} {{DXGI_FORMAT_R8G8_SNORM}} {{DXGI_FORMAT_R16_FLOAT}} {{DXGI_FORMAT_R16_UNORM}} {{DXGI_FORMAT_R16_SNORM}} {{DXGI_FORMAT_R8_UNORM}} {{DXGI_FORMAT_R8_SNORM}} {{DXGI_FORMAT_A8_UNORM}} {{DXGI_FORMAT_B5G5R5A1_UNORM}} (optional) </pre>For all other unsupported formats, GenerateMips will silently fail. Returns nothing.

<dd> A reference to an {{ID3D11ShaderResourceView}} interface that represents the shader resource. </dd>

Sets the minimum level-of-detail ({{LOD}}) for a resource.

To use a resource with SetResourceMinLOD, you must set the {{D3D11_RESOURCE_MISC_RESOURCE_CLAMP}} flag when you create that resource.For Direct3D 10 and Direct3D 10.1, when sampling from a texture resource in a shader, the sampler can define a minimum {{LOD}} clamp to force sampling from less detailed mip levels. For Direct3D 11, this functionality is extended from the sampler to the entire resource. Therefore, the application can specify the highest-resolution mip level of a resource that is available for access. This restricts the set of mip levels that are required to be resident in {{GPU}} memory, thereby saving memory.The set of mip levels resident per-resource in {{GPU}} memory can be specified by the user.Minimum {{LOD}} affects all of the resident mip levels. Therefore, only the resident mip levels can be updated and read from.All methods that access texture resources must adhere to minimum {{LOD}} clamps.Empty-set accesses are handled as out-of-bounds cases. Returns nothing.

<dd> A reference to an {{ID3D11Resource}} that represents the resource. </dd>

<dd> The level-of-detail, which ranges between 0 and the maximum number of mipmap levels of the resource. For example, the maximum number of mipmap levels of a 1D texture is specified in the MipLevels member of the {{D3D11_TEXTURE1D_DESC}} structure. </dd>

Gets the minimum level-of-detail ({{LOD}}).

Returns the minimum {{LOD}}.

<dd> A reference to an {{ID3D11Resource}} which represents the resource. </dd>

Copy a multisampled resource into a non-multisampled resource.

This {{API}} is most useful when re-using the resulting rendertarget of one render pass as an input to a second render pass.The source and destination resources must be the same resource type and have the same dimensions. In addition, they must have compatible formats. There are three scenarios for this:<table> <tr><th>Scenario</th><th>Requirements</th></tr> <tr><td>Source and destination are prestructured and typed</td><td>Both the source and destination must have identical formats and that format must be specified in the Format parameter.</td></tr> <tr><td>One resource is prestructured and typed and the other is prestructured and typeless</td><td>The typed resource must have a format that is compatible with the typeless resource (i.e. the typed resource is {{DXGI_FORMAT_R32_FLOAT}} and the typeless resource is {{DXGI_FORMAT_R32_TYPELESS}}). The format of the typed resource must be specified in the Format parameter.</td></tr> <tr><td>Source and destination are prestructured and typeless</td><td>Both the source and desintation must have the same typeless format (i.e. both must have {{DXGI_FORMAT_R32_TYPELESS}}), and the Format parameter must specify a format that is compatible with the source and destination (i.e. if both are {{DXGI_FORMAT_R32_TYPELESS}} then {{DXGI_FORMAT_R32_FLOAT}} could be specified in the Format parameter). For example, given the {{DXGI_FORMAT_R16G16B16A16_TYPELESS}} format: <ul> <li>The source (or dest) format could be {{DXGI_FORMAT_R16G16B16A16_UNORM}}</li> <li>The dest (or source) format could be {{DXGI_FORMAT_R16G16B16A16_FLOAT}}</li> </ul> </td></tr> </table>? Returns nothing.

<dd> Destination resource. Must be a created with the {{D3D11_USAGE_DEFAULT}} flag and be single-sampled. See {{ID3D11Resource}}. </dd>

<dd> A zero-based index, that identifies the destination subresource. Use {{D3D11CalcSubresource}} to calculate the index. </dd>

<dd> Source resource. Must be multisampled. </dd>

<dd> The source subresource of the source resource. </dd>

<dd> A {{DXGI_FORMAT}} that indicates how the multisampled resource will be resolved to a single-sampled resource. See remarks. </dd>

Queues commands from a command list onto a device.

Use this method to play back a command list that was recorded by a deferred context on any thread. A call to ExecuteCommandList of a command list from a deferred context onto the immediate context is required for the recorded commands to be executed on the graphics processing unit ({{GPU}}). A call to ExecuteCommandList of a command list from a deferred context onto another deferred context can be used to merge recorded lists. But to run the commands from the merged deferred command list on the {{GPU}}, you need to execute them on the immediate context. This method performs some runtime validation related to queries. Queries that are begun in a device context cannot be manipulated indirectly by executing a command list (that is, Begin or End was invoked against the same query by the deferred context which generated the command list). If such a condition occurs, the ExecuteCommandList method does not execute the command list. However, the state of the device context is still maintained, as would be expected ({{ID3D11DeviceContext::ClearState}} is performed, unless the application indicates to preserve the device context state). Windows?Phone?8: This {{API}} is supported. This method does not return a value.

<dd> A reference to an {{ID3D11CommandList}} interface that encapsulates a command list. </dd>

<dd> A Boolean flag that determines whether the target context state is saved prior to and restored after the execution of a command list. Use {{TRUE}} to indicate that the runtime needs to save and restore the state. Use {{FALSE}} to indicate that no state shall be saved or restored, which causes the target context to return to its default state after the command list executes. Applications should typically use {{FALSE}} unless they will restore the state to be nearly equivalent to the state that the runtime would restore if {{TRUE}} were passed. When applications use {{FALSE}}, they can avoid unnecessary and inefficient state transitions. </dd>

Bind an array of shader resources to the hull-shader stage.

Set a hull shader to the device.

<dd> Pointer to a hull shader (see {{ID3D11HullShader}}). Passing in {{NULL}} disables the shader for this pipeline stage. </dd>

<dd> A reference to an array of class-instance interfaces (see {{ID3D11ClassInstance}}). Each interface used by a shader must have a corresponding class instance or the shader will get disabled. Set ppClassInstances to {{NULL}} if the shader does not use any interfaces. </dd>

<dd> The number of class-instance interfaces in the array. </dd>

Set an array of sampler states to the hull-shader stage.

Set the constant buffers used by the hull-shader stage.

The method will hold a reference to the interfaces passed in. This differs from the device state behavior in Direct3D 10. The Direct3D 11.1 runtime, which is available starting with Windows?8, can bind a larger number of {{ID3D11Buffer}} resources to the shader than the maximum constant buffer size that is supported by shaders (4096 constants ? 4*32-bit components each). When you bind such a large buffer, the shader can access only the first 4096 4*32-bit component constants in the buffer, as if 4096 constants is the full size of the buffer. If the application wants the shader to access other parts of the buffer, it must call the {{HSSetConstantBuffers1}} method instead. This method does not return a value.

Bind an array of shader resources to the domain-shader stage.

<dd> Index into the device's zero-based array to begin setting shader resources to (ranges from 0 to {{D3D11_COMMONSHADER_INPUT_RESOURCE_SLOT_COUNT}} - 1). </dd>

<dd> Number of shader resources to set. Up to a maximum of 128 slots are available for shader resources(ranges from 0 to {{D3D11_COMMONSHADER_INPUT_RESOURCE_SLOT_COUNT}} - StartSlot). </dd>

<dd> Array of shader resource view interfaces to set to the device. </dd>

Set a domain shader to the device.

<dd> Pointer to a domain shader (see {{ID3D11DomainShader}}). Passing in {{NULL}} disables the shader for this pipeline stage. </dd>

<dd> The number of class-instance interfaces in the array. </dd>

Set an array of sampler states to the domain-shader stage.

<dd> Index into the device's zero-based array to begin setting samplers to (ranges from 0 to {{D3D11_COMMONSHADER_SAMPLER_SLOT_COUNT}} - 1). </dd>

<dd> Number of samplers in the array. Each pipeline stage has a total of 16 sampler slots available (ranges from 0 to {{D3D11_COMMONSHADER_SAMPLER_SLOT_COUNT}} - StartSlot). </dd>

<dd> Pointer to an array of sampler-state interfaces (see {{ID3D11SamplerState}}). See Remarks. </dd>

Sets the constant buffers used by the domain-shader stage.

The method will hold a reference to the interfaces passed in. This differs from the device state behavior in Direct3D 10. The Direct3D 11.1 runtime, which is available starting with Windows?8, can bind a larger number of {{ID3D11Buffer}} resources to the shader than the maximum constant buffer size that is supported by shaders (4096 constants ? 4*32-bit components each). When you bind such a large buffer, the shader can access only the first 4096 4*32-bit component constants in the buffer, as if 4096 constants is the full size of the buffer. If the application wants the shader to access other parts of the buffer, it must call the {{DSSetConstantBuffers1}} method instead. Windows?Phone?8: This {{API}} is supported. This method does not return a value.

<dd> Index into the zero-based array to begin setting constant buffers to (ranges from 0 to {{D3D11_COMMONSHADER_CONSTANT_BUFFER_API_SLOT_COUNT}} - 1). </dd>

<dd> Number of buffers to set (ranges from 0 to {{D3D11_COMMONSHADER_CONSTANT_BUFFER_API_SLOT_COUNT}} - StartSlot). </dd>

<dd> Array of constant buffers (see {{ID3D11Buffer}}) being given to the device. </dd>

Bind an array of shader resources to the compute-shader stage.

<dd> Index into the device's zero-based array to begin setting shader resources to (ranges from 0 to {{D3D11_COMMONSHADER_INPUT_RESOURCE_SLOT_COUNT}} - 1). </dd>

<dd> Number of shader resources to set. Up to a maximum of 128 slots are available for shader resources(ranges from 0 to {{D3D11_COMMONSHADER_INPUT_RESOURCE_SLOT_COUNT}} - StartSlot). </dd>

<dd> Array of shader resource view interfaces to set to the device. </dd>

Sets an array of views for an unordered resource.

Windows?Phone?8: This {{API}} is supported. This method does not return a value.

<dd> Index of the first element in the zero-based array to begin setting (ranges from 0 to {{D3D11_1_UAV_SLOT_COUNT}} - 1). {{D3D11_1_UAV_SLOT_COUNT}} is defined as 64. </dd>

<dd> Number of views to set (ranges from 0 to {{D3D11_1_UAV_SLOT_COUNT}} - StartSlot). </dd>

<dd> A reference to an array of {{ID3D11UnorderedAccessView}} references to be set by the method. </dd>

<dd> An array of append and consume buffer offsets. A value of -1 indicates to keep the current offset. Any other values set the hidden counter for that appendable and consumable {{UAV}}. pUAVInitialCounts is only relevant for {{UAVs}} that were created with either {{D3D11_BUFFER_UAV_FLAG_APPEND}} or {{D3D11_BUFFER_UAV_FLAG_COUNTER}} specified when the {{UAV}} was created; otherwise, the argument is ignored. </dd>

Set a compute shader to the device.

<dd> Pointer to a compute shader (see {{ID3D11ComputeShader}}). Passing in {{NULL}} disables the shader for this pipeline stage. </dd>

<dd> A reference to an array of class-instance interfaces (see {{ID3D11ClassInstance}}). Each interface used by a shader must have a corresponding class instance or the shader will get disabled. Set ppClassInstances to {{NULL}} if the shader does not use any interfaces. </dd>

<dd> The number of class-instance interfaces in the array. </dd>

Set an array of sampler states to the compute-shader stage.

Any sampler may be set to {{NULL}}; this invokes the default state, which is defined to be the following.<pre>//Default sampler state: {{D3D11_SAMPLER_DESC}} SamplerDesc; SamplerDesc.Filter = {{D3D11_FILTER_MIN_MAG_MIP_LINEAR}}; SamplerDesc.AddressU = {{D3D11_TEXTURE_ADDRESS_CLAMP}}; SamplerDesc.AddressV = {{D3D11_TEXTURE_ADDRESS_CLAMP}}; SamplerDesc.AddressW = {{D3D11_TEXTURE_ADDRESS_CLAMP}}; SamplerDesc.MipLODBias = 0; SamplerDesc.MaxAnisotropy = 1; SamplerDesc.ComparisonFunc = {{D3D11_COMPARISON_NEVER}}; SamplerDesc.BorderColor[0] = 1.0f; SamplerDesc.BorderColor[1] = 1.0f; SamplerDesc.BorderColor[2] = 1.0f; SamplerDesc.BorderColor[3] = 1.0f; SamplerDesc.MinLOD = -{{FLT_MAX}}; SamplerDesc.MaxLOD = {{FLT_MAX}}; </pre> The method will hold a reference to the interfaces passed in. This differs from the device state behavior in Direct3D 10. This method does not return a value.

<dd> Index into the device's zero-based array to begin setting samplers to (ranges from 0 to {{D3D11_COMMONSHADER_SAMPLER_SLOT_COUNT}} - 1). </dd>

<dd> Number of samplers in the array. Each pipeline stage has a total of 16 sampler slots available (ranges from 0 to {{D3D11_COMMONSHADER_SAMPLER_SLOT_COUNT}} - StartSlot). </dd>

<dd> Pointer to an array of sampler-state interfaces (see {{ID3D11SamplerState}}). See Remarks. </dd>

Sets the constant buffers used by the compute-shader stage.

The method will hold a reference to the interfaces passed in. This differs from the device state behavior in Direct3D 10. The Direct3D 11.1 runtime, which is available starting with Windows?8, can bind a larger number of {{ID3D11Buffer}} resources to the shader than the maximum constant buffer size that is supported by shaders (4096 constants ? 4*32-bit components each). When you bind such a large buffer, the shader can access only the first 4096 4*32-bit component constants in the buffer, as if 4096 constants is the full size of the buffer. If the application wants the shader to access other parts of the buffer, it must call the {{CSSetConstantBuffers1}} method instead. This method does not return a value.

<dd> Index into the zero-based array to begin setting constant buffers to (ranges from 0 to {{D3D11_COMMONSHADER_CONSTANT_BUFFER_API_SLOT_COUNT}} - 1). </dd>

<dd> Number of buffers to set (ranges from 0 to {{D3D11_COMMONSHADER_CONSTANT_BUFFER_API_SLOT_COUNT}} - StartSlot). </dd>

<dd> Array of constant buffers (see {{ID3D11Buffer}}) being given to the device. </dd>

Get the constant buffers used by the vertex shader pipeline stage.

Any returned interfaces will have their reference count incremented by one. Applications should call {{IUnknown::Release}} on the returned interfaces when they are no longer needed to avoid memory leaks. Returns nothing.

<dd> Index into the device's zero-based array to begin retrieving constant buffers from (ranges from 0 to {{D3D11_COMMONSHADER_CONSTANT_BUFFER_API_SLOT_COUNT}} - 1). </dd>

<dd> Number of buffers to retrieve (ranges from 0 to {{D3D11_COMMONSHADER_CONSTANT_BUFFER_API_SLOT_COUNT}} - StartSlot). </dd>

<dd> Array of constant buffer interface references (see {{ID3D11Buffer}}) to be returned by the method. </dd>

Bind an array of shader resources to the pixel shader stage.

<dd> Index into the device's zero-based array to begin setting shader resources to (ranges from 0 to {{D3D11_COMMONSHADER_INPUT_RESOURCE_SLOT_COUNT}} - 1). </dd>

<dd> Number of shader resources to set. Up to a maximum of 128 slots are available for shader resources (ranges from 0 to {{D3D11_COMMONSHADER_INPUT_RESOURCE_SLOT_COUNT}} - StartSlot). </dd>

<dd> Array of shader resource view interfaces to set to the device. </dd>

Get the pixel shader currently set on the device.

Any returned interfaces will have their reference count incremented by one. Applications should call {{IUnknown::Release}} on the returned interfaces when they are no longer needed, to avoid memory leaks. Windows?Phone?8: This {{API}} is supported. Returns nothing.

<dd> Address of a reference to a pixel shader (see {{ID3D11PixelShader}}) to be returned by the method. </dd>

<dd> Pointer to an array of class instance interfaces (see {{ID3D11ClassInstance}}). </dd>

<dd> The number of class-instance elements in the array. </dd>

Get an array of sampler states from the pixel shader pipeline stage.

<dd> Index into a zero-based array to begin getting samplers from (ranges from 0 to {{D3D11_COMMONSHADER_SAMPLER_SLOT_COUNT}} - 1). </dd>

<dd> Number of samplers to get from a device context. Each pipeline stage has a total of 16 sampler slots available (ranges from 0 to {{D3D11_COMMONSHADER_SAMPLER_SLOT_COUNT}} - StartSlot). </dd>

<dd> Arry of sampler-state interface references (see {{ID3D11SamplerState}}) to be returned by the device. </dd>

Get the vertex shader currently set on the device.

<dd> Address of a reference to a vertex shader (see {{ID3D11VertexShader}}) to be returned by the method. </dd>

<dd> Pointer to an array of class instance interfaces (see {{ID3D11ClassInstance}}). </dd>

<dd> The number of class-instance elements in the array. </dd>

Get the constant buffers used by the pixel shader pipeline stage.

<dd> Index into the device's zero-based array to begin retrieving constant buffers from (ranges from 0 to {{D3D11_COMMONSHADER_CONSTANT_BUFFER_API_SLOT_COUNT}} - 1). </dd>

<dd> Number of buffers to retrieve (ranges from 0 to {{D3D11_COMMONSHADER_CONSTANT_BUFFER_API_SLOT_COUNT}} - StartSlot). </dd>

<dd> Array of constant buffer interface references (see {{ID3D11Buffer}}) to be returned by the method. </dd>

Get a reference to the input-layout object that is bound to the input-assembler stage.

For information about creating an input-layout object, see Creating the Input-Layout Object.Any returned interfaces will have their reference count incremented by one. Applications should call {{IUnknown::Release}} on the returned interfaces when they are no longer needed to avoid memory leaks. Returns nothing.

<dd> A reference to the input-layout object (see {{ID3D11InputLayout}}), which describes the input buffers that will be read by the {{IA}} stage. </dd>

Get the vertex buffers bound to the input-assembler stage.

<dd> The input slot of the first vertex buffer to get. The first vertex buffer is explicitly bound to the start slot; this causes each additional vertex buffer in the array to be implicitly bound to each subsequent input slot. The maximum of 16 or 32 input slots (ranges from 0 to {{D3D11_IA_VERTEX_INPUT_RESOURCE_SLOT_COUNT}} - 1) are available; the maximum number of input slots depends on the feature level. </dd>

<dd> The number of vertex buffers to get starting at the offset. The number of buffers (plus the starting slot) cannot exceed the total number of {{IA}}-stage input slots. </dd>

<dd> A reference to an array of vertex buffers returned by the method (see {{ID3D11Buffer}}). </dd>

<dd> Pointer to an array of stride values returned by the method; one stride value for each buffer in the vertex-buffer array. Each stride value is the size (in bytes) of the elements that are to be used from that vertex buffer. </dd>

<dd> Pointer to an array of offset values returned by the method; one offset value for each buffer in the vertex-buffer array. Each offset is the number of bytes between the first element of a vertex buffer and the first element that will be used. </dd>

Get a reference to the index buffer that is bound to the input-assembler stage.

<dd> A reference to an index buffer returned by the method (see {{ID3D11Buffer}}). </dd>

<dd> Specifies format of the data in the index buffer (see {{DXGI_FORMAT}}). These formats provide the size and type of the data in the buffer. The only formats allowed for index buffer data are 16-bit ({{DXGI_FORMAT_R16_UINT}}) and 32-bit ({{DXGI_FORMAT_R32_UINT}}) integers. </dd>

<dd> Offset (in bytes) from the start of the index buffer, to the first index to use. </dd>

Get the constant buffers used by the geometry shader pipeline stage.

<dd> Index into the device's zero-based array to begin retrieving constant buffers from (ranges from 0 to {{D3D11_COMMONSHADER_CONSTANT_BUFFER_API_SLOT_COUNT}} - 1). </dd>

<dd> Number of buffers to retrieve (ranges from 0 to {{D3D11_COMMONSHADER_CONSTANT_BUFFER_API_SLOT_COUNT}} - StartSlot). </dd>

<dd> Array of constant buffer interface references (see {{ID3D11Buffer}}) to be returned by the method. </dd>

Get the geometry shader currently set on the device.

<dd> Address of a reference to a geometry shader (see {{ID3D11GeometryShader}}) to be returned by the method. </dd>

<dd> Pointer to an array of class instance interfaces (see {{ID3D11ClassInstance}}). </dd>

<dd> The number of class-instance elements in the array. </dd>

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

Returns nothing.

<dd> A reference to the type of primitive, and ordering of the primitive data (see {{D3D11_PRIMITIVE_TOPOLOGY}}). </dd>

Get the vertex shader resources.

<dd> Index into the device's zero-based array to begin getting shader resources from (ranges from 0 to {{D3D11_COMMONSHADER_INPUT_RESOURCE_SLOT_COUNT}} - 1). </dd>

<dd> The number of resources to get from the device. Up to a maximum of 128 slots are available for shader resources (ranges from 0 to {{D3D11_COMMONSHADER_INPUT_RESOURCE_SLOT_COUNT}} - StartSlot). </dd>

<dd> Array of shader resource view interfaces to be returned by the device. </dd>

Get an array of sampler states from the vertex shader pipeline stage.

<dd> Index into a zero-based array to begin getting samplers from (ranges from 0 to {{D3D11_COMMONSHADER_SAMPLER_SLOT_COUNT}} - 1). </dd>

<dd> Arry of sampler-state interface references (see {{ID3D11SamplerState}}) to be returned by the device. </dd>

Get the rendering predicate state.

<dd> Address of a reference to a predicate (see {{ID3D11Predicate}}). Value stored here will be {{NULL}} upon device creation. </dd>

<dd> Address of a boolean to fill with the predicate comparison value. {{FALSE}} upon device creation. </dd>

Get the geometry shader resources.

<dd> Index into the device's zero-based array to begin getting shader resources from (ranges from 0 to {{D3D11_COMMONSHADER_INPUT_RESOURCE_SLOT_COUNT}} - 1). </dd>

<dd> Array of shader resource view interfaces to be returned by the device. </dd>

Get an array of sampler state interfaces from the geometry shader pipeline stage.

<dd> Index into a zero-based array to begin getting samplers from (ranges from 0 to {{D3D11_COMMONSHADER_SAMPLER_SLOT_COUNT}} - 1). </dd>

<dd> Pointer to an array of sampler-state interfaces (see {{ID3D11SamplerState}}). </dd>

Get references to the resources bound to the output-merger stage.

<dd> Number of render targets to retrieve. </dd>

<dd> Pointer to an array of {{ID3D11RenderTargetView}}s which represent render target views. Specify {{NULL}} for this parameter when retrieval of a render target is not needed. </dd>

<dd> Pointer to a {{ID3D11DepthStencilView}}, which represents a depth-stencil view. Specify {{NULL}} for this parameter when retrieval of the depth-stencil view is not needed. </dd>

Get references to the resources bound to the output-merger stage.

Any returned interfaces will have their reference count incremented by one. Applications should call {{IUnknown::Release}} on the returned interfaces when they are no longer needed to avoid memory leaks. Windows?Phone?8: This {{API}} is supported. Returns nothing.

<dd> The number of render-target views to retrieve. </dd>

<dd> Pointer to an array of {{ID3D11RenderTargetView}}s, which represent render-target views. Specify {{NULL}} for this parameter when retrieval of render-target views is not required. </dd>

<dd> Pointer to a {{ID3D11DepthStencilView}}, which represents a depth-stencil view. Specify {{NULL}} for this parameter when retrieval of the depth-stencil view is not required. </dd>

<dd> Index into a zero-based array to begin retrieving unordered-access views (ranges from 0 to {{D3D11_PS_CS_UAV_REGISTER_COUNT}} - 1). For pixel shaders {{UAVStartSlot}} should be equal to the number of render-target views that are bound. </dd>

<dd> Number of unordered-access views to return in ppUnorderedAccessViews. This number ranges from 0 to {{D3D11_PS_CS_UAV_REGISTER_COUNT}} - {{UAVStartSlot}}. </dd>

<dd> Pointer to an array of {{ID3D11UnorderedAccessView}}s, which represent unordered-access views that are retrieved. Specify {{NULL}} for this parameter when retrieval of unordered-access views is not required. </dd>

Set the blend state of the output-merger stage.

<dd> 32-bit sample coverage. The default value is 0xffffffff. See remarks. </dd>

Gets the depth-stencil state of the output-merger stage.

<dd> Address of a reference to a depth-stencil state interface (see {{ID3D11DepthStencilState}}) to be filled with information from the device. </dd>

<dd> Pointer to the stencil reference value used in the depth-stencil test. </dd>

Get the target output buffers for the stream-output stage of the pipeline.

A maximum of four output buffers can be retrieved. The offsets to the output buffers pointed to in the returned ppSOTargets array may be assumed to be -1 (append), as defined for use in {{ID3D11DeviceContext::SOSetTargets}}. Any returned interfaces will have their reference count incremented by one. Applications should call {{IUnknown::Release}} on the returned interfaces when they are no longer needed to avoid memory leaks.Windows?Phone?8: This {{API}} is supported. Returns nothing.

<dd> Number of buffers to get. </dd>

<dd> An array of output buffers (see {{ID3D11Buffer}}) to be retrieved from the device. </dd>

Gets a reference to the data contained in a subresource, and denies the {{GPU}} access to that subresource.

Gets the array of viewports bound to the rasterizer stage.

Windows?Phone?8: This {{API}} is supported. Returns nothing.

<dd> A reference to a variable that, on input, specifies the number of viewports (ranges from 0 to {{D3D11_VIEWPORT_AND_SCISSORRECT_OBJECT_COUNT_PER_PIPELINE}}) in the pViewports array; on output, the variable contains the actual number of viewports that are bound to the rasterizer stage. If pViewports is {{NULL}}, {{RSGetViewports}} fills the variable with the number of viewports currently bound. Note?? In some versions of the Windows {{SDK}}, a debug device will raise an exception if the input value in the variable to which pNumViewports points is greater than {{D3D11_VIEWPORT_AND_SCISSORRECT_OBJECT_COUNT_PER_PIPELINE}} even if pViewports is {{NULL}}. The regular runtime ignores the value in the variable to which pNumViewports points when pViewports is {{NULL}}. This behavior of a debug device might be corrected in a future release of the Windows {{SDK}}. ? </dd>

<dd> An array of {{D3D11_VIEWPORT}} structures for the viewports that are bound to the rasterizer stage. If the number of viewports (in the variable to which pNumViewports points) is greater than the actual number of viewports currently bound, unused elements of the array contain 0. For info about how the viewport size depends on the device feature level, which has changed between Direct3D 11 and Direct3D 10, see {{D3D11_VIEWPORT}}. </dd>

Get the array of scissor rectangles bound to the rasterizer stage.

Returns nothing.

<dd> The number of scissor rectangles (ranges between 0 and {{D3D11_VIEWPORT_AND_SCISSORRECT_OBJECT_COUNT_PER_PIPELINE}}) bound; set pRects to {{NULL}} to use pNumRects to see how many rectangles would be returned. </dd>

<dd> An array of scissor rectangles (see {{D3D11_RECT}}). If NumRects is greater than the number of scissor rects currently bound, then unused members of the array will contain 0. </dd>

Get the hull-shader resources.

<dd> Index into the device's zero-based array to begin getting shader resources from (ranges from 0 to {{D3D11_COMMONSHADER_INPUT_RESOURCE_SLOT_COUNT}} - 1). </dd>

<dd> Array of shader resource view interfaces to be returned by the device. </dd>

Get the hull shader currently set on the device.

<dd> Address of a reference to a hull shader (see {{ID3D11HullShader}}) to be returned by the method. </dd>

<dd> Pointer to an array of class instance interfaces (see {{ID3D11ClassInstance}}). </dd>

<dd> The number of class-instance elements in the array. </dd>

Get an array of sampler state interfaces from the hull-shader stage.

Get the constant buffers used by the hull-shader stage.

Get the domain-shader resources.

<dd> Index into the device's zero-based array to begin getting shader resources from (ranges from 0 to {{D3D11_COMMONSHADER_INPUT_RESOURCE_SLOT_COUNT}} - 1). </dd>

<dd> Array of shader resource view interfaces to be returned by the device. </dd>

Get the domain shader currently set on the device.

<dd> Address of a reference to a domain shader (see {{ID3D11DomainShader}}) to be returned by the method. </dd>

<dd> Pointer to an array of class instance interfaces (see {{ID3D11ClassInstance}}). </dd>

<dd> The number of class-instance elements in the array. </dd>

Get an array of sampler state interfaces from the domain-shader stage.

<dd> Index into a zero-based array to begin getting samplers from (ranges from 0 to {{D3D11_COMMONSHADER_SAMPLER_SLOT_COUNT}} - 1). </dd>

<dd> Pointer to an array of sampler-state interfaces (see {{ID3D11SamplerState}}). </dd>

Get the constant buffers used by the domain-shader stage.

<dd> Index into the device's zero-based array to begin retrieving constant buffers from (ranges from 0 to {{D3D11_COMMONSHADER_CONSTANT_BUFFER_API_SLOT_COUNT}} - 1). </dd>

<dd> Number of buffers to retrieve (ranges from 0 to {{D3D11_COMMONSHADER_CONSTANT_BUFFER_API_SLOT_COUNT}} - StartSlot). </dd>

<dd> Array of constant buffer interface references (see {{ID3D11Buffer}}) to be returned by the method. </dd>

Get the compute-shader resources.

<dd> Index into the device's zero-based array to begin getting shader resources from (ranges from 0 to {{D3D11_COMMONSHADER_INPUT_RESOURCE_SLOT_COUNT}} - 1). </dd>

<dd> Array of shader resource view interfaces to be returned by the device. </dd>

Gets an array of views for an unordered resource.

Any returned interfaces will have their reference count incremented by one. Applications should call {{IUnknown::Release}} on the returned interfaces when they are no longer needed to avoid memory leaks. Returns nothing.

<dd> Index of the first element in the zero-based array to return (ranges from 0 to {{D3D11_1_UAV_SLOT_COUNT}} - 1). </dd>

<dd> Number of views to get (ranges from 0 to {{D3D11_1_UAV_SLOT_COUNT}} - StartSlot). </dd>

<dd> A reference to an array of interface references (see {{ID3D11UnorderedAccessView}}) to get. </dd>

Get the compute shader currently set on the device.

<dd> Address of a reference to a Compute shader (see {{ID3D11ComputeShader}}) to be returned by the method. </dd>

<dd> Pointer to an array of class instance interfaces (see {{ID3D11ClassInstance}}). </dd>

<dd> The number of class-instance elements in the array. </dd>

Get an array of sampler state interfaces from the compute-shader stage.

<dd> Index into a zero-based array to begin getting samplers from (ranges from 0 to {{D3D11_COMMONSHADER_SAMPLER_SLOT_COUNT}} - 1). </dd>

<dd> Pointer to an array of sampler-state interfaces (see {{ID3D11SamplerState}}). </dd>

Get the constant buffers used by the compute-shader stage.

<dd> Index into the device's zero-based array to begin retrieving constant buffers from (ranges from 0 to {{D3D11_COMMONSHADER_CONSTANT_BUFFER_API_SLOT_COUNT}} - 1). </dd>

<dd> Number of buffers to retrieve (ranges from 0 to {{D3D11_COMMONSHADER_CONSTANT_BUFFER_API_SLOT_COUNT}} - StartSlot). </dd>

<dd> Array of constant buffer interface references (see {{ID3D11Buffer}}) to be returned by the method. </dd>

Restore all default settings.

This method resets any device context to the default settings. This sets all input/output resource slots, shaders, input layouts, predications, scissor rectangles, depth-stencil state, rasterizer state, blend state, sampler state, and viewports to {{NULL}}. The primitive topology is set to {{UNDEFINED}}.For a scenario where you would like to clear a list of commands recorded so far, call {{ID3D11DeviceContext::FinishCommandList}} and throw away the resulting {{ID3D11CommandList}}. Returns nothing.

Sends queued-up commands in the command buffer to the graphics processing unit ({{GPU}}).

Most applications don't need to call this method. If an application calls this method when not necessary, it incurs a performance penalty. Each call to Flush incurs a significant amount of overhead.When Microsoft Direct3D state-setting, present, or draw commands are called by an application, those commands are queued into an internal command buffer. Flush sends those commands to the {{GPU}} for processing. Typically, the Direct3D runtime sends these commands to the {{GPU}} automatically whenever the runtime determines that they need to be sent, such as when the command buffer is full or when an application maps a resource. Flush sends the commands manually.We recommend that you use Flush when the {{CPU}} waits for an arbitrary amount of time (such as when you call the Sleep function).Because Flush operates asynchronously, it can return either before or after the {{GPU}} finishes executing the queued graphics commands. However, the graphics commands eventually always complete. You can call the {{ID3D11Device::CreateQuery}} method with the {{D3D11_QUERY_EVENT}} value to create an event query; you can then use that event query in a call to the {{ID3D11DeviceContext::GetData}} method to determine when the {{GPU}} is finished processing the graphics commands. Microsoft Direct3D?11 defers the destruction of objects. Therefore, an application can't rely upon objects immediately being destroyed. By calling Flush, you destroy any objects whose destruction was deferred. If an application requires synchronous destruction of an object, we recommend that the application release all its references, call {{ID3D11DeviceContext::ClearState}}, and then call Flush. This method does not return a value.

Gets the type of device context.

A member of {{D3D11_DEVICE_CONTEXT_TYPE}} that indicates the type of device context.

Gets the initialization flags associated with the current deferred context.

Create a command list and record graphics commands into it.

Create a command list from a deferred context and record commands into it by calling FinishCommandList. Play back a command list with an immediate context by calling {{ID3D11DeviceContext::ExecuteCommandList}}. Immediate context state is cleared before and after a command list is executed. A command list has no concept of inheritance. Each call to FinishCommandList will record only the state set since any previous call to FinishCommandList. For example, the state of a device context is its render state or pipeline state. To retrieve device context state, an application can call {{ID3D11DeviceContext::GetData}} or {{ID3D11DeviceContext::GetPredication}}. For more information about how to use FinishCommandList, see How to: Record a Command List. Windows?Phone?8: This {{API}} is supported. Returns {{S_OK}} if successful; otherwise, returns one of the following:<ul> <li>Returns {{DXGI_ERROR_DEVICE_REMOVED}} if the video card has been physically removed from the system, or a driver upgrade for the video card has occurred. If this error occurs, you should destroy and recreate the device.</li> <li> Returns {{DXGI_ERROR_INVALID_CALL}} if FinishCommandList cannot be called from the current context. See remarks. </li> <li>Returns {{E_OUTOFMEMORY}} if the application has exhausted available memory.</li> </ul>

<dd> A Boolean flag that determines whether the runtime saves deferred context state before it executes FinishCommandList and restores it afterwards. Use {{TRUE}} to indicate that the runtime needs to save and restore the state. Use {{FALSE}} to indicate that the runtime will not save or restore any state. In this case, the deferred context will return to its default state after the call to FinishCommandList completes. For information about default state, see {{ID3D11DeviceContext::ClearState}}. Typically, use {{FALSE}} unless you restore the state to be nearly equivalent to the state that the runtime would restore if you passed {{TRUE}}. When you use {{FALSE}}, you can avoid unnecessary and inefficient state transitions. Note?? This parameter does not affect the command list that the current call to FinishCommandList returns. However, this parameter affects the command list of the next call to FinishCommandList on the same deferred context. ? </dd>

<dd> Upon completion of the method, the passed reference to an {{ID3D11CommandList}} interface reference is initialized with the recorded command list information. The resulting {{ID3D11CommandList}} object is immutable and can only be used with {{ID3D11DeviceContext::ExecuteCommandList}}. </dd>

Represents a hardware-accelerated video decoder for Microsoft Direct3D?11.

To get a reference to this interface, call {{ID3D11VideoDevice::CreateVideoDecoder}}.

Gets the parameters that were used to create the decoder.

If this method succeeds, it returns {{S_OK}}. Otherwise, it returns an {{HRESULT}} error code.

<dd> A reference to a {{D3D11_VIDEO_DECODER_DESC}} structure that receives a description of the video stream. </dd>

<dd> A reference to a {{D3D11_VIDEO_DECODER_CONFIG}} structure that receives the decoder configuration. </dd>

Gets a handle to the driver.

The driver handle can be used to configure content protection. If this method succeeds, it returns {{S_OK}}. Otherwise, it returns an {{HRESULT}} error code.

<dd> Receives a handle to the driver. </dd>

Gets the content description that was used to create this enumerator.

If this method succeeds, it returns {{S_OK}}. Otherwise, it returns an {{HRESULT}} error code.

<dd> A reference to a {{D3D11_VIDEO_PROCESSOR_CONTENT_DESC}} structure that receives the content description. </dd>

Gets the content description that was used to create this enumerator.

If this method succeeds, it returns {{S_OK}}. Otherwise, it returns an {{HRESULT}} error code.

<dd> A reference to a {{D3D11_VIDEO_PROCESSOR_CONTENT_DESC}} structure that receives the content description. </dd>

Queries whether the video processor supports a specified video format.

If this method succeeds, it returns {{S_OK}}. Otherwise, it returns an {{HRESULT}} error code.

<dd> The video format to query, specified as a {{DXGI_FORMAT}} value. </dd>

<dd> Receives a bitwise {{OR}} of zero or more flags from the {{D3D11_VIDEO_PROCESSOR_FORMAT_SUPPORT}} enumeration. </dd>

Gets the capabilities of the video processor.

If this method succeeds, it returns {{S_OK}}. Otherwise, it returns an {{HRESULT}} error code.

<dd> A reference to a {{D3D11_VIDEO_PROCESSOR_CAPS}} structure that receives the capabilities. </dd>

Returns a group of video processor capabilities that are associated with frame-rate conversion, including deinterlacing and inverse telecine.

The capabilities defined in the {{D3D11_VIDEO_PROCESSOR_RATE_CONVERSION_CAPS}} structure are interdependent. Therefore, the driver can support multiple, distinct groups of these capabilities. If this method succeeds, it returns {{S_OK}}. Otherwise, it returns an {{HRESULT}} error code.

<dd> The zero-based index of the group to retrieve. To get the maximum index, call {{ID3D11VideoProcessorEnumerator::GetVideoProcessorCaps}} and check the RateConversionCapsCount member of the {{D3D11_VIDEO_PROCESSOR_CAPS}} structure. </dd>

<dd> A reference to a {{D3D11_VIDEO_PROCESSOR_RATE_CONVERSION_CAPS}} structure that receives the frame-rate conversion capabilities. </dd>

Gets a list of custom frame rates that a video processor supports.

If this method succeeds, it returns {{S_OK}}. Otherwise, it returns an {{HRESULT}} error code.

<dd> The zero-based index of the frame-rate capability group. To get the maxmum index, call {{ID3D11VideoProcessorEnumerator::GetVideoProcessorCaps}} and check the RateConversionCapsCount member of the {{D3D11_VIDEO_PROCESSOR_CAPS}} structure. </dd>

<dd> The zero-based index of the custom rate to retrieve. To get the maximum index, call {{ID3D11VideoProcessorEnumerator::GetVideoProcessorRateConversionCaps}} and check the CustomRateCount member of the {{D3D11_VIDEO_PROCESSOR_RATE_CONVERSION_CAPS}} structure. This index value is always relative to the capability group specified in the TypeIndex parameter. </dd>

<dd> A reference to a {{D3D11_VIDEO_PROCESSOR_CUSTOM_RATE}} structure that receives the custom rate. </dd>

Gets the range of values for an image filter.

If this method succeeds, it returns {{S_OK}}. Otherwise, it returns an {{HRESULT}} error code.

<dd> The type of image filter, specified as a {{D3D11_VIDEO_PROCESSOR_FILTER}} value. </dd>

<dd> A reference to a {{D3D11_VIDEO_PROCESSOR_FILTER_RANGE}} structure. The method fills the structure with the range of values for the specified filter. </dd>

Represents a video processor for Microsoft Direct3D?11.

To get a reference to this interface, call {{ID3D11VideoDevice::CreateVideoProcessor}}.

Gets the content description that was used to create the video processor.

This method does not return a value.

<dd> A reference to a {{D3D11_VIDEO_PROCESSOR_CONTENT_DESC}} structure that receives the content description. </dd>

Gets the rate conversion capabilities of the video processor.

This method does not return a value.

<dd> A reference to a {{D3D11_VIDEO_PROCESSOR_RATE_CONVERSION_CAPS}} structure that receives the rate conversion capabilities. </dd>

Provides a communication channel with the graphics driver or the Microsoft Direct3D runtime.

To get a reference to this interface, call {{ID3D11VideoDevice::CreateAuthenticatedChannel}}.

Gets the size of the driver's certificate chain.

If this method succeeds, it returns {{S_OK}}. Otherwise, it returns an {{HRESULT}} error code.

<dd> Receives the size of the certificate chain, in bytes. </dd>

Gets the driver's certificate chain.

If this method succeeds, it returns {{S_OK}}. Otherwise, it returns an {{HRESULT}} error code.

<dd> The size of the pCertificate array, in bytes. To get the size of the certificate chain, call {{ID3D11CryptoSession::GetCertificateSize}}. </dd>

<dd> A reference to a byte array that receives the driver's certificate chain. The caller must allocate the array. </dd>

Gets a handle to the authenticated channel.

This method does not return a value.

<dd> Receives a handle to the channel. </dd>

Represents a cryptographic session.

To get a reference to this interface, call {{ID3D11VideoDevice::CreateCryptoSession}}.

Gets the type of encryption that is supported by this session.

The application specifies the encryption type when it creates the session. This method does not return a value.

<dd> Receives a {{GUID}} that specifies the encryption type. The following {{GUIDs}} are defined. <table> <tr><th>Value</th><th>Meaning</th></tr> <tr><td><dl> <dt>{{D3D11_CRYPTO_TYPE_AES128_CTR}}</dt> </dl> </td><td> 128-bit Advanced Encryption Standard {{CTR}} mode ({{AES}}-{{CTR}}) block cipher. </td></tr> </table> ? </dd>

Gets the decoding profile of the session.

The application specifies the profile when it creates the session. This method does not return a value.

<dd> Receives the decoding profile. For a list of possible values, see {{ID3D11VideoDevice::GetVideoDecoderProfile}}. </dd>

Gets the size of the driver's certificate chain.

To get the certificate, call {{ID3D11CryptoSession::GetCertificate}}. If this method succeeds, it returns {{S_OK}}. Otherwise, it returns an {{HRESULT}} error code.

<dd> Receives the size of the certificate chain, in bytes. </dd>

Gets the driver's certificate chain.

If this method succeeds, it returns {{S_OK}}. Otherwise, it returns an {{HRESULT}} error code.

<dd> The size of the pCertificate array, in bytes. To get the size of the certificate chain, call {{ID3D11CryptoSession::GetCertificateSize}}. </dd>

<dd> A reference to a byte array that receives the driver's certificate chain. The caller must allocate the array. </dd>

Gets a handle to the cryptographic session.

You can use this handle to associate the session with a decoder. This enables the decoder to decrypt data that is encrypted using this session. This method does not return a value.

<dd> Receives a handle to the session. </dd>

Identifies the output surfaces that can be accessed during video decoding.

To get a reference to this interface, call {{ID3D11VideoDevice::CreateVideoDecoderOutputView}}.

Gets the properties of the video decoder output view.

This method does not return a value.

<dd> A reference to a {{D3D11_VIDEO_DECODER_OUTPUT_VIEW_DESC}} structure. The method fills the structure with the view properties. </dd>

Identifies the input surfaces that can be accessed during video processing.

To get a reference to this interface, call {{ID3D11VideoDevice::CreateVideoProcessorInputView}}.

Gets the properties of the video processor input view.

This method does not return a value.

<dd> A reference to a {{D3D11_VIDEO_PROCESSOR_INPUT_VIEW_DESC}} structure. The method fills the structure with the view properties. </dd>

Identifies the output surfaces that can be accessed during video processing.

To get a reference to this interface, call {{ID3D11VideoDevice::CreateVideoProcessorOutputView}}.

Gets the properties of the video processor output view.

This method does not return a value.

<dd> A reference to a {{D3D11_VIDEO_PROCESSOR_OUTPUT_VIEW_DESC}} structure. The method fills the structure with the view properties. </dd>

Provides the video functionality of a Microsoft Direct3D?11 device.

To get a reference to this interface, call QueryInterface with an {{ID3D11DeviceContext}} interface reference.This interface provides access to several areas of Microsoft Direct3D video functionality:<ul> <li>Hardware-accelerated video decoding</li> <li>Video processing</li> <li>{{GPU}}-based content protection</li> <li>Video encryption and decryption</li> </ul>In Microsoft Direct3D?9, the equivalent functions were distributed across several interfaces:<ul> <li> {{IDirect3DAuthenticatedChannel9}} </li> <li> {{IDirect3DCryptoSession9}} </li> <li> {{IDirectXVideoDecoder}} </li> <li> {{IDirectXVideoProcessor}} </li> <li> {{IDXVAHD_VideoProcessor}} </li> </ul>

Gets a reference to a decoder buffer.

The graphics driver allocates the buffers that are used for decoding. This method locks the Microsoft Direct3D surface that contains the buffer. When you are done using the buffer, call {{ID3D11VideoContext::ReleaseDecoderBuffer}} to unlock the surface. If this method succeeds, it returns {{S_OK}}. Otherwise, it returns an {{HRESULT}} error code.

<dd> A reference to the {{ID3D11VideoDecoder}} interface. To get this reference, call {{ID3D11VideoDevice::CreateVideoDecoder}}. </dd>

<dd> The type of buffer to retrieve, specified as a member of the {{D3D11_VIDEO_DECODER_BUFFER_TYPE}} enumeration. </dd>

<dd> Receives the size of the buffer, in bytes. </dd>

<dd> Receives a reference to the start of the memory buffer. </dd>

Releases a buffer that was obtained by calling the {{ID3D11VideoContext::GetDecoderBuffer}} method.

If this method succeeds, it returns {{S_OK}}. Otherwise, it returns an {{HRESULT}} error code.

Starts a decoding operation to decode a video frame.

After this method is called, call {{ID3D11VideoContext::SubmitDecoderBuffers}} to perform decoding operations. When all decoding operations have been executed, call {{ID3D11VideoContext::DecoderEndFrame}}. Each call to DecoderBeginFrame must have a matching call to DecoderEndFrame. In most cases you cannot nest DecoderBeginFrame calls, but some codecs, such as like {{VC}}-1, can have nested DecoderBeginFrame calls for special operations like post processing.The following encryption scenarios are supported through the content key:<ul> <li>The decoder can choose to not encrypt every frame, for example it may only encrypt the I frames and not encrypt the P/B frames. In these scenario, the decoder will specify pContentKey = {{NULL}} and ContentKeySize = 0 for those frames that it does not encrypt.</li> <li>The decoder can choose to encrypt the compressed buffers using the session key. In this scenario, the decoder will specify a content key containing all zeros.</li> <li>The decoder can choose to encrypt the compressed buffers using a separate content key. In this scenario, the decoder will {{ECB}} encrypt the content key using the session key and pass the encrypted content key.</li> </ul> If this method succeeds, it returns {{S_OK}}. Otherwise, it returns an {{HRESULT}} error code. {{D3DERR_WASSTILLDRAWING}} or {{E_PENDING}} is returned if the harware is busy, in which case the decoder should try to make the call again.

<dd> A reference to the {{ID3D11VideoDecoder}} interface. To get this reference, call {{ID3D11VideoDevice::CreateVideoDecoder}}. </dd>

<dd> A reference to the {{ID3D11VideoDecoderOutputView}} interface. This interface describes the resource that will receive the decoded frame. To get this reference, call {{ID3D11VideoDevice::CreateVideoDecoderOutputView}}. </dd>

<dd> The size of the content key that is specified in pContentKey. If pContentKey is {{NULL}}, set ContentKeySize to zero. </dd>

<dd> An optional reference to a content key that was used to encrypt the frame data. If no content key was used, set this parameter to {{NULL}}. If the caller provides a content key, the caller must use the session key to encrypt the content key. </dd>

Signals the end of a decoding operation.

If this method succeeds, it returns {{S_OK}}. Otherwise, it returns an {{HRESULT}} error code.

<dd> A reference to the {{ID3D11VideoDecoder}} interface. To get this reference, call {{ID3D11VideoDevice::CreateVideoDecoder}}. </dd>

Submits one or more buffers for decoding.

This function does not honor a {{D3D11}} predicate that may have been set.If the application uses {{D3D11}} quries, this function may not be accounted for with {{D3D11_QUERY_EVENT}} and {{D3D11_QUERY_TIMESTAMP}} when using feature levels lower than 11. {{D3D11_QUERY_PIPELINE_STATISTICS}} will not include this function for any feature level.When using feature levels 9_x, all partially encrypted buffers must use the same EncryptedBlockInfo, and partial encryption cannot be turned off on a per frame basis. If this method succeeds, it returns {{S_OK}}. Otherwise, it returns an {{HRESULT}} error code.

<dd> A reference to the {{ID3D11VideoDecoder}} interface. To get this reference, call the {{ID3D11VideoDevice::CreateVideoDecoder}} method. </dd>

<dd> The number of buffers submitted for decoding. </dd>

<dd> A reference to an array of {{D3D11_VIDEO_DECODER_BUFFER_DESC}} structures. The NumBuffers parameter specifies the number of elements in the array. Each element in the array describes a compressed buffer for decoding. </dd>

Performs an extended function for decoding. This method enables extensions to the basic decoder functionality.

If this method succeeds, it returns {{S_OK}}. Otherwise, it returns an {{HRESULT}} error code.

<dd> A reference to the {{ID3D11VideoDecoder}} interface. To get this reference, call {{ID3D11VideoDevice::CreateVideoDecoder}}. </dd>

<dd> A reference to a {{D3D11_VIDEO_DECODER_EXTENSION}} structure that contains data for the function. </dd>

Sets the target rectangle for the video processor.

The target rectangle is the area within the destination surface where the output will be drawn. The target rectangle is given in pixel coordinates, relative to the destination surface.If this method is never called, or if the Enable parameter is {{FALSE}}, the video processor writes to the entire destination surface. This method does not return a value.

<dd> A reference to the {{ID3D11VideoProcessor}} interface. To get this reference, call {{ID3D11VideoDevice::CreateVideoProcessor}}. </dd>

<dd> Specifies whether to apply the target rectangle. </dd>

<dd> A reference to a {{RECT}} structure that specifies the target rectangle. If Enable is {{FALSE}}, this parameter is ignored. </dd>

Sets the background color for the video processor.

The video processor uses the background color to fill areas of the target rectangle that do not contain a video image. Areas outside the target rectangle are not affected. This method does not return a value.

<dd> A reference to the {{ID3D11VideoProcessor}} interface. To get this reference, call {{ID3D11VideoDevice::CreateVideoProcessor}}. </dd>

<dd> If {{TRUE}}, the color is specified as a {{YCbCr}} value. Otherwise, the color is specified as an {{RGB}} value. </dd>

<dd> A reference to a {{D3D11_VIDEO_COLOR}} structure that specifies the background color. </dd>

Sets the output color space for the video processor.

This method does not return a value.

<dd> A reference to the {{ID3D11VideoProcessor}} interface. To get this reference, call {{ID3D11VideoDevice::CreateVideoProcessor}}. </dd>

<dd> A reference to a {{D3D11_VIDEO_PROCESSOR_COLOR_SPACE}} structure that specifies the color space. </dd>

Sets the alpha fill mode for data that the video processor writes to the render target.

To find out which fill modes the device supports, call the {{ID3D11VideoProcessorEnumerator::GetVideoProcessorCaps}} method. If the driver reports the {{D3D11_VIDEO_PROCESSOR_FEATURE_CAPS_ALPHA_FILL}} capability, the driver supports all of the fill modes. Otherwise, the AlphaFillMode parameter must be {{D3D11_VIDEO_PROCESSOR_ALPHA_FILL_MODE_OPAQUE}}. The default fill mode is {{D3D11_VIDEO_PROCESSOR_ALPHA_FILL_MODE_OPAQUE}}. This method does not return a value.

<dd> A reference to the {{ID3D11VideoProcessor}} interface. To get this reference, call {{ID3D11VideoDevice::CreateVideoProcessor}}. </dd>

<dd> The alpha fill mode, specified as a {{D3D11_VIDEO_PROCESSOR_ALPHA_FILL_MODE}} value. </dd>

<dd> The zero-based index of an input stream. This parameter is used if AlphaFillMode is {{D3D11_VIDEO_PROCESSOR_ALPHA_FILL_MODE_SOURCE_STREAM}}. Otherwise, the parameter is ignored. </dd>

Sets the amount of downsampling to perform on the output.

Downsampling is sometimes used to reduce the quality of premium content when other forms of content protection are not available. By default, downsampling is disabled.If the Enable parameter is {{TRUE}}, the driver downsamples the composed image to the specified size, and then scales it back to the size of the target rectangle.The width and height of Size must be greater than zero. If the size is larger than the target rectangle, downsampling does not occur.To use this feature, the driver must support downsampling, indicated by the {{D3D11_VIDEO_PROCESSOR_FEATURE_CAPS_CONSTRICTION}} capability flag. To query for this capability, call {{ID3D11VideoProcessorEnumerator::GetVideoProcessorCaps}}. This method does not return a value.

<dd> A reference to the {{ID3D11VideoProcessor}} interface. To get this reference, call {{ID3D11VideoDevice::CreateVideoProcessor}}. </dd>

<dd> If {{TRUE}}, downsampling is enabled. Otherwise, downsampling is disabled and the Size member is ignored. </dd>

<dd> The sampling size. </dd>

Specifies whether the video processor produces stereo video frames.

By default, the video processor produces mono video frames.To use this feature, the driver must support stereo video, indicated by the {{D3D11_VIDEO_PROCESSOR_FEATURE_CAPS_STEREO}} capability flag. To query for this capability, call {{ID3D11VideoProcessorEnumerator::GetVideoProcessorCaps}}. This method does not return a value.

<dd> A reference to the {{ID3D11VideoProcessor}} interface. To get this reference, call {{ID3D11VideoDevice::CreateVideoProcessor}}. </dd>

<dd> If {{TRUE}}, stereo output is enabled. Otherwise, the video processor produces mono video frames. </dd>

Sets a driver-specific video processing state.

If this method succeeds, it returns {{S_OK}}. Otherwise, it returns an {{HRESULT}} error code.

<dd> A reference to the {{ID3D11VideoProcessor}} interface. To get this reference, call {{ID3D11VideoDevice::CreateVideoProcessor}}. </dd>

<dd> A reference to a {{GUID}} that identifies the operation. The meaning of this {{GUID}} is defined by the graphics driver. </dd>

<dd> The size of the pData buffer, in bytes. </dd>

<dd> A reference to a buffer that contains private state data. The method passes this buffer directly to the driver without validation. It is the responsibility of the driver to validate the data. </dd>

Gets the current target rectangle for the video processor.

This method does not return a value.

<dd> A reference to the {{ID3D11VideoProcessor}} interface. To get this reference, call {{ID3D11VideoDevice::CreateVideoProcessor}}. </dd>

<dd> Receives the value {{TRUE}} if the target rectangle was explicitly set using the {{ID3D11VideoContext::VideoProcessorSetOutputTargetRect}} method. Receives the value {{FALSE}} if the target rectangle was disabled or was never set. </dd>

<dd> If Enabled receives the value {{TRUE}}, this parameter receives the target rectangle. Otherwise, this parameter is ignored. </dd>

Gets the current background color for the video processor.

This method does not return a value.

<dd> A reference to the {{ID3D11VideoProcessor}} interface. To get this reference, call {{ID3D11VideoDevice::CreateVideoProcessor}}. </dd>

<dd> Receives the value {{TRUE}} if the background color is a {{YCbCr}} color, or {{FALSE}} if the background color is an {{RGB}} color. </dd>

<dd> A reference to a {{D3D11_VIDEO_COLOR}} structure. The method fills in the structure with the background color. </dd>

Gets the current output color space for the video processor.

This method does not return a value.

<dd> A reference to the {{ID3D11VideoProcessor}} interface. To get this reference, call {{ID3D11VideoDevice::CreateVideoProcessor}}. </dd>

<dd> A reference to a {{D3D11_VIDEO_PROCESSOR_COLOR_SPACE}} structure. The method fills in the structure with the output color space. </dd>

Gets the current alpha fill mode for the video processor.

This method does not return a value.

<dd> A reference to the {{ID3D11VideoProcessor}} interface. To get this reference, call {{ID3D11VideoDevice::CreateVideoProcessor}}. </dd>

<dd> Receives the alpha fill mode, as a {{D3D11_VIDEO_PROCESSOR_ALPHA_FILL_MODE}} value. </dd>

<dd> If the alpha fill mode is {{D3D11_VIDEO_PROCESSOR_ALPHA_FILL_MODE_SOURCE_STREAM}}, this parameter receives the zero-based index of an input stream. The input stream provides the alpha values for the alpha fill. </dd>

Gets the current level of downsampling that is performed by the video processor.

This method does not return a value.

<dd> A reference to the {{ID3D11VideoProcessor}} interface. To get this reference, call {{ID3D11VideoDevice::CreateVideoProcessor}}. </dd>

<dd> Receives the value {{TRUE}} if downsampling was explicitly enabled using the {{ID3D11VideoContext::VideoProcessorSetOutputConstriction}} method. Receives the value {{FALSE}} if the downsampling was disabled or was never set. </dd>

<dd> If Enabled receives the value {{TRUE}}, this parameter receives the downsampling size. Otherwise, this parameter is ignored. </dd>

Queries whether the video processor produces stereo video frames.

This method does not return a value.

<dd> A reference to the {{ID3D11VideoProcessor}} interface. To get this reference, call {{ID3D11VideoDevice::CreateVideoProcessor}}. </dd>

<dd> Receives the value {{TRUE}} if stereo output is enabled, or {{FALSE}} otherwise. </dd>

Gets private state data from the video processor.

If this method succeeds, it returns {{S_OK}}. Otherwise, it returns an {{HRESULT}} error code.

<dd> A reference to the {{ID3D11VideoProcessor}} interface. To get this reference, call {{ID3D11VideoDevice::CreateVideoProcessor}}. </dd>

<dd> A reference to a {{GUID}} that identifies the state. The meaning of this {{GUID}} is defined by the graphics driver. </dd>

<dd> The size of the pData buffer, in bytes. </dd>

<dd> A reference to a buffer that receives the private state data. </dd>

Specifies whether an input stream on the video processor contains interlaced or progressive frames.

This method does not return a value.

<dd> A reference to the {{ID3D11VideoProcessor}} interface. To get this reference, call {{ID3D11VideoDevice::CreateVideoProcessor}}. </dd>

<dd> The zero-based index of the input stream. To get the maximum number of streams, call {{ID3D11VideoProcessorEnumerator::GetVideoProcessorCaps}} and check the MaxStreamStates structure member. </dd>

<dd> A {{D3D11_VIDEO_FRAME_FORMAT}} value that specifies the interlacing. </dd>

Sets the color space for an input stream on the video processor.

This method does not return a value.

<dd> A reference to the {{ID3D11VideoProcessor}} interface. To get this reference, call {{ID3D11VideoDevice::CreateVideoProcessor}}. </dd>

<dd> A reference to a {{D3D11_VIDEO_PROCESSOR_COLOR_SPACE}} structure that specifies the color space. </dd>

Sets the rate at which the video processor produces output frames for an input stream.

The standard output rates are normal frame-rate ({{D3D11_VIDEO_PROCESSOR_OUTPUT_RATE_NORMAL}}) and half frame-rate ({{D3D11_VIDEO_PROCESSOR_OUTPUT_RATE_HALF}}). In addition, the driver might support custom rates for rate conversion or inverse telecine. To get the list of custom rates, call {{ID3D11VideoProcessorEnumerator::GetVideoProcessorCustomRate}}.Depending on the output rate, the driver might need to convert the frame rate. If so, the value of RepeatFrame controls whether the driver creates interpolated frames or simply repeats input frames. This method does not return a value.

<dd> A reference to the {{ID3D11VideoProcessor}} interface. To get this reference, call {{ID3D11VideoDevice::CreateVideoProcessor}}. </dd>

<dd> The output rate, specified as a {{D3D11_VIDEO_PROCESSOR_OUTPUT_RATE}} value. </dd>

<dd> Specifies how the driver performs frame-rate conversion, if required. <table> <tr><th>Value</th><th>Meaning</th></tr> <tr><td><dl> <dt>{{TRUE}}</dt> </dl> </td><td> Repeat frames. </td></tr> <tr><td><dl> <dt>{{FALSE}}</dt> </dl> </td><td> Interpolate frames. </td></tr> </table> ? </dd>

<dd> A reference to a {{DXGI_RATIONAL}} structure. If OutputRate is {{D3D11_VIDEO_PROCESSOR_OUTPUT_RATE_CUSTOM}}, this parameter specifies the exact output rate. Otherwise, this parameter is ignored and can be {{NULL}}. </dd>

Sets the source rectangle for an input stream on the video processor.

The source rectangle is the portion of the input surface that is blitted to the destination surface. The source rectangle is given in pixel coordinates, relative to the input surface.If this method is never called, or if the Enable parameter is {{FALSE}}, the video processor reads from the entire input surface. This method does not return a value.

<dd> A reference to the {{ID3D11VideoProcessor}} interface. To get this reference, call {{ID3D11VideoDevice::CreateVideoProcessor}}. </dd>

<dd> Specifies whether to apply the source rectangle. </dd>

<dd> A reference to a {{RECT}} structure that specifies the source rectangle. If Enable is {{FALSE}}, this parameter is ignored. </dd>

Sets the destination rectangle for an input stream on the video processor.

The destination rectangle is the portion of the output surface that receives the blit for this stream. The destination rectangle is given in pixel coordinates, relative to the output surface.The default destination rectangle is an empty rectangle (0, 0, 0, 0). If this method is never called, or if the Enable parameter is {{FALSE}}, no data is written from this stream. This method does not return a value.

<dd> A reference to the {{ID3D11VideoProcessor}} interface. To get this reference, call {{ID3D11VideoDevice::CreateVideoProcessor}}. </dd>

<dd> Specifies whether to apply the destination rectangle. </dd>

<dd> A reference to a {{RECT}} structure that specifies the destination rectangle. If Enable is {{FALSE}}, this parameter is ignored. </dd>

Sets the planar alpha for an input stream on the video processor.

To use this feature, the driver must support stereo video, indicated by the {{D3D11_VIDEO_PROCESSOR_FEATURE_CAPS_ALHPA_STREAM}} capability flag. To query for this capability, call {{ID3D11VideoProcessorEnumerator::GetVideoProcessorCaps}}.Alpha blending is disabled by default. For each pixel, the destination color value is computed as follows:<code>Cd = Cs * (As * Ap * Ae) + Cd * (1.0 - As * Ap * Ae)</code>where:<ul> <li><code>Cd</code> = The color value of the destination pixel</li> <li><code>Cs</code> = The color value of the source pixel</li> <li><code>As</code> = The per-pixel source alpha</li> <li><code>Ap</code> = The planar alpha value</li> <li><code>Ae</code> = The palette-entry alpha value, or 1.0 (see Note)</li> </ul>Note??Palette-entry alpha values apply only to palettized color formats, and only when the device supports the {{D3D11_VIDEO_PROCESSOR_FEATURE_CAPS_ALPHA_PALETTE}} capability. Otherwise, this factor equals 1.0.?The destination alpha value is computed according to the alpha fill mode. For more information, see {{ID3D11VideoContext::VideoProcessorSetOutputAlphaFillMode}}. This method does not return a value.

<dd> A reference to the {{ID3D11VideoProcessor}} interface. To get this reference, call {{ID3D11VideoDevice::CreateVideoProcessor}}. </dd>

<dd> Specifies whether alpha blending is enabled. </dd>

<dd> The planar alpha value. The value can range from 0.0 (transparent) to 1.0 (opaque). If Enable is {{FALSE}}, this parameter is ignored. </dd>

Sets the color-palette entries for an input stream on the video processor.

This method applies only to input streams that have a palettized color format. Palettized formats with 4 bits per pixel (bpp) use the first 16 entries in the list. Formats with 8 bpp use the first 256 entries.If a pixel has a palette index greater than the number of entries, the device treats the pixel as white with opaque alpha. For full-range {{RGB}}, this value is (255, 255, 255, 255); for {{YCbCr}} the value is (255, 235, 128, 128).If the driver does not report the {{D3D11_VIDEO_PROCESSOR_FEATURE_CAPS_ALPHA_PALETTE}} capability flag, every palette entry must have an alpha value of 0xFF (opaque). To query for this capability, call {{ID3D11VideoProcessorEnumerator::GetVideoProcessorCaps}}. This method does not return a value.

<dd> A reference to the {{ID3D11VideoProcessor}} interface. To get this reference, call {{ID3D11VideoDevice::CreateVideoProcessor}}. </dd>

<dd> The number of elements in the pEntries array. </dd>

<dd> A reference to an array of palette entries. For {{RGB}} streams, the palette entries use the {{DXGI_FORMAT_B8G8R8A8}} representation. For {{YCbCr}} streams, the palette entries use the {{DXGI_FORMAT_AYUV}} representation. The caller allocates the array. </dd>

Sets the pixel aspect ratio for an input stream on the video processor.

This function can only be called if the driver reports the {{D3D11_VIDEO_PROCESSOR_FEATURE_CAPS_PIXEL_ASPECT_RATIO}} capability. If this capability is not set, this function will have no effect.Pixel aspect ratios of the form 0/n and n/0 are not valid.The default pixel aspect ratio is 1:1 (square pixels). This method does not return a value.

<dd> A reference to the {{ID3D11VideoProcessor}} interface. To get this reference, call {{ID3D11VideoDevice::CreateVideoProcessor}}. </dd>

<dd> Specifies whether the pSourceAspectRatio and pDestinationAspectRatio parameters contain valid values. Otherwise, the pixel aspect ratios are unspecified. </dd>

<dd> A reference to a {{DXGI_RATIONAL}} structure that contains the pixel aspect ratio of the source rectangle. If Enable is {{FALSE}}, this parameter can be {{NULL}}. </dd>

<dd> A reference to a {{DXGI_RATIONAL}} structure that contains the pixel aspect ratio of the destination rectangle. If Enable is {{FALSE}}, this parameter can be {{NULL}}. </dd>

Sets the luma key for an input stream on the video processor.

To use this feature, the driver must support luma keying, indicated by the {{D3D11_VIDEO_PROCESSOR_FEATURE_CAPS_LUMA_KEY}} capability flag. To query for this capability, call {{ID3D11VideoProcessorEnumerator::GetVideoProcessorCaps}}. In addition, if the input format is {{RGB}}, the device must support the {{D3D11_VIDEO_PROCESSOR_FORMAT_CAPS_RGB_LUMA_KEY}} capability.The values of Lower and Upper give the lower and upper bounds of the luma key, using a nominal range of [0...1]. Given a format with n bits per channel, these values are converted to luma values as follows:<code>val = f * ((1 << n)-1)</code>Any pixel whose luma value falls within the upper and lower bounds (inclusive) is treated as transparent.For example, if the pixel format uses 8-bit luma, the upper bound is calculated as follows:<code>{{BYTE}} Y = {{BYTE}}(max(min(1.0, Upper), 0.0) * 255.0)</code>Note that the value is clamped to the range [0...1] before multiplying by 255. This method does not return a value.

<dd> A reference to the {{ID3D11VideoProcessor}} interface. To get this reference, call {{ID3D11VideoDevice::CreateVideoProcessor}}. </dd>

<dd> Specifies whether luma keying is enabled. </dd>

<dd> The lower bound for the luma key. The valid range is [0?1]. If Enable is {{FALSE}}, this parameter is ignored. </dd>

<dd> The upper bound for the luma key. The valid range is [0?1]. If Enable is {{FALSE}}, this parameter is ignored. </dd>

Enables or disables stereo 3D video for an input stream on the video processor. In addition, this method specifies the layout of the video frames in memory.

This method does not return a value.

<dd> A reference to the {{ID3D11VideoProcessor}} interface. To get this reference, call {{ID3D11VideoDevice::CreateVideoProcessor}}. </dd>

<dd> Specifies whether stereo 3D is enabled for this stream. If the value is {{FALSE}}, the remaining parameters of this method are ignored. </dd>

<dd> Specifies the layout of the two stereo views in memory, as a {{D3D11_VIDEO_PROCESSOR_STEREO_FORMAT}} value. </dd>

<dd> If {{TRUE}}, frame 0 contains the left view. Otherwise, frame 0 contains the right view. This parameter is ignored for the following stereo formats: <ul> <li>{{D3D11_VIDEO_PROCESSOR_STEREO_FORMAT_MONO}} </li> <li>{{D3D11_VIDEO_PROCESSOR_STEREO_FORMAT_MONO_OFFSET}}</li> </ul> </dd>

<dd> If {{TRUE}}, frame 0 contains the base view. Otherwise, frame 1 contains the base view. This parameter is ignored for the following stereo formats: <ul> <li>{{D3D11_VIDEO_PROCESSOR_STEREO_FORMAT_MONO}} </li> <li>{{D3D11_VIDEO_PROCESSOR_STEREO_FORMAT_MONO_OFFSET}}</li> <li>When {{D3D11_VIDEO_PROCESSOR_STEREO_FORMAT_SEPARATE}} is used and the application wants to convert the stereo data to mono, it can either:<ul> <li>Specify the base view as a mono input.</li> <li>Specify both resources and allow the driver to do the conversion from the base view. In this case, {{D3D11_VIDEO_PROCESSOR_STREAM}}.hInputSurface is considered frame 0 and {{D3D11_VIDEO_PROCESSOR_STREAM}}.hInputSurfaceRight is considered frame 1.</li> </ul> </li> </ul> </dd>

<dd> A flag from the {{D3D11_VIDEO_PROCESSOR_STEREO_FLIP_MODE}} enumeration, specifying whether one of the views is flipped. </dd>

<dd> For {{D3D11_VIDEO_PROCESSOR_STEREO_FORMAT_MONO_OFFSET}} format, this parameter specifies how to generate the left and right views: <ul> <li>If MonoOffset is positive, the right view is shifted to the right by that many pixels, and the left view is shifted to the left by the same amount. </li> <li>If MonoOffset is negative, the right view is shifted to the left by that many pixels, and the left view is shifted to right by the same amount.</li> </ul> If Format is not {{D3D11_VIDEO_PROCESSOR_STEREO_FORMAT_MONO_OFFSET}}, this parameter must be zero. </dd>

Enables or disables automatic processing features on the video processor.

By default, the driver might perform certain processing tasks automatically during the video processor blit. This method enables the application to disable these extra video processing features. For example, if you provide your own pixel shader for the video processor, you might want to disable the driver's automatic processing. This method does not return a value.

<dd> A reference to the {{ID3D11VideoProcessor}} interface. To get this reference, call {{ID3D11VideoDevice::CreateVideoProcessor}}. </dd>

<dd> If {{TRUE}}, automatic processing features are enabled. If {{FALSE}}, the driver disables any extra video processing that it might be performing. </dd>

Enables or disables an image filter for an input stream on the video processor.

This method does not return a value.

<dd> A reference to the {{ID3D11VideoProcessor}} interface. To get this reference, call {{ID3D11VideoDevice::CreateVideoProcessor}}. </dd>

<dd> The filter, specified as a {{D3D11_VIDEO_PROCESSOR_FILTER}} value. To query which filters the driver supports, call {{ID3D11VideoProcessorEnumerator::GetVideoProcessorCaps}}. </dd>

<dd> Specifies whether to enable the filter. </dd>

<dd> The filter level. If Enable is {{FALSE}}, this parameter is ignored. To find the valid range of levels for a specified filter, call {{ID3D11VideoProcessorEnumerator::GetVideoProcessorFilterRange}}. </dd>

Sets a driver-specific state on a video processing stream.

If this method succeeds, it returns {{S_OK}}. Otherwise, it returns an {{HRESULT}} error code.

<dd> A reference to the {{ID3D11VideoProcessor}} interface. To get this reference, call {{ID3D11VideoDevice::CreateVideoProcessor}}. </dd>

<dd> A reference to a {{GUID}} that identifies the operation. The meaning of this {{GUID}} is defined by the graphics driver. </dd>

<dd> The size of the pData buffer, in bytes. </dd>

Gets the format of an input stream on the video processor.

This method does not return a value.

<dd> A reference to the {{ID3D11VideoProcessor}} interface. To get this reference, call {{ID3D11VideoDevice::CreateVideoProcessor}}. </dd>

<dd> Receives a {{D3D11_VIDEO_FRAME_FORMAT}} value that specifies whether the stream contains interlaced or progressive frames. </dd>

Gets the color space for an input stream of the video processor.

This method does not return a value.

<dd> A reference to the {{ID3D11VideoProcessor}} interface. To get this reference, call {{ID3D11VideoDevice::CreateVideoProcessor}}. </dd>

<dd> Receives a {{D3D11_VIDEO_PROCESSOR_COLOR_SPACE}} value that specifies the color space. </dd>

Gets the rate at which the video processor produces output frames for an input stream.

This method does not return a value.

<dd> A reference to the {{ID3D11VideoProcessor}} interface. To get this reference, call {{ID3D11VideoDevice::CreateVideoProcessor}}. </dd>

<dd> Receives a {{D3D11_VIDEO_PROCESSOR_OUTPUT_RATE}} value that specifies the output rate. </dd>

<dd> Receives a Boolean value that specifies how the driver performs frame-rate conversion, if required. <table> <tr><th>Value</th><th>Meaning</th></tr> <tr><td><dl> <dt>{{TRUE}}</dt> </dl> </td><td> Repeat frames. </td></tr> <tr><td><dl> <dt>{{FALSE}}</dt> </dl> </td><td> Interpolate frames. </td></tr> </table> ? </dd>

<dd> A reference to a {{DXGI_RATIONAL}} structure. If the output rate is {{D3D11_VIDEO_PROCESSOR_OUTPUT_RATE_CUSTOM}}, the method fills in this structure with the exact output rate. Otherwise, this parameter is ignored. </dd>

Gets the source rectangle for an input stream on the video processor.

This method does not return a value.

<dd> A reference to the {{ID3D11VideoProcessor}} interface. To get this reference, call {{ID3D11VideoDevice::CreateVideoProcessor}}. </dd>

<dd> Receives the value {{TRUE}} if the source rectangle is enabled, or {{FALSE}} otherwise. </dd>

<dd> A reference to a {{RECT}} structure that receives the source rectangle. </dd>

Gets the destination rectangle for an input stream on the video processor.

This method does not return a value.

<dd> A reference to the {{ID3D11VideoProcessor}} interface. To get this reference, call {{ID3D11VideoDevice::CreateVideoProcessor}}. </dd>

<dd> Receives the value {{TRUE}} if the destination rectangle is enabled, or {{FALSE}} otherwise. </dd>

<dd> A reference to a {{RECT}} structure that receives the destination rectangle. </dd>

Gets the planar alpha for an input stream on the video processor.

This method does not return a value.

<dd> A reference to the {{ID3D11VideoProcessor}} interface. To get this reference, call {{ID3D11VideoDevice::CreateVideoProcessor}}. </dd>

<dd> Receives the value {{TRUE}} if planar alpha is enabled, or {{FALSE}} otherwise. </dd>

<dd> Receives the planar alpha value. The value can range from 0.0 (transparent) to 1.0 (opaque). </dd>

Gets the color-palette entries for an input stream on the video processor.

This method applies only to input streams that have a palettized color format. Palettized formats with 4 bits per pixel (bpp) use 16 palette entries. Formats with 8 bpp use 256 entries. This method does not return a value.

<dd> A reference to the {{ID3D11VideoProcessor}} interface. To get this reference, call {{ID3D11VideoDevice::CreateVideoProcessor}}. </dd>

<dd> The number of entries in the pEntries array. </dd>

<dd> A reference to a {{UINT}} array allocated by the caller. The method fills the array with the palette entries. For {{RGB}} streams, the palette entries use the {{DXGI_FORMAT_B8G8R8A8}} representation. For {{YCbCr}} streams, the palette entries use the {{DXGI_FORMAT_AYUV}} representation. </dd>

Gets the pixel aspect ratio for an input stream on the video processor.

When the method returns, if *pEnabled is {{TRUE}}, the pSourceAspectRatio and pDestinationAspectRatio parameters contain the pixel aspect ratios. Otherwise, the default pixel aspect ratio is 1:1 (square pixels). This method does not return a value.

<dd> A reference to the {{ID3D11VideoProcessor}} interface. To get this reference, call {{ID3D11VideoDevice::CreateVideoProcessor}}. </dd>

<dd> Receives the value {{TRUE}} if the pixel aspect ratio is specified. Otherwise, receives the value {{FALSE}}. </dd>

<dd> A reference to a {{DXGI_RATIONAL}} structure. If *pEnabled is {{TRUE}}, this parameter receives the pixel aspect ratio of the source rectangle. </dd>

Gets the luma key for an input stream of the video processor.

This method does not return a value.

<dd> A reference to the {{ID3D11VideoProcessor}} interface. To get this reference, call {{ID3D11VideoDevice::CreateVideoProcessor}}. </dd>

<dd> Receives the value {{TRUE}} if luma keying is enabled, or {{FALSE}} otherwise. </dd>

<dd> Receives the lower bound for the luma key. The valid range is [0?1]. </dd>

<dd> Receives the upper bound for the luma key. The valid range is [0?1]. </dd>

Gets the stereo 3D format for an input stream on the video processor

This method does not return a value.

<dd> A reference to the {{ID3D11VideoProcessor}} interface. To get this reference, call {{ID3D11VideoDevice::CreateVideoProcessor}}. </dd>

<dd> Receives the value {{TRUE}} if stereo 3D is enabled for this stream, or {{FALSE}} otherwise. If the value is {{FALSE}}, ignore the remaining parameters. </dd>

<dd> Receives a {{D3D11_VIDEO_PROCESSOR_STEREO_FORMAT}} value that specifies the layout of the two stereo views in memory. </dd>

<dd> Receives a Boolean value. <table> <tr><th>Value</th><th>Meaning</th></tr> <tr><td><dl> <dt>{{TRUE}}</dt> </dl> </td><td> Frame 0 contains the left view. </td></tr> <tr><td><dl> <dt>{{FALSE}}</dt> </dl> </td><td> Frame 0 contains the right view. </td></tr> </table> ? </dd>

<dd> Receives a Boolean value. <table> <tr><th>Value</th><th>Meaning</th></tr> <tr><td><dl> <dt>{{TRUE}}</dt> </dl> </td><td> Frame 0 contains the base view. </td></tr> <tr><td><dl> <dt>{{FALSE}}</dt> </dl> </td><td> Frame 1 contains the base view. </td></tr> </table> ? </dd>

<dd> Receives a {{D3D11_VIDEO_PROCESSOR_STEREO_FLIP_MODE}} value. This value specifies whether one of the views is flipped. </dd>

<dd> Receives the pixel offset used for {{D3D11_VIDEO_PROCESSOR_STEREO_FORMAT_MONO_OFFSET}} format. This parameter is ignored for other stereo formats. </dd>

Queries whether automatic processing features of the video processor are enabled.

Automatic processing refers to additional image processing that drivers might have performed on the image data prior to the application receiving the data. This method does not return a value.

<dd> A reference to the {{ID3D11VideoProcessor}} interface. To get this reference, call {{ID3D11VideoDevice::CreateVideoProcessor}}. </dd>

<dd> Receives the value {{TRUE}} if automatic processing features are enabled, or {{FALSE}} otherwise. </dd>

Gets the image filter settings for an input stream on the video processor.

This method does not return a value.

<dd> A reference to the {{ID3D11VideoProcessor}} interface. To get this reference, call {{ID3D11VideoDevice::CreateVideoProcessor}}. </dd>

<dd> The filter to query, specified as a {{D3D11_VIDEO_PROCESSOR_FILTER}} value. </dd>

<dd> Receives the value {{TRUE}} if the image filter is enabled, or {{FALSE}} otherwise. </dd>

<dd> Receives the filter level. </dd>

Gets a driver-specific state for a video processing stream.

If this method succeeds, it returns {{S_OK}}. Otherwise, it returns an {{HRESULT}} error code.

<dd> A reference to the {{ID3D11VideoProcessor}} interface. To get this reference, call {{ID3D11VideoDevice::CreateVideoProcessor}}. </dd>

<dd> A reference to a {{GUID}} that identifies the state. The meaning of this {{GUID}} is defined by the graphics driver. </dd>

<dd> The size of the pData buffer, in bytes. </dd>

<dd> A reference to a buffer that receives the private state data. </dd>

Performs a video processing operation on one or more input samples and writes the result to a Direct3D surface.

The maximum value of StreamCount is given in the MaxStreamStates member of the {{D3D11_VIDEO_PROCESSOR_CAPS}} structure. The maximum number of streams that can be enabled at one time is given in the MaxInputStreams member of that structure. If the output stereo mode is {{TRUE}}:<ul> <li>The output view must contain a texture array of two elements.</li> <li>At least one stereo stream must be specified.</li> <li>If multiple input streams are enabled, it is possible that one or more of the input streams may contain mono data.</li> </ul>Otherwise:<ul> <li>The output view must contain a single element.</li> <li>The stereo format cannot be {{D3D11_VIDEO_PROCESSOR_STEREO_FORMAT_MONO}} .</li> </ul>This function does not honor a {{D3D11}} predicate that may have been set.If the application uses {{D3D11}} quries, this function may not be accounted for with {{D3D11_QUERY_EVENT}} and {{D3D11_QUERY_TIMESTAMP}} when using feature levels lower than 11. {{D3D11_QUERY_PIPELINE_STATISTICS}} will not include this function for any feature level. If this method succeeds, it returns {{S_OK}}. Otherwise, it returns an {{HRESULT}} error code.

<dd> A reference to the {{ID3D11VideoProcessor}} interface. To get this reference, call the {{ID3D11VideoDevice::CreateVideoProcessor}} method. </dd>

<dd> A reference to the {{ID3D11VideoProcessorOutputView}} interface for the output surface. The output of the video processing operation will be written to this surface. </dd>

<dd> The frame number of the output video frame, indexed from zero. </dd>

<dd> The number of input streams to process. </dd>

<dd> A reference to an array of {{D3D11_VIDEO_PROCESSOR_STREAM}} structures that contain information about the input streams. The caller allocates the array and fills in each structure. The number of elements in the array is given in the StreamCount parameter. </dd>

Establishes the session key for a cryptographic session.

The key exchange mechanism depends on the type of cryptographic session.For {{RSA}} Encryption Scheme - Optimal Asymmetric Encryption Padding ({{RSAES}}-{{OAEP}}), the software decoder generates the secret key, encrypts the secret key by using the public key with {{RSAES}}-{{OAEP}}, and places the cipher text in the pData parameter. The actual size of the buffer for {{RSAES}}-{{OAEP}} is 256 bytes. If this method succeeds, it returns {{S_OK}}. Otherwise, it returns an {{HRESULT}} error code.

<dd> A reference to the {{ID3D11CryptoSession}} interface of the cryptographic session. </dd>

<dd> The size of the pData byte array, in bytes. </dd>

<dd> A reference to a byte array that contains the encrypted session key. </dd>

Reads encrypted data from a protected surface.

Not all drivers support this method. To query the driver capabilities, call {{ID3D11VideoDevice::GetContentProtectionCaps}} and check for the {{D3D11_CONTENT_PROTECTION_CAPS_ENCRYPTED_READ_BACK}} flag in the Caps member of the {{D3D11_VIDEO_CONTENT_PROTECTION_CAPS}} structure.Some drivers might require a separate key to decrypt the data that is read back. To check for this requirement, call GetContentProtectionCaps and check for the {{D3D11_CONTENT_PROTECTION_CAPS_ENCRYPTED_READ_BACK_KEY}} flag. If this flag is present, call {{ID3D11VideoContext::GetEncryptionBltKey}} to get the decryption key.This method has the following limitations:<ul> <li>Reading back sub-rectangles is not supported.</li> <li>Reading back partially encrypted surfaces is not supported.</li> <li>The protected surface must be either an off-screen plain surface or a render target.</li> <li>The destination surface must be a {{D3D11_USAGE_STAGING}} resource.</li> <li>The protected surface cannot be multisampled.</li> <li>Stretching and colorspace conversion are not supported.</li> </ul> This function does not honor a {{D3D11}} predicate that may have been set. If the application uses {{D3D11}} quries, this function may not be accounted for with {{D3D11_QUERY_EVENT}} and {{D3D11_QUERY_TIMESTAMP}} when using feature levels lower than 11. {{D3D11_QUERY_PIPELINE_STATISTICS}} will not include this function for any feature level. If this method succeeds, it returns {{S_OK}}. Otherwise, it returns an {{HRESULT}} error code.

<dd> A reference to the {{ID3D11CryptoSession}} interface of the cryptographic session. </dd>

<dd> A reference to the {{ID3D11Texture2D}} interface of the protected surface. </dd>

<dd> A reference to the {{ID3D11Texture2D}} interface of the surface that receives the encrypted data. </dd>

<dd> A reference to a buffer that receives the initialization vector ({{IV}}). The caller allocates this buffer, but the driver generates the {{IV}}. For 128-bit {{AES}}-{{CTR}} encryption, pIV points to a {{D3D11_AES_CTR_IV}} structure. When the driver generates the first {{IV}}, it initializes the structure to a random number. For each subsequent {{IV}}, the driver simply increments the {{IV}} member of the structure, ensuring that the value always increases. The application can validate that the same {{IV}} is never used more than once with the same key pair. </dd>

<dd> The size of the pIV buffer, in bytes. </dd>

Writes encrypted data to a protected surface.

Not all hardware or drivers support this functionality for all cryptographic types. This function can only be called when the {{D3D11_CONTENT_PROTECTION_CAPS_DECRYPTION_BLT}} cap is reported.This method does not support writing to sub-rectangles of the surface.If the hardware and driver support a content key:<ul> <li>The data is encrypted by the caller using the content key.</li> <li>The content key is encrypted by the caller using the session key.</li> <li>The encrypted content key is passed to the driver.</li> </ul> Otherwise, the data is encrypted by the caller using the session key and {{NULL}} is passed as the content key.If the driver and hardware support partially encrypted buffers, pEncryptedBlockInfo indicates which portions of the buffer are encrypted and which is not. If the entire buffer is encrypted, pEncryptedBlockinfo should be {{NULL}}.The {{D3D11_ENCRYPTED_BLOCK_INFO}} allows the application to indicate which bytes in the buffer are encrypted. This is specified in bytes, so the application must ensure that the encrypted blocks match the {{GPU}}?s crypto block alignment.This function does not honor a {{D3D11}} predicate that may have been set.If the application uses {{D3D11}} quries, this function may not be accounted for with {{D3D11_QUERY_EVENT}} and {{D3D11_QUERY_TIMESTAMP}} when using feature levels lower than 11. {{D3D11_QUERY_PIPELINE_STATISTICS}} will not include this function for any feature level. If this method succeeds, it returns {{S_OK}}. Otherwise, it returns an {{HRESULT}} error code.

<dd> A reference to the {{ID3D11CryptoSession}} interface. </dd>

<dd> A reference to the surface that contains the source data. </dd>

<dd> A reference to the protected surface where the encrypted data is written. </dd>

<dd> A reference to a {{D3D11_ENCRYPTED_BLOCK_INFO}} structure, or {{NULL}}. If the driver supports partially encrypted buffers, pEncryptedBlockInfo indicates which portions of the buffer are encrypted. If the entire surface is encrypted, set this parameter to {{NULL}}. To check whether the driver supports partially encrypted buffers, call {{ID3D11VideoDevice::GetContentProtectionCaps}} and check for the {{D3D11_CONTENT_PROTECTION_CAPS_PARTIAL_DECRYPTION}} capabilities flag. If the driver does not support partially encrypted buffers, set this parameter to {{NULL}}. </dd>

<dd> A reference to a buffer that contains a content encryption key, or {{NULL}}. To query whether the driver supports the use of content keys, call {{ID3D11VideoDevice::GetContentProtectionCaps}} and check for the {{D3D11_CONTENT_PROTECTION_CAPS_CONTENT_KEY}} capabilities flag. If the driver supports content keys, use the content key to encrypt the surface. Encrypt the content key using the session key, and place the resulting cipher text in pContentKey. If the driver does not support content keys, use the session key to encrypt the surface and set pContentKey to {{NULL}}. </dd>

<dd> The size of the encrypted content key, in bytes. </dd>

<dd> A reference to a buffer that contains the initialization vector ({{IV}}). For 128-bit {{AES}}-{{CTR}} encryption, pIV points to a {{D3D11_AES_CTR_IV}} structure. The caller allocates the structure and generates the {{IV}}. When you generate the first {{IV}}, initialize the structure to a random number. For each subsequent {{IV}}, simply increment the {{IV}} member of the structure, ensuring that the value always increases. This procedure enables the driver to validate that the same {{IV}} is never used more than once with the same key pair. For other encryption types, a different structure might be used, or the encryption might not use an {{IV}}. </dd>

<dd> The size of the pIV buffer, in bytes. </dd>

Gets a random number that can be used to refresh the session key.

To generate a new session key, perform a bitwise {{XOR}} between the previous session key and the random number. The new session key does not take affect until the application calls {{ID3D11VideoContext::FinishSessionKeyRefresh}}.To query whether the driver supports this method, call {{ID3D11VideoDevice::GetContentProtectionCaps}} and check for the {{D3D11_CONTENT_PROTECTION_CAPS_FRESHEN_SESSION_KEY}} capabilities flag. If this method succeeds, it returns {{S_OK}}. Otherwise, it returns an {{HRESULT}} error code.

<dd> A reference to the {{ID3D11CryptoSession}} interface. </dd>

<dd> The size of the pRandomNumber array, in bytes. The size should match the size of the session key. </dd>

<dd> A reference to a byte array that receives a random number. </dd>

Switches to a new session key.

This function can only be called when the {{D3D11_CONTENT_PROTECTION_CAPS_FRESHEN_SESSION_KEY}} cap is reported.Before calling this method, call {{ID3D11VideoContext::StartSessionKeyRefresh}}. The StartSessionKeyRefresh method gets a random number from the driver, which is used to create a new session key. The new session key does not become active until the application calls FinishSessionKeyRefresh. After the application calls FinishSessionKeyRefresh, all protected surfaces are encrypted using the new session key. If this method succeeds, it returns {{S_OK}}. Otherwise, it returns an {{HRESULT}} error code.

<dd> A reference to the {{ID3D11CryptoSession}} interface. </dd>

Gets the cryptographic key to decrypt the data returned by the {{ID3D11VideoContext::EncryptionBlt}} method.

This method applies only when the driver requires a separate content key for the EncryptionBlt method. For more information, see the Remarks for EncryptionBlt.Each time this method is called, the driver generates a new key.The KeySize should match the size of the session key.The read back key is encrypted by the driver/hardware using the session key. If this method succeeds, it returns {{S_OK}}. Otherwise, it returns an {{HRESULT}} error code.

Establishes a session key for an authenticated channel.

This method will fail if the channel type is {{D3D11_AUTHENTICATED_CHANNEL_D3D11}}, because the Direct3D11 channel does not support authentication. If this method succeeds, it returns {{S_OK}}. Otherwise, it returns an {{HRESULT}} error code.

<dd> A reference to the {{ID3D11AuthenticatedChannel}} interface. This method will fail if the channel type is {{D3D11_AUTHENTICATED_CHANNEL_D3D11}}, because the Direct3D11 channel does not support authentication. </dd>

<dd> The size of the data in the pData array, in bytes. </dd>

<dd> A reference to a byte array that contains the encrypted session key. The buffer must contain 256 bytes of data, encrypted using {{RSA}} Encryption Scheme - Optimal Asymmetric Encryption Padding ({{RSAES}}-{{OAEP}}). </dd>

Sends a query to an authenticated channel.

If this method succeeds, it returns {{S_OK}}. Otherwise, it returns an {{HRESULT}} error code.

<dd> A reference to the {{ID3D11AuthenticatedChannel}} interface. </dd>

<dd> The size of the pInput array, in bytes. </dd>

<dd> A reference to a byte array that contains input data for the query. This array always starts with a {{D3D11_AUTHENTICATED_QUERY_INPUT}} structure. The QueryType member of the structure specifies the query and defines the meaning of the rest of the array. </dd>

<dd> The size of the pOutput array, in bytes. </dd>

<dd> A reference to a byte array that receives the result of the query. This array always starts with a {{D3D11_AUTHENTICATED_QUERY_OUTPUT}} structure. The meaning of the rest of the array depends on the query. </dd>

Sends a configuration command to an authenticated channel.

If this method succeeds, it returns {{S_OK}}. Otherwise, it returns an {{HRESULT}} error code.

<dd> A reference to the {{ID3D11AuthenticatedChannel}} interface. </dd>

<dd> The size of the pInput array, in bytes. </dd>

<dd> A reference to a byte array that contains input data for the command. This buffer always starts with a {{D3D11_AUTHENTICATED_CONFIGURE_INPUT}} structure. The ConfigureType member of the structure specifies the command and defines the meaning of the rest of the buffer. </dd>

<dd> A reference to a {{D3D11_AUTHENTICATED_CONFIGURE_OUTPUT}} structure that receives the response to the command. </dd>

Sets the stream rotation for an input stream on the video processor.

This is an optional state and the application should only use it if {{D3D11_VIDEO_PROCESSOR_FEATURE_CAPS_ROTATION}} is reported in {{D3D11_VIDEO_PROCESSOR_CAPS}}.FeatureCaps.The stream source rectangle will be specified in the pre-rotation coordinates (typically landscape) and the stream destination rectangle will be specified in the post-rotation coordinates (typically portrait). The application must update the stream destination rectangle correctly when using a rotation value other than 0? and 180?. This method does not return a value.

<dd> A reference to the {{ID3D11VideoProcessor}} interface. To get this reference, call {{ID3D11VideoDevice::CreateVideoProcessor}}. </dd>

<dd> Specifies if the stream is to be rotated in a clockwise orientation. </dd>

<dd> Specifies the rotation of the stream. </dd>

Gets the stream rotation for an input stream on the video processor.

This method does not return a value.

<dd> A reference to the {{ID3D11VideoProcessor}} interface. To get this reference, call {{ID3D11VideoDevice::CreateVideoProcessor}}. </dd>

<dd> Specifies if the stream is rotated. </dd>

<dd> Specifies the rotation of the stream in a clockwise orientation. </dd>

Provides the video decoding and video processing capabilities of a Microsoft Direct3D?11 device.

The Direct3D?11 device supports this interface. To get a reference to this interface, call QueryInterface with an {{ID3D11Device}} interface reference.If you query an {{ID3D11Device}} for {{ID3D11VideoDevice}} and the Direct3D?11 device created is using the reference rasterizer or {{WARP}}, or is a hardware device and you are using the Microsoft Basic Display Adapter, {{E_NOINTERFACE}} is returned.

Creates a video decoder device for Microsoft Direct3D?11.

This method allocates the necessary decoder buffers. The {{ID3D11DeviceContext::ClearState}} method does not affect the internal state of the video decoder. If this method succeeds, it returns {{S_OK}}. Otherwise, it returns an {{HRESULT}} error code.

<dd> A reference to a {{D3D11_VIDEO_DECODER_DESC}} structure that describes the video stream and the decoder profile. </dd>

<dd> A reference to a {{D3D11_VIDEO_DECODER_CONFIG}} structure that specifies the decoder configuration. </dd>

<dd> Receives a reference to the {{ID3D11VideoDecoder}} interface. The caller must release the interface. </dd>

Creates a video processor device for Microsoft Direct3D?11.

The {{ID3D11DeviceContext::ClearState}} method does not affect the internal state of the video processor. If this method succeeds, it returns {{S_OK}}. Otherwise, it returns an {{HRESULT}} error code.

<dd> A reference to the {{ID3D11VideoProcessorEnumerator}} interface. To get this reference, call {{ID3D11VideoDevice::CreateVideoProcessorEnumerator}}. </dd>

<dd> Specifies the frame-rate conversion capabilities for the video processor. The value is a zero-based index that corresponds to the TypeIndex parameter of the {{ID3D11VideoProcessorEnumerator::GetVideoProcessorRateConversionCaps}} method. </dd>

<dd> Receives a reference to the {{ID3D11VideoProcessor}} interface. The caller must release the interface. </dd>

Creates a channel to communicate with the Microsoft Direct3D device or the graphics driver. The channel can be used to send commands and queries for content protection.

If the ChannelType parameter is {{D3D11_AUTHENTICATED_CHANNEL_D3D11}}, the method creates a channel with the Direct3D device. This type of channel does not support authentication.If ChannelType is {{D3D11_AUTHENTICATED_CHANNEL_DRIVER_SOFTWARE}} or {{D3D11_AUTHENTICATED_CHANNEL_DRIVER_HARDWARE}}, the method creates an authenticated channel with the graphics driver. If this method succeeds, it returns {{S_OK}}. Otherwise, it returns an {{HRESULT}} error code.

<dd> Specifies the type of channel, as a member of the {{D3D11_AUTHENTICATED_CHANNEL_TYPE}} enumeration. </dd>

<dd> Receives a reference to the {{ID3D11AuthenticatedChannel}} interface. The caller must release the interface. </dd>

Creates a cryptographic session to encrypt video content that is sent to the graphics driver.

The {{ID3D11DeviceContext::ClearState}} method does not affect the internal state of the cryptographic session. If this method succeeds, it returns {{S_OK}}. Otherwise, it returns an {{HRESULT}} error code.

<dd> A reference to a {{GUID}} that specifies the type of encryption to use. The following {{GUIDs}} are defined. <table> <tr><th>Value</th><th>Meaning</th></tr> <tr><td><dl> <dt>{{D3D11_CRYPTO_TYPE_AES128_CTR}}</dt> </dl> </td><td> 128-bit Advanced Encryption Standard {{CTR}} mode ({{AES}}-{{CTR}}) block cipher. </td></tr> </table> ? </dd>

<dd> A reference to a {{GUID}} that specifies the decoding profile. For a list of possible values, see {{ID3D11VideoDevice::GetVideoDecoderProfile}}. If decoding will not be used, set this parameter to {{NULL}}. </dd>

<dd> A reference to a {{GUID}} that specifies the type of key exchange. <table> <tr><th>Value</th><th>Meaning</th></tr> <tr><td><dl> <dt>{{D3D11_KEY_EXCHANGE_RSAES_OAEP}}</dt> </dl> </td><td> The caller will create the session key, encrypt it with {{RSA}} Encryption Scheme - Optimal Asymmetric Encryption Padding ({{RSAES}}-{{OAEP}}) by using the driver's public key, and pass the session key to the driver. </td></tr> </table> ? </dd>

<dd> Receives a reference to the {{ID3D11CryptoSession}} interface. The caller must release the interface. </dd>

Creates a resource view for a video decoder, describing the output sample for the decoding operation.

Set the ppVDOVView parameter to {{NULL}} to test whether a view is supported. If this method succeeds, it returns {{S_OK}}. Otherwise, it returns an {{HRESULT}} error code.

<dd> A reference to the {{ID3D11Resource}} interface of the decoder surface. The resource must be created with the {{D3D11_BIND_DECODER}} flag. See {{D3D11_BIND_FLAG}}. </dd>

<dd> A reference to a {{D3D11_VIDEO_DECODER_OUTPUT_VIEW_DESC}} structure that describes the view. </dd>

<dd> Receives a reference to the {{ID3D11VideoDecoderOutputView}} interface. The caller must release the interface. If this parameter is {{NULL}}, the method checks whether the view is supported, but does not create the view. </dd>

Creates a resource view for a video processor, describing the input sample for the video processing operation.

Set the ppVPIView parameter to {{NULL}} to test whether a view is supported.The surface format is given in the FourCC member of the {{D3D11_VIDEO_PROCESSOR_INPUT_VIEW_DESC}} structure. The method fails if the video processor does not support this format as an input sample. An app must specify 0 when using 9_1, 9_2, or 9_3 feature levels. Resources used for video processor input views must use the following bind flag combinations:<ul> <li>Any combination of bind flags that includes {{D3D11_BIND_DECODER}},{{D3D11_BIND_VIDEO_ENCODER}}, {{D3D11_BIND_RENDER_TARGET}}, and {{D3D11_BIND_UNORDERED_ACCESS_VIEW}} can be used as for video processor input views (regardless of what other bind flags may be set).</li> <li>Bind flags = 0 is also allowed for a video processor input view.</li> <li>Other restrictions will apply such as:<ul> <li>No multi-sampling is allowed.</li> <li>The Texture2D must have been created using {{D3D11_USAGE_DEFAULT}}.</li> </ul> </li> </ul> If this method succeeds, it returns {{S_OK}}. Otherwise, it returns an {{HRESULT}} error code.

<dd> A reference to the {{ID3D11Resource}} interface of the input surface. </dd>

<dd> A reference to the {{ID3D11VideoProcessorEnumerator}} interface that specifies the video processor. To get this reference, call {{ID3D11VideoDevice::CreateVideoProcessorEnumerator}}. </dd>

<dd> A reference to a {{D3D11_VIDEO_PROCESSOR_INPUT_VIEW_DESC}} structure that describes the view. </dd>

<dd> Receives a reference to the {{ID3D11VideoProcessorInputView}} interface. The caller must release the resource. If this parameter is {{NULL}}, the method checks whether the view is supported, but does not create the view. </dd>

Creates a resource view for a video processor, describing the output sample for the video processing operation.

Set the ppVPOView parameter to {{NULL}} to test whether a view is supported.Resources used for video processor output views must use the following {{D3D11_BIND_FLAG}} combinations:<ul> <li> {{D3D11_BIND_RENDER_TARGET}} indicates that it can be used for a video processor output view. The following bind flags are allowed to be set with {{D3D11_BIND_RENDER_TARGET}}:<ul> <li> {{D3D11_BIND_VIDEO_ENCODER}} </li> <li> {{D3D11_BIND_SHADER_RESOURCE}} </li> </ul> </li> <li>Other restrictions will apply such as:<ul> <li>No multi-sampling is allowed.</li> <li>The Texture2D must have been created using {{D3D11_USAGE_DEFAULT}}.</li> </ul> </li> <li>Some {{YUV}} formats can be supported as a video processor output view, but might not be supported as a 3D render target. {{D3D11}} will allow the {{D3D11_BIND_RENDER_TARGET}} flag for these formats, but CreateRenderTargetView will not be allowed for these formats.</li> </ul>If stereo output is enabled, the output view must have 2 array elements. Otherwise, it must only have a single array element. If this method succeeds, it returns {{S_OK}}. Otherwise, it returns an {{HRESULT}} error code.

<dd> A reference to the {{ID3D11Resource}} interface of the output surface. The resource must be created with the {{D3D11_BIND_RENDER_TARGET}} flag. See {{D3D11_BIND_FLAG}}. </dd>

<dd> A reference to a {{D3D11_VIDEO_PROCESSOR_OUTPUT_VIEW_DESC}} structure that describes the view. </dd>

<dd> Receives a reference to the {{ID3D11VideoProcessorOutputView}} interface. The caller must release the resource. If this parameter is {{NULL}}, the method checks whether the view is supported, but does not create the view. </dd>

Enumerates the video processor capabilities of the driver.

To create the video processor device, pass the {{ID3D11VideoProcessorEnumerator}} reference to the {{ID3D11VideoDevice::CreateVideoProcessor}} method. If this method succeeds, it returns {{S_OK}}. Otherwise, it returns an {{HRESULT}} error code.

<dd> A reference to a {{D3D11_VIDEO_PROCESSOR_CONTENT_DESC}} structure that describes the video content. </dd>

<dd> Receives a reference to the {{ID3D11VideoProcessorEnumerator}} interface. The caller must release the interface. </dd>

Gets the number of profiles that are supported by the driver.

To enumerate the profiles, call {{ID3D11VideoDevice::GetVideoDecoderProfile}}. Returns the number of profiles.

Gets a profile that is supported by the driver.

If this method succeeds, it returns {{S_OK}}. Otherwise, it returns an {{HRESULT}} error code.

<dd> The zero-based index of the profile. To get the number of profiles that the driver supports, call {{ID3D11VideoDevice::GetVideoDecoderProfileCount}}. </dd>

<dd> Receives a {{GUID}} that identifies the profile. </dd>

Given aprofile, checks whether the driver supports a specified output format.

If the driver does not support the profile given in pDecoderProfile, the method returns {{E_INVALIDARG}}. If the driver supports the profile, but the {{DXGI}} format is not compatible with the profile, the method succeeds but returns the value {{FALSE}} in pSupported. If this method succeeds, it returns {{S_OK}}. Otherwise, it returns an {{HRESULT}} error code.

<dd> A reference to a {{GUID}} that identifies the profile. To get the list of supported profiles, call {{ID3D11VideoDevice::GetVideoDecoderProfile}}. </dd>

<dd> A {{DXGI_FORMAT}} value that specifies the output format. Typical values include {{DXGI_FORMAT_NV12}} and {{DXGI_FORMAT_420_OPAQUE}}. </dd>

<dd> Receives the value {{TRUE}} if the format is supported, or {{FALSE}} otherwise. </dd>

Gets the number of decoder configurations that the driver supports for a specified video description.

To enumerate the decoder configurations, call {{ID3D11VideoDevice::GetVideoDecoderConfig}}. If this method succeeds, it returns {{S_OK}}. Otherwise, it returns an {{HRESULT}} error code.

<dd> A reference to a {{D3D11_VIDEO_DECODER_DESC}} structure that describes the video stream. </dd>

<dd> Receives the number of decoder configurations. </dd>

Gets a decoder configuration that is supported by the driver.

If this method succeeds, it returns {{S_OK}}. Otherwise, it returns an {{HRESULT}} error code.

<dd> A reference to a {{D3D11_VIDEO_DECODER_DESC}} structure that describes the video stream. </dd>

<dd> The zero-based index of the decoder configuration. To get the number of configurations that the driver supports, call {{ID3D11VideoDevice::GetVideoDecoderConfigCount}}. </dd>

<dd> A reference to a {{D3D11_VIDEO_DECODER_CONFIG}} structure. The method fills in the structure with the decoder configuration. </dd>

Queries the driver for its content protection capabilities.

If this method succeeds, it returns {{S_OK}}. Otherwise, it returns an {{HRESULT}} error code.

<dd> A reference to a {{GUID}} that specifies the type of encryption to be used. The following {{GUIDs}} are defined. <table> <tr><th>Value</th><th>Meaning</th></tr> <tr><td><dl> <dt>{{D3D11_CRYPTO_TYPE_AES128_CTR}}</dt> </dl> </td><td> 128-bit Advanced Encryption Standard {{CTR}} mode ({{AES}}-{{CTR}}) block cipher. </td></tr> </table> ? If no encryption will be used, set this parameter to {{NULL}}. </dd>

<dd> A reference to a {{GUID}} that specifies the decoding profile. To get profiles that the driver supports, call {{ID3D11VideoDevice::GetVideoDecoderProfile}}. If decoding will not be used, set this parameter to {{NULL}}. The driver might disallow some combinations of encryption type and profile. </dd>

<dd> A reference to a {{D3D11_VIDEO_CONTENT_PROTECTION_CAPS}} structure. The method fills in this structure with the driver's content protection capabilities. </dd>

Gets a cryptographic key-exchange mechanism that is supported by the driver.

If this method succeeds, it returns {{S_OK}}. Otherwise, it returns an {{HRESULT}} error code.

<dd> The zero-based index of the key-exchange type. The driver reports the number of types in the KeyExchangeTypeCount member of the {{D3D11_VIDEO_CONTENT_PROTECTION_CAPS}} structure. </dd>

<dd> Receives a {{GUID}} that identifies the type of key exchange. </dd>

Sets private data on the video device and associates that data with a {{GUID}}.

If this method succeeds, it returns {{S_OK}}. Otherwise, it returns an {{HRESULT}} error code.

<dd> The {{GUID}} associated with the data. </dd>

<dd> The size of the data, in bytes. </dd>

<dd> A reference to the data. </dd>

Sets a private {{IUnknown}} reference on the video device and associates that reference with a {{GUID}}.

If this method succeeds, it returns {{S_OK}}. Otherwise, it returns an {{HRESULT}} error code.

The device interface represents a virtual adapter; it is used to create resources.

A device is created using {{D3D11CreateDevice}}. Windows?Phone?8: This {{API}} is supported.

Creates a buffer (vertex buffer, index buffer, or shader-constant buffer).

For example code, see How to: Create a Vertex Buffer, How to: Create an Index Buffer or How to: Create a Constant Buffer. For a constant buffer (BindFlags of {{D3D11_BUFFER_DESC}} set to {{D3D11_BIND_CONSTANT_BUFFER}}), you must set the ByteWidth value of {{D3D11_BUFFER_DESC}} in multiples of 16, and less than or equal to {{D3D11_REQ_CONSTANT_BUFFER_ELEMENT_COUNT}}. The Direct3D 11.1 runtime, which is available on Windows?8 and later operating systems, provides the following new functionality for CreateBuffer: You can create a constant buffer that is larger than the maximum constant buffer size that a shader can access (4096 32-bit*4-component constants ? 64KB). When you bind the constant buffer to the pipeline (for example, via {{PSSetConstantBuffers}} or {{PSSetConstantBuffers1}}), you can define a range of the buffer that the shader can access that fits within the 4096 constant limit. The runtime will emulate this feature for feature level 9.1, 9.2, and 9.3; therefore, this feature is supported for feature level 9.1, 9.2, and 9.3. This feature is always available on new drivers for feature level 10 and higher. On existing drivers that are implemented to feature level 10 and higher, a call to CreateBuffer to request a constant buffer that is larger than 4096 fails. This method returns {{E_OUTOFMEMORY}} if there is insufficient memory to create the buffer. See Direct3D 11 Return Codes for other possible return values.

<dd> A reference to a {{D3D11_BUFFER_DESC}} structure that describes the buffer. </dd>

<dd> A reference to a {{D3D11_SUBRESOURCE_DATA}} structure that describes the initialization data; use {{NULL}} to allocate space only (with the exception that it cannot be {{NULL}} if the usage flag is {{D3D11_USAGE_IMMUTABLE}}). If you don't pass anything to pInitialData, the initial content of the memory for the buffer is undefined. In this case, you need to write the buffer content some other way before the resource is read. </dd>

<dd> Address of a reference to the {{ID3D11Buffer}} interface for the buffer object created. Set this parameter to {{NULL}} to validate the other input parameters ({{S_FALSE}} indicates a pass). </dd>

Creates an array of 1D textures.

CreateTexture1D creates a 1D texture resource, which can contain a number of 1D subresources. The number of textures is specified in the texture description. All textures in a resource must have the same format, size, and number of mipmap levels.All resources are made up of one or more subresources. To load data into the texture, applications can supply the data initially as an array of {{D3D11_SUBRESOURCE_DATA}} structures pointed to by pInitialData, or they can use one of the {{D3DX}} texture functions such as {{D3DX11CreateTextureFromFile}}.For a 32 width texture with a full mipmap chain, the pInitialData array has the following 6 elements: <ul> <li>pInitialData[0] = 32x1</li> <li>pInitialData[1] = 16x1</li> <li>pInitialData[2] = 8x1</li> <li>pInitialData[3] = 4x1 </li> <li>pInitialData[4] = 2x1 </li> <li>pInitialData[5] = 1x1 </li> </ul> If the method succeeds, the return code is {{S_OK}}. See Direct3D 11 Return Codes for failing error codes.

Create an array of 2D textures.

CreateTexture2D creates a 2D texture resource, which can contain a number of 2D subresources. The number of textures is specified in the texture description. All textures in a resource must have the same format, size, and number of mipmap levels.All resources are made up of one or more subresources. To load data into the texture, applications can supply the data initially as an array of {{D3D11_SUBRESOURCE_DATA}} structures pointed to by pInitialData, or it may use one of the {{D3DX}} texture functions such as {{D3DX11CreateTextureFromFile}}.For a 32 x 32 texture with a full mipmap chain, the pInitialData array has the following 6 elements: <ul> <li>pInitialData[0] = 32x32</li> <li>pInitialData[1] = 16x16</li> <li>pInitialData[2] = 8x8</li> <li>pInitialData[3] = 4x4 </li> <li>pInitialData[4] = 2x2 </li> <li>pInitialData[5] = 1x1 </li> </ul> If the method succeeds, the return code is {{S_OK}}. See Direct3D 11 Return Codes for failing error codes.

Create a single 3D texture.

CreateTexture3D creates a 3D texture resource, which can contain a number of 3D subresources. The number of textures is specified in the texture description. All textures in a resource must have the same format, size, and number of mipmap levels.All resources are made up of one or more subresources. To load data into the texture, applications can supply the data initially as an array of {{D3D11_SUBRESOURCE_DATA}} structures pointed to by pInitialData, or they can use one of the {{D3DX}} texture functions such as {{D3DX11CreateTextureFromFile}}.Each element of pInitialData provides all of the slices that are defined for a given miplevel. For example, for a 32 x 32 x 4 volume texture with a full mipmap chain, the array has the following 6 elements:<ul> <li>pInitialData[0] = 32x32 with 4 slices</li> <li>pInitialData[1] = 16x16 with 2 slices</li> <li>pInitialData[2] = 8x8 with 1 slice</li> <li>pInitialData[3] = 4x4 with 1 slice</li> <li>pInitialData[4] = 2x2 with 1 slice</li> <li>pInitialData[5] = 1x1 with 1 slice</li> </ul> If the method succeeds, the return code is {{S_OK}}. See Direct3D 11 Return Codes for failing error codes.

Create a shader-resource view for accessing data in a resource.

A resource is made up of one or more subresources; a view identifies which subresources to allow the pipeline to access. In addition, each resource is bound to the pipeline using a view. A shader-resource view is designed to bind any buffer or texture resource to the shader stages using the following {{API}} methods: {{ID3D11DeviceContext::VSSetShaderResources}}, {{ID3D11DeviceContext::GSSetShaderResources}} and {{ID3D11DeviceContext::PSSetShaderResources}}. Because a view is fully typed, this means that typeless resources become fully typed when bound to the pipeline.Note?? To successfully create a shader-resource view from a typeless buffer (for example, {{DXGI_FORMAT_R32G32B32A32_TYPELESS}}), you must set the {{D3D11_RESOURCE_MISC_BUFFER_ALLOW_RAW_VIEWS}} flag when you create the buffer.? The Direct3D 11.1 runtime, which is available starting with Windows?8, allows you to use CreateShaderResourceView for the following new purpose. You can create shader-resource views of video resources so that Direct3D shaders can process those shader-resource views. These video resources are either Texture2D or Texture2DArray. The value in the ViewDimension member of the {{D3D11_SHADER_RESOURCE_VIEW_DESC}} structure for a created shader-resource view must match the type of video resource, {{D3D11_SRV_DIMENSION_TEXTURE2D}} for Texture2D and {{D3D11_SRV_DIMENSION_TEXTURE2DARRAY}} for Texture2DArray. Additionally, the format of the underlying video resource restricts the formats that the view can use. The video resource format values on the {{DXGI_FORMAT}} reference page specify the format values that views are restricted to. The runtime read+write conflict prevention logic (which stops a resource from being bound as an {{SRV}} and {{RTV}} or {{UAV}} at the same time) treats views of different parts of the same video surface as conflicting for simplicity. Therefore, the runtime does not allow an application to read from luma while the application simultaneously renders to chroma in the same surface even though the hardware might allow these simultaneous operations.Windows?Phone?8: This {{API}} is supported. This method returns one of the following Direct3D 11 Return Codes.

<dd> Pointer to the resource that will serve as input to a shader. This resource must have been created with the {{D3D11_BIND_SHADER_RESOURCE}} flag. </dd>

<dd> Pointer to a shader-resource view description (see {{D3D11_SHADER_RESOURCE_VIEW_DESC}}). Set this parameter to {{NULL}} to create a view that accesses the entire resource (using the format the resource was created with). </dd>

<dd> Address of a reference to an {{ID3D11ShaderResourceView}}. Set this parameter to {{NULL}} to validate the other input parameters (the method will return {{S_FALSE}} if the other input parameters pass validation). </dd>

Creates a view for accessing an unordered access resource.

The Direct3D 11.1 runtime, which is available starting with Windows?8, allows you to use CreateUnorderedAccessView for the following new purpose. You can create unordered-access views of video resources so that Direct3D shaders can process those unordered-access views. These video resources are either Texture2D or Texture2DArray. The value in the ViewDimension member of the {{D3D11_UNORDERED_ACCESS_VIEW_DESC}} structure for a created unordered-access view must match the type of video resource, {{D3D11_UAV_DIMENSION_TEXTURE2D}} for Texture2D and {{D3D11_UAV_DIMENSION_TEXTURE2DARRAY}} for Texture2DArray. Additionally, the format of the underlying video resource restricts the formats that the view can use. The video resource format values on the {{DXGI_FORMAT}} reference page specify the format values that views are restricted to.The runtime read+write conflict prevention logic (which stops a resource from being bound as an {{SRV}} and {{RTV}} or {{UAV}} at the same time) treats views of different parts of the same video surface as conflicting for simplicity. Therefore, the runtime does not allow an application to read from luma while the application simultaneously renders to chroma in the same surface even though the hardware might allow these simultaneous operations. This method returns one of the Direct3D 11 Return Codes.

Creates a render-target view for accessing resource data.

A render-target view can be bound to the output-merger stage by calling {{ID3D11DeviceContext::OMSetRenderTargets}}.The Direct3D 11.1 runtime, which is available starting with Windows?8, allows you to use CreateRenderTargetView for the following new purpose. You can create render-target views of video resources so that Direct3D shaders can process those render-target views. These video resources are either Texture2D or Texture2DArray. The value in the ViewDimension member of the {{D3D11_RENDER_TARGET_VIEW_DESC}} structure for a created render-target view must match the type of video resource, {{D3D11_RTV_DIMENSION_TEXTURE2D}} for Texture2D and {{D3D11_RTV_DIMENSION_TEXTURE2DARRAY}} for Texture2DArray. Additionally, the format of the underlying video resource restricts the formats that the view can use. The video resource format values on the {{DXGI_FORMAT}} reference page specify the format values that views are restricted to.The runtime read+write conflict prevention logic (which stops a resource from being bound as an {{SRV}} and {{RTV}} or {{UAV}} at the same time) treats views of different parts of the same video surface as conflicting for simplicity. Therefore, the runtime does not allow an application to read from luma while the application simultaneously renders to chroma in the same surface even though the hardware might allow these simultaneous operations. This method returns one of the Direct3D 11 Return Codes.

<dd> Pointer to a {{ID3D11Resource}} that represents a render target. This resource must have been created with the {{D3D11_BIND_RENDER_TARGET}} flag. </dd>

<dd> Pointer to a {{D3D11_RENDER_TARGET_VIEW_DESC}} that represents a render-target view description. Set this parameter to {{NULL}} to create a view that accesses all of the subresources in mipmap level 0. </dd>

<dd> Address of a reference to an {{ID3D11RenderTargetView}}. Set this parameter to {{NULL}} to validate the other input parameters (the method will return {{S_FALSE}} if the other input parameters pass validation). </dd>

Create a depth-stencil view for accessing resource data.

A depth-stencil view can be bound to the output-merger stage by calling {{ID3D11DeviceContext::OMSetRenderTargets}}. This method returns one of the following Direct3D 11 Return Codes.

<dd> Pointer to the resource that will serve as the depth-stencil surface. This resource must have been created with the {{D3D11_BIND_DEPTH_STENCIL}} flag. </dd>

<dd> Pointer to a depth-stencil-view description (see {{D3D11_DEPTH_STENCIL_VIEW_DESC}}). Set this parameter to {{NULL}} to create a view that accesses mipmap level 0 of the entire resource (using the format the resource was created with). </dd>

<dd> Address of a reference to an {{ID3D11DepthStencilView}}. Set this parameter to {{NULL}} to validate the other input parameters (the method will return {{S_FALSE}} if the other input parameters pass validation). </dd>

Create an input-layout object to describe the input-buffer data for the input-assembler stage.

After creating an input layout object, it must be bound to the input-assembler stage before calling a draw {{API}}.Once an input-layout object is created from a shader signature, the input-layout object can be reused with any other shader that has an identical input signature (semantics included). This can simplify the creation of input-layout objects when you are working with many shaders with identical inputs. If a data type in the input-layout declaration does not match the data type in a shader-input signature, CreateInputLayout will generate a warning during compilation. The warning is simply to call attention to the fact that the data may be reinterpreted when read from a register. You may either disregard this warning (if reinterpretation is intentional) or make the data types match in both declarations to eliminate the warning. Windows?Phone?8: This {{API}} is supported. If the method succeeds, the return code is {{S_OK}}. See Direct3D 11 Return Codes for failing error codes.

<dd> An array of the input-assembler stage input data types; each type is described by an element description (see {{D3D11_INPUT_ELEMENT_DESC}}). </dd>

<dd> The number of input-data types in the array of input-elements. </dd>

<dd> A reference to the compiled shader. The compiled shader code contains a input signature which is validated against the array of elements. See remarks. </dd>

<dd> Size of the compiled shader. </dd>

<dd> A reference to the input-layout object created (see {{ID3D11InputLayout}}). To validate the other input parameters, set this reference to be {{NULL}} and verify that the method returns {{S_FALSE}}. </dd>

Create a vertex-shader object from a compiled shader.

The Direct3D 11.1 runtime, which is available starting with Windows?8, provides the following new functionality for CreateVertexShader.The following shader model 5.0 instructions are available to just pixel shaders and compute shaders in the Direct3D 11.0 runtime. For the Direct3D 11.1 runtime, because unordered access views ({{UAV}}) are available at all shader stages, you can use these instructions in all shader stages.Therefore, if you use the following shader model 5.0 instructions in a vertex shader, you can successfully pass the compiled vertex shader to pShaderBytecode. That is, the call to CreateVertexShader succeeds.If you pass a compiled shader to pShaderBytecode that uses any of the following instructions on a device that doesn?t support {{UAVs}} at every shader stage (including existing drivers that are not implemented to support {{UAVs}} at every shader stage), CreateVertexShader fails. CreateVertexShader also fails if the shader tries to use a {{UAV}} slot beyond the set of {{UAV}} slots that the hardware supports.<ul> <li> dcl_uav_typed </li> <li> dcl_uav_raw </li> <li> dcl_uav_structured </li> <li> ld_raw </li> <li> ld_structured </li> <li> ld_uav_typed </li> <li> store_raw </li> <li> store_structured </li> <li> store_uav_typed </li> <li> sync_uglobal </li> <li>All atomics and immediate atomics (for example, atomic_and and imm_atomic_and)</li> </ul> This method returns one of the Direct3D 11 Return Codes.

<dd> A reference to the compiled shader. </dd>

<dd> Size of the compiled vertex shader. </dd>

<dd> A reference to a class linkage interface (see {{ID3D11ClassLinkage}}); the value can be {{NULL}}. </dd>

<dd> Address of a reference to a {{ID3D11VertexShader}} interface. If this is {{NULL}}, all other parameters will be validated, and if all parameters pass validation this {{API}} will return {{S_FALSE}} instead of {{S_OK}}. </dd>

Create a geometry shader.

After it is created, the shader can be set to the device by calling {{ID3D11DeviceContext::GSSetShader}}.The Direct3D 11.1 runtime, which is available starting with Windows?8, provides the following new functionality for CreateGeometryShader.The following shader model 5.0 instructions are available to just pixel shaders and compute shaders in the Direct3D 11.0 runtime. For the Direct3D 11.1 runtime, because unordered access views ({{UAV}}) are available at all shader stages, you can use these instructions in all shader stages.Therefore, if you use the following shader model 5.0 instructions in a geometry shader, you can successfully pass the compiled geometry shader to pShaderBytecode. That is, the call to CreateGeometryShader succeeds.If you pass a compiled shader to pShaderBytecode that uses any of the following instructions on a device that doesn?t support {{UAVs}} at every shader stage (including existing drivers that are not implemented to support {{UAVs}} at every shader stage), CreateGeometryShader fails. CreateGeometryShader also fails if the shader tries to use a {{UAV}} slot beyond the set of {{UAV}} slots that the hardware supports.<ul> <li> dcl_uav_typed </li> <li> dcl_uav_raw </li> <li> dcl_uav_structured </li> <li> ld_raw </li> <li> ld_structured </li> <li> ld_uav_typed </li> <li> store_raw </li> <li> store_structured </li> <li> store_uav_typed </li> <li> sync_uglobal </li> <li>All atomics and immediate atomics (for example, atomic_and and imm_atomic_and)</li> </ul> This method returns one of the following Direct3D 11 Return Codes.

<dd> A reference to the compiled shader. </dd>

<dd> Size of the compiled geometry shader. </dd>

<dd> A reference to a class linkage interface (see {{ID3D11ClassLinkage}}); the value can be {{NULL}}. </dd>

<dd> Address of a reference to a {{ID3D11GeometryShader}} interface. If this is {{NULL}}, all other parameters will be validated, and if all parameters pass validation this {{API}} will return {{S_FALSE}} instead of {{S_OK}}. </dd>

Creates a geometry shader that can write to streaming output buffers.

For more info about using CreateGeometryShaderWithStreamOutput, see Create a Geometry-Shader Object with Stream Output. The Direct3D 11.1 runtime, which is available starting with Windows?8, provides the following new functionality for CreateGeometryShaderWithStreamOutput. The following shader model 5.0 instructions are available to just pixel shaders and compute shaders in the Direct3D 11.0 runtime. For the Direct3D 11.1 runtime, because unordered access views ({{UAV}}) are available at all shader stages, you can use these instructions in all shader stages. Therefore, if you use the following shader model 5.0 instructions in a geometry shader, you can successfully pass the compiled geometry shader to pShaderBytecode. That is, the call to CreateGeometryShaderWithStreamOutput succeeds. If you pass a compiled shader to pShaderBytecode that uses any of the following instructions on a device that doesn?t support {{UAVs}} at every shader stage (including existing drivers that are not implemented to support {{UAVs}} at every shader stage), CreateGeometryShaderWithStreamOutput fails. CreateGeometryShaderWithStreamOutput also fails if the shader tries to use a {{UAV}} slot beyond the set of {{UAV}} slots that the hardware supports. <ul> <li> dcl_uav_typed </li> <li> dcl_uav_raw </li> <li> dcl_uav_structured </li> <li> ld_raw </li> <li> ld_structured </li> <li> ld_uav_typed </li> <li> store_raw </li> <li> store_structured </li> <li> store_uav_typed </li> <li> sync_uglobal </li> <li> All atomics and immediate atomics (for example, atomic_and and imm_atomic_and) </li> </ul>Windows?Phone?8: This {{API}} is supported. This method returns one of the Direct3D 11 Return Codes.

<dd> A reference to the compiled geometry shader for a standard geometry shader plus stream output. For info on how to get this reference, see Getting a Pointer to a Compiled Shader. To create the stream output without using a geometry shader, pass a reference to the output signature for the prior stage. To obtain this output signature, call the {{D3DGetOutputSignatureBlob}} compiler function. You can also pass a reference to the compiled shader for the prior stage (for example, the vertex-shader stage or domain-shader stage). This compiled shader provides the output signature for the data. </dd>

<dd> Size of the compiled geometry shader. </dd>

<dd> Pointer to a {{D3D11_SO_DECLARATION_ENTRY}} array. Cannot be {{NULL}} if NumEntries > 0. </dd>

<dd> The number of entries in the stream output declaration ( ranges from 0 to {{D3D11_SO_STREAM_COUNT}} * {{D3D11_SO_OUTPUT_COMPONENT_COUNT}} ). </dd>

<dd> An array of buffer strides; each stride is the size of an element for that buffer. </dd>

<dd> The number of strides (or buffers) in pBufferStrides (ranges from 0 to {{D3D11_SO_BUFFER_SLOT_COUNT}}). </dd>

<dd> The index number of the stream to be sent to the rasterizer stage (ranges from 0 to {{D3D11_SO_STREAM_COUNT}} - 1). Set to {{D3D11_SO_NO_RASTERIZED_STREAM}} if no stream is to be rasterized. </dd>

<dd> A reference to a class linkage interface (see {{ID3D11ClassLinkage}}); the value can be {{NULL}}. </dd>

<dd> Address of a reference to an {{ID3D11GeometryShader}} interface, representing the geometry shader that was created. Set this to {{NULL}} to validate the other parameters; if validation passes, the method will return {{S_FALSE}} instead of {{S_OK}}. </dd>

Create a pixel shader.

After creating the pixel shader, you can set it to the device using {{ID3D11DeviceContext::PSSetShader}}. This method returns one of the following Direct3D 11 Return Codes.

<dd> A reference to the compiled shader. </dd>

<dd> Size of the compiled pixel shader. </dd>

<dd> A reference to a class linkage interface (see {{ID3D11ClassLinkage}}); the value can be {{NULL}}. </dd>

<dd> Address of a reference to a {{ID3D11PixelShader}} interface. If this is {{NULL}}, all other parameters will be validated, and if all parameters pass validation this {{API}} will return {{S_FALSE}} instead of {{S_OK}}. </dd>

Create a hull shader.

The Direct3D 11.1 runtime, which is available starting with Windows?8, provides the following new functionality for CreateHullShader.The following shader model 5.0 instructions are available to just pixel shaders and compute shaders in the Direct3D 11.0 runtime. For the Direct3D 11.1 runtime, because unordered access views ({{UAV}}) are available at all shader stages, you can use these instructions in all shader stages.Therefore, if you use the following shader model 5.0 instructions in a hull shader, you can successfully pass the compiled hull shader to pShaderBytecode. That is, the call to CreateHullShader succeeds.If you pass a compiled shader to pShaderBytecode that uses any of the following instructions on a device that doesn?t support {{UAVs}} at every shader stage (including existing drivers that are not implemented to support {{UAVs}} at every shader stage), CreateHullShader fails. CreateHullShader also fails if the shader tries to use a {{UAV}} slot beyond the set of {{UAV}} slots that the hardware supports.<ul> <li> dcl_uav_typed </li> <li> dcl_uav_raw </li> <li> dcl_uav_structured </li> <li> ld_raw </li> <li> ld_structured </li> <li> ld_uav_typed </li> <li> store_raw </li> <li> store_structured </li> <li> store_uav_typed </li> <li> sync_uglobal </li> <li>All atomics and immediate atomics (for example, atomic_and and imm_atomic_and)</li> </ul> This method returns one of the Direct3D 11 Return Codes.

Create a domain shader .

The Direct3D 11.1 runtime, which is available starting with Windows?8, provides the following new functionality for CreateDomainShader.The following shader model 5.0 instructions are available to just pixel shaders and compute shaders in the Direct3D 11.0 runtime. For the Direct3D 11.1 runtime, because unordered access views ({{UAV}}) are available at all shader stages, you can use these instructions in all shader stages.Therefore, if you use the following shader model 5.0 instructions in a domain shader, you can successfully pass the compiled domain shader to pShaderBytecode. That is, the call to CreateDomainShader succeeds.If you pass a compiled shader to pShaderBytecode that uses any of the following instructions on a device that doesn?t support {{UAVs}} at every shader stage (including existing drivers that are not implemented to support {{UAVs}} at every shader stage), CreateDomainShader fails. CreateDomainShader also fails if the shader tries to use a {{UAV}} slot beyond the set of {{UAV}} slots that the hardware supports.<ul> <li> dcl_uav_typed </li> <li> dcl_uav_raw </li> <li> dcl_uav_structured </li> <li> ld_raw </li> <li> ld_structured </li> <li> ld_uav_typed </li> <li> store_raw </li> <li> store_structured </li> <li> store_uav_typed </li> <li> sync_uglobal </li> <li>All atomics and immediate atomics (for example, atomic_and and imm_atomic_and)</li> </ul> This method returns one of the following Direct3D 11 Return Codes.

Create a compute shader.

For an example, see How To: Create a Compute Shader and {{HDRToneMappingCS11}} Sample. This method returns {{E_OUTOFMEMORY}} if there is insufficient memory to create the compute shader. See Direct3D 11 Return Codes for other possible return values.

Creates class linkage libraries to enable dynamic shader linkage.

The {{ID3D11ClassLinkage}} interface returned in ppLinkage is associated with a shader by passing it as a parameter to one of the {{ID3D11Device}} create shader methods such as {{ID3D11Device::CreatePixelShader}}. This method returns one of the following Direct3D 11 Return Codes.

<dd> A reference to a class-linkage interface reference (see {{ID3D11ClassLinkage}}). </dd>

Create a blend-state object that encapsules blend state for the output-merger stage.

An application can create up to 4096 unique blend-state objects. For each object created, the runtime checks to see if a previous object has the same state. If such a previous object exists, the runtime will return a reference to previous instance instead of creating a duplicate object. Windows?Phone?8: This {{API}} is supported. This method returns {{E_OUTOFMEMORY}} if there is insufficient memory to create the blend-state object. See Direct3D 11 Return Codes for other possible return values.

<dd> Pointer to a blend-state description (see {{D3D11_BLEND_DESC}}). </dd>

<dd> Address of a reference to the blend-state object created (see {{ID3D11BlendState}}). </dd>

Create a depth-stencil state object that encapsulates depth-stencil test information for the output-merger stage.

4096 unique depth-stencil state objects can be created on a device at a time.If an application attempts to create a depth-stencil-state interface with the same state as an existing interface, the same interface will be returned and the total number of unique depth-stencil state objects will stay the same. This method returns one of the following Direct3D 11 Return Codes.

<dd> Pointer to a depth-stencil state description (see {{D3D11_DEPTH_STENCIL_DESC}}). </dd>

<dd> Address of a reference to the depth-stencil state object created (see {{ID3D11DepthStencilState}}). </dd>

Create a rasterizer state object that tells the rasterizer stage how to behave.

4096 unique rasterizer state objects can be created on a device at a time.If an application attempts to create a rasterizer-state interface with the same state as an existing interface, the same interface will be returned and the total number of unique rasterizer state objects will stay the same. This method returns {{E_OUTOFMEMORY}} if there is insufficient memory to create the compute shader. See Direct3D 11 Return Codes for other possible return values.

<dd> Pointer to a rasterizer state description (see {{D3D11_RASTERIZER_DESC}}). </dd>

<dd> Address of a reference to the rasterizer state object created (see {{ID3D11RasterizerState}}). </dd>

Create a sampler-state object that encapsulates sampling information for a texture.

4096 unique sampler state objects can be created on a device at a time.If an application attempts to create a sampler-state interface with the same state as an existing interface, the same interface will be returned and the total number of unique sampler state objects will stay the same. This method returns one of the following Direct3D 11 Return Codes.

<dd> Pointer to a sampler state description (see {{D3D11_SAMPLER_DESC}}). </dd>

<dd> Address of a reference to the sampler state object created (see {{ID3D11SamplerState}}). </dd>

This interface encapsulates methods for querying information from the {{GPU}}.

This method returns {{E_OUTOFMEMORY}} if there is insufficient memory to create the query object. See Direct3D 11 Return Codes for other possible return values.

<dd> Pointer to a query description (see {{D3D11_QUERY_DESC}}). </dd>

<dd> Address of a reference to the query object created (see {{ID3D11Query}}). </dd>

Creates a predicate.

This method returns one of the following Direct3D 11 Return Codes.

<dd> Pointer to a query description where the type of query must be a {{D3D11_QUERY_SO_OVERFLOW_PREDICATE}} or {{D3D11_QUERY_OCCLUSION_PREDICATE}} (see {{D3D11_QUERY_DESC}}). </dd>

<dd> Address of a reference to a predicate (see {{ID3D11Predicate}}). </dd>

Create a counter object for measuring {{GPU}} performance.

If this function succeeds, it will return {{S_OK}}. If it fails, possible return values are: {{S_FALSE}}, {{E_OUTOFMEMORY}}, {{DXGI_ERROR_UNSUPPORTED}}, {{DXGI_ERROR_NONEXCLUSIVE}}, or {{E_INVALIDARG}}.{{DXGI_ERROR_UNSUPPORTED}} is returned whenever the application requests to create a well-known counter, but the current device does not support it.{{DXGI_ERROR_NONEXCLUSIVE}} indicates that another device object is currently using the counters, so they cannot be used by this device at the moment.{{E_INVALIDARG}} is returned whenever an out-of-range well-known or device-dependent counter is requested, or when the simulataneously active counters have been exhausted.

<dd> Pointer to a counter description (see {{D3D11_COUNTER_DESC}}). </dd>

<dd> Address of a reference to a counter (see {{ID3D11Counter}}). </dd>

Creates a deferred context, which can record command lists.

A deferred context is a thread-safe context that you can use to record graphics commands on a thread other than the main rendering thread. Using a deferred context, you can record graphics commands into a command list that is encapsulated by the {{ID3D11CommandList}} interface. After all scene items are recorded, you can then submit them to the main render thread for final rendering. In this manner, you can perform rendering tasks concurrently across multiple threads and potentially improve performance in multi-core {{CPU}} scenarios. You can create multiple deferred contexts. Note?? If you use the {{D3D11_CREATE_DEVICE_SINGLETHREADED}} value to create the device that is represented by {{ID3D11Device}}, the CreateDeferredContext method will fail, and you will not be able to create a deferred context.? For more information about deferred contexts, see Immediate and Deferred Rendering. Windows?Phone?8: This {{API}} is supported. Returns {{S_OK}} if successful; otherwise, returns one of the following: <ul> <li> Returns {{DXGI_ERROR_DEVICE_REMOVED}} if the video card has been physically removed from the system, or a driver upgrade for the video card has occurred. If this error occurs, you should destroy and recreate the device. </li> <li> Returns {{DXGI_ERROR_INVALID_CALL}} if the CreateDeferredContext method cannot be called from the current context. For example, if the device was created with the {{D3D11_CREATE_DEVICE_SINGLETHREADED}} value, CreateDeferredContext returns {{DXGI_ERROR_INVALID_CALL}}. </li> <li> Returns {{E_INVALIDARG}} if the ContextFlags parameter is invalid. </li> <li> Returns {{E_OUTOFMEMORY}} if the application has exhausted available memory. </li> </ul>

<dd> Reserved for future use. Pass 0. </dd>

<dd> Upon completion of the method, the passed reference to an {{ID3D11DeviceContext}} interface reference is initialized. </dd>

Give a device access to a shared resource created on a different device.

The {{REFIID}}, or {{GUID}}, of the interface to the resource can be obtained by using the __uuidof() macro. For example, __uuidof({{ID3D11Buffer}}) will get the {{GUID}} of the interface to a buffer resource.The unique handle of the resource is obtained differently depending on the type of device that originally created the resource.To share a resource between two Direct3D 11 devices the resource must have been created with the {{D3D11_RESOURCE_MISC_SHARED}} flag, if it was created using the {{ID3D11Device}} interface. If it was created using a {{DXGI}} device interface, then the resource is always shared.The {{REFIID}}, or {{GUID}}, of the interface to the resource can be obtained by using the __uuidof() macro. For example, __uuidof({{ID3D11Buffer}}) will get the {{GUID}} of the interface to a buffer resource.When sharing a resource between two Direct3D 10/11 devices the unique handle of the resource can be obtained by querying the resource for the {{IDXGIResource}} interface and then calling GetSharedHandle.<pre> {{IDXGIResource}}* pOtherResource({{NULL}}); hr = pOtherDeviceResource->QueryInterface( __uuidof({{IDXGIResource}}), (void**)&pOtherResource ); {{HANDLE}} sharedHandle; pOtherResource->GetSharedHandle(&sharedHandle); </pre>The only resources that can be shared are 2D non-mipmapped textures.To share a resource between a Direct3D 9 device and a Direct3D 11 device the texture must have been created using the pSharedHandle argument of CreateTexture. The shared Direct3D 9 handle is then passed to OpenSharedResource in the hResource argument.The following code illustrates the method calls involved.<pre> sharedHandle = {{NULL}}; // must be set to {{NULL}} to create, can use a valid handle here to open in {{D3D9}} pDevice9->CreateTexture(..., pTex2D_9, &sharedHandle); ... pDevice11->OpenSharedResource(sharedHandle, __uuidof({{ID3D11Resource}}), (void**)(&tempResource11)); tempResource11->QueryInterface(__uuidof({{ID3D11Texture2D}}), (void**)(&pTex2D_11)); tempResource11->Release(); // now use pTex2D_11 with pDevice11 </pre>Textures being shared from {{D3D9}} to {{D3D11}} have the following restrictions.<ul> <li>Textures must be 2D</li> <li>Only 1 mip level is allowed</li> <li>Texture must have default usage</li> <li>Texture must be write only</li> <li>{{MSAA}} textures are not allowed</li> <li>Bind flags must have {{SHADER_RESOURCE}} and {{RENDER_TARGET}} set</li> <li>Only {{R10G10B10A2_UNORM}}, {{R16G16B16A16_FLOAT}} and {{R8G8B8A8_UNORM}} formats are allowed</li> </ul>If a shared texture is updated on one device {{ID3D11DeviceContext::Flush}} must be called on that device. This method returns one of the following Direct3D 11 Return Codes.

<dd> A resource handle. See remarks. </dd>

<dd> The globally unique identifier ({{GUID}}) for the resource interface. See remarks. </dd>

<dd> Address of a reference to the resource we are gaining access to. </dd>

Get the support of a given format on the installed video device.

Returns {{S_OK}} if successful; otherwise, returns {{E_INVALIDARG}} if the Format parameter is {{NULL}}, or returns {{E_FAIL}} if the described format does not exist.

<dd> A {{DXGI_FORMAT}} enumeration that describes a format for which to check for support. </dd>

<dd> A bitfield of {{D3D11_FORMAT_SUPPORT}} enumeration values describing how the specified format is supported on the installed device. The values are {{ORed}} together. </dd>

Get the number of quality levels available during multisampling.

When multisampling a texture, the number of quality levels available for an adapter is dependent on the texture format used and the number of samples requested. The maximum number of quality levels is defined by {{D3D11_MAX_MULTISAMPLE_SAMPLE_COUNT}} in {{D3D11}}.h. If this method returns 0, the format and sample count combination is not supported for the installed adapter.Furthermore, the definition of a quality level is up to each hardware vendor to define, however no facility is provided by Direct3D to help discover this information.Note that {{FEATURE_LEVEL_10_1}} devices are required to support 4x {{MSAA}} for all render targets except {{R32G32B32A32}} and {{R32G32B32}}. {{FEATURE_LEVEL_11_0}} devices are required to support 4x {{MSAA}} for all render target formats, and 8x {{MSAA}} for all render target formats except {{R32G32B32A32}} formats. This method returns one of the following Direct3D 11 Return Codes.

<dd> The texture format. See {{DXGI_FORMAT}}. </dd>

<dd> The number of samples during multisampling. </dd>

<dd> Number of quality levels supported by the adapter. See remarks. </dd>

Get a counter's information.

Returns nothing.

<dd> Pointer to counter information (see {{D3D11_COUNTER_INFO}}). </dd>

Get the type, name, units of measure, and a description of an existing counter.

Length parameters can be {{NULL}}, which indicates the application is not interested in the length nor the corresponding string value. When a length parameter is non-{{NULL}} and the corresponding string is {{NULL}}, the input value of the length parameter is ignored, and the length of the corresponding string (including terminating {{NULL}}) will be returned through the length parameter. When length and the corresponding parameter are both non-{{NULL}}, the input value of length is checked to ensure there is enough room, and then the length of the string (including terminating {{NULL}} character) is passed out through the length parameter. Windows?Phone?8: This {{API}} is supported. This method returns one of the following Direct3D 11 Return Codes.

<dd> Pointer to a counter description (see {{D3D11_COUNTER_DESC}}). Specifies which counter information is to be retrieved about. </dd>

<dd> Pointer to the data type of a counter (see {{D3D11_COUNTER_TYPE}}). Specifies the data type of the counter being retrieved. </dd>

<dd> Pointer to the number of hardware counters that are needed for this counter type to be created. All instances of the same counter type use the same hardware counters. </dd>

<dd> String to be filled with a brief name for the counter. May be {{NULL}} if the application is not interested in the name of the counter. </dd>

<dd> Length of the string returned to szName. Can be {{NULL}}. </dd>

<dd> Name of the units a counter measures, provided the memory the reference points to has enough room to hold the string. Can be {{NULL}}. The returned string will always be in English. </dd>

<dd> Length of the string returned to szUnits. Can be {{NULL}}. </dd>

<dd> A description of the counter, provided the memory the reference points to has enough room to hold the string. Can be {{NULL}}. The returned string will always be in English. </dd>

<dd> Length of the string returned to szDescription. Can be {{NULL}}. </dd>

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

To query for multi-threading support, pass the {{D3D11_FEATURE_THREADING}} value to the Feature parameter, pass the {{D3D11_FEATURE_DATA_THREADING}} structure to the pFeatureSupportData parameter, and pass the size of the {{D3D11_FEATURE_DATA_THREADING}} structure to the FeatureSupportDataSize parameter.Calling CheckFeatureSupport with Feature set to {{D3D11_FEATURE_FORMAT_SUPPORT}} causes the method to return the same information that would be returned by {{ID3D11Device::CheckFormatSupport}}. Returns {{S_OK}} if successful; otherwise, returns {{E_INVALIDARG}} if an unsupported data type is passed to the pFeatureSupportData parameter or a size mismatch is detected for the FeatureSupportDataSize parameter.

<dd> A member of the {{D3D11_FEATURE}} enumerated type that describes which feature to query for support. </dd>

<dd> Upon completion of the method, the passed structure is filled with data that describes the feature support. </dd>

<dd> The size of the structure passed to the pFeatureSupportData parameter. </dd>

Get application-defined data from a device.

This method returns one of the codes described in the topic Direct3D 11 Return Codes.

<dd> Guid associated with the data. </dd>

<dd> A reference to a variable that on input contains the size, in bytes, of the buffer that pData points to, and on output contains the size, in bytes, of the amount of data that GetPrivateData retrieved. </dd>

<dd> A reference to a buffer that GetPrivateData fills with data from the device if pDataSize points to a value that specifies a buffer large enough to hold the data. </dd>

Set data to a device and associate that data with a guid.

The data stored in the device with this method can be retrieved with {{ID3D11Device::GetPrivateData}}.The data and guid set with this method will typically be application-defined.The debug layer reports memory leaks by outputting a list of object interface references along with their friendly names. The default friendly name is "<unnamed>". You can set the friendly name so that you can determine if the corresponding object interface reference caused the leak. To set the friendly name, use the SetPrivateData method and the {{WKPDID_D3DDebugObjectName}} {{GUID}} that is in {{D3Dcommon}}.h. For example, to give pContext a friendly name of My name, use the following code:<pre> static const char c_szName[] = "My name"; hr = pContext->SetPrivateData( {{WKPDID_D3DDebugObjectName}}, sizeof( c_szName ) - 1, c_szName ); </pre> This method returns one of the following Direct3D 11 Return Codes.

<dd> Guid associated with the data. </dd>

<dd> Pointer to the data to be stored with this device. If pData is {{NULL}}, DataSize must also be 0, and any data previously associated with the guid will be destroyed. </dd>

Associate an {{IUnknown}}-derived interface with this device child and associate that interface with an application-defined guid.

This method returns one of the following Direct3D 11 Return Codes.

<dd> Guid associated with the interface. </dd>

<dd> Pointer to an {{IUnknown}}-derived interface to be associated with the device child. </dd>

Gets the feature level of the hardware device.

Feature levels determine the capabilities of your device. A member of the {{D3D_FEATURE_LEVEL}} enumerated type that describes the feature level of the hardware device.

Get the flags used during the call to create the device with {{D3D11CreateDevice}}.

A bitfield containing the flags used to create the device. See {{D3D11_CREATE_DEVICE_FLAG}}.

Get the reason why the device was removed.

Possible return values include: <ul> <li>{{DXGI_ERROR_DEVICE_HUNG}}</li> <li>{{DXGI_ERROR_DEVICE_REMOVED}}</li> <li>{{DXGI_ERROR_DEVICE_RESET}}</li> <li>{{DXGI_ERROR_DRIVER_INTERNAL_ERROR}}</li> <li>{{DXGI_ERROR_INVALID_CALL}}</li> <li>{{S_OK}}</li> </ul>For more detail on these return codes, see {{DXGI_ERROR}}.

Gets an immediate context, which can play back command lists.

The GetImmediateContext method returns an {{ID3D11DeviceContext}} object that represents an immediate context which is used to perform rendering that you want immediately submitted to a device. For most applications, an immediate context is the primary object that is used to draw your scene.The GetImmediateContext method increments the reference count of the immediate context by one. Therefore, you must call Release on the returned interface reference when you are done with it to avoid a memory leak. This method does not return a value.

<dd> Upon completion of the method, the passed reference to an {{ID3D11DeviceContext}} interface reference is initialized. </dd>

Get the exception-mode flags.

Set an exception-mode flag to elevate an error condition to a non-continuable exception. Whenever an error occurs, a Direct3D device enters the {{DEVICEREMOVED}} state and if the appropriate exception flag has been set, an exception is raised. A raised exception is designed to terminate an application. Before termination, the last chance an application has to persist data is by using an UnhandledExceptionFilter (see Structured Exception Handling). In general, UnhandledExceptionFilters are leveraged to try to persist data when an application is crashing (to disk, for example). Any code that executes during an UnhandledExceptionFilter is not guaranteed to reliably execute (due to possible process corruption). Any data that the UnhandledExceptionFilter manages to persist, before the UnhandledExceptionFilter crashes again, should be treated as suspect, and therefore inspected by a new, non-corrupted process to see if it is usable. This method returns one of the following Direct3D 11 Return Codes.

<dd> A value that contains one or more exception flags; each flag specifies a condition which will cause an exception to be raised. The flags are listed in {{D3D11_RAISE_FLAG}}. A default value of 0 means there are no flags. </dd>

Get the exception-mode flags.

An exception-mode flag is used to elevate an error condition to a non-continuable exception. A value that contains one or more exception flags; each flag specifies a condition which will cause an exception to be raised. The flags are listed in {{D3D11_RAISE_FLAG}}. A default value of 0 means there are no flags.

Creates a device that represents the display adapter.

This entry-point is supported by the Direct3D 11 runtime, which is available on Windows 7, Windows Server 2008 {{R2}}, and as an update to Windows Vista ({{KB971644}}). To create a Direct3D 11.1 device ({{ID3D11Device1}}), which is available on Windows?8, Windows Server?2012, and Windows?7 and Windows Server?2008?{{R2}} with the Platform Update for Windows 7 installed, you first create a {{ID3D11Device}} with this function, and then call the QueryInterface method on the {{ID3D11Device}} object to obtain the {{ID3D11Device1}} interface. To create a Direct3D 11.2 device ({{ID3D11Device2}}), which is available on Windows?8.1 and Windows Server?2012?{{R2}}, you first create a {{ID3D11Device}} with this function, and then call the QueryInterface method on the {{ID3D11Device}} object to obtain the {{ID3D11Device2}} interface. Set ppDevice and ppImmediateContext to {{NULL}} to determine which feature level is supported by looking at pFeatureLevel without creating a device. For an example, see How To: Create a Device and Immediate Context; to create a device and a swap chain at the same time, use {{D3D11CreateDeviceAndSwapChain}}. If you set the pAdapter parameter to a non-{{NULL}} value, you must also set the DriverType parameter to the {{D3D_DRIVER_TYPE_UNKNOWN}} value. If you set the pAdapter parameter to a non-{{NULL}} value and the DriverType parameter to the {{D3D_DRIVER_TYPE_HARDWARE}} value, {{D3D11CreateDevice}} returns an {{HRESULT}} of {{E_INVALIDARG}}. <table> <tr><td> Differences between Direct3D 10 and Direct3D 11: In Direct3D 10, the presence of pAdapter dictated which adapter to use and the DriverType could mismatch what the adapter was. In Direct3D 11, if you are trying to create a hardware or a software device, set pAdapter != {{NULL}} which constrains the other inputs to be: <ul> <li>DriverType must be {{D3D_DRIVER_TYPE_UNKNOWN}} </li> <li>Software must be {{NULL}}. </li> </ul> On the other hand, if pAdapter == {{NULL}}, the DriverType cannot be set to {{D3D_DRIVER_TYPE_UNKNOWN}}; it can be set to either: <ul> <li> If DriverType == {{D3D_DRIVER_TYPE_SOFTWARE}}, Software cannot be {{NULL}}. </li> <li> If DriverType == {{D3D_DRIVER_TYPE_HARDWARE}}, the adapter used will be the default adapter, which is the first adapter that is enumerated by {{IDXGIFactory1::EnumAdapters}} </li> </ul> </td></tr> </table>? The function signature {{PFN_D3D11_CREATE_DEVICE}} is provided as a typedef, so that you can use dynamic linking techniques (GetProcAddress) instead of statically linking. Windows?Phone?8: This {{API}} is supported. Windows Phone 8.1: This {{API}} is supported. This method can return one of the Direct3D 11 Return Codes. This method returns {{E_INVALIDARG}} if you set the pAdapter parameter to a non-{{NULL}} value and the DriverType parameter to the {{D3D_DRIVER_TYPE_HARDWARE}} value. This method returns {{DXGI_ERROR_SDK_COMPONENT_MISSING}} if you specify {{D3D11_CREATE_DEVICE_DEBUG}} in Flags and the incorrect version of the debug layer is installed on your computer. Install the latest Windows {{SDK}} to get the correct version.

<dd> A reference to the video adapter to use when creating a device. Pass {{NULL}} to use the default adapter, which is the first adapter that is enumerated by {{IDXGIFactory1::EnumAdapters}}. Note?? Do not mix the use of {{DXGI}} 1.0 ({{IDXGIFactory}}) and {{DXGI}} 1.1 ({{IDXGIFactory1}}) in an application. Use {{IDXGIFactory}} or {{IDXGIFactory1}}, but not both in an application. ? </dd>

<dd> The {{D3D_DRIVER_TYPE}}, which represents the driver type to create. </dd>

<dd> The runtime layers to enable (see {{D3D11_CREATE_DEVICE_FLAG}}); values can be bitwise {{OR}}'d together. </dd>

<dd> A reference to an array of {{D3D_FEATURE_LEVEL}}s, which determine the order of feature levels to attempt to create. If pFeatureLevels is set to {{NULL}}, this function uses the following array of feature levels: <pre>{ {{D3D_FEATURE_LEVEL_11_0}}, {{D3D_FEATURE_LEVEL_10_1}}, {{D3D_FEATURE_LEVEL_10_0}}, {{D3D_FEATURE_LEVEL_9_3}}, {{D3D_FEATURE_LEVEL_9_2}}, {{D3D_FEATURE_LEVEL_9_1}}, };</pre> Note?? If the Direct3D 11.1 runtime is present on the computer and pFeatureLevels is set to {{NULL}}, this function won't create a {{D3D_FEATURE_LEVEL_11_1}} device. To create a {{D3D_FEATURE_LEVEL_11_1}} device, you must explicitly provide a {{D3D_FEATURE_LEVEL}} array that includes {{D3D_FEATURE_LEVEL_11_1}}. If you provide a {{D3D_FEATURE_LEVEL}} array that contains {{D3D_FEATURE_LEVEL_11_1}} on a computer that doesn't have the Direct3D 11.1 runtime installed, this function immediately fails with {{E_INVALIDARG}}. ? </dd>

<dd> The number of elements in pFeatureLevels. </dd>

<dd> The {{SDK}} version; use {{D3D11_SDK_VERSION}}. </dd>

<dd> Returns the address of a reference to an {{ID3D11Device}} object that represents the device created. If this parameter is {{NULL}}, no {{ID3D11Device}} will be returned. </dd>

<dd> If successful, returns the first {{D3D_FEATURE_LEVEL}} from the pFeatureLevels array which succeeded. Supply {{NULL}} as an input if you don't need to determine which feature level is supported. </dd>

<dd> Returns the address of a reference to an {{ID3D11DeviceContext}} object that represents the device context. If this parameter is {{NULL}}, no {{ID3D11DeviceContext}} will be returned. </dd>

Creates a device that represents the display adapter and a swap chain used for rendering.

Note?? If you call this method in a Session 0 process, it returns {{DXGI_ERROR_NOT_CURRENTLY_AVAILABLE}}.? This entry-point is supported by the Direct3D 11 runtime, which is available on Windows 7, Windows Server 2008 {{R2}}, and as an update to Windows Vista ({{KB971644}}). To create a Direct3D 11.1 device ({{ID3D11Device1}}), which is available on Windows?8, Windows Server?2012, and Windows?7 and Windows Server?2008?{{R2}} with the Platform Update for Windows 7 installed, you first create a {{ID3D11Device}} with this function, and then call the QueryInterface method on the {{ID3D11Device}} object to obtain the {{ID3D11Device1}} interface. To create a Direct3D 11.2 device ({{ID3D11Device2}}), which is available on Windows?8.1 and Windows Server?2012?{{R2}}, you first create a {{ID3D11Device}} with this function, and then call the QueryInterface method on the {{ID3D11Device}} object to obtain the {{ID3D11Device2}} interface. Also, see the remarks section in {{D3D11CreateDevice}} for details about input parameter dependencies. To create a device without creating a swap chain, use the {{D3D11CreateDevice}} function. If you set the pAdapter parameter to a non-{{NULL}} value, you must also set the DriverType parameter to the {{D3D_DRIVER_TYPE_UNKNOWN}} value. If you set the pAdapter parameter to a non-{{NULL}} value and the DriverType parameter to the {{D3D_DRIVER_TYPE_HARDWARE}} value, {{D3D11CreateDeviceAndSwapChain}} returns an {{HRESULT}} of {{E_INVALIDARG}}. The function signature {{PFN_D3D11_CREATE_DEVICE_AND_SWAP_CHAIN}} is provided as a typedef, so that you can use dynamic linking techniques (GetProcAddress) instead of statically linking. This method can return one of the Direct3D 11 Return Codes. This method returns {{DXGI_ERROR_NOT_CURRENTLY_AVAILABLE}} if you call it in a Session 0 process. This method returns {{E_INVALIDARG}} if you set the pAdapter parameter to a non-{{NULL}} value and the DriverType parameter to the {{D3D_DRIVER_TYPE_HARDWARE}} value. This method returns {{DXGI_ERROR_SDK_COMPONENT_MISSING}} if you specify {{D3D11_CREATE_DEVICE_DEBUG}} in Flags and the incorrect version of the debug layer is installed on your computer. Install the latest Windows {{SDK}} to get the correct version.

<dd> A reference to the video adapter to use when creating a device. Pass {{NULL}} to use the default adapter, which is the first adapter enumerated by {{IDXGIFactory1::EnumAdapters}}. Note?? Do not mix the use of {{DXGI}} 1.0 ({{IDXGIFactory}}) and {{DXGI}} 1.1 ({{IDXGIFactory1}}) in an application. Use {{IDXGIFactory}} or {{IDXGIFactory1}}, but not both in an application. ? </dd>

<dd> The {{D3D_DRIVER_TYPE}}, which represents the driver type to create. </dd>

<dd> A handle to a {{DLL}} that implements a software rasterizer. If DriverType is {{D3D_DRIVER_TYPE_SOFTWARE}}, Software must not be {{NULL}}. Get the handle by calling LoadLibrary, LoadLibraryEx , or GetModuleHandle. The value should be non-{{NULL}} when {{D3D_DRIVER_TYPE}} is {{D3D_DRIVER_TYPE_SOFTWARE}} and {{NULL}} otherwise. </dd>

<dd> The runtime layers to enable (see {{D3D11_CREATE_DEVICE_FLAG}}); values can be bitwise {{OR}}'d together. </dd>

<dd> A reference to an array of {{D3D_FEATURE_LEVEL}}s, which determine the order of feature levels to attempt to create. If pFeatureLevels is set to {{NULL}}, this function uses the following array of feature levels: <pre> { {{D3D_FEATURE_LEVEL_11_0}}, {{D3D_FEATURE_LEVEL_10_1}}, {{D3D_FEATURE_LEVEL_10_0}}, {{D3D_FEATURE_LEVEL_9_3}}, {{D3D_FEATURE_LEVEL_9_2}}, {{D3D_FEATURE_LEVEL_9_1}}, }; </pre> Note?? If the Direct3D 11.1 runtime is present on the computer and pFeatureLevels is set to {{NULL}}, this function won't create a {{D3D_FEATURE_LEVEL_11_1}} device. To create a {{D3D_FEATURE_LEVEL_11_1}} device, you must explicitly provide a {{D3D_FEATURE_LEVEL}} array that includes {{D3D_FEATURE_LEVEL_11_1}}. If you provide a {{D3D_FEATURE_LEVEL}} array that contains {{D3D_FEATURE_LEVEL_11_1}} on a computer that doesn't have the Direct3D 11.1 runtime installed, this function immediately fails with {{E_INVALIDARG}}. ? </dd>

<dd> The number of elements in pFeatureLevels. </dd>

<dd> The {{SDK}} version; use {{D3D11_SDK_VERSION}}. </dd>

<dd> A reference to a swap chain description (see {{DXGI_SWAP_CHAIN_DESC}}) that contains initialization parameters for the swap chain. </dd>

<dd> Returns the address of a reference to the {{IDXGISwapChain}} object that represents the swap chain used for rendering. </dd>

<dd> Returns a reference to a {{D3D_FEATURE_LEVEL}}, which represents the first element in an array of feature levels supported by the device. Supply {{NULL}} as an input if you don't need to determine which feature level is supported. </dd>

Note??This enumeration is supported by the Direct3D 11.1 runtime, which is available on Windows?8 and later operating systems.?Specifies how to handle the existing contents of a resource during a copy or update operation of a region within that resource.

<dd> The existing contents of the resource cannot be overwritten. </dd>

<dd> The existing contents of the resource are undefined and can be discarded. </dd>

Note??This enumeration is supported by the Direct3D 11.1 runtime, which is available on Windows?8 and later operating systems.?Specifies logical operations to configure for a render target.

<dd> Clears the render target. </dd>

<dd> Sets the render target. </dd>

<dd> Copys the render target. </dd>

<dd> Performs an inverted-copy of the render target. </dd>

<dd> No operation is performed on the render target. </dd>

<dd> Inverts the render target. </dd>

<dd> Performs a logical {{AND}} operation on the render target. </dd>

<dd> Performs a logical {{NAND}} operation on the render target. </dd>

<dd> Performs a logical {{OR}} operation on the render target. </dd>

<dd> Performs a logical {{NOR}} operation on the render target. </dd>

<dd> Performs a logical {{XOR}} operation on the render target. </dd>

<dd> Performs a logical equal operation on the render target. </dd>

<dd> Performs a logical {{AND}} and reverse operation on the render target. </dd>

<dd> Performs a logical {{AND}} and invert operation on the render target. </dd>

<dd> Performs a logical {{OR}} and reverse operation on the render target. </dd>

<dd> Performs a logical {{OR}} and invert operation on the render target. </dd>

Describes flags that are used to create a device context state object ({{ID3DDeviceContextState}}) with the {{ID3D11Device1::CreateDeviceContextState}} method.

Specifies capabilities of the video decoder.

<dd> Indicates that the graphics driver supports at least a subset of downsampling operations. </dd>

<dd> Indicates that the decoding hardware cannot support the decode operation in real-time. Decoding is still supported for transcoding scenarios. With this capability, it is possible that decoding can occur in real-time if downsampling is enabled. </dd>

<dd> Indicates that the driver supports changing down sample parameters after the initial down sample parameters have been applied. For more information, see {{ID3D11VideoContext1::DecoderUpdateDownsampling}}. </dd>

Specifies flags that indicate the most efficient methods for performing video processing operations.

<dd> Multi-plane overlay hardware can perform the rotation operation more efficiently than the {{ID3D11VideoContext::VideoProcessorBlt}} method. </dd>

<dd> Multi-plane overlay hardware can perform the scaling operation more efficiently than the {{ID3D11VideoContext::VideoProcessorBlt}} method. </dd>

<dd> Multi-plane overlay hardware can perform the colorspace conversion operation more efficiently than the {{ID3D11VideoContext::VideoProcessorBlt}} method. </dd>

<dd> The video processor output data should be at least triple buffered for optimal performance. </dd>

Represents the status of an {{ID3D11CryptoSession}} interface.

Note??This structure is supported by the Direct3D 11.1 runtime, which is available on Windows?8 and later operating systems.?Describes the blend state for a render target.

You specify an array of {{D3D11_RENDER_TARGET_BLEND_DESC1}} structures in the RenderTarget member of the {{D3D11_BLEND_DESC1}} structure to describe the blend states for render targets; you can bind up to eight render targets to the output-merger stage at one time.For info about how blending is done, see the output-merger stage.Here are the default values for blend state.<table> <tr><th>State</th><th>Default Value</th></tr> <tr><td>BlendEnable</td><td>{{FALSE}}</td></tr> <tr><td>LogicOpEnable</td><td>{{FALSE}}</td></tr> <tr><td>SrcBlend</td><td>{{D3D11_BLEND_ONE}}</td></tr> <tr><td>DestBlend</td><td>{{D3D11_BLEND_ZERO}}</td></tr> <tr><td>BlendOp</td><td>{{D3D11_BLEND_OP_ADD}}</td></tr> <tr><td>SrcBlendAlpha</td><td>{{D3D11_BLEND_ONE}}</td></tr> <tr><td>DestBlendAlpha</td><td>{{D3D11_BLEND_ZERO}}</td></tr> <tr><td>BlendOpAlpha</td><td>{{D3D11_BLEND_OP_ADD}}</td></tr> <tr><td>LogicOp</td><td>{{D3D11_LOGIC_OP_NOOP}}</td></tr> <tr><td>RenderTargetWriteMask</td><td>{{D3D11_COLOR_WRITE_ENABLE_ALL}}</td></tr> </table>?

<dd> Enable (or disable) blending. </dd>

<dd> Enable (or disable) a logical operation. </dd>

<dd> This blend operation defines how to combine the SrcBlend and DestBlend operations. </dd>

<dd> This blend operation defines how to combine the SrcBlendAlpha and DestBlendAlpha operations. </dd>

<dd> A {{D3D11_LOGIC_OP}}-typed value that specifies the logical operation to configure for the render target. </dd>

<dd> A write mask. </dd>

Note?? This structure is supported by the Direct3D 11.1 runtime, which is available on Windows?8 and later operating systems.? Describes the blend state that you use in a call to {{ID3D11Device1::CreateBlendState1}} to create a blend-state object.

Here are the default values for blend state. <table> <tr><th>State</th><th>Default Value</th></tr> <tr><td>AlphaToCoverageEnable</td><td>{{FALSE}}</td></tr> <tr><td>IndependentBlendEnable</td><td>{{FALSE}}</td></tr> <tr><td>RenderTarget[0].BlendEnable</td><td>{{FALSE}}</td></tr> <tr><td>RenderTarget[0].LogicOpEnable</td><td>{{FALSE}}</td></tr> <tr><td>RenderTarget[0].SrcBlend</td><td>{{D3D11_BLEND_ONE}}</td></tr> <tr><td>RenderTarget[0].DestBlend</td><td>{{D3D11_BLEND_ZERO}}</td></tr> <tr><td>RenderTarget[0].BlendOp</td><td>{{D3D11_BLEND_OP_ADD}}</td></tr> <tr><td>RenderTarget[0].SrcBlendAlpha</td><td>{{D3D11_BLEND_ONE}}</td></tr> <tr><td>RenderTarget[0].DestBlendAlpha</td><td>{{D3D11_BLEND_ZERO}}</td></tr> <tr><td>RenderTarget[0].BlendOpAlpha</td><td>{{D3D11_BLEND_OP_ADD}}</td></tr> <tr><td>RenderTarget[0].LogicOp</td><td>{{D3D11_LOGIC_OP_NOOP}}</td></tr> <tr><td>RenderTarget[0].RenderTargetWriteMask</td><td>{{D3D11_COLOR_WRITE_ENABLE_ALL}}</td></tr> </table>? If the driver type is set to {{D3D_DRIVER_TYPE_HARDWARE}}, the feature level is set to less than or equal to {{D3D_FEATURE_LEVEL_9_3}}, and the pixel format of the render target is set to {{DXGI_FORMAT_R8G8B8A8_UNORM_SRGB}}, {{DXGI_FORMAT_B8G8R8A8_UNORM_SRGB}}, or {{DXGI_FORMAT_B8G8R8X8_UNORM_SRGB}}, the display device performs the blend in standard {{RGB}} (sRGB) space and not in linear space. However, if the feature level is set to greater than {{D3D_FEATURE_LEVEL_9_3}}, the display device performs the blend in linear space, which is ideal. When you set the LogicOpEnable member of the first element of the RenderTarget array (RenderTarget[0]) to {{TRUE}}, you must also set the BlendEnable member of RenderTarget[0] to {{FALSE}}, and the IndependentBlendEnable member of this {{D3D11_BLEND_DESC1}} to {{FALSE}}. This reflects the limitation in hardware that you can't mix logic operations with blending across multiple render targets, and that when you use a logic operation, you must apply the same logic operation to all render targets.

Note??This structure is supported by the Direct3D 11.1 runtime, which is available on Windows?8 and later operating systems.?Describes rasterizer state.

Rasterizer state defines the behavior of the rasterizer stage. To create a rasterizer-state object, call {{ID3D11Device1::CreateRasterizerState1}}. To set rasterizer state, call {{ID3D11DeviceContext::RSSetState}}.If you do not specify some rasterizer state, the Direct3D runtime uses the following default values for rasterizer state.<table> <tr><th>State</th><th>Default Value</th></tr> <tr><td>FillMode</td><td>Solid</td></tr> <tr><td>CullMode</td><td>Back</td></tr> <tr><td>FrontCounterClockwise</td><td>{{FALSE}}</td></tr> <tr><td>DepthBias</td><td>0</td></tr> <tr><td>SlopeScaledDepthBias</td><td>0.0f</td></tr> <tr><td>DepthBiasClamp</td><td>0.0f</td></tr> <tr><td>DepthClipEnable</td><td>{{TRUE}}</td></tr> <tr><td>ScissorEnable</td><td>{{FALSE}}</td></tr> <tr><td>MultisampleEnable</td><td>{{FALSE}}</td></tr> <tr><td>AntialiasedLineEnable</td><td>{{FALSE}}</td></tr> <tr><td>ForcedSampleCount</td><td>0</td></tr> </table>?Note??For feature levels 9.1, 9.2, 9.3, and 10.0, if you set MultisampleEnable to {{FALSE}}, the runtime renders all points, lines, and triangles without anti-aliasing even for render targets with a sample count greater than 1. For feature levels 10.1 and higher, the setting of MultisampleEnable has no effect on points and triangles with regard to {{MSAA}} and impacts only the selection of the line-rendering algorithm as shown in this table:? <table> <tr><th>Line-rendering algorithm</th><th>MultisampleEnable</th><th>AntialiasedLineEnable</th></tr> <tr><td>Aliased</td><td>{{FALSE}}</td><td>{{FALSE}}</td></tr> <tr><td>Alpha antialiased</td><td>{{FALSE}}</td><td>{{TRUE}}</td></tr> <tr><td>Quadrilateral</td><td>{{TRUE}}</td><td>{{FALSE}}</td></tr> <tr><td>Quadrilateral</td><td>{{TRUE}}</td><td>{{TRUE}}</td></tr> </table>?The settings of the MultisampleEnable and AntialiasedLineEnable members apply only to multisample antialiasing ({{MSAA}}) render targets (that is, render targets with sample counts greater than 1). Because of the differences in feature-level behavior and as long as you aren?t performing any line drawing or don?t mind that lines render as quadrilaterals, we recommend that you always set MultisampleEnable to {{TRUE}} whenever you render on {{MSAA}} render targets.

<dd> Determines the fill mode to use when rendering. </dd>

<dd> Indicates that triangles facing the specified direction are not drawn. </dd>

<dd> Specifies whether a triangle is front- or back-facing. If {{TRUE}}, a triangle will be considered front-facing if its vertices are counter-clockwise on the render target and considered back-facing if they are clockwise. If {{FALSE}}, the opposite is true. </dd>

<dd> Depth value added to a given pixel. For info about depth bias, see Depth Bias. </dd>

<dd> Maximum depth bias of a pixel. For info about depth bias, see Depth Bias. </dd>

<dd> Scalar on a given pixel's slope. For info about depth bias, see Depth Bias. </dd>

<dd> Specifies whether to enable clipping based on distance. The hardware always performs x and y clipping of rasterized coordinates. When DepthClipEnable is set to the default?{{TRUE}}, the hardware also clips the z value (that is, the hardware performs the last step of the following algorithm). <code> 0 < w -w <= x <= w (or arbitrarily wider range if implementation uses a guard band to reduce clipping burden) -w <= y <= w (or arbitrarily wider range if implementation uses a guard band to reduce clipping burden) 0 <= z <= w </code> When you set DepthClipEnable to {{FALSE}}, the hardware skips the z clipping (that is, the last step in the preceding algorithm). However, the hardware still performs the "0 < w" clipping. When z clipping is disabled, improper depth ordering at the pixel level might result. However, when z clipping is disabled, stencil shadow implementations are simplified. In other words, you can avoid complex special-case handling for geometry that goes beyond the back clipping plane. </dd>

<dd> Specifies whether to enable scissor-rectangle culling. All pixels outside an active scissor rectangle are culled. </dd>

<dd> The sample count that is forced while {{UAV}} rendering or rasterizing. Valid values are 0, 1, 2, 4, 8, and optionally 16. 0 indicates that the sample count is not forced. Note??If you want to render with ForcedSampleCount set to 1 or greater, you must follow these guidelines: <ul> <li>Don't bind depth-stencil views.</li> <li>Disable depth testing.</li> <li>Ensure the shader doesn't output depth.</li> <li>If you have any render-target views bound ({{D3D11_BIND_RENDER_TARGET}}) and ForcedSampleCount is greater than 1, ensure that every render target has only a single sample.</li> <li>Don't operate the shader at sample frequency. Therefore, {{ID3D11ShaderReflection::IsSampleFrequencyShader}} returns {{FALSE}}.</li> </ul>Otherwise, rendering behavior is undefined. For info about how to configure depth-stencil, see Configuring Depth-Stencil Functionality. ? </dd>

Values in the sub sample mapping blocks are relative to the start of the decode buffer.

<dd> The number of clear (non-encrypted) bytes at the start of the block. </dd>

<dd> The number of encrypted bytes following the clear bytes. </dd>

<dd> The type of buffer. </dd>

<dd> The offset of the relevant data from the beginning of the buffer, in bytes. This value must be zero. </dd>

<dd> Size of the relevant data. </dd>

<dd> A reference to a buffer that contains an initialization vector ({{IV}}) for encrypted data. If the decode buffer does not contain encrypted data, set this member to {{NULL}}. </dd>

<dd> The size of the buffer specified in the pIV parameter. If pIV is {{NULL}}, set this member to zero. </dd>

<dd> A reference to an array of {{D3D11_VIDEO_DECODER_SUB_SAMPLE_MAPPING_BLOCK}} structures, which indicates exactly which bytes in the decode buffer are encrypted and which are in the clear. If the decode buffer does not contain encrypted data, set this member to {{NULL}}. Values in the sub sample mapping blocks are relative to the start of the decode buffer. </dd>

<dd> The number of {{D3D11_VIDEO_DECODER_SUB_SAMPLE_MAPPING_BLOCK}} structures specified in the pSubSampleMappingBlocks parameter. If pSubSampleMappingBlocks is {{NULL}}, set this member to zero. </dd>

[Some information relates to pre-released product which may be substantially modified before it's commercially released. Microsoft makes no warranties, express or implied, with respect to the information provided here.]Provides data to the {{ID3D11VideoContext::DecoderBeginFrame}} method.

This structure is passed in the pContentKey parameter of the {{ID3D11VideoContext::DecoderBeginFrame}} function when {{D3D11_DECODER_ENCRYPTION_HW_CENC}} is specified in the guidConfigBitstreamEncryption member of the {{D3D11_VIDEO_DECODER_CONFIG}} structure when creating the video decoder interface.

[Some information relates to pre-released product which may be substantially modified before it's commercially released. Microsoft makes no warranties, express or implied, with respect to the information provided here.]Provides information about the input streams passed into the {{ID3DVideoContext1::VideoProcessorGetBehaviorHints}} method.

<dd> The size of the private data reserved for {{IHV}} usage. This size is determined from the pPrivateInputSize parameter returned by the {{ID3D11VideoDevice1::GetCryptoSessionPrivateDataSize}} function. </dd>

<dd> The size of the {{DRM}} command data. </dd>

<dd> If PrivateDataSize is greater than 0, pbInput[0] ? pbInput[PrivateDataSize - 1] is reserved for {{IHV}} use. pbInput[PrivateDataSize] ? pbInput[{{HWProtectionDataSize}} + PrivateDataSize - 1] contains the input data for the {{DRM}} command. The format and size of the {{DRM}} command is defined by the {{DRM}} specification. </dd>

<dd> The size of the private data reserved for {{IHV}} usage. This size is determined from the pPrivateOutputSize parameter returned by the {{ID3D11VideoDevice1::GetCryptoSessionPrivateDataSize}} function. </dd>

<dd> The maximum size of data that the driver can return in the output buffer. The last byte that it can write to is pbOuput[PrivateDataSize + MaxHWProtectionDataSize ? 1]. </dd>

<dd> The size of the output data written by the driver. </dd>

<dd> The number of 100 nanosecond units spent transporting the data. </dd>

<dd> The number of 100 nanosecond units spent executing the content protection command. </dd>

<dd> If PrivateDataSize is greater than 0, pbInput[0] ? pbOutput[PrivateDataSize - 1] is reserved for {{IHV}} use. pbOutput[PrivateDataSize] ? pbOutput[{{HWProtectionDataSize}} + PrivateDataSize - 1] contains the input data for the {{DRM}} command. The format and size of the {{DRM}} command is defined by the {{DRM}} specification. </dd>

A reference to this structure is passed in the pData parameter of {{ID3D11VideoContext::NegotiateCryptoSessionKeyExchange}} method when the {{ID3D11CryptoSession}} is creating using the {{D3D11_KEY_EXCHANGE_HW_PROTECTION}} key exchange type.

<dd> The function {{ID}} of the {{DRM}} command. The values and meanings of the function {{ID}} are defined by the {{DRM}} specification. </dd>

<dd> Pointer to a buffer containing a {{D3D11_KEY_EXCHANGE_HW_PROTECTION_INPUT_DATA}} structure that specifies memory reserved for {{IHV}} use and the input data for the {{DRM}} command. </dd>

<dd> Pointer to a buffer containing a {{D3D11_KEY_EXCHANGE_HW_PROTECTION_OUTPUT_DATA}} structure that specifies memory reserved for {{IHV}} use and the input data for the {{DRM}} command. </dd>

<dd> The result of the hardware {{DRM}} command. </dd>

<dd> The width of the video sample. </dd>

<dd> The height of the video sample. </dd>

<dd> The format of the video sample. </dd>

<dd> The colorspace of the sample. </dd>

The blend-state interface holds a description for blending state that you can bind to the output-merger stage. This blend-state interface supports logical operations as well as blending operations.

Blending applies a simple function to combine output values from a pixel shader with data in a render target. You have control over how the pixels are blended by using a predefined set of blending operations and preblending operations.To create a blend-state object, call {{ID3D11Device1::CreateBlendState1}}. To bind the blend-state object to the output-merger stage, call {{ID3D11DeviceContext::OMSetBlendState}}.

Gets the description for blending state that you used to create the blend-state object.

You use the description for blending state in a call to the {{ID3D11Device1::CreateBlendState1}} method to create the blend-state object. Returns nothing.

<dd> A reference to a {{D3D11_BLEND_DESC1}} structure that receives a description of the blend state. This blend state can specify logical operations as well as blending operations. </dd>

The rasterizer-state interface holds a description for rasterizer state that you can bind to the rasterizer stage. This rasterizer-state interface supports forced sample count.

To create a rasterizer-state object, call {{ID3D11Device1::CreateRasterizerState1}}. To bind the rasterizer-state object to the rasterizer stage, call {{ID3D11DeviceContext::RSSetState}}.

Gets the description for rasterizer state that you used to create the rasterizer-state object.

You use the description for rasterizer state in a call to the {{ID3D11Device1::CreateRasterizerState1}} method to create the rasterizer-state object. Returns nothing.

<dd> A reference to a {{D3D11_RASTERIZER_DESC1}} structure that receives a description of the rasterizer state. This rasterizer state can specify forced sample count. </dd>

The {{ID3DDeviceContextState}} interface represents a context state object, which holds state and behavior information about a Microsoft Direct3D device.

The device context interface represents a device context; it is used to render commands. {{ID3D11DeviceContext1}} adds new methods to those in {{ID3D11DeviceContext}}.

Copies a region from a source resource to a destination resource.

If the display driver supports overlapping, the source and destination subresources can be identical, and the source and destination regions can overlap each other. For existing display drivers that don?t support overlapping, the runtime drops calls with identical source and destination subresources, regardless of whether the regions overlap. To determine whether the display driver supports overlapping, check the CopyWithOverlap member of {{D3D11_FEATURE_DATA_D3D11_OPTIONS}}. This overlapping support enables additional scroll functionality in a call to {{IDXGISwapChain::Present}}.Note??Applies only to feature level 9_x hardware If you use {{ID3D11DeviceContext1::UpdateSubresource1}} or CopySubresourceRegion1 to copy from a staging resource to a default resource, you can corrupt the destination contents. This occurs if you pass a {{NULL}} source box and if the source resource has different dimensions from those of the destination resource or if you use destination offsets, (x, y, and z). In this situation, always pass a source box that is the full size of the source resource.? Returns nothing

<dd> A reference to the destination resource. </dd>

<dd> Destination subresource index. </dd>

<dd> The x-coordinate of the upper-left corner of the destination region. </dd>

<dd> The y-coordinate of the upper-left corner of the destination region. For a 1D subresource, this must be zero. </dd>

<dd> The z-coordinate of the upper-left corner of the destination region. For a 1D or 2D subresource, this must be zero. </dd>

<dd> A reference to the source resource. </dd>

<dd> Source subresource index. </dd>

<dd> A reference to a 3D box that defines the region of the source subresource that CopySubresourceRegion1 can copy. If {{NULL}}, CopySubresourceRegion1 copies the entire source subresource. The box must fit within the source resource. An empty box results in a no-op. A box is empty if the top value is greater than or equal to the bottom value, or the left value is greater than or equal to the right value, or the front value is greater than or equal to the back value. When the box is empty, CopySubresourceRegion1 doesn't perform a copy operation. </dd>

<dd> A {{D3D11_COPY_FLAGS}}-typed value that specifies how to perform the copy operation. If you specify zero for no copy option, CopySubresourceRegion1 behaves like {{ID3D11DeviceContext::CopySubresourceRegion}}. For existing display drivers that can't process these flags, the runtime doesn't use them. </dd>

The {{CPU}} copies data from memory to a subresource created in non-mappable memory.

If you call UpdateSubresource1 to update a constant buffer, pass any region, and the driver has not been implemented to Windows?8, the runtime drops the call (except feature level 9.1, 9.2, and 9.3 where the runtime emulates support). The runtime also drops the call if you update a constant buffer with a partial region whose extent is not aligned to 16-byte granularity (16 bytes being a full constant). When the runtime drops the call, the runtime doesn't call the corresponding device driver interface ({{DDI}}).When you record a call to UpdateSubresource with an offset pDstBox in a software command list, the offset in pDstBox is incorrectly applied to pSrcData when you play back the command list. The new-for-Windows?8UpdateSubresource1 fixes this issue. In a call to UpdateSubresource1, pDstBox does not affect pSrcData.For info about various resource types and how UpdateSubresource1 might work with each resource type, see Introduction to a Resource in Direct3D 11. Note??Applies only to feature level 9_x hardware If you use UpdateSubresource1 or {{ID3D11DeviceContext1::CopySubresourceRegion1}} to copy from a staging resource to a default resource, you can corrupt the destination contents. This occurs if you pass a {{NULL}} source box and if the source resource has different dimensions from those of the destination resource or if you use destination offsets, (x, y, and z). In this situation, always pass a source box that is the full size of the source resource.? Returns nothing.

<dd> A reference to the destination resource. </dd>

<dd> A zero-based index that identifies the destination subresource. See {{D3D11CalcSubresource}} for more details. </dd>

<dd> A reference to a box that defines the portion of the destination subresource to copy the resource data into. Coordinates are in bytes for buffers and in texels for textures. If {{NULL}}, UpdateSubresource1 writes the data to the destination subresource with no offset. The dimensions of the source must fit the destination. An empty box results in a no-op. A box is empty if the top value is greater than or equal to the bottom value, or the left value is greater than or equal to the right value, or the front value is greater than or equal to the back value. When the box is empty, UpdateSubresource1 doesn't perform an update operation. </dd>

<dd> A reference to the source data in memory. </dd>

<dd> The size of one row of the source data. </dd>

<dd> The size of one depth slice of source data. </dd>

<dd> A {{D3D11_COPY_FLAGS}}-typed value that specifies how to perform the update operation. If you specify zero for no update option, UpdateSubresource1 behaves like {{ID3D11DeviceContext::UpdateSubresource}}. For existing display drivers that can't process these flags, the runtime doesn't use them. </dd>

Discards a resource from the device context.

DiscardResource informs the graphics processing unit ({{GPU}}) that the existing content in the resource that pResource points to is no longer needed. Returns nothing

<dd> A reference to the {{ID3D11Resource}} interface for the resource to discard. The resource must have been created with usage {{D3D11_USAGE_DEFAULT}} or {{D3D11_USAGE_DYNAMIC}}, otherwise the runtime drops the call to DiscardResource; if the debug layer is enabled, the runtime returns an error message. </dd>

Discards a resource view from the device context.

DiscardView informs the graphics processing unit ({{GPU}}) that the existing content in the resource view that pResourceView points to is no longer needed. The view can be an {{SRV}}, {{RTV}}, {{UAV}}, or {{DSV}}. DiscardView is a variation on the DiscardResource method. DiscardView allows you to discard a subset of a resource that is in a view (such as a single miplevel). More importantly, DiscardView provides a convenience because often views are what are being bound and unbound at the pipeline. Some pipeline bindings do not have views, such as stream output. In that situation, DiscardResource can do the job for any resource. Returns nothing

<dd> A reference to the {{ID3D11View}} interface for the resource view to discard. The resource that underlies the view must have been created with usage {{D3D11_USAGE_DEFAULT}} or {{D3D11_USAGE_DYNAMIC}}, otherwise the runtime drops the call to DiscardView; if the debug layer is enabled, the runtime returns an error message. </dd>

Sets the constant buffers that the vertex shader pipeline stage uses.

The runtime drops the call to {{VSSetConstantBuffers1}} if the number of constants to which pNumConstants points is larger than the maximum constant buffer size that is supported by shaders (4096 constants). The values in the elements of the pFirstConstant and pFirstConstant + pNumConstants arrays can exceed the length of each buffer; from the shader's point of view, the constant buffer is the intersection of the actual memory allocation for the buffer and the window [value in an element of pFirstConstant, value in an element of pFirstConstant + value in an element of pNumConstants]. The runtime also drops the call to {{VSSetConstantBuffers1}} on existing drivers that don't support this offsetting.The runtime will emulate this feature for feature level 9.1, 9.2, and 9.3; therefore, this feature is supported for feature level 9.1, 9.2, and 9.3. This feature is always available on new drivers for feature level 10 and higher.From the shader?s point of view, element [0] in the constant buffers array is the constant at pFirstConstant.Out of bounds access to the constant buffers from the shader to the range that is defined by pFirstConstant and pNumConstants returns 0. If pFirstConstant and pNumConstants arrays are {{NULL}}, you get the same result as if you were binding the entire buffer into view. You get this same result if you call the {{VSSetConstantBuffers}} method. If the buffer is larger than the maximum constant buffer size that is supported by shaders (4096 elements), the shader can access only the first 4096 constants.If either pFirstConstant or pNumConstants is {{NULL}}, the other parameter must also be {{NULL}}. Returns nothing.

<dd> Index into the device's zero-based array to begin setting constant buffers to (ranges from 0 to {{D3D11_COMMONSHADER_CONSTANT_BUFFER_API_SLOT_COUNT}} - 1). </dd>

<dd> Number of buffers to set (ranges from 0 to {{D3D11_COMMONSHADER_CONSTANT_BUFFER_API_SLOT_COUNT}} - StartSlot). </dd>

<dd> Array of constant buffers being given to the device. </dd>

<dd> An array that holds the offsets into the buffers that ppConstantBuffers specifies. Each offset specifies where, from the shader's point of view, each constant buffer starts. Each offset is measured in shader constants, which are 16 bytes (4*32-bit components). Therefore, an offset of 16 indicates that the start of the associated constant buffer is 256 bytes into the constant buffer. Each offset must be a multiple of 16 constants. </dd>

<dd> An array that holds the numbers of constants in the buffers that ppConstantBuffers specifies. Each number specifies the number of constants that are contained in the constant buffer that the shader uses. Each number of constants starts from its respective offset that is specified in the pFirstConstant array. Each number of constants must be a multiple of 16 constants, in the range [0..4096]. </dd>

Sets the constant buffers that the hull-shader stage of the pipeline uses.

The runtime drops the call to {{HSSetConstantBuffers1}} if the number of constants to which pNumConstants points is larger than the maximum constant buffer size that is supported by shaders (4096 constants). The values in the elements of the pFirstConstant and pFirstConstant + pNumConstants arrays can exceed the length of each buffer; from the shader's point of view, the constant buffer is the intersection of the actual memory allocation for the buffer and the window [value in an element of pFirstConstant, value in an element of pFirstConstant + value in an element of pNumConstants]. The runtime also drops the call to {{HSSetConstantBuffers1}} on existing drivers that don't support this offsetting.The runtime will emulate this feature for feature level 9.1, 9.2, and 9.3; therefore, this feature is supported for feature level 9.1, 9.2, and 9.3. This feature is always available on new drivers for feature level 10 and higher.From the shader?s point of view, element [0] in the constant buffers array is the constant at pFirstConstant.Out of bounds access to the constant buffers from the shader to the range that is defined by pFirstConstant and pNumConstants returns 0. If the pFirstConstant and pNumConstants arrays are {{NULL}}, you get the same result as if you were binding the entire buffer into view. You get this same result if you call the {{HSSetConstantBuffers}} method. If the buffer is larger than the maximum constant buffer size that is supported by shaders (4096 elements), the shader can access only the first 4096 constants.If either pFirstConstant or pNumConstants is {{NULL}}, the other parameter must also be {{NULL}}. Returns nothing

Sets the constant buffers that the domain-shader stage uses.

The runtime drops the call to {{DSSetConstantBuffers1}} if the number of constants to which pNumConstants points is larger than the maximum constant buffer size that is supported by shaders (4096 constants). The values in the elements of the pFirstConstant and pFirstConstant + pNumConstants arrays can exceed the length of each buffer; from the shader's point of view, the constant buffer is the intersection of the actual memory allocation for the buffer and the window [value in an element of pFirstConstant, value in an element of pFirstConstant + value in an element of pNumConstants]. The runtime also drops the call to {{DSSetConstantBuffers1}} on existing drivers that don't support this offsetting.The runtime will emulate this feature for feature level 9.1, 9.2, and 9.3; therefore, this feature is supported for feature level 9.1, 9.2, and 9.3. This feature is always available on new drivers for feature level 10 and higher.From the shader?s point of view, element [0] in the constant buffers array is the constant at pFirstConstant.Out of bounds access to the constant buffers from the shader to the range that is defined by pFirstConstant and pNumConstants returns 0. If pFirstConstant and pNumConstants arrays are {{NULL}}, you get the same result as if you were binding the entire buffer into view. You get this same result if you call the {{DSSetConstantBuffers}} method. If the buffer is larger than the maximum constant buffer size that is supported by shaders (4096 elements), the shader can access only the first 4096 constants.If either pFirstConstant or pNumConstants is {{NULL}}, the other parameter must also be {{NULL}}. Returns nothing

<dd> Index into the zero-based array to begin setting constant buffers to (ranges from 0 to {{D3D11_COMMONSHADER_CONSTANT_BUFFER_API_SLOT_COUNT}} - 1). </dd>

<dd> Number of buffers to set (ranges from 0 to {{D3D11_COMMONSHADER_CONSTANT_BUFFER_API_SLOT_COUNT}} - StartSlot). </dd>

<dd> Array of constant buffers being given to the device. </dd>

Sets the constant buffers that the geometry shader pipeline stage uses.

The runtime drops the call to {{GSSetConstantBuffers1}} if the number of constants to which pNumConstants points is larger than the maximum constant buffer size that is supported by shaders (4096 constants). The values in the elements of the pFirstConstant and pFirstConstant + pNumConstants arrays can exceed the length of each buffer; from the shader's point of view, the constant buffer is the intersection of the actual memory allocation for the buffer and the window [value in an element of pFirstConstant, value in an element of pFirstConstant + value in an element of pNumConstants]. The runtime also drops the call to {{GSSetConstantBuffers1}} on existing drivers that don't support this offsetting.The runtime will emulate this feature for feature level 9.1, 9.2, and 9.3; therefore, this feature is supported for feature level 9.1, 9.2, and 9.3. This feature is always available on new drivers for feature level 10 and higher.From the shader?s point of view, element [0] in the constant buffers array is the constant at pFirstConstant.Out of bounds access to the constant buffers from the shader to the range that is defined by pFirstConstant and pNumConstants returns 0. If pFirstConstant and pNumConstants arrays are {{NULL}}, you get the same result as if you were binding the entire buffer into view. You get this same result if you call the {{GSSetConstantBuffers}} method. If the buffer is larger than the maximum constant buffer size that is supported by shaders (4096 elements), the shader can access only the first 4096 constants.If either pFirstConstant or pNumConstants is {{NULL}}, the other parameter must also be {{NULL}}. Returns nothing.

<dd> Index into the device's zero-based array to begin setting constant buffers to (ranges from 0 to {{D3D11_COMMONSHADER_CONSTANT_BUFFER_API_SLOT_COUNT}} - 1). </dd>

<dd> Number of buffers to set (ranges from 0 to {{D3D11_COMMONSHADER_CONSTANT_BUFFER_API_SLOT_COUNT}} - StartSlot). </dd>

<dd> Array of constant buffers (see {{ID3D11Buffer}}) being given to the device. </dd>

Sets the constant buffers that the pixel shader pipeline stage uses, and enables the shader to access other parts of the buffer.

To enable the shader to access other parts of the buffer, call {{PSSetConstantBuffers1}} instead of {{PSSetConstantBuffers}}. {{PSSetConstantBuffers1}} has additional parameters pFirstConstant and pNumConstants. The runtime drops the call to {{PSSetConstantBuffers1}} if the numbers of constants to which pNumConstants points is larger than the maximum constant buffer size that is supported by shaders. The maximum constant buffer size that is supported by shaders holds 4096 constants, where each constant has four 32-bit components. The values in the elements of the pFirstConstant and pFirstConstant + pNumConstants arrays can exceed the length of each buffer; from the shader's point of view, the constant buffer is the intersection of the actual memory allocation for the buffer and the following window (range): [value in an element of pFirstConstant, value in an element of pFirstConstant + value in an element of pNumConstants] That is, the window is the range is from (value in an element of pFirstConstant) to (value in an element of pFirstConstant + value in an element of pNumConstants). The runtime also drops the call to {{PSSetConstantBuffers1}} on existing drivers that do not support this offsetting. The runtime will emulate this feature for feature level 9.1, 9.2, and 9.3; therefore, this feature is supported for feature level 9.1, 9.2, and 9.3. This feature is always available on new drivers for feature level 10 and higher. From the shader?s point of view, element [0] in the constant buffers array is the constant at pFirstConstant. Out of bounds access to the constant buffers from the shader to the range that is defined by pFirstConstant and pNumConstants returns 0. If pFirstConstant and pNumConstants arrays are {{NULL}}, you get the same result as if you were binding the entire buffer into view. You get this same result if you call the {{PSSetConstantBuffers}} method. If the buffer is larger than the maximum constant buffer size that is supported by shaders (4096 elements), the shader can access only the first 4096 constants. If either pFirstConstant or pNumConstants is {{NULL}}, the other parameter must also be {{NULL}}. Returns nothing.

<dd> Index into the device's zero-based array to begin setting constant buffers to (ranges from 0 to {{D3D11_COMMONSHADER_CONSTANT_BUFFER_API_SLOT_COUNT}} - 1). </dd>

<dd> Number of buffers to set (ranges from 0 to {{D3D11_COMMONSHADER_CONSTANT_BUFFER_API_SLOT_COUNT}} - StartSlot). </dd>

<dd> Array of constant buffers being given to the device. </dd>

<dd> An array that holds the offsets into the buffers that ppConstantBuffers specifies. Each offset specifies where, from the shader's point of view, each constant buffer starts. Each offset is measured in shader constants, which are 16 bytes (4*32-bit components). Therefore, an offset of 16 indicates that the start of the associated constant buffer is 256 bytes into the constant buffer. Each offset must be a multiple of 16 constants. </dd>

<dd> An array that holds the numbers of constants in the buffers that ppConstantBuffers specifies. Each number specifies the number of constants that are contained in the constant buffer that the shader uses. Each number of constants starts from its respective offset that is specified in the pFirstConstant array. Each number of constants must be a multiple of 16 constants, in the range [0..4096]. </dd>

Sets the constant buffers that the compute-shader stage uses.

The runtime drops the call to {{CSSetConstantBuffers1}} if the number of constants to which pNumConstants points is larger than the maximum constant buffer size that is supported by shaders (4096 constants). The values in the elements of the pFirstConstant and pFirstConstant + pNumConstants arrays can exceed the length of each buffer; from the shader's point of view, the constant buffer is the intersection of the actual memory allocation for the buffer and the window [value in an element of pFirstConstant, value in an element of pFirstConstant + value in an element of pNumConstants]. The runtime also drops the call to {{CSSetConstantBuffers1}} on existing drivers that don't support this offsetting.The runtime will emulate this feature for feature level 9.1, 9.2, and 9.3; therefore, this feature is supported for feature level 9.1, 9.2, and 9.3. This feature is always available on new drivers for feature level 10 and higher.From the shader?s point of view, element [0] in the constant buffers array is the constant at pFirstConstant.Out of bounds access to the constant buffers from the shader to the range that is defined by pFirstConstant and pNumConstants returns 0. If pFirstConstant and pNumConstants arrays are {{NULL}}, you get the same result as if you were binding the entire buffer into view. You get this same result if you call the {{CSSetConstantBuffers}} method. If the buffer is larger than the maximum constant buffer size that is supported by shaders (4096 elements), the shader can access only the first 4096 constants.If either pFirstConstant or pNumConstants is {{NULL}}, the other parameter must also be {{NULL}}. Returns nothing.

<dd> Index into the zero-based array to begin setting constant buffers to (ranges from 0 to {{D3D11_COMMONSHADER_CONSTANT_BUFFER_API_SLOT_COUNT}} - 1). </dd>

<dd> Number of buffers to set (ranges from 0 to {{D3D11_COMMONSHADER_CONSTANT_BUFFER_API_SLOT_COUNT}} - StartSlot). </dd>

<dd> Array of constant buffers (see {{ID3D11Buffer}}) being given to the device. </dd>

Gets the constant buffers that the vertex shader pipeline stage uses.

If no buffer is bound at a slot, pFirstConstant and pNumConstants are {{NULL}} for that slot. Returns nothing.

<dd> Index into the device's zero-based array to begin retrieving constant buffers from (ranges from 0 to {{D3D11_COMMONSHADER_CONSTANT_BUFFER_API_SLOT_COUNT}} - 1). </dd>

<dd> Number of buffers to retrieve (ranges from 0 to {{D3D11_COMMONSHADER_CONSTANT_BUFFER_API_SLOT_COUNT}} - StartSlot). </dd>

<dd> Array of constant buffer interface references to be returned by the method. </dd>

<dd> A reference to an array that receives the offsets into the buffers that ppConstantBuffers specifies. Each offset specifies where, from the shader's point of view, each constant buffer starts. Each offset is measured in shader constants, which are 16 bytes (4*32-bit components). Therefore, an offset of 2 indicates that the start of the associated constant buffer is 32 bytes into the constant buffer. The runtime sets pFirstConstant to {{NULL}} if the buffers do not have offsets. </dd>

<dd> A reference to an array that receives the numbers of constants in the buffers that ppConstantBuffers specifies. Each number specifies the number of constants that are contained in the constant buffer that the shader uses. Each number of constants starts from its respective offset that is specified in the pFirstConstant array. The runtime sets pNumConstants to {{NULL}} if it doesn't specify the numbers of constants in each buffer. </dd>

Gets the constant buffers that the hull-shader stage uses.

If no buffer is bound at a slot, pFirstConstant and pNumConstants are {{NULL}} for that slot. Returns nothing

Gets the constant buffers that the domain-shader stage uses.

If no buffer is bound at a slot, pFirstConstant and pNumConstants are {{NULL}} for that slot. Returns nothing

<dd> Index into the device's zero-based array to begin retrieving constant buffers from (ranges from 0 to {{D3D11_COMMONSHADER_CONSTANT_BUFFER_API_SLOT_COUNT}} - 1). </dd>

<dd> Number of buffers to retrieve (ranges from 0 to {{D3D11_COMMONSHADER_CONSTANT_BUFFER_API_SLOT_COUNT}} - StartSlot). </dd>

<dd> Array of constant buffer interface references to be returned by the method. </dd>

Gets the constant buffers that the geometry shader pipeline stage uses.

If no buffer is bound at a slot, pFirstConstant and pNumConstants are {{NULL}} for that slot. Returns nothing.

<dd> Index into the device's zero-based array to begin retrieving constant buffers from (ranges from 0 to {{D3D11_COMMONSHADER_CONSTANT_BUFFER_API_SLOT_COUNT}} - 1). </dd>

<dd> Number of buffers to retrieve (ranges from 0 to {{D3D11_COMMONSHADER_CONSTANT_BUFFER_API_SLOT_COUNT}} - StartSlot). </dd>

<dd> Array of constant buffer interface references to be returned by the method. </dd>

Gets the constant buffers that the pixel shader pipeline stage uses.

If no buffer is bound at a slot, pFirstConstant and pNumConstants are {{NULL}} for that slot. Returns nothing.

<dd> Index into the device's zero-based array to begin retrieving constant buffers from (ranges from 0 to {{D3D11_COMMONSHADER_CONSTANT_BUFFER_API_SLOT_COUNT}} - 1). </dd>

<dd> Number of buffers to retrieve (ranges from 0 to {{D3D11_COMMONSHADER_CONSTANT_BUFFER_API_SLOT_COUNT}} - StartSlot). </dd>

<dd> Array of constant buffer interface references to be returned by the method. </dd>

Gets the constant buffers that the compute-shader stage uses.

If no buffer is bound at a slot, pFirstConstant and pNumConstants are {{NULL}} for that slot. Returns nothing.

<dd> Index into the device's zero-based array to begin retrieving constant buffers from (ranges from 0 to {{D3D11_COMMONSHADER_CONSTANT_BUFFER_API_SLOT_COUNT}} - 1). </dd>

<dd> Number of buffers to retrieve (ranges from 0 to {{D3D11_COMMONSHADER_CONSTANT_BUFFER_API_SLOT_COUNT}} - StartSlot). </dd>

<dd> Array of constant buffer interface references to be returned by the method. </dd>

Activates the given context state object and changes the current device behavior to Direct3D?11, Direct3D?10.1, or Direct3D?10.

SwapDeviceContextState changes device behavior. This device behavior depends on the emulated interface that you passed to the EmulatedInterface parameter of the {{ID3D11Device1::CreateDeviceContextState}} method when you created the context state object. SwapDeviceContextState is not supported on a deferred context.SwapDeviceContextState disables the incompatible device interfaces {{ID3D10Device}}, {{ID3D10Device1}}, {{ID3D11Device}}, and {{ID3D11Device1}}. When a context state object is active, the runtime disables certain methods on the device and context interfaces. A context state object that is created with <code>__uuidof({{ID3D11Device1}})</code> or <code>__uuidof({{ID3D11Device}})</code> turns off most of the Direct3D?10 device interfaces. A context state object that is created with <code>__uuidof({{ID3D10Device1}})</code> or <code>__uuidof({{ID3D10Device}})</code> turns off most of the {{ID3D11DeviceContext}} methods. For more information about this behavior, see {{ID3D11Device1::CreateDeviceContextState}}.SwapDeviceContextState activates the context state object specified by pState. This means that the device behaviors that are associated with the context state object's feature level and compatible interface are activated on the Direct3D device until the next call to SwapDeviceContextState. In addition, any state that was saved when this context state object was last active is now reactivated, so that the previous state is replaced.SwapDeviceContextState sets ppPreviousState to the most recently activated context state object. The object allows the caller to save and then later restore the previous device state. This behavior is useful in a plug-in architecture such as Direct2D that shares a Direct3D device with its plug-ins. A Direct2D interface can use context state objects to save and restore the application's state.If the caller did not previously call the {{ID3D11Device1::CreateDeviceContextState}} method to create a previous context state object, SwapDeviceContextState sets ppPreviousState to the default context state object. In either case, usage of SwapDeviceContextState is the same.The feature level that is specified by the application, and that is chosen by the context state object from the acceptable list that the application supplies to {{ID3D11Device1::CreateDeviceContextState}}, controls the feature level of the immediate context whenever the context state object is active. Because the Direct3D?11 device is free-threaded, the device methods cannot query the current immediate context feature level. Instead, the device runs at a feature level that is the maximum of all previously created context state objects' feature levels. This means that the device's feature level can increase dynamically.The feature level of the context state object controls the functionality available from the immediate context. However, to maintain the free-threaded contract of the Direct3D?11 device methods?the resource-creation methods in particular?the upper-bound feature level of all created context state objects controls the set of resources that the device creates.Because the context state object interface is published by the immediate context, the interface requires the same threading model as the immediate context. Specifically, SwapDeviceContextState is single-threaded with respect to the other immediate context methods and with respect to the equivalent methods of {{ID3D10Device}}.Crucially, because only one of the Direct3D?10 or Direct3D?11 ref-count behaviors can be available at a time, one of the Direct3D?10 and Direct3D?11 interfaces must break its ref-count contract. To avoid this situation, the activation of a context state object turns off the incompatible version interface. Also, if you call a method of an incompatible version interface, the call silently fails if the method has return type void, returns an {{HRESULT}} value of {{E_INVALIDARG}}, or sets any out parameter to {{NULL}}.When you switch from Direct3D?11 mode to either Direct3D?10 mode or Direct3D?10.1 mode, the binding behavior of the device changes. Specifically, the final release of a resource induces unbind in Direct3D?10 mode or Direct3D?10.1 mode. During final release an application releases all of the resource's references, including indirect references such as the linkage from view to resource, and the linkage from context state object to any of the context state object's bound resources. Any bound resource to which the application has no reference is unbound and destroyed, in order to maintain the Direct3D?10 behavior.SwapDeviceContextState does not affect any state that {{ID3D11VideoContext}} sets. Command lists that are generated by deferred contexts do not hold a reference to context state objects and are not affected by future updates to context state objects.No asynchronous objects are affected by SwapDeviceContextState. For example, if a query is active before a call to SwapDeviceContextState, it is still active after the call. Returns nothing.

<dd> A reference to the {{ID3DDeviceContextState}} interface for the context state object that was previously created through the {{ID3D11Device1::CreateDeviceContextState}} method. If SwapDeviceContextState is called with pState set to {{NULL}}, the call has no effect. </dd>

<dd> A reference to a variable that receives a reference to the {{ID3DDeviceContextState}} interface for the previously-activated context state object. </dd>

Sets all the elements in a resource view to one value.

ClearView works only on render-target views ({{RTVs}}), depth/stencil views ({{DSVs}}) on depth-only resources (resources with no stencil component), unordered-access views ({{UAVs}}), or any video view of a Texture2D surface. The runtime drops invalid calls. Empty rectangles in the pRect array are a no-op. A rectangle is empty if the top value equals the bottom value or the left value equals the right value.ClearView doesn?t support 3D textures.ClearView applies the same color value to all array slices in a view; all rectangles in the pRect array correspond to each array slice. The pRect array of rectangles is a set of areas to clear on a single surface. If the view is an array, ClearView clears all the rectangles on each array slice individually.When you apply rectangles to buffers, set the top value to 0 and the bottom value to 1 and set the left value and right value to describe the extent within the buffer. When the top value equals the bottom value or the left value equals the right value, the rectangle is empty and a no-op is achieved.The driver converts and clamps color values to the destination format as appropriate per Direct3D conversion rules. For example, if the format of the view is {{DXGI_FORMAT_R8G8B8A8_UNORM}}, the driver clamps inputs to 0.0f to 1.0f (+{{INF}} -> 1.0f (0XFF)/NaN -> 0.0f).If the format is integer, such as {{DXGI_FORMAT_R8G8B8A8_UINT}}, the runtime interprets inputs as integral floats. Therefore, 235.0f maps to 235 (rounds to zero, out of range/{{INF}} values clamp to target range, and NaN to 0).Here are the color mappings:<ul> <li>Color[0]: R (or Y for video)</li> <li>Color[1]: G (or U/Cb for video)</li> <li>Color[2]: B (or V/Cr for video)</li> <li>Color[3]: A</li> </ul>For video views with {{YUV}} or {{YCbBr}} formats, ClearView doesn't convert color values. In situations where the format name doesn?t indicate _UNORM, _UINT, and so on, ClearView assumes _UINT. Therefore, 235.0f maps to 235 (rounds to zero, out of range/{{INF}} values clamp to target range, and NaN to 0). Returns nothing.

<dd> A reference to the {{ID3D11View}} interface that represents the resource view to clear. </dd>

<dd> A 4-component array that represents the color to use to clear the resource view. </dd>

<dd> An array of {{D3D11_RECT}} structures for the rectangles in the resource view to clear. If {{NULL}}, ClearView clears the entire surface. </dd>

<dd> Number of rectangles in the array that the pRect parameter specifies. </dd>

Discards the specified elements in a resource view from the device context.

DiscardView1 informs the graphics processing unit ({{GPU}}) that the existing content in the specified elements in the resource view that pResourceView points to is no longer needed. The view can be an {{SRV}}, {{RTV}}, {{UAV}}, or {{DSV}}. DiscardView1 is a variation on the DiscardResource method. DiscardView1 allows you to discard elements of a subset of a resource that is in a view (such as elements of a single miplevel). More importantly, DiscardView1 provides a convenience because often views are what are being bound and unbound at the pipeline. Some pipeline bindings do not have views, such as stream output. In that situation, DiscardResource can do the job for any resource. Returns nothing

<dd> A reference to the {{ID3D11View}} interface for the resource view to discard. The resource that underlies the view must have been created with usage {{D3D11_USAGE_DEFAULT}} or {{D3D11_USAGE_DYNAMIC}}, otherwise the runtime drops the call to DiscardView1; if the debug layer is enabled, the runtime returns an error message. </dd>

<dd> An array of {{D3D11_RECT}} structures for the rectangles in the resource view to discard. If {{NULL}}, DiscardView1 discards the entire view and behaves the same as DiscardView. </dd>

<dd> Number of rectangles in the array that the pRects parameter specifies. </dd>

To get a reference to this interface, call QueryInterface with an {{ID3D11DeviceContext1}} interface reference.

Submits one or more buffers for decoding.

This function does not honor any {{D3D11}} predicate that may have been set. {{D3D11_QUERY_DATA_PIPELINE_STATISTICS}} will not include this function for any feature level. If this method succeeds, it returns {{S_OK}}. Otherwise, it returns an {{HRESULT}} error code.

<dd> A reference to the {{ID3D11VideoDecoder}} interface. To get this reference, call the {{ID3D11VideoDevice::CreateVideoDecoder}} method. </dd>

<dd> The number of buffers submitted for decoding. </dd>

<dd> A reference to an array of {{D3D11_VIDEO_DECODER_BUFFER_DESC1}} structures. The NumBuffers parameter specifies the number of elements in the array. Each element in the array describes a compressed buffer for decoding. </dd>

Allows the driver to return {{IHV}} specific information used when initializing the new hardware key.

This method returns one of the following error codes.<table> <tr><td>{{S_OK}}</td><td>The operation completed successfully.</td></tr> <tr><td>{{E_OUTOFMEMORY}}</td><td>There is insufficient memory to complete the operation.</td></tr> </table>?

<dd> A reference to the {{ID3D11CryptoSession}} interface. To get this reference, call {{ID3D11VideoDevice1::CreateCryptoSession}}. </dd>

<dd> The size of the memory referenced by the pPrivateInputData parameter. </dd>

<dd> The private input data. The contents of this parameter is defined by the implementation of the secure execution environment. It may contain data about the license or about the stream properties. </dd>

<dd> A reference to the private output data. The return data is defined by the implementation of the secure execution environment. It may contain graphics-specific data to be associated with the underlying hardware key. </dd>

Checks the status of a crypto session.

This method returns one of the following error codes.<table> <tr><td>{{S_OK}}</td><td>The operation completed successfully.</td></tr> <tr><td>{{E_INVALIDARG}}</td><td>An invalid parameter was passed or this function was called using an invalid calling pattern.</td></tr> <tr><td>{{E_OUTOFMEMORY}}</td><td>There is insufficient memory to complete the operation.</td></tr> </table>?

<dd> Specifies a {{ID3D11CryptoSession}} for which status is checked. </dd>

<dd> A {{D3D11_CRYPTO_SESSION_STATUS}} that is populated with the crypto session status upon completion. </dd>

Indicates that decoder downsampling will be used and that the driver should allocate the appropriate reference frames.

This function can only be called once for a specific {{ID3D11VideoDecoder}} interface. This method must be called prior to the first call to DecoderBeginFrame. To update the downsampling parameters, use DecoderUpdateDownsampling. This method returns one of the following error codes.<table> <tr><td>{{S_OK}}</td><td>The operation completed successfully.</td></tr> <tr><td>{{E_INVALIDARG}}</td><td>An invalid parameter was passed or this function was called using an invalid calling pattern.</td></tr> <tr><td>{{E_OUTOFMEMORY}}</td><td>There is insufficient memory to complete the operation.</td></tr> </table>?

<dd> A reference to the {{ID3D11VideoDecoder}} interface. </dd>

<dd> The color space information of the reference frame data. </dd>

<dd> The resolution, format, and colorspace of the output/display frames. This is the destination resolution and format of the downsample operation. </dd>

<dd> The number of reference frames to be used in the operation. </dd>

Updates the decoder downsampling parameters.

This method can only be called after decode downsampling is enabled by calling DecoderEnableDownsampling. This method is only supported if the {{D3D11_VIDEO_DECODER_CAPS_DOWNSAMPLE_DYNAMIC}} capability is reported. This method returns one of the following error codes.<table> <tr><td>{{S_OK}}</td><td>The operation completed successfully.</td></tr> <tr><td>{{E_INVALIDARG}}</td><td>An invalid parameter was passed or this function was called using an invalid calling pattern.</td></tr> <tr><td>{{E_OUTOFMEMORY}}</td><td>There is insufficient memory to complete the operation.</td></tr> </table>?

<dd> A reference to the {{ID3D11VideoDecoder}} interface. </dd>

<dd> The resolution, format, and colorspace of the output/display frames. This is the destination resolution and format of the downsample operation. </dd>

Sets the color space information for the video processor output surface.

This method does not return a value.

<dd> A reference to the {{ID3D11VideoProcessor}} interface. </dd>

<dd> A {{DXGI_COLOR_SPACE_TYPE}} value that specifies the colorspace for the video processor output surface. </dd>

Sets a value indicating whether the output surface from a call to {{ID3D11VideoContext::VideoProcessorBlt}} will be read by Direct3D shaders.

This method does not return a value.

Gets the color space information for the video processor output surface.

This method does not return a value.

<dd> A reference to the {{ID3D11VideoProcessor}} interface. </dd>

<dd> A reference to a {{DXGI_COLOR_SPACE_TYPE}} value that indicates the colorspace for the video processor output surface. </dd>

Gets a value indicating whether the output surface from a call to {{ID3D11VideoContext::VideoProcessorBlt}} can be read by Direct3D shaders.

This method does not return a value.

Sets the color space information for the video processor input stream.

This method does not return a value.

<dd> A reference to the {{ID3D11VideoProcessor}} interface. </dd>

<dd> An index identifying the input stream. </dd>

<dd> A {{DXGI_COLOR_SPACE_TYPE}} value that specifies the colorspace for the video processor input stream. </dd>

Specifies whether the video processor input stream should be flipped vertically or horizontally.

When used in combination, transformations on the processor input stream should be applied in the following order:<ul> <li>Rotation</li> <li>Mirroring</li> <li>Source clipping</li> </ul> This method does not return a value.

<dd> A reference to the {{ID3D11VideoProcessor}} interface. </dd>

<dd> An index identifying the input stream. </dd>

<dd> True if mirroring should be enabled; otherwise, false. </dd>

<dd> True if the stream should be flipped horizontally; otherwise, false. </dd>

<dd> True if the stream should be flipped vertically; otherwise, false. </dd>

Gets the color space information for the video processor input stream.

This method does not return a value.

<dd> A reference to the {{ID3D11VideoProcessor}} interface. </dd>

<dd> An index identifying the input stream. </dd>

<dd> A reference to a {{DXGI_COLOR_SPACE_TYPE}} value that specifies the colorspace for the video processor input stream. </dd>

Gets values that indicate whether the video processor input stream is being flipped vertically or horizontally.

This method does not return a value.

<dd> A reference to the {{ID3D11VideoProcessor}} interface. </dd>

<dd> An index identifying the input stream. </dd>

<dd> A reference to a boolean value indicating whether mirroring is enabled. True if mirroring is enabled; otherwise, false. </dd>

<dd> A reference to a boolean value indicating whether the stream is being flipped horizontally. True if the stream is being flipped horizontally; otherwise, false. </dd>

<dd> A reference to a boolean value indicating whether the stream is being flipped vertically. True if the stream is being flipped vertically; otherwise, false. </dd>

Returns driver hints that indicate which of the video processor operations are best performed using multi-plane overlay hardware rather than {{ID3D11VideoContext::VideoProcessorBlt}} method.

This method computes the behavior hints using the current state of the video processor as set by the "SetOutput" and "SetStream" methods of {{ID3D11VideoContext}} and {{ID3D11VideoContext1}}. You must set the proper state before calling this method to ensure that the returned hints contain useful data. This method returns one of the following error codes.<table> <tr><td>{{S_OK}}</td><td>The operation completed successfully.</td></tr> <tr><td>{{E_INVALIDARG}}</td><td>An invalid parameter was passed or this function was called using an invalid calling pattern.</td></tr> <tr><td>{{E_OUTOFMEMORY}}</td><td>There is insufficient memory to complete the operation.</td></tr> </table>?

Provides the video decoding and video processing capabilities of a Microsoft Direct3D?11 device.

The Direct3D?11 device supports this interface. To get a reference to this interface, call QueryInterface with an {{ID3D11Device1}} interface reference.

Retrieves optional sizes for private driver data.

When pKeyExchangeType is {{D3D11_KEY_EXCHANGE_HW_PROTECTION}}, the following behavior is expected in the {{ID3D11VideoContext::NegotiateCryptoSessionKeyExchange}} method:<ul> <li>The DataSize parameter is set to the size of the {{D3D11_KEY_EXCHANGE_HW_PROTECTION_DATA}} structure.</li> <li>pData points to a {{D3D11_KEY_EXCHANGE_HW_PROTECTION_DATA}} structure. <ul> <li>The pInputData of this structure points to a {{D3D11_KEY_EXCHANGE_HW_PROTECTION_INPUT_DATA}} structure where:<ul> <li>pbInput[0] ? pbInput[N-1] contains memory reserved for use by the driver. The number of bytes (N) reserved for the driver is determined by the pPrivateInputSize value returned by the {{ID3D11VideoDevice1::GetCryptoSessionPrivateDataSize}} function.</li> <li>pbInput[N] contains the first byte of the {{DRM}} command packet.</li> </ul> </li> <li>The pOutputData of this structure points to a {{D3D11_KEY_EXCHANGE_HW_PROTECTION_OUTPUT_DATA}} structure where:<ul> <li>pbOutput[0] ? pbOutput[N-1] contains memory reserved for use by the driver. The number of bytes (N) reserved for the driver is determined by the pPrivateOutputSize value returned by the {{ID3D11VideoDevice1::GetCryptoSessionPrivateDataSize}} function.</li> <li>pbOutput[N] contains the first byte of the {{DRM}} command packet.</li> </ul> </li> </ul> </li> </ul> If this method succeeds, it returns {{S_OK}}. Otherwise, it returns an {{HRESULT}} error code.

<dd> Indicates the crypto type for which the private input and output size is queried. </dd>

<dd> Indicates the decoder profile for which the private input and output size is queried. </dd>

<dd> Indicates the key exchange type for which the private input and output size is queried. </dd>

<dd> Returns the size of private data that the driver needs for input commands. </dd>

<dd> Returns the size of private data that the driver needs for output commands. </dd>

Retrieves capabilities and limitations of the video decoder.

<dd> The decode profile for which the capabilities are queried. </dd>

<dd> The video width for which the capabilities are queried. </dd>

<dd> The video height for which the capabilities are queried. </dd>

<dd> The frame rate of the video content. This information is used by the driver to determine whether the video can be decoded in real-time. </dd>

<dd> The bit rate of the video stream. A value of zero indicates that the bit rate can be ignored. </dd>

<dd> The type of cryptography used to encrypt the video stream. A value of {{NULL}} indicates that the video stream is not encrypted. </dd>

<dd> A reference to a bitwise {{OR}} combination of {{D3D11_VIDEO_DECODER_CAPS}} values specifying the decoder capabilities. </dd>

Indicates whether the video decoder supports downsampling with the specified input format, and whether real-time downsampling is supported.

You should call GetVideoDecoderCaps to determine whether decoder downsampling is supported before checking support for a specific configuration. This method returns one of the following error codes.<table> <tr><td>{{S_OK}}</td><td>The operation completed successfully.</td></tr> <tr><td>{{E_INVALIDARG}}</td><td>An invalid parameter was passed or this function was called using an invalid calling pattern.</td></tr> </table>?

<dd> An object describing the decoding profile, the resolution, and format of the input stream. This is the resolution and format to be downsampled. </dd>

<dd> A {{DXGI_COLOR_SPACE_TYPE}} value that specifies the colorspace of the reference frame data. </dd>

<dd> The configuration data associated with the decode profile. </dd>

<dd> The frame rate of the video content. This is used by the driver to determine whether the video can be decoded in real-time. </dd>

<dd> An object describing the resolution, format, and colorspace of the output frames. This is the destination resolution and format of the downsample operation. </dd>

<dd> Pointer to a boolean value set by the driver that indicates if downsampling is supported with the specified input data. True if the driver supports the requested downsampling; otherwise, false. </dd>

<dd> Pointer to a boolean value set by the driver that indicates if real-time decoding is supported with the specified input data. True if the driver supports the requested real-time decoding; otherwise, false. Note that the returned value is based on the current configuration of the video decoder and does not guarantee that real-time decoding will be supported for future downsampling operations. </dd>

Allows the driver to recommend optimal output downsample parameters from the input parameters.

<dd> A {{D3D11_VIDEO_DECODER_DESC}} object describing the decoding profile, the resolution, and format of the input stream. This is the resolution and format to be downsampled. </dd>

<dd> A {{DXGI_COLOR_SPACE_TYPE}} value that specifies the colorspace of the reference frame data. </dd>

<dd> The configuration data associated with the decode profile. </dd>

<dd> The frame rate of the video content. This is used by the driver to determine whether the video can be decoded in real-time. </dd>

<dd> Pointer to a {{D3D11_VIDEO_SAMPLE_DESC}} structure that the driver populates with the recommended output buffer parameters for a downsample operation. The driver will attempt to recommend parameters that can support real-time decoding. If it is unable to do so, the driver will recommend values that are as close to the real-time solution as possible. </dd>

Enumerates the video processor capabilities of a Microsoft Direct3D?11 device.

To get a reference to this interface, call {{ID3D11VideoDevice::CreateVideoProcessorEnumerator}}.

Indicates whether the driver supports the specified combination of format and colorspace conversions.

<dd> The format of the video processor input. </dd>

<dd> The colorspace of the video processor input. </dd>

<dd> The format of the video processor output. </dd>

<dd> The colorspace of the video processor output. </dd>

<dd> Pointer to a boolean that is set by the driver to indicate if the specified combination of format and colorspace conversions is supported. True if the conversion is supported; otherwise, false. </dd>

The device interface represents a virtual adapter; it is used to create resources. {{ID3D11Device1}} adds new methods to those in {{ID3D11Device}}.

Gets an immediate context, which can play back command lists.

GetImmediateContext1 returns an {{ID3D11DeviceContext1}} object that represents an immediate context. You can use this immediate context to perform rendering that you want immediately submitted to a device. For most applications, an immediate context is the primary object that is used to draw your scene.GetImmediateContext1 increments the reference count of the immediate context by one. So, call Release on the returned interface reference when you are done with it to avoid a memory leak. This method does not return a value.

<dd> Upon completion of the method, the passed reference to an {{ID3D11DeviceContext1}} interface reference is initialized. </dd>

Creates a deferred context, which can record command lists.

A deferred context is a thread-safe context that you can use to record graphics commands on a thread other than the main rendering thread. By using a deferred context, you can record graphics commands into a command list that is encapsulated by the {{ID3D11CommandList}} interface. After you record all scene items, you can then submit them to the main render thread for final rendering. In this manner, you can perform rendering tasks concurrently across multiple threads and potentially improve performance in multi-core {{CPU}} scenarios. You can create multiple deferred contexts. Note?? If you use the {{D3D11_CREATE_DEVICE_SINGLETHREADED}} value to create the device that is represented by {{ID3D11Device1}}, the CreateDeferredContext1 method will fail, and you will not be able to create a deferred context.? For more information about deferred contexts, see Immediate and Deferred Rendering. Windows?Phone?8: This {{API}} is supported. Returns {{S_OK}} if successful; otherwise, returns one of the following: <ul> <li> Returns {{DXGI_ERROR_DEVICE_REMOVED}} if the graphics adapter has been physically removed from the computer or a driver upgrade for the graphics adapter has occurred. If this error occurs, you should destroy and re-create the device. </li> <li> Returns {{DXGI_ERROR_INVALID_CALL}} if the CreateDeferredContext1 method cannot be called from the current context. For example, if the device was created with the {{D3D11_CREATE_DEVICE_SINGLETHREADED}} value, CreateDeferredContext1 returns {{DXGI_ERROR_INVALID_CALL}}. </li> <li> Returns {{E_INVALIDARG}} if the ContextFlags parameter is invalid. </li> <li> Returns {{E_OUTOFMEMORY}} if the application has exhausted available memory. </li> </ul>

<dd> Reserved for future use. Pass 0. </dd>

<dd> Upon completion of the method, the passed reference to an {{ID3D11DeviceContext1}} interface reference is initialized. </dd>

Creates a blend-state object that encapsulates blend state for the output-merger stage and allows the configuration of logic operations.

The logical operations (those that enable bitwise logical operations between pixel shader output and render target contents, refer to {{D3D11_RENDER_TARGET_BLEND_DESC1}} ) are only available on certain feature levels; call CheckFeatureSupport with {{D3D11_FEATURE_D3D11_OPTIONS}} set, to ensure support by checking the boolean field OutputMergerLogicOp of {{D3D11_FEATURE_DATA_D3D11_OPTIONS}}.An app can create up to 4096 unique blend-state objects. For each object created, the runtime checks to see if a previous object has the same state. If such a previous object exists, the runtime will return a reference to previous instance instead of creating a duplicate object. This method returns {{E_OUTOFMEMORY}} if there is insufficient memory to create the blend-state object. See Direct3D 11 Return Codes for other possible return values.

Creates a rasterizer state object that informs the rasterizer stage how to behave and forces the sample count while {{UAV}} rendering or rasterizing.

An app can create up to 4096 unique rasterizer state objects. For each object created, the runtime checks to see if a previous object has the same state. If such a previous object exists, the runtime will return a reference to previous instance instead of creating a duplicate object. This method returns {{E_OUTOFMEMORY}} if there is insufficient memory to create the rasterizer state object. See Direct3D 11 Return Codes for other possible return values.

Creates a context state object that holds all Microsoft Direct3D state and some Direct3D behavior.

The {{REFIID}} value of the emulated interface is a {{GUID}} obtained by use of the __uuidof operator. For example, <code>__uuidof({{ID3D11Device}})</code> gets the {{GUID}} of the interface to a Microsoft Direct3D?11 device. Call the {{ID3D11DeviceContext1::SwapDeviceContextState}} method to activate the context state object. When the context state object is active, the device behaviors that are associated with both the context state object's feature level and its compatible interface are activated on the Direct3D device until the next call to SwapDeviceContextState. When a context state object is active, the runtime disables certain methods on the device and context interfaces. For example, a context state object that is created with <code>__uuidof({{ID3D11Device}})</code> will cause the runtime to turn off most of the Microsoft Direct3D?10 device interfaces, and a context state object that is created with <code>__uuidof({{ID3D10Device1}})</code> or <code>__uuidof({{ID3D10Device}})</code> will cause the runtime to turn off most of the {{ID3D11DeviceContext}} methods. This behavior ensures that a user of either emulated interface cannot set device state that the other emulated interface is unable to express. This restriction helps guarantee that the {{ID3D10Device1}} emulated interface accurately reflects the full state of the pipeline and that the emulated interface will not operate contrary to its original interface definition. For example, suppose the tessellation stage is made active through the {{ID3D11DeviceContext}} interface when you create the device through {{D3D11CreateDevice}} or {{D3D11CreateDeviceAndSwapChain}}, instead of through the Direct3D?10 equivalents. Because the Direct3D?11 context is active, a Direct3D?10 interface is inactive when you first retrieve it via QueryInterface. This means that you cannot immediately pass a Direct3D?10 interface that you retrieved from a Direct3D?11 device to a function. You must first call SwapDeviceContextState to activate a Direct3D?10-compatible context state object. The following table shows the methods that are active and inactive for each emulated interface.<table> <tr><th> Emulated interface </th><th>Active device or immediate context interfaces </th><th>Inactive device or immediate context interfaces</th></tr> <tr><td> {{ID3D11Device}} or {{ID3D11Device1}} </td><td> {{ID3D11Device}} {{IDXGIDevice}} + {{IDXGIDevice1}} + {{IDXGIDevice2}} {{ID3D10Multithread}} </td><td> {{ID3D10Device}} </td></tr> <tr><td> {{ID3D10Device1}} or {{ID3D10Device}} </td><td> {{ID3D10Device}} {{ID3D10Device1}} {{IDXGIDevice}} + {{IDXGIDevice1}} {{ID3D10Multithread}} </td><td> {{ID3D11Device}} {{ID3D11DeviceContext}} (As published by the immediate context. The Direct3D?10 or Microsoft Direct3D?10.1 emulated interface has no effect on deferred contexts.) </td></tr> </table>? The following table shows the immediate context methods that the runtime disables when the indicated context state objects are active.<table> <tr><th> Methods of {{ID3D11DeviceContext}} when <code>__uuidof({{ID3D10Device1}})</code> or <code>__uuidof({{ID3D10Device}})</code> is active </th><th> Methods of {{ID3D10Device}} when <code>__uuidof({{ID3D11Device}})</code> is active </th></tr> <tr><td> ClearDepthStencilView </td><td> ClearDepthStencilView </td></tr> <tr><td> ClearRenderTargetView </td><td> ClearRenderTargetView </td></tr> <tr><td> ClearState </td><td> ClearState </td></tr> <tr><td> ClearUnorderedAccessViewUint </td><td></td></tr> <tr><td> ClearUnorderedAccessViewFloat </td><td></td></tr> <tr><td> CopyResource </td><td> CopyResource </td></tr> <tr><td> CopyStructureCount </td><td></td></tr> <tr><td> CopySubresourceRegion </td><td> CopySubresourceRegion </td></tr> <tr><td> {{CSGetConstantBuffers}} </td><td></td></tr> <tr><td> {{CSGetSamplers}} </td><td></td></tr> <tr><td> {{CSGetShader}} </td><td></td></tr> <tr><td> {{CSGetShaderResources}} </td><td></td></tr> <tr><td> {{CSGetUnorderedAccessViews}} </td><td></td></tr> <tr><td> {{CSSetConstantBuffers}} </td><td></td></tr> <tr><td> {{CSSetSamplers}} </td><td></td></tr> <tr><td> {{CSSetShader}} </td><td></td></tr> <tr><td> {{CSSetShaderResources}} </td><td></td></tr> <tr><td> {{CSSetUnorderedAccessViews}} </td><td></td></tr> <tr><td> Dispatch </td><td></td></tr> <tr><td> DispatchIndirect </td><td></td></tr> <tr><td></td><td> CreateBlendState </td></tr> <tr><td> Draw </td><td> Draw </td></tr> <tr><td> DrawAuto </td><td> DrawAuto </td></tr> <tr><td> DrawIndexed </td><td> DrawIndexed </td></tr> <tr><td> DrawIndexedInstanced </td><td> DrawIndexedInstanced </td></tr> <tr><td> DrawIndexedInstancedIndirect </td><td></td></tr> <tr><td> DrawInstanced </td><td> DrawInstanced </td></tr> <tr><td> DrawInstancedIndirect </td><td></td></tr> <tr><td> {{DSGetConstantBuffers}} </td><td></td></tr> <tr><td> {{DSGetSamplers}} </td><td></td></tr> <tr><td> {{DSGetShader}} </td><td></td></tr> <tr><td> {{DSGetShaderResources}} </td><td></td></tr> <tr><td> {{DSSetConstantBuffers}} </td><td></td></tr> <tr><td> {{DSSetSamplers}} </td><td></td></tr> <tr><td> {{DSSetShader}} </td><td></td></tr> <tr><td> {{DSSetShaderResources}} </td><td></td></tr> <tr><td> ExecuteCommandList </td><td></td></tr> <tr><td> FinishCommandList </td><td></td></tr> <tr><td> Flush </td><td> Flush </td></tr> <tr><td> GenerateMips </td><td> GenerateMips </td></tr> <tr><td> GetPredication </td><td> GetPredication </td></tr> <tr><td> GetResourceMinLOD </td><td></td></tr> <tr><td> GetType </td><td></td></tr> <tr><td></td><td> GetTextFilterSize </td></tr> <tr><td> {{GSGetConstantBuffers}} </td><td> {{GSGetConstantBuffers}} </td></tr> <tr><td> {{GSGetSamplers}} </td><td> {{GSGetSamplers}} </td></tr> <tr><td> {{GSGetShader}} </td><td> {{GSGetShader}} </td></tr> <tr><td> {{GSGetShaderResources}} </td><td> {{GSGetShaderResources}} </td></tr> <tr><td> {{GSSetConstantBuffers}} </td><td> {{GSSetConstantBuffers}} </td></tr> <tr><td> {{GSSetSamplers}} </td><td> {{GSSetSamplers}} </td></tr> <tr><td> {{GSSetShader}} </td><td> {{GSSetShader}} </td></tr> <tr><td> {{GSSetShaderResources}} </td><td> {{GSSetShaderResources}} </td></tr> <tr><td> {{HSGetConstantBuffers}} </td><td></td></tr> <tr><td> {{HSGetSamplers}} </td><td></td></tr> <tr><td> {{HSGetShader}} </td><td></td></tr> <tr><td> {{HSGetShaderResources}} </td><td></td></tr> <tr><td> {{HSSetConstantBuffers}} </td><td></td></tr> <tr><td> {{HSSetSamplers}} </td><td></td></tr> <tr><td> {{HSSetShader}} </td><td></td></tr> <tr><td> {{HSSetShaderResources}} </td><td></td></tr> <tr><td> {{IAGetIndexBuffer}} </td><td> {{IAGetIndexBuffer}} </td></tr> <tr><td> {{IAGetInputLayout}} </td><td> {{IAGetInputLayout}} </td></tr> <tr><td> {{IAGetPrimitiveTopology}} </td><td> {{IAGetPrimitiveTopology}} </td></tr> <tr><td> {{IAGetVertexBuffers}} </td><td> {{IAGetVertexBuffers}} </td></tr> <tr><td> {{IASetIndexBuffer}} </td><td> {{IASetIndexBuffer}} </td></tr> <tr><td> {{IASetInputLayout}} </td><td> {{IASetInputLayout}} </td></tr> <tr><td> {{IASetPrimitiveTopology}} </td><td> {{IASetPrimitiveTopology}} </td></tr> <tr><td> {{IASetVertexBuffers}} </td><td> {{IASetVertexBuffers}} </td></tr> <tr><td> {{OMGetBlendState}} </td><td> {{OMGetBlendState}} </td></tr> <tr><td> {{OMGetDepthStencilState}} </td><td> {{OMGetDepthStencilState}} </td></tr> <tr><td> {{OMGetRenderTargets}} </td><td> {{OMGetRenderTargets}} </td></tr> <tr><td> {{OMGetRenderTargetsAndUnorderedAccessViews}} </td><td></td></tr> <tr><td> {{OMSetBlendState}} </td><td> {{OMSetBlendState}} </td></tr> <tr><td> {{OMSetDepthStencilState}} </td><td> {{OMSetDepthStencilState}} </td></tr> <tr><td> {{OMSetRenderTargets}} </td><td> {{OMSetRenderTargets}} </td></tr> <tr><td> {{OMSetRenderTargetsAndUnorderedAccessViews}} </td><td></td></tr> <tr><td> {{PSGetConstantBuffers}} </td><td> {{PSGetConstantBuffers}} </td></tr> <tr><td> {{PSGetSamplers}} </td><td> {{PSGetSamplers}} </td></tr> <tr><td> {{PSGetShader}} </td><td> {{PSGetShader}} </td></tr> <tr><td> {{PSGetShaderResources}} </td><td> {{PSGetShaderResources}} </td></tr> <tr><td> {{PSSetConstantBuffers}} </td><td> {{PSSetConstantBuffers}} </td></tr> <tr><td> {{PSSetSamplers}} </td><td> {{PSSetSamplers}} </td></tr> <tr><td> {{PSSetShader}} </td><td> {{PSSetShader}} </td></tr> <tr><td> {{PSSetShaderResources}} </td><td> {{PSSetShaderResources}} </td></tr> <tr><td> ResolveSubresource </td><td> ResolveSubresource </td></tr> <tr><td> {{RSGetScissorRects}} </td><td> {{RSGetScissorRects}} </td></tr> <tr><td> {{RSGetState}} </td><td> {{RSGetState}} </td></tr> <tr><td> {{RSGetViewports}} </td><td> {{RSGetViewports}} </td></tr> <tr><td> {{RSSetScissorRects}} </td><td> {{RSSetScissorRects}} </td></tr> <tr><td> {{RSSetState}} </td><td> {{RSSetState}} </td></tr> <tr><td> {{RSSetViewports}} </td><td> {{RSSetViewports}} </td></tr> <tr><td> SetPredication </td><td> SetPredication </td></tr> <tr><td> SetResourceMinLOD </td><td></td></tr> <tr><td></td><td> SetTextFilterSize </td></tr> <tr><td> {{SOGetTargets}} </td><td> {{SOGetTargets}} </td></tr> <tr><td> {{SOSetTargets}} </td><td> {{SOSetTargets}} </td></tr> <tr><td> UpdateSubresource </td><td> UpdateSubresource </td></tr> <tr><td> {{VSGetConstantBuffers}} </td><td> {{VSGetConstantBuffers}} </td></tr> <tr><td> {{VSGetSamplers}} </td><td> {{VSGetSamplers}} </td></tr> <tr><td> {{VSGetShader}} </td><td> {{VSGetShader}} </td></tr> <tr><td> {{VSGetShaderResources}} </td><td> {{VSGetShaderResources}} </td></tr> <tr><td> {{VSSetConstantBuffers}} </td><td> {{VSSetConstantBuffers}} </td></tr> <tr><td> {{VSSetSamplers}} </td><td> {{VSSetSamplers}} </td></tr> <tr><td> {{VSSetShader}} </td><td> {{VSSetShader}} </td></tr> <tr><td> {{VSSetShaderResources}} </td><td> {{VSSetShaderResources}} </td></tr> </table>? The following table shows the immediate context methods that the runtime does not disable when the indicated context state objects are active.<table> <tr><th> Methods of {{ID3D11DeviceContext}} when <code>__uuidof({{ID3D10Device1}})</code> or <code>__uuidof({{ID3D10Device}})</code> is active </th><th> Methods of {{ID3D10Device}} when <code>__uuidof({{ID3D11Device}})</code> is active </th></tr> <tr><td> Begin </td><td></td></tr> <tr><td> End </td><td></td></tr> <tr><td></td><td> GetCreationFlags </td></tr> <tr><td></td><td> GetPrivateData </td></tr> <tr><td> GetContextFlags </td><td></td></tr> <tr><td> GetData </td><td></td></tr> <tr><td> Map </td><td></td></tr> <tr><td> Unmap </td><td></td></tr> </table>? The following table shows the {{ID3D10Device}} interface methods that the runtime does not disable because they are not immediate context methods.<table> <tr><th> Methods of {{ID3D10Device}} </th></tr> <tr><td> CheckCounter </td></tr> <tr><td> CheckCounterInfo </td></tr> <tr><td> Create*, like CreateQuery </td></tr> <tr><td> GetDeviceRemovedReason </td></tr> <tr><td> GetExceptionMode </td></tr> <tr><td> OpenSharedResource </td></tr> <tr><td> SetExceptionMode </td></tr> <tr><td> SetPrivateData </td></tr> <tr><td> SetPrivateDataInterface </td></tr> </table>?Windows?Phone?8: This {{API}} is supported. This method returns one of the Direct3D 11 Return Codes.

<dd> A combination of {{D3D11_1_CREATE_DEVICE_CONTEXT_STATE_FLAG}} values that are combined by using a bitwise {{OR}} operation. The resulting value specifies how to create the context state object. The {{D3D11_1_CREATE_DEVICE_CONTEXT_STATE_SINGLETHREADED}} flag is currently the only defined flag. If the original device was created with {{D3D11_CREATE_DEVICE_SINGLETHREADED}}, you must create all context state objects from that device with the {{D3D11_1_CREATE_DEVICE_CONTEXT_STATE_SINGLETHREADED}} flag. If you set the single-threaded flag for both the context state object and the device, you guarantee that you will call the whole set of context methods and device methods only from one thread. You therefore do not need to use critical sections to synchronize access to the device context, and the runtime can avoid working with those processor-intensive critical sections. </dd>

<dd> A reference to an array of {{D3D_FEATURE_LEVEL}} values. The array can contain elements from the following list and determines the order of feature levels for which creation is attempted. Unlike {{D3D11CreateDevice}}, you can't set pFeatureLevels to {{NULL}} because there is no default feature level array. <pre>{ {{D3D_FEATURE_LEVEL_11_1}}, {{D3D_FEATURE_LEVEL_11_0}}, {{D3D_FEATURE_LEVEL_10_1}}, {{D3D_FEATURE_LEVEL_10_0}}, {{D3D_FEATURE_LEVEL_9_3}}, {{D3D_FEATURE_LEVEL_9_2}}, {{D3D_FEATURE_LEVEL_9_1}}, }; </pre> </dd>

<dd> The number of elements in pFeatureLevels. Unlike {{D3D11CreateDevice}}, you must set FeatureLevels to greater than 0 because you can't set pFeatureLevels to {{NULL}}. </dd>

<dd> The {{SDK}} version. You must set this parameter to {{D3D11_SDK_VERSION}}. </dd>

<dd> The globally unique identifier ({{GUID}}) for the emulated interface. This value specifies the behavior of the device when the context state object is active. Valid values are obtained by using the __uuidof operator on the {{ID3D10Device}}, {{ID3D10Device1}}, {{ID3D11Device}}, and {{ID3D11Device1}} interfaces. See Remarks. </dd>

<dd> A reference to a variable that receives a {{D3D_FEATURE_LEVEL}} value from the pFeatureLevels array. This is the first array value with which CreateDeviceContextState succeeded in creating the context state object. If the call to CreateDeviceContextState fails, the variable pointed to by pChosenFeatureLevel is set to zero. </dd>

<dd> The address of a reference to an {{ID3DDeviceContextState}} object that represents the state of a Direct3D device. </dd>

Give a device access to a shared resource created on a different device.

<dd> A resource handle. See remarks. </dd>

<dd> The globally unique identifier ({{GUID}}) for the resource interface. See remarks. </dd>

<dd> Address of a reference to the resource we are gaining access to. </dd>

Gives a device access to a shared resource that is referenced by name and that was created on a different device. You must have previously created the resource as shared and specified that it uses {{NT}} handles (that is, you set the {{D3D11_RESOURCE_MISC_SHARED_NTHANDLE}} flag).

The behavior of OpenSharedResourceByName is similar to the behavior of the {{ID3D11Device1::OpenSharedResource1}} method; each call to OpenSharedResourceByName to access a resource creates a new resource object. In other words, if you call OpenSharedResourceByName twice and pass the same resource name to lpName, you receive two resource objects with different {{IUnknown}} references.To share a resource between two devices<ol> <li>Create the resource as shared and specify that it uses {{NT}} handles, by setting the {{D3D11_RESOURCE_MISC_SHARED_NTHANDLE}} flag.</li> <li>Obtain the {{REFIID}}, or {{GUID}}, of the interface to the resource by using the __uuidof() macro. For example, __uuidof({{ID3D11Texture2D}}) retrieves the {{GUID}} of the interface to a 2D texture.</li> <li>Query the resource for the {{IDXGIResource1}} interface.</li> <li>Call the {{IDXGIResource1::CreateSharedHandle}} method to obtain the unique handle to the resource. In this {{IDXGIResource1::CreateSharedHandle}} call, you must pass a name for the resource if you want to subsequently call OpenSharedResourceByName to access the resource by name. </li> </ol> This method returns one of the Direct3D 11 return codes. This method also returns {{E_ACCESSDENIED}} if the permissions to access the resource aren't valid.Platform Update for Windows?7:??On Windows?7 or Windows Server?2008?{{R2}} with the Platform Update for Windows?7 installed, OpenSharedResourceByName fails with {{E_NOTIMPL}} because {{NTHANDLES}} are used. For more info about the Platform Update for Windows?7, see Platform Update for Windows 7.

The {{ID3DUserDefinedAnnotation}} interface enables an application to describe conceptual sections and markers within the application's code flow. An appropriately enabled tool, such as Microsoft Visual Studio Ultimate?2012, can display these sections and markers visually along the tool's Microsoft Direct3D time line, while the tool debugs the application. These visual notes allow users of such a tool to navigate to parts of the time line that are of interest, or to understand what set of Direct3D calls are produced by certain sections of the application's code.

The methods of {{ID3DUserDefinedAnnotation}} have no effect when the calling application is not running under a Direct3D-specific profiling tool like Visual Studio Ultimate?2012. The {{ID3DUserDefinedAnnotation}} interface is published by Microsoft Direct3D?11 device contexts. Therefore, {{ID3DUserDefinedAnnotation}} has the same threading rules as the {{ID3D11DeviceContext}} interface, or any other context interface. For more information about Direct3D threading, see MultiThreading. To retrieve the {{ID3DUserDefinedAnnotation}} interface for the context, call the QueryInterface method for the context (for example, {{ID3D11DeviceContext::QueryInterface}}). In this call, you must pass the identifier of {{ID3DUserDefinedAnnotation}}. The {{ID3DUserDefinedAnnotation}} interface is the Microsoft Direct3D?10 and later equivalent of the Direct3D 9 {{PIX}} functions ({{D3DPERF_}}* functions).Note??Setting the {{D3D11_CREATE_DEVICE_PREVENT_ALTERING_LAYER_SETTINGS_FROM_REGISTRY}} flag in your app replaces calling {{D3DPerf_SetOptions}}(1). But, to prevent Direct3D debugging tools from hooking your app, your app can also call {{ID3DUserDefinedAnnotation::GetStatus}} to determine whether it is running under a Direct3D debugging tool and then exit accordingly.?You must call the BeginEvent and EndEvent methods in pairs; pairs of calls to these methods can nest within pairs of calls to these methods at a higher level in the application's call stack. In other words, a "Draw World" section can entirely contain another section named "Draw Trees," which can in turn entirely contain a section called "Draw Oaks." You can only associate an EndEvent method with the most recent BeginEvent method, that is, pairs cannot overlap. You cannot call an EndEvent for any BeginEvent that preceded the most recent BeginEvent. In fact, the runtime interprets the first EndEvent as ending the second BeginEvent.

Marks the beginning of a section of event code.

You call the EndEvent method to mark the end of the section of event code.A user can visualize the event when the calling application is running under an enabled Direct3D profiling tool such as Microsoft Visual Studio Ultimate?2012.BeginEvent has no effect if the calling application is not running under an enabled Direct3D profiling tool. Returns the number of previous calls to BeginEvent that have not yet been finalized by calls to the {{ID3DUserDefinedAnnotation::EndEvent}} method.The return value is ?1 if the calling application is not running under a Direct3D profiling tool.

<dd> A {{NULL}}-terminated {{UNICODE}} string that contains the name of the event. The name is not relevant to the operating system. You can choose a name that is meaningful when the calling application is running under the Direct3D profiling tool. A {{NULL}} reference produces undefined results. </dd>

Marks the end of a section of event code.

You call the BeginEvent method to mark the beginning of the section of event code.A user can visualize the event when the calling application is running under an enabled Direct3D profiling tool such as Microsoft Visual Studio Ultimate?2012.EndEvent has no effect if the calling application is not running under an enabled Direct3D profiling tool. Returns the number of previous calls to the {{ID3DUserDefinedAnnotation::BeginEvent}} method that have not yet been finalized by calls to EndEvent.The return value is ?1 if the calling application is not running under a Direct3D profiling tool.

Marks a single point of execution in code.

A user can visualize the marker when the calling application is running under an enabled Direct3D profiling tool such as Microsoft Visual Studio Ultimate?2012.SetMarker has no effect if the calling application is not running under an enabled Direct3D profiling tool. This method returns no values.

<dd> A {{NULL}}-terminated {{UNICODE}} string that contains the name of the marker. The name is not relevant to the operating system. You can choose a name that is meaningful when the calling application is running under the Direct3D profiling tool. A {{NULL}} reference produces undefined results. </dd>

Determines whether the calling application is running under a Microsoft Direct3D profiling tool.

You can call GetStatus to determine whether your application is running under a Direct3D profiling tool before you make further calls to other methods of the {{ID3DUserDefinedAnnotation}} interface. For example, the {{ID3DUserDefinedAnnotation::BeginEvent}} and {{ID3DUserDefinedAnnotation::EndEvent}} methods have no effect if the calling application is not running under an enabled Direct3D profiling tool. Therefore, you do not need to call these methods unless your application is running under a Direct3D profiling tool. The return value is nonzero if the calling application is running under a Direct3D profiling tool such as Visual Studio Ultimate?2012, and zero otherwise.

Identifies how to perform a tile-mapping operation.

<dd> Indicates that no overwriting of tiles occurs in the tile-mapping operation. </dd>

Specifies a range of tile mappings to use with {{ID3D11DeviceContext2::UpdateTiles}}.

Identifies how to check multisample quality levels.

<dd> Indicates to check the multisample quality levels of a tiled resource. </dd>

Identifies how to copy a tile.

<dd> Indicates that the {{GPU}} isn't currently referencing any of the portions of destination memory being written. </dd>

<dd> Indicates that the {{ID3D11DeviceContext2::CopyTiles}} operation involves copying a linear buffer to a swizzled tiled resource. This means to copy tile data from the specified buffer location, reading tiles sequentially, to the specified tile region (in x,y,z order if the region is a box), swizzling to optimal hardware memory layout as needed. In this {{ID3D11DeviceContext2::CopyTiles}} call, you specify the source data with the pBuffer parameter and the destination with the pTiledResource parameter. </dd>

<dd> Indicates that the {{ID3D11DeviceContext2::CopyTiles}} operation involves copying a swizzled tiled resource to a linear buffer. This means to copy tile data from the tile region, reading tiles sequentially (in x,y,z order if the region is a box), to the specified buffer location, deswizzling to linear memory layout as needed. In this {{ID3D11DeviceContext2::CopyTiles}} call, you specify the source data with the pTiledResource parameter and the destination with the pBuffer parameter. </dd>

Describes the coordinates of a tiled resource.

<dd> The x position of a tiled resource. Used for buffer and 1D, 2D, and 3D textures. </dd>

<dd> The y position of a tiled resource. Used for 2D and 3D textures. </dd>

<dd> The z position of a tiled resource. Used for 3D textures. </dd>

<dd> A subresource index value into mipmaps and arrays. Used for 1D, 2D, and 3D textures. For mipmaps that use nonstandard tiling, or are packed, or both use nonstandard tiling and are packed, any subresource value that indicates any of the packed mipmaps all refer to the same tile. </dd>

Describes the size of a tiled region.

<dd> The number of tiles in the tiled region. </dd>

<dd> Specifies whether the runtime uses the Width, Height, and Depth members to define the region. If {{TRUE}}, the runtime uses the Width, Height, and Depth members to define the region. If {{FALSE}}, the runtime ignores the Width, Height, and Depth members and uses the NumTiles member to traverse tiles in the resource linearly across x, then y, then z (as applicable) and then spills over mipmaps/arrays in subresource order. For example, use this technique to map an entire resource at once. Regardless of whether you specify {{TRUE}} or {{FALSE}} for bUseBox, you use a {{D3D11_TILED_RESOURCE_COORDINATE}} structure to specify the starting location for the region within the resource as a separate parameter outside of this structure by using x, y, and z coordinates. When the region includes mipmaps that are packed with nonstandard tiling, bUseBox must be {{FALSE}} because tile dimensions are not standard and the app only knows a count of how many tiles are consumed by the packed area, which is per array slice. The corresponding (separate) starting location parameter uses x to offset into the flat range of tiles in this case, and y and z coordinates must each be 0. </dd>

<dd> The width of the tiled region, in tiles. Used for buffer and 1D, 2D, and 3D textures. </dd>

<dd> The height of the tiled region, in tiles. Used for 2D and 3D textures. </dd>

<dd> The depth of the tiled region, in tiles. Used for 3D textures or arrays. For arrays, used for advancing in depth jumps to next slice of same mipmap size, which isn't contiguous in the subresource counting space if there are multiple mipmaps. </dd>

Describes a tiled subresource volume.

Each packed mipmap is individually reported as 0 for WidthInTiles, HeightInTiles and DepthInTiles. The total number of tiles in subresources is WidthInTiles*HeightInTiles*DepthInTiles.

<dd> The width in tiles of the subresource. </dd>

<dd> The height in tiles of the subresource. </dd>

<dd> The depth in tiles of the subresource. </dd>

<dd> The index of the tile in the overall tiled subresource to start with. GetResourceTiling sets StartTileIndexInOverallResource to {{D3D11_PACKED_TILE}} (0xffffffff) to indicate that the whole {{D3D11_SUBRESOURCE_TILING}} structure is meaningless, and the info to which the pPackedMipDesc parameter of GetResourceTiling points applies. For packed tiles, the description of the packed mipmaps comes from a {{D3D11_PACKED_MIP_DESC}} structure instead. </dd>

Describes the shape of a tile by specifying its dimensions.

Texels are equivalent to pixels. For untyped buffer resources, a texel is just a byte. For multisample antialiasing ({{MSAA}}) surfaces, the numbers are still in terms of pixels/texels. The values here are independent of the surface dimensions. Even if the surface is smaller than what would fit in a tile, the full tile dimensions are reported here.

<dd> The width in texels of the tile. </dd>

<dd> The height in texels of the tile. </dd>

<dd> The depth in texels of the tile. </dd>

Describes the tile structure of a tiled resource with mipmaps.

<dd> Number of standard mipmaps in the tiled resource. </dd>

<dd> Number of packed mipmaps in the tiled resource. This number starts from the least detailed mipmap (either sharing tiles or using non standard tile layout). This number is 0 if no such packing is in the resource. For array surfaces, this value is the number of mipmaps that are packed for a given array slice where each array slice repeats the same packing. On Tier_2 tiled resources hardware, mipmaps that fill at least one standard shaped tile in all dimensions are not allowed to be included in the set of packed mipmaps. On Tier_1 hardware, mipmaps that are an integer multiple of one standard shaped tile in all dimensions are not allowed to be included in the set of packed mipmaps. Mipmaps with at least one dimension less than the standard tile shape may or may not be packed. When a given mipmap needs to be packed, all coarser mipmaps for a given array slice are considered packed as well. </dd>

<dd> Number of tiles for the packed mipmaps in the tiled resource. If there is no packing, this value is meaningless and is set to 0. Otherwise, it is set to the number of tiles that are needed to represent the set of packed mipmaps. The pixel layout within the packed mipmaps is hardware specific. If apps define only partial mappings for the set of tiles in packed mipmaps, read and write behavior is vendor specific and undefined. For arrays, this value is only the count of packed mipmaps within the subresources for each array slice. </dd>

<dd> Offset of the first packed tile for the resource in the overall range of tiles. If NumPackedMips is 0, this value is meaningless and is 0. Otherwise, it is the offset of the first packed tile for the resource in the overall range of tiles for the resource. A value of 0 for StartTileIndexInOverallResource means the entire resource is packed. For array surfaces, this is the offset for the tiles that contain the packed mipmaps for the first array slice. Packed mipmaps for each array slice in arrayed surfaces are at this offset past the beginning of the tiles for each array slice. Note??The number of overall tiles, packed or not, for a given array slice is simply the total number of tiles for the resource divided by the resource's array size, so it is easy to locate the range of tiles for any given array slice, out of which StartTileIndexInOverallResource identifies which of those are packed. ? </dd>

The device context interface represents a device context; it is used to render commands. {{ID3D11DeviceContext2}} adds new methods to those in {{ID3D11DeviceContext1}}.

Updates mappings of tile locations in tiled resources to memory locations in a tile pool.

In a single call to UpdateTileMappings, you can map one or more ranges of resource tiles to one or more ranges of tile-pool tiles. You can organize the parameters of UpdateTileMappings in these ways to perform an update:<ul> <li>Tiled resource whose mappings are updated. This is a resource that was created with the {{D3D11_RESOURCE_MISC_TILED}} flag. Mappings start off all {{NULL}} when a resource is initially created.</li> <li>Set of tile regions on the tiled resource whose mappings are updated. You can make one UpdateTileMappings call to update many mappings or multiple calls with a bit more {{API}} call overhead as well if that is more convenient. NumTiledResourceRegions specifies how many regions there are, pTiledResourceRegionStartCoordinates and pTiledResourceRegionSizes are each arrays that identify the start location and extend of each region. If NumTiledResourceRegions is 1, for convenience either or both of the arrays that describe the regions can be {{NULL}}. {{NULL}} for pTiledResourceRegionStartCoordinates means the start coordinate is all 0s, and {{NULL}} for pTiledResourceRegionSizes identifies a default region that is the full set of tiles for the entire tiled resource, including all mipmaps, array slices, or both. If pTiledResourceRegionStartCoordinates isn't {{NULL}} and pTiledResourceRegionSizes is {{NULL}}, the region size defaults to 1 tile for all regions. This makes it easy to define mappings for a set of individual tiles each at disparate locations by providing an array of locations in pTiledResourceRegionStartCoordinates without having to send an array of pTiledResourceRegionSizes all set to 1. The updates are applied from first region to last; so, if regions overlap in a single call, the updates later in the list overwrite the areas that overlap with previous updates. </li> <li>Tile pool that provides memory where tile mappings can go. A tiled resource can point to a single tile pool at a time. If a new tile pool is specified (for the first time or different from the last time a tile pool was specified), all existing tile mappings for the tiled resource are cleared and the new set of mappings in the current UpdateTileMappings call are applied for the new tile pool. If no tile pool is specified ({{NULL}}) or the same tile pool as a previous UpdateTileMappings call is provided, the UpdateTileMappings call just adds the new mappings to existing ones (overwriting on overlap). If UpdateTileMappings only defines {{NULL}} mappings, you don't need to specify a tile pool because it is irrelevant. But if you specify a tile pool anyway, it takes the same behavior as previously described when providing a tile pool. </li> <li>Set of tile ranges where mappings are going. Each given tile range can specify one of a few types of ranges: a range of tiles in a tile pool (default), a count of tiles in the tiled resource to map to a single tile in a tile pool (sharing the tile), a count of tile mappings in the tiled resource to skip and leave as they are, or a count of tiles in the tile pool to map to {{NULL}}.NumRanges specifies the number of tile ranges, where the total tiles identified across all ranges must match the total number of tiles in the tile regions from the previously described tiled resource. Mappings are defined by iterating through the tiles in the tile regions in sequential order - x then y then z order for box regions - while walking through the set of tile ranges in sequential order. The breakdown of tile regions doesn't have to line up with the breakdown of tile ranges, but the total number of tiles on both sides must be equal so that each tiled resource tile specified has a mapping specified. pRangeFlags, pTilePoolStartOffsets, and pRangeTileCounts are all arrays, of size NumRanges, that describe the tile ranges. If pRangeFlags is {{NULL}}, all ranges are sequential tiles in the tile pool; otherwise, for each range i, pRangeFlags[i] identifies how the mappings in that range of tiles work: <ul> <li>If pRangeFlags[i] is 0, that range defines sequential tiles in the tile pool, with the number of tiles being pRangeTileCounts[i] and the starting location pTilePoolStartOffsets[i]. If NumRanges is 1, pRangeTileCounts can be {{NULL}} and defaults to the total number of tiles specified by all the tile regions.</li> <li>If pRangeFlags[i] is {{D3D11_TILE_RANGE_REUSE_SINGLE_TILE}}, pTilePoolStartOffsets[i] identifies the single tile in the tile pool to map to, and pRangeTileCounts[i] specifies how many tiles from the tile regions to map to that tile pool location. If NumRanges is 1, pRangeTileCounts can be {{NULL}} and defaults to the total number of tiles specified by all the tile regions.</li> <li>If pRangeFlags[i] is {{D3D11_TILE_RANGE_NULL}}, pRangeTileCounts[i] specifies how many tiles from the tile regions to map to {{NULL}}. If NumRanges is 1, pRangeTileCounts can be {{NULL}} and defaults to the total number of tiles specified by all the tile regions. pTilePoolStartOffsets[i] is ignored for {{NULL}} mappings. </li> <li>If pRangeFlags[i] is {{D3D11_TILE_RANGE_SKIP}}, pRangeTileCounts[i] specifies how many tiles from the tile regions to skip over and leave existing mappings unchanged for. This can be useful if a tile region conveniently bounds an area of tile mappings to update except with some exceptions that need to be left the same as whatever they were mapped to before. pTilePoolStartOffsets[i] is ignored for {{SKIP}} mappings.</li> </ul> </li> <li>Flags parameter for overall options. {{D3D11_TILE_MAPPING_NO_OVERWRITE}} means the caller promises that previously submitted commands to the device that may still be executing do not reference any of the tile region being updated. This allows the device to avoid having to flush previously submitted work in order to do the tile mapping update. If the app violates this promise by updating tile mappings for locations in tiled resources still being referenced by outstanding commands, undefined rendering behavior results, which includes the potential for significant slowdowns on some architectures. This is like the "no overwrite" concept that exists elsewhere in the Direct3D {{API}}, except applied to tile mapping data structure itself, which in hardware is a page table. The absence of this flag requires that tile mapping updates specified by this UpdateTileMappings call must be completed before any subsequent Direct3D command can proceed.</li> </ul>If tile mappings have changed on a tiled resource that the app will render via RenderTargetView or DepthStencilView, the app must clear, by using the fixed function Clear {{APIs}}, the tiles that have changed within the area being rendered (mapped or not). If an app doesn't clear in these situations, the app receives undefined values when it reads from the tiled resource. Note??In Direct3D 11.2, hardware can now support ClearView on depth-only formats. For more info, see {{D3D11_FEATURE_DATA_D3D11_OPTIONS1}}.?If an app needs to preserve existing memory contents of areas in a tiled resource where mappings have changed, the app can first save the contents where tile mappings have changed, by copying them to a temporary surface, for example using CopyTiles, issuing the required Clear, and then copying the contents back. Suppose a tile is mapped into multiple tiled resources at the same time and tile contents are manipulated by any means (render, copy, and so on) via one of the tiled resources. Then, if the same tile is to be rendered via any other tiled resource, the tile must be cleared first as previously described. For more info about tiled resources, see Tiled resources.Here are some examples of common UpdateTileMappings cases: Returns {{S_OK}} if successful; otherwise, returns one of the following:<ul> <li> Returns {{E_INVALIDARG}} if various conditions such as invalid flags result in the call being dropped.The debug layer will emit an error. </li> <li> Returns {{E_OUTOFMEMORY}} if the call results in the driver having to allocate space for new page table mappings but running out of memory.If out of memory occurs when this is called in a commandlist and the commandlist is being executed, the device will be removed. Apps can avoid this situation by only doing update calls that change existing mappings from tiled resources within commandlists (so drivers will not have to allocate page table memory, only change the mapping). </li> <li> Returns {{DXGI_ERROR_DEVICE_REMOVED}} if the video card has been physically removed from the system, or a driver upgrade for the video card has occurred. </li> </ul>

<dd> A reference to the tiled resource. </dd>

<dd> The number of tiled resource regions. </dd>

<dd> An array of {{D3D11_TILED_RESOURCE_COORDINATE}} structures that describe the starting coordinates of the tiled resource regions. The NumTiledResourceRegions parameter specifies the number of {{D3D11_TILED_RESOURCE_COORDINATE}} structures in the array. </dd>

<dd> An array of {{D3D11_TILE_REGION_SIZE}} structures that describe the sizes of the tiled resource regions. The NumTiledResourceRegions parameter specifies the number of {{D3D11_TILE_REGION_SIZE}} structures in the array. </dd>

<dd> A reference to the tile pool. </dd>

<dd> The number of tile-pool ranges. </dd>

<dd> An array of {{D3D11_TILE_RANGE_FLAG}} values that describe each tile-pool range. The NumRanges parameter specifies the number of values in the array. </dd>

<dd> An array of offsets into the tile pool. These are 0-based tile offsets, counting in tiles (not bytes). </dd>

<dd> An array of tiles. An array of values that specify the number of tiles in each tile-pool range. The NumRanges parameter specifies the number of values in the array. </dd>

<dd> A combination of {{D3D11_TILE_MAPPING_FLAGS}} values that are combined by using a bitwise {{OR}} operation. </dd>

Copies mappings from a source tiled resource to a destination tiled resource.

CopyTileMappings helps with tasks such as shifting mappings around within and across tiled resources, for example, scrolling tiles. The source and destination regions can overlap; the result of the copy in this situation is as if the source was saved to a temp location and then from there written to the destination.For more info about tiled resources, see Tiled resources. Returns {{S_OK}} if successful; otherwise, returns one of the following: <ul> <li> Returns {{E_INVALIDARG}} if various conditions such as invalid flags or passing in non Tiled Resources result in the call being dropped. The dest and the source regions must each entirely fit in their resource or behavior is undefined (debug layer will emit an error). </li> <li> Returns {{E_OUTOFMEMORY}} if the call results in the driver having to allocate space for new page table mappings but running out of memory. If out of memory occurs when this is called in a commandlist and the commandlist is being executed, the device will be removed. Applications can avoid this situation by only doing update calls that change existing mappings from Tiled Resources within commandlists (so drivers will not have to allocate page table memory, only change the mapping). </li> </ul>

<dd> A reference to the destination tiled resource. </dd>

<dd> A reference to a {{D3D11_TILED_RESOURCE_COORDINATE}} structure that describes the starting coordinates of the destination tiled resource. </dd>

<dd> A reference to the source tiled resource. </dd>

<dd> A reference to a {{D3D11_TILED_RESOURCE_COORDINATE}} structure that describes the starting coordinates of the source tiled resource. </dd>

<dd> A reference to a {{D3D11_TILE_REGION_SIZE}} structure that describes the size of the tiled region. </dd>

<dd> A combination of {{D3D11_TILE_MAPPING_FLAGS}} values that are combined by using a bitwise {{OR}} operation. The only valid value is {{D3D11_TILE_MAPPING_NO_OVERWRITE}}, which indicates that previously submitted commands to the device that may still be executing do not reference any of the tile region being updated. The device can then avoid having to flush previously submitted work to perform the tile mapping update. If the app violates this promise by updating tile mappings for locations in tiled resources that are still being referenced by outstanding commands, undefined rendering behavior results, including the potential for significant slowdowns on some architectures. This is like the "no overwrite" concept that exists elsewhere in the Direct3D {{API}}, except applied to the tile mapping data structure itself (which in hardware is a page table). The absence of the {{D3D11_TILE_MAPPING_NO_OVERWRITE}} value requires that tile mapping updates that CopyTileMappings specifies must be completed before any subsequent Direct3D command can proceed. </dd>

Copies tiles from buffer to tiled resource or vice versa.

CopyTiles drops write operations to unmapped areas and handles read operations from unmapped areas (except on Tier_1 tiled resources, where reading and writing unmapped areas is invalid). If a copy operation involves writing to the same memory location multiple times because multiple locations in the destination resource are mapped to the same tile memory, the resulting write operations to multi-mapped tiles are non-deterministic and non-repeatable; that is, accesses to the tile memory happen in whatever order the hardware happens to execute the copy operation. The tiles involved in the copy operation can't include tiles that contain packed mipmaps or results of the copy operation are undefined. To transfer data to and from mipmaps that the hardware packs into one tile, you must use the standard (that is, non-tile specific) copy and update {{APIs}} (like {{ID3D11DeviceContext1::CopySubresourceRegion1}} and {{ID3D11DeviceContext1::UpdateSubresource1}}) or {{ID3D11DeviceContext::GenerateMips}} for the whole mipmap chain. The memory layout of the tiles in the non-tiled buffer resource side of the copy operation is linear in memory within 64 {{KB}} tiles, which the hardware and driver swizzle and deswizzle per tile as appropriate when they transfer to and from a tiled resource. For multisample antialiasing ({{MSAA}}) surfaces, the hardware and driver traverse each pixel's samples in sample-index order before they move to the next pixel. For tiles that are partially filled on the right side (for a surface that has a width not a multiple of tile width in pixels), the pitch and stride to move down a row is the full size in bytes of the number pixels that would fit across the tile if the tile was full. So, there can be a gap between each row of pixels in memory. Mipmaps that are smaller than a tile are not packed together in the linear layout, which might seem to be a waste of memory space, but as mentioned you can't use CopyTiles or {{ID3D11DeviceContext2::UpdateTiles}} to copy to mipmaps that the hardware packs together. You can just use generic copy and update {{APIs}} (like {{ID3D11DeviceContext1::CopySubresourceRegion1}} and {{ID3D11DeviceContext1::UpdateSubresource1}}) to copy small mipmaps individually. Although in the case of a generic copy {{API}} (like {{ID3D11DeviceContext1::CopySubresourceRegion1}}), the linear memory must be the same dimension as the tiled resource; {{ID3D11DeviceContext1::CopySubresourceRegion1}} can't copy from a buffer resource to a Texture2D for instance. For more info about tiled resources, see Tiled resources. Returns nothing

<dd> A reference to a tiled resource. </dd>

<dd> A reference to a {{D3D11_TILED_RESOURCE_COORDINATE}} structure that describes the starting coordinates of the tiled resource. </dd>

<dd> A reference to a {{D3D11_TILE_REGION_SIZE}} structure that describes the size of the tiled region. </dd>

<dd> A reference to an {{ID3D11Buffer}} that represents a default, dynamic, or staging buffer. </dd>

<dd> The offset in bytes into the buffer at pBuffer to start the operation. </dd>

<dd> A combination of {{D3D11_TILE_COPY_FLAG}}-typed values that are combined by using a bitwise {{OR}} operation and that identifies how to copy tiles. </dd>

Updates tiles by copying from app memory to the tiled resource.

UpdateTiles drops write operations to unmapped areas (except on Tier_1 tiled resources, where writing to unmapped areas is invalid). If a copy operation involves writing to the same memory location multiple times because multiple locations in the destination resource are mapped to the same tile memory, the resulting write operations to multi-mapped tiles are non-deterministic and non-repeatable; that is, accesses to the tile memory happen in whatever order the hardware happens to execute the copy operation.The tiles involved in the copy operation can't include tiles that contain packed mipmaps or results of the copy operation are undefined. To transfer data to and from mipmaps that the hardware packs into one tile, you must use the standard (that is, non-tile specific) copy and update {{APIs}} (like {{ID3D11DeviceContext1::CopySubresourceRegion1}} and {{ID3D11DeviceContext1::UpdateSubresource1}}) or {{ID3D11DeviceContext::GenerateMips}} for the whole mipmap chain.The memory layout of the data on the source side of the copy operation is linear in memory within 64 {{KB}} tiles, which the hardware and driver swizzle and deswizzle per tile as appropriate when they transfer to and from a tiled resource. For multisample antialiasing ({{MSAA}}) surfaces, the hardware and driver traverse each pixel's samples in sample-index order before they move to the next pixel. For tiles that are partially filled on the right side (for a surface that has a width not a multiple of tile width in pixels), the pitch and stride to move down a row is the full size in bytes of the number pixels that would fit across the tile if the tile was full. So, there can be a gap between each row of pixels in memory. Mipmaps that are smaller than a tile are not packed together in the linear layout, which might seem to be a waste of memory space, but as mentioned you can't use {{ID3D11DeviceContext2::CopyTiles}} or UpdateTiles to copy to mipmaps that the hardware packs together. You can just use generic copy and update {{APIs}} (like {{ID3D11DeviceContext1::CopySubresourceRegion1}} and {{ID3D11DeviceContext1::UpdateSubresource1}}) to copy small mipmaps individually. Although in the case of a generic copy {{API}} (like {{ID3D11DeviceContext1::CopySubresourceRegion1}}), the linear memory must be the same dimension as the tiled resource; {{ID3D11DeviceContext1::CopySubresourceRegion1}} can't copy from a buffer resource to a Texture2D for instance.For more info about tiled resources, see Tiled resources. Returns nothing

<dd> A reference to a tiled resource to update. </dd>

<dd> A reference to a {{D3D11_TILED_RESOURCE_COORDINATE}} structure that describes the starting coordinates of the tiled resource. </dd>

<dd> A reference to a {{D3D11_TILE_REGION_SIZE}} structure that describes the size of the tiled region. </dd>

<dd> A reference to memory that contains the source tile data that UpdateTiles uses to update the tiled resource. </dd>

<dd> A combination of {{D3D11_TILE_COPY_FLAG}}-typed values that are combined by using a bitwise {{OR}} operation. The only valid value is {{D3D11_TILE_COPY_NO_OVERWRITE}}. The other values aren't meaningful here, though by definition the {{D3D11_TILE_COPY_LINEAR_BUFFER_TO_SWIZZLED_TILED_RESOURCE}} value is basically what UpdateTiles does, but sources from app memory. </dd>

Resizes a tile pool.

ResizeTilePool increases or decreases the size of the tile pool depending on whether the app needs more or less working set for the tiled resources that are mapped into it. An app can allocate additional tile pools for new tiled resources, but if any single tiled resource needs more space than initially available in its tile pool, the app can increase the size of the resource's tile pool. A tiled resource can't have mappings into multiple tile pools simultaneously. When you increase the size of a tile pool, additional tiles are added to the end of the tile pool via one or more new allocations by the driver; your app can't detect the breakdown into the new allocations. Existing memory in the tile pool is left untouched, and existing tiled resource mappings into that memory remain intact.When you decrease the size of a tile pool, tiles are removed from the end (this is allowed even below the initial allocation size, down to 0). This means that new mappings can't be made past the new size. But, existing mappings past the end of the new size remain intact and useable. The memory is kept active as long as mappings to any part of the allocations that are being used for the tile pool memory remains. If after decreasing, some memory has been kept active because tile mappings are pointing to it and the tile pool is increased again (by any amount), the existing memory is reused first before any additional allocations occur to service the size of the increase. To be able to save memory, an app has to not only decrease a tile pool but also remove and remap existing mappings past the end of the new smaller tile pool size.The act of decreasing (and removing mappings) doesn't necessarily produce immediate memory savings. Freeing of memory depends on how granular the driver's underlying allocations for the tile pool are. When a decrease in the size of a tile pool happens to be enough to make a driver allocation unused, the driver can free the allocation. If a tile pool was increased and if you then decrease to previous sizes (and remove and remap tile mappings correspondingly), you will most likely yield memory savings. But, this scenario isn't guaranteed in the case that the sizes don't exactly align with the underlying allocation sizes chosen by the driver. For more info about tiled resources, see Tiled resources. Returns {{S_OK}} if successful; otherwise, returns one of the following:<ul> <li>Returns {{E_INVALIDARG}} if the new tile pool size isn't a multiple of 64 {{KB}} or 0.</li> <li>Returns {{E_OUTOFMEMORY}} if the call results in the driver having to allocate space for new page table mappings but running out of memory.</li> <li>Returns {{DXGI_ERROR_DEVICE_REMOVED}} if the video card has been physically removed from the system, or a driver upgrade for the video card has occurred.</li> </ul>For {{E_INVALIDARG}} or {{E_OUTOFMEMORY}}, the existing tile pool remains unchanged, which includes existing mappings.

<dd> A reference to an {{ID3D11Buffer}} for the tile pool to resize. </dd>

<dd> The new size in bytes of the tile pool. The size must be a multiple of 64 {{KB}} or 0. </dd>

Specifies a data access ordering constraint between multiple tiled resources. For more info about this constraint, see Remarks.

Apps can use tiled resources to reuse tiles in different resources. But, a device and driver might not be able to determine whether some memory in a tile pool that was just rendered to is now being used for reading. For example, an app can render to some tiles in a tile pool with one tiled resource but then read from the same tiles by using a different tiled resource. These tiled-resource operations are different from using one resource and then just switching from writing with {{ID3D11RenderTargetView}} to reading with {{ID3D11ShaderResourceView}}. The runtime already tracks and handles these one resource operations using {{ID3D11RenderTargetView}} and {{ID3D11ShaderResourceView}}. When an app transitions from accessing (reading or writing) some location in a tile pool with one resource to accessing the same memory (read or write) via another tiled resource (with mappings to the same memory), the app must call TiledResourceBarrier after the first use of the resource and before the second. The parameters are the pTiledResourceOrViewAccessBeforeBarrier for accesses before the barrier (via rendering, copying), and the pTiledResourceOrViewAccessAfterBarrier for accesses after the barrier by using the same tile pool memory. If the resources are identical, the app doesn't need to call TiledResourceBarrier because this kind of hazard is already tracked and handled. The barrier call informs the driver that operations issued to the resource before the call must complete before any accesses that occur after the call via a different tiled resource that shares the same memory. Either or both of the parameters (before or after the barrier) can be {{NULL}}. {{NULL}} before the barrier means all tiled resource accesses before the barrier must complete before the resource specified after the barrier can be referenced by the graphics processing unit ({{GPU}}). {{NULL}} after the barrier means that any tiled resources accessed after the barrier can only be executed by the {{GPU}} after accesses to the tiled resources before the barrier are finished. Both {{NULL}} means all previous tiled resource accesses are complete before any subsequent tiled resource access can proceed. An app can pass a view reference, a resource, or {{NULL}} for each parameter. Views are allowed not only for convenience but also to allow the app to scope the barrier effect to a relevant portion of a resource. For more info about tiled resources, see Tiled resources. Returns nothing

<dd> A reference to an {{ID3D11Resource}} or {{ID3D11View}} for a resource that was created with the {{D3D11_RESOURCE_MISC_TILED}} flag. Access operations on this object must complete before the access operations on the object that pTiledResourceOrViewAccessAfterBarrier specifies. </dd>

<dd> A reference to an {{ID3D11Resource}} or {{ID3D11View}} for a resource that was created with the {{D3D11_RESOURCE_MISC_TILED}} flag. Access operations on this object must begin after the access operations on the object that pTiledResourceOrViewAccessBeforeBarrier specifies. </dd>

Allows apps to determine when either a capture or profiling request is enabled.

Returns {{TRUE}} if the capture tool is present and capturing or the app is being profiled such that SetMarkerInt or BeginEventInt will be logged to {{ETW}}. Otherwise, it returns {{FALSE}}. Apps can use this to turn off self-throttling mechanisms in order to accurately capture what is currently being seen as app output. Apps can also avoid generating event markers and the associated overhead it may entail when there is no benefit to do so. If apps detect that capture is being performed, they can prevent the Direct3D debugging tools, such as Microsoft Visual Studio?2013, from capturing them. The purpose of the {{D3D11_CREATE_DEVICE_PREVENT_ALTERING_LAYER_SETTINGS_FROM_REGISTRY}} flag prior to Windows?8.1 was to allow the Direct3D runtime to prevent debugging tools from capturing apps. Returns {{TRUE}} if capture or profiling is enabled and {{FALSE}} otherwise.

Allows applications to annotate graphics commands.

SetMarkerInt allows applications to annotate graphics commands, in order to provide more context to what the {{GPU}} is executing. When {{ETW}} logging or a support tool is enabled, an additional marker is correlated between the {{CPU}} and {{GPU}} timelines. The pLabel and Data value are logged to {{ETW}}. When the appropriate {{ETW}} logging is not enabled, this method does nothing. This method does not return a value.

<dd> An optional string that will be logged to {{ETW}} when {{ETW}} logging is active. If ?#d? appears in the string, it will be replaced by the value of the Data parameter similar to the way printf works. </dd>

<dd> A signed data value that will be logged to {{ETW}} when {{ETW}} logging is active. </dd>

Allows applications to annotate the beginning of a range of graphics commands.

BeginEventInt allows applications to annotate the beginning of a range of graphics commands, in order to provide more context to what the {{GPU}} is executing. When {{ETW}} logging (or a supported tool) is enabled, an additional marker is correlated between the {{CPU}} and {{GPU}} timelines. The pLabel and Data value are logged to {{ETW}}. When the appropriate {{ETW}} logging is not enabled, this method does nothing. This method does not return a value.

<dd> A signed data value that will be logged to {{ETW}} when {{ETW}} logging is active. </dd>

Allows applications to annotate the end of a range of graphics commands.

EndEvent allows applications to annotate the end of a range of graphics commands, in order to provide more context to what the {{GPU}} is executing. When the appropriate {{ETW}} logging is not enabled, this method does nothing. When {{ETW}} logging is enabled, an additional marker is correlated between the {{CPU}} and {{GPU}} timelines. This method does not return a value.

The device interface represents a virtual adapter; it is used to create resources. {{ID3D11Device2}} adds new methods to those in {{ID3D11Device1}}.

Gets an immediate context, which can play back command lists.

The GetImmediateContext2 method returns an {{ID3D11DeviceContext2}} object that represents an immediate context, which is used to perform rendering that you want immediately submitted to a device. For most apps, an immediate context is the primary object that is used to draw your scene.The GetImmediateContext2 method increments the reference count of the immediate context by one. Therefore, you must call Release on the returned interface reference when you are done with it to avoid a memory leak. This method does not return a value.

Creates a deferred context, which can record command lists.

A deferred context is a thread-safe context that you can use to record graphics commands on a thread other than the main rendering thread. By using a deferred context, you can record graphics commands into a command list that is encapsulated by the {{ID3D11CommandList}} interface. After you record all scene items, you can then submit them to the main render thread for final rendering. In this manner, you can perform rendering tasks concurrently across multiple threads and potentially improve performance in multi-core {{CPU}} scenarios. You can create multiple deferred contexts. Note?? If you use the {{D3D11_CREATE_DEVICE_SINGLETHREADED}} value to create the device, CreateDeferredContext2 fails with {{DXGI_ERROR_INVALID_CALL}}, and you can't create a deferred context.? For more information about deferred contexts, see Immediate and Deferred Rendering. Returns {{S_OK}} if successful; otherwise, returns one of the following: <ul> <li> Returns {{DXGI_ERROR_DEVICE_REMOVED}} if the video card has been physically removed from the system, or a driver upgrade for the video card has occurred. If this error occurs, you should destroy and recreate the device. </li> <li> Returns {{DXGI_ERROR_INVALID_CALL}} if the CreateDeferredContext2 method can't be called from the current context. For example, if the device was created with the {{D3D11_CREATE_DEVICE_SINGLETHREADED}} value, CreateDeferredContext2 returns {{DXGI_ERROR_INVALID_CALL}}. </li> <li> Returns {{E_INVALIDARG}} if the ContextFlags parameter is invalid. </li> <li> Returns {{E_OUTOFMEMORY}} if the app has exhausted available memory. </li> </ul>

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

For more info about tiled resources, see Tiled resources. Returns nothing

<dd> A reference to the tiled resource to get info about. </dd>

<dd> A reference to a variable that receives the number of tiles needed to store the entire tiled resource. </dd>

<dd> A reference to a {{D3D11_PACKED_MIP_DESC}} structure that GetResourceTiling fills with info about how the tiled resource's mipmaps are packed. </dd>

<dd> A reference to a {{D3D11_TILE_SHAPE}} structure that GetResourceTiling fills with info about the tile shape. This is info about how pixels fit in the tiles, independent of tiled resource's dimensions, not including packed mipmaps. If the entire tiled resource is packed, this parameter is meaningless because the tiled resource has no defined layout for packed mipmaps. In this situation, GetResourceTiling sets the members of {{D3D11_TILE_SHAPE}} to zeros. </dd>

<dd> A reference to a variable that contains the number of tiles in the subresource. On input, this is the number of subresources to query tilings for; on output, this is the number that was actually retrieved at pSubresourceTilingsForNonPackedMips (clamped to what's available). </dd>

<dd> The number of the first subresource tile to get. GetResourceTiling ignores this parameter if the number that pNumSubresourceTilings points to is 0. </dd>

<dd> A reference to a {{D3D11_SUBRESOURCE_TILING}} structure that GetResourceTiling fills with info about subresource tiles. If subresource tiles are part of packed mipmaps, GetResourceTiling sets the members of {{D3D11_SUBRESOURCE_TILING}} to zeros, except the StartTileIndexInOverallResource member, which GetResourceTiling sets to {{D3D11_PACKED_TILE}} (0xffffffff). The {{D3D11_PACKED_TILE}} constant indicates that the whole {{D3D11_SUBRESOURCE_TILING}} structure is meaningless for this situation, and the info that the pPackedMipDesc parameter points to applies. </dd>

Get the number of quality levels available during multisampling.

When you multisample a texture, the number of quality levels available for an adapter is dependent on the texture format that you use and the number of samples that you request. The maximum number of quality levels is defined by {{D3D11_MAX_MULTISAMPLE_SAMPLE_COUNT}} in {{D3D11}}.h. If this method returns 0, the format and sample count combination is not supported for the installed adapter.Furthermore, the definition of a quality level is up to each hardware vendor to define, however no facility is provided by Direct3D to help discover this information.Note that {{FEATURE_LEVEL_10_1}} devices are required to support 4x {{MSAA}} for all render targets except {{R32G32B32A32}} and {{R32G32B32}}. {{FEATURE_LEVEL_11_0}} devices are required to support 4x {{MSAA}} for all render target formats, and 8x {{MSAA}} for all render target formats except {{R32G32B32A32}} formats. This method returns one of the Direct3D 11 Return Codes.

<dd> The texture format during multisampling. </dd>

<dd> The number of samples during multisampling. </dd>

<dd> A combination of {{D3D11_CHECK_MULTISAMPLE_QUALITY_LEVELS_FLAGS}} values that are combined by using a bitwise {{OR}} operation. Currently, only {{D3D11_CHECK_MULTISAMPLE_QUALITY_LEVELS_TILED_RESOURCE}} is supported. </dd>

<dd> A reference to a variable the receives the number of quality levels supported by the adapter. See Remarks. </dd>

Specifies the context in which a query occurs.

This enum is used by the following: <ul> <li> {{D3D11_QUERY_DESC1}} structure </li> <li> A {{CD3D11_QUERY_DESC1}} constructor.</li> <li> {{ID3D11DeviceContext3::Flush1}} method </li> </ul>

<dd> The query can occur in all contexts. </dd>

<dd> The query occurs in the context of a 3D command queue. </dd>

<dd> The query occurs in the context of a 3D compute queue. </dd>

<dd> The query occurs in the context of a 3D copy queue. </dd>

<dd> The query occurs in the context of video. </dd>

Specifies texture layout options.

This enumeration controls the swizzle pattern of default textures and enable map support on default textures. Callers must query {{D3D11_FEATURE_DATA_D3D11_OPTIONS2}} to ensure that each option is supported.The standard swizzle formats applies within each page-sized chunk, and pages are laid out in linear order with respect to one another. A 16-bit interleave pattern defines the conversion from pre-swizzled intra-page location to the post-swizzled location. To demonstrate, consider the 32bpp swizzle format above. This is represented by the following interleave masks, where bits on the left are most-significant.<code>{{UINT}} xBytesMask = 1010 1010 1000 1111 {{UINT}} yMask = 0101 0101 0111 0000 </code>To compute the swizzled address, the following code could be used (where the _pdep_u32 instruction is supported):<code>{{UINT}} swizzledOffset = resourceBaseOffset + _pdep_u32(xOffset, xBytesMask) + _pdep_u32(yOffset, yBytesMask); </code>

<dd> The texture layout is undefined, and is selected by the driver. </dd>

<dd> Data for the texture is stored in row major (sometimes called pitch-linear) order. </dd>

<dd> A default texture uses the standardized swizzle pattern. </dd>

Identifies whether conservative rasterization is on or off.

<dd> Conservative rasterization is off. </dd>

<dd> Conservative rasterization is on. </dd>

Device context options.

This enumeration is used by {{ID3D11DeviceContext::GetType}}.

<dd> The device context is an immediate context. </dd>

<dd> The device context is a deferred context. </dd>

Describes a 2D texture.

This structure is used in a call to {{ID3D11Device3::CreateTexture2D1}}.In addition to this structure, you can also use the {{CD3D11_TEXTURE2D_DESC1}} derived structure, which is defined in {{D3D11_3}}.h and behaves like an inherited class, to help create a texture description.The device places some size restrictions (must be multiples of a minimum size) for a subsampled, block compressed, or bit-format resource.The texture size range is determined by the feature level at which you create the device and not the Microsoft Direct3D interface version. For example, if you use Microsoft Direct3D?10 hardware at feature level 10 ({{D3D_FEATURE_LEVEL_10_0}}) and call {{D3D11CreateDevice}} to create an {{ID3D11Device}}, you must constrain the maximum texture size to {{D3D10_REQ_TEXTURE2D_U_OR_V_DIMENSION}} (8192) when you create your 2D texture.

<dd> Texture format (see {{DXGI_FORMAT}}). </dd>

<dd> Structure that specifies multisampling parameters for the texture. See {{DXGI_SAMPLE_DESC}}. </dd>

<dd> Flags (see {{D3D11_BIND_FLAG}}) for binding to pipeline stages. The flags can be combined by a logical {{OR}}. </dd>

<dd> A {{D3D11_TEXTURE_LAYOUT}}-typed value that identifies the layout of the texture. The TextureLayout parameter selects both the actual layout of the texture in memory and the layout visible to the application while the texture is mapped. These flags may not be requested without {{CPU}} access also requested. It is illegal to set {{CPU}} access flags on default textures without also setting TextureLayout to a value other than {{D3D11_TEXTURE_LAYOUT_UNDEFINED}}. {{D3D11_TEXTURE_LAYOUT_ROW_MAJOR}} may only be used to create non-multisampled, textures with a single subresource (Planar {{YUV}} textures are supported). These textures may only be used as a source and destination of copy operations, and BindFlags must be zero. {{D3D11_TEXTURE_LAYOUT_64K_STANDARD_SWIZZLE}} may only be used to create non-multisampled, non-depth-stencil textures. </dd>

Describes a 3D texture.

This structure is used in a call to {{ID3D11Device3::CreateTexture3D1}}.In addition to this structure, you can also use the {{CD3D11_TEXTURE3D_DESC1}} derived structure, which is defined in {{D3D11_3}}.h and behaves like an inherited class, to help create a texture description.The device restricts the size of subsampled, block compressed, and bit format resources to be multiples of sizes specific to each format.The texture size range is determined by the feature level at which you create the device and not the Microsoft Direct3D interface version. For example, if you use Microsoft Direct3D?10 hardware at feature level 10 ({{D3D_FEATURE_LEVEL_10_0}}) and call {{D3D11CreateDevice}} to create an {{ID3D11Device}}, you must constrain the maximum texture size to {{D3D10_REQ_TEXTURE3D_U_V_OR_W_DIMENSION}} (2048) when you create your 3D texture.

<dd> Texture format (see {{DXGI_FORMAT}}). </dd>

<dd> Flags (see {{D3D11_BIND_FLAG}}) for binding to pipeline stages. The flags can be combined by a logical {{OR}}. </dd>

<dd> A {{D3D11_TEXTURE_LAYOUT}}-typed value that identifies the layout of the texture. The TextureLayout parameter selects both the actual layout of the texture in memory and the layout visible to the application while the texture is mapped. These flags may not be requested without {{CPU}} access also requested. It is illegal to set {{CPU}} access flags on default textures without also setting Layout to a value other than {{D3D11_TEXTURE_LAYOUT_UNDEFINED}}. {{D3D11_TEXTURE_LAYOUT_ROW_MAJOR}} may not be used with 3D textures. {{D3D11_TEXTURE_LAYOUT_64K_STANDARD_SWIZZLE}} may not be used with 3D textures that have mipmaps. </dd>

Describes rasterizer state.

Rasterizer state defines the behavior of the rasterizer stage. To create a rasterizer-state object, call {{ID3D11Device3::CreateRasterizerState2}}. To set rasterizer state, call {{ID3D11DeviceContext::RSSetState}}.If you do not specify some rasterizer state, the Direct3D runtime uses the following default values for rasterizer state.<table> <tr><th>State</th><th>Default Value</th></tr> <tr><td>FillMode</td><td>Solid</td></tr> <tr><td>CullMode</td><td>Back</td></tr> <tr><td>FrontCounterClockwise</td><td>{{FALSE}}</td></tr> <tr><td>DepthBias</td><td>0</td></tr> <tr><td>SlopeScaledDepthBias</td><td>0.0f</td></tr> <tr><td>DepthBiasClamp</td><td>0.0f</td></tr> <tr><td>DepthClipEnable</td><td>{{TRUE}}</td></tr> <tr><td>ScissorEnable</td><td>{{FALSE}}</td></tr> <tr><td>MultisampleEnable</td><td>{{FALSE}}</td></tr> <tr><td>AntialiasedLineEnable</td><td>{{FALSE}}</td></tr> <tr><td>ForcedSampleCount</td><td>0</td></tr> <tr><td>ConservativeRaster</td><td>{{D3D11_CONSERVATIVE_RASTERIZATION_MODE_OFF}}</td></tr> </table>?Note??For feature levels 9.1, 9.2, 9.3, and 10.0, if you set MultisampleEnable to {{FALSE}}, the runtime renders all points, lines, and triangles without anti-aliasing even for render targets with a sample count greater than 1. For feature levels 10.1 and higher, the setting of MultisampleEnable has no effect on points and triangles with regard to {{MSAA}} and impacts only the selection of the line-rendering algorithm as shown in this table:? <table> <tr><th>Line-rendering algorithm</th><th>MultisampleEnable</th><th>AntialiasedLineEnable</th></tr> <tr><td>Aliased</td><td>{{FALSE}}</td><td>{{FALSE}}</td></tr> <tr><td>Alpha antialiased</td><td>{{FALSE}}</td><td>{{TRUE}}</td></tr> <tr><td>Quadrilateral</td><td>{{TRUE}}</td><td>{{FALSE}}</td></tr> <tr><td>Quadrilateral</td><td>{{TRUE}}</td><td>{{TRUE}}</td></tr> </table>?The settings of the MultisampleEnable and AntialiasedLineEnable members apply only to multisample antialiasing ({{MSAA}}) render targets (that is, render targets with sample counts greater than 1). Because of the differences in feature-level behavior and as long as you aren?t performing any line drawing or don?t mind that lines render as quadrilaterals, we recommend that you always set MultisampleEnable to {{TRUE}} whenever you render on {{MSAA}} render targets.

<dd> A {{D3D11_FILL_MODE}}-typed value that determines the fill mode to use when rendering. </dd>

<dd> A {{D3D11_CULL_MODE}}-typed value that indicates that triangles facing the specified direction are not drawn. </dd>

<dd> Depth value added to a given pixel. For info about depth bias, see Depth Bias. </dd>

<dd> Maximum depth bias of a pixel. For info about depth bias, see Depth Bias. </dd>

<dd> Scalar on a given pixel's slope. For info about depth bias, see Depth Bias. </dd>

<dd> Specifies whether to enable scissor-rectangle culling. All pixels outside an active scissor rectangle are culled. </dd>

<dd> A {{D3D11_CONSERVATIVE_RASTERIZATION_MODE}}-typed value that identifies whether conservative rasterization is on or off. </dd>

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

<dd> Index of the most detailed mipmap level to use; this number is between 0 and (MipLevels (from the original Texture2D for which {{ID3D11Device3::CreateShaderResourceView1}} creates a view) - 1 ). </dd>

<dd> The maximum number of mipmap levels for the view of the texture. See the remarks in {{D3D11_TEX1D_SRV}}. Set to -1 to indicate all the mipmap levels from MostDetailedMip on down to least detailed. </dd>

<dd> The index (plane slice number) of the plane to use in the texture. </dd>

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

<dd> Index of the most detailed mipmap level to use; this number is between 0 and ( MipLevels (from the original Texture2D for which {{ID3D11Device3::CreateShaderResourceView1}} creates a view) - 1). </dd>

<dd> The maximum number of mipmap levels for the view of the texture. See the remarks in {{D3D11_TEX1D_SRV}}. Set to -1 to indicate all the mipmap levels from MostDetailedMip on down to least detailed. </dd>

<dd> The index of the first texture to use in an array of textures. </dd>

<dd> Number of textures in the array. </dd>

<dd> The index (plane slice number) of the plane to use in an array of textures. </dd>

Describes a shader-resource view.

A view is a format-specific way to look at the data in a resource. The view determines what data to look at, and how it is cast when read.When viewing a resource, the resource-view description must specify a typed format, that is compatible with the resource format. So that means that you cannot create a resource-view description using any format with _TYPELESS in the name. You can however view a typeless resource by specifying a typed format for the view. For example, a {{DXGI_FORMAT_R32G32B32_TYPELESS}} resource can be viewed with one of these typed formats: {{DXGI_FORMAT_R32G32B32_FLOAT}}, {{DXGI_FORMAT_R32G32B32_UINT}}, and {{DXGI_FORMAT_R32G32B32_SINT}}, since these typed formats are compatible with the typeless resource.Create a shader-resource-view description by calling {{ID3D11Device3::CreateShaderResourceView1}}. To view a shader-resource-view description, call {{ID3D11ShaderResourceView1::GetDesc1}}.

<dd> A {{DXGI_FORMAT}}-typed value that specifies the viewing format. See remarks. </dd>

<dd> A {{D3D11_SRV_DIMENSION}}-typed value that specifies the resource type of the view. This type is the same as the resource type of the underlying resource. This member also determines which _SRV to use in the union below. </dd>

<dd> A {{D3D11_BUFFER_SRV}} structure that views the resource as a buffer. </dd>

<dd> A {{D3D11_TEX1D_SRV}} structure that views the resource as a 1D texture. </dd>

<dd> A {{D3D11_TEX1D_ARRAY_SRV}} structure that views the resource as a 1D-texture array. </dd>

<dd> A {{D3D11_TEX2D_SRV1}} structure that views the resource as a 2D-texture. </dd>

<dd> A {{D3D11_TEX2D_ARRAY_SRV1}} structure that views the resource as a 2D-texture array. </dd>

<dd> A {{D3D11_TEX2DMS_SRV}} structure that views the resource as a 2D-multisampled texture. </dd>

<dd> A {{D3D11_TEX2DMS_ARRAY_SRV}} structure that views the resource as a 2D-multisampled-texture array. </dd>

<dd> A {{D3D11_TEX3D_SRV}} structure that views the resource as a 3D texture. </dd>

<dd> A {{D3D11_TEXCUBE_SRV}} structure that views the resource as a 3D-cube texture. </dd>

<dd> A {{D3D11_TEXCUBE_ARRAY_SRV}} structure that views the resource as a 3D-cube-texture array. </dd>

<dd> A {{D3D11_BUFFEREX_SRV}} structure that views the resource as a raw buffer. For more info about raw viewing of buffers, see Raw Views of Buffers. </dd>

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

<dd> The index of the mipmap level to use mip slice. </dd>

<dd> The index (plane slice number) of the plane to use in the texture. </dd>

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

<dd> The index of the mipmap level to use mip slice. </dd>

<dd> The index of the first texture to use in an array of textures. </dd>

<dd> Number of textures in the array to use in the render-target view, starting from FirstArraySlice. </dd>

<dd> The index (plane slice number) of the plane to use in an array of textures. </dd>

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

A render-target-view description is passed into {{ID3D11Device3::CreateRenderTargetView1}} to create a render target.A render-target-view can't use the following formats:<ul> <li>Any typeless format.</li> <li>{{DXGI_FORMAT_R32G32B32}} if the view will be used to bind a buffer (vertex, index, constant, or stream-output).</li> </ul>If the format is set to {{DXGI_FORMAT_UNKNOWN}}, then the format of the resource that the view binds to the pipeline will be used.

<dd> A {{DXGI_FORMAT}}-typed value that specifies the data format. </dd>

<dd> A {{D3D11_RTV_DIMENSION}}-typed value that specifies the resource type and how the render-target resource will be accessed. </dd>

<dd> A {{D3D11_BUFFER_RTV}} structure that specifies which buffer elements can be accessed. </dd>

<dd> A {{D3D11_TEX1D_RTV}} structure that specifies the subresources in a 1D texture that can be accessed. </dd>

<dd> A {{D3D11_TEX1D_ARRAY_RTV}} structure that specifies the subresources in a 1D texture array that can be accessed. </dd>

<dd> A {{D3D11_TEX2D_RTV1}} structure that specifies the subresources in a 2D texture that can be accessed. </dd>

<dd> A {{D3D11_TEX2D_ARRAY_RTV1}} structure that specifies the subresources in a 2D texture array that can be accessed. </dd>

<dd> A {{D3D11_TEX2DMS_RTV}} structure that specifies a single subresource because a multisampled 2D texture only contains one subresource. </dd>

<dd> A {{D3D11_TEX2DMS_ARRAY_RTV}} structure that specifies the subresources in a multisampled 2D texture array that can be accessed. </dd>

<dd> A {{D3D11_TEX3D_RTV}} structure that specifies subresources in a 3D texture that can be accessed. </dd>

Describes a unordered-access 2D texture resource.

<dd> The mipmap slice index. </dd>

<dd> The index (plane slice number) of the plane to use in the texture. </dd>

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

<dd> The mipmap slice index. </dd>

<dd> The zero-based index of the first array slice to be accessed. </dd>

<dd> The number of slices in the array. </dd>

<dd> The index (plane slice number) of the plane to use in an array of textures. </dd>

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

An unordered-access-view description is passed into {{ID3D11Device3::CreateUnorderedAccessView1}} to create a view.

<dd> A {{DXGI_FORMAT}}-typed value that specifies the data format. </dd>

<dd> A {{D3D11_UAV_DIMENSION}}-typed value that specifies the resource type of the view. This type is the same as the resource type of the underlying resource. This member also determines which _UAV to use in the union below. </dd>

<dd> A {{D3D11_BUFFER_UAV}} structure that specifies which buffer elements can be accessed. </dd>

<dd> A {{D3D11_TEX1D_UAV}} structure that specifies the subresources in a 1D texture that can be accessed. </dd>

<dd> A {{D3D11_TEX1D_ARRAY_UAV}} structure that specifies the subresources in a 1D texture array that can be accessed. </dd>

<dd> A {{D3D11_TEX2D_UAV1}} structure that specifies the subresources in a 2D texture that can be accessed. </dd>

<dd> A {{D3D11_TEX2D_ARRAY_UAV1}} structure that specifies the subresources in a 2D texture array that can be accessed. </dd>

<dd> A {{D3D11_TEX3D_UAV}} structure that specifies subresources in a 3D texture that can be accessed. </dd>

Describes a query.

<dd> A {{D3D11_QUERY}}-typed value that specifies the type of query. </dd>

<dd> A combination of {{D3D11_QUERY_MISC_FLAG}}-typed values that are combined by using a bitwise {{OR}} operation. The resulting value specifies query behavior. </dd>

<dd> A {{D3D11_CONTEXT_TYPE}}-typed value that specifies the context for the query. </dd>

A 2D texture interface represents texel data, which is structured memory.

To create an empty Texture2D resource, call {{ID3D11Device3::CreateTexture2D1}}. For info about how to create a 2D texture, see How to: Create a Texture. Textures can't be bound directly to the pipeline; instead, a view must be created and bound. Using a view, texture data can be interpreted at run time within certain restrictions. To use the texture as a render-target or depth-stencil resource, call {{ID3D11Device3::CreateRenderTargetView1}}, and {{ID3D11Device::CreateDepthStencilView}}, respectively. To use the texture as an input to a shader, call {{ID3D11Device3::CreateShaderResourceView1}}.

Gets the properties of the texture resource.

Returns nothing.

<dd> A reference to a {{D3D11_TEXTURE2D_DESC1}} structure that receives the description of the 2D texture. </dd>

A 3D texture interface represents texel data, which is structured memory.

To create an empty Texture3D resource, call {{ID3D11Device3::CreateTexture3D1}}. For info about how to create a 2D texture, which is similar to creating a 3D texture, see How to: Create a Texture. Textures can't be bound directly to the pipeline; instead, a view must be created and bound. Using a view, texture data can be interpreted at run time within certain restrictions. To use the texture as a render-target or depth-stencil resource, call {{ID3D11Device3::CreateRenderTargetView1}}, and {{ID3D11Device::CreateDepthStencilView}}, respectively. To use the texture as an input to a shader, call {{ID3D11Device3::CreateShaderResourceView1}}.

Gets the properties of the texture resource.

Returns nothing.

<dd> A reference to a {{D3D11_TEXTURE3D_DESC1}} structure that receives the description of the 3D texture. </dd>

The rasterizer-state interface holds a description for rasterizer state that you can bind to the rasterizer stage. This rasterizer-state interface supports forced sample count and conservative rasterization mode.

To create a rasterizer-state object, call {{ID3D11Device3::CreateRasterizerState2}}. To bind the rasterizer-state object to the rasterizer stage, call {{ID3D11DeviceContext::RSSetState}}.

Gets the description for rasterizer state that you used to create the rasterizer-state object.

You use the description for rasterizer state in a call to the {{ID3D11Device3::CreateRasterizerState2}} method to create the rasterizer-state object. Returns nothing.

<dd> A reference to a {{D3D11_RASTERIZER_DESC2}} structure that receives a description of the rasterizer state. This rasterizer state can specify forced sample count and conservative rasterization mode. </dd>

A shader-resource-view interface represents the subresources a shader can access during rendering. Examples of shader resources include a constant buffer, a texture buffer, and a texture.

To create a shader-resource view, call {{ID3D11Device3::CreateShaderResourceView1}}.A shader-resource view is required when binding a resource to a shader stage; the binding occurs by calling {{ID3D11DeviceContext::GSSetShaderResources}}, {{ID3D11DeviceContext::VSSetShaderResources}} or {{ID3D11DeviceContext::PSSetShaderResources}}.

Gets the shader-resource view's description.

Returns nothing.

<dd> A reference to a {{D3D11_SHADER_RESOURCE_VIEW_DESC1}} structure that receives the description of the shader-resource view. </dd>

A render-target-view interface represents the render-target subresources that can be accessed during rendering.

To create a render-target view, call {{ID3D11Device3::CreateRenderTargetView1}}. To bind a render-target view to the pipeline, call {{ID3D11DeviceContext::OMSetRenderTargets}}.A render target is a resource that can be written by the output-merger stage at the end of a render pass. Each render target can also have a corresponding depth-stencil view.

Gets the properties of a render-target view.

Returns nothing.

<dd> A reference to a {{D3D11_RENDER_TARGET_VIEW_DESC1}} structure that receives the description of the render-target view. </dd>

An unordered-access-view interface represents the parts of a resource the pipeline can access during rendering.

To create a view for an unordered access resource, call {{ID3D11Device3::CreateUnorderedAccessView1}}.All resources must be bound to the pipeline before they can be accessed. Call {{ID3D11DeviceContext::CSSetUnorderedAccessViews}} to bind an unordered access view to a compute shader; call {{ID3D11DeviceContext::OMSetRenderTargetsAndUnorderedAccessViews}} to bind an unordered access view to a pixel shader.

Gets a description of the resource.

Returns nothing.

<dd> A reference to a {{D3D11_UNORDERED_ACCESS_VIEW_DESC1}} structure that receives the description of the unordered-access resource. </dd>

Represents a query object for querying information from the graphics processing unit ({{GPU}}).

A query can be created with {{ID3D11Device3::CreateQuery1}}.Query data is typically gathered by issuing an {{ID3D11DeviceContext::Begin}} command, issuing some graphics commands, issuing an {{ID3D11DeviceContext::End}} command, and then calling {{ID3D11DeviceContext::GetData}} to get data about what happened in between the Begin and End calls. The data returned by GetData will be different depending on the type of query.There are, however, some queries that do not require calls to Begin. For a list of possible queries see {{D3D11_QUERY}}.When using a query that does not require a call to Begin, it still requires a call to End. The call to End causes the data returned by GetData to be accurate up until the last call to End.

Gets a query description.

Returns nothing.

<dd> A reference to a {{D3D11_QUERY_DESC1}} structure that receives a description of the query. </dd>

The device context interface represents a device context; it is used to render commands. {{ID3D11DeviceContext3}} adds new methods to those in {{ID3D11DeviceContext2}}.

Sends queued-up commands in the command buffer to the graphics processing unit ({{GPU}}), with a specified context type and an optional event handle to create an event query.

Flush1 has parameters. For more information, see {{ID3D11DeviceContext::Flush}}, which doesn't have parameters. This method does not return a value.

<dd> A {{D3D11_CONTEXT_TYPE}} that specifies the context in which a query occurs, such as a 3D command queue, 3D compute queue, 3D copy queue, video, or image. </dd>

<dd> An optional event handle. When specified, this method creates an event query. Flush1 operates asynchronously, therefore it can return either before or after the {{GPU}} finishes executing the queued graphics commands, which will eventually complete. To create an event query, you can call {{ID3D11Device::CreateQuery}} with the value {{D3D11_QUERY_EVENT}} value. To determine when the {{GPU}} is finished processing the graphics commands, you can then use that event query in a call to {{ID3D11DeviceContext::GetData}}. </dd>

Sets the hardware protection state.

This method does not return a value.

<dd> Specifies whether to enable hardware protection. </dd>

Gets whether hardware protection is enabled.

This method does not return a value.

<dd> After this method returns, points to a {{BOOL}} that indicates whether hardware protection is enabled. </dd>

The {{ID3D11DeviceContext}} interface represents a device context which generates rendering commands.Note??The latest version of this interface is {{ID3D11DeviceContext4}} introduced in the Windows 10 Creators Update. Applications targetting Windows 10 Creators Update should use the {{ID3D11DeviceContext4}} interface instead of {{ID3D11Device}}.?

The device interface represents a virtual adapter; it is used to create resources. {{ID3D11Device3}} adds new methods to those in {{ID3D11Device2}}.

Creates a 2D texture.

CreateTexture2D1 creates a 2D texture resource, which can contain a number of 2D subresources. The number of subresources is specified in the texture description. All textures in a resource must have the same format, size, and number of mipmap levels.All resources are made up of one or more subresources. To load data into the texture, applications can supply the data initially as an array of {{D3D11_SUBRESOURCE_DATA}} structures pointed to by pInitialData, or they can use one of the {{D3DX}} texture functions such as {{D3DX11CreateTextureFromFile}}.For a 32 x 32 texture with a full mipmap chain, the pInitialData array has the following 6 elements: <ul> <li>pInitialData[0] = 32x32</li> <li>pInitialData[1] = 16x16</li> <li>pInitialData[2] = 8x8</li> <li>pInitialData[3] = 4x4 </li> <li>pInitialData[4] = 2x2 </li> <li>pInitialData[5] = 1x1 </li> </ul> If the method succeeds, the return code is {{S_OK}}. See Direct3D 11 Return Codes for failing error codes.

Creates a 3D texture.

CreateTexture3D1 creates a 3D texture resource, which can contain a number of 3D subresources. The number of textures is specified in the texture description. All textures in a resource must have the same format, size, and number of mipmap levels.All resources are made up of one or more subresources. To load data into the texture, applications can supply the data initially as an array of {{D3D11_SUBRESOURCE_DATA}} structures pointed to by pInitialData, or they can use one of the {{D3DX}} texture functions such as {{D3DX11CreateTextureFromFile}}.Each element of pInitialData provides all of the slices that are defined for a given miplevel. For example, for a 32 x 32 x 4 volume texture with a full mipmap chain, the array has the following 6 elements:<ul> <li>pInitialData[0] = 32x32 with 4 slices</li> <li>pInitialData[1] = 16x16 with 2 slices</li> <li>pInitialData[2] = 8x8 with 1 slice</li> <li>pInitialData[3] = 4x4 with 1 slice</li> <li>pInitialData[4] = 2x2 with 1 slice</li> <li>pInitialData[5] = 1x1 with 1 slice</li> </ul> If the method succeeds, the return code is {{S_OK}}. See Direct3D 11 Return Codes for failing error codes.

Creates a rasterizer state object that informs the rasterizer stage how to behave and forces the sample count while {{UAV}} rendering or rasterizing.

This method returns {{E_OUTOFMEMORY}} if there is insufficient memory to create the rasterizer state object. See Direct3D 11 Return Codes for other possible return values.

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

This method returns {{E_OUTOFMEMORY}} if there is insufficient memory to create the shader-resource view. See Direct3D 11 Return Codes for other possible return values.

<dd> Pointer to the resource that will serve as input to a shader. This resource must have been created with the {{D3D11_BIND_SHADER_RESOURCE}} flag. </dd>

<dd> A reference to a {{D3D11_SHADER_RESOURCE_VIEW_DESC1}} structure that describes a shader-resource view. Set this parameter to {{NULL}} to create a view that accesses the entire resource (using the format the resource was created with). </dd>

<dd> A reference to a memory block that receives a reference to a {{ID3D11ShaderResourceView1}} interface for the created shader-resource view. Set this parameter to {{NULL}} to validate the other input parameters (the method will return {{S_FALSE}} if the other input parameters pass validation). </dd>

Creates a view for accessing an unordered access resource.

This method returns {{E_OUTOFMEMORY}} if there is insufficient memory to create the unordered-access view. See Direct3D 11 Return Codes for other possible return values.

Creates a render-target view for accessing resource data.

A render-target view can be bound to the output-merger stage by calling {{ID3D11DeviceContext::OMSetRenderTargets}}. This method returns one of the Direct3D 11 Return Codes.

<dd> Pointer to a {{ID3D11Resource}} that represents a render target. This resource must have been created with the {{D3D11_BIND_RENDER_TARGET}} flag. </dd>

<dd> Pointer to a {{D3D11_RENDER_TARGET_VIEW_DESC1}} that represents a render-target view description. Set this parameter to {{NULL}} to create a view that accesses all of the subresources in mipmap level 0. </dd>

<dd> A reference to a memory block that receives a reference to a {{ID3D11RenderTargetView1}} interface for the created render-target view. Set this parameter to {{NULL}} to validate the other input parameters (the method will return {{S_FALSE}} if the other input parameters pass validation). </dd>

Creates a query object for querying information from the graphics processing unit ({{GPU}}).

This method returns {{E_OUTOFMEMORY}} if there is insufficient memory to create the query object. See Direct3D 11 Return Codes for other possible return values.

<dd> Pointer to a {{D3D11_QUERY_DESC1}} structure that represents a query description. </dd>

<dd> A reference to a memory block that receives a reference to a {{ID3D11Query1}} interface for the created query object. Set this parameter to {{NULL}} to validate the other input parameters (the method will return {{S_FALSE}} if the other input parameters pass validation). </dd>

Gets an immediate context, which can play back command lists.

The GetImmediateContext3 method outputs an {{ID3D11DeviceContext3}} object that represents an immediate context, which is used to perform rendering that you want immediately submitted to a device. For most apps, an immediate context is the primary object that is used to draw your scene. The GetImmediateContext3 method increments the reference count of the immediate context by one. Therefore, you must call Release on the returned interface reference when you are done with it to avoid a memory leak. This method does not return a value.

Creates a deferred context, which can record command lists.

Returns {{S_OK}} if successful; otherwise, returns one of the following: <ul> <li> Returns {{DXGI_ERROR_DEVICE_REMOVED}} if the video card has been physically removed from the system, or a driver upgrade for the video card has occurred. If this error occurs, you should destroy and recreate the device. </li> <li> Returns {{DXGI_ERROR_INVALID_CALL}} if the CreateDeferredContext3 method can't be called from the current context. For example, if the device was created with the {{D3D11_CREATE_DEVICE_SINGLETHREADED}} value, CreateDeferredContext3 returns {{DXGI_ERROR_INVALID_CALL}}. </li> <li> Returns {{E_INVALIDARG}} if the ContextFlags parameter is invalid. </li> <li> Returns {{E_OUTOFMEMORY}} if the app has exhausted available memory. </li> </ul>

Copies data into a {{D3D11_USAGE_DEFAULT}} texture which was mapped using {{ID3D11DeviceContext3::}}Map while providing a {{NULL}} {{D3D11_MAPPED_SUBRESOURCE}} parameter.

The provided resource must be a {{D3D11_USAGE_DEFAULT}} texture which was mapped for writing by a previous call to {{ID3D11DeviceContext3::}}Map while providing a {{NULL}} {{D3D11_MAPPED_SUBRESOURCE}} parameter. This {{API}} is intended for calling at high frequency. Callers can reduce memory by making iterative calls that update progressive regions of the texture, while provide a small buffer during each call. It is most efficient to specify large enough regions, though, because this enables {{D3D}} to fill whole cache lines in the texture before returning. For efficiency, ensure the bounds and alignment of the extents within the box are ( 64 / [bytes per pixel] ) pixels horizontally. Vertical bounds and alignment should be 2 rows, except when 1-byte-per-pixel formats are used, in which case 4 rows are recommended. Single depth slices per call are handled efficiently. It is recommended but not necessary to provide references and strides which are 128-byte aligned. When writing to sub mipmap levels, it is recommended to use larger width and heights than described above. This is because small mipmap levels may actually be stored within a larger block of memory, with an opaque amount of offsetting which can interfere with alignment to cache lines. This method does not return a value.

Copies data from a {{D3D11_USAGE_DEFAULT}} texture which was mapped using {{ID3D11DeviceContext3::}}Map while providing a {{NULL}} {{D3D11_MAPPED_SUBRESOURCE}} parameter.

The provided resource must be a {{D3D11_USAGE_DEFAULT}} texture which was mapped for writing by a previous call to {{ID3D11DeviceContext3::}}Map while providing a {{NULL}} {{D3D11_MAPPED_SUBRESOURCE}} parameter. This {{API}} is intended for calling at high frequency. Callers can reduce memory by making iterative calls that update progressive regions of the texture, while provide a small buffer during each call. It is most efficient to specify large enough regions, though, because this enables {{D3D}} to fill whole cache lines in the texture before returning. For efficiency, ensure the bounds and alignment of the extents within the box are ( 64 / [Bytes per pixel] ) pixels horizontally. Vertical bounds and alignment should be 2 rows, except when 1-byte-per-pixel formats are used, in which case 4 rows are recommended. Single depth slices per call are handled efficiently. It is recommended but not necessary to provide references and strides which are 128-byte aligned. When reading from sub mipmap levels, it is recommended to use larger width and heights than described above. This is because small mipmap levels may actually be stored within a larger block of memory, with an opaque amount of offseting which can interfere with alignment to cache lines. This method does not return a value.

Describes Direct3D 11.4 feature options in the current graphics driver.

Use this structure with the {{D3D11_FEATURE_D3D11_OPTIONS4}} member of {{D3D11_FEATURE}}. Refer to the section on {{NV12}} in Direct3D 11.4 Features.

<dd> Specifies a {{BOOL}} that determines if {{NV12}} textures can be shared across processes and {{D3D}} devices. </dd>

The device interface represents a virtual adapter; it is used to create resources. {{ID3D11Device4}} adds new methods to those in {{ID3D11Device3}}, such as RegisterDeviceRemovedEvent and UnregisterDeviceRemoved.

Registers the "device removed" event and indicates when a Direct3D device has become removed for any reason, using an asynchronous notification mechanism.

Indicates when a Direct3D device has become removed for any reason, using an asynchronous notification mechanism, rather than as an {{HRESULT}} from Present. The reason for device removal can be retrieved using {{ID3D11Device::GetDeviceRemovedReason}} after being notified of the occurrence. Applications register and un-register a Win32 event handle with a particular device. That event handle will be signaled when the device becomes removed. A poll into the device's {{ID3D11Device::GetDeviceRemovedReason}} method indicates that the device is removed. {{ISignalableNotifier}} or SetThreadpoolWait can be used by {{UWP}} apps. When the graphics device is lost, the app or title will receive the graphics event, so that the app or title knows that its graphics device is no longer valid and it is safe for the app or title to re-create its DirectX devices. In response to this event, the app or title needs to re-create its rendering device and pass it into a SetRenderingDevice call on the composition graphics device objects. After setting this new rendering device, the app or title needs to redraw content of all the pre-existing surfaces after the composition graphics device's OnRenderingDeviceReplaced event is fired. This method supports Composition for device loss. The event is not signaled when it is most ideal to re-create. So, instead, we recommend iterating through the adapter ordinals and creating the first ordinal that will succeed. The application can register an event with the device. The application will be signaled when the device becomes removed. If the device is already removed, calls to RegisterDeviceRemovedEvent will signal the event immediately. No device-removed error code will be returned from RegisterDeviceRemovedEvent. Each "device removed" event is never signaled, or is signaled only once. These events are not signaled during device destruction. These events are unregistered during destruction. The semantics of RegisterDeviceRemovedEvent are similar to {{IDXGIFactory2::RegisterOcclusionStatusEvent}}. See Direct3D 11 Return Codes.

<dd> The handle to the "device removed" event. </dd>

<dd> A reference to information about the "device removed" event, which can be used in UnregisterDeviceRemoved to unregister the event. </dd>

Unregisters the "device removed" event.

See RegisterDeviceRemovedEvent. This method does not return a value.

<dd> Information about the "device removed" event, retrieved during a successful RegisterDeviceRemovedEvent call. </dd>

The device interface represents a virtual adapter; it is used to create resources.Note??The latest version of this interface is {{ID3D11Device5}} introduced in the Windows 10 Creators Update. Applications targetting Windows 10 Creators Update should use the {{ID3D11Device5}} interface instead of {{ID3D11Device}}.?

A device is created using {{D3D11CreateDevice}}. Windows?Phone?8: This {{API}} is supported.

The device interface represents a virtual adapter; it is used to create resources. {{ID3D11Device5}} adds new methods to those in {{ID3D11Device4}}.Note??This interface, introduced in the Windows 10 Creators Update, is the latest version of the {{ID3D11Device}} interface. Applications targetting Windows 10 Creators Update should use this interface instead of earlier versions.?

Provides threading protection for critical sections of a multi-threaded application.

This interface is obtained by querying it from an immediate device context created with the {{ID3D11DeviceContext}} (or later versions of this) interface using {{IUnknown::QueryInterface}}.Unlike {{D3D10}}, there is no multithreaded layer in {{D3D11}}. By default, multithread protection is turned off. Use SetMultithreadProtected to turn it on, then Enter and Leave to encapsulate graphics commands that must be executed in a specific order.By default in {{D3D11}}, applications can only use one thread with the immediate context at a time. But, applications can use this interface to change that restriction. The interface can turn on threading protection for the immediate context, which will increase the overhead of each immediate context call in order to share one context with multiple threads.

Enter a device's critical section.

If SetMultithreadProtected is set to true, then entering a device's critical section prevents other threads from simultaneously calling that device's methods, calling {{DXGI}} methods, and calling the methods of all resource, view, shader, state, and asynchronous interfaces.This function should be used in multithreaded applications when there is a series of graphics commands that must happen in order. This function is typically called at the beginning of the series of graphics commands, and Leave is typically called after those graphics commands. This method does not return a value.

Leave a device's critical section.

This function is typically used in multithreaded applications when there is a series of graphics commands that must happen in order. Enter is typically called at the beginning of a series of graphics commands, and this function is typically called after those graphics commands. This method does not return a value.

Turns multithread protection on or off.

True if multithread protection was already turned on prior to calling this method, false otherwise.

<dd> Set to true to turn multithread protection on, false to turn it off. </dd>

Find out if multithread protection is turned on or not.

Returns true if multithread protection is turned on, false otherwise.

Provides the video functionality of a Microsoft Direct3D?11 device.

Specifies the type of a command list.

This enum is used by the following methods:<ul> <li> CreateCommandAllocator </li> <li> CreateCommandQueue </li> <li> CreateCommandList </li> </ul>

<dd> Specifies a command buffer that the {{GPU}} can execute. A direct command list doesn't inherit any {{GPU}} state. </dd>

<dd> Specifies a command buffer that can be executed only directly via a direct command list. A bundle command list inherits all {{GPU}} state (except for the currently set pipeline state object and primitive topology). </dd>

<dd> Specifies a command buffer for computing. </dd>

<dd> Specifies a command buffer for copying (drawing). </dd>

Specifies flags to be used when creating a command queue.

This enum is used by the {{D3D12_COMMAND_QUEUE_DESC}} structure.

<dd> Indicates a default command queue. </dd>

<dd> Indicates that the {{GPU}} timeout should be disabled for this command queue. </dd>

Defines priority levels for a command queue.

This enumeration is used by the Priority member of the {{D3D12_COMMAND_QUEUE_DESC}} structure.

<dd> Normal priority. </dd>

<dd> High priority. </dd>

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

This enum is used by the {{D3D12_GRAPHICS_PIPELINE_STATE_DESC}} structure.

<dd> The shader has not been initialized with an input primitive type. </dd>

<dd> Interpret the input primitive as a point. </dd>

<dd> Interpret the input primitive as a line. </dd>

<dd> Interpret the input primitive as a triangle. </dd>

<dd> Interpret the input primitive as a control point patch. </dd>

Identifies the type of data contained in an input slot.

Specify one of these values in the member of a {{D3D12_INPUT_ELEMENT_DESC}} structure to specify the type of data for the input element of a pipeline state object.

<dd> Input data is per-vertex data. </dd>

<dd> Input data is per-instance data. </dd>

Specifies the fill mode to use when rendering triangles.

Fill mode is specified in a {{D3D12_RASTERIZER_DESC}} structure.

<dd> Draw lines connecting the vertices. Adjacent vertices are not drawn. </dd>

<dd> Fill the triangles formed by the vertices. Adjacent vertices are not drawn. </dd>

Specifies triangles facing a particular direction are not drawn.

Cull mode is specified in a {{D3D12_RASTERIZER_DESC}} structure.

<dd> Always draw all triangles. </dd>

<dd> Do not draw triangles that are front-facing. </dd>

<dd> Do not draw triangles that are back-facing. </dd>

Specifies comparison options.

A comparison option determines how the runtime compares source (new) data against destination (existing) data before storing the new data. The comparison option is declared in a description before an object is created. The {{API}} allows you to set a comparison option for <ul> <li> a depth-stencil buffer ({{D3D12_DEPTH_STENCIL_DESC}}) </li> <li> depth-stencil operations ({{D3D12_DEPTH_STENCILOP_DESC}}) </li> <li> sampler state ({{D3D12_SAMPLER_DESC}}) </li> </ul>

<dd> Never pass the comparison. </dd>

<dd> If the source data is less than the destination data, the comparison passes. </dd>

<dd> If the source data is equal to the destination data, the comparison passes. </dd>

<dd> If the source data is less than or equal to the destination data, the comparison passes. </dd>

<dd> If the source data is greater than the destination data, the comparison passes. </dd>

<dd> If the source data is not equal to the destination data, the comparison passes. </dd>

<dd> If the source data is greater than or equal to the destination data, the comparison passes. </dd>

<dd> Always pass the comparison. </dd>

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

This enum is used by the {{D3D12_DEPTH_STENCIL_DESC}} structure.

<dd> Turn off writes to the depth-stencil buffer. </dd>

<dd> Turn on writes to the depth-stencil buffer. </dd>

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

This enum is used by the {{D3D12_DEPTH_STENCILOP_DESC}} structure.

<dd> Keep the existing stencil data. </dd>

<dd> Set the stencil data to 0. </dd>

<dd> Set the stencil data to the reference value set by calling {{ID3D11DeviceContext::OMSetDepthStencilState}}. </dd>

<dd> Increment the stencil value by 1, and clamp the result. </dd>

<dd> Decrement the stencil value by 1, and clamp the result. </dd>

<dd> Invert the stencil data. </dd>

<dd> Increment the stencil value by 1, and wrap the result if necessary. </dd>

<dd> Decrement the stencil value by 1, and wrap the result if necessary. </dd>

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

Source and destination blend operations are specified in a {{D3D12_RENDER_TARGET_BLEND_DESC}} structure.