YourPhoneControls.Managed InitializeComponent() Connect() GetBindingConnector(int connectionId, object target) Use this class with an ItemsRepeater and ItemTemplate to maximize reuse while avoiding memory leaks that happens when the built-in repeater recycling is used, see ADO#57451824 for context. You can use this with any control that accepts IElementFactory. InitializeComponent() Connect() GetBindingConnector(int connectionId, object target) The UniformGrid2 control presents information within a Grid with even spacing. The UniformGrid2 spaces items evenly. Referencable class object we can use to have a reference shared between our and iterator. This is used so we can better isolate our logic and make it easier to test. The instance used to efficiently track empty spots. Initializes a new instance of the class. The number of rows to track. The number of columns to track. Gets the height of the grid to monitor. Gets the width of the grid to monitor. Gets or sets the value of a specified grid cell. The vertical offset. The horizontal offset. Fills the specified area in the current grid with a given value. If invalid coordinates are given, they will simply be ignored and no exception will be thrown. The value to fill the target area with. The row to start on (inclusive, 0-based index). The column to start on (inclusive, 0-based index). The positive width of area to fill. The positive height of area to fill. Resets the current reference holder. Determines if this element in the grid participates in the auto-layout algorithm. Gets the AutoLayout Attached Property Value. Used internally to track items which need to be arranged vs. fixed in place. A true value indicates this item should be automatically arranged. Gets the AutoLayout Attached Property Value. Used internally to track items which need to be arranged vs. fixed in place. A true value indicates this item should be automatically arranged. Gets the AutoLayout Attached Property Value. Used internally to track items which need to be arranged vs. fixed in place. A true value indicates this item should be automatically arranged. Sets the AutoLayout Attached Property Value. Used internally to track items which need to be arranged vs. fixed in place. Though it its required to use this property to force an element to the 0, 0 position. A true value indicates this item should be automatically arranged. Sets the AutoLayout Attached Property Value. Used internally to track items which need to be arranged vs. fixed in place. A true value indicates this item should be automatically arranged. Sets the AutoLayout Attached Property Value. Used internally to track items which need to be arranged vs. fixed in place. A true value indicates this item should be automatically arranged. Identifies the dependency property. Identifies the dependency property. Identifies the dependency property. Identifies the dependency property. Gets or sets the number of columns in the UniformGrid2. Gets or sets the starting column offset for the first row of the UniformGrid2. Gets or sets the orientation of the grid. When , will transpose the layout of automatically arranged items such that they start from top to bottom then based on . Defaults to . Gets or sets the number of rows in the UniformGrid2. InitializeComponent() Connect() GetBindingConnector(int connectionId, object target) Main class for providing metadata for the app or library GetXamlType(Type) GetXamlType(String) GetXmlnsDefinitions() The **HRESULT** data type is the same as the [SCODE](scode.md) data type. An **HRESULT** value consists of the following fields: - A 1-bit code indicating severity, where zero represents success and 1 represents failure. - A 4-bit reserved value. - An 11-bit code indicating responsibility for the error or warning, also known as a facility code. - A 16-bit code describing the error or warning. Most MAPI interface methods and functions return **HRESULT** values to provide detailed cause formation. **HRESULT** values are also used widely in OLE interface methods. OLE provides several macros for converting between **HRESULT** values and **SCODE** values, another common data type for error handling. > [!NOTE] > In 64-bit MAPI, **HRESULT** is still a 32-bit value. For information about the OLE use of **HRESULT** values, see the *OLE Programmer's Reference*. For more information about the use of these values in MAPI, see [Error Handling](error-handling-in-mapi.md) and any of the following interface methods: [IABLogon::GetLastError](iablogon-getlasterror.md) [IMAPISupport::GetLastError](imapisupport-getlasterror.md) [IMAPIControl::GetLastError](imapicontrol-getlasterror.md) [IMAPITable::GetLastError](imapitable-getlasterror.md) [IMAPIProp::GetLastError](imapiprop-getlasterror.md) [IMAPIViewAdviseSink::OnPrint](imapiviewadvisesink-onprint.md) Read more on docs.microsoft.com. A pointer to the IErrorInfo interface that provides more information about the error. You can specify to use the current IErrorInfo interface, or new IntPtr(-1) to ignore the current IErrorInfo interface and construct the exception just from the error code. , if it does not reflect an error. Documentation varies per use. Refer to each: IMbnConnectionContextEvents.OnSetProvisionedContextComplete, IMbnConnectionEvents.OnConnectComplete, IMbnPinEvents.OnChangeComplete, IMbnPinEvents.OnDisableComplete, IMbnPinEvents.OnEnableComplete, IMbnPinEvents.OnEnterComplete, IMbnPinEvents.OnUnblockComplete, IMbnPinManagerEvents.OnGetPinStateComplete, IMbnRadioEvents.OnSetSoftwareRadioStateComplete, IMbnServiceActivationEvents.OnActivationComplete, IMbnSmsEvents.OnSetSmsConfigurationComplete, IMbnSmsEvents.OnSmsDeleteComplete, IMbnSmsEvents.OnSmsReadComplete, IMbnSmsEvents.OnSmsSendComplete. The LUID structure is an opaque structure that specifies an identifier that is guaranteed to be unique on the local machine. For more information, see the reference page for LUID in the Microsoft Windows SDK documentation. Learn more about this API from docs.microsoft.com. A pointer to a null-terminated, constant, ANSI character string. A pointer to the first character in the string. The content should be considered readonly, as it was typed as constant in the SDK. Gets the number of characters up to the first null character (exclusive). Returns a with a copy of this character array, decoding as UTF-8. A , or if is . Returns a span of the characters in this string, up to the first null character (exclusive). Returns a span of the characters in this string, up to the first null character (exclusive). The RECT structure defines a rectangle by the coordinates of its upper-left and lower-right corners. The RECT structure is identical to the RECTL structure. Specifies the x-coordinate of the upper-left corner of the rectangle. Specifies the y-coordinate of the upper-left corner of the rectangle. Specifies the x-coordinate of the lower-right corner of the rectangle. Specifies the y-coordinate of the lower-right corner of the rectangle. The length of the inline array. Gets a ref to an individual element of the inline array. ⚠ Important ⚠: When this struct is on the stack, do not let the returned reference outlive the stack frame that defines it. Gets this inline array as a span. ⚠ Important ⚠: When this struct is on the stack, do not let the returned span outlive the stack frame that defines it. Gets this inline array as a span. ⚠ Important ⚠: When this struct is on the stack, do not let the returned span outlive the stack frame that defines it. Copies the fixed array to a new string up to the specified length regardless of whether there are null terminating characters. Thrown when is less than 0 or greater than . Copies the fixed array to a new string, stopping before the first null terminator character or at the end of the fixed array (whichever is shorter). The length of the inline array. Gets a ref to an individual element of the inline array. ⚠ Important ⚠: When this struct is on the stack, do not let the returned reference outlive the stack frame that defines it. Gets this inline array as a span. ⚠ Important ⚠: When this struct is on the stack, do not let the returned span outlive the stack frame that defines it. Gets this inline array as a span. ⚠ Important ⚠: When this struct is on the stack, do not let the returned span outlive the stack frame that defines it. Copies the fixed array to a new string up to the specified length regardless of whether there are null terminating characters. Thrown when is less than 0 or greater than . Copies the fixed array to a new string, stopping before the first null terminator character or at the end of the fixed array (whichever is shorter). Identifies how to bind a resource to the pipeline. (D3D11_BIND_FLAG) In general, binding flags can be combined using a bitwise 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: This doc was truncated. Read more on docs.microsoft.com. Bind a buffer as a vertex buffer to the input-assembler stage. Bind a buffer as an index buffer to the input-assembler stage. Bind a buffer as a constant buffer to a shader stage; this flag may NOT be combined with any other bind flag. 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.
 
 Read more on docs.microsoft.com. Bind an output buffer for the stream-output stage. Bind a texture as a render target for the output-merger stage. Bind a texture as a depth-stencil target for the output-merger stage. Bind an unordered access resource. 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. Read more on docs.microsoft.com. 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. Read more on docs.microsoft.com. Blend factors, which modulate values for the pixel shader and render target. Blend operations are specified in a blend description. The blend factor is (0, 0, 0, 0). No pre-blend operation. The blend factor is (1, 1, 1, 1). No pre-blend operation. The blend factor is (Rₛ, Gₛ, Bₛ, Aₛ), that is color data (RGB) from a pixel shader. No pre-blend operation. The blend factor is (1 - Rₛ, 1 - Gₛ, 1 - Bₛ, 1 - Aₛ), that is color data (RGB) from a pixel shader. The pre-blend operation inverts the data, generating 1 - RGB. The blend factor is (Aₛ, Aₛ, Aₛ, Aₛ), that is alpha data (A) from a pixel shader. No pre-blend operation. The blend factor is ( 1 - Aₛ, 1 - Aₛ, 1 - Aₛ, 1 - Aₛ), that is alpha data (A) from a pixel shader. The pre-blend operation inverts the data, generating 1 - A. The blend factor is (Ad Ad Ad Ad), that is alpha data from a render target. No pre-blend operation. The blend factor is (1 - Ad 1 - Ad 1 - Ad 1 - Ad), that is alpha data from a render target. The pre-blend operation inverts the data, generating 1 - A. The blend factor is (Rd, Gd, Bd, Ad), that is color data from a render target. No pre-blend operation. The blend factor is (1 - Rd, 1 - Gd, 1 - Bd, 1 - Ad), that is color data from a render target. The pre-blend operation inverts the data, generating 1 - RGB. The blend factor is (f, f, f, 1); where f = min(Aₛ, 1 - Ad). The pre-blend operation clamps the data to 1 or less. Read more on docs.microsoft.com. The blend factor is the blend factor set with ID3D11DeviceContext::OMSetBlendState. No pre-blend operation. The blend factor is the blend factor set with ID3D11DeviceContext::OMSetBlendState. The pre-blend operation inverts the blend factor, generating 1 - blend_factor. The blend factor is data sources both as color data output by a pixel shader. There is no pre-blend operation. This blend factor supports dual-source color blending. The blend factor is data sources both as color data output by a pixel shader. The pre-blend operation inverts the data, generating 1 - RGB. This blend factor supports dual-source color blending. The blend factor is data sources as alpha data output by a pixel shader. There is no pre-blend operation. This blend factor supports dual-source color blending. The blend factor is data sources as alpha data output by a pixel shader. The pre-blend operation inverts the data, generating 1 - A. This blend factor supports dual-source color blending. Describes the blend state that you use in a call to ID3D11Device::CreateBlendState to create a blend-state object. Here are the default values for blend state. This doc was truncated. Read more on docs.microsoft.com. Type: BOOL Specifies whether to use alpha-to-coverage as a multisampling technique when setting a pixel to a render target. For more info about using alpha-to-coverage, see Alpha-To-Coverage. Read more on docs.microsoft.com. Type: BOOL Specifies whether to enable independent blending in simultaneous render targets. Set to TRUE to enable independent blending. If set to FALSE, only the RenderTarget[0] members are used; RenderTarget[1..7] are ignored. Read more on docs.microsoft.com. Type: D3D11_RENDER_TARGET_BLEND_DESC[8] An array of D3D11_RENDER_TARGET_BLEND_DESC structures that describe the blend states for render targets; these correspond to the eight render targets that can be bound to the output-merger stage at one time. Read more on docs.microsoft.com. RGB or alpha blending operation. (D3D11_BLEND_OP) 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. Read more on docs.microsoft.com. Add source 1 and source 2. Subtract source 1 from source 2. Subtract source 2 from source 1. Find the minimum of source 1 and source 2. Find the maximum of source 1 and source 2. Defines a 3D box. (D3D11_BOX) The following diagram shows a 3D box, where the origin is the left, front, top corner. This doc was truncated. Read more on docs.microsoft.com. Type: UINT The x position of the left hand side of the box. Read more on docs.microsoft.com. Type: UINT The y position of the top of the box. Read more on docs.microsoft.com. Type: UINT The z position of the front of the box. Read more on docs.microsoft.com. Type: UINT The x position of the right hand side of the box. Read more on docs.microsoft.com. Type: UINT The y position of the bottom of the box. Read more on docs.microsoft.com. Type: UINT The z position of the back of the box. Read more on docs.microsoft.com. 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. Type: UINT The index of the first element to be accessed by the view. Read more on docs.microsoft.com. Type: UINT The number of elements in the resource. Read more on docs.microsoft.com. Type: UINT 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. Read more on docs.microsoft.com. Describes a buffer resource. (D3D11_BUFFER_DESC) 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. Read more on docs.microsoft.com. Type: UINT Size of the buffer in bytes. Read more on docs.microsoft.com. Type: D3D11_USAGE 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. Read more on docs.microsoft.com. Type: UINT 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. Read more on docs.microsoft.com. 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. Specifies the elements in a buffer resource to use in a shader-resource view. (D3D11_BUFFER_SRV) 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. Describes the elements in a buffer to use in a unordered-access view. (D3D11_BUFFER_UAV) This structure is used by a D3D11_UNORDERED_ACCESS_VIEW_DESC. Type: UINT The zero-based index of the first element to be accessed. Read more on docs.microsoft.com. Type: UINT The number of elements in the resource. For structured buffers, this is the number of structures in the buffer. Read more on docs.microsoft.com. Type: UINT View options for the resource (see D3D11_BUFFER_UAV_FLAG). Read more on docs.microsoft.com. 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 acquired using ID3D11ClassLinkage::CreateClassInstance. The InstanceIndex member is only valid when the class instance is aquired using ID3D11ClassLinkage::GetClassInstance. Read more on docs.microsoft.com. Type: UINT The instance ID of an HLSL class; the default value is 0. Read more on docs.microsoft.com. Type: UINT The instance index of an HLSL class; the default value is 0. Read more on docs.microsoft.com. Type: UINT The type ID of an HLSL class; the default value is 0. Read more on docs.microsoft.com. Type: UINT Describes the constant buffer associated with an HLSL class; the default value is 0. Read more on docs.microsoft.com. Type: UINT The base constant buffer offset associated with an HLSL class; the default value is 0. Read more on docs.microsoft.com. Type: UINT The base texture associated with an HLSL class; the default value is 127. Read more on docs.microsoft.com. Type: UINT The base sampler associated with an HLSL class; the default value is 15. Read more on docs.microsoft.com. Type: BOOL True if the class was created; the default value is false. Read more on docs.microsoft.com. Comparison options. (D3D11_COMPARISON_FUNC) 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). Never pass the comparison. If the source data is less than the destination data, the comparison passes. If the source data is equal to the destination data, the comparison passes. If the source data is less than or equal to the destination data, the comparison passes. If the source data is greater than the destination data, the comparison passes. If the source data is not equal to the destination data, the comparison passes. If the source data is greater than or equal to the destination data, the comparison passes. Always pass the comparison. 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. Read more on docs.microsoft.com. Define a performance counter that is dependent on the hardware device. Describes a counter. (D3D11_COUNTER_DESC) This structure is used by ID3D11Counter::GetDesc, ID3D11Device::CheckCounter and ID3D11Device::CreateCounter. Type: D3D11_COUNTER Type of counter (see D3D11_COUNTER). Read more on docs.microsoft.com. Type: UINT Reserved. Read more on docs.microsoft.com. Information about the video card's performance counter capabilities. (D3D11_COUNTER_INFO) This structure is returned by ID3D11Device::CheckCounterInfo. Type: D3D11_COUNTER 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. Read more on docs.microsoft.com. Type: UINT Number of counters that can be simultaneously supported. Read more on docs.microsoft.com. Type: UINT8 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. Read more on docs.microsoft.com. Data type of a performance counter. (D3D11_COUNTER_TYPE) These flags are an output parameter in ID3D11Device::CheckCounter. 32-bit floating point. 16-bit unsigned integer. 32-bit unsigned integer. 64-bit unsigned integer. Specifies the types of CPU access allowed for a resource. (D3D11_CPU_ACCESS_FLAG) 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 bitwise 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. Read more on docs.microsoft.com. 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). 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). 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. Read more on docs.microsoft.com. 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. Read more on docs.microsoft.com. 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. Read more on docs.microsoft.com.
Note  This flag is not supported in Direct3D 11.
 
 Read more on docs.microsoft.com. 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. Read more on docs.microsoft.com. 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.
 
 Read more on docs.microsoft.com. 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. Read more on docs.microsoft.com. 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. Read more on docs.microsoft.com. 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. Read more on docs.microsoft.com. 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. Read more on docs.microsoft.com. Indicates triangles facing a particular direction are not drawn. (D3D11_CULL_MODE) This enumeration is part of a rasterizer-state object description (see D3D11_RASTERIZER_DESC). Always draw all triangles. Do not draw triangles that are front-facing. Do not draw triangles that are back-facing. 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. Read more on docs.microsoft.com. Type: D3D11_STENCIL_OP The stencil operation to perform when stencil testing fails. Read more on docs.microsoft.com. Type: D3D11_STENCIL_OP The stencil operation to perform when stencil testing passes and depth testing fails. Read more on docs.microsoft.com. Type: D3D11_STENCIL_OP The stencil operation to perform when stencil testing and depth testing both pass. Read more on docs.microsoft.com. Type: D3D11_COMPARISON_FUNC A function that compares stencil data against existing stencil data. The function options are listed in D3D11_COMPARISON_FUNC. Read more on docs.microsoft.com. Describes depth-stencil state. (D3D11_DEPTH_STENCIL_DESC) Pass a pointer 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. This doc was truncated. Read more on docs.microsoft.com. Type: BOOL Enable depth testing. Read more on docs.microsoft.com. Type: D3D11_DEPTH_WRITE_MASK Identify a portion of the depth-stencil buffer that can be modified by depth data (see D3D11_DEPTH_WRITE_MASK). Read more on docs.microsoft.com. Type: D3D11_COMPARISON_FUNC A function that compares depth data against existing depth data. The function options are listed in D3D11_COMPARISON_FUNC. Read more on docs.microsoft.com. Type: BOOL Enable stencil testing. Read more on docs.microsoft.com. Type: UINT8 Identify a portion of the depth-stencil buffer for reading stencil data. Read more on docs.microsoft.com. Type: UINT8 Identify a portion of the depth-stencil buffer for writing stencil data. Read more on docs.microsoft.com. Type: D3D11_DEPTH_STENCILOP_DESC 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). Read more on docs.microsoft.com. Type: D3D11_DEPTH_STENCILOP_DESC 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). Read more on docs.microsoft.com. Specifies the subresources of a texture that are accessible from a depth-stencil view. These are valid formats for a depth-stencil view: This doc was truncated. Read more on docs.microsoft.com. Type: DXGI_FORMAT Resource data format (see DXGI_FORMAT). See remarks for allowable formats. Read more on docs.microsoft.com. Type: D3D11_DSV_DIMENSION 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. Read more on docs.microsoft.com. Type: UINT 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. Read more on docs.microsoft.com. Identify the portion of a depth-stencil buffer for writing depth data. (D3D11_DEPTH_WRITE_MASK) Learn more about this API from docs.microsoft.com. Turn off writes to the depth-stencil buffer. Turn on writes to the depth-stencil buffer. Device context options. This enumeration is used by ID3D11DeviceContext::GetType. The device context is an immediate context. The device context is a deferred context. Specifies how to access a resource used in a depth-stencil view. (D3D11_DSV_DIMENSION) This enumeration is used in D3D11_DEPTH_STENCIL_VIEW_DESC to create a depth-stencil view. D3D11_DSV_DIMENSION_UNKNOWN is not a valid value for D3D11_DEPTH_STENCIL_VIEW_DESC and is not used. The resource will be accessed as a 1D texture. The resource will be accessed as an array of 1D textures. The resource will be accessed as a 2D texture. The resource will be accessed as an array of 2D textures. The resource will be accessed as a 2D texture with multisampling. The resource will be accessed as an array of 2D textures with multisampling. 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. 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. Supports the use of the double-precision shaders in HLSL. Refer to D3D11_FEATURE_DATA_DOUBLES. Supports the formats in D3D11_FORMAT_SUPPORT. Refer to D3D11_FEATURE_DATA_FORMAT_SUPPORT. Supports the formats in D3D11_FORMAT_SUPPORT2. Refer to D3D11_FEATURE_DATA_FORMAT_SUPPORT2. Supports compute shaders and raw and structured buffers. Refer to D3D11_FEATURE_DATA_D3D10_X_HARDWARE_OPTIONS. Supports Direct3D 11.1 feature options. Refer to D3D11_FEATURE_DATA_D3D11_OPTIONS. Direct3D 11:  This value is not supported until Direct3D 11.1. Read more on docs.microsoft.com. Supports specific adapter architecture. Refer to D3D11_FEATURE_DATA_ARCHITECTURE_INFO. Direct3D 11:  This value is not supported until Direct3D 11.1. Read more on docs.microsoft.com. Supports Direct3D 9 feature options. Refer to D3D11_FEATURE_DATA_D3D9_OPTIONS. Direct3D 11:  This value is not supported until Direct3D 11.1. Read more on docs.microsoft.com. 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. Read more on docs.microsoft.com. Supports Direct3D 9 shadowing feature. Refer to D3D11_FEATURE_DATA_D3D9_SHADOW_SUPPORT. Direct3D 11:  This value is not supported until Direct3D 11.1. Read more on docs.microsoft.com. Supports Direct3D 11.2 feature options. Refer to D3D11_FEATURE_DATA_D3D11_OPTIONS1. Direct3D 11:  This value is not supported until Direct3D 11.2. Read more on docs.microsoft.com. 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. Read more on docs.microsoft.com. Supports Direct3D 11.2 marker options. Refer to D3D11_FEATURE_DATA_MARKER_SUPPORT. Direct3D 11:  This value is not supported until Direct3D 11.2. Read more on docs.microsoft.com. 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. Read more on docs.microsoft.com. 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. Read more on docs.microsoft.com. 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. Read more on docs.microsoft.com. Supports GPU virtual addresses. Refer to D3D11_FEATURE_DATA_GPU_VIRTUAL_ADDRESS_SUPPORT. 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. Read more on docs.microsoft.com. Supports shader cache, described in D3D11_FEATURE_DATA_SHADER_CACHE. Supports a D3D11_SHARED_RESOURCE_TIER to indicate the level of support for shared resources in the current graphics driver. Refer to D3D11_FEATURE_DATA_D3D11_OPTIONS5. Supports displayable surfaces, described in [D3D11_FEATURE_DATA_DISPLAYABLE](/windows/win32/api/d3d11/ns-d3d11-d3d11_feature_data_displayable). Determines the fill mode to use when rendering triangles. (D3D11_FILL_MODE) This enumeration is part of a rasterizer-state object description (see D3D11_RASTERIZER_DESC). Draw lines connecting the vertices. Adjacent vertices are not drawn. Fill the triangles formed by the vertices. Adjacent vertices are not drawn. Filtering options during texture sampling. (D3D11_FILTER)
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. This doc was truncated. Read more on docs.microsoft.com. Use point sampling for minification, magnification, and mip-level sampling. Use point sampling for minification and magnification; use linear interpolation for mip-level sampling. Use point sampling for minification; use linear interpolation for magnification; use point sampling for mip-level sampling. Use point sampling for minification; use linear interpolation for magnification and mip-level sampling. Use linear interpolation for minification; use point sampling for magnification and mip-level sampling. Use linear interpolation for minification; use point sampling for magnification; use linear interpolation for mip-level sampling. Use linear interpolation for minification and magnification; use point sampling for mip-level sampling. Use linear interpolation for minification, magnification, and mip-level sampling. Use anisotropic interpolation for minification, magnification, and mip-level sampling. Use point sampling for minification, magnification, and mip-level sampling. Compare the result to the comparison value. Use point sampling for minification and magnification; use linear interpolation for mip-level sampling. Compare the result to the comparison value. Use point sampling for minification; use linear interpolation for magnification; use point sampling for mip-level sampling. Compare the result to the comparison value. Use point sampling for minification; use linear interpolation for magnification and mip-level sampling. Compare the result to the comparison value. Use linear interpolation for minification; use point sampling for magnification and mip-level sampling. Compare the result to the comparison value. Use linear interpolation for minification; use point sampling for magnification; use linear interpolation for mip-level sampling. Compare the result to the comparison value. Use linear interpolation for minification and magnification; use point sampling for mip-level sampling. Compare the result to the comparison value. Use linear interpolation for minification, magnification, and mip-level sampling. Compare the result to the comparison value. Use anisotropic interpolation for minification, magnification, and mip-level sampling. Compare the result to the comparison value. Fetch the same set of texels as 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. Type of data contained in an input slot. (D3D11_INPUT_CLASSIFICATION) Use these values to specify the type of data for a particular input element (see D3D11_INPUT_ELEMENT_DESC) of an input-layout object. Input data is per-vertex data. Input data is per-instance data. A description of a single element for the input-assembler stage. (D3D11_INPUT_ELEMENT_DESC) 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. Read more on docs.microsoft.com. Type: LPCSTR The HLSL semantic associated with this element in a shader input-signature. See HLSL Semantics for more info. Read more on docs.microsoft.com. Type: UINT 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 This doc was truncated. Read more on docs.microsoft.com. Type: DXGI_FORMAT The data type of the element data. See DXGI_FORMAT. Read more on docs.microsoft.com. Type: UINT An integer value that identifies the input-assembler (see input slot). Valid values are between 0 and 15, defined in D3D11.h. Read more on docs.microsoft.com. Type: UINT Optional. Offset (in bytes) from the start of the vertex. Use D3D11_APPEND_ALIGNED_ELEMENT for convenience to define the current element directly after the previous one, including any packing if necessary. Read more on docs.microsoft.com. Type: D3D11_INPUT_CLASSIFICATION Identifies the input data class for a single input slot (see D3D11_INPUT_CLASSIFICATION). Read more on docs.microsoft.com. Type: UINT 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). Read more on docs.microsoft.com. Identifies a resource to be accessed for reading and writing by the CPU. Applications may combine one or more of these flags. (D3D11_MAP) This enumeration is used in ID3D11DeviceContext::Map.

Meaning of D3D11_MAP_WRITE_NO_OVERWRITE

D3D11_MAP_WRITE_NO_OVERWRITE signifies that the application promises not to write to data that the input assembler (IA) stage is using. In exchange, the GPU allows the application to write to other parts of the same buffer. The application must ensure that it does not write over any data in use by the IA stage. For example, consider the buffer illustrated in the following diagram. If a Draw call has been issued that uses vertices 4-6, then an application that calls Map on this buffer must ensure that it does not write to the vertices that the Draw call will access during rendering. This doc was truncated. Read more on docs.microsoft.com. Resource is mapped for reading. The resource must have been created with read access (see D3D11_CPU_ACCESS_READ). Read more on docs.microsoft.com. Resource is mapped for writing. The resource must have been created with write access (see D3D11_CPU_ACCESS_WRITE). Read more on docs.microsoft.com. 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). Read more on docs.microsoft.com. 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). Read more on docs.microsoft.com. 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.
 
 Read more on docs.microsoft.com. 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: This doc was truncated. Read more on docs.microsoft.com. Type: void* Pointer to the data. When ID3D11DeviceContext::Map provides the pointer, the runtime ensures that the pointer has a specific alignment, depending on the following feature levels: This doc was truncated. Read more on docs.microsoft.com. Type: UINT The row pitch, or width, or physical size (in bytes) of the data. Read more on docs.microsoft.com. Type: UINT The depth pitch, or width, or physical size (in bytes)of the data. Read more on docs.microsoft.com. Query types. (D3D11_QUERY) Create a query with ID3D11Device::CreateQuery. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. Describes a query. (D3D11_QUERY_DESC) Learn more about this API from docs.microsoft.com. Type: D3D11_QUERY Type of query (see D3D11_QUERY). Read more on docs.microsoft.com. Type: UINT Miscellaneous flags (see D3D11_QUERY_MISC_FLAG). Read more on docs.microsoft.com. Describes rasterizer state. (D3D11_RASTERIZER_DESC) 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. This doc was truncated. Read more on docs.microsoft.com. Type: D3D11_FILL_MODE Determines the fill mode to use when rendering (see D3D11_FILL_MODE). Read more on docs.microsoft.com. Type: D3D11_CULL_MODE Indicates triangles facing the specified direction are not drawn (see D3D11_CULL_MODE). Read more on docs.microsoft.com. Type: BOOL 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. Read more on docs.microsoft.com. Type: INT Depth value added to a given pixel. For info about depth bias, see Depth Bias. Read more on docs.microsoft.com. Type: FLOAT Maximum depth bias of a pixel. For info about depth bias, see Depth Bias. Read more on docs.microsoft.com. Type: FLOAT Scalar on a given pixel's slope. For info about depth bias, see Depth Bias. Read more on docs.microsoft.com. Type: BOOL 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). This doc was truncated. Read more on docs.microsoft.com. Type: BOOL Enable scissor-rectangle culling. All pixels outside an active scissor rectangle are culled. Read more on docs.microsoft.com. Type: BOOL 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. Read more on docs.microsoft.com. Type: BOOL Specifies whether to enable line antialiasing; only applies if doing line drawing and MultisampleEnable is FALSE. For more info about this member, see Remarks. Read more on docs.microsoft.com. Describes the blend state for a render target. (D3D11_RENDER_TARGET_BLEND_DESC) 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. This doc was truncated. Read more on docs.microsoft.com. Type: BOOL Enable (or disable) blending. Read more on docs.microsoft.com. Type: D3D11_BLEND 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. Read more on docs.microsoft.com. Type: D3D11_BLEND 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. Read more on docs.microsoft.com. Type: D3D11_BLEND_OP This blend operation defines how to combine the SrcBlend and DestBlend operations. Read more on docs.microsoft.com. Type: D3D11_BLEND 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. Read more on docs.microsoft.com. Type: D3D11_BLEND 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. Read more on docs.microsoft.com. Type: D3D11_BLEND_OP This blend operation defines how to combine the SrcBlendAlpha and DestBlendAlpha operations. Read more on docs.microsoft.com. Type: UINT8 A write mask. Read more on docs.microsoft.com. The length of the inline array. Gets this inline array as a span. ⚠ Important ⚠: When this struct is on the stack, do not let the returned span outlive the stack frame that defines it. Gets this inline array as a span. ⚠ Important ⚠: When this struct is on the stack, do not let the returned span outlive the stack frame that defines it. 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: This doc was truncated. Read more on docs.microsoft.com. Type: DXGI_FORMAT The data format (see DXGI_FORMAT). Read more on docs.microsoft.com. Type: D3D11_RTV_DIMENSION The resource type (see D3D11_RTV_DIMENSION), which specifies how the render-target resource will be accessed. Read more on docs.microsoft.com. Identifies the type of resource being used. (D3D11_RESOURCE_DIMENSION) This enumeration is used in ID3D11Resource::GetType. Resource is of unknown type. Resource is a buffer. Resource is a 1D texture. Resource is a 2D texture. Resource is a 3D texture. 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. Read more on docs.microsoft.com. 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. 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.
 
 Read more on docs.microsoft.com. Sets a resource to be a cube texture created from a Texture2DArray that contains 6 textures. Enables instancing of GPU-generated content. Enables a resource as a byte address buffer. Enables a resource as a structured buffer. Enables a resource with MIP map clamping for use with ID3D11DeviceContext::SetResourceMinLOD. 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. This doc was truncated. Read more on docs.microsoft.com. 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: This doc was truncated. Read more on docs.microsoft.com. 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. The 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. Read more on docs.microsoft.com. 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. Read more on docs.microsoft.com. 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. Read more on docs.microsoft.com. 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. Read more on docs.microsoft.com. 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: This doc was truncated. Read more on docs.microsoft.com. Set this flag to indicate that the resource is a tile pool. Direct3D 11:  This value is not supported until Direct3D 11.2. Read more on docs.microsoft.com. Set this flag to indicate that the resource is a tiled resource. Direct3D 11:  This value is not supported until Direct3D 11.2. Read more on docs.microsoft.com. 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: This doc was truncated. Read more on docs.microsoft.com. Enables the resource to work with the [displayable surfaces](/windows/win32/direct3d11/displayable-surfaces) feature. You must use **D3D11_RESOURCE_MISC_SHARED_DISPLAYABLE** in combination with both **D3D11_RESOURCE_MISC_SHARED** and **D3D11_RESOURCE_MISC_SHARED_NTHANDLE**. TBD 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. Do not use this value, as it will cause ID3D11Device::CreateRenderTargetView to fail. The resource will be accessed as a buffer. The resource will be accessed as a 1D texture. The resource will be accessed as an array of 1D textures. The resource will be accessed as a 2D texture. The resource will be accessed as an array of 2D textures. The resource will be accessed as a 2D texture with multisampling. The resource will be accessed as an array of 2D textures with multisampling. The resource will be accessed as a 3D texture. Describes a sampler state. (D3D11_SAMPLER_DESC) These are the default values for sampler state. This doc was truncated. Read more on docs.microsoft.com. Type: D3D11_FILTER Filtering method to use when sampling a texture (see D3D11_FILTER). Read more on docs.microsoft.com. Type: D3D11_TEXTURE_ADDRESS_MODE Method to use for resolving a u texture coordinate that is outside the 0 to 1 range (see D3D11_TEXTURE_ADDRESS_MODE). Read more on docs.microsoft.com. Type: D3D11_TEXTURE_ADDRESS_MODE Method to use for resolving a v texture coordinate that is outside the 0 to 1 range. Read more on docs.microsoft.com. Type: D3D11_TEXTURE_ADDRESS_MODE Method to use for resolving a w texture coordinate that is outside the 0 to 1 range. Read more on docs.microsoft.com. Type: FLOAT 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. Read more on docs.microsoft.com. Type: UINT Clamping value used if D3D11_FILTER_ANISOTROPIC or D3D11_FILTER_COMPARISON_ANISOTROPIC is specified in Filter. Valid values are between 1 and 16. Read more on docs.microsoft.com. Type: D3D11_COMPARISON_FUNC A function that compares sampled data against existing sampled data. The function options are listed in D3D11_COMPARISON_FUNC. Read more on docs.microsoft.com. Type: FLOAT[4] 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. Read more on docs.microsoft.com. Type: FLOAT 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. Read more on docs.microsoft.com. Type: FLOAT 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. Read more on docs.microsoft.com. Describes a shader-resource view. (D3D11_SHADER_RESOURCE_VIEW_DESC) 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. Read more on docs.microsoft.com. Type: DXGI_FORMAT A DXGI_FORMAT specifying the viewing format. See remarks. Read more on docs.microsoft.com. Type: D3D11_SRV_DIMENSION The resource type of the view. See D3D11_SRV_DIMENSION. You must set *ViewDimension* to the same resource type as that of the underlying resource. This parameter also determines which _SRV to use in the union below. Read more on docs.microsoft.com. Description of a vertex element in a vertex buffer in an output slot. (D3D11_SO_DECLARATION_ENTRY) Learn more about this API from docs.microsoft.com. Type: UINT Zero-based, stream number. Read more on docs.microsoft.com. Type: LPCSTR 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. Read more on docs.microsoft.com. Type: UINT Output element's zero-based index. Should be used if, for example, you have more than one texture coordinate stored in each vertex. Read more on docs.microsoft.com. Type: BYTE 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. Read more on docs.microsoft.com. Type: BYTE 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. Read more on docs.microsoft.com. Type: BYTE The associated stream output buffer that is bound to the pipeline (see ID3D11DeviceContext::SOSetTargets). The valid range for OutputSlot is 0 to 3. Read more on docs.microsoft.com. The stencil operations that can be performed during depth-stencil testing. (D3D11_STENCIL_OP) Learn more about this API from docs.microsoft.com. Keep the existing stencil data. Set the stencil data to 0. Set the stencil data to the reference value set by calling ID3D11DeviceContext::OMSetDepthStencilState. Increment the stencil value by 1, and clamp the result. Decrement the stencil value by 1, and clamp the result. Invert the stencil data. Increment the stencil value by 1, and wrap the result if necessary. Decrement the stencil value by 1, and wrap the result if necessary. Specifies data for initializing a subresource. (D3D11_SUBRESOURCE_DATA) 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. 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.
 
 Read more on docs.microsoft.com. Type: const void* Pointer to the initialization data. Read more on docs.microsoft.com. Type: UINT 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. Read more on docs.microsoft.com. Type: UINT 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. Read more on docs.microsoft.com. 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). Type: UINT The index of the first mipmap level to use. Read more on docs.microsoft.com. Type: UINT The index of the first texture to use in an array of textures. Read more on docs.microsoft.com. Type: UINT Number of textures to use. Read more on docs.microsoft.com. 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). Type: UINT The index of the mipmap level to use mip slice. Read more on docs.microsoft.com. Type: UINT The index of the first texture to use in an array of textures. Read more on docs.microsoft.com. Type: UINT Number of textures to use. Read more on docs.microsoft.com. 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). Type: UINT 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. Read more on docs.microsoft.com. Type: UINT 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. Read more on docs.microsoft.com. Type: UINT The index of the first texture to use in an array of textures. Read more on docs.microsoft.com. Type: UINT Number of textures in the array. Read more on docs.microsoft.com. Describes an array of unordered-access 1D texture resources. (D3D11_TEX1D_ARRAY_UAV) This structure is used by a D3D11_UNORDERED_ACCESS_VIEW_DESC. Type: UINT The mipmap slice index. Read more on docs.microsoft.com. Type: UINT The zero-based index of the first array slice to be accessed. Read more on docs.microsoft.com. Type: UINT The number of slices in the array. Read more on docs.microsoft.com. Specifies the subresource from a 1D texture that is accessible to a depth-stencil view. (D3D11_TEX1D_DSV) This structure is one member of a depth-stencil-view description (see D3D11_DEPTH_STENCIL_VIEW_DESC). Type: UINT The index of the first mipmap level to use. Read more on docs.microsoft.com. Specifies the subresource from a 1D texture to use in a render-target view. (D3D11_TEX1D_RTV) This structure is one member of a render-target-view description (see D3D11_RENDER_TARGET_VIEW_DESC). Type: UINT The index of the mipmap level to use mip slice. Read more on docs.microsoft.com. Specifies the subresource from a 1D texture to use in a shader-resource view. (D3D11_TEX1D_SRV) 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. Read more on docs.microsoft.com. Type: UINT 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. Read more on docs.microsoft.com. Type: UINT 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. Read more on docs.microsoft.com. Describes a unordered-access 1D texture resource. (D3D11_TEX1D_UAV) This structure is used by a D3D11_UNORDERED_ACCESS_VIEW_DESC. Type: UINT The mipmap slice index. Read more on docs.microsoft.com. 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). Type: UINT The index of the first texture to use in an array of textures. Read more on docs.microsoft.com. Type: UINT Number of textures to use. Read more on docs.microsoft.com. 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). Type: UINT The index of the first texture to use in an array of textures. Read more on docs.microsoft.com. Type: UINT Number of textures to use. Read more on docs.microsoft.com. 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). Type: UINT The index of the first texture to use in an array of textures. Read more on docs.microsoft.com. Type: UINT Number of textures to use. Read more on docs.microsoft.com. Specifies the subresource from a multisampled 2D texture that is accessible to a depth-stencil view. (D3D11_TEX2DMS_DSV) 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. Type: UINT Unused. Read more on docs.microsoft.com. Specifies the subresource from a multisampled 2D texture to use in a render-target view. (D3D11_TEX2DMS_RTV) 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. Type: UINT Integer of any value. See remarks. Read more on docs.microsoft.com. 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. Type: UINT Integer of any value. See remarks. Read more on docs.microsoft.com. 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). Type: UINT The index of the first mipmap level to use. Read more on docs.microsoft.com. Type: UINT The index of the first texture to use in an array of textures. Read more on docs.microsoft.com. Type: UINT Number of textures to use. Read more on docs.microsoft.com. 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). Type: UINT The index of the mipmap level to use mip slice. Read more on docs.microsoft.com. Type: UINT The index of the first texture to use in an array of textures. Read more on docs.microsoft.com. Type: UINT Number of textures in the array to use in the render target view, starting from FirstArraySlice. Read more on docs.microsoft.com. 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). Type: UINT 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. Read more on docs.microsoft.com. Type: UINT 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. Read more on docs.microsoft.com. Type: UINT The index of the first texture to use in an array of textures. Read more on docs.microsoft.com. Type: UINT Number of textures in the array. Read more on docs.microsoft.com. Describes an array of unordered-access 2D texture resources. (D3D11_TEX2D_ARRAY_UAV) This structure is used by a D3D11_UNORDERED_ACCESS_VIEW_DESC. Type: UINT The mipmap slice index. Read more on docs.microsoft.com. Type: UINT The zero-based index of the first array slice to be accessed. Read more on docs.microsoft.com. Type: UINT The number of slices in the array. Read more on docs.microsoft.com. Specifies the subresource from a 2D texture that is accessible to a depth-stencil view. (D3D11_TEX2D_DSV) This structure is one member of a depth-stencil-view description (see D3D11_DEPTH_STENCIL_VIEW_DESC). Type: UINT The index of the first mipmap level to use. Read more on docs.microsoft.com. Specifies the subresource from a 2D texture to use in a render-target view. (D3D11_TEX2D_RTV) This structure is one member of a render-target-view description (see D3D11_RENDER_TARGET_VIEW_DESC). Type: UINT The index of the mipmap level to use mip slice. Read more on docs.microsoft.com. Specifies the subresource from a 2D texture to use in a shader-resource view. (D3D11_TEX2D_SRV) This structure is one member of a shader-resource-view description (see D3D11_SHADER_RESOURCE_VIEW_DESC). Type: UINT 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. Read more on docs.microsoft.com. Type: UINT 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. Read more on docs.microsoft.com. Describes a unordered-access 2D texture resource. (D3D11_TEX2D_UAV) This structure is used by a D3D11_UNORDERED_ACCESS_VIEW_DESC. Type: UINT The mipmap slice index. Read more on docs.microsoft.com. 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. Type: UINT The index of the mipmap level to use mip slice. Read more on docs.microsoft.com. Type: UINT First depth level to use. Read more on docs.microsoft.com. Type: UINT 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. Read more on docs.microsoft.com. 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). Type: UINT 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. Read more on docs.microsoft.com. Type: UINT 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. Read more on docs.microsoft.com. Describes a unordered-access 3D texture resource. (D3D11_TEX3D_UAV) This structure is used by a D3D11_UNORDERED_ACCESS_VIEW_DESC. Type: UINT The mipmap slice index. Read more on docs.microsoft.com. Type: UINT The zero-based index of the first depth slice to be accessed. Read more on docs.microsoft.com. Type: UINT The number of depth slices. Read more on docs.microsoft.com. 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). Type: UINT 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. Read more on docs.microsoft.com. Type: UINT 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. Read more on docs.microsoft.com. Type: UINT Index of the first 2D texture to use. Read more on docs.microsoft.com. Type: UINT Number of cube textures in the array. Read more on docs.microsoft.com. Specifies the subresource from a cube texture to use in a shader-resource view. (D3D11_TEXCUBE_SRV) This structure is one member of a shader-resource-view description (see D3D11_SHADER_RESOURCE_VIEW_DESC). Type: UINT 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. Read more on docs.microsoft.com. Type: UINT 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. Read more on docs.microsoft.com. Describes a 1D texture. (D3D11_TEXTURE1D_DESC) 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. Read more on docs.microsoft.com. Type: UINT 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. Read more on docs.microsoft.com. Type: UINT 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. Read more on docs.microsoft.com. Type: UINT 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. Read more on docs.microsoft.com. Type: DXGI_FORMAT Texture format (see DXGI_FORMAT). Read more on docs.microsoft.com. Type: D3D11_USAGE 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. Read more on docs.microsoft.com. Describes a 2D texture. (D3D11_TEXTURE2D_DESC) 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. Read more on docs.microsoft.com. Type: UINT 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. Read more on docs.microsoft.com. Type: UINT 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. Read more on docs.microsoft.com. Type: UINT 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. Read more on docs.microsoft.com. Type: UINT 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. Read more on docs.microsoft.com. Type: DXGI_FORMAT Texture format (see DXGI_FORMAT). Read more on docs.microsoft.com. Type: DXGI_SAMPLE_DESC Structure that specifies multisampling parameters for the texture. See DXGI_SAMPLE_DESC. Read more on docs.microsoft.com. Type: D3D11_USAGE 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. Read more on docs.microsoft.com. Describes a 3D texture. (D3D11_TEXTURE3D_DESC) 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. Read more on docs.microsoft.com. Type: UINT 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. Read more on docs.microsoft.com. Type: UINT 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. Read more on docs.microsoft.com. Type: UINT 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. Read more on docs.microsoft.com. Type: UINT 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. Read more on docs.microsoft.com. Type: DXGI_FORMAT Texture format (see DXGI_FORMAT). Read more on docs.microsoft.com. Type: D3D11_USAGE 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. Read more on docs.microsoft.com. Identify a technique for resolving texture coordinates that are outside of the boundaries of a texture. (D3D11_TEXTURE_ADDRESS_MODE) Learn more about this API from docs.microsoft.com. Tile the texture at every (u,v) integer junction. For example, for u values between 0 and 3, the texture is repeated three times. Flip the texture at every (u,v) integer junction. For u values between 0 and 1, for example, the texture is addressed normally; between 1 and 2, the texture is flipped (mirrored); between 2 and 3, the texture is normal again; and so on. Texture coordinates outside the range [0.0, 1.0] are set to the texture color at 0.0 or 1.0, respectively. Texture coordinates outside the range [0.0, 1.0] are set to the border color specified in D3D11_SAMPLER_DESC or HLSL code. 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. Unordered-access view options. This enumeration is used by a unordered access-view description (see D3D11_UNORDERED_ACCESS_VIEW_DESC). The view type is unknown. View the resource as a buffer. View the resource as a 1D texture. View the resource as a 1D texture array. View the resource as a 2D texture. View the resource as a 2D texture array. View the resource as a 3D texture array. 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. Type: DXGI_FORMAT The data format (see DXGI_FORMAT). Read more on docs.microsoft.com. Type: D3D11_UAV_DIMENSION The resource type (see D3D11_UAV_DIMENSION), which specifies how the resource will be accessed. Read more on docs.microsoft.com. 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. This doc was truncated. Read more on docs.microsoft.com. A resource that requires read and write access by the GPU. This is likely to be the most common usage choice. 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. 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. Read more on docs.microsoft.com. A resource that supports data transfer (copy) from the GPU to the CPU. Defines the dimensions of a viewport. (D3D11_VIEWPORT) In all cases, Width and Height must be >= 0 and TopLeftX + Width and TopLeftY + Height must be <= D3D11_VIEWPORT_BOUNDS_MAX. This doc was truncated. Read more on docs.microsoft.com. Type: FLOAT X position of the left hand side of the viewport. Ranges between D3D11_VIEWPORT_BOUNDS_MIN and D3D11_VIEWPORT_BOUNDS_MAX. Read more on docs.microsoft.com. Type: FLOAT Y position of the top of the viewport. Ranges between D3D11_VIEWPORT_BOUNDS_MIN and D3D11_VIEWPORT_BOUNDS_MAX. Read more on docs.microsoft.com. Type: FLOAT Width of the viewport. Read more on docs.microsoft.com. Type: FLOAT Height of the viewport. Read more on docs.microsoft.com. Type: FLOAT Minimum depth of the viewport. Ranges between 0 and 1. Read more on docs.microsoft.com. Type: FLOAT Maximum depth of the viewport. Ranges between 0 and 1. Read more on docs.microsoft.com. Get the size of the data (in bytes) that is output when calling ID3D11DeviceContext::GetData. Type: UINT Size of the data (in bytes) that is output when calling GetData. Learn more about this API from docs.microsoft.com. The IID guid for this interface. {4b35d0cd-1e15-4258-9c98-1b1333f6dd3b} Gets the description for blending state that you used to create the blend-state object. (ID3D11BlendState.GetDesc) Type: D3D11_BLEND_DESC* A pointer to a D3D11_BLEND_DESC structure that receives a description of the blend state. Read more on docs.microsoft.com. You use the description for blending state in a call to the ID3D11Device::CreateBlendState method to create the blend-state object. The IID guid for this interface. {75b68faa-347d-4159-8f45-a0640f01cd9a} Get the properties of a buffer resource. (ID3D11Buffer.GetDesc) Type: D3D11_BUFFER_DESC* Pointer to a resource description (see D3D11_BUFFER_DESC) filled in by the method. Read more on docs.microsoft.com. Learn more about this API from docs.microsoft.com. The IID guid for this interface. {48570b85-d1ee-4fcd-a250-eb350722b037} Gets the ID3D11ClassLinkage object associated with the current HLSL class. Type: ID3D11ClassLinkage** A pointer to a ID3D11ClassLinkage interface pointer. Read more on docs.microsoft.com. For more information about using the ID3D11ClassInstance interface, see Dynamic Linking. Windows Phone 8: This API is supported. Read more on docs.microsoft.com. Gets a description of the current HLSL class. Type: D3D11_CLASS_INSTANCE_DESC* A pointer to a D3D11_CLASS_INSTANCE_DESC structure that describes the current HLSL class. Read more on docs.microsoft.com. 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. This doc was truncated. Read more on docs.microsoft.com. Gets the instance name of the current HLSL class. Type: LPSTR The instance name of the current HLSL class. Read more on docs.microsoft.com. Type: SIZE_T* The length of the pInstanceName parameter. Read more on docs.microsoft.com. 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. Read more on docs.microsoft.com. Gets the type of the current HLSL class. Type: LPSTR Type of the current HLSL class. Read more on docs.microsoft.com. Type: SIZE_T* The length of the pTypeName parameter. Read more on docs.microsoft.com. 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. Read more on docs.microsoft.com. The IID guid for this interface. {a6cd7faa-b0b7-4a2f-9436-8662a65797cb} Gets the class-instance object that represents the specified HLSL class. Type: LPCSTR The name of a class for which to get the class instance. Read more on docs.microsoft.com. Type: UINT The index of the class instance. Read more on docs.microsoft.com. Type: ID3D11ClassInstance** The address of a pointer to an ID3D11ClassInstance interface to initialize. Read more on docs.microsoft.com. Type: HRESULT Returns S_OK if successful; otherwise, returns one of the Direct3D 11 Return Codes. 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. Read more on docs.microsoft.com. Initializes a class-instance object that represents an HLSL class instance. Type: LPCSTR The type name of a class to initialize. Read more on docs.microsoft.com. Type: UINT Identifies the constant buffer that contains the class data. Read more on docs.microsoft.com. Type: UINT 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. Read more on docs.microsoft.com. Type: UINT The texture slot for the first texture; there may be multiple textures following the offset. Read more on docs.microsoft.com. Type: UINT The sampler slot for the first sampler; there may be multiple samplers following the offset. Read more on docs.microsoft.com. Type: ID3D11ClassInstance** The address of a pointer to an ID3D11ClassInstance interface to initialize. Read more on docs.microsoft.com. Type: HRESULT Returns S_OK if successful; otherwise, returns one of the following Direct3D 11 Return Codes. 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. Read more on docs.microsoft.com. The IID guid for this interface. {ddf57cba-9543-46e4-a12b-f207a0fe7fed} Gets the initialization flags associated with the deferred context that created the command list. Type: UINT The context flag is reserved for future use and is always 0. 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 IID guid for this interface. {a24bc4d1-769e-43f7-8013-98ff566c18e2} The IID guid for this interface. {4f5b196e-c2bd-495e-bd01-1fded38e4969} Get a counter description. (ID3D11Counter.GetDesc) Type: D3D11_COUNTER_DESC* Pointer to a counter description (see D3D11_COUNTER_DESC). Read more on docs.microsoft.com. Learn more about this API from docs.microsoft.com. The IID guid for this interface. {6e8c49fb-a371-4770-b440-29086022b741} Gets the description for depth-stencil state that you used to create the depth-stencil-state object. Type: D3D11_DEPTH_STENCIL_DESC* A pointer to a D3D11_DEPTH_STENCIL_DESC structure that receives a description of the depth-stencil state. Read more on docs.microsoft.com. You use the description for depth-stencil state in a call to the ID3D11Device::CreateDepthStencilState method to create the depth-stencil-state object. The IID guid for this interface. {03823efb-8d8f-4e1c-9aa2-f64bb2cbfdf1} Get the depth-stencil view. (ID3D11DepthStencilView.GetDesc) Type: D3D11_DEPTH_STENCIL_VIEW_DESC* Pointer to a depth-stencil-view description (see D3D11_DEPTH_STENCIL_VIEW_DESC). Read more on docs.microsoft.com. Learn more about this API from docs.microsoft.com. The IID guid for this interface. {9fdac92a-1876-48c3-afad-25b94f84a9b6} Creates a buffer (vertex buffer, index buffer, or shader-constant buffer). Type: const D3D11_BUFFER_DESC* A pointer to a D3D11_BUFFER_DESC structure that describes the buffer. Read more on docs.microsoft.com. Type: const D3D11_SUBRESOURCE_DATA* A pointer 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. Read more on docs.microsoft.com. Type: ID3D11Buffer** Address of a pointer 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). Read more on docs.microsoft.com. Type: HRESULT This method returns E_OUTOFMEMORY if there is insufficient memory to create the buffer. See Direct3D 11 Return Codes for other possible return values. 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 Direct3D 11.1 runtime (available in Windows 8 and later operating systems) emulates this feature for [feature level](/windows/win32/direct3d11/overviews-direct3d-11-devices-downlevel-intro) 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 runtimes older than Direct3D 11.1, a call to **CreateBuffer** to request a constant buffer that is larger than 4096 fails. Read more on docs.microsoft.com. Creates an array of 1D textures. Type: const D3D11_TEXTURE1D_DESC* A pointer to a D3D11_TEXTURE1D_DESC structure that describes a 1D texture resource. To create a typeless resource that can be interpreted at runtime into different, compatible formats, specify a typeless format in the texture description. To generate mipmap levels automatically, set the number of mipmap levels to 0. Read more on docs.microsoft.com. Type: const D3D11_SUBRESOURCE_DATA* A pointer to an array of D3D11_SUBRESOURCE_DATA structures that describe subresources for the 1D texture resource. Applications can't specify NULL for pInitialData when creating IMMUTABLE resources (see D3D11_USAGE). If the resource is multisampled, pInitialData must be NULL because multisampled resources cannot be initialized with data when they are created. If you don't pass anything to pInitialData, the initial content of the memory for the resource is undefined. In this case, you need to write the resource content some other way before the resource is read. You can determine the size of this array from values in the MipLevels and ArraySize members of the D3D11_TEXTURE1D_DESC structure to which pDesc points by using the following calculation: MipLevels * ArraySize For more information about this array size, see Remarks. Read more on docs.microsoft.com. Type: ID3D11Texture1D** A pointer to a buffer that receives a pointer to a ID3D11Texture1D interface for the created texture. Set this parameter to NULL to validate the other input parameters (the method will return S_FALSE if the other input parameters pass validation). Read more on docs.microsoft.com. Type: HRESULT If the method succeeds, the return code is S_OK. See Direct3D 11 Return Codes for failing error codes. 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: This doc was truncated. Read more on docs.microsoft.com. Create an array of 2D textures. Type: const D3D11_TEXTURE2D_DESC* A pointer to a D3D11_TEXTURE2D_DESC structure that describes a 2D texture resource. To create a typeless resource that can be interpreted at runtime into different, compatible formats, specify a typeless format in the texture description. To generate mipmap levels automatically, set the number of mipmap levels to 0. Read more on docs.microsoft.com. Type: const D3D11_SUBRESOURCE_DATA* A pointer to an array of D3D11_SUBRESOURCE_DATA structures that describe subresources for the 2D texture resource. Applications can't specify NULL for pInitialData when creating IMMUTABLE resources (see D3D11_USAGE). If the resource is multisampled, pInitialData must be NULL because multisampled resources cannot be initialized with data when they are created. If you don't pass anything to pInitialData, the initial content of the memory for the resource is undefined. In this case, you need to write the resource content some other way before the resource is read. You can determine the size of this array from values in the MipLevels and ArraySize members of the D3D11_TEXTURE2D_DESC structure to which pDesc points by using the following calculation: MipLevels * ArraySize For more information about this array size, see Remarks. Read more on docs.microsoft.com. Type: ID3D11Texture2D** A pointer to a buffer that receives a pointer to a ID3D11Texture2D interface for the created texture. Set this parameter to NULL to validate the other input parameters (the method will return S_FALSE if the other input parameters pass validation). Read more on docs.microsoft.com. Type: HRESULT If the method succeeds, the return code is S_OK. See Direct3D 11 Return Codes for failing error codes. 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: This doc was truncated. Read more on docs.microsoft.com. Create a single 3D texture. Type: const D3D11_TEXTURE3D_DESC* A pointer to a D3D11_TEXTURE3D_DESC structure that describes a 3D texture resource. To create a typeless resource that can be interpreted at runtime into different, compatible formats, specify a typeless format in the texture description. To generate mipmap levels automatically, set the number of mipmap levels to 0. Read more on docs.microsoft.com. Type: const D3D11_SUBRESOURCE_DATA* A pointer to an array of D3D11_SUBRESOURCE_DATA structures that describe subresources for the 3D texture resource. Applications cannot specify NULL for pInitialData when creating IMMUTABLE resources (see D3D11_USAGE). If the resource is multisampled, pInitialData must be NULL because multisampled resources cannot be initialized with data when they are created. If you don't pass anything to pInitialData, the initial content of the memory for the resource is undefined. In this case, you need to write the resource content some other way before the resource is read. You can determine the size of this array from the value in the MipLevels member of the D3D11_TEXTURE3D_DESC structure to which pDesc points. Arrays of 3D volume textures are not supported. For more information about this array size, see Remarks. Read more on docs.microsoft.com. Type: ID3D11Texture3D** A pointer to a buffer that receives a pointer to a ID3D11Texture3D interface for the created texture. Set this parameter to NULL to validate the other input parameters (the method will return S_FALSE if the other input parameters pass validation). Read more on docs.microsoft.com. Type: HRESULT If the method succeeds, the return code is S_OK. See Direct3D 11 Return Codes for failing error codes. 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: This doc was truncated. Read more on docs.microsoft.com. Create a shader-resource view for accessing data in a resource. (ID3D11Device.CreateShaderResourceView) Type: ID3D11Resource* 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. Read more on docs.microsoft.com. Type: const D3D11_SHADER_RESOURCE_VIEW_DESC* 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). Read more on docs.microsoft.com. Type: ID3D11ShaderResourceView** Address of a pointer 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). Read more on docs.microsoft.com. Type: HRESULT This method returns one of the following Direct3D 11 Return Codes. 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. Read more on docs.microsoft.com. Creates a view for accessing an unordered access resource. (ID3D11Device.CreateUnorderedAccessView) Type: ID3D11Resource* Pointer to an ID3D11Resource that represents a resources that will serve as an input to a shader. Read more on docs.microsoft.com. Type: const D3D11_UNORDERED_ACCESS_VIEW_DESC* Pointer to an D3D11_UNORDERED_ACCESS_VIEW_DESC that represents a shader-resource view description. Set this parameter to NULL to create a view that accesses the entire resource (using the format the resource was created with). Read more on docs.microsoft.com. Type: ID3D11UnorderedAccessView** Address of a pointer to an ID3D11UnorderedAccessView that represents an unordered-access 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). Read more on docs.microsoft.com. Type: HRESULT This method returns one of the Direct3D 11 Return Codes. 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. Read more on docs.microsoft.com. Creates a render-target view for accessing resource data. (ID3D11Device.CreateRenderTargetView) Type: ID3D11Resource* Pointer to a ID3D11Resource that represents a render target. This resource must have been created with the D3D11_BIND_RENDER_TARGET flag. Read more on docs.microsoft.com. Type: const D3D11_RENDER_TARGET_VIEW_DESC* 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. Read more on docs.microsoft.com. Type: ID3D11RenderTargetView** Address of a pointer 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). Read more on docs.microsoft.com. Type: HRESULT This method returns one of the Direct3D 11 Return Codes. 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. Read more on docs.microsoft.com. Create a depth-stencil view for accessing resource data. (ID3D11Device.CreateDepthStencilView) Type: ID3D11Resource* 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. Read more on docs.microsoft.com. Type: const D3D11_DEPTH_STENCIL_VIEW_DESC* 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). Read more on docs.microsoft.com. Type: ID3D11DepthStencilView** Address of a pointer 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). Read more on docs.microsoft.com. Type: HRESULT This method returns one of the following Direct3D 11 Return Codes. A depth-stencil view can be bound to the output-merger stage by calling ID3D11DeviceContext::OMSetRenderTargets. Create an input-layout object to describe the input-buffer data for the input-assembler stage. (ID3D11Device.CreateInputLayout) Type: const D3D11_INPUT_ELEMENT_DESC* An array of the input-assembler stage input data types; each type is described by an element description (see D3D11_INPUT_ELEMENT_DESC). Read more on docs.microsoft.com. Type: UINT The number of input-data types in the array of input-elements. Read more on docs.microsoft.com. Type: const void* A pointer to the compiled shader. The compiled shader code contains a input signature which is validated against the array of elements. See remarks. Read more on docs.microsoft.com. Type: SIZE_T Size of the compiled shader. Read more on docs.microsoft.com. Type: ID3D11InputLayout** A pointer to the input-layout object created (see ID3D11InputLayout). To validate the other input parameters, set this pointer to be NULL and verify that the method returns S_FALSE. Read more on docs.microsoft.com. Type: HRESULT If the method succeeds, the return code is S_OK. See Direct3D 11 Return Codes for failing error codes. 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. Read more on docs.microsoft.com. Create a vertex-shader object from a compiled shader. (ID3D11Device.CreateVertexShader) Type: const void* A pointer to the compiled shader. Read more on docs.microsoft.com. Type: SIZE_T Size of the compiled vertex shader. Read more on docs.microsoft.com. Type: ID3D11ClassLinkage* A pointer to a class linkage interface (see ID3D11ClassLinkage); the value can be NULL. Read more on docs.microsoft.com. Type: ID3D11VertexShader** Address of a pointer 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. Read more on docs.microsoft.com. Type: HRESULT This method returns one of the Direct3D 11 Return Codes. 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. This doc was truncated. Read more on docs.microsoft.com. Create a geometry shader. (ID3D11Device.CreateGeometryShader) Type: const void* A pointer to the compiled shader. Read more on docs.microsoft.com. Type: SIZE_T Size of the compiled geometry shader. Read more on docs.microsoft.com. Type: ID3D11ClassLinkage* A pointer to a class linkage interface (see ID3D11ClassLinkage); the value can be NULL. Read more on docs.microsoft.com. Type: ID3D11GeometryShader** Address of a pointer 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. Read more on docs.microsoft.com. Type: HRESULT This method returns one of the following Direct3D 11 Return Codes. 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. This doc was truncated. Read more on docs.microsoft.com. Creates a geometry shader that can write to streaming output buffers. (ID3D11Device.CreateGeometryShaderWithStreamOutput) Type: const void* A pointer to the compiled geometry shader for a standard geometry shader plus stream output. For info on how to get this pointer, see Getting a Pointer to a Compiled Shader. To create the stream output without using a geometry shader, pass a pointer to the output signature for the prior stage. To obtain this output signature, call the D3DGetOutputSignatureBlob compiler function. You can also pass a pointer 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. Read more on docs.microsoft.com. Type: SIZE_T Size of the compiled geometry shader. Read more on docs.microsoft.com. Type: const D3D11_SO_DECLARATION_ENTRY* Pointer to a D3D11_SO_DECLARATION_ENTRY array. Cannot be NULL if NumEntries > 0. Read more on docs.microsoft.com. Type: UINT The number of entries in the stream output declaration ( ranges from 0 to D3D11_SO_STREAM_COUNT * D3D11_SO_OUTPUT_COMPONENT_COUNT ). Read more on docs.microsoft.com. Type: const UINT* An array of buffer strides; each stride is the size of an element for that buffer. Read more on docs.microsoft.com. Type: UINT The number of strides (or buffers) in pBufferStrides (ranges from 0 to D3D11_SO_BUFFER_SLOT_COUNT). Read more on docs.microsoft.com. Type: UINT 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. Read more on docs.microsoft.com. Type: ID3D11ClassLinkage* A pointer to a class linkage interface (see ID3D11ClassLinkage); the value can be NULL. Read more on docs.microsoft.com. Type: ID3D11GeometryShader** Address of a pointer 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. Read more on docs.microsoft.com. Type: HRESULT This method returns one of the Direct3D 11 Return Codes. 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. This doc was truncated. Read more on docs.microsoft.com. Create a pixel shader. (ID3D11Device.CreatePixelShader) Type: const void* A pointer to the compiled shader. Read more on docs.microsoft.com. Type: SIZE_T Size of the compiled pixel shader. Read more on docs.microsoft.com. Type: ID3D11ClassLinkage* A pointer to a class linkage interface (see ID3D11ClassLinkage); the value can be NULL. Read more on docs.microsoft.com. Type: ID3D11PixelShader** Address of a pointer 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. Read more on docs.microsoft.com. Type: HRESULT This method returns one of the following Direct3D 11 Return Codes. After creating the pixel shader, you can set it to the device using ID3D11DeviceContext::PSSetShader. Create a hull shader. Type: const void* A pointer to a compiled shader. Read more on docs.microsoft.com. Type: SIZE_T Size of the compiled shader. Read more on docs.microsoft.com. Type: ID3D11ClassLinkage* A pointer to a class linkage interface (see ID3D11ClassLinkage); the value can be NULL. Read more on docs.microsoft.com. Type: ID3D11HullShader** Address of a pointer to a ID3D11HullShader interface. Read more on docs.microsoft.com. Type: HRESULT This method returns one of the Direct3D 11 Return Codes. 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. This doc was truncated. Read more on docs.microsoft.com. Create a domain shader. Type: const void* A pointer to a compiled shader. Read more on docs.microsoft.com. Type: SIZE_T Size of the compiled shader. Read more on docs.microsoft.com. Type: ID3D11ClassLinkage* A pointer to a class linkage interface (see ID3D11ClassLinkage); the value can be NULL. Read more on docs.microsoft.com. Type: ID3D11DomainShader** Address of a pointer to a ID3D11DomainShader 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. Read more on docs.microsoft.com. Type: HRESULT This method returns one of the following Direct3D 11 Return Codes. 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. This doc was truncated. Read more on docs.microsoft.com. Create a compute shader. Type: const void* A pointer to a compiled shader. Read more on docs.microsoft.com. Type: SIZE_T Size of the compiled shader in pShaderBytecode. Read more on docs.microsoft.com. Type: ID3D11ClassLinkage* A pointer to a ID3D11ClassLinkage, which represents class linkage interface; the value can be NULL. Read more on docs.microsoft.com. Type: ID3D11ComputeShader** Address of a pointer to an ID3D11ComputeShader interface. If this is NULL, all other parameters will be validated; if validation passes, CreateComputeShader returns S_FALSE instead of S_OK. Read more on docs.microsoft.com. Type: HRESULT 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. For an example, see How To: Create a Compute Shader and HDRToneMappingCS11 Sample. Creates class linkage libraries to enable dynamic shader linkage. Type: ID3D11ClassLinkage** A pointer to a class-linkage interface pointer (see ID3D11ClassLinkage). Read more on docs.microsoft.com. Type: HRESULT This method returns one of the following Direct3D 11 Return Codes. 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. Create a blend-state object that encapsulates blend state for the output-merger stage. (ID3D11Device.CreateBlendState) Type: const D3D11_BLEND_DESC* Pointer to a blend-state description (see D3D11_BLEND_DESC). Read more on docs.microsoft.com. Type: ID3D11BlendState** Address of a pointer to the blend-state object created (see ID3D11BlendState). Read more on docs.microsoft.com. Type: HRESULT 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. 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 pointer to previous instance instead of creating a duplicate object. Windows Phone 8: This API is supported. Read more on docs.microsoft.com. Create a depth-stencil state object that encapsulates depth-stencil test information for the output-merger stage. (ID3D11Device.CreateDepthStencilState) Type: const D3D11_DEPTH_STENCIL_DESC* Pointer to a depth-stencil state description (see D3D11_DEPTH_STENCIL_DESC). Read more on docs.microsoft.com. Type: ID3D11DepthStencilState** Address of a pointer to the depth-stencil state object created (see ID3D11DepthStencilState). Read more on docs.microsoft.com. Type: HRESULT This method returns one of the following Direct3D 11 Return Codes. 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. Read more on docs.microsoft.com. Create a rasterizer state object that tells the rasterizer stage how to behave. (ID3D11Device.CreateRasterizerState) Type: const D3D11_RASTERIZER_DESC* Pointer to a rasterizer state description (see D3D11_RASTERIZER_DESC). Read more on docs.microsoft.com. Type: ID3D11RasterizerState** Address of a pointer to the rasterizer state object created (see ID3D11RasterizerState). Read more on docs.microsoft.com. Type: HRESULT 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. 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. Read more on docs.microsoft.com. Create a sampler-state object that encapsulates sampling information for a texture. (ID3D11Device.CreateSamplerState) Type: const D3D11_SAMPLER_DESC* Pointer to a sampler state description (see D3D11_SAMPLER_DESC). Read more on docs.microsoft.com. Type: ID3D11SamplerState** Address of a pointer to the sampler state object created (see ID3D11SamplerState). Read more on docs.microsoft.com. Type: HRESULT This method returns one of the following Direct3D 11 Return Codes. 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. Read more on docs.microsoft.com. This interface encapsulates methods for querying information from the GPU. (ID3D11Device.CreateQuery) Type: const D3D11_QUERY_DESC* Pointer to a query description (see D3D11_QUERY_DESC). Read more on docs.microsoft.com. Type: ID3D11Query** Address of a pointer to the query object created (see ID3D11Query). Read more on docs.microsoft.com. Type: HRESULT 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. Learn more about this API from docs.microsoft.com. Creates a predicate. (ID3D11Device.CreatePredicate) Type: const D3D11_QUERY_DESC* 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). Read more on docs.microsoft.com. Type: ID3D11Predicate** Address of a pointer to a predicate (see ID3D11Predicate). Read more on docs.microsoft.com. Type: HRESULT This method returns one of the following Direct3D 11 Return Codes. Learn more about this API from docs.microsoft.com. Create a counter object for measuring GPU performance. (ID3D11Device.CreateCounter) Type: const D3D11_COUNTER_DESC* Pointer to a counter description (see D3D11_COUNTER_DESC). Read more on docs.microsoft.com. Type: ID3D11Counter** Address of a pointer to a counter (see ID3D11Counter). Read more on docs.microsoft.com. Type: HRESULT 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. Learn more about this API from docs.microsoft.com. Creates a deferred context, which can record command lists. (ID3D11Device.CreateDeferredContext) Type: UINT Reserved for future use. Pass 0. Read more on docs.microsoft.com. Type: ID3D11DeviceContext** Upon completion of the method, the passed pointer to an ID3D11DeviceContext interface pointer is initialized. Read more on docs.microsoft.com. Type: HRESULT Returns S_OK if successful; otherwise, returns one of the following: This doc was truncated. 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. Read more on docs.microsoft.com. Give a device access to a shared resource created on a different device. Type: HANDLE A resource handle. See remarks. Read more on docs.microsoft.com. Type: REFIID The globally unique identifier (GUID) for the resource interface. See remarks. Read more on docs.microsoft.com. Type: void** Address of a pointer to the resource we are gaining access to. Read more on docs.microsoft.com. Type: HRESULT This method returns one of the following Direct3D 11 Return Codes. 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. This doc was truncated. Read more on docs.microsoft.com. Get the support of a given format on the installed video device. (ID3D11Device.CheckFormatSupport) Type: DXGI_FORMAT A DXGI_FORMAT enumeration that describes a format for which to check for support. Read more on docs.microsoft.com. Type: UINT* A bitfield of D3D11_FORMAT_SUPPORT enumeration values describing how the specified format is supported on the installed device. The values are ORed together. Read more on docs.microsoft.com. Type: HRESULT 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. Learn more about this API from docs.microsoft.com. Get the number of quality levels available during multisampling. (ID3D11Device.CheckMultisampleQualityLevels) Type: DXGI_FORMAT The texture format. See DXGI_FORMAT. Read more on docs.microsoft.com. Type: UINT The number of samples during multisampling. Read more on docs.microsoft.com. Type: UINT* Number of quality levels supported by the adapter. See **Remarks**. Read more on docs.microsoft.com. Type: HRESULT This method returns one of the following Direct3D 11 Return Codes. 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 (S_OK), and the output parameter `pNumQualityLevels` receives a positive value, then the format and sample count combination is supported for the device. When the combination is not supported, this method returns a failure **HRESULT** code (that is, a negative integer), or sets `pNumQualityLevels` output parameter to zero, or both. Furthermore, the definition of a quality level is left 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. Read more on docs.microsoft.com. Get a counter's information. (ID3D11Device.CheckCounterInfo) Type: D3D11_COUNTER_INFO* Pointer to counter information (see D3D11_COUNTER_INFO). Read more on docs.microsoft.com. Learn more about this API from docs.microsoft.com. Get the type, name, units of measure, and a description of an existing counter. (ID3D11Device.CheckCounter) Type: const D3D11_COUNTER_DESC* Pointer to a counter description (see D3D11_COUNTER_DESC). Specifies which counter information is to be retrieved about. Read more on docs.microsoft.com. Type: D3D11_COUNTER_TYPE* Pointer to the data type of a counter (see D3D11_COUNTER_TYPE). Specifies the data type of the counter being retrieved. Read more on docs.microsoft.com. Type: UINT* 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. Read more on docs.microsoft.com. Type: LPSTR 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. Read more on docs.microsoft.com. Type: UINT* Length of the string returned to szName. Can be NULL. Read more on docs.microsoft.com. Type: LPSTR Name of the units a counter measures, provided the memory the pointer points to has enough room to hold the string. Can be NULL. The returned string will always be in English. Read more on docs.microsoft.com. Type: UINT* Length of the string returned to szUnits. Can be NULL. Read more on docs.microsoft.com. Type: LPSTR A description of the counter, provided the memory the pointer points to has enough room to hold the string. Can be NULL. The returned string will always be in English. Read more on docs.microsoft.com. Type: UINT* Length of the string returned to szDescription. Can be NULL. Read more on docs.microsoft.com. Type: HRESULT This method returns one of the following Direct3D 11 Return Codes. 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. Read more on docs.microsoft.com. Gets information about the features that are supported by the current graphics driver. (ID3D11Device.CheckFeatureSupport) Type: D3D11_FEATURE A member of the D3D11_FEATURE enumerated type that describes which feature to query for support. Read more on docs.microsoft.com. Type: void* Upon completion of the method, the passed structure is filled with data that describes the feature support. Read more on docs.microsoft.com. Type: UINT The size of the structure passed to the pFeatureSupportData parameter. Read more on docs.microsoft.com. Type: HRESULT 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. 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. Read more on docs.microsoft.com. Get application-defined data from a device. Type: REFGUID Guid associated with the data. Read more on docs.microsoft.com. Type: UINT* A pointer to a variable that on input contains the size, in bytes, of the buffer that pData points to, and on output contains the size, in bytes, of the amount of data that GetPrivateData retrieved. Read more on docs.microsoft.com. Type: void* A pointer 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. Read more on docs.microsoft.com. Type: HRESULT This method returns one of the codes described in the topic Direct3D 11 Return Codes. If the data returned is a pointer to an IUnknown, or one of its derivative classes, which was previously set by SetPrivateDataInterface, that interface will have its reference count incremented before the private data is returned. Set data to a device and associate that data with a guid. (ID3D11Device.SetPrivateData) Type: REFGUID Guid associated with the data. Read more on docs.microsoft.com. Type: UINT Size of the data. Read more on docs.microsoft.com. Type: const void* 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. Read more on docs.microsoft.com. Type: HRESULT This method returns one of the following Direct3D 11 Return Codes. 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 pointers 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 pointer 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: This doc was truncated. Read more on docs.microsoft.com. Associate an IUnknown-derived interface with this device child and associate that interface with an application-defined guid. (ID3D11Device.SetPrivateDataInterface) Type: REFGUID Guid associated with the interface. Read more on docs.microsoft.com. Type: const IUnknown* Pointer to an IUnknown-derived interface to be associated with the device child. Read more on docs.microsoft.com. Type: HRESULT This method returns one of the following Direct3D 11 Return Codes. Learn more about this API from docs.microsoft.com. Gets the feature level of the hardware device. (ID3D11Device.GetFeatureLevel) Type: D3D_FEATURE_LEVEL A member of the D3D_FEATURE_LEVEL enumerated type that describes the feature level of the hardware device. Feature levels determine the capabilities of your device. Get the flags used during the call to create the device with D3D11CreateDevice. Type: UINT A bitfield containing the flags used to create the device. See D3D11_CREATE_DEVICE_FLAG. Learn more about this API from docs.microsoft.com. Get the reason why the device was removed. (ID3D11Device.GetDeviceRemovedReason) Type: HRESULT Possible return values include: This doc was truncated. Learn more about this API from docs.microsoft.com. Gets an immediate context, which can play back command lists. (ID3D11Device.GetImmediateContext) Type: ID3D11DeviceContext** Upon completion of the method, the passed pointer to an ID3D11DeviceContext interface pointer is initialized. Read more on docs.microsoft.com. 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 pointer when you are done with it to avoid a memory leak. Read more on docs.microsoft.com. Get the exception-mode flags. (ID3D11Device.SetExceptionMode) Type: UINT 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. Read more on docs.microsoft.com. Type: HRESULT This method returns one of the following Direct3D 11 Return Codes. 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. Read more on docs.microsoft.com. Get the exception-mode flags. (ID3D11Device.GetExceptionMode) Type: UINT 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. An exception-mode flag is used to elevate an error condition to a non-continuable exception. The IID guid for this interface. {db6f6ddb-ac77-4e88-8253-819df9bbf140} Get a pointer to the device that created this interface. (ID3D11DeviceChild.GetDevice) Type: ID3D11Device** Address of a pointer to a device (see ID3D11Device). Read more on docs.microsoft.com. Any returned interfaces will have their reference count incremented by one, so be sure to call ::release() on the returned pointer(s) before they are freed or else you will have a memory leak. Get application-defined data from a device child. (ID3D11DeviceChild.GetPrivateData) Type: REFGUID Guid associated with the data. Read more on docs.microsoft.com. Type: UINT* A pointer to a variable that on input contains the size, in bytes, of the buffer that pData points to, and on output contains the size, in bytes, of the amount of data that GetPrivateData retrieved. Read more on docs.microsoft.com. Type: void* A pointer 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. Read more on docs.microsoft.com. Type: HRESULT This method returns one of the Direct3D 11 Return Codes. The data stored in the device child is set by calling ID3D11DeviceChild::SetPrivateData. If the data returned is a pointer to an IUnknown, or one of its derivative classes, which was previously set by SetPrivateDataInterface, that interface will have its reference count incremented before the private data is returned. Windows Phone 8: This API is supported. Read more on docs.microsoft.com. Set application-defined data to a device child and associate that data with an application-defined guid. (ID3D11DeviceChild.SetPrivateData) Type: REFGUID Guid associated with the data. Read more on docs.microsoft.com. Type: UINT Size of the data. Read more on docs.microsoft.com. Type: const void* 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. Read more on docs.microsoft.com. Type: HRESULT This method returns one of the following Direct3D 11 Return Codes. 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 pointers 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 pointer 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: This doc was truncated. Read more on docs.microsoft.com. Associate an IUnknown-derived interface with this device child and associate that interface with an application-defined guid. (ID3D11DeviceChild.SetPrivateDataInterface) Type: REFGUID Guid associated with the interface. Read more on docs.microsoft.com. Type: const IUnknown* Pointer to an IUnknown-derived interface to be associated with the device child. Read more on docs.microsoft.com. Type: HRESULT This method returns one of the following Direct3D 11 Return Codes. When this method is called ::addref() will be called on the IUnknown-derived interface, and when the device child is destroyed ::release() will be called on the IUnknown-derived interface. The IID guid for this interface. {1841e5c8-16b0-489b-bcc8-44cfb0d5deae} Sets the constant buffers used by the vertex shader pipeline stage. Type: UINT 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). Read more on docs.microsoft.com. Type: UINT Number of buffers to set (ranges from 0 to D3D11_COMMONSHADER_CONSTANT_BUFFER_API_SLOT_COUNT - StartSlot). Read more on docs.microsoft.com. Type: ID3D11Buffer* Array of constant buffers (see ID3D11Buffer) being given to the device. Read more on docs.microsoft.com. 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. Read more on docs.microsoft.com. Bind an array of shader resources to the pixel shader stage. (ID3D11DeviceContext.PSSetShaderResources) Type: UINT 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). Read more on docs.microsoft.com. Type: UINT 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). Read more on docs.microsoft.com. Type: ID3D11ShaderResourceView* Array of shader resource view interfaces to set to the device. Read more on docs.microsoft.com. 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. Read more on docs.microsoft.com. Sets a pixel shader to the device. (ID3D11DeviceContext.PSSetShader) Type: ID3D11PixelShader* Pointer to a pixel shader (see ID3D11PixelShader). Passing in NULL disables the shader for this pipeline stage. Read more on docs.microsoft.com. Type: ID3D11ClassInstance* A pointer 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. Read more on docs.microsoft.com. Type: UINT The number of class-instance interfaces in the array. Read more on docs.microsoft.com. 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 pointer must have a corresponding class instance or the assigned shader will be disabled. Windows Phone 8: This API is supported. Read more on docs.microsoft.com. Set an array of sampler states to the pixel shader pipeline stage. (ID3D11DeviceContext.PSSetSamplers) Type: UINT Index into the device's zero-based array to begin setting samplers to (ranges from 0 to D3D11_COMMONSHADER_SAMPLER_SLOT_COUNT - 1). Read more on docs.microsoft.com. Type: UINT 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). Read more on docs.microsoft.com. Type: ID3D11SamplerState* Pointer to an array of sampler-state interfaces (see ID3D11SamplerState). See Remarks. Read more on docs.microsoft.com. Any sampler may be set to NULL; this invokes the default state, which is defined to be the following. This doc was truncated. Read more on docs.microsoft.com. Set a vertex shader to the device. (ID3D11DeviceContext.VSSetShader) Type: ID3D11VertexShader* Pointer to a vertex shader (see ID3D11VertexShader). Passing in NULL disables the shader for this pipeline stage. Read more on docs.microsoft.com. Type: ID3D11ClassInstance* A pointer 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. Read more on docs.microsoft.com. Type: UINT The number of class-instance interfaces in the array. Read more on docs.microsoft.com. 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. Read more on docs.microsoft.com. Draw indexed, non-instanced primitives. (ID3D11DeviceContext.DrawIndexed) Type: UINT Number of indices to draw. Read more on docs.microsoft.com. Type: UINT The location of the first index read by the GPU from the index buffer. Read more on docs.microsoft.com. Type: INT A value added to each index before reading a vertex from the vertex buffer. Read more on docs.microsoft.com. 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. Read more on docs.microsoft.com. Draw non-indexed, non-instanced primitives. (ID3D11DeviceContext.Draw) Type: UINT Number of vertices to draw. Read more on docs.microsoft.com. Type: UINT Index of the first vertex, which is usually an offset in a vertex buffer. Read more on docs.microsoft.com. 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. Read more on docs.microsoft.com. Invalidate the pointer to a resource and reenable the GPU's access to that resource. Type: ID3D11Resource* A pointer to a ID3D11Resource interface. Read more on docs.microsoft.com. Type: UINT A subresource to be unmapped. Read more on docs.microsoft.com. For info about how to use Unmap, see How to: Use dynamic resources. Windows Phone 8: This API is supported. Read more on docs.microsoft.com. Sets the constant buffers used by the pixel shader pipeline stage. Type: UINT 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). Read more on docs.microsoft.com. Type: UINT Number of buffers to set (ranges from 0 to D3D11_COMMONSHADER_CONSTANT_BUFFER_API_SLOT_COUNT - StartSlot). Read more on docs.microsoft.com. Type: ID3D11Buffer* Array of constant buffers (see ID3D11Buffer) being given to the device. Read more on docs.microsoft.com. 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. Read more on docs.microsoft.com. Bind an input-layout object to the input-assembler stage. (ID3D11DeviceContext.IASetInputLayout) Type: ID3D11InputLayout* A pointer to the input-layout object (see ID3D11InputLayout), which describes the input buffers that will be read by the IA stage. Read more on docs.microsoft.com. 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. Read more on docs.microsoft.com. Bind an array of vertex buffers to the input-assembler stage. (ID3D11DeviceContext.IASetVertexBuffers) Type: UINT The first input slot for binding. 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. Read more on docs.microsoft.com. Type: UINT The number of vertex buffers in the array. The number of buffers (plus the starting slot) can't exceed the total number of IA-stage input slots (ranges from 0 to D3D11_IA_VERTEX_INPUT_RESOURCE_SLOT_COUNT - StartSlot). Read more on docs.microsoft.com. Type: ID3D11Buffer* A pointer to an array of vertex buffers (see ID3D11Buffer). The vertex buffers must have been created with the D3D11_BIND_VERTEX_BUFFER flag. Read more on docs.microsoft.com. Type: const UINT* Pointer to an array of stride values; one stride value for each buffer in the vertex-buffer array. Each stride is the size (in bytes) of the elements that are to be used from that vertex buffer. Read more on docs.microsoft.com. Type: const UINT* Pointer to an array of offset values; 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. Read more on docs.microsoft.com. 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. Read more on docs.microsoft.com. Bind an index buffer to the input-assembler stage. (ID3D11DeviceContext.IASetIndexBuffer) Type: ID3D11Buffer* A pointer to an ID3D11Buffer object, that contains indices. The index buffer must have been created with the D3D11_BIND_INDEX_BUFFER flag. Read more on docs.microsoft.com. Type: DXGI_FORMAT 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. Read more on docs.microsoft.com. Type: UINT Offset (in bytes) from the start of the index buffer to the first index to use. Read more on docs.microsoft.com. 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. Read more on docs.microsoft.com. Draw indexed, instanced primitives. (ID3D11DeviceContext.DrawIndexedInstanced) Type: UINT Number of indices read from the index buffer for each instance. Read more on docs.microsoft.com. Type: UINT Number of instances to draw. Read more on docs.microsoft.com. Type: UINT The location of the first index read by the GPU from the index buffer. Read more on docs.microsoft.com. Type: INT A value added to each index before reading a vertex from the vertex buffer. Read more on docs.microsoft.com. Type: UINT A value added to each index before reading per-instance data from a vertex buffer. Read more on docs.microsoft.com. 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. The second buffer is needed only if the input layout that you use has elements that use [D3D11_INPUT_PER_INSTANCE_DATA](./ne-d3d11-d3d11_input_classification.md) as the input element classification buffer for per-instance data. Read more on docs.microsoft.com. Draw non-indexed, instanced primitives. (ID3D11DeviceContext.DrawInstanced) Type: UINT Number of vertices to draw. Read more on docs.microsoft.com. Type: UINT Number of instances to draw. Read more on docs.microsoft.com. Type: UINT Index of the first vertex. Read more on docs.microsoft.com. Type: UINT A value added to each index before reading per-instance data from a vertex buffer. Read more on docs.microsoft.com. 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). Read more on docs.microsoft.com. Sets the constant buffers used by the geometry shader pipeline stage. Type: UINT 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). Read more on docs.microsoft.com. Type: UINT Number of buffers to set (ranges from 0 to D3D11_COMMONSHADER_CONSTANT_BUFFER_API_SLOT_COUNT - StartSlot). Read more on docs.microsoft.com. Type: ID3D11Buffer* Array of constant buffers (see ID3D11Buffer) being given to the device. Read more on docs.microsoft.com. 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 pointer to the ID3D11ShaderReflection interface and then call ID3D11ShaderReflection::GetConstantBufferByName to get a pointer 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. Read more on docs.microsoft.com. Set a geometry shader to the device. (ID3D11DeviceContext.GSSetShader) Type: ID3D11GeometryShader* Pointer to a geometry shader (see ID3D11GeometryShader). Passing in NULL disables the shader for this pipeline stage. Read more on docs.microsoft.com. Type: ID3D11ClassInstance* A pointer 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. Read more on docs.microsoft.com. Type: UINT The number of class-instance interfaces in the array. Read more on docs.microsoft.com. 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. Read more on docs.microsoft.com. Bind information about the primitive type, and data order that describes input data for the input assembler stage. (ID3D11DeviceContext.IASetPrimitiveTopology) Type: D3D11_PRIMITIVE_TOPOLOGY The type of primitive and ordering of the primitive data (see D3D11_PRIMITIVE_TOPOLOGY). Read more on docs.microsoft.com. Windows Phone 8: This API is supported. Read more on docs.microsoft.com. Bind an array of shader resources to the vertex-shader stage. Type: UINT 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). Read more on docs.microsoft.com. Type: UINT 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). Read more on docs.microsoft.com. Type: ID3D11ShaderResourceView* Array of shader resource view interfaces to set to the device. Read more on docs.microsoft.com. 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. In order to unbind resource slots, you must pass an array containing null values. For example, to clear the first 4 slots, use: This doc was truncated. Read more on docs.microsoft.com. Set an array of sampler states to the vertex shader pipeline stage. (ID3D11DeviceContext.VSSetSamplers) Type: UINT Index into the device's zero-based array to begin setting samplers to (ranges from 0 to D3D11_COMMONSHADER_SAMPLER_SLOT_COUNT - 1). Read more on docs.microsoft.com. Type: UINT 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). Read more on docs.microsoft.com. Type: ID3D11SamplerState* Pointer to an array of sampler-state interfaces (see ID3D11SamplerState). See Remarks. Read more on docs.microsoft.com. Any sampler may be set to NULL; this invokes the default state, which is defined to be the following. This doc was truncated. Read more on docs.microsoft.com. Mark the beginning of a series of commands. Type: ID3D11Asynchronous* A pointer to an ID3D11Asynchronous interface. Read more on docs.microsoft.com. Use ID3D11DeviceContext::End to mark the ending of the series of commands. Mark the end of a series of commands. Type: ID3D11Asynchronous* A pointer to an ID3D11Asynchronous interface. Read more on docs.microsoft.com. Use ID3D11DeviceContext::Begin to mark the beginning of the series of commands. Get data from the graphics processing unit (GPU) asynchronously. Type: ID3D11Asynchronous* A pointer to an ID3D11Asynchronous interface for the object about which GetData retrieves data. Read more on docs.microsoft.com. Type: void* 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. Read more on docs.microsoft.com. Type: UINT Size of the data to retrieve or 0. Must be 0 when pData is NULL. Read more on docs.microsoft.com. Type: UINT Optional flags. Can be 0 or any combination of the flags enumerated by D3D11_ASYNC_GETDATA_FLAG. Read more on docs.microsoft.com. Type: HRESULT 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. 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. Read more on docs.microsoft.com. Set a rendering predicate. (ID3D11DeviceContext.SetPredication) Type: ID3D11Predicate* A pointer 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. Read more on docs.microsoft.com. Type: BOOL 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. Read more on docs.microsoft.com. 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 its own application logic. Rendering and resource manipulation commands for Direct3D 11 include these Draw, Dispatch, Copy, Update, Clear, Generate, and Resolve operations. This doc was truncated. Read more on docs.microsoft.com. Bind an array of shader resources to the geometry shader stage. (ID3D11DeviceContext.GSSetShaderResources) Type: UINT 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). Read more on docs.microsoft.com. Type: UINT 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). Read more on docs.microsoft.com. Type: ID3D11ShaderResourceView* Array of shader resource view interfaces to set to the device. Read more on docs.microsoft.com. 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. Read more on docs.microsoft.com. Set an array of sampler states to the geometry shader pipeline stage. (ID3D11DeviceContext.GSSetSamplers) Type: UINT Index into the device's zero-based array to begin setting samplers to (ranges from 0 to D3D11_COMMONSHADER_SAMPLER_SLOT_COUNT - 1). Read more on docs.microsoft.com. Type: UINT 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). Read more on docs.microsoft.com. Type: ID3D11SamplerState* Pointer to an array of sampler-state interfaces (see ID3D11SamplerState). See Remarks. Read more on docs.microsoft.com. Any sampler may be set to NULL; this invokes the default state, which is defined to be the following. This doc was truncated. Read more on docs.microsoft.com. Bind one or more render targets atomically and the depth-stencil buffer to the output-merger stage. Type: UINT 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. Read more on docs.microsoft.com. Type: ID3D11RenderTargetView* Pointer to an array of ID3D11RenderTargetView that represent the render targets to bind to the device. If this parameter is NULL and NumViews is 0, no render targets are bound. Read more on docs.microsoft.com. Type: ID3D11DepthStencilView* Pointer to a ID3D11DepthStencilView that represents the depth-stencil view to bind to the device. If this parameter is NULL, the depth-stencil view is not bound. Read more on docs.microsoft.com. 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. Note that unlike some other resource methods in Direct3D, all currently bound render targets will be unbound by calling `OMSetRenderTargets(0, nullptr, nullptr);`. Read more on docs.microsoft.com. Binds resources to the output-merger stage. Type: UINT 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). Read more on docs.microsoft.com. Type: ID3D11RenderTargetView* Pointer to an array of ID3D11RenderTargetViews that represent the render targets to bind to the device. If this parameter is NULL and NumRTVs is 0, no render targets are bound. Read more on docs.microsoft.com. Type: ID3D11DepthStencilView* Pointer to a ID3D11DepthStencilView that represents the depth-stencil view to bind to the device. If this parameter is NULL, the depth-stencil view is not bound. Read more on docs.microsoft.com. Type: UINT 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. Read more on docs.microsoft.com. Type: UINT 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. Read more on docs.microsoft.com. Type: ID3D11UnorderedAccessView* Pointer to an array of ID3D11UnorderedAccessViews 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. Read more on docs.microsoft.com. Type: const UINT* 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. Read more on docs.microsoft.com. 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: This doc was truncated. Read more on docs.microsoft.com. Set the blend state of the output-merger stage. (ID3D11DeviceContext.OMSetBlendState) Type: ID3D11BlendState* Pointer to a blend-state interface (see ID3D11BlendState). Pass NULL for a default blend state. For more info about default blend state, see Remarks. Read more on docs.microsoft.com. Type: const FLOAT[4] 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 }. Read more on docs.microsoft.com. Type: UINT 32-bit sample coverage. The default value is 0xffffffff. See remarks. Read more on docs.microsoft.com. 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. This doc was truncated. Read more on docs.microsoft.com. Sets the depth-stencil state of the output-merger stage. (ID3D11DeviceContext.OMSetDepthStencilState) Type: ID3D11DepthStencilState* 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. Read more on docs.microsoft.com. Type: UINT Reference value to perform against when doing a depth-stencil test. See remarks. Read more on docs.microsoft.com. 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. Read more on docs.microsoft.com. Set the target output buffers for the stream-output stage of the pipeline. Type: UINT 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. Read more on docs.microsoft.com. Type: ID3D11Buffer* 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. Read more on docs.microsoft.com. Type: const UINT* Array of offsets to the output buffers from ppSOTargets, one offset for each buffer. The offset values must be in bytes. Read more on docs.microsoft.com. 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. Note that unlike some other resource methods in Direct3D, all currently bound targets will be unbound by calling `SOSetTargets(0, nullptr, nullptr);`. Windows Phone 8: This API is supported. Read more on docs.microsoft.com. 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. This doc was truncated. Read more on docs.microsoft.com. Draw indexed, instanced, GPU-generated primitives. Type: **[ID3D11Buffer](/windows/win32/api/d3d11/nn-d3d11-id3d11buffer)\*** A pointer to an [ID3D11Buffer](/windows/win32/api/d3d11/nn-d3d11-id3d11buffer), which is a buffer containing the GPU-generated primitives. Read more on docs.microsoft.com. Type: **[UINT](/windows/win32/winprog/windows-data-types)** A DWORD-aligned byte offset in pBufferForArgs to the start of the GPU generated primitives. Read more on docs.microsoft.com. When an application creates a buffer that is associated with the [ID3D11Buffer](/windows/win32/api/d3d11/nn-d3d11-id3d11buffer) interface that *pBufferForArgs* points to, your application must set the [D3D11_RESOURCE_MISC_DRAWINDIRECT_ARGS](/windows/win32/api/d3d11/ne-d3d11-d3d11_resource_misc_flag) flag in the *MiscFlags* member of the [D3D11_BUFFER_DESC](/windows/win32/api/d3d11/ns-d3d11-d3d11_buffer_desc) structure that describes the buffer. To create the buffer, your application should call the [ID3D11Device::CreateBuffer](/windows/win32/api/d3d11/nf-d3d11-id3d11device-createbuffer) method, and pass a pointer to a **D3D11_BUFFER_DESC** in the *pDesc* parameter. **Windows Phone 8:** This API is supported. Read more on docs.microsoft.com. Draw instanced, GPU-generated primitives. Type: ID3D11Buffer* A pointer to an ID3D11Buffer, which is a buffer containing the GPU generated primitives. Read more on docs.microsoft.com. Type: UINT Offset in pBufferForArgs to the start of the GPU generated primitives. Read more on docs.microsoft.com. 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 pointer to D3D11_BUFFER_DESC in the pDesc parameter. Execute a command list from a thread group. Type: UINT 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). Read more on docs.microsoft.com. Type: UINT 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). Read more on docs.microsoft.com. Type: UINT 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. Read more on docs.microsoft.com. 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). This doc was truncated. Read more on docs.microsoft.com. Execute a command list over one or more thread groups. Type: ID3D11Buffer* A pointer to an ID3D11Buffer, which must be loaded with data that matches the argument list for ID3D11DeviceContext::Dispatch. Read more on docs.microsoft.com. Type: UINT A byte-aligned offset between the start of the buffer and the arguments. Read more on docs.microsoft.com. 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 pointer to D3D11_BUFFER_DESC in the pDesc parameter. Read more on docs.microsoft.com. Set the rasterizer state for the rasterizer stage of the pipeline. (ID3D11DeviceContext.RSSetState) Type: ID3D11RasterizerState* Pointer to a rasterizer-state interface (see ID3D11RasterizerState) to bind to the pipeline. Read more on docs.microsoft.com. 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. Read more on docs.microsoft.com. Bind an array of viewports to the rasterizer stage of the pipeline. (ID3D11DeviceContext.RSSetViewports) Type: UINT Number of viewports to bind. Read more on docs.microsoft.com. Type: const D3D11_VIEWPORT* 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. Read more on docs.microsoft.com. 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.
 
 Read more on docs.microsoft.com. Bind an array of scissor rectangles to the rasterizer stage. (ID3D11DeviceContext.RSSetScissorRects) Type: UINT Number of scissor rectangles to bind. Read more on docs.microsoft.com. Type: const D3D11_RECT* An array of scissor rectangles (see D3D11_RECT). Read more on docs.microsoft.com. 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. Read more on docs.microsoft.com. Copy a region from a source resource to a destination resource. (ID3D11DeviceContext.CopySubresourceRegion) Type: ID3D11Resource* A pointer to the destination resource (see ID3D11Resource). Read more on docs.microsoft.com. Type: UINT Destination subresource index. Read more on docs.microsoft.com. Type: UINT The x-coordinate of the upper left corner of the destination region. Read more on docs.microsoft.com. Type: UINT The y-coordinate of the upper left corner of the destination region. For a 1D subresource, this must be zero. Read more on docs.microsoft.com. Type: UINT The z-coordinate of the upper left corner of the destination region. For a 1D or 2D subresource, this must be zero. Read more on docs.microsoft.com. Type: ID3D11Resource* A pointer to the source resource (see ID3D11Resource). Read more on docs.microsoft.com. Type: UINT Source subresource index. Read more on docs.microsoft.com. Type: const D3D11_BOX* A pointer 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. Read more on docs.microsoft.com. 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: This doc was truncated. Read more on docs.microsoft.com. Copy the entire contents of the source resource to the destination resource using the GPU. (ID3D11DeviceContext.CopyResource) Type: ID3D11Resource* A pointer to the ID3D11Resource interface that represents the destination resource. Read more on docs.microsoft.com. Type: ID3D11Resource* A pointer to the ID3D11Resource interface that represents the source resource. Read more on docs.microsoft.com. 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: This doc was truncated. Read more on docs.microsoft.com. The CPU copies data from memory to a subresource created in non-mappable memory. (ID3D11DeviceContext.UpdateSubresource) Type: ID3D11Resource* A pointer to the destination resource (see ID3D11Resource). Read more on docs.microsoft.com. Type: UINT A zero-based index, that identifies the destination subresource. See D3D11CalcSubresource for more details. Read more on docs.microsoft.com. Type: const D3D11_BOX* A pointer 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. Read more on docs.microsoft.com. Type: const void* A pointer to the source data in memory. Read more on docs.microsoft.com. Type: UINT The size of one row of the source data. Read more on docs.microsoft.com. Type: UINT The size of one depth slice of source data. Read more on docs.microsoft.com. 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: This doc was truncated. Read more on docs.microsoft.com. Copies data from a buffer holding variable length data. Type: ID3D11Buffer* 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. Read more on docs.microsoft.com. Type: UINT Offset from the start of pDstBuffer to write 32-bit UINT structure (vertex) count from pSrcView. Read more on docs.microsoft.com. Type: ID3D11UnorderedAccessView* 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. Read more on docs.microsoft.com. Learn more about this API from docs.microsoft.com. Set all the elements in a render target to one value. (ID3D11DeviceContext.ClearRenderTargetView) Type: ID3D11RenderTargetView* Pointer to the render target. Read more on docs.microsoft.com. Type: const FLOAT[4] A 4-component array that represents the color to fill the render target with. Read more on docs.microsoft.com. 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. This doc was truncated. Read more on docs.microsoft.com. Clears an unordered access resource with bit-precise values. Type: ID3D11UnorderedAccessView* The ID3D11UnorderedAccessView to clear. Read more on docs.microsoft.com. Type: const UINT[4] Values to copy to corresponding channels, see remarks. Read more on docs.microsoft.com. 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. Read more on docs.microsoft.com. Clears an unordered access resource with a float value. Type: ID3D11UnorderedAccessView* The ID3D11UnorderedAccessView to clear. Read more on docs.microsoft.com. Type: const FLOAT[4] Values to copy to corresponding channels, see remarks. Read more on docs.microsoft.com. 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. Clears the depth-stencil resource. (ID3D11DeviceContext.ClearDepthStencilView) Type: ID3D11DepthStencilView* Pointer to the depth stencil to be cleared. Read more on docs.microsoft.com. Type: UINT Identify the type of data to clear (see D3D11_CLEAR_FLAG). Read more on docs.microsoft.com. Type: FLOAT Clear the depth buffer with this value. This value will be clamped between 0 and 1. Read more on docs.microsoft.com. Type: UINT8 Clear the stencil buffer with this value. Read more on docs.microsoft.com. This doc was truncated. Read more on docs.microsoft.com. Generates mipmaps for the given shader resource. (ID3D11DeviceContext.GenerateMips) Type: ID3D11ShaderResourceView* A pointer to an ID3D11ShaderResourceView interface that represents the shader resource. Read more on docs.microsoft.com. 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: This doc was truncated. Read more on docs.microsoft.com. Sets the minimum level-of-detail (LOD) for a resource. Type: ID3D11Resource* A pointer to an ID3D11Resource that represents the resource. Read more on docs.microsoft.com. Type: FLOAT 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. Read more on docs.microsoft.com. 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. Read more on docs.microsoft.com. Gets the minimum level-of-detail (LOD). Type: ID3D11Resource* A pointer to an ID3D11Resource which represents the resource. Read more on docs.microsoft.com. Type: FLOAT Returns the minimum LOD. Learn more about this API from docs.microsoft.com. Copy a multisampled resource into a non-multisampled resource. Type: ID3D11Resource* Destination resource. Must be a created with the D3D11_USAGE_DEFAULT flag and be single-sampled. See ID3D11Resource. Read more on docs.microsoft.com. Type: UINT A zero-based index, that identifies the destination subresource. Use D3D11CalcSubresource to calculate the index. Read more on docs.microsoft.com. Type: ID3D11Resource* Source resource. Must be multisampled. Read more on docs.microsoft.com. Type: UINT The source subresource of the source resource. Read more on docs.microsoft.com. Type: DXGI_FORMAT A DXGI_FORMAT that indicates how the multisampled resource will be resolved to a single-sampled resource. See remarks. Read more on docs.microsoft.com. 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: This doc was truncated. Read more on docs.microsoft.com. Queues commands from a command list onto a device. Type: ID3D11CommandList* A pointer to an ID3D11CommandList interface that encapsulates a command list. Read more on docs.microsoft.com. Type: BOOL 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. Read more on docs.microsoft.com. 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. Read more on docs.microsoft.com. Bind an array of shader resources to the hull-shader stage. Type: UINT 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). Read more on docs.microsoft.com. Type: UINT 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). Read more on docs.microsoft.com. Type: ID3D11ShaderResourceView* Array of shader resource view interfaces to set to the device. Read more on docs.microsoft.com. 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. Read more on docs.microsoft.com. Set a hull shader to the device. Type: ID3D11HullShader* Pointer to a hull shader (see ID3D11HullShader). Passing in NULL disables the shader for this pipeline stage. Read more on docs.microsoft.com. Type: ID3D11ClassInstance* A pointer 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. Read more on docs.microsoft.com. Type: UINT The number of class-instance interfaces in the array. Read more on docs.microsoft.com. 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. Read more on docs.microsoft.com. Set an array of sampler states to the hull-shader stage. Type: UINT Index into the zero-based array to begin setting samplers to (ranges from 0 to D3D11_COMMONSHADER_SAMPLER_SLOT_COUNT - 1). Read more on docs.microsoft.com. Type: UINT 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). Read more on docs.microsoft.com. Type: ID3D11SamplerState* Pointer to an array of sampler-state interfaces (see ID3D11SamplerState). See Remarks. Read more on docs.microsoft.com. Any sampler may be set to NULL; this invokes the default state, which is defined to be the following. This doc was truncated. Read more on docs.microsoft.com. Set the constant buffers used by the hull-shader stage. Type: UINT 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). Read more on docs.microsoft.com. Type: UINT Number of buffers to set (ranges from 0 to D3D11_COMMONSHADER_CONSTANT_BUFFER_API_SLOT_COUNT - StartSlot). Read more on docs.microsoft.com. Type: ID3D11Buffer* Array of constant buffers (see ID3D11Buffer) being given to the device. Read more on docs.microsoft.com. 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. Read more on docs.microsoft.com. Bind an array of shader resources to the domain-shader stage. Type: UINT 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). Read more on docs.microsoft.com. Type: UINT 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). Read more on docs.microsoft.com. Type: ID3D11ShaderResourceView* Array of shader resource view interfaces to set to the device. Read more on docs.microsoft.com. 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. Read more on docs.microsoft.com. Set a domain shader to the device. Type: ID3D11DomainShader* Pointer to a domain shader (see ID3D11DomainShader). Passing in NULL disables the shader for this pipeline stage. Read more on docs.microsoft.com. Type: ID3D11ClassInstance* A pointer 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. Read more on docs.microsoft.com. Type: UINT The number of class-instance interfaces in the array. Read more on docs.microsoft.com. 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. Windows Phone 8: This API is supported. Read more on docs.microsoft.com. Set an array of sampler states to the domain-shader stage. Type: UINT Index into the device's zero-based array to begin setting samplers to (ranges from 0 to D3D11_COMMONSHADER_SAMPLER_SLOT_COUNT - 1). Read more on docs.microsoft.com. Type: UINT 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). Read more on docs.microsoft.com. Type: ID3D11SamplerState* Pointer to an array of sampler-state interfaces (see ID3D11SamplerState). See Remarks. Read more on docs.microsoft.com. Any sampler may be set to NULL; this invokes the default state, which is defined to be the following. This doc was truncated. Read more on docs.microsoft.com. Sets the constant buffers used by the domain-shader stage. Type: UINT Index into the zero-based array to begin setting constant buffers to (ranges from 0 to D3D11_COMMONSHADER_CONSTANT_BUFFER_API_SLOT_COUNT - 1). Read more on docs.microsoft.com. Type: UINT Number of buffers to set (ranges from 0 to D3D11_COMMONSHADER_CONSTANT_BUFFER_API_SLOT_COUNT - StartSlot). Read more on docs.microsoft.com. Type: ID3D11Buffer* Array of constant buffers (see ID3D11Buffer) being given to the device. Read more on docs.microsoft.com. 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. Read more on docs.microsoft.com. Bind an array of shader resources to the compute-shader stage. Type: UINT 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). Read more on docs.microsoft.com. Type: UINT 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). Read more on docs.microsoft.com. Type: ID3D11ShaderResourceView* Array of shader resource view interfaces to set to the device. Read more on docs.microsoft.com. 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. Read more on docs.microsoft.com. Sets an array of views for an unordered resource. Type: UINT 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. Read more on docs.microsoft.com. Type: UINT Number of views to set (ranges from 0 to D3D11_1_UAV_SLOT_COUNT - StartSlot). Read more on docs.microsoft.com. Type: ID3D11UnorderedAccessView* A pointer to an array of ID3D11UnorderedAccessView pointers to be set by the method. Read more on docs.microsoft.com. Type: const UINT* 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. Read more on docs.microsoft.com. Windows Phone 8: This API is supported. Read more on docs.microsoft.com. Set a compute shader to the device. Type: ID3D11ComputeShader* Pointer to a compute shader (see ID3D11ComputeShader). Passing in NULL disables the shader for this pipeline stage. Read more on docs.microsoft.com. Type: ID3D11ClassInstance* A pointer 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. Read more on docs.microsoft.com. Type: UINT The number of class-instance interfaces in the array. Read more on docs.microsoft.com. 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. Read more on docs.microsoft.com. Set an array of sampler states to the compute-shader stage. Type: UINT Index into the device's zero-based array to begin setting samplers to (ranges from 0 to D3D11_COMMONSHADER_SAMPLER_SLOT_COUNT - 1). Read more on docs.microsoft.com. Type: UINT 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). Read more on docs.microsoft.com. Type: ID3D11SamplerState* Pointer to an array of sampler-state interfaces (see ID3D11SamplerState). See Remarks. Read more on docs.microsoft.com. Any sampler may be set to NULL; this invokes the default state, which is defined to be the following. This doc was truncated. Read more on docs.microsoft.com. Sets the constant buffers used by the compute-shader stage. Type: UINT Index into the zero-based array to begin setting constant buffers to (ranges from 0 to D3D11_COMMONSHADER_CONSTANT_BUFFER_API_SLOT_COUNT - 1). Read more on docs.microsoft.com. Type: UINT Number of buffers to set (ranges from 0 to D3D11_COMMONSHADER_CONSTANT_BUFFER_API_SLOT_COUNT - StartSlot). Read more on docs.microsoft.com. Type: ID3D11Buffer* Array of constant buffers (see ID3D11Buffer) being given to the device. Read more on docs.microsoft.com. 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. Read more on docs.microsoft.com. Get the constant buffers used by the vertex shader pipeline stage. (ID3D11DeviceContext.VSGetConstantBuffers) Type: UINT 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). Read more on docs.microsoft.com. Type: UINT Number of buffers to retrieve (ranges from 0 to D3D11_COMMONSHADER_CONSTANT_BUFFER_API_SLOT_COUNT - StartSlot). Read more on docs.microsoft.com. Type: ID3D11Buffer** Array of constant buffer interface pointers (see ID3D11Buffer) to be returned by the method. Read more on docs.microsoft.com. 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. Get the pixel shader resources. (ID3D11DeviceContext.PSGetShaderResources) Type: UINT 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). Read more on docs.microsoft.com. Type: UINT 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). Read more on docs.microsoft.com. Type: ID3D11ShaderResourceView** Array of shader resource view interfaces to be returned by the device. Read more on docs.microsoft.com. 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. Get the pixel shader currently set on the device. (ID3D11DeviceContext.PSGetShader) Type: ID3D11PixelShader** Address of a pointer to a pixel shader (see ID3D11PixelShader) to be returned by the method. Read more on docs.microsoft.com. Type: ID3D11ClassInstance** Pointer to an array of class instance interfaces (see ID3D11ClassInstance). Read more on docs.microsoft.com. Type: UINT* The number of class-instance elements in the array. Read more on docs.microsoft.com. 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. Read more on docs.microsoft.com. Get an array of sampler states from the pixel shader pipeline stage. (ID3D11DeviceContext.PSGetSamplers) Type: UINT Index into a zero-based array to begin getting samplers from (ranges from 0 to D3D11_COMMONSHADER_SAMPLER_SLOT_COUNT - 1). Read more on docs.microsoft.com. Type: UINT 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). Read more on docs.microsoft.com. Type: ID3D11SamplerState** Array of sampler-state interface pointers (see ID3D11SamplerState) to be returned by the device. Read more on docs.microsoft.com. 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. Get the vertex shader currently set on the device. (ID3D11DeviceContext.VSGetShader) Type: ID3D11VertexShader** Address of a pointer to a vertex shader (see ID3D11VertexShader) to be returned by the method. Read more on docs.microsoft.com. Type: ID3D11ClassInstance** Pointer to an array of class instance interfaces (see ID3D11ClassInstance). Read more on docs.microsoft.com. Type: UINT* The number of class-instance elements in the array. Read more on docs.microsoft.com. 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. Get the constant buffers used by the pixel shader pipeline stage. (ID3D11DeviceContext.PSGetConstantBuffers) Type: UINT 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). Read more on docs.microsoft.com. Type: UINT Number of buffers to retrieve (ranges from 0 to D3D11_COMMONSHADER_CONSTANT_BUFFER_API_SLOT_COUNT - StartSlot). Read more on docs.microsoft.com. Type: ID3D11Buffer** Array of constant buffer interface pointers (see ID3D11Buffer) to be returned by the method. Read more on docs.microsoft.com. 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. Get a pointer to the input-layout object that is bound to the input-assembler stage. (ID3D11DeviceContext.IAGetInputLayout) Type: ID3D11InputLayout** A pointer to the input-layout object (see ID3D11InputLayout), which describes the input buffers that will be read by the IA stage. Read more on docs.microsoft.com. 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. Read more on docs.microsoft.com. Get the vertex buffers bound to the input-assembler stage. (ID3D11DeviceContext.IAGetVertexBuffers) Type: UINT 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. Read more on docs.microsoft.com. Type: UINT 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. Read more on docs.microsoft.com. Type: ID3D11Buffer** A pointer to an array of vertex buffers returned by the method (see ID3D11Buffer). Read more on docs.microsoft.com. Type: UINT* 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. Read more on docs.microsoft.com. Type: UINT* 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. Read more on docs.microsoft.com. 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. Get a pointer to the index buffer that is bound to the input-assembler stage. (ID3D11DeviceContext.IAGetIndexBuffer) Type: ID3D11Buffer** A pointer to an index buffer returned by the method (see ID3D11Buffer). Read more on docs.microsoft.com. Type: DXGI_FORMAT* 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. Read more on docs.microsoft.com. Type: UINT* Offset (in bytes) from the start of the index buffer, to the first index to use. Read more on docs.microsoft.com. 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. Read more on docs.microsoft.com. Get the constant buffers used by the geometry shader pipeline stage. (ID3D11DeviceContext.GSGetConstantBuffers) Type: UINT 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). Read more on docs.microsoft.com. Type: UINT Number of buffers to retrieve (ranges from 0 to D3D11_COMMONSHADER_CONSTANT_BUFFER_API_SLOT_COUNT - StartSlot). Read more on docs.microsoft.com. Type: ID3D11Buffer** Array of constant buffer interface pointers (see ID3D11Buffer) to be returned by the method. Read more on docs.microsoft.com. 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. Get the geometry shader currently set on the device. (ID3D11DeviceContext.GSGetShader) Type: ID3D11GeometryShader** Address of a pointer to a geometry shader (see ID3D11GeometryShader) to be returned by the method. Read more on docs.microsoft.com. Type: ID3D11ClassInstance** Pointer to an array of class instance interfaces (see ID3D11ClassInstance). Read more on docs.microsoft.com. Type: UINT* The number of class-instance elements in the array. Read more on docs.microsoft.com. 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. Get information about the primitive type, and data order that describes input data for the input assembler stage. (ID3D11DeviceContext.IAGetPrimitiveTopology) Type: D3D11_PRIMITIVE_TOPOLOGY* A pointer to the type of primitive, and ordering of the primitive data (see D3D11_PRIMITIVE_TOPOLOGY). Read more on docs.microsoft.com. Learn more about this API from docs.microsoft.com. Get the vertex shader resources. (ID3D11DeviceContext.VSGetShaderResources) Type: UINT 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). Read more on docs.microsoft.com. Type: UINT 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). Read more on docs.microsoft.com. Type: ID3D11ShaderResourceView** Array of shader resource view interfaces to be returned by the device. Read more on docs.microsoft.com. 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. Get an array of sampler states from the vertex shader pipeline stage. (ID3D11DeviceContext.VSGetSamplers) Type: UINT Index into a zero-based array to begin getting samplers from (ranges from 0 to D3D11_COMMONSHADER_SAMPLER_SLOT_COUNT - 1). Read more on docs.microsoft.com. Type: UINT 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). Read more on docs.microsoft.com. Type: ID3D11SamplerState** Array of sampler-state interface pointers (see ID3D11SamplerState) to be returned by the device. Read more on docs.microsoft.com. 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. Get the rendering predicate state. (ID3D11DeviceContext.GetPredication) Type: ID3D11Predicate** Address of a pointer to a predicate (see ID3D11Predicate). Value stored here will be NULL upon device creation. Read more on docs.microsoft.com. Type: BOOL* Address of a boolean to fill with the predicate comparison value. FALSE upon device creation. Read more on docs.microsoft.com. 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. Get the geometry shader resources. (ID3D11DeviceContext.GSGetShaderResources) Type: UINT 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). Read more on docs.microsoft.com. Type: UINT 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). Read more on docs.microsoft.com. Type: ID3D11ShaderResourceView** Array of shader resource view interfaces to be returned by the device. Read more on docs.microsoft.com. 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. Get an array of sampler state interfaces from the geometry shader pipeline stage. Type: UINT Index into a zero-based array to begin getting samplers from (ranges from 0 to D3D11_COMMONSHADER_SAMPLER_SLOT_COUNT - 1). Read more on docs.microsoft.com. Type: UINT 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). Read more on docs.microsoft.com. Type: ID3D11SamplerState** Pointer to an array of sampler-state interfaces (see ID3D11SamplerState). Read more on docs.microsoft.com. 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. Get pointers to the resources bound to the output-merger stage. (ID3D11DeviceContext.OMGetRenderTargets) Type: UINT Number of render targets to retrieve. Read more on docs.microsoft.com. Type: ID3D11RenderTargetView** Pointer to an array of ID3D11RenderTargetViews which represent render target views. Specify NULL for this parameter when retrieval of a render target is not needed. Read more on docs.microsoft.com. Type: ID3D11DepthStencilView** 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. Read more on docs.microsoft.com. 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. Get pointers to the resources bound to the output-merger stage. (ID3D11DeviceContext.OMGetRenderTargetsAndUnorderedAccessViews) Type: UINT The number of render-target views to retrieve. Read more on docs.microsoft.com. Type: ID3D11RenderTargetView** Pointer to an array of ID3D11RenderTargetViews, which represent render-target views. Specify NULL for this parameter when retrieval of render-target views is not required. Read more on docs.microsoft.com. Type: ID3D11DepthStencilView** 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. Read more on docs.microsoft.com. Type: UINT 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. Read more on docs.microsoft.com. Type: UINT Number of unordered-access views to return in ppUnorderedAccessViews. This number ranges from 0 to D3D11_PS_CS_UAV_REGISTER_COUNT - UAVStartSlot. Read more on docs.microsoft.com. Type: ID3D11UnorderedAccessView** Pointer to an array of ID3D11UnorderedAccessViews, which represent unordered-access views that are retrieved. Specify NULL for this parameter when retrieval of unordered-access views is not required. Read more on docs.microsoft.com. 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. Read more on docs.microsoft.com. Get the blend state of the output-merger stage. (ID3D11DeviceContext.OMGetBlendState) Type: ID3D11BlendState** Address of a pointer to a blend-state interface (see ID3D11BlendState). Read more on docs.microsoft.com. Type: FLOAT[4] Array of blend factors, one for each RGBA component. Read more on docs.microsoft.com. Type: UINT* Pointer to a sample mask. Read more on docs.microsoft.com. The reference count of the returned interface will be incremented by one when the blend state is retrieved. Applications must release returned pointer(s) when they are no longer needed, or else there will be a memory leak. Windows Phone 8: This API is supported. Read more on docs.microsoft.com. Gets the depth-stencil state of the output-merger stage. (ID3D11DeviceContext.OMGetDepthStencilState) Type: ID3D11DepthStencilState** Address of a pointer to a depth-stencil state interface (see ID3D11DepthStencilState) to be filled with information from the device. Read more on docs.microsoft.com. Type: UINT* Pointer to the stencil reference value used in the depth-stencil test. Read more on docs.microsoft.com. 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. Read more on docs.microsoft.com. Get the target output buffers for the stream-output stage of the pipeline. Type: UINT Number of buffers to get. Read more on docs.microsoft.com. Type: ID3D11Buffer** An array of output buffers (see ID3D11Buffer) to be retrieved from the device. Read more on docs.microsoft.com. 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. Read more on docs.microsoft.com. Get the rasterizer state from the rasterizer stage of the pipeline. (ID3D11DeviceContext.RSGetState) Type: ID3D11RasterizerState** Address of a pointer to a rasterizer-state interface (see ID3D11RasterizerState) to fill with information from the device. Read more on docs.microsoft.com. 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. Gets the array of viewports bound to the rasterizer stage. Type: UINT* A pointer 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.
 
 Read more on docs.microsoft.com. Type: D3D11_VIEWPORT* 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. Read more on docs.microsoft.com. Windows Phone 8: This API is supported. Read more on docs.microsoft.com. Get the array of scissor rectangles bound to the rasterizer stage. (ID3D11DeviceContext.RSGetScissorRects) Type: UINT* 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. Read more on docs.microsoft.com. Type: D3D11_RECT* 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. Read more on docs.microsoft.com. Learn more about this API from docs.microsoft.com. Get the hull-shader resources. Type: UINT 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). Read more on docs.microsoft.com. Type: UINT 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). Read more on docs.microsoft.com. Type: ID3D11ShaderResourceView** Array of shader resource view interfaces to be returned by the device. Read more on docs.microsoft.com. 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. Get the hull shader currently set on the device. Type: ID3D11HullShader** Address of a pointer to a hull shader (see ID3D11HullShader) to be returned by the method. Read more on docs.microsoft.com. Type: ID3D11ClassInstance** Pointer to an array of class instance interfaces (see ID3D11ClassInstance). Read more on docs.microsoft.com. Type: UINT* The number of class-instance elements in the array. Read more on docs.microsoft.com. 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. Get an array of sampler state interfaces from the hull-shader stage. Type: UINT Index into a zero-based array to begin getting samplers from (ranges from 0 to D3D11_COMMONSHADER_SAMPLER_SLOT_COUNT - 1). Read more on docs.microsoft.com. Type: UINT 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). Read more on docs.microsoft.com. Type: ID3D11SamplerState** Pointer to an array of sampler-state interfaces (see ID3D11SamplerState). Read more on docs.microsoft.com. 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. Get the constant buffers used by the hull-shader stage. Type: UINT 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). Read more on docs.microsoft.com. Type: UINT Number of buffers to retrieve (ranges from 0 to D3D11_COMMONSHADER_CONSTANT_BUFFER_API_SLOT_COUNT - StartSlot). Read more on docs.microsoft.com. Type: ID3D11Buffer** Array of constant buffer interface pointers (see ID3D11Buffer) to be returned by the method. Read more on docs.microsoft.com. 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. Get the domain-shader resources. Type: UINT 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). Read more on docs.microsoft.com. Type: UINT 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). Read more on docs.microsoft.com. Type: ID3D11ShaderResourceView** Array of shader resource view interfaces to be returned by the device. Read more on docs.microsoft.com. 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. Get the domain shader currently set on the device. Type: ID3D11DomainShader** Address of a pointer to a domain shader (see ID3D11DomainShader) to be returned by the method. Read more on docs.microsoft.com. Type: ID3D11ClassInstance** Pointer to an array of class instance interfaces (see ID3D11ClassInstance). Read more on docs.microsoft.com. Type: UINT* The number of class-instance elements in the array. Read more on docs.microsoft.com. 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. Get an array of sampler state interfaces from the domain-shader stage. Type: UINT Index into a zero-based array to begin getting samplers from (ranges from 0 to D3D11_COMMONSHADER_SAMPLER_SLOT_COUNT - 1). Read more on docs.microsoft.com. Type: UINT 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). Read more on docs.microsoft.com. Type: ID3D11SamplerState** Pointer to an array of sampler-state interfaces (see ID3D11SamplerState). Read more on docs.microsoft.com. 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. Get the constant buffers used by the domain-shader stage. Type: UINT 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). Read more on docs.microsoft.com. Type: UINT Number of buffers to retrieve (ranges from 0 to D3D11_COMMONSHADER_CONSTANT_BUFFER_API_SLOT_COUNT - StartSlot). Read more on docs.microsoft.com. Type: ID3D11Buffer** Array of constant buffer interface pointers (see ID3D11Buffer) to be returned by the method. Read more on docs.microsoft.com. 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. Get the compute-shader resources. Type: UINT 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). Read more on docs.microsoft.com. Type: UINT 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). Read more on docs.microsoft.com. Type: ID3D11ShaderResourceView** Array of shader resource view interfaces to be returned by the device. Read more on docs.microsoft.com. 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. Gets an array of views for an unordered resource. Type: UINT Index of the first element in the zero-based array to return (ranges from 0 to D3D11_1_UAV_SLOT_COUNT - 1). Read more on docs.microsoft.com. Type: UINT Number of views to get (ranges from 0 to D3D11_1_UAV_SLOT_COUNT - StartSlot). Read more on docs.microsoft.com. Type: ID3D11UnorderedAccessView** A pointer to an array of interface pointers (see ID3D11UnorderedAccessView) to get. Read more on docs.microsoft.com. 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. Get the compute shader currently set on the device. Type: ID3D11ComputeShader** Address of a pointer to a Compute shader (see ID3D11ComputeShader) to be returned by the method. Read more on docs.microsoft.com. Type: ID3D11ClassInstance** Pointer to an array of class instance interfaces (see ID3D11ClassInstance). Read more on docs.microsoft.com. Type: UINT* The number of class-instance elements in the array. Read more on docs.microsoft.com. 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. Get an array of sampler state interfaces from the compute-shader stage. Type: UINT Index into a zero-based array to begin getting samplers from (ranges from 0 to D3D11_COMMONSHADER_SAMPLER_SLOT_COUNT - 1). Read more on docs.microsoft.com. Type: UINT 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). Read more on docs.microsoft.com. Type: ID3D11SamplerState** Pointer to an array of sampler-state interfaces (see ID3D11SamplerState). Read more on docs.microsoft.com. 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. Get the constant buffers used by the compute-shader stage. Type: UINT 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). Read more on docs.microsoft.com. Type: UINT Number of buffers to retrieve (ranges from 0 to D3D11_COMMONSHADER_CONSTANT_BUFFER_API_SLOT_COUNT - StartSlot). Read more on docs.microsoft.com. Type: ID3D11Buffer** Array of constant buffer interface pointers (see ID3D11Buffer) to be returned by the method. Read more on docs.microsoft.com. 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. 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. Read more on docs.microsoft.com. 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.

Deferred Destruction Issues with Flip Presentation Swap Chains

Direct3D 11 defers the destruction of objects like views and resources until it can efficiently destroy them. This deferred destruction can cause problems with flip presentation model swap chains. Flip presentation model swap chains have the DXGI_SWAP_EFFECT_FLIP_SEQUENTIAL flag set. When you create a flip presentation model swap chain, you can associate only one swap chain at a time with an HWND, IWindow, or composition surface. If an application attempts to destroy a flip presentation model swap chain and replace it with another swap chain, the original swap chain is not destroyed when the application immediately frees all of the original swap chain's references. Most applications typically use the IDXGISwapChain::ResizeBuffers method for the majority of scenarios where they replace new swap chain buffers for old swap chain buffers. However, if an application must actually destroy an old swap chain and create a new swap chain, the application must force the destruction of all objects that the application freed. To force the destruction, call ID3D11DeviceContext::ClearState (or otherwise ensure no views are bound to pipeline state), and then call Flush on the immediate context. You must force destruction before you call IDXGIFactory2::CreateSwapChainForHwnd, IDXGIFactory2::CreateSwapChainForCoreWindow, or IDXGIFactory2::CreateSwapChainForComposition again to create a new swap chain. Read more on docs.microsoft.com. Gets the type of device context. Type: D3D11_DEVICE_CONTEXT_TYPE A member of D3D11_DEVICE_CONTEXT_TYPE that indicates the type of device context. Learn more about this API from docs.microsoft.com. Gets the initialization flags associated with the current deferred context. 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. Create a command list and record graphics commands into it. Type: BOOL 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.
 
 Read more on docs.microsoft.com. Type: ID3D11CommandList** Upon completion of the method, the passed pointer to an ID3D11CommandList interface pointer is initialized with the recorded command list information. The resulting ID3D11CommandList object is immutable and can only be used with ID3D11DeviceContext::ExecuteCommandList. Read more on docs.microsoft.com. Type: HRESULT Returns S_OK if successful; otherwise, returns one of the following: This doc was truncated. 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. Read more on docs.microsoft.com. The IID guid for this interface. {c0bfa96c-e089-44fb-8eaf-26f8796190da} The IID guid for this interface. {f582c508-0f36-490c-9977-31eece268cfa} The IID guid for this interface. {38325b96-effb-4022-ba02-2e795b70275c} The IID guid for this interface. {8e5c6061-628a-4c8e-8264-bbe45cb3d5dd} The IID guid for this interface. {e4819ddc-4cf0-4025-bd26-5de82a3e07b7} The IID guid for this interface. {ea82e40d-51dc-4f33-93d4-db7c9125ae8c} The IID guid for this interface. {9eb576dd-9f77-4d86-81aa-8bab5fe490e2} Get a query description. (ID3D11Query.GetDesc) Type: D3D11_QUERY_DESC* Pointer to a query description (see D3D11_QUERY_DESC). Read more on docs.microsoft.com. Learn more about this API from docs.microsoft.com. The IID guid for this interface. {d6c00747-87b7-425e-b84d-44d108560afd} Gets the description for rasterizer state that you used to create the rasterizer-state object. (ID3D11RasterizerState.GetDesc) Type: D3D11_RASTERIZER_DESC* A pointer to a D3D11_RASTERIZER_DESC structure that receives a description of the rasterizer state. Read more on docs.microsoft.com. You use the description for rasterizer state in a call to the ID3D11Device::CreateRasterizerState method to create the rasterizer-state object. The IID guid for this interface. {9bb4ab81-ab1a-4d8f-b506-fc04200b6ee7} Get the properties of a render target view. (ID3D11RenderTargetView.GetDesc) Type: D3D11_RENDER_TARGET_VIEW_DESC* Pointer to the description of a render target view (see D3D11_RENDER_TARGET_VIEW_DESC). Read more on docs.microsoft.com. Learn more about this API from docs.microsoft.com. The IID guid for this interface. {dfdba067-0b8d-4865-875b-d7b4516cc164} Get the type of the resource. (ID3D11Resource.GetType) Type: D3D11_RESOURCE_DIMENSION* Pointer to the resource type (see D3D11_RESOURCE_DIMENSION). Read more on docs.microsoft.com. Windows Phone 8: This API is supported. Read more on docs.microsoft.com. Set the eviction priority of a resource. (ID3D11Resource.SetEvictionPriority) Type: UINT 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. Read more on docs.microsoft.com. Get the eviction priority of a resource. (ID3D11Resource.GetEvictionPriority) Type: UINT One of the following values, which specifies the eviction priority for the resource: This doc was truncated. Learn more about this API from docs.microsoft.com. The IID guid for this interface. {dc8e63f3-d12b-4952-b47b-5e45026a862d} Gets the description for sampler state that you used to create the sampler-state object. Type: D3D11_SAMPLER_DESC* A pointer to a D3D11_SAMPLER_DESC structure that receives a description of the sampler state. Read more on docs.microsoft.com. You use the description for sampler state in a call to the ID3D11Device::CreateSamplerState method to create the sampler-state object. The IID guid for this interface. {da6fea51-564c-4487-9810-f0d0f9b4e3a5} Get the shader resource view's description. (ID3D11ShaderResourceView.GetDesc) Type: D3D11_SHADER_RESOURCE_VIEW_DESC* A pointer to a D3D11_SHADER_RESOURCE_VIEW_DESC structure to be filled with data about the shader resource view. Read more on docs.microsoft.com. Learn more about this API from docs.microsoft.com. The IID guid for this interface. {b0e06fe0-8192-4e1a-b1ca-36d7414710b2} Get the properties of the texture resource. (ID3D11Texture1D.GetDesc) Type: D3D11_TEXTURE1D_DESC* Pointer to a resource description (see D3D11_TEXTURE1D_DESC). Read more on docs.microsoft.com. Learn more about this API from docs.microsoft.com. The IID guid for this interface. {f8fb5c27-c6b3-4f75-a4c8-439af2ef564c} Get the properties of the texture resource. (ID3D11Texture2D.GetDesc) Type: D3D11_TEXTURE2D_DESC* Pointer to a resource description (see D3D11_TEXTURE2D_DESC). Read more on docs.microsoft.com. Learn more about this API from docs.microsoft.com. The IID guid for this interface. {6f15aaf2-d208-4e89-9ab4-489535d34f9c} Get the properties of the texture resource. (ID3D11Texture3D.GetDesc) Type: D3D11_TEXTURE3D_DESC* Pointer to a resource description (see D3D11_TEXTURE3D_DESC). Read more on docs.microsoft.com. Learn more about this API from docs.microsoft.com. The IID guid for this interface. {037e866e-f56d-4357-a8af-9dabbe6e250e} Get a description of the resource. Type: D3D11_UNORDERED_ACCESS_VIEW_DESC* Pointer to a resource description (see D3D11_UNORDERED_ACCESS_VIEW_DESC.) Read more on docs.microsoft.com. Learn more about this API from docs.microsoft.com. The IID guid for this interface. {28acf509-7f5c-48f6-8611-f316010a6380} The IID guid for this interface. {3b301d64-d678-4289-8897-22f8928b72f3} Get the resource that is accessed through this view. (ID3D11View.GetResource) Type: ID3D11Resource** Address of a pointer to the resource that is accessed through this view. (See ID3D11Resource.) Read more on docs.microsoft.com. This function increments the reference count of the resource by one, so it is necessary to call Release on the returned pointer when the application is done with it. Destroying (or losing) the returned pointer before Release is called will result in a memory leak. The IID guid for this interface. {839d1216-bb2e-412b-b7f4-a9dbebe08ed1} Driver type options. The driver type is required when calling D3D11CreateDevice or D3D11CreateDeviceAndSwapChain. The driver type is unknown. A hardware driver, which implements Direct3D features in hardware. This is the primary driver that you should use in your Direct3D applications because it provides the best performance. A hardware driver uses hardware acceleration (on supported hardware) but can also use software for parts of the pipeline that are not supported in hardware. This driver type is often referred to as a hardware abstraction layer or HAL. A reference driver, which is a software implementation that supports every Direct3D feature. A reference driver is designed for accuracy rather than speed and as a result is slow but accurate. The rasterizer portion of the driver does make use of special CPU instructions whenever it can, but it is not intended for retail applications; use it only for feature testing, demonstration of functionality, debugging, or verifying bugs in other drivers. The reference device for this driver is installed by the Windows SDK 8.0 or later and is intended only as a debug aid for development purposes. This driver may be referred to as a REF driver, a reference driver, or a reference rasterizer.
Note  When you use the REF driver in Windows Store apps, the REF driver renders correctly but doesn't display any output on the screen. To verify bugs in hardware drivers for Windows Store apps, use D3D_DRIVER_TYPE_WARP for the WARP driver instead.
 
 Read more on docs.microsoft.com. A NULL driver, which is a reference driver without render capability. This driver is commonly used for debugging non-rendering API calls, it is not appropriate for retail applications. This driver is installed by the DirectX SDK. A software driver, which is a driver implemented completely in software. The software implementation is not intended for a high-performance application due to its very slow performance. A WARP driver, which is a high-performance software rasterizer. The rasterizer supports feature levels 9_1 through level 10_1 with a high performance software implementation. For information about limitations creating a WARP device on certain feature levels, see Limitations Creating WARP and Reference Devices. For more information about using a WARP driver, see Windows Advanced Rasterization Platform (WARP) In-Depth Guide.
Note  The WARP driver that Windows 8 includes supports feature levels 9_1 through level 11_1.
 
Note  The WARP driver that Windows 8.1 includes fully supports feature level 11_1, including tiled resources, IDXGIDevice3::Trim, shared BCn surfaces, minblend, and map default.
 
 Read more on docs.microsoft.com. Describes the set of features targeted by a Direct3D device. For an overview of the capabilities of each feature level, see [Direct3D feature levels](/windows/desktop/direct3d11/overviews-direct3d-11-devices-downlevel-intro). For information about limitations creating non-hardware-type devices on certain feature levels, see [Limitations creating WARP and reference devices](/windows/desktop/direct3d11/overviews-direct3d-11-devices-limitations). Read more on docs.microsoft.com. Allows Microsoft Compute Driver Model (MCDM) devices to be used, or more feature-rich devices (such as traditional GPUs) that support a superset of the functionality. MCDM is the overall driver model for compute-only; it's a scaled-down peer of the larger scoped Windows Device Driver Model (WDDM). Targets features supported by [feature level](/windows/desktop/direct3d11/overviews-direct3d-11-devices-downlevel-intro) 9.1, including shader model 2. Targets features supported by [feature level](/windows/desktop/direct3d11/overviews-direct3d-11-devices-downlevel-intro) 9.2, including shader model 2. Targets features supported by [feature level](/windows/desktop/direct3d11/overviews-direct3d-11-devices-downlevel-intro) 9.3, including shader model 2.0b. Targets features supported by Direct3D 10.0, including shader model 4. Targets features supported by Direct3D 10.1, including shader model 4. Targets features supported by Direct3D 11.0, including shader model 5. Targets features supported by Direct3D 11.1, including shader model 5 and logical blend operations. This feature level requires a display driver that is at least implemented to WDDM for Windows 8 (WDDM 1.2). Targets features supported by Direct3D 12.0, including shader model 5. Targets features supported by Direct3D 12.1, including shader model 5. Targets features supported by Direct3D 12.2, including shader model 6.5. For more information about feature level 12_2, see its [specification page](https://microsoft.github.io/DirectX-Specs/d3d/D3D12_FeatureLevel12_2.html). Feature level 12_2 is available in Windows SDK builds 20170 and later. Values that indicate how the pipeline interprets vertex data that is bound to the input-assembler stage. These primitive topology values determine how the vertex data is rendered on screen. Use the ID3D11DeviceContext::IASetPrimitiveTopology method and a value from D3D_PRIMITIVE_TOPOLOGY to bind a primitive topology to the input-assembler stage. Use the ID3D11DeviceContext::IAGetPrimitiveTopology method to retrieve the primitive topology for the input-assembler stage. The following diagram shows the various primitive types for a geometry shader object. This doc was truncated. Read more on docs.microsoft.com. The IA stage has not been initialized with a primitive topology. The IA stage will not function properly unless a primitive topology is defined. Interpret the vertex data as a list of points. Interpret the vertex data as a list of lines. Interpret the vertex data as a line strip. Interpret the vertex data as a list of triangles. Interpret the vertex data as a triangle strip. Interpret the vertex data as a list of lines with adjacency data. Interpret the vertex data as a line strip with adjacency data. Interpret the vertex data as a list of triangles with adjacency data. Interpret the vertex data as a triangle strip with adjacency data. Interpret the vertex data as a patch list. Interpret the vertex data as a patch list. Interpret the vertex data as a patch list. Interpret the vertex data as a patch list. Interpret the vertex data as a patch list. Interpret the vertex data as a patch list. Interpret the vertex data as a patch list. Interpret the vertex data as a patch list. Interpret the vertex data as a patch list. Interpret the vertex data as a patch list. Interpret the vertex data as a patch list. Interpret the vertex data as a patch list. Interpret the vertex data as a patch list. Interpret the vertex data as a patch list. Interpret the vertex data as a patch list. Interpret the vertex data as a patch list. Interpret the vertex data as a patch list. Interpret the vertex data as a patch list. Interpret the vertex data as a patch list. Interpret the vertex data as a patch list. Interpret the vertex data as a patch list. Interpret the vertex data as a patch list. Interpret the vertex data as a patch list. Interpret the vertex data as a patch list. Interpret the vertex data as a patch list. Interpret the vertex data as a patch list. Interpret the vertex data as a patch list. Interpret the vertex data as a patch list. Interpret the vertex data as a patch list. Interpret the vertex data as a patch list. Interpret the vertex data as a patch list. Interpret the vertex data as a patch list. The IA stage has not been initialized with a primitive topology. The IA stage will not function properly unless a primitive topology is defined. Interpret the vertex data as a list of points. Interpret the vertex data as a list of lines. Interpret the vertex data as a line strip. Interpret the vertex data as a list of triangles. Interpret the vertex data as a triangle strip. Interpret the vertex data as a list of lines with adjacency data. Interpret the vertex data as a line strip with adjacency data. Interpret the vertex data as a list of triangles with adjacency data. Interpret the vertex data as a triangle strip with adjacency data. The IA stage has not been initialized with a primitive topology. The IA stage will not function properly unless a primitive topology is defined. Interpret the vertex data as a list of points. Interpret the vertex data as a list of lines. Interpret the vertex data as a line strip. Interpret the vertex data as a list of triangles. Interpret the vertex data as a triangle strip. Interpret the vertex data as a list of lines with adjacency data. Interpret the vertex data as a line strip with adjacency data. Interpret the vertex data as a list of triangles with adjacency data. Interpret the vertex data as a triangle strip with adjacency data. Interpret the vertex data as a patch list. Interpret the vertex data as a patch list. Interpret the vertex data as a patch list. Interpret the vertex data as a patch list. Interpret the vertex data as a patch list. Interpret the vertex data as a patch list. Interpret the vertex data as a patch list. Interpret the vertex data as a patch list. Interpret the vertex data as a patch list. Interpret the vertex data as a patch list. Interpret the vertex data as a patch list. Interpret the vertex data as a patch list. Interpret the vertex data as a patch list. Interpret the vertex data as a patch list. Interpret the vertex data as a patch list. Interpret the vertex data as a patch list. Interpret the vertex data as a patch list. Interpret the vertex data as a patch list. Interpret the vertex data as a patch list. Interpret the vertex data as a patch list. Interpret the vertex data as a patch list. Interpret the vertex data as a patch list. Interpret the vertex data as a patch list. Interpret the vertex data as a patch list. Interpret the vertex data as a patch list. Interpret the vertex data as a patch list. Interpret the vertex data as a patch list. Interpret the vertex data as a patch list. Interpret the vertex data as a patch list. Interpret the vertex data as a patch list. Interpret the vertex data as a patch list. Interpret the vertex data as a patch list. Values that identify the type of resource to be viewed as a shader resource. A D3D_SRV_DIMENSION-typed value is specified in the ViewDimension member of the D3D11_SHADER_RESOURCE_VIEW_DESC structure or the Dimension member of the D3D11_SHADER_INPUT_BIND_DESC structure. The type is unknown. The resource is a buffer. The resource is a 1D texture. The resource is an array of 1D textures. The resource is a 2D texture. The resource is an array of 2D textures. The resource is a multisampling 2D texture. The resource is an array of multisampling 2D textures. The resource is a 3D texture. The resource is a cube texture. The resource is an array of cube textures. The resource is a raw buffer. For more info about raw viewing of buffers, see Raw Views of Buffers. The type is unknown. The resource is a buffer. The resource is a 1D texture. The resource is an array of 1D textures. The resource is a 2D texture. The resource is an array of 2D textures. The resource is a multisampling 2D texture. The resource is an array of multisampling 2D textures. The resource is a 3D texture. The resource is a cube texture. The type is unknown. The resource is a buffer. The resource is a 1D texture. The resource is an array of 1D textures. The resource is a 2D texture. The resource is an array of 2D textures. The resource is a multisampling 2D texture. The resource is an array of multisampling 2D textures. The resource is a 3D texture. The resource is a cube texture. The resource is an array of cube textures. The type is unknown. The resource is a buffer. The resource is a 1D texture. The resource is an array of 1D textures. The resource is a 2D texture. The resource is an array of 2D textures. The resource is a multisampling 2D texture. The resource is an array of multisampling 2D textures. The resource is a 3D texture. The resource is a cube texture. The resource is an array of cube textures. The resource is a raw buffer. For more info about raw viewing of buffers, see Raw Views of Buffers. Describes an adapter (or video card) by using DXGI 1.0. The DXGI_ADAPTER_DESC structure provides a description of an adapter. This structure is initialized by using the IDXGIAdapter::GetDesc method. Type: WCHAR[128] A string that contains the adapter description. On feature level 9 graphics hardware, GetDesc returns “Software Adapter” for the description string. Read more on docs.microsoft.com. Type: UINT The PCI ID of the hardware vendor. On feature level 9 graphics hardware, GetDesc returns zeros for the PCI ID of the hardware vendor. Read more on docs.microsoft.com. Type: UINT The PCI ID of the hardware device. On feature level 9 graphics hardware, GetDesc returns zeros for the PCI ID of the hardware device. Read more on docs.microsoft.com. Type: UINT The PCI ID of the sub system. On feature level 9 graphics hardware, GetDesc returns zeros for the PCI ID of the sub system. Read more on docs.microsoft.com. Type: UINT The PCI ID of the revision number of the adapter. On feature level 9 graphics hardware, GetDesc returns zeros for the PCI ID of the revision number of the adapter. Read more on docs.microsoft.com. Type: SIZE_T The number of bytes of dedicated video memory that are not shared with the CPU. Read more on docs.microsoft.com. Type: SIZE_T The number of bytes of dedicated system memory that are not shared with the CPU. This memory is allocated from available system memory at boot time. Read more on docs.microsoft.com. Type: SIZE_T The number of bytes of shared system memory. This is the maximum value of system memory that may be consumed by the adapter during operation. Any incidental memory consumed by the driver as it manages and uses video memory is additional. Read more on docs.microsoft.com. Type: LUID A unique value that identifies the adapter. See LUID for a definition of the structure. LUID is defined in dxgi.h. Read more on docs.microsoft.com. Describes an adapter (or video card) using DXGI 1.1. The DXGI_ADAPTER_DESC1 structure provides a DXGI 1.1 description of an adapter. This structure is initialized by using the IDXGIAdapter1::GetDesc1 method. Type: WCHAR[128] A string that contains the adapter description. On feature level 9 graphics hardware, GetDesc1 returns “Software Adapter” for the description string. Read more on docs.microsoft.com. Type: UINT The PCI ID of the hardware vendor. On feature level 9 graphics hardware, GetDesc1 returns zeros for the PCI ID of the hardware vendor. Read more on docs.microsoft.com. Type: UINT The PCI ID of the hardware device. On feature level 9 graphics hardware, GetDesc1 returns zeros for the PCI ID of the hardware device. Read more on docs.microsoft.com. Type: UINT The PCI ID of the sub system. On feature level 9 graphics hardware, GetDesc1 returns zeros for the PCI ID of the sub system. Read more on docs.microsoft.com. Type: UINT The PCI ID of the revision number of the adapter. On feature level 9 graphics hardware, GetDesc1 returns zeros for the PCI ID of the revision number of the adapter. Read more on docs.microsoft.com. Type: SIZE_T The number of bytes of dedicated video memory that are not shared with the CPU. Read more on docs.microsoft.com. Type: SIZE_T The number of bytes of dedicated system memory that are not shared with the CPU. This memory is allocated from available system memory at boot time. Read more on docs.microsoft.com. Type: SIZE_T The number of bytes of shared system memory. This is the maximum value of system memory that may be consumed by the adapter during operation. Any incidental memory consumed by the driver as it manages and uses video memory is additional. Read more on docs.microsoft.com. Type: LUID A unique value that identifies the adapter. See LUID for a definition of the structure. LUID is defined in dxgi.h. Read more on docs.microsoft.com. Identifies the type of DXGI adapter. (DXGI_ADAPTER_FLAG) The DXGI_ADAPTER_FLAG enumerated type is used by the Flags member of the DXGI_ADAPTER_DESC1 or DXGI_ADAPTER_DESC2 structure to identify the type of DXGI adapter. Read more on docs.microsoft.com. Specifies no flags. Value always set to 0. This flag is reserved. Specifies a software adapter. For more info about this flag, see new info in Windows 8 about enumerating adapters. Direct3D 11:  This enumeration value is supported starting with Windows 8. Read more on docs.microsoft.com. Identifies the alpha value, transparency behavior, of a surface. For more information about alpha mode, see D2D1_ALPHA_MODE. Indicates that the transparency behavior is not specified. Indicates that the transparency behavior is premultiplied. Each color is first scaled by the alpha value. The alpha value itself is the same in both straight and premultiplied alpha. Typically, no color channel value is greater than the alpha channel value. If a color channel value in a premultiplied format is greater than the alpha channel, the standard source-over blending math results in an additive blend. Indicates that the transparency behavior is not premultiplied. The alpha channel indicates the transparency of the color. Indicates to ignore the transparency behavior. Resource data formats, including fully-typed and typeless formats. A list of modifiers at the bottom of the page more fully describes each format type.

Byte Order (LSB/MSB)

Most formats have byte-aligned components, and the components are in C-array order (the least address comes first). For those formats that don't have power-of-2-aligned components, the first named component is in the least-significant bits.

Portable Coding for Endian-Independence

Rather than adjusting for whether a system uses big-endian or little-endian byte ordering, you should write portable code, as follows. This doc was truncated. Read more on docs.microsoft.com. The format is not known. A four-component, 128-bit typeless format that supports 32 bits per channel including alpha. ¹ A four-component, 128-bit floating-point format that supports 32 bits per channel including alpha. 1,5,8 A four-component, 128-bit unsigned-integer format that supports 32 bits per channel including alpha. ¹ A four-component, 128-bit signed-integer format that supports 32 bits per channel including alpha. ¹ A three-component, 96-bit typeless format that supports 32 bits per color channel. A three-component, 96-bit floating-point format that supports 32 bits per color channel.5,8 A three-component, 96-bit unsigned-integer format that supports 32 bits per color channel. A three-component, 96-bit signed-integer format that supports 32 bits per color channel. A four-component, 64-bit typeless format that supports 16 bits per channel including alpha. A four-component, 64-bit floating-point format that supports 16 bits per channel including alpha.5,7 A four-component, 64-bit unsigned-normalized-integer format that supports 16 bits per channel including alpha. A four-component, 64-bit unsigned-integer format that supports 16 bits per channel including alpha. A four-component, 64-bit signed-normalized-integer format that supports 16 bits per channel including alpha. A four-component, 64-bit signed-integer format that supports 16 bits per channel including alpha. A two-component, 64-bit typeless format that supports 32 bits for the red channel and 32 bits for the green channel. A two-component, 64-bit floating-point format that supports 32 bits for the red channel and 32 bits for the green channel.5,8 A two-component, 64-bit unsigned-integer format that supports 32 bits for the red channel and 32 bits for the green channel. A two-component, 64-bit signed-integer format that supports 32 bits for the red channel and 32 bits for the green channel. A two-component, 64-bit typeless format that supports 32 bits for the red channel, 8 bits for the green channel, and 24 bits are unused. A 32-bit floating-point component, and two unsigned-integer components (with an additional 32 bits). This format supports 32-bit depth, 8-bit stencil, and 24 bits are unused.⁵ A 32-bit floating-point component, and two typeless components (with an additional 32 bits). This format supports 32-bit red channel, 8 bits are unused, and 24 bits are unused.⁵ A 32-bit typeless component, and two unsigned-integer components (with an additional 32 bits). This format has 32 bits unused, 8 bits for green channel, and 24 bits are unused. A four-component, 32-bit typeless format that supports 10 bits for each color and 2 bits for alpha. A four-component, 32-bit unsigned-normalized-integer format that supports 10 bits for each color and 2 bits for alpha. A four-component, 32-bit unsigned-integer format that supports 10 bits for each color and 2 bits for alpha. Three partial-precision floating-point numbers encoded into a single 32-bit value (a variant of s10e5, which is sign bit, 10-bit mantissa, and 5-bit biased (15) exponent). There are no sign bits, and there is a 5-bit biased (15) exponent for each channel, 6-bit mantissa for R and G, and a 5-bit mantissa for B, as shown in the following illustration.5,7 This doc was truncated. Read more on docs.microsoft.com. A four-component, 32-bit typeless format that supports 8 bits per channel including alpha. A four-component, 32-bit unsigned-normalized-integer format that supports 8 bits per channel including alpha. A four-component, 32-bit unsigned-normalized integer sRGB format that supports 8 bits per channel including alpha. A four-component, 32-bit unsigned-integer format that supports 8 bits per channel including alpha. A four-component, 32-bit signed-normalized-integer format that supports 8 bits per channel including alpha. A four-component, 32-bit signed-integer format that supports 8 bits per channel including alpha. A two-component, 32-bit typeless format that supports 16 bits for the red channel and 16 bits for the green channel. A two-component, 32-bit floating-point format that supports 16 bits for the red channel and 16 bits for the green channel.5,7 A two-component, 32-bit unsigned-normalized-integer format that supports 16 bits each for the green and red channels. A two-component, 32-bit unsigned-integer format that supports 16 bits for the red channel and 16 bits for the green channel. A two-component, 32-bit signed-normalized-integer format that supports 16 bits for the red channel and 16 bits for the green channel. A two-component, 32-bit signed-integer format that supports 16 bits for the red channel and 16 bits for the green channel. A single-component, 32-bit typeless format that supports 32 bits for the red channel. A single-component, 32-bit floating-point format that supports 32 bits for depth.5,8 A single-component, 32-bit floating-point format that supports 32 bits for the red channel.5,8 A single-component, 32-bit unsigned-integer format that supports 32 bits for the red channel. A single-component, 32-bit signed-integer format that supports 32 bits for the red channel. A two-component, 32-bit typeless format that supports 24 bits for the red channel and 8 bits for the green channel. A 32-bit z-buffer format that supports 24 bits for depth and 8 bits for stencil. A 32-bit format, that contains a 24 bit, single-component, unsigned-normalized integer, with an additional typeless 8 bits. This format has 24 bits red channel and 8 bits unused. A 32-bit format, that contains a 24 bit, single-component, typeless format, with an additional 8 bit unsigned integer component. This format has 24 bits unused and 8 bits green channel. A two-component, 16-bit typeless format that supports 8 bits for the red channel and 8 bits for the green channel. A two-component, 16-bit unsigned-normalized-integer format that supports 8 bits for the red channel and 8 bits for the green channel. A two-component, 16-bit unsigned-integer format that supports 8 bits for the red channel and 8 bits for the green channel. A two-component, 16-bit signed-normalized-integer format that supports 8 bits for the red channel and 8 bits for the green channel. A two-component, 16-bit signed-integer format that supports 8 bits for the red channel and 8 bits for the green channel. A single-component, 16-bit typeless format that supports 16 bits for the red channel. A single-component, 16-bit floating-point format that supports 16 bits for the red channel.5,7 A single-component, 16-bit unsigned-normalized-integer format that supports 16 bits for depth. A single-component, 16-bit unsigned-normalized-integer format that supports 16 bits for the red channel. A single-component, 16-bit unsigned-integer format that supports 16 bits for the red channel. A single-component, 16-bit signed-normalized-integer format that supports 16 bits for the red channel. A single-component, 16-bit signed-integer format that supports 16 bits for the red channel. A single-component, 8-bit typeless format that supports 8 bits for the red channel. A single-component, 8-bit unsigned-normalized-integer format that supports 8 bits for the red channel. A single-component, 8-bit unsigned-integer format that supports 8 bits for the red channel. A single-component, 8-bit signed-normalized-integer format that supports 8 bits for the red channel. A single-component, 8-bit signed-integer format that supports 8 bits for the red channel. A single-component, 8-bit unsigned-normalized-integer format for alpha only. A single-component, 1-bit unsigned-normalized integer format that supports 1 bit for the red channel. ². Three partial-precision floating-point numbers encoded into a single 32-bit value all sharing the same 5-bit exponent (variant of s10e5, which is sign bit, 10-bit mantissa, and 5-bit biased (15) exponent). There is no sign bit, and there is a shared 5-bit biased (15) exponent and a 9-bit mantissa for each channel, as shown in the following illustration. 6,7. This doc was truncated. Read more on docs.microsoft.com. A four-component, 32-bit unsigned-normalized-integer format. This packed RGB format is analogous to the UYVY format. Each 32-bit block describes a pair of pixels: (R8, G8, B8) and (R8, G8, B8) where the R8/B8 values are repeated, and the G8 values are unique to each pixel. ³ Width must be even. Read more on docs.microsoft.com. A four-component, 32-bit unsigned-normalized-integer format. This packed RGB format is analogous to the YUY2 format. Each 32-bit block describes a pair of pixels: (R8, G8, B8) and (R8, G8, B8) where the R8/B8 values are repeated, and the G8 values are unique to each pixel. ³ Width must be even. Read more on docs.microsoft.com. Four-component typeless block-compression format. For information about block-compression formats, see Texture Block Compression in Direct3D 11. Four-component block-compression format. For information about block-compression formats, see Texture Block Compression in Direct3D 11. Four-component block-compression format for sRGB data. For information about block-compression formats, see Texture Block Compression in Direct3D 11. Four-component typeless block-compression format. For information about block-compression formats, see Texture Block Compression in Direct3D 11. Four-component block-compression format. For information about block-compression formats, see Texture Block Compression in Direct3D 11. Four-component block-compression format for sRGB data. For information about block-compression formats, see Texture Block Compression in Direct3D 11. Four-component typeless block-compression format. For information about block-compression formats, see Texture Block Compression in Direct3D 11. Four-component block-compression format. For information about block-compression formats, see Texture Block Compression in Direct3D 11. Four-component block-compression format for sRGB data. For information about block-compression formats, see Texture Block Compression in Direct3D 11. One-component typeless block-compression format. For information about block-compression formats, see Texture Block Compression in Direct3D 11. One-component block-compression format. For information about block-compression formats, see Texture Block Compression in Direct3D 11. One-component block-compression format. For information about block-compression formats, see Texture Block Compression in Direct3D 11. Two-component typeless block-compression format. For information about block-compression formats, see Texture Block Compression in Direct3D 11. Two-component block-compression format. For information about block-compression formats, see Texture Block Compression in Direct3D 11. Two-component block-compression format. For information about block-compression formats, see Texture Block Compression in Direct3D 11. A three-component, 16-bit unsigned-normalized-integer format that supports 5 bits for blue, 6 bits for green, and 5 bits for red. Direct3D 10 through Direct3D 11:  This value is defined for DXGI. However, Direct3D 10, 10.1, or 11 devices do not support this format. Direct3D 11.1:  This value is not supported until Windows 8. Read more on docs.microsoft.com. A four-component, 16-bit unsigned-normalized-integer format that supports 5 bits for each color channel and 1-bit alpha. Direct3D 10 through Direct3D 11:  This value is defined for DXGI. However, Direct3D 10, 10.1, or 11 devices do not support this format. Direct3D 11.1:  This value is not supported until Windows 8. Read more on docs.microsoft.com. A four-component, 32-bit unsigned-normalized-integer format that supports 8 bits for each color channel and 8-bit alpha. A four-component, 32-bit unsigned-normalized-integer format that supports 8 bits for each color channel and 8 bits unused. A four-component, 32-bit 2.8-biased fixed-point format that supports 10 bits for each color channel and 2-bit alpha. A four-component, 32-bit typeless format that supports 8 bits for each channel including alpha. ⁴ A four-component, 32-bit unsigned-normalized standard RGB format that supports 8 bits for each channel including alpha. ⁴ A four-component, 32-bit typeless format that supports 8 bits for each color channel, and 8 bits are unused. ⁴ A four-component, 32-bit unsigned-normalized standard RGB format that supports 8 bits for each color channel, and 8 bits are unused. ⁴ A typeless block-compression format. ⁴ For information about block-compression formats, see Texture Block Compression in Direct3D 11. A block-compression format. ⁴ For information about block-compression formats, see Texture Block Compression in Direct3D 11.⁵ A block-compression format. ⁴ For information about block-compression formats, see Texture Block Compression in Direct3D 11.⁵ A typeless block-compression format. ⁴ For information about block-compression formats, see Texture Block Compression in Direct3D 11. A block-compression format. ⁴ For information about block-compression formats, see Texture Block Compression in Direct3D 11. A block-compression format. ⁴ For information about block-compression formats, see Texture Block Compression in Direct3D 11. Most common YUV 4:4:4 video resource format. Valid view formats for this video resource format are DXGI_FORMAT_R8G8B8A8_UNORM and DXGI_FORMAT_R8G8B8A8_UINT. For UAVs, an additional valid view format is DXGI_FORMAT_R32_UINT. By using DXGI_FORMAT_R32_UINT for UAVs, you can both read and write as opposed to just write for DXGI_FORMAT_R8G8B8A8_UNORM and DXGI_FORMAT_R8G8B8A8_UINT. Supported view types are SRV, RTV, and UAV. One view provides a straightforward mapping of the entire surface. The mapping to the view channel is V->R8, U->G8, Y->B8, and A->A8. For more info about YUV formats for video rendering, see Recommended 8-Bit YUV Formats for Video Rendering. Direct3D 11.1:  This value is not supported until Windows 8. Read more on docs.microsoft.com. 10-bit per channel packed YUV 4:4:4 video resource format. Valid view formats for this video resource format are DXGI_FORMAT_R10G10B10A2_UNORM and DXGI_FORMAT_R10G10B10A2_UINT. For UAVs, an additional valid view format is DXGI_FORMAT_R32_UINT. By using DXGI_FORMAT_R32_UINT for UAVs, you can both read and write as opposed to just write for DXGI_FORMAT_R10G10B10A2_UNORM and DXGI_FORMAT_R10G10B10A2_UINT. Supported view types are SRV and UAV. One view provides a straightforward mapping of the entire surface. The mapping to the view channel is U->R10, Y->G10, V->B10, and A->A2. For more info about YUV formats for video rendering, see Recommended 8-Bit YUV Formats for Video Rendering. Direct3D 11.1:  This value is not supported until Windows 8. Read more on docs.microsoft.com. 16-bit per channel packed YUV 4:4:4 video resource format. Valid view formats for this video resource format are DXGI_FORMAT_R16G16B16A16_UNORM and DXGI_FORMAT_R16G16B16A16_UINT. Supported view types are SRV and UAV. One view provides a straightforward mapping of the entire surface. The mapping to the view channel is U->R16, Y->G16, V->B16, and A->A16. For more info about YUV formats for video rendering, see Recommended 8-Bit YUV Formats for Video Rendering. Direct3D 11.1:  This value is not supported until Windows 8. Read more on docs.microsoft.com. Most common YUV 4:2:0 video resource format. Valid luminance data view formats for this video resource format are DXGI_FORMAT_R8_UNORM and DXGI_FORMAT_R8_UINT. Valid chrominance data view formats (width and height are each 1/2 of luminance view) for this video resource format are DXGI_FORMAT_R8G8_UNORM and DXGI_FORMAT_R8G8_UINT. Supported view types are SRV, RTV, and UAV. For luminance data view, the mapping to the view channel is Y->R8. For chrominance data view, the mapping to the view channel is U->R8 and V->G8. For more info about YUV formats for video rendering, see Recommended 8-Bit YUV Formats for Video Rendering. Width and height must be even. Direct3D 11 staging resources and initData parameters for this format use (rowPitch * (height + (height / 2))) bytes. The first (SysMemPitch * height) bytes are the Y plane, the remaining (SysMemPitch * (height / 2)) bytes are the UV plane. An app using the YUY 4:2:0 formats must map the luma (Y) plane separately from the chroma (UV) planes. Developers do this by calling ID3D12Device::CreateShaderResourceView twice for the same texture and passing in 1-channel and 2-channel formats. Passing in a 1-channel format compatible with the Y plane maps only the Y plane. Passing in a 2-channel format compatible with the UV planes (together) maps only the U and V planes as a single resource view. Direct3D 11.1:  This value is not supported until Windows 8. Read more on docs.microsoft.com. 10-bit per channel planar YUV 4:2:0 video resource format. Valid luminance data view formats for this video resource format are DXGI_FORMAT_R16_UNORM and DXGI_FORMAT_R16_UINT. The runtime does not enforce whether the lowest 6 bits are 0 (given that this video resource format is a 10-bit format that uses 16 bits). If required, application shader code would have to enforce this manually. From the runtime's point of view, DXGI_FORMAT_P010 is no different than DXGI_FORMAT_P016. Valid chrominance data view formats (width and height are each 1/2 of luminance view) for this video resource format are DXGI_FORMAT_R16G16_UNORM and DXGI_FORMAT_R16G16_UINT. For UAVs, an additional valid chrominance data view format is DXGI_FORMAT_R32_UINT. By using DXGI_FORMAT_R32_UINT for UAVs, you can both read and write as opposed to just write for DXGI_FORMAT_R16G16_UNORM and DXGI_FORMAT_R16G16_UINT. Supported view types are SRV, RTV, and UAV. For luminance data view, the mapping to the view channel is Y->R16. For chrominance data view, the mapping to the view channel is U->R16 and V->G16. For more info about YUV formats for video rendering, see Recommended 8-Bit YUV Formats for Video Rendering. Width and height must be even. Direct3D 11 staging resources and initData parameters for this format use (rowPitch * (height + (height / 2))) bytes. The first (SysMemPitch * height) bytes are the Y plane, the remaining (SysMemPitch * (height / 2)) bytes are the UV plane. An app using the YUY 4:2:0 formats must map the luma (Y) plane separately from the chroma (UV) planes. Developers do this by calling ID3D12Device::CreateShaderResourceView twice for the same texture and passing in 1-channel and 2-channel formats. Passing in a 1-channel format compatible with the Y plane maps only the Y plane. Passing in a 2-channel format compatible with the UV planes (together) maps only the U and V planes as a single resource view. Direct3D 11.1:  This value is not supported until Windows 8. Read more on docs.microsoft.com. 16-bit per channel planar YUV 4:2:0 video resource format. Valid luminance data view formats for this video resource format are DXGI_FORMAT_R16_UNORM and DXGI_FORMAT_R16_UINT. Valid chrominance data view formats (width and height are each 1/2 of luminance view) for this video resource format are DXGI_FORMAT_R16G16_UNORM and DXGI_FORMAT_R16G16_UINT. For UAVs, an additional valid chrominance data view format is DXGI_FORMAT_R32_UINT. By using DXGI_FORMAT_R32_UINT for UAVs, you can both read and write as opposed to just write for DXGI_FORMAT_R16G16_UNORM and DXGI_FORMAT_R16G16_UINT. Supported view types are SRV, RTV, and UAV. For luminance data view, the mapping to the view channel is Y->R16. For chrominance data view, the mapping to the view channel is U->R16 and V->G16. For more info about YUV formats for video rendering, see Recommended 8-Bit YUV Formats for Video Rendering. Width and height must be even. Direct3D 11 staging resources and initData parameters for this format use (rowPitch * (height + (height / 2))) bytes. The first (SysMemPitch * height) bytes are the Y plane, the remaining (SysMemPitch * (height / 2)) bytes are the UV plane. An app using the YUY 4:2:0 formats must map the luma (Y) plane separately from the chroma (UV) planes. Developers do this by calling ID3D12Device::CreateShaderResourceView twice for the same texture and passing in 1-channel and 2-channel formats. Passing in a 1-channel format compatible with the Y plane maps only the Y plane. Passing in a 2-channel format compatible with the UV planes (together) maps only the U and V planes as a single resource view. Direct3D 11.1:  This value is not supported until Windows 8. Read more on docs.microsoft.com. 8-bit per channel planar YUV 4:2:0 video resource format. This format is subsampled where each pixel has its own Y value, but each 2x2 pixel block shares a single U and V value. The runtime requires that the width and height of all resources that are created with this format are multiples of 2. The runtime also requires that the left, right, top, and bottom members of any RECT that are used for this format are multiples of 2. This format differs from DXGI_FORMAT_NV12 in that the layout of the data within the resource is completely opaque to applications. Applications cannot use the CPU to map the resource and then access the data within the resource. You cannot use shaders with this format. Because of this behavior, legacy hardware that supports a non-NV12 4:2:0 layout (for example, YV12, and so on) can be used. Also, new hardware that has a 4:2:0 implementation better than NV12 can be used when the application does not need the data to be in a standard layout. For more info about YUV formats for video rendering, see Recommended 8-Bit YUV Formats for Video Rendering. Width and height must be even. Direct3D 11 staging resources and initData parameters for this format use (rowPitch * (height + (height / 2))) bytes. An app using the YUY 4:2:0 formats must map the luma (Y) plane separately from the chroma (UV) planes. Developers do this by calling ID3D12Device::CreateShaderResourceView twice for the same texture and passing in 1-channel and 2-channel formats. Passing in a 1-channel format compatible with the Y plane maps only the Y plane. Passing in a 2-channel format compatible with the UV planes (together) maps only the U and V planes as a single resource view. Direct3D 11.1:  This value is not supported until Windows 8. Read more on docs.microsoft.com. Most common YUV 4:2:2 video resource format. Valid view formats for this video resource format are DXGI_FORMAT_R8G8B8A8_UNORM and DXGI_FORMAT_R8G8B8A8_UINT. For UAVs, an additional valid view format is DXGI_FORMAT_R32_UINT. By using DXGI_FORMAT_R32_UINT for UAVs, you can both read and write as opposed to just write for DXGI_FORMAT_R8G8B8A8_UNORM and DXGI_FORMAT_R8G8B8A8_UINT. Supported view types are SRV and UAV. One view provides a straightforward mapping of the entire surface. The mapping to the view channel is Y0->R8, U0->G8, Y1->B8, and V0->A8. A unique valid view format for this video resource format is DXGI_FORMAT_R8G8_B8G8_UNORM. With this view format, the width of the view appears to be twice what the DXGI_FORMAT_R8G8B8A8_UNORM or DXGI_FORMAT_R8G8B8A8_UINT view would be when hardware reconstructs RGBA automatically on read and before filtering. This Direct3D hardware behavior is legacy and is likely not useful any more. With this view format, the mapping to the view channel is Y0->R8, U0-> G8[0], Y1->B8, and V0-> G8[1]. For more info about YUV formats for video rendering, see Recommended 8-Bit YUV Formats for Video Rendering. Width must be even. Direct3D 11.1:  This value is not supported until Windows 8. Read more on docs.microsoft.com. 10-bit per channel packed YUV 4:2:2 video resource format. Valid view formats for this video resource format are DXGI_FORMAT_R16G16B16A16_UNORM and DXGI_FORMAT_R16G16B16A16_UINT. The runtime does not enforce whether the lowest 6 bits are 0 (given that this video resource format is a 10-bit format that uses 16 bits). If required, application shader code would have to enforce this manually. From the runtime's point of view, DXGI_FORMAT_Y210 is no different than DXGI_FORMAT_Y216. Supported view types are SRV and UAV. One view provides a straightforward mapping of the entire surface. The mapping to the view channel is Y0->R16, U->G16, Y1->B16, and V->A16. For more info about YUV formats for video rendering, see Recommended 8-Bit YUV Formats for Video Rendering. Width must be even. Direct3D 11.1:  This value is not supported until Windows 8. Read more on docs.microsoft.com. 16-bit per channel packed YUV 4:2:2 video resource format. Valid view formats for this video resource format are DXGI_FORMAT_R16G16B16A16_UNORM and DXGI_FORMAT_R16G16B16A16_UINT. Supported view types are SRV and UAV. One view provides a straightforward mapping of the entire surface. The mapping to the view channel is Y0->R16, U->G16, Y1->B16, and V->A16. For more info about YUV formats for video rendering, see Recommended 8-Bit YUV Formats for Video Rendering. Width must be even. Direct3D 11.1:  This value is not supported until Windows 8. Read more on docs.microsoft.com. Most common planar YUV 4:1:1 video resource format. Valid luminance data view formats for this video resource format are DXGI_FORMAT_R8_UNORM and DXGI_FORMAT_R8_UINT. Valid chrominance data view formats (width and height are each 1/4 of luminance view) for this video resource format are DXGI_FORMAT_R8G8_UNORM and DXGI_FORMAT_R8G8_UINT. Supported view types are SRV, RTV, and UAV. For luminance data view, the mapping to the view channel is Y->R8. For chrominance data view, the mapping to the view channel is U->R8 and V->G8. For more info about YUV formats for video rendering, see Recommended 8-Bit YUV Formats for Video Rendering. Width must be a multiple of 4. Direct3D11 staging resources and initData parameters for this format use (rowPitch * height * 2) bytes. The first (SysMemPitch * height) bytes are the Y plane, the next ((SysMemPitch / 2) * height) bytes are the UV plane, and the remainder is padding. Direct3D 11.1:  This value is not supported until Windows 8. Read more on docs.microsoft.com. 4-bit palletized YUV format that is commonly used for DVD subpicture. For more info about YUV formats for video rendering, see Recommended 8-Bit YUV Formats for Video Rendering. Direct3D 11.1:  This value is not supported until Windows 8. Read more on docs.microsoft.com. 4-bit palletized YUV format that is commonly used for DVD subpicture. For more info about YUV formats for video rendering, see Recommended 8-Bit YUV Formats for Video Rendering. Direct3D 11.1:  This value is not supported until Windows 8. Read more on docs.microsoft.com. 8-bit palletized format that is used for palletized RGB data when the processor processes ISDB-T data and for palletized YUV data when the processor processes BluRay data. For more info about YUV formats for video rendering, see Recommended 8-Bit YUV Formats for Video Rendering. Direct3D 11.1:  This value is not supported until Windows 8. Read more on docs.microsoft.com. 8-bit palletized format with 8 bits of alpha that is used for palletized YUV data when the processor processes BluRay data. For more info about YUV formats for video rendering, see Recommended 8-Bit YUV Formats for Video Rendering. Direct3D 11.1:  This value is not supported until Windows 8. Read more on docs.microsoft.com. A four-component, 16-bit unsigned-normalized integer format that supports 4 bits for each channel including alpha. Direct3D 11.1:  This value is not supported until Windows 8. Read more on docs.microsoft.com. A video format; an 8-bit version of a hybrid planar 4:2:2 format. An 8 bit YCbCrA 4:4 rendering format. An 8 bit YCbCrA 4:4:4:4 rendering format. Represents a rational number. This structure is a member of the DXGI_MODE_DESC structure. The DXGI_RATIONAL structure operates under the following rules: This doc was truncated. Read more on docs.microsoft.com. Type: UINT An unsigned integer value representing the top of the rational number. Read more on docs.microsoft.com. Type: UINT An unsigned integer value representing the bottom of the rational number. Read more on docs.microsoft.com. The length of the inline array. Gets this inline array as a span. ⚠ Important ⚠: When this struct is on the stack, do not let the returned span outlive the stack frame that defines it. Gets this inline array as a span. ⚠ Important ⚠: When this struct is on the stack, do not let the returned span outlive the stack frame that defines it. Describes multi-sampling parameters for a resource. This structure is a member of the DXGI_SWAP_CHAIN_DESC1 structure. The default sampler mode, with no anti-aliasing, has a count of 1 and a quality level of 0. If multi-sample antialiasing is being used, all bound render targets and depth buffers must have the same sample counts and quality levels. This doc was truncated. Read more on docs.microsoft.com. Type: UINT The number of multisamples per pixel. Read more on docs.microsoft.com. Type: UINT The image quality level. The higher the quality, the lower the performance. The valid range is between zero and one less than the level returned by ID3D10Device::CheckMultisampleQualityLevels for Direct3D 10 or ID3D11Device::CheckMultisampleQualityLevels for Direct3D 11. For Direct3D 10.1 and Direct3D 11, you can use two special quality level values. For more information about these quality level values, see Remarks. Read more on docs.microsoft.com. Options for enumerating display modes. These flag options are used in [**IDXGIOutput::GetDisplayModeList**](/windows/desktop/api/DXGI/nf-dxgi-idxgioutput-getdisplaymodelist) to enumerate display modes. These flag options are also used in [**IDXGIOutput1::GetDisplayModeList1**](/windows/desktop/api/DXGI1_2/nf-dxgi1_2-idxgioutput1-getdisplaymodelist1) to enumerate display modes. Read more on docs.microsoft.com. Describes timing and presentation statistics for a frame. You initialize the DXGI_FRAME_STATISTICS structure with the IDXGIOutput::GetFrameStatistics or IDXGISwapChain::GetFrameStatistics method. You can only use IDXGISwapChain::GetFrameStatistics for swap chains that either use the flip presentation model or draw in full-screen mode. You set the DXGI_SWAP_EFFECT_FLIP_SEQUENTIAL value in the SwapEffect member of the DXGI_SWAP_CHAIN_DESC1 structure to specify that the swap chain uses the flip presentation model. The values in the PresentCount and PresentRefreshCount members indicate information about when a frame was presented on the display screen. You can use these values to determine whether a glitch occurred. The values in the SyncRefreshCount and SyncQPCTime members indicate timing information that you can use for audio and video synchronization or very precise animation. If the swap chain draws in full-screen mode, these values are based on when the computer booted. If the swap chain draws in windowed mode, these values are based on when the swap chain is created. Read more on docs.microsoft.com. Type: UINT A value that represents the running total count of times that an image was presented to the monitor since the computer booted.
Note  The number of times that an image was presented to the monitor is not necessarily the same as the number of times that you called IDXGISwapChain::Present or IDXGISwapChain1::Present1.
 
 Read more on docs.microsoft.com. Type: UINT A value that represents the running total count of v-blanks at which the last image was presented to the monitor and that have happened since the computer booted (for windowed mode, since the swap chain was created). Read more on docs.microsoft.com. Type: UINT A value that represents the running total count of v-blanks when the scheduler last sampled the machine time by calling QueryPerformanceCounter and that have happened since the computer booted (for windowed mode, since the swap chain was created). Read more on docs.microsoft.com. Type: LARGE_INTEGER A value that represents the high-resolution performance counter timer. This value is the same as the value returned by the QueryPerformanceCounter function. Read more on docs.microsoft.com. Type: LARGE_INTEGER Reserved. Always returns 0. Read more on docs.microsoft.com. Describes a mapped rectangle that is used to access a surface. The DXGI_MAPPED_RECT structure is initialized by the IDXGISurface::Map method. Type: INT A value that describes the width, in bytes, of the surface. Read more on docs.microsoft.com. Type: BYTE* A pointer to the image buffer of the surface. Read more on docs.microsoft.com. Describes an output or physical connection between the adapter (video card) and a device. The DXGI_OUTPUT_DESC structure is initialized by the IDXGIOutput::GetDesc method. Type: WCHAR[32] A string that contains the name of the output device. Read more on docs.microsoft.com. Type: RECT A RECT structure containing the bounds of the output in desktop coordinates. Desktop coordinates depend on the dots per inch (DPI) of the desktop. For info about writing DPI-aware Win32 apps, see High DPI. Read more on docs.microsoft.com. Type: BOOL True if the output is attached to the desktop; otherwise, false. Read more on docs.microsoft.com. Type: DXGI_MODE_ROTATION A member of the DXGI_MODE_ROTATION enumerated type describing on how an image is rotated by the output. Read more on docs.microsoft.com. Type: HMONITOR An HMONITOR handle that represents the display monitor. For more information, see HMONITOR and the Device Context. Read more on docs.microsoft.com. The DXGI\_PRESENT constants specify options for presenting frames to the output. Presentation options are supplied during the [**IDXGISwapChain::Present**](/windows/desktop/api/DXGI/nf-dxgi-idxgiswapchain-present) or [**IDXGISwapChain1::Present1**](/windows/desktop/api/DXGI1_2/nf-dxgi1_2-idxgiswapchain1-present1) call. The buffers are specified in the swap chain description (see [**DXGI\_SWAP\_CHAIN\_DESC**](/windows/desktop/api/DXGI/ns-dxgi-dxgi_swap_chain_desc) or [**DXGI\_SWAP\_CHAIN\_DESC1**](/windows/desktop/api/DXGI1_2/ns-dxgi1_2-dxgi_swap_chain_desc1)). DXGI\_PRESENT\_RESTART is valid only for flip-model swap chains and full screen. Applications can use DXGI\_PRESENT\_RESTART to recover from glitches in playback, as well as to discard previously queued presentations. Discarding previously queued presentations is useful if those queued presentations are windowed scenarios. In particular, the previously queued presentation might have assumed that the window is an old size (that is, a resize operation occurred after submission). DXGI\_PRESENT\_RESTRICT\_TO\_OUTPUT is valid only for swap chains that specified a particular output to restrict content to when those swap chains were created ([**IDXGIFactory2::CreateSwapChainForHwnd**](/windows/desktop/api/DXGI1_2/nf-dxgi1_2-idxgifactory2-createswapchainforhwnd)). If there is no output to restrict to, the flag is invalid. DXGI\_PRESENT\_STEREO\_PREFER\_RIGHT indicates that if the stereo present must be reduced to mono the right eye should be used rather than the left (default) eye. You can use this flag if one side is higher quality (for example, if the stereo pair is synthesized from a standard image.) DXGI\_PRESENT\_STEREO\_TEMPORARY\_MONO indicates that the present should use the left buffer as a mono buffer. You can use this flag to avoid updating the right buffer when an application temporarily has no stereo content. You should use this flag whenever possible because it enables significant optimization by the operating system and under some circumstances it can avoid visible mode change artifacts. You should use the DXGI\_PRESENT\_STEREO\_TEMPORARY\_MONO flag in preference to switching to a mono swap chain for most applications that you anticipate will use stereo again. You need to balance the use of this flag in applications that are extremely long running or that rarely display stereo against the disadvantage of unused memory. > [!Note] > Full-screen applications that switch to a mono swap chain cause a mode change that generally has visible artifacts (for example, "flashing”). However, temporary mono might not be supported for full-screen swap chains. The DXGI\_PRESENT\_STEREO\_PREFER\_RIGHT and DXGI\_PRESENT\_STEREO\_TEMPORARY\_MONO flags apply only to stereo swap chains. If you use them when you present mono swap chains, an invalid operation occurs. If you use the DXGI\_PRESENT\_STEREO\_TEMPORARY\_MONO flag when you present a stereo swap chain that does not support temporary mono, an error occurs, the swap chain does not display, and the presentation returns [DXGI\_ERROR\_INVALID\_CALL](dxgi-error.md). Read more on docs.microsoft.com. Describes information about present that helps the operating system optimize presentation. This structure is used by the Present1 method. The scroll rectangle and the list of dirty rectangles could overlap. In this situation, the dirty rectangles take priority. Applications can then have pieces of dynamic content on top of a scrolled area. For example, an application could scroll a page and play video at the same time. The following diagram and coordinates illustrate this example. This doc was truncated. Read more on docs.microsoft.com. The number of updated rectangles that you update in the back buffer for the presented frame. The operating system uses this information to optimize presentation. You can set this member to 0 to indicate that you update the whole frame. A list of updated rectangles that you update in the back buffer for the presented frame. An application must update every single pixel in each rectangle that it reports to the runtime; the application cannot assume that the pixels are saved from the previous frame. For more information about updating dirty rectangles, see Remarks. You can set this member to NULL if DirtyRectsCount is 0. An application must not update any pixel outside of the dirty rectangles. A pointer to the scrolled rectangle. The scrolled rectangle is the rectangle of the previous frame from which the runtime bit-block transfers (bitblts) content. The runtime also uses the scrolled rectangle to optimize presentation in terminal server and indirect display scenarios. The scrolled rectangle also describes the destination rectangle, that is, the region on the current frame that is filled with scrolled content. You can set this member to NULL to indicate that no content is scrolled from the previous frame. Read more on docs.microsoft.com. A pointer to the offset of the scrolled area that goes from the source rectangle (of previous frame) to the destination rectangle (of current frame). You can set this member to NULL to indicate no offset. Flags indicating the memory location of a resource. This enum is used by QueryResourceResidency. The resource is located in video memory. At least some of the resource is located in CPU memory. At least some of the resource has been paged out to the hard drive. DXGI_RGBA structure - Represents a color value with alpha, which is used for transparency. You can set the members of this structure to values outside the range of 0 through 1 to implement some unusual effects. Values greater than 1 produce strong lights that tend to wash out a scene. Negative values produce dark lights that actually remove light from a scene. The DXGItype.h header type-defines **DXGI\_RGBA** as an alias of [**D3DCOLORVALUE**](d3dcolorvalue.md), as follows: This doc was truncated. Read more on docs.microsoft.com. Floating-point value that specifies the red component of a color. This value generally is in the range from 0.0 through 1.0. A value of 0.0 indicates the complete absence of the red component, while a value of 1.0 indicates that red is fully present. Floating-point value that specifies the green component of a color. This value generally is in the range from 0.0 through 1.0. A value of 0.0 indicates the complete absence of the green component, while a value of 1.0 indicates that green is fully present. Floating-point value that specifies the blue component of a color. This value generally is in the range from 0.0 through 1.0. A value of 0.0 indicates the complete absence of the blue component, while a value of 1.0 indicates that blue is fully present. Floating-point value that specifies the alpha component of a color. This value generally is in the range from 0.0 through 1.0. A value of 0.0 indicates fully transparent, while a value of 1.0 indicates fully opaque. Identifies resize behavior when the back-buffer size does not match the size of the target output. The DXGI_SCALING_NONE value is supported only for flip presentation model swap chains that you create with the DXGI_SWAP_EFFECT_FLIP_SEQUENTIAL value. You pass these values in a call to IDXGIFactory2::CreateSwapChainForHwnd, IDXGIFactory2::CreateSwapChainForCoreWindow, or IDXGIFactory2::CreateSwapChainForComposition. DXGI_SCALING_ASPECT_RATIO_STRETCH will prefer to use a horizontal fill, otherwise it will use a vertical fill, using the following logic. This doc was truncated. Read more on docs.microsoft.com. Directs DXGI to make the back-buffer contents scale to fit the presentation target size. This is the implicit behavior of DXGI when you call the IDXGIFactory::CreateSwapChain method. Directs DXGI to make the back-buffer contents appear without any scaling when the presentation target size is not equal to the back-buffer size. The top edges of the back buffer and presentation target are aligned together. If the WS_EX_LAYOUTRTL style is associated with the HWND handle to the target output window, the right edges of the back buffer and presentation target are aligned together; otherwise, the left edges are aligned together. All target area outside the back buffer is filled with window background color. This value specifies that all target areas outside the back buffer of a swap chain are filled with the background color that you specify in a call to IDXGISwapChain1::SetBackgroundColor. Read more on docs.microsoft.com. Directs DXGI to make the back-buffer contents scale to fit the presentation target size, while preserving the aspect ratio of the back-buffer. If the scaled back-buffer does not fill the presentation area, it will be centered with black borders. This constant is supported on Windows Phone 8 and Windows 10. Note that with legacy Win32 window swapchains, this works the same as DXGI_SCALING_STRETCH. Read more on docs.microsoft.com. Represents a handle to a shared resource. To create a shared surface, pass a shared-resource handle into the IDXGIDevice::CreateSurface method. Type: HANDLE A handle to a shared resource. Read more on docs.microsoft.com. Describes a surface. This structure is used by the GetDesc and CreateSurface methods. Type: UINT A value describing the surface width. Read more on docs.microsoft.com. Type: UINT A value describing the surface height. Read more on docs.microsoft.com. Type: DXGI_FORMAT A member of the DXGI_FORMAT enumerated type that describes the surface format. Read more on docs.microsoft.com. Type: DXGI_SAMPLE_DESC A member of the DXGI_SAMPLE_DESC structure that describes multi-sampling parameters for the surface. Read more on docs.microsoft.com. Describes a swap chain. (DXGI_SWAP_CHAIN_DESC) This structure is used by the GetDesc and CreateSwapChain methods. In full-screen mode, there is a dedicated front buffer; in windowed mode, the desktop is the front buffer. If you create a swap chain with one buffer, specifying DXGI_SWAP_EFFECT_SEQUENTIAL does not cause the contents of the single buffer to be swapped with the front buffer. For performance information about flipping swap-chain buffers in full-screen application, see Full-Screen Application Performance Hints. Read more on docs.microsoft.com. Type: DXGI_MODE_DESC A DXGI_MODE_DESC structure that describes the backbuffer display mode. Read more on docs.microsoft.com. Type: DXGI_SAMPLE_DESC A DXGI_SAMPLE_DESC structure that describes multi-sampling parameters. Read more on docs.microsoft.com. Type: DXGI_USAGE A member of the DXGI_USAGE enumerated type that describes the surface usage and CPU access options for the back buffer. The back buffer can be used for shader input or render-target output. Read more on docs.microsoft.com. Type: UINT A value that describes the number of buffers in the swap chain. When you call IDXGIFactory::CreateSwapChain to create a full-screen swap chain, you typically include the front buffer in this value. For more information about swap-chain buffers, see Remarks. Read more on docs.microsoft.com. Type: HWND An HWND handle to the output window. This member must not be NULL. Read more on docs.microsoft.com. Type: BOOL A Boolean value that specifies whether the output is in windowed mode. TRUE if the output is in windowed mode; otherwise, FALSE. We recommend that you create a windowed swap chain and allow the end user to change the swap chain to full screen through IDXGISwapChain::SetFullscreenState; that is, do not set this member to FALSE to force the swap chain to be full screen. However, if you create the swap chain as full screen, also provide the end user with a list of supported display modes through the BufferDesc member because a swap chain that is created with an unsupported display mode might cause the display to go black and prevent the end user from seeing anything. For more information about choosing windowed verses full screen, see IDXGIFactory::CreateSwapChain. Read more on docs.microsoft.com. Type: DXGI_SWAP_EFFECT A member of the DXGI_SWAP_EFFECT enumerated type that describes options for handling the contents of the presentation buffer after presenting a surface. Read more on docs.microsoft.com. Describes a swap chain. (DXGI_SWAP_CHAIN_DESC1) This structure is used by the CreateSwapChainForHwnd, CreateSwapChainForCoreWindow, CreateSwapChainForComposition, CreateSwapChainForCompositionSurfaceHandle, and GetDesc1 methods.
Note  You cannot cast a DXGI_SWAP_CHAIN_DESC1 to a DXGI_SWAP_CHAIN_DESC and vice versa. An application must explicitly use the IDXGISwapChain1::GetDesc1 method to retrieve the newer version of the swap-chain description structure.
 
In full-screen mode, there is a dedicated front buffer; in windowed mode, the desktop is the front buffer. For a flip-model swap chain (that is, a swap chain that has the DXGI_SWAP_EFFECT_FLIP_DISCARD or DXGI_SWAP_EFFECT_FLIP_SEQUENTIAL value set in the SwapEffect member), you must set the Format member to DXGI_FORMAT_R16G16B16A16_FLOAT, DXGI_FORMAT_B8G8R8A8_UNORM, or DXGI_FORMAT_R8G8B8A8_UNORM; you must set the Count member of the DXGI_SAMPLE_DESC structure that the SampleDesc member specifies to one and the Quality member of DXGI_SAMPLE_DESC to zero because multiple sample antialiasing (MSAA) is not supported; you must set the BufferCount member to from two to sixteen. For more info about flip-model swap chain, see DXGI Flip Model. Read more on docs.microsoft.com. A value that describes the resolution width. If you specify the width as zero when you call the IDXGIFactory2::CreateSwapChainForHwnd method to create a swap chain, the runtime obtains the width from the output window and assigns this width value to the swap-chain description. You can subsequently call the IDXGISwapChain1::GetDesc1 method to retrieve the assigned width value. You cannot specify the width as zero when you call the IDXGIFactory2::CreateSwapChainForComposition method. Read more on docs.microsoft.com. A value that describes the resolution height. If you specify the height as zero when you call the IDXGIFactory2::CreateSwapChainForHwnd method to create a swap chain, the runtime obtains the height from the output window and assigns this height value to the swap-chain description. You can subsequently call the IDXGISwapChain1::GetDesc1 method to retrieve the assigned height value. You cannot specify the height as zero when you call the IDXGIFactory2::CreateSwapChainForComposition method. Read more on docs.microsoft.com. A DXGI_FORMAT structure that describes the display format. Read more on docs.microsoft.com. Specifies whether the full-screen display mode or the swap-chain back buffer is stereo. TRUE if stereo; otherwise, FALSE. If you specify stereo, you must also specify a flip-model swap chain (that is, a swap chain that has the DXGI_SWAP_EFFECT_FLIP_SEQUENTIAL value set in the SwapEffect member). Read more on docs.microsoft.com. A DXGI_SAMPLE_DESC structure that describes multi-sampling parameters. This member is valid only with bit-block transfer (bitblt) model swap chains. Read more on docs.microsoft.com. A DXGI_USAGE-typed value that describes the surface usage and CPU access options for the back buffer. The back buffer can be used for shader input or render-target output. Read more on docs.microsoft.com. A value that describes the number of buffers in the swap chain. When you create a full-screen swap chain, you typically include the front buffer in this value. Read more on docs.microsoft.com. A DXGI_SCALING-typed value that identifies resize behavior if the size of the back buffer is not equal to the target output. Read more on docs.microsoft.com. A DXGI_SWAP_EFFECT-typed value that describes the presentation model that is used by the swap chain and options for handling the contents of the presentation buffer after presenting a surface. You must specify the DXGI_SWAP_EFFECT_FLIP_SEQUENTIAL value when you call the IDXGIFactory2::CreateSwapChainForComposition method because this method supports only flip presentation model. Read more on docs.microsoft.com. A DXGI_ALPHA_MODE-typed value that identifies the transparency behavior of the swap-chain back buffer. Read more on docs.microsoft.com. Options for swap-chain behavior. This enumeration is used by the DXGI_SWAP_CHAIN_DESC structure and the IDXGISwapChain::ResizeTarget method. This enumeration is also used by the DXGI_SWAP_CHAIN_DESC1 structure. You don't need to set DXGI_SWAP_CHAIN_FLAG_DISPLAY_ONLY for swap chains that you create in full-screen mode with the IDXGIFactory::CreateSwapChain method because those swap chains already behave as if DXGI_SWAP_CHAIN_FLAG_DISPLAY_ONLY is set. That is, presented content is not accessible by remote access or through the desktop duplication APIs. Swap chains that you create with the IDXGIFactory2::CreateSwapChainForHwnd, IDXGIFactory2::CreateSwapChainForCoreWindow, and IDXGIFactory2::CreateSwapChainForComposition methods are not protected if DXGI_SWAP_CHAIN_FLAG_DISPLAY_ONLY is not set and are protected if DXGI_SWAP_CHAIN_FLAG_DISPLAY_ONLY is set. When swap chains are protected, screen scraping is prevented and, in full-screen mode, presented content is not accessible through the desktop duplication APIs. When you call IDXGISwapChain::ResizeBuffers to change the swap chain's back buffer, you can reset or change all DXGI_SWAP_CHAIN_FLAG flags. Read more on docs.microsoft.com. Set this flag to turn off automatic image rotation; that is, do not perform a rotation when transferring the contents of the front buffer to the monitor. Use this flag to avoid a bandwidth penalty when an application expects to handle rotation. This option is valid only during full-screen mode. Read more on docs.microsoft.com. Set this flag to enable an application to switch modes by calling IDXGISwapChain::ResizeTarget. When switching from windowed to full-screen mode, the display mode (or monitor resolution) will be changed to match the dimensions of the application window. Read more on docs.microsoft.com. Set this flag to enable an application to render using GDI on a swap chain or a surface. This will allow the application to call IDXGISurface1::GetDC on the 0th back buffer or a surface. This flag is not applicable for Direct3D 12. Read more on docs.microsoft.com. Set this flag to indicate that the swap chain might contain protected content; therefore, the operating system supports the creation of the swap chain only when driver and hardware protection is used. If the driver and hardware do not support content protection, the call to create a resource for the swap chain fails. Direct3D 11:  This enumeration value is supported starting with Windows 8. Read more on docs.microsoft.com. Set this flag to indicate that shared resources that are created within the swap chain must be protected by using the driver’s mechanism for restricting access to shared surfaces. Direct3D 11:  This enumeration value is supported starting with Windows 8. Read more on docs.microsoft.com. Set this flag to restrict presented content to the local displays. Therefore, the presented content is not accessible via remote accessing or through the desktop duplication APIs. This flag supports the window content protection features of Windows. Applications can use this flag to protect their own onscreen window content from being captured or copied through a specific set of public operating system features and APIs. If you use this flag with windowed (HWND or IWindow) swap chains where another process created the HWND, the owner of the HWND must use the SetWindowDisplayAffinity function appropriately in order to allow calls to IDXGISwapChain::Present or IDXGISwapChain1::Present1 to succeed. Direct3D 11:  This enumeration value is supported starting with Windows 8. Read more on docs.microsoft.com. Set this flag to create a waitable object you can use to ensure rendering does not begin while a frame is still being presented. When this flag is used, the swapchain's latency must be set with the IDXGISwapChain2::SetMaximumFrameLatency API instead of IDXGIDevice1::SetMaximumFrameLatency. This flag isn't supported in full-screen mode, unless the render API is Direct3D 12. Note  This enumeration value is supported starting with Windows 8.1. Read more on docs.microsoft.com. Set this flag to create a swap chain in the foreground layer for multi-plane rendering. This flag can only be used with CoreWindow swap chains, which are created with CreateSwapChainForCoreWindow. Apps should not create foreground swap chains if IDXGIOutput2::SupportsOverlays indicates that hardware support for overlays is not available. Note that IDXGISwapChain::ResizeBuffers cannot be used to add or remove this flag. Note  This enumeration value is supported starting with Windows 8.1. Read more on docs.microsoft.com. Set this flag to create a swap chain for full-screen video. Note  This enumeration value is supported starting with Windows 8.1. Read more on docs.microsoft.com. Set this flag to create a swap chain for YUV video. Note  This enumeration value is supported starting with Windows 8.1. Read more on docs.microsoft.com. Indicates that the swap chain should be created such that all underlying resources can be protected by the hardware. Resource creation will fail if hardware content protection is not supported. This flag has the following restrictions: This doc was truncated. Read more on docs.microsoft.com. Tearing support is a requirement to enable displays that support variable refresh rates to function properly when the application presents a swap chain tied to a full screen borderless window. Win32 apps can already achieve tearing in fullscreen exclusive mode by calling SetFullscreenState(TRUE), but the recommended approach for Win32 developers is to use this tearing flag instead. This flag requires the use of a DXGI_SWAP_EFFECT_FLIP_* swap effect. To check for hardware support of this feature, refer to IDXGIFactory5::CheckFeatureSupport. For usage information refer to IDXGISwapChain::Present and the DXGI_PRESENT flags. > [!NOTE] > [**IDXGISwapChain::ResizeBuffers**](/windows/win32/api/dxgi/nf-dxgi-idxgiswapchain-resizebuffers) can't be used to add or remove this flag. Read more on docs.microsoft.com. Describes full-screen mode for a swap chain. This structure is used by the CreateSwapChainForHwnd and GetFullscreenDesc methods. A DXGI_RATIONAL structure that describes the refresh rate in hertz. A member of the DXGI_MODE_SCANLINE_ORDER enumerated type that describes the scan-line drawing mode. A member of the DXGI_MODE_SCALING enumerated type that describes the scaling mode. A Boolean value that specifies whether the swap chain is in windowed mode. TRUE if the swap chain is in windowed mode; otherwise, FALSE. Options for handling pixels in a display surface after calling IDXGISwapChain1::Present1. This enumeration is used by the DXGI_SWAP_CHAIN_DESC and DXGI_SWAP_CHAIN_DESC1 structures. In D3D12, only DXGI_SWAP_EFFECT_FLIP_SEQUENTIAL and DXGI_SWAP_EFFECT_FLIP_DISCARD are supported, and the bitblt models are not. Because of this, multisampling a back buffer is not supported in D3D12, and you must manually perform multisampling in the app using ID3D12GraphicsCommandList::ResolveSubresource or ID3D12GraphicsCommandList1::ResolveSubresourceRegion. To use multisampling with DXGI_SWAP_EFFECT_SEQUENTIAL or DXGI_SWAP_EFFECT_FLIP_SEQUENTIAL, you must perform the multisampling in a separate render target. For example, create a multisampled texture by calling ID3D11Device::CreateTexture2D with a filled D3D11_TEXTURE2D_DESC structure (BindFlags member set to D3D11_BIND_RENDER_TARGET and SampleDesc member with multisampling parameters). Next call ID3D11Device::CreateRenderTargetView to create a render-target view for the texture, and render your scene into the texture. Finally call ID3D11DeviceContext::ResolveSubresource to resolve the multisampled texture into your non-multisampled swap chain. The primary difference between presentation models is how back-buffer contents get to the Desktop Window Manager (DWM) for composition. In the bitblt model, which is used with the DXGI_SWAP_EFFECT_DISCARD and DXGI_SWAP_EFFECT_SEQUENTIAL values, contents of the back buffer get copied into the redirection surface on each call to IDXGISwapChain1::Present1. In the flip model, which is used with the DXGI_SWAP_EFFECT_FLIP_SEQUENTIAL value, all back buffers are shared with the DWM. Therefore, the DWM can compose straight from those back buffers without any additional copy operations. In general, the flip model is the more efficient model. The flip model also provides more features, such as enhanced present statistics. The difference between DXGI_SWAP_EFFECT_FLIP_SEQUENTIAL and DXGI_SWAP_EFFECT_FLIP_DISCARD is that DXGI_SWAP_EFFECT_FLIP_SEQUENTIAL forces DXGI to guarantee that the contents of each back buffer is preserved across `IDXGISwapChain::Present` calls, whereas DXGI_SWAP_EFFECT_FLIP_DISCARD doesn't provide this guarantee. The compositor, under certain scenarios, can use DirectFlip, where it uses the application's back buffer as the entire display back buffer, which elides the cost of copying the application's back buffer into the final desktop back buffer. With DXGI_SWAP_EFFECT_FLIP_SEQUENTIAL and DXGI_SWAP_EFFECT_FLIP_DISCARD, this optimization can occur when the application is the only item visible on the screen. However, even when the application is not the only visible item on the screen, if the flip model is DXGI_SWAP_EFFECT_FLIP_DISCARD, the compositor can in some scenarios still perform this optimization, by drawing other content onto the application's back buffer. When you call IDXGISwapChain1::Present1 on a flip model swap chain (DXGI_SWAP_EFFECT_FLIP_SEQUENTIAL) with 0 specified in the SyncInterval parameter, IDXGISwapChain1::Present1's behavior is the same as the behavior of Direct3D 9Ex's IDirect3DDevice9Ex::PresentEx with D3DSWAPEFFECT_FLIPEX and D3DPRESENT_FORCEIMMEDIATE. That is, the runtime not only presents the next frame instead of any previously queued frames, it also terminates any remaining time left on the previously queued frames. Regardless of whether the flip model is more efficient, an application still might choose the bitblt model because the bitblt model is the only way to mix GDI and DirectX presentation. In the flip model, the application must create the swap chain with DXGI_SWAP_CHAIN_FLAG_GDI_COMPATIBLE, and then must use GetDC on the back buffer explicitly. After the first successful call to IDXGISwapChain1::Present1 on a flip-model swap chain, GDI no longer works with the HWND that is associated with that swap chain, even after the destruction of the swap chain. This restriction even extends to methods like ScrollWindowEx. For more info about the flip-model swap chain and optimizing presentation, see Enhancing presentation with the flip model, dirty rectangles, and scrolled areas. Read more on docs.microsoft.com. Use this flag to specify the bit-block transfer (bitblt) model and to specify that DXGI discard the contents of the back buffer after you call IDXGISwapChain1::Present1. This flag is valid for a swap chain with more than one back buffer, although, applications only have read and write access to buffer 0. Use this flag to enable the display driver to select the most efficient presentation technique for the swap chain. Direct3D 12: This enumeration value is never supported. D3D12 apps must use DXGI_SWAP_EFFECT_FLIP_SEQUENTIAL or DXGI_SWAP_EFFECT_FLIP_DISCARD.
Note  There are differences between full screen exclusive and full screen UWP. If you are porting a Direct3D 11 application to UWP on a Windows PC, be aware that the use of DXGI_SWAP_EFFECT_DISCARD when creating swap chains does not behave the same way in UWP as it does in Win32, and its use may be detrimental to GPU performance. This is because UWP applications are forced into FLIP swap modes (even if other swap modes are set), because this reduces the computation time used by the memory copies originally done by the older bitblt model. The recommended approach is to manually convert DX11 Discard swap chains to use flip models within UWP, using DXGI_SWAP_EFFECT_FLIP_DISCARD instead of DXGI_SWAP_EFFECT_DISCARD where possible. Refer to the Example below, and see this article for more information.
 
 Read more on docs.microsoft.com. Use this flag to specify the bitblt model and to specify that DXGI persist the contents of the back buffer after you call IDXGISwapChain1::Present1. Use this option to present the contents of the swap chain in order, from the first buffer (buffer 0) to the last buffer. This flag cannot be used with multisampling. Direct3D 12: This enumeration value is never supported. D3D12 apps must use DXGI_SWAP_EFFECT_FLIP_SEQUENTIAL or DXGI_SWAP_EFFECT_FLIP_DISCARD.
Note  For best performance, use DXGI_SWAP_EFFECT_FLIP_SEQUENTIAL instead of DXGI_SWAP_EFFECT_SEQUENTIAL. See this article for more information.
 
 Read more on docs.microsoft.com. Use this flag to specify the flip presentation model and to specify that DXGI persist the contents of the back buffer after you call IDXGISwapChain1::Present1. This flag cannot be used with multisampling. Direct3D 11:  This enumeration value is supported starting with Windows 8. Read more on docs.microsoft.com. Use this flag to specify the flip presentation model and to specify that DXGI discard the contents of the back buffer after you call IDXGISwapChain1::Present1. This flag cannot be used with multisampling and partial presentation. See DXGI 1.4 Improvements. Direct3D 11:  This enumeration value is supported starting with Windows 10. This flag is valid for a swap chain with more than one back buffer; although applications have read and write access only to buffer 0.
Note  Windows Store apps must use DXGI_SWAP_EFFECT_FLIP_SEQUENTIAL or DXGI_SWAP_EFFECT_FLIP_DISCARD.
 
 Read more on docs.microsoft.com. Flags for surface and resource creation options. Each flag is defined as an unsigned integer. This doc was truncated. Read more on docs.microsoft.com. Enumerate adapter (video card) outputs. Type: UINT The index of the output. Read more on docs.microsoft.com. Type: IDXGIOutput** The address of a pointer to an IDXGIOutput interface at the position specified by the Output parameter. Read more on docs.microsoft.com. Type: HRESULT A code that indicates success or failure (see DXGI_ERROR). DXGI_ERROR_NOT_FOUND is returned if the index is greater than the number of outputs. If the adapter came from a device created using D3D_DRIVER_TYPE_WARP, then the adapter has no outputs, so DXGI_ERROR_NOT_FOUND is returned.
Note  If you call this API in a Session 0 process, it returns DXGI_ERROR_NOT_CURRENTLY_AVAILABLE.
 
When the EnumOutputs method succeeds and fills the ppOutput parameter with the address of the pointer to the output interface, EnumOutputs increments the output interface's reference count. To avoid a memory leak, when you finish using the output interface, call the Release method to decrement the reference count. EnumOutputs first returns the output on which the desktop primary is displayed. This output corresponds with an index of zero. EnumOutputs then returns other outputs. Read more on docs.microsoft.com. Gets a DXGI 1.0 description of an adapter (or video card). Type: HRESULT Returns S_OK if successful; otherwise returns E_INVALIDARG if the pDesc parameter is NULL. Graphics apps can use the DXGI API to retrieve an accurate set of graphics memory values on systems that have Windows Display Driver Model (WDDM) drivers. The following are the critical steps involved. This doc was truncated. Read more on docs.microsoft.com. Checks whether the system supports a device interface for a graphics component. Type: REFGUID The GUID of the interface of the device version for which support is being checked. This should usually be __uuidof(IDXGIDevice), which returns the version number of the Direct3D 9 UMD (user mode driver) binary. Since WDDM 2.3, all driver components within a driver package (D3D9, D3D11, and D3D12) have been required to share a single version number, so this is a good way to query the driver version regardless of which API is being used. Read more on docs.microsoft.com. Type: LARGE_INTEGER* The user mode driver version of InterfaceName. This is returned only if the interface is supported, otherwise this parameter will be NULL. Read more on docs.microsoft.com. Type: HRESULT S_OK indicates that the interface is supported, otherwise DXGI_ERROR_UNSUPPORTED is returned (For more information, see DXGI_ERROR).
Note  You can use CheckInterfaceSupport only to check whether a Direct3D 10.x interface is supported, and only on Windows Vista SP1 and later versions of the operating system. If you try to use CheckInterfaceSupport to check whether a Direct3D 11.x and later version interface is supported, CheckInterfaceSupport returns DXGI_ERROR_UNSUPPORTED. Therefore, do not use CheckInterfaceSupport. Instead, to verify whether the operating system supports a particular interface, try to create the interface. For example, if you call the ID3D11Device::CreateBlendState method and it fails, the operating system does not support the ID3D11BlendState interface.
 
 Read more on docs.microsoft.com. The IID guid for this interface. {2411e7e1-12ac-4ccf-bd14-9798e8534dc0} Gets a DXGI 1.1 description of an adapter (or video card). Type: HRESULT Returns S_OK if successful; otherwise, returns E_INVALIDARG if the pDesc parameter is NULL. This method is not supported by DXGI 1.0, which shipped in Windows Vista and Windows Server 2008. DXGI 1.1 support is required, which is available on Windows 7, Windows Server 2008 R2, and as an update to Windows Vista with Service Pack 2 (SP2) (KB 971644) and Windows Server 2008 (KB 971512). Use the GetDesc1 method to get a DXGI 1.1 description of an adapter. To get a DXGI 1.0 description, use the IDXGIAdapter method. Read more on docs.microsoft.com. The IID guid for this interface. {29038f61-3839-4626-91fd-086879011a05} Returns the adapter for the specified device. Type: IDXGIAdapter** The address of an IDXGIAdapter interface pointer to the adapter. This parameter must not be NULL. Read more on docs.microsoft.com. Type: HRESULT Returns S_OK if successful; otherwise, returns one of the DXGI_ERROR that indicates failure. If the pAdapter parameter is NULL this method returns E_INVALIDARG. If the GetAdapter method succeeds, the reference count on the adapter interface will be incremented. To avoid a memory leak, be sure to release the interface when you are finished using it. Returns a surface. This method is used internally and you should not call it directly in your application. Type: const DXGI_SURFACE_DESC* A pointer to a DXGI_SURFACE_DESC structure that describes the surface. Read more on docs.microsoft.com. Type: UINT The number of surfaces to create. Read more on docs.microsoft.com. Type: DXGI_USAGE A DXGI_USAGE flag that specifies how the surface is expected to be used. Read more on docs.microsoft.com. Type: const DXGI_SHARED_RESOURCE* An optional pointer to a DXGI_SHARED_RESOURCE structure that contains shared resource information for opening views of such resources. Read more on docs.microsoft.com. Type: IDXGISurface** The address of an IDXGISurface interface pointer to the first created surface. Read more on docs.microsoft.com. Type: HRESULT Returns S_OK if successful; an error code otherwise. For a list of error codes, see DXGI_ERROR. The CreateSurface method creates a buffer to exchange data between one or more devices. It is used internally, and you should not directly call it. The runtime automatically creates an IDXGISurface interface when it creates a Direct3D resource object that represents a surface. For example, the runtime creates an IDXGISurface interface when it calls ID3D11Device::CreateTexture2D or ID3D10Device::CreateTexture2D to create a 2D texture. To retrieve the IDXGISurface interface that represents the 2D texture surface, call ID3D11Texture2D::QueryInterface or ID3D10Texture2D::QueryInterface. In this call, you must pass the identifier of IDXGISurface. If the 2D texture has only a single MIP-map level and does not consist of an array of textures, QueryInterface succeeds and returns a pointer to the IDXGISurface interface pointer. Otherwise, QueryInterface fails and does not return the pointer to IDXGISurface. Read more on docs.microsoft.com. Gets the residency status of an array of resources. Type: IUnknown* An array of IDXGIResource interfaces. Read more on docs.microsoft.com. Type: DXGI_RESIDENCY* An array of DXGI_RESIDENCY flags. Each element describes the residency status for corresponding element in the ppResources argument array. Read more on docs.microsoft.com. Type: UINT The number of resources in the ppResources argument array and pResidencyStatus argument array. Read more on docs.microsoft.com. Type: HRESULT Returns S_OK if successful; otherwise, returns DXGI_ERROR_DEVICE_REMOVED, E_INVALIDARG, or E_POINTER (see Common HRESULT Values and WinError.h for more information). The information returned by the pResidencyStatus argument array describes the residency status at the time that the QueryResourceResidency method was called.
Note  The residency status will constantly change.
 
If you call the QueryResourceResidency method during a device removed state, the pResidencyStatus argument will return the DXGI_RESIDENCY_RESIDENT_IN_SHARED_MEMORY flag.
Note  This method should not be called every frame as it incurs a non-trivial amount of overhead.
 
 Read more on docs.microsoft.com. Sets the GPU thread priority. Type: INT A value that specifies the required GPU thread priority. This value must be between -7 and 7, inclusive, where 0 represents normal priority. Read more on docs.microsoft.com. Type: HRESULT Return S_OK if successful; otherwise, returns E_INVALIDARG if the Priority parameter is invalid. The values for the Priority parameter function as follows: This doc was truncated. Read more on docs.microsoft.com. Gets the GPU thread priority. Type: INT* A pointer to a variable that receives a value that indicates the current GPU thread priority. The value will be between -7 and 7, inclusive, where 0 represents normal priority. Read more on docs.microsoft.com. Type: HRESULT Return S_OK if successful; otherwise, returns E_POINTER if the pPriority parameter is NULL. Learn more about this API from docs.microsoft.com. The IID guid for this interface. {54ec77fa-1377-44e6-8c32-88fd5f44c84c} Retrieves the device. Type: REFIID The reference id for the device. Read more on docs.microsoft.com. Type: void** The address of a pointer to the device. Read more on docs.microsoft.com. Type: HRESULT A code that indicates success or failure (see DXGI_ERROR). The type of interface that is returned can be any interface published by the device. For example, it could be an IDXGIDevice * called pDevice, and therefore the REFIID would be obtained by calling __uuidof(pDevice). The IID guid for this interface. {3d3e0379-f9de-4d58-bb6c-18d62992f1a6} Enumerates the adapters (video cards). Type: UINT The index of the adapter to enumerate. Read more on docs.microsoft.com. Type: IDXGIAdapter** The address of a pointer to an IDXGIAdapter interface at the position specified by the Adapter parameter. This parameter must not be NULL. Read more on docs.microsoft.com. Type: HRESULT Returns S_OK if successful; otherwise, returns DXGI_ERROR_NOT_FOUND if the index is greater than or equal to the number of adapters in the local system, or DXGI_ERROR_INVALID_CALL if ppAdapter parameter is NULL. When you create a factory, the factory enumerates the set of adapters that are available in the system. Therefore, if you change the adapters in a system, you must destroy and recreate the IDXGIFactory object. The number of adapters in a system changes when you add or remove a display card, or dock or undock a laptop. When the EnumAdapters method succeeds and fills the ppAdapter parameter with the address of the pointer to the adapter interface, EnumAdapters increments the adapter interface's reference count. When you finish using the adapter interface, call the Release method to decrement the reference count before you destroy the pointer. EnumAdapters first returns the adapter with the output on which the desktop primary is displayed. This adapter corresponds with an index of zero. EnumAdapters next returns other adapters with outputs. EnumAdapters finally returns adapters without outputs. Read more on docs.microsoft.com. Allows DXGI to monitor an application's message queue for the alt-enter key sequence (which causes the application to switch from windowed to full screen or vice versa). Type: HWND The handle of the window that is to be monitored. This parameter can be NULL; but only if *Flags* is also 0. Read more on docs.microsoft.com. Type: UINT Type: HRESULT DXGI_ERROR_INVALID_CALL if WindowHandle is invalid, or E_OUTOFMEMORY.
Note  If you call this API in a Session 0 process, it returns DXGI_ERROR_NOT_CURRENTLY_AVAILABLE.
 
The combination of WindowHandle and Flags informs DXGI to stop monitoring window messages for the previously-associated window. If the application switches to full-screen mode, DXGI will choose a full-screen resolution to be the smallest supported resolution that is larger or the same size as the current back buffer size. Applications can make some changes to make the transition from windowed to full screen more efficient. For example, on a WM_SIZE message, the application should release any outstanding swap-chain back buffers, call IDXGISwapChain::ResizeBuffers, then re-acquire the back buffers from the swap chain(s). This gives the swap chain(s) an opportunity to resize the back buffers, and/or recreate them to enable full-screen flipping operation. If the application does not perform this sequence, DXGI will still make the full-screen/windowed transition, but may be forced to use a stretch operation (since the back buffers may not be the correct size), which may be less efficient. Even if a stretch is not required, presentation may not be optimal because the back buffers might not be directly interchangeable with the front buffer. Thus, a call to ResizeBuffers on WM_SIZE is always recommended, since WM_SIZE is always sent during a fullscreen transition. While windowed, the application can, if it chooses, restrict the size of its window's client area to sizes to which it is comfortable rendering. A fully flexible application would make no such restriction, but UI elements or other design considerations can, of course, make this flexibility untenable. If the application further chooses to restrict its window's client area to just those that match supported full-screen resolutions, the application can field WM_SIZING, then check against IDXGIOutput::FindClosestMatchingMode. If a matching mode is found, allow the resize. (The IDXGIOutput can be retrieved from IDXGISwapChain::GetContainingOutput. Absent subsequent changes to desktop topology, this will be the same output that will be chosen when alt-enter is fielded and fullscreen mode is begun for that swap chain.) Applications that want to handle mode changes or Alt+Enter themselves should call MakeWindowAssociation with the DXGI_MWA_NO_WINDOW_CHANGES flag after swap chain creation. The WindowHandle argument, if non-NULL, specifies that the application message queues will not be handled by the DXGI runtime for all swap chains of a particular target HWND. Calling MakeWindowAssociation with the DXGI_MWA_NO_WINDOW_CHANGES flag after swapchain creation ensures that DXGI will not interfere with application's handling of window mode changes or Alt+Enter. You must call the **MakeWindowAssociation** method on the factory object associated with the target HWND swap chain(s). You can guarantee that by calling the [IDXGIObject::GetParent](/windows/win32/api/dxgi/nf-dxgi-idxgiobject-getparent) method on the swap chain(s) to locate the factory. Here's a code example of doing that. This doc was truncated. Read more on docs.microsoft.com. Get the window through which the user controls the transition to and from full screen. Type: HWND* A pointer to a window handle. Read more on docs.microsoft.com. Type: HRESULT Returns a code that indicates success or failure. S_OK indicates success, DXGI_ERROR_INVALID_CALL indicates pWindowHandle was passed in as NULL.
Note  If you call this API in a Session 0 process, it returns DXGI_ERROR_NOT_CURRENTLY_AVAILABLE.
 
 Read more on docs.microsoft.com. Creates a swap chain. Type: IUnknown* For Direct3D 11, and earlier versions of Direct3D, this is a pointer to the Direct3D device for the swap chain. For Direct3D 12 this is a pointer to a direct command queue (refer to ID3D12CommandQueue) . This parameter cannot be NULL. Read more on docs.microsoft.com. Type: DXGI_SWAP_CHAIN_DESC* A pointer to a DXGI_SWAP_CHAIN_DESC structure for the swap-chain description. This parameter cannot be NULL. Read more on docs.microsoft.com. Type: IDXGISwapChain** A pointer to a variable that receives a pointer to the IDXGISwapChain interface for the swap chain that CreateSwapChain creates. Read more on docs.microsoft.com. Type: HRESULT DXGI_ERROR_INVALID_CALL if pDesc or ppSwapChain is NULL, DXGI_STATUS_OCCLUDED if you request full-screen mode and it is unavailable, or E_OUTOFMEMORY. Other error codes defined by the type of device passed in may also be returned.
Note  If you call this API in a Session 0 process, it returns DXGI_ERROR_NOT_CURRENTLY_AVAILABLE.
 
If you attempt to create a swap chain in full-screen mode, and full-screen mode is unavailable, the swap chain will be created in windowed mode and DXGI_STATUS_OCCLUDED will be returned. If the buffer width or the buffer height is zero, the sizes will be inferred from the output window size in the swap-chain description. Because the target output can't be chosen explicitly when the swap chain is created, we recommend not to create a full-screen swap chain. This can reduce presentation performance if the swap chain size and the output window size do not match. Here are two ways to ensure that the sizes match: This doc was truncated. Read more on docs.microsoft.com. Create an adapter interface that represents a software adapter. Type: HMODULE Handle to the software adapter's dll. HMODULE can be obtained with GetModuleHandle or LoadLibrary. Read more on docs.microsoft.com. Type: IDXGIAdapter** Address of a pointer to an adapter (see IDXGIAdapter). Read more on docs.microsoft.com. Type: HRESULT A return code indicating success or failure. A software adapter is a DLL that implements the entirety of a device driver interface, plus emulation, if necessary, of kernel-mode graphics components for Windows. Details on implementing a software adapter can be found in the Windows Vista Driver Development Kit. This is a very complex development task, and is not recommended for general readers. Calling this method will increment the module's reference count by one. The reference count can be decremented by calling FreeLibrary. The typical calling scenario is to call LoadLibrary, pass the handle to CreateSoftwareAdapter, then immediately call FreeLibrary on the DLL and forget the DLL's HMODULE. Since the software adapter calls FreeLibrary when it is destroyed, the lifetime of the DLL will now be owned by the adapter, and the application is free of any further consideration of its lifetime. Read more on docs.microsoft.com. The IID guid for this interface. {7b7166ec-21c7-44ae-b21a-c9ae321ae369} Enumerates both adapters (video cards) with or without outputs. Type: UINT The index of the adapter to enumerate. Read more on docs.microsoft.com. Type: IDXGIAdapter1** The address of a pointer to an IDXGIAdapter1 interface at the position specified by the Adapter parameter. This parameter must not be NULL. Read more on docs.microsoft.com. Type: HRESULT Returns S_OK if successful; otherwise, returns DXGI_ERROR_NOT_FOUND if the index is greater than or equal to the number of adapters in the local system, or DXGI_ERROR_INVALID_CALL if ppAdapter parameter is NULL. This method is not supported by DXGI 1.0, which shipped in Windows Vista and Windows Server 2008. DXGI 1.1 support is required, which is available on Windows 7, Windows Server 2008 R2, and as an update to Windows Vista with Service Pack 2 (SP2) (KB 971644) and Windows Server 2008 (KB 971512). When you create a factory, the factory enumerates the set of adapters that are available in the system. Therefore, if you change the adapters in a system, you must destroy and recreate the IDXGIFactory1 object. The number of adapters in a system changes when you add or remove a display card, or dock or undock a laptop. When the EnumAdapters1 method succeeds and fills the ppAdapter parameter with the address of the pointer to the adapter interface, EnumAdapters1 increments the adapter interface's reference count. When you finish using the adapter interface, call the Release method to decrement the reference count before you destroy the pointer. EnumAdapters1 first returns the adapter with the output on which the desktop primary is displayed. This adapter corresponds with an index of zero. EnumAdapters1 next returns other adapters with outputs. EnumAdapters1 finally returns adapters without outputs. Read more on docs.microsoft.com. Informs an application of the possible need to re-enumerate adapters. Type: BOOL FALSE, if a new adapter is becoming available or the current adapter is going away. TRUE, no adapter changes. IsCurrent returns FALSE to inform the calling application to re-enumerate adapters. This method is not supported by DXGI 1.0, which shipped in Windows Vista and Windows Server 2008. DXGI 1.1 support is required, which is available on Windows 7, Windows Server 2008 R2, and as an update to Windows Vista with Service Pack 2 (SP2) (KB 971644) and Windows Server 2008 (KB 971512). Read more on docs.microsoft.com. The IID guid for this interface. {770aae78-f26f-4dba-a829-253c83d1b387} Determines whether to use stereo mode. Indicates whether to use stereo mode. TRUE indicates that you can use stereo mode; otherwise, FALSE. Platform Update for Windows 7:  On Windows 7 or Windows Server 2008 R2 with the Platform Update for Windows 7 installed, IsWindowedStereoEnabled always returns FALSE because stereoscopic 3D display behavior isn’t available with the Platform Update for Windows 7. For more info about the Platform Update for Windows 7, see Platform Update for Windows 7. We recommend that windowed applications call IsWindowedStereoEnabled before they attempt to use stereo. IsWindowedStereoEnabled returns TRUE if both of the following items are true: This doc was truncated. Read more on docs.microsoft.com. Creates a swap chain that is associated with an HWND handle to the output window for the swap chain. For Direct3D 11, and earlier versions of Direct3D, this is a pointer to the Direct3D device for the swap chain. For Direct3D 12 this is a pointer to a direct command queue (refer to ID3D12CommandQueue). This parameter cannot be NULL. The HWND handle that is associated with the swap chain that CreateSwapChainForHwnd creates. This parameter cannot be NULL. A pointer to a DXGI_SWAP_CHAIN_DESC1 structure for the swap-chain description. This parameter cannot be NULL. A pointer to a DXGI_SWAP_CHAIN_FULLSCREEN_DESC structure for the description of a full-screen swap chain. You can optionally set this parameter to create a full-screen swap chain. Set it to NULL to create a windowed swap chain. A pointer to the IDXGIOutput interface for the output to restrict content to. You must also pass the DXGI_PRESENT_RESTRICT_TO_OUTPUT flag in a IDXGISwapChain1::Present1 call to force the content to appear blacked out on any other output. If you want to restrict the content to a different output, you must create a new swap chain. However, you can conditionally restrict content based on the DXGI_PRESENT_RESTRICT_TO_OUTPUT flag. Set this parameter to NULL if you don't want to restrict content to an output target. Read more on docs.microsoft.com. A pointer to a variable that receives a pointer to the IDXGISwapChain1 interface for the swap chain that CreateSwapChainForHwnd creates. CreateSwapChainForHwnd returns: This doc was truncated.
Note  Do not use this method in Windows Store apps. Instead, use IDXGIFactory2::CreateSwapChainForCoreWindow.
 
If you specify the width, height, or both (Width and Height members of DXGI_SWAP_CHAIN_DESC1 that pDesc points to) of the swap chain as zero, the runtime obtains the size from the output window that the hWnd parameter specifies. You can subsequently call the IDXGISwapChain1::GetDesc1 method to retrieve the assigned width or height value. Because you can associate only one flip presentation model swap chain at a time with an HWND, the Microsoft Direct3D 11 policy of deferring the destruction of objects can cause problems if you attempt to destroy a flip presentation model swap chain and replace it with another swap chain. For more info about this situation, see Deferred Destruction Issues with Flip Presentation Swap Chains. For info about how to choose a format for the swap chain's back buffer, see Converting data for the color space. Read more on docs.microsoft.com. Creates a swap chain that is associated with the CoreWindow object for the output window for the swap chain. For Direct3D 11, and earlier versions of Direct3D, this is a pointer to the Direct3D device for the swap chain. For Direct3D 12 this is a pointer to a direct command queue (refer to ID3D12CommandQueue). This parameter cannot be NULL. A pointer to the CoreWindow object that is associated with the swap chain that CreateSwapChainForCoreWindow creates. A pointer to a DXGI_SWAP_CHAIN_DESC1 structure for the swap-chain description. This parameter cannot be NULL. A pointer to the IDXGIOutput interface that the swap chain is restricted to. If the swap chain is moved to a different output, the content is black. You can optionally set this parameter to an output target that uses DXGI_PRESENT_RESTRICT_TO_OUTPUT to restrict the content on this output. If you do not set this parameter to restrict content on an output target, you can set it to NULL. A pointer to a variable that receives a pointer to the IDXGISwapChain1 interface for the swap chain that CreateSwapChainForCoreWindow creates. CreateSwapChainForCoreWindow returns: This doc was truncated.
Note  Use this method in Windows Store apps rather than IDXGIFactory2::CreateSwapChainForHwnd.
 
If you specify the width, height, or both (Width and Height members of DXGI_SWAP_CHAIN_DESC1 that pDesc points to) of the swap chain as zero, the runtime obtains the size from the output window that the pWindow parameter specifies. You can subsequently call the IDXGISwapChain1::GetDesc1 method to retrieve the assigned width or height value. Because you can associate only one flip presentation model swap chain (per layer) at a time with a CoreWindow, the Microsoft Direct3D 11 policy of deferring the destruction of objects can cause problems if you attempt to destroy a flip presentation model swap chain and replace it with another swap chain. For more info about this situation, see Deferred Destruction Issues with Flip Presentation Swap Chains. For info about how to choose a format for the swap chain's back buffer, see Converting data for the color space.

Overlapping swap chains

Starting with Windows 8.1, it is possible to create an additional swap chain in the foreground layer. A foreground swap chain can be used to render UI elements at native resolution while scaling up real-time rendering in the background swap chain (such as gameplay). This enables scenarios where lower resolution rendering is required for faster fill rates, but without sacrificing UI quality. Foreground swap chains are created by setting the DXGI_SWAP_CHAIN_FLAG_FOREGROUND_LAYER swap chain flag in the DXGI_SWAP_CHAIN_DESC1 that pDesc points to. Foreground swap chains must also use the DXGI_ALPHA_MODE_PREMULTIPLIED alpha mode, and must use DXGI_SCALING_NONE. Premultiplied alpha means that each pixel's color values are expected to be already multiplied by the alpha value before the frame is presented. For example, a 100% white BGRA pixel at 50% alpha is set to (0.5, 0.5, 0.5, 0.5). The alpha premultiplication step can be done in the output-merger stage by applying an app blend state (see ID3D11BlendState) with the D3D11_RENDER_TARGET_BLEND_DESC structure's SrcBlend field set to D3D11_SRC_ALPHA. If the alpha premultiplication step is not done, colors on the foreground swap chain will be brighter than expected. The foreground swap chain will use multiplane overlays if supported by the hardware. Call IDXGIOutput2::SupportsOverlays to query the adapter for overlay support. The following example creates a foreground swap chain for a CoreWindow: This doc was truncated. Read more on docs.microsoft.com. Identifies the adapter on which a shared resource object was created. A handle to a shared resource object. The IDXGIResource1::CreateSharedHandle method returns this handle. A pointer to a variable that receives a locally unique identifier (LUID) value that identifies the adapter. LUID is defined in Dxgi.h. An LUID is a 64-bit value that is guaranteed to be unique only on the operating system on which it was generated. The uniqueness of an LUID is guaranteed only until the operating system is restarted. GetSharedResourceAdapterLuid returns: This doc was truncated. You cannot share resources across adapters. Therefore, you cannot open a shared resource on an adapter other than the adapter on which the resource was created. Call GetSharedResourceAdapterLuid before you open a shared resource to ensure that the resource was created on the appropriate adapter. To open a shared resource, call the ID3D11Device1::OpenSharedResource1 or ID3D11Device1::OpenSharedResourceByName method. Registers an application window to receive notification messages of changes of stereo status. The handle of the window to send a notification message to when stereo status change occurs. Identifies the notification message to send. A pointer to a key value that an application can pass to the IDXGIFactory2::UnregisterStereoStatus method to unregister the notification message that wMsg specifies. RegisterStereoStatusWindow returns: This doc was truncated. Learn more about this API from docs.microsoft.com. Registers to receive notification of changes in stereo status by using event signaling. A handle to the event object that the operating system sets when notification of stereo status change occurs. The CreateEvent or OpenEvent function returns this handle. A pointer to a key value that an application can pass to the IDXGIFactory2::UnregisterStereoStatus method to unregister the notification event that hEvent specifies. RegisterStereoStatusEvent returns: This doc was truncated. Learn more about this API from docs.microsoft.com. Unregisters a window or an event to stop it from receiving notification when stereo status changes. A key value for the window or event to unregister. The IDXGIFactory2::RegisterStereoStatusWindow or IDXGIFactory2::RegisterStereoStatusEvent method returns this value. Platform Update for Windows 7:  On Windows 7 or Windows Server 2008 R2 with the Platform Update for Windows 7 installed, UnregisterStereoStatus has no effect. For more info about the Platform Update for Windows 7, see Platform Update for Windows 7. Registers an application window to receive notification messages of changes of occlusion status. The handle of the window to send a notification message to when occlusion status change occurs. Identifies the notification message to send. A pointer to a key value that an application can pass to the IDXGIFactory2::UnregisterOcclusionStatus method to unregister the notification message that wMsg specifies. RegisterOcclusionStatusWindow returns: This doc was truncated. Apps choose the Windows message that Windows sends when occlusion status changes. Registers to receive notification of changes in occlusion status by using event signaling. A handle to the event object that the operating system sets when notification of occlusion status change occurs. The CreateEvent or OpenEvent function returns this handle. A pointer to a key value that an application can pass to the IDXGIFactory2::UnregisterOcclusionStatus method to unregister the notification event that hEvent specifies. RegisterOcclusionStatusEvent returns: This doc was truncated. If you call RegisterOcclusionStatusEvent multiple times with the same event handle, RegisterOcclusionStatusEvent fails with DXGI_ERROR_INVALID_CALL. If you call RegisterOcclusionStatusEvent multiple times with the different event handles, RegisterOcclusionStatusEvent properly registers the events. Read more on docs.microsoft.com. Unregisters a window or an event to stop it from receiving notification when occlusion status changes. A key value for the window or event to unregister. The IDXGIFactory2::RegisterOcclusionStatusWindow or IDXGIFactory2::RegisterOcclusionStatusEvent method returns this value. Platform Update for Windows 7:  On Windows 7 or Windows Server 2008 R2 with the Platform Update for Windows 7 installed, UnregisterOcclusionStatus has no effect. For more info about the Platform Update for Windows 7, see Platform Update for Windows 7. Creates a swap chain that you can use to send Direct3D content into the DirectComposition API or a Xaml framework to compose in a window. For Direct3D 11, and earlier versions of Direct3D, this is a pointer to the Direct3D device for the swap chain. For Direct3D 12 this is a pointer to a direct command queue (refer to ID3D12CommandQueue). This parameter cannot be NULL. Software drivers, like D3D_DRIVER_TYPE_REFERENCE, are not supported for composition swap chains. A pointer to a DXGI_SWAP_CHAIN_DESC1 structure for the swap-chain description. This parameter cannot be NULL. You must specify the DXGI_SWAP_EFFECT_FLIP_SEQUENTIAL value in the SwapEffect member of DXGI_SWAP_CHAIN_DESC1 because CreateSwapChainForComposition supports only flip presentation model. You must also specify the DXGI_SCALING_STRETCH value in the Scaling member of DXGI_SWAP_CHAIN_DESC1. Read more on docs.microsoft.com. A pointer to the IDXGIOutput interface for the output to restrict content to. You must also pass the DXGI_PRESENT_RESTRICT_TO_OUTPUT flag in a IDXGISwapChain1::Present1 call to force the content to appear blacked out on any other output. If you want to restrict the content to a different output, you must create a new swap chain. However, you can conditionally restrict content based on the DXGI_PRESENT_RESTRICT_TO_OUTPUT flag. Set this parameter to NULL if you don't want to restrict content to an output target. Read more on docs.microsoft.com. A pointer to a variable that receives a pointer to the IDXGISwapChain1 interface for the swap chain that CreateSwapChainForComposition creates. CreateSwapChainForComposition returns: This doc was truncated. You can use composition swap chains with either: * DirectComposition's IDCompositionVisual interface, * System XAML's [SwapChainPanel](/uwp/api/windows.ui.xaml.controls.swapchainpanel) or [SwapChainBackgroundPanel](/uwp/api/windows.ui.xaml.controls.swapchainbackgroundpanel) classes. * [Windows UI Library (WinUI) 3](https://docs.microsoft.com/windows/apps/winui/) XAML's [SwapChainPanel](/windows/windows-app-sdk/api/winrt/microsoft.ui.xaml.controls.swapchainpanel) or [SwapChainBackgroundPanel](/windows/windows-app-sdk/api/winrt/microsoft.ui.xaml.controls.swapchainbackgroundpanel) classes. For DirectComposition, you can call the IDCompositionVisual::SetContent method to set the swap chain as the content of a visual object, which then allows you to bind the swap chain to the visual tree. For XAML, the SwapChainBackgroundPanel class exposes a classic COM interface ISwapChainBackgroundPanelNative. You can use the ISwapChainBackgroundPanelNative::SetSwapChain method to bind to the XAML UI graph. For info about how to use composition swap chains with XAML’s SwapChainBackgroundPanel class, see DirectX and XAML interop. The IDXGISwapChain::SetFullscreenState, IDXGISwapChain::ResizeTarget, IDXGISwapChain::GetContainingOutput, IDXGISwapChain1::GetHwnd, and IDXGISwapChain::GetCoreWindow methods aren't valid on this type of swap chain. If you call any of these methods on this type of swap chain, they fail. For info about how to choose a format for the swap chain's back buffer, see Converting data for the color space. Read more on docs.microsoft.com. The IID guid for this interface. {50c83a1c-e072-4c48-87b0-3630fa36a6d0} Sets application-defined data to the object and associates that data with a GUID. Type: REFGUID A GUID that identifies the data. Use this GUID in a call to GetPrivateData to get the data. Read more on docs.microsoft.com. Type: UINT The size of the object's data. Read more on docs.microsoft.com. Type: const void* A pointer to the object's data. Read more on docs.microsoft.com. Type: HRESULT Returns one of the DXGI_ERROR values. SetPrivateData makes a copy of the specified data and stores it with the object. Private data that SetPrivateData stores in the object occupies the same storage space as private data that is stored by associated Direct3D objects (for example, by a Microsoft Direct3D 11 device through ID3D11Device::SetPrivateData or by a Direct3D 11 child device through ID3D11DeviceChild::SetPrivateData). The debug layer reports memory leaks by outputting a list of object interface pointers 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 pointer caused the leak. To set the friendly name, use the SetPrivateData method and the well-known private data GUID (WKPDID_D3DDebugObjectName) that is in D3Dcommon.h. For example, to give pContext a friendly name of My name, use the following code: This doc was truncated. Read more on docs.microsoft.com. Set an interface in the object's private data. Type: REFGUID A GUID identifying the interface. Read more on docs.microsoft.com. Type: const IUnknown* The interface to set. Read more on docs.microsoft.com. Type: HRESULT Returns one of the following DXGI_ERROR. This API associates an interface pointer with the object. When the interface is set its reference count is incremented. When the data are overwritten (by calling SPD or SPDI with the same GUID) or the object is destroyed, ::Release() is called and the interface's reference count is decremented. Read more on docs.microsoft.com. Gets the parent of the object. Type: REFIID The ID of the requested interface. Read more on docs.microsoft.com. Type: void** The address of a pointer to the parent object. Read more on docs.microsoft.com. Type: HRESULT Returns one of the DXGI_ERROR values. Learn more about this API from docs.microsoft.com. The IID guid for this interface. {aec22fb8-76f3-4639-9be0-28eb43a67a2e} Get a description of the output. Type: HRESULT Returns a code that indicates success or failure. S_OK if successful, DXGI_ERROR_INVALID_CALL if pDesc is passed in as NULL. On a high DPI desktop, GetDesc returns the visualized screen size unless the app is marked high DPI aware. For info about writing DPI-aware Win32 apps, see High DPI. Gets the display modes that match the requested format and other input options. (IDXGIOutput.GetDisplayModeList) Type: DXGI_FORMAT The color format (see DXGI_FORMAT). Read more on docs.microsoft.com. Type: UINT Options for modes to include (see DXGI_ENUM_MODES). DXGI_ENUM_MODES_SCALING needs to be specified to expose the display modes that require scaling. Centered modes, requiring no scaling and corresponding directly to the display output, are enumerated by default. Read more on docs.microsoft.com. Type: UINT* Set pDesc to NULL so that pNumModes returns the number of display modes that match the format and the options. Otherwise, pNumModes returns the number of display modes returned in pDesc. Read more on docs.microsoft.com. Type: DXGI_MODE_DESC* A pointer to a list of display modes (see DXGI_MODE_DESC); set to NULL to get the number of display modes. Read more on docs.microsoft.com. Type: HRESULT Returns one of the following DXGI_ERROR. It is rare, but possible, that the display modes available can change immediately after calling this method, in which case DXGI_ERROR_MORE_DATA is returned (if there is not enough room for all the display modes). If GetDisplayModeList is called from a Remote Desktop Services session (formerly Terminal Services session), DXGI_ERROR_NOT_CURRENTLY_AVAILABLE is returned. In general, when switching from windowed to full-screen mode, a swap chain automatically chooses a display mode that meets (or exceeds) the resolution, color depth and refresh rate of the swap chain. To exercise more control over the display mode, use this API to poll the set of display modes that are validated against monitor capabilities, or all modes that match the desktop (if the desktop settings are not validated against the monitor). As shown, this API is designed to be called twice. First to get the number of modes available, and second to return a description of the modes. This doc was truncated. Read more on docs.microsoft.com. Finds the display mode that most closely matches the requested display mode. (IDXGIOutput.FindClosestMatchingMode) Type: const DXGI_MODE_DESC* The desired display mode (see DXGI_MODE_DESC). Members of DXGI_MODE_DESC can be unspecified indicating no preference for that member. A value of 0 for Width or Height indicates the value is unspecified. If either Width or Height are 0, both must be 0. A numerator and denominator of 0 in RefreshRate indicate it is unspecified. Other members of DXGI_MODE_DESC have enumeration values indicating the member is unspecified. If pConcernedDevice is NULL, Format cannot be DXGI_FORMAT_UNKNOWN. Read more on docs.microsoft.com. Type: DXGI_MODE_DESC* The mode that most closely matches pModeToMatch. Read more on docs.microsoft.com. Type: IUnknown* A pointer to the Direct3D device interface. If this parameter is NULL, only modes whose format matches that of pModeToMatch will be returned; otherwise, only those formats that are supported for scan-out by the device are returned. For info about the formats that are supported for scan-out by the device at each feature level: This doc was truncated. Read more on docs.microsoft.com. Type: HRESULT Returns one of the following DXGI_ERROR. FindClosestMatchingMode behaves similarly to the IDXGIOutput1::FindClosestMatchingMode1 except FindClosestMatchingMode considers only the mono display modes. IDXGIOutput1::FindClosestMatchingMode1 considers only stereo modes if you set the Stereo member in the DXGI_MODE_DESC1 structure that pModeToMatch points to, and considers only mono modes if Stereo is not set. IDXGIOutput1::FindClosestMatchingMode1 returns a matched display-mode set with only stereo modes or only mono modes. FindClosestMatchingMode behaves as though you specified the input mode as mono. Read more on docs.microsoft.com. Halt a thread until the next vertical blank occurs. Type: HRESULT Returns one of the following DXGI_ERROR. A vertical blank occurs when the raster moves from the lower right corner to the upper left corner to begin drawing the next frame. Takes ownership of an output. Type: IUnknown* A pointer to the IUnknown interface of a device (such as an ID3D10Device). Read more on docs.microsoft.com. Type: BOOL Set to TRUE to enable other threads or applications to take ownership of the device; otherwise, set to FALSE. Read more on docs.microsoft.com. Type: HRESULT Returns one of the DXGI_ERROR values. When you are finished with the output, call IDXGIOutput::ReleaseOwnership. TakeOwnership should not be called directly by applications, since results will be unpredictable. It is called implicitly by the DXGI swap chain object during full-screen transitions, and should not be used as a substitute for swap-chain methods.

Notes for Windows Store apps

If a Windows Store app uses TakeOwnership, it fails with DXGI_ERROR_NOT_CURRENTLY_AVAILABLE. Read more on docs.microsoft.com. Releases ownership of the output. If you are not using a swap chain, get access to an output by calling IDXGIOutput::TakeOwnership and release it when you are finished by calling IDXGIOutput::ReleaseOwnership. An application that uses a swap chain will typically not call either of these methods. Gets a description of the gamma-control capabilities. Type: DXGI_GAMMA_CONTROL_CAPABILITIES* A pointer to a description of the gamma-control capabilities (see DXGI_GAMMA_CONTROL_CAPABILITIES). Read more on docs.microsoft.com. Type: HRESULT Returns one of the DXGI_ERROR values.
Note  Calling this method is only supported while in full-screen mode.
 
 For info about using gamma correction, see Using gamma correction. Read more on docs.microsoft.com. Sets the gamma controls. Type: const DXGI_GAMMA_CONTROL* A pointer to a DXGI_GAMMA_CONTROL structure that describes the gamma curve to set. Read more on docs.microsoft.com. Type: HRESULT Returns one of the DXGI_ERROR values.
Note  Calling this method is only supported while in full-screen mode.
 
 For info about using gamma correction, see Using gamma correction. Read more on docs.microsoft.com. Gets the gamma control settings. Type: DXGI_GAMMA_CONTROL* An array of gamma control settings (see DXGI_GAMMA_CONTROL). Read more on docs.microsoft.com. Type: HRESULT Returns one of the DXGI_ERROR values.
Note  Calling this method is only supported while in full-screen mode.
 
 For info about using gamma correction, see Using gamma correction. Read more on docs.microsoft.com. Changes the display mode. Type: IDXGISurface* A pointer to a surface (see IDXGISurface) used for rendering an image to the screen. The surface must have been created as a back buffer (DXGI_USAGE_BACKBUFFER). Read more on docs.microsoft.com. Type: HRESULT Returns one of the DXGI_ERROR values. IDXGIOutput::SetDisplaySurface should not be called directly by applications, since results will be unpredictable. It is called implicitly by the DXGI swap chain object during full-screen transitions, and should not be used as a substitute for swap-chain methods. This method should only be called between IDXGIOutput::TakeOwnership and IDXGIOutput::ReleaseOwnership calls.

Notes for Windows Store apps

If a Windows Store app uses SetDisplaySurface, it fails with DXGI_ERROR_NOT_CURRENTLY_AVAILABLE. Read more on docs.microsoft.com. Gets a copy of the current display surface. Type: IDXGISurface* A pointer to a destination surface (see IDXGISurface). Read more on docs.microsoft.com. Type: HRESULT Returns one of the DXGI_ERROR values. IDXGIOutput::GetDisplaySurfaceData can only be called when an output is in full-screen mode. If the method succeeds, DXGI fills the destination surface. Use IDXGIOutput::GetDesc to determine the size (width and height) of the output when you want to allocate space for the destination surface. This is true regardless of target monitor rotation. A destination surface created by a graphics component (such as Direct3D 10) must be created with CPU-write permission (see D3D10_CPU_ACCESS_WRITE). Other surfaces should be created with CPU read-write permission (see D3D10_CPU_ACCESS_READ_WRITE). This method will modify the surface data to fit the destination surface (stretch, shrink, convert format, rotate). The stretch and shrink is performed with point-sampling. Read more on docs.microsoft.com. Gets statistics about recently rendered frames. Type: DXGI_FRAME_STATISTICS* A pointer to frame statistics (see DXGI_FRAME_STATISTICS). Read more on docs.microsoft.com. Type: HRESULT If this function succeeds, it returns S_OK. Otherwise, it might return DXGI_ERROR_INVALID_CALL. This API is similar to IDXGISwapChain::GetFrameStatistics.
Note  Calling this method is only supported while in full-screen mode.
 
 Read more on docs.microsoft.com. The IID guid for this interface. {ae02eedb-c735-4690-8d52-5a8dc20213aa} Get a description of the surface. Type: HRESULT Returns S_OK if successful; otherwise, returns one of the error codes that are described in the DXGI_ERROR topic. Learn more about this API from docs.microsoft.com. Get a pointer to the data contained in the surface, and deny GPU access to the surface. Type: DXGI_MAPPED_RECT* A pointer to the surface data (see DXGI_MAPPED_RECT). Read more on docs.microsoft.com. Type: UINT CPU read-write flags. These flags can be combined with a logical OR. This doc was truncated. Read more on docs.microsoft.com. Type: HRESULT Returns S_OK if successful; otherwise, returns one of the error codes that are described in the DXGI_ERROR topic. Use IDXGISurface::Map to access a surface from the CPU. To release a mapped surface (and allow GPU access) call IDXGISurface::Unmap. Invalidate the pointer to the surface retrieved by IDXGISurface::Map and re-enable GPU access to the resource. Type: HRESULT Returns S_OK if successful; otherwise, returns one of the error codes that are described in the DXGI_ERROR topic. Learn more about this API from docs.microsoft.com. The IID guid for this interface. {cafcb56c-6ac3-4889-bf47-9e23bbd260ec} Presents a rendered image to the user. Type: UINT An integer that specifies how to synchronize presentation of a frame with the vertical blank. For the bit-block transfer (bitblt) model (DXGI_SWAP_EFFECT_DISCARD or DXGI_SWAP_EFFECT_SEQUENTIAL), values are: This doc was truncated. Read more on docs.microsoft.com. Type: UINT An integer value that contains swap-chain presentation options. These options are defined by the DXGI_PRESENT constants. Read more on docs.microsoft.com. Type: HRESULT Possible return values include: S_OK, DXGI_ERROR_DEVICE_RESET or DXGI_ERROR_DEVICE_REMOVED (see DXGI_ERROR), DXGI_STATUS_OCCLUDED (see DXGI_STATUS), or D3DDDIERR_DEVICEREMOVED.
Note  The Present method can return either DXGI_ERROR_DEVICE_REMOVED or D3DDDIERR_DEVICEREMOVED if a video card has been physically removed from the computer, or a driver upgrade for the video card has occurred.
 
 Starting with Direct3D 11.1, consider using IDXGISwapChain1::Present1 because you can then use dirty rectangles and the scroll rectangle in the swap chain presentation and as such use less memory bandwidth and as a result less system power. For more info about using dirty rectangles and the scroll rectangle in swap chain presentation, see Using dirty rectangles and the scroll rectangle in swap chain presentation. For the best performance when flipping swap-chain buffers in a full-screen application, see Full-Screen Application Performance Hints. Because calling Present might cause the render thread to wait on the message-pump thread, be careful when calling this method in an application that uses multiple threads. For more details, see Multithreading Considerations. This doc was truncated. Read more on docs.microsoft.com. Accesses one of the swap-chain's back buffers. Type: UINT A zero-based buffer index. If the swap chain's swap effect is DXGI_SWAP_EFFECT_DISCARD, this method can only access the first buffer; for this situation, set the index to zero. If the swap chain's swap effect is either DXGI_SWAP_EFFECT_SEQUENTIAL or DXGI_SWAP_EFFECT_FLIP_SEQUENTIAL, only the swap chain's zero-index buffer can be read from and written to. The swap chain's buffers with indexes greater than zero can only be read from; so if you call the IDXGIResource::GetUsage method for such buffers, they have the DXGI_USAGE_READ_ONLY flag set. Read more on docs.microsoft.com. Type: REFIID The type of interface used to manipulate the buffer. Read more on docs.microsoft.com. Type: void** A pointer to a back-buffer interface. Read more on docs.microsoft.com. Type: HRESULT Returns one of the following DXGI_ERROR. Learn more about this API from docs.microsoft.com. Sets the display state to windowed or full screen. Type: BOOL A Boolean value that specifies whether to set the display state to windowed or full screen. TRUE for full screen, and FALSE for windowed. Read more on docs.microsoft.com. Type: [in, optional] IDXGIOutput* If you pass TRUE to the Fullscreen parameter to set the display state to full screen, you can optionally set this parameter to a pointer to an IDXGIOutput interface for the output target that contains the swap chain. If you set this parameter to NULL, DXGI will choose the output based on the swap-chain's device and the output window's placement. If you pass FALSE to Fullscreen, then you must set this parameter to NULL. Read more on docs.microsoft.com. Type: HRESULT This method returns one of these values. - **S_OK** if the action succeeded and the swap chain was placed in the requested state. - **DXGI_ERROR_NOT_CURRENTLY_AVAILABLE** if the action failed. When this error is returned, your application can continue to run in windowed mode and try to switch to full-screen mode later. There are many reasons why a windowed-mode swap chain cannot switch to full-screen mode. Here are some examples. - The application is running over Terminal Server. - The output window is occluded. - The output window does not have keyboard focus. - Another application is already in full-screen mode. - **DXGI_STATUS_MODE_CHANGE_IN_PROGRESS** is returned if a fullscreen/windowed mode transition is occurring when this API is called. - Other error codes if you run out of memory or encounter another unexpected fault; these codes may be treated as hard, non-continuable errors. DXGI may change the display state of a swap chain in response to end user or system requests. We recommend that you create a windowed swap chain and allow the end user to change the swap chain to full screen through SetFullscreenState; that is, do not set the Windowed member of DXGI_SWAP_CHAIN_DESC to FALSE to force the swap chain to be full screen. However, if you create the swap chain as full screen, also provide the end user with a list of supported display modes because a swap chain that is created with an unsupported display mode might cause the display to go black and prevent the end user from seeing anything. Also, we recommend that you have a time-out confirmation screen or other fallback mechanism when you allow the end user to change display modes.

Notes for Windows Store apps

If a Windows Store app calls SetFullscreenState to set the display state to full screen, SetFullscreenState fails with DXGI_ERROR_NOT_CURRENTLY_AVAILABLE. You cannot call SetFullscreenState on a swap chain that you created with IDXGIFactory2::CreateSwapChainForComposition. For the flip presentation model, after you transition the display state to full screen, you must call ResizeBuffers to ensure that your call to IDXGISwapChain1::Present1 succeeds. Read more on docs.microsoft.com. Get the state associated with full-screen mode. Type: BOOL* A pointer to a boolean whose value is either: This doc was truncated. Read more on docs.microsoft.com. Type: IDXGIOutput** A pointer to the output target (see IDXGIOutput) when the mode is full screen; otherwise NULL. Read more on docs.microsoft.com. Type: HRESULT Returns one of the following DXGI_ERROR. When the swap chain is in full-screen mode, a pointer to the target output will be returned and its reference count will be incremented. Get a description of the swap chain. Type: HRESULT Returns one of the following DXGI_ERROR. Learn more about this API from docs.microsoft.com. Changes the swap chain's back buffer size, format, and number of buffers. This should be called when the application window is resized. Type: UINT The number of buffers in the swap chain (including all back and front buffers). This number can be different from the number of buffers with which you created the swap chain. This number can't be greater than DXGI_MAX_SWAP_CHAIN_BUFFERS. Set this number to zero to preserve the existing number of buffers in the swap chain. You can't specify less than two buffers for the flip presentation model. Read more on docs.microsoft.com. Type: UINT The new width of the back buffer. If you specify zero, DXGI will use the width of the client area of the target window. You can't specify the width as zero if you called the IDXGIFactory2::CreateSwapChainForComposition method to create the swap chain for a composition surface. Read more on docs.microsoft.com. Type: UINT The new height of the back buffer. If you specify zero, DXGI will use the height of the client area of the target window. You can't specify the height as zero if you called the IDXGIFactory2::CreateSwapChainForComposition method to create the swap chain for a composition surface. Read more on docs.microsoft.com. Type: DXGI_FORMAT A DXGI_FORMAT-typed value for the new format of the back buffer. Set this value to DXGI_FORMAT_UNKNOWN to preserve the existing format of the back buffer. The flip presentation model supports a more restricted set of formats than the bit-block transfer (bitblt) model. Read more on docs.microsoft.com. Type: UINT A combination of DXGI_SWAP_CHAIN_FLAG-typed values that are combined by using a bitwise OR operation. The resulting value specifies options for swap-chain behavior. Read more on docs.microsoft.com. Type: HRESULT Returns S_OK if successful; an error code otherwise. For a list of error codes, see DXGI_ERROR. You can't resize a swap chain unless you release all outstanding references to its back buffers. You must release all of its direct and indirect references on the back buffers in order for ResizeBuffers to succeed. Direct references are held by the application after it calls AddRef on a resource. Indirect references are held by views to a resource, binding a view of the resource to a device context, a command list that used the resource, a command list that used a view to that resource, a command list that executed another command list that used the resource, and so on. Before you call ResizeBuffers, ensure that the application releases all references (by calling the appropriate number of Release invocations) on the resources, any views to the resource, and any command lists that use either the resources or views, and ensure that neither the resource nor a view is still bound to a device context. You can use ID3D11DeviceContext::ClearState to ensure that all references are released. If a view is bound to a deferred context, you must discard the partially built command list as well (by calling ID3D11DeviceContext::ClearState, then ID3D11DeviceContext::FinishCommandList, then Release on the command list). After you call ResizeBuffers, you can re-query interfaces via IDXGISwapChain::GetBuffer. For swap chains that you created with DXGI_SWAP_CHAIN_FLAG_GDI_COMPATIBLE, before you call ResizeBuffers, also call IDXGISurface1::ReleaseDC on the swap chain's back-buffer surface to ensure that you have no outstanding GDI device contexts (DCs) open. We recommend that you call ResizeBuffers when a client window is resized (that is, when an application receives a WM_SIZE message). The only difference between IDXGISwapChain::ResizeBuffers in Windows 8 versus Windows 7 is with flip presentation model swap chains that you create with the DXGI_SWAP_EFFECT_FLIP_SEQUENTIAL or DXGI_SWAP_EFFECT_FLIP_DISCARD value set. In Windows 8, you must call ResizeBuffers to realize a transition between full-screen mode and windowed mode; otherwise, your next call to the IDXGISwapChain::Present method fails. Read more on docs.microsoft.com. Resizes the output target. Type: const DXGI_MODE_DESC* A pointer to a DXGI_MODE_DESC structure that describes the mode, which specifies the new width, height, format, and refresh rate of the target. If the format is DXGI_FORMAT_UNKNOWN, ResizeTarget uses the existing format. We only recommend that you use DXGI_FORMAT_UNKNOWN when the swap chain is in full-screen mode as this method is not thread safe. Read more on docs.microsoft.com. Type: HRESULT Returns a code that indicates success or failure. DXGI_STATUS_MODE_CHANGE_IN_PROGRESS is returned if a full-screen/windowed mode transition is occurring when this API is called. See DXGI_ERROR for additional DXGI error codes. ResizeTarget resizes the target window when the swap chain is in windowed mode, and changes the display mode on the target output when the swap chain is in full-screen mode. Therefore, apps can call ResizeTarget to resize the target window (rather than a Microsoft Win32API such as SetWindowPos) without knowledge of the swap chain display mode. If a Windows Store app calls ResizeTarget, it fails with DXGI_ERROR_NOT_CURRENTLY_AVAILABLE. You cannot call ResizeTarget on a swap chain that you created with IDXGIFactory2::CreateSwapChainForComposition. Apps must still call IDXGISwapChain::ResizeBuffers after they call ResizeTarget because only ResizeBuffers can change the back buffers. But, if those apps have implemented window resize processing to call ResizeBuffers, they don't need to explicitly call ResizeBuffers after they call ResizeTarget because the window resize processing will achieve what the app requires. Read more on docs.microsoft.com. Get the output (the display monitor) that contains the majority of the client area of the target window. Type: IDXGIOutput** A pointer to the output interface (see IDXGIOutput). Read more on docs.microsoft.com. Type: HRESULT Returns one of the following DXGI_ERROR. If the method succeeds, the output interface will be filled and its reference count incremented. When you are finished with it, be sure to release the interface to avoid a memory leak. The output is also owned by the adapter on which the swap chain's device was created. You cannot call GetContainingOutput on a swap chain that you created with IDXGIFactory2::CreateSwapChainForComposition. To determine the output corresponding to such a swap chain, you should call IDXGIFactory::EnumAdapters and then IDXGIAdapter::EnumOutputs to enumerate over all of the available outputs. You should then intersect the bounds of your CoreWindow::Bounds with the desktop coordinates of each output, as reported by DXGI_OUTPUT_DESC1::DesktopCoordinates or DXGI_OUTPUT_DESC::DesktopCoordinates. Read more on docs.microsoft.com. Gets performance statistics about the last render frame. Type: DXGI_FRAME_STATISTICS* A pointer to a DXGI_FRAME_STATISTICS structure for the frame statistics. Read more on docs.microsoft.com. Type: HRESULT Returns one of the DXGI_ERROR values. You cannot use GetFrameStatistics for swap chains that both use the bit-block transfer (bitblt) presentation model and draw in windowed mode. You can only use GetFrameStatistics for swap chains that either use the flip presentation model or draw in full-screen mode. You set the DXGI_SWAP_EFFECT_FLIP_SEQUENTIAL value in the SwapEffect member of the DXGI_SWAP_CHAIN_DESC1 structure to specify that the swap chain uses the flip presentation model. Statistics are not reliable in many multiple monitor scenarios, as well as scenarios where other fullscreen apps are running. Read more on docs.microsoft.com. Gets the number of times that IDXGISwapChain::Present or IDXGISwapChain1::Present1 has been called. Type: UINT* A pointer to a variable that receives the number of calls. Read more on docs.microsoft.com. Type: HRESULT Returns one of the DXGI_ERROR values. For info about presentation statistics for a frame, see DXGI_FRAME_STATISTICS. The IID guid for this interface. {310d36a0-d2e7-4c0a-aa04-6a9d23b8886a} Gets a description of the swap chain. Returns S_OK if successful; an error code otherwise. For a list of error codes, see DXGI_ERROR. Learn more about this API from docs.microsoft.com. Gets a description of a full-screen swap chain. GetFullscreenDesc returns: This doc was truncated. The semantics of GetFullscreenDesc are identical to that of the IDXGISwapchain::GetDesc method for HWND-based swap chains. Retrieves the underlying HWND for this swap-chain object. A pointer to a variable that receives the HWND for the swap-chain object. Returns S_OK if successful; an error code otherwise. For a list of error codes, see DXGI_ERROR. If pHwnd receives NULL (that is, the swap chain is not HWND-based), GetHwnd returns DXGI_ERROR_INVALID_CALL. Applications call the IDXGIFactory2::CreateSwapChainForHwnd method to create a swap chain that is associated with an HWND. Retrieves the underlying CoreWindow object for this swap-chain object. A pointer to the globally unique identifier (GUID) of the CoreWindow object that is referenced by the ppUnk parameter. Read more on docs.microsoft.com. A pointer to a variable that receives a pointer to the CoreWindow object. GetCoreWindow returns: This doc was truncated. Applications call the IDXGIFactory2::CreateSwapChainForCoreWindow method to create a swap chain that is associated with an CoreWindow object. Presents a frame on the display screen. An integer that specifies how to synchronize presentation of a frame with the vertical blank. For the bit-block transfer (bitblt) model (DXGI_SWAP_EFFECT_DISCARD or DXGI_SWAP_EFFECT_SEQUENTIAL), values are: This doc was truncated. Read more on docs.microsoft.com. An integer value that contains swap-chain presentation options. These options are defined by the DXGI_PRESENT constants. A pointer to a DXGI_PRESENT_PARAMETERS structure that describes updated rectangles and scroll information of the frame to present. Possible return values include: S_OK, DXGI_ERROR_DEVICE_REMOVED , DXGI_STATUS_OCCLUDED, DXGI_ERROR_INVALID_CALL, or E_OUTOFMEMORY. An app can use Present1 to optimize presentation by specifying scroll and dirty rectangles. When the runtime has information about these rectangles, the runtime can then perform necessary bitblts during presentation more efficiently and pass this metadata to the Desktop Window Manager (DWM). The DWM can then use the metadata to optimize presentation and pass the metadata to indirect displays and terminal servers to optimize traffic over the wire. An app must confine its modifications to only the dirty regions that it passes to Present1, as well as modify the entire dirty region to avoid undefined resource contents from being exposed. For flip presentation model swap chains that you create with the DXGI_SWAP_EFFECT_FLIP_SEQUENTIAL value set, a successful presentation results in an unbind of back buffer 0 from the graphics pipeline, except for when you pass the DXGI_PRESENT_DO_NOT_SEQUENCE flag in the Flags parameter. For info about how data values change when you present content to the screen, see Converting data for the color space. For info about calling Present1 when your app uses multiple threads, see Multithread Considerations and Multithreading and DXGI.

Flip presentation model queue

Suppose the following frames with sync-interval values are queued from oldest (A) to newest (E) before you call Present1. A: 3, B: 0, C: 0, D: 1, E: 0 When you call Present1, the runtime shows frame A for only 1 vertical blank interval. The runtime terminates frame A early because of the sync interval 0 in frame B. Then the runtime shows frame D for 1 vertical blank interval, and then frame E until you submit a new presentation. The runtime discards frames B and C.

Variable refresh rate displays

It is a requirement of variable refresh rate displays that tearing is enabled. The CheckFeatureSupport method can be used to determine if this feature is available, and to set the required flags refer to the descriptions of DXGI_PRESENT_ALLOW_TEARING and DXGI_SWAP_CHAIN_FLAG_ALLOW_TEARING, and the Variable refresh rate displays/Vsync off section of DXGI 1.5 Improvements. Read more on docs.microsoft.com. Determines whether a swap chain supports “temporary mono.” Indicates whether to use the swap chain in temporary mono mode. TRUE indicates that you can use temporary-mono mode; otherwise, FALSE. Platform Update for Windows 7:  On Windows 7 or Windows Server 2008 R2 with the Platform Update for Windows 7 installed, IsTemporaryMonoSupported always returns FALSE because stereoscopic 3D display behavior isn’t available with the Platform Update for Windows 7. For more info about the Platform Update for Windows 7, see Platform Update for Windows 7. Temporary mono is a feature where a stereo swap chain can be presented using only the content in the left buffer. To present using the left buffer as a mono buffer, an application calls the IDXGISwapChain1::Present1 method with the DXGI_PRESENT_STEREO_TEMPORARY_MONO flag. All windowed swap chains support temporary mono. However, full-screen swap chains optionally support temporary mono because not all hardware supports temporary mono on full-screen swap chains efficiently. Read more on docs.microsoft.com. Gets the output (the display monitor) to which you can restrict the contents of a present operation. A pointer to a buffer that receives a pointer to the IDXGIOutput interface for the restrict-to output. An application passes this pointer to IDXGIOutput in a call to the IDXGIFactory2::CreateSwapChainForHwnd, IDXGIFactory2::CreateSwapChainForCoreWindow, or IDXGIFactory2::CreateSwapChainForComposition method to create the swap chain. Returns S_OK if the restrict-to output was successfully retrieved; otherwise, returns E_INVALIDARG if the pointer is invalid. If the method succeeds, the runtime fills the buffer at ppRestrictToOutput with a pointer to the restrict-to output interface. This restrict-to output interface has its reference count incremented. When you are finished with it, be sure to release the interface to avoid a memory leak. The output is also owned by the adapter on which the swap chain's device was created. Read more on docs.microsoft.com. Changes the background color of the swap chain. A pointer to a DXGI_RGBA structure that specifies the background color to set. SetBackgroundColor returns: This doc was truncated. The background color affects only swap chains that you create with DXGI_SCALING_NONE in windowed mode. You pass this value in a call to IDXGIFactory2::CreateSwapChainForHwnd, IDXGIFactory2::CreateSwapChainForCoreWindow, or IDXGIFactory2::CreateSwapChainForComposition. Typically, the background color is not visible unless the swap-chain contents are smaller than the destination window. When you set the background color, it is not immediately realized. It takes effect in conjunction with your next call to the IDXGISwapChain1::Present1 method. The DXGI_PRESENT flags that you pass to IDXGISwapChain1::Present1 can help achieve the effect that you require. For example, if you call SetBackgroundColor and then call IDXGISwapChain1::Present1 with the Flags parameter set to DXGI_PRESENT_DO_NOT_SEQUENCE, you change only the background color without changing the displayed contents of the swap chain. When you call the IDXGISwapChain1::Present1 method to display contents of the swap chain, IDXGISwapChain1::Present1 uses the DXGI_ALPHA_MODE value that is specified in the AlphaMode member of the DXGI_SWAP_CHAIN_DESC1 structure to determine how to handle the a member of the DXGI_RGBA structure, the alpha value of the background color, that achieves window transparency. For example, if AlphaMode is DXGI_ALPHA_MODE_IGNORE, IDXGISwapChain1::Present1 ignores the a member of DXGI_RGBA.
Note  Like all presentation data, we recommend that you perform floating point operations in a linear color space. When the desktop is in a fixed bit color depth mode, the operating system converts linear color data to standard RGB data (sRGB, gamma 2.2 corrected space) to compose to the screen. For more info, see Converting data for the color space.
 
 Read more on docs.microsoft.com. Retrieves the background color of the swap chain. A pointer to a DXGI_RGBA structure that receives the background color of the swap chain. GetBackgroundColor returns: This doc was truncated.
Note  The background color that GetBackgroundColor retrieves does not indicate what the screen currently displays. The background color indicates what the screen will display with your next call to the IDXGISwapChain1::Present1 method. The default value of the background color is black with full opacity: 0,0,0,1.
 
 Read more on docs.microsoft.com. Sets the rotation of the back buffers for the swap chain. A DXGI_MODE_ROTATION-typed value that specifies how to set the rotation of the back buffers for the swap chain. SetRotation returns: This doc was truncated. You can only use SetRotation to rotate the back buffers for flip-model swap chains that you present in windowed mode. SetRotation isn't supported for rotating the back buffers for flip-model swap chains that you present in full-screen mode. In this situation, SetRotation doesn't fail, but you must ensure that you specify no rotation (DXGI_MODE_ROTATION_IDENTITY) for the swap chain. Otherwise, when you call IDXGISwapChain1::Present1 or IDXGISwapChain::Present to present a frame, the presentation fails. Read more on docs.microsoft.com. Gets the rotation of the back buffers for the swap chain. A pointer to a variable that receives a DXGI_MODE_ROTATION-typed value that specifies the rotation of the back buffers for the swap chain. Returns S_OK if successful; an error code otherwise. For a list of error codes, see DXGI_ERROR. Platform Update for Windows 7:  On Windows 7 or Windows Server 2008 R2 with the Platform Update for Windows 7 installed, GetRotation fails with DXGI_ERROR_INVALID_CALL. For more info about the Platform Update for Windows 7, see Platform Update for Windows 7. Learn more about this API from docs.microsoft.com. The IID guid for this interface. {790a45f7-0d42-4876-983a-0a55cfe6f4aa} The length of the inline array. Gets a ref to an individual element of the inline array. ⚠ Important ⚠: When this struct is on the stack, do not let the returned reference outlive the stack frame that defines it. Gets this inline array as a span. ⚠ Important ⚠: When this struct is on the stack, do not let the returned span outlive the stack frame that defines it. Gets this inline array as a span. ⚠ Important ⚠: When this struct is on the stack, do not let the returned span outlive the stack frame that defines it. The length of the inline array. Gets a ref to an individual element of the inline array. ⚠ Important ⚠: When this struct is on the stack, do not let the returned reference outlive the stack frame that defines it. Gets this inline array as a span. ⚠ Important ⚠: When this struct is on the stack, do not let the returned span outlive the stack frame that defines it. Gets this inline array as a span. ⚠ Important ⚠: When this struct is on the stack, do not let the returned span outlive the stack frame that defines it. A handle to a Windows Runtime string. Use **HSTRING** to represent immutable strings in the Windows Runtime. JavaScript and other languages, such as C\#, and Microsoft Visual Basic, can use strings that are represented by using **HSTRING**. The following table shows how an **HSTRING** is represented in other languages. | Programming Language | String Representation | |-----------------------------------------------------------------------------------------|------------------------------------------------------------| | [C++/WinRT](/windows/uwp/cpp-and-winrt-apis/intro-to-using-cpp-with-winrt) | [winrt::hstring](/uwp/cpp-ref-for-winrt/hstring) class | | Visual C++ component extensions ([C++/CX](/cpp/cppcx/visual-c-language-reference-c-cx)) | [Platform::String](/cpp/cppcx/platform-string-class) class | | JavaScript | String object | | .NET Framework | System.String class | The **HSTRING** handle is a standard handle type. Semantically, an **HSTRING** containing the value **NULL** represents the empty string, which consists of zero content characters and a terminating **NULL** character. Creating a string via [**WindowsCreateString**](/windows/win32/api/winstring/nf-winstring-windowscreatestring) with zero characters will produce the handle value **NULL**. When calling [**WindowsGetStringRawBuffer**](/windows/win32/api/winstring/nf-winstring-windowsgetstringrawbuffer) with the value **NULL**, a pointer to an empty string followed only by the **NUL** terminating character will be returned. No distinct value exists to represent an **HSTRING** that is uninitialized. Call the [**WindowsCreateString**](/windows/win32/api/winstring/nf-winstring-windowscreatestring) function to create a new **HSTRING**, and call the [**WindowsDeleteString**](/windows/win32/api/winstring/nf-winstring-windowsdeletestring) function to release the reference to the backing string memory. Call the [**WindowsCreateStringReference**](/windows/win32/api/winstring/nf-winstring-windowscreatestringreference) function to create a string reference, which is also called a *fast-pass string*. Copy an **HSTRING** by calling the [**WindowsDuplicateString**](/windows/win32/api/winstring/nf-winstring-windowsduplicatestring) function. Concatenate two strings by calling the [**WindowsConcatString**](/windows/win32/api/winstring/nf-winstring-windowsconcatstring) function. Access the backing string memory by calling the [**WindowsGetStringRawBuffer**](/windows/win32/api/winstring/nf-winstring-windowsgetstringrawbuffer) function. **HSTRING** can store and use embedded **NUL** characters. Use the [**WindowsStringHasEmbeddedNull**](/windows/win32/api/winstring/nf-winstring-windowsstringhasembeddednull) function to check for embedded **NUL** characters before using any functions which may produce unexpected results. For example, most of the Windows functions use **LPCWSTR** as an input parameter, and they compute the length of the string only until the first **NUL** is encountered. The backing string must remain immutable and null-terminated. When calling code creates a string reference by using the [**WindowsCreateStringReference**](/windows/win32/api/winstring/nf-winstring-windowscreatestringreference) function, the memory containing the backing string representation is owned by the caller. The Windows Runtime relies on the contents of the original string to remain unchanged. When passing a string reference into the Windows Runtime, it is the caller’s responsibility to ensure that the string’s contents are unchanging and **NUL** terminated for the duration of the call. The Windows Runtime releases all references to the string reference when the call returns. When you receive an **HSTRING** as an out parameter, it is good practice to set the handle to **NULL** when you are finished with it. Call the [**WindowsPreallocateStringBuffer**](/windows/win32/api/winstring/nf-winstring-windowspreallocatestringbuffer) function to allocate a mutable string buffer that you can use to create an immutable **HSTRING**. When you have finished populating the buffer, you call the [**WindowsPromoteStringBuffer**](/windows/win32/api/winstring/nf-winstring-windowspromotestringbuffer) function to create the **HSTRING**. This two-phase construction pattern enables functionality that is similar to a "string builder." Read more on docs.microsoft.com. Gets the interfaces that are implemented by the current Windows Runtime class. Type: ULONG* The number of interfaces that are implemented by the current Windows Runtime object, excluding the IUnknown and IInspectable implementations. Read more on docs.microsoft.com. Type: IID** A pointer to an array that contains an IID for each interface implemented by the current Windows Runtime object. The IUnknown and IInspectable interfaces are excluded. Read more on docs.microsoft.com. Type: HRESULT This function can return the following values. This doc was truncated. Use the GetIids method to discover the interfaces that are implemented by a Windows Runtime object. A QueryInterface call on any IID in the iids array must succeed. The caller is responsible for freeing the IID array by using the CoTaskMemFree function. Read more on docs.microsoft.com. Gets the fully qualified name of the current Windows Runtime object. Type: HSTRING* The fully qualified name of the current Windows Runtime object. Read more on docs.microsoft.com. Type: HRESULT This function can return the following values. This doc was truncated. Use the GetRuntimeClassName method to retrieve the namespace-qualified name of a Windows Runtime object. The caller is responsible for freeing the className string by using the WindowsDeleteString function. The following table shows example class name strings that could be returned by the GetRuntimeClassName method. This doc was truncated. Read more on docs.microsoft.com. Gets the trust level of the current Windows Runtime object. Type: TrustLevel* The trust level of the current Windows Runtime object. The default is BaseLevel. Read more on docs.microsoft.com. Type: HRESULT This method always returns S_OK. Learn more about this API from docs.microsoft.com. The IID guid for this interface. {af86e2e0-b12d-4c6a-9c5a-d7aa65101e90} Represents the trust level of an activatable class. Classes can be activated depending on the trust level of the caller and the trust classification of the activatable class. RegisteredTrustLevel is an alias for this enumeration. Read more on docs.microsoft.com. The component has access to resources that are not protected. The component has access to resources requested in the app manifest and approved by the user. The component requires the full privileges of the user. Increments the reference count for an interface pointer to a COM object. You should call this method whenever you make a copy of an interface pointer. The method returns the new reference count. This value is intended to be used only for test purposes. A COM object uses a per-interface reference-counting mechanism to ensure that the object doesn't outlive references to it. You use **AddRef** to stabilize a copy of an interface pointer. It can also be called when the life of a cloned pointer must extend beyond the lifetime of the original pointer. The cloned pointer must be released by calling [IUnknown::Release](/windows/desktop/api/unknwn/nf-unknwn-iunknown-queryinterface(refiid_void)) on it. The internal reference counter that **AddRef** maintains should be a 32-bit unsigned integer. Read more on docs.microsoft.com. Decrements the reference count for an interface on a COM object. The method returns the new reference count. This value is intended to be used only for test purposes. When the reference count on an object reaches zero, **Release** must cause the interface pointer to free itself. When the released pointer is the only (formerly) outstanding reference to an object (whether the object supports single or multiple interfaces), the implementation must free the object. Note that aggregation of objects restricts the ability to recover interface pointers. Read more on docs.microsoft.com. The IID guid for this interface. {00000000-0000-0000-c000-000000000046} The IID guid for this interface. The reference that is returned comes from a permanent memory address, and is therefore safe to convert to a pointer and pass around or hold long-term. Non generic interface that allows constraining against a COM wrapper type directly. COM structs should implement . Contains extern methods from "api-ms-win-core-winrt-string-l1-1-0.dll". Contains extern methods from "d3d11.dll". Contains extern methods from "KERNEL32.dll". Contains extern methods from "USER32.dll". Decrements the reference count of a string buffer. Type: HRESULT This function always returns S_OK. Use the WindowsDeleteString function to de-allocate an [**HSTRING**](/windows/win32/winrt/hstring). Calling WindowsDeleteString decrements the reference count of the backing buffer, and if the reference count reaches 0, the Windows Runtime de-allocates the buffer. Creates a device that represents the display adapter. (D3D11CreateDevice) Type: IDXGIAdapter* A pointer to the video adapter to use when creating a device. Pass NULL to use the default adapter, which is the first adapter that is enumerated by IDXGIFactory1::EnumAdapters.
Note  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.
 
 Read more on docs.microsoft.com. Type: D3D_DRIVER_TYPE The D3D_DRIVER_TYPE, which represents the driver type to create. Read more on docs.microsoft.com. Type: HMODULE 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. Read more on docs.microsoft.com. Type: UINT The runtime layers to enable (see D3D11_CREATE_DEVICE_FLAG); values can be bitwise OR'd together. Read more on docs.microsoft.com. Type: const D3D_FEATURE_LEVEL* A pointer to an array of D3D_FEATURE_LEVELs, 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: This doc was truncated. Read more on docs.microsoft.com. Type: UINT The number of elements in pFeatureLevels. Read more on docs.microsoft.com. Type: UINT The SDK version; use D3D11_SDK_VERSION. Read more on docs.microsoft.com. Type: ID3D11Device** Returns the address of a pointer to an ID3D11Device object that represents the device created. If this parameter is NULL, no ID3D11Device will be returned. Read more on docs.microsoft.com. Type: D3D_FEATURE_LEVEL* 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. Read more on docs.microsoft.com. Type: ID3D11DeviceContext** Returns the address of a pointer to an ID3D11DeviceContext object that represents the device context. If this parameter is NULL, no ID3D11DeviceContext will be returned. Read more on docs.microsoft.com. Type: HRESULT 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. 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. This doc was truncated. Read more on docs.microsoft.com. Creates an instance of IDirect3DSurface from an IDXGISurface. Type: **[IInspectable](/windows/desktop/api/inspectable/nn-inspectable-iinspectable)\*\*** An [IDirect3DSurface](/uwp/api/windows.graphics.directx.direct3d11.idirect3dsurface) instance that wraps the [IDXGISurface](/windows/desktop/api/dxgi/nn-dxgi-idxgisurface). Read more on docs.microsoft.com. Type: [**HRESULT**](/windows/desktop/com/structure-of-com-error-codes) If the function succeeds, it returns **S_OK**. Otherwise, it returns an [**HRESULT**](/windows/desktop/com/structure-of-com-error-codes) [error code](/windows/desktop/com/com-error-codes-10). While we recommend [C++/WinRT](/windows/uwp/cpp-and-winrt-apis/index), if you're using C++/CX then you should call [CreateDirect3DSurface](./nf-windows-graphics-directx-direct3d11-interop-createdirect3dsurface.md) instead of **CreateDirect3D11DeviceFromDXGIDevice**. If you're using WRL then **CreateDirect3D11DeviceFromDXGIDevice** can be used as shown in this code example. This doc was truncated. Read more on docs.microsoft.com. A window receives this message when the user chooses a command from the Window menu (formerly known as the system or control menu) or when the user chooses the maximize button, minimize button, restore button, or close button. An application should return zero if it processes this message. To obtain the position coordinates in screen coordinates, use the following code: This doc was truncated. Read more on docs.microsoft.com. Closes an open object handle. A valid handle to an open object. If the function succeeds, the return value is nonzero. If the function fails, the return value is zero. To get extended error information, call GetLastError. If the application is running under a debugger, the function will throw an exception if it receives either a handle value that is not valid or a pseudo-handle value. This can happen if you close a handle twice, or if you call CloseHandle on a handle returned by the FindFirstFile function instead of calling the FindClose function. The CloseHandle function closes handles to the following objects: This doc was truncated. Read more on docs.microsoft.com. Frees the loaded dynamic-link library (DLL) module and, if necessary, decrements its reference count. A handle to the loaded library module. The LoadLibrary, LoadLibraryEx, GetModuleHandle, or GetModuleHandleEx function returns this handle. Read more on docs.microsoft.com. If the function succeeds, the return value is nonzero. If the function fails, the return value is zero. To get extended error information, call the GetLastError function. The system maintains a per-process reference count for each loaded module. A module that was loaded at process initialization due to load-time dynamic linking has a reference count of one. The reference count for a module is incremented each time the module is loaded by a call to LoadLibrary. The reference count is also incremented by a call to LoadLibraryEx unless the module is being loaded for the first time and is being loaded as a data or image file. The reference count is decremented each time the FreeLibrary or FreeLibraryAndExitThread function is called for the module. When a module's reference count reaches zero or the process terminates, the system unloads the module from the address space of the process. Before unloading a library module, the system enables the module to detach from the process by calling the module's DllMain function, if it has one, with the DLL_PROCESS_DETACH value. Doing so gives the library module an opportunity to clean up resources allocated on behalf of the current process. After the entry-point function returns, the library module is removed from the address space of the current process. It is not safe to call FreeLibrary from DllMain. For more information, see the Remarks section in DllMain. Calling FreeLibrary does not affect other processes that are using the same module. Use caution when calling FreeLibrary with a handle returned by GetModuleHandle. The GetModuleHandle function does not increment a module's reference count, so passing this handle to FreeLibrary can cause a module to be unloaded prematurely. A thread that must unload the DLL in which it is executing and then terminate itself should call FreeLibraryAndExitThread instead of calling FreeLibrary and ExitThread separately. Otherwise, a race condition can occur. For details, see the Remarks section of FreeLibraryAndExitThread. Read more on docs.microsoft.com. Returns the dots per inch (dpi) value for the specified window. The window that you want to get information about. The DPI for the window, which depends on the [DPI_AWARENESS](/windows/win32/api/windef/ne-windef-dpi_awareness) of the window. See the **Remarks** section for more information. An invalid *hwnd* value will result in a return value of 0. The following table indicates the return value of GetDpiForWindow based on the [DPI_AWARENESS](/windows/win32/api/windef/ne-windef-dpi_awareness) of the provided *hwnd*. This doc was truncated. Read more on docs.microsoft.com. Retrieves the specified system metric or system configuration setting taking into account a provided DPI. The system metric or configuration setting to be retrieved. See GetSystemMetrics for the possible values. The DPI to use for scaling the metric. If the function succeeds, the return value is nonzero. If the function fails, the return value is zero. To get extended error information, call GetLastError. This function returns the same result as GetSystemMetrics but scales it according to an arbitrary DPI you provide if appropriate. Places (posts) a message in the message queue associated with the thread that created the specified window and returns without waiting for the thread to process the message. (Unicode) Type: HWND A handle to the window whose window procedure is to receive the message. The following values have special meanings. This doc was truncated. Read more on docs.microsoft.com. Type: UINT The message to be posted. For lists of the system-provided messages, see System-Defined Messages. Read more on docs.microsoft.com. Type: WPARAM Additional message-specific information. Read more on docs.microsoft.com. Type: LPARAM Additional message-specific information. Read more on docs.microsoft.com. Type: BOOL If the function succeeds, the return value is nonzero. If the function fails, the return value is zero. To get extended error information, call GetLastError. When a message is blocked by UIPI the last error, retrieved with GetLastError, is set to 5 (access denied). Messages in a message queue are retrieved by calls to the GetMessage or PeekMessage function. Applications that need to communicate using HWND_BROADCAST should use the RegisterWindowMessage function to obtain a unique message for inter-application communication. The system only does marshalling for system messages (those in the range 0 to (WM_USER-1)). To send other messages (those >= WM_USER) to another process, you must do custom marshalling. If you send a message in the range below WM_USER to the asynchronous message functions (PostMessage, SendNotifyMessage, and SendMessageCallback), its message parameters cannot include pointers. Otherwise, the operation will fail. The functions will return before the receiving thread has had a chance to process the message and the sender will free the memory before it is used. Do not post the WM_QUIT message using PostMessage; use the PostQuitMessage function. An accessibility application can use PostMessage to post WM_APPCOMMAND messages to the shell to launch applications. This functionality is not guaranteed to work for other types of applications. There is a limit of 10,000 posted messages per message queue. This limit should be sufficiently large. If your application exceeds the limit, it should be redesigned to avoid consuming so many system resources. To adjust this limit, modify the following registry key. 
HKEY_LOCAL_MACHINE SOFTWARE Microsoft Windows NT CurrentVersion Windows USERPostMessageLimit
If the function fails, call GetLastError to get extended error information. GetLastError returns ERROR_NOT_ENOUGH_QUOTA when the limit is hit. The minimum acceptable value is 4000. Read more on docs.microsoft.com. Determines whether a window is maximized. Type: HWND A handle to the window to be tested. Read more on docs.microsoft.com. Type: BOOL If the window is zoomed, the return value is nonzero. If the window is not zoomed, the return value is zero. Learn more about this API from docs.microsoft.com. Represents a Win32 handle that can be closed with .