SharpDX.Direct3D11
The blend-state interface holds a description for blending state that you can bind to the output-merger stage.
ID3D11BlendState
A device-child interface accesses data used by a device.
ID3D11DeviceChild
Initializes a new instance of the class.
The native pointer.
Get a reference to the device that created this interface.
Address of a reference to a device (see ).
Any returned interfaces will have their reference count incremented by one, so be sure to call ::release() on the returned reference(s) before they are freed or else you will have a memory leak.
void ID3D11DeviceChild::GetDevice([Out] ID3D11Device** ppDevice)
Get application-defined data from a device child.
Guid associated with the data.
A reference to a variable that on input contains the size, in bytes, of the buffer that pData points to, and on output contains the size, in bytes, of the amount of data that GetPrivateData retrieved.
A reference to a buffer that GetPrivateData fills with data from the device child if pDataSize points to a value that specifies a buffer large enough to hold the data.
This method returns one of the codes described in the topic Direct3D 11 Return Codes.
The data stored in the device child is set by calling .
HRESULT ID3D11DeviceChild::GetPrivateData([In] const GUID& guid,[InOut] unsigned int* pDataSize,[Out, Buffer, Optional] void* pData)
Set application-defined data to a device child and associate that data with an application-defined guid.
Guid associated with the data.
Size of the data.
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.
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 .The debug layer reports memory leaks by outputting a list of object interface references along with their friendly names. The default friendly name is "<unnamed>". You can set the friendly name so that you can determine if the corresponding object interface reference caused the leak. To set the friendly name, use the SetPrivateData method and the that is in D3Dcommon.h. For example, to give pContext a friendly name of My name, use the following code:
static const char c_szName[] = "My name";
hr = pContext->SetPrivateData( , sizeof( c_szName ) - 1, c_szName );
HRESULT ID3D11DeviceChild::SetPrivateData([In] const GUID& guid,[In] unsigned int DataSize,[In, Buffer, Optional] const void* pData)
Associate an -derived interface with this device child and associate that interface with an application-defined guid.
Guid associated with the interface.
Pointer to an -derived interface to be associated with the device child.
This method returns one of the following Direct3D 11 Return Codes.
When this method is called ::addref() will be called on the -derived interface, and when the device child is detroyed ::release() will be called on the -derived interface.
HRESULT ID3D11DeviceChild::SetPrivateDataInterface([In] const GUID& guid,[In, Optional] const IUnknown* pData)
Gets or sets the debug-name for this object.
The debug name.
Get a reference to the device that created this interface.
Any returned interfaces will have their reference count incremented by one, so be sure to call ::release() on the returned reference(s) before they are freed or else you will have a memory leak.
GetDevice
void ID3D11DeviceChild::GetDevice([Out] ID3D11Device** ppDevice)
Constructs a new based on the specified description.
The device with which to associate the state object.
The state description.
The newly created object.
Constructs a new based on the specified description.
The device with which to associate the state object.
The state description.
The newly created object.
Initializes a new instance of the class.
The native pointer.
Gets the description for blending state that you used to create the blend-state object.
A reference to a structure that receives a description of the blend state.
You use the description for blending state in a call to the method to create the blend-state object.
void ID3D11BlendState::GetDesc([Out] D3D11_BLEND_DESC* pDesc)
Gets the description for blending state that you used to create the blend-state object.
You use the description for blending state in a call to the method to create the blend-state object.
GetDesc
void ID3D11BlendState::GetDesc([Out] D3D11_BLEND_DESC* pDesc)
A buffer interface accesses a buffer resource, which is unstructured memory. Buffers typically store vertex or index data.
ID3D11Buffer
A resource interface provides common actions on all resources.
ID3D11Resource
Constant MaximumMipLevels.
D3D11_REQ_MIP_LEVELS
Constant ResourceSizeInMegabytes.
D3D11_REQ_RESOURCE_SIZE_IN_MEGABYTES_EXPRESSION_A_TERM
Constant MaximumTexture1DArraySize.
D3D11_REQ_TEXTURE1D_ARRAY_AXIS_DIMENSION
Constant MaximumTexture2DArraySize.
D3D11_REQ_TEXTURE2D_ARRAY_AXIS_DIMENSION
Constant MaximumTexture1DSize.
D3D11_REQ_TEXTURE1D_U_DIMENSION
Constant MaximumTexture2DSize.
D3D11_REQ_TEXTURE2D_U_OR_V_DIMENSION
Constant MaximumTexture3DSize.
D3D11_REQ_TEXTURE3D_U_V_OR_W_DIMENSION
Constant MaximumTextureCubeSize.
D3D11_REQ_TEXTURECUBE_DIMENSION
Initializes a new instance of the class.
The native pointer.
Get the type of the resource.
Pointer to the resource type (see ).
void ID3D11Resource::GetType([Out] D3D11_RESOURCE_DIMENSION* pResourceDimension)
Set the eviction priority of a resource.
Eviction priority for the resource, which is one of the following values:
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, , 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.
void ID3D11Resource::SetEvictionPriority([In] unsigned int EvictionPriority)
Get the eviction priority of a resource.
One of the following values, which specifies the eviction priority for the resource:
unsigned int ID3D11Resource::GetEvictionPriority()
Gets a swap chain back buffer.
The type of the buffer.
The swap chain to get the buffer from.
The index of the desired buffer.
The buffer interface, or null on failure.
Calculates the sub resource index from a miplevel.
A zero-based index for the mipmap level to address; 0 indicates the first, most detailed mipmap level.
The zero-based index for the array level to address; always use 0 for volume (3D) textures.
Number of mipmap levels in the resource.
The index which equals MipSlice + (ArraySlice * MipLevels).
D3D11CalcSubresource
Calculates the resulting size at a single level for an original size.
The mip level to get the size.
Size of the base.
Size of the mipLevel
Calculates the sub resource index for a particular mipSlice and arraySlice.
The mip slice.
The array slice.
The size of slice. This values is resource dependent. Texture1D -> mipSize of the Width. Texture2D -> mipSize of the Height. Texture3D -> mipsize of the Depth
The resulting miplevel calulated for this instance with this mipSlice and arraySlice.
Get the type of the resource.
GetType
void ID3D11Resource::GetType([Out] D3D11_RESOURCE_DIMENSION* pResourceDimension)
Get the eviction priority of a resource.
GetEvictionPriority
unsigned int ID3D11Resource::GetEvictionPriority()
Initializes a new instance of the class.
The device with which to associate the buffer.
The description of the buffer.
Initializes a new instance of the class.
The device with which to associate the buffer.
Initial data used to initialize the buffer.
The description of the buffer.
Initializes a new instance of the class.
The device with which to associate the buffer.
The size, in bytes, of the buffer.
The usage pattern for the buffer.
Flags specifying how the buffer will be bound to the pipeline.
Flags specifying how the buffer will be accessible from the CPU.
Miscellaneous resource options.
The size (in bytes) of the structure element for structured buffers.
Initializes a new instance of the class.
The device with which to associate the buffer.
Initial data used to initialize the buffer.
The size, in bytes, of the buffer.
The usage pattern for the buffer.
Flags specifying how the buffer will be bound to the pipeline.
Flags specifying how the buffer will be accessible from the CPU.
Miscellaneous resource options.
The size (in bytes) of the structure element for structured buffers.
Creates a new instance of the class.
Type of the data to upload
The device with which to associate the buffer.
Flags specifying how the buffer will be bound to the pipeline.
Initial data used to initialize the buffer.
The size, in bytes, of the buffer. If 0 is specified, sizeof(T) is used.
The usage pattern for the buffer.
Flags specifying how the buffer will be accessible from the CPU.
Miscellaneous resource options.
The size (in bytes) of the structure element for structured buffers.
An initialized buffer
Creates a new instance of the class.
Type of the data to upload
The device with which to associate the buffer.
Flags specifying how the buffer will be bound to the pipeline.
Initial data used to initialize the buffer.
The size, in bytes, of the buffer. If 0 is specified, sizeof(T) * data.Length is used.
The usage pattern for the buffer.
Flags specifying how the buffer will be accessible from the CPU.
Miscellaneous resource options.
The size (in bytes) of the structure element for structured buffers.
An initialized buffer
Creates a new instance of the class.
Type of the data to upload
The device with which to associate the buffer.
Initial data used to initialize the buffer.
The description.
An initialized buffer
If the is at 0, sizeof(T) is used.
Creates a new instance of the class.
Type of the data to upload
The device with which to associate the buffer.
Initial data used to initialize the buffer.
The description.
An initialized buffer
If the is at 0, sizeof(T) * data.Length is used.
Initializes a new instance of the class.
The native pointer.
Get the properties of a buffer resource.
Pointer to a resource description (see ) filled in by the method.
void ID3D11Buffer::GetDesc([Out] D3D11_BUFFER_DESC* pDesc)
Get the properties of a buffer resource.
GetDesc
void ID3D11Buffer::GetDesc([Out] D3D11_BUFFER_DESC* pDesc)
Describes a buffer resource.
This structure is used by to create buffer resources.In addition to this structure, there is also a derived structure in D3D11.h (CD3D11_BUFFER_DESC) which behaves like an inherited class to help create a buffer description.If the bind flag is then the ByteWidth value must be in multiples of 16, and less than or equal to D3D11_REQ_CONSTANT_BUFFER_ELEMENT_COUNT.
D3D11_BUFFER_DESC
Initializes a new instance of the struct.
The size in bytes.
The usage.
The bind flags.
The cpu access flags.
The option flags.
The structure byte stride.
Size of the buffer in bytes.
unsigned int ByteWidth
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 ; see for all possible values.
D3D11_USAGE Usage
Identify how the buffer will be bound to the pipeline. Flags (see ) can be combined with a logical OR.
D3D11_BIND_FLAG BindFlags
CPU access flags (see ) or 0 if no CPU access is necessary. Flags can be combined with a logical OR.
D3D11_CPU_ACCESS_FLAG CPUAccessFlags
Miscellaneous flags (see ) or 0 if unused. Flags can be combined with a logical OR.
D3D11_RESOURCE_MISC_FLAG MiscFlags
The size of the structure (in bytes) when it represents a structured buffer.
unsigned int StructureByteStride
This interface encapsulates an HLSL class.
ID3D11ClassInstance
Initializes a class-instance object that represents an HLSL class instance.
Instances can be created (or gotten) before or after a shader is created. Use the same shader linkage object to acquire a class instance and create the shader the instance is going to be used in. For more information about using the interface, see {{Dynamic Linking}}.
An instance of .
The type name of a class to initialize.
Identifies the constant buffer that contains the class data.
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.
The texture slot for the first texture; there may be multiple textures following the offset.
The sampler slot for the first sampler; there may be multiple samplers following the offset.
Returns S_OK if successful; otherwise, returns one of the following {{Direct3D 11 Return Codes}}.
HRESULT ID3D11ClassLinkage::CreateClassInstance([In] const char* pClassTypeName,[In] int ConstantBufferOffset,[In] int ConstantVectorOffset,[In] int TextureOffset,[In] int SamplerOffset,[Out] ID3D11ClassInstance** ppInstance)
Initializes a new instance of the class.
The native pointer.
Gets the object associated with the current HLSL class.
No documentation.
For more information about using the interface, see Dynamic Linking.
void ID3D11ClassInstance::GetClassLinkage([Out] ID3D11ClassLinkage** ppLinkage)
Gets a description of the current HLSL class.
A reference to a structure that describes the current HLSL class.
For more information about using the 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.A created instance will work for any shader that contains a type of the same type name. For instance, a class instance created with the type name DefaultShader would work in any shader that contained a type DefaultShader even though several shaders could describe a different type. A gotten instance maps directly to an instance name/index in a shader. A class instance aquired using GetClassInstance will work for any shader that contains a class instance of the name used to generate the runtime instance, the instance does not have to be the same type in all of the shaders it's used in.An instance does not replace the importance of reflection for a particular shader since a gotten instance will not know its slot location and a created instance only specifies a type name.
void ID3D11ClassInstance::GetDesc([Out] D3D11_CLASS_INSTANCE_DESC* pDesc)
Gets the instance name of the current HLSL class.
The instance name of the current HLSL class.
The length of the pInstanceName parameter.
GetInstanceName will return a valid name only for instances acquired using .For more information about using the interface, see Dynamic Linking.
void ID3D11ClassInstance::GetInstanceName([Out, Buffer, Optional] char* pInstanceName,[InOut] SIZE_T* pBufferLength)
Gets the type of the current HLSL class.
Type of the current HLSL class.
The length of the pTypeName parameter.
GetTypeName will return a valid name only for instances acquired using .For more information about using the interface, see Dynamic Linking.
void ID3D11ClassInstance::GetTypeName([Out, Buffer, Optional] char* pTypeName,[InOut] SIZE_T* pBufferLength)
Gets the instance name of the current HLSL class.
GetInstanceName will return a valid name only for instances acquired using .For more information about using the interface, see {{Dynamic Linking}}.
The instance name of the current HLSL class.
void GetInstanceName([Out, Buffer, Optional] LPSTR pInstanceName,[InOut] SIZE_T* pBufferLength)
Gets the type of the current HLSL class.
GetTypeName will return a valid name only for instances acquired using .For more information about using the interface, see {{Dynamic Linking}}.
Type of the current HLSL class.
void GetTypeName([Out, Buffer, Optional] LPSTR pTypeName,[InOut] SIZE_T* pBufferLength)
Gets the object associated with the current HLSL class.
For more information about using the interface, see Dynamic Linking.
GetClassLinkage
void ID3D11ClassInstance::GetClassLinkage([Out] ID3D11ClassLinkage** ppLinkage)
Gets a description of the current HLSL class.
For more information about using the 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.A created instance will work for any shader that contains a type of the same type name. For instance, a class instance created with the type name DefaultShader would work in any shader that contained a type DefaultShader even though several shaders could describe a different type. A gotten instance maps directly to an instance name/index in a shader. A class instance aquired using GetClassInstance will work for any shader that contains a class instance of the name used to generate the runtime instance, the instance does not have to be the same type in all of the shaders it's used in.An instance does not replace the importance of reflection for a particular shader since a gotten instance will not know its slot location and a created instance only specifies a type name.
GetDesc
void ID3D11ClassInstance::GetDesc([Out] D3D11_CLASS_INSTANCE_DESC* pDesc)
This interface encapsulates an HLSL dynamic linkage.
ID3D11ClassLinkage
Create a new instance of .
Initializes a new instance of the class.
The native pointer.
Gets the class-instance object that represents the specified HLSL class.
The name of a class for which to get the class instance.
The index of the class instance.
The address of a reference to an interface to initialize.
For more information about using the 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 . 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 instead.
HRESULT ID3D11ClassLinkage::GetClassInstance([In] const char* pClassInstanceName,[In] unsigned int InstanceIndex,[Out] ID3D11ClassInstance** ppInstance)
Initializes a class-instance object that represents an HLSL class instance.
The type name of a class to initialize.
Identifies the constant buffer that contains the class data.
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.
The texture slot for the first texture; there may be multiple textures following the offset.
The sampler slot for the first sampler; there may be multiple samplers following the offset.
The address of a reference to an interface to initialize.
Returns 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 interface, see Dynamic Linking.
HRESULT ID3D11ClassLinkage::CreateClassInstance([In] const char* pClassTypeName,[In] unsigned int ConstantBufferOffset,[In] unsigned int ConstantVectorOffset,[In] unsigned int TextureOffset,[In] unsigned int SamplerOffset,[Out, Fast] ID3D11ClassInstance** ppInstance)
A compute-shader interface manages an executable program (a compute shader) that controls the compute-shader stage.
ID3D11ComputeShader
Initializes a new instance of the class.
The device used to create the shader.
The compiled shader bytecode.
Initializes a new instance of the class.
The device used to create the shader.
The compiled shader bytecode.
A dynamic class linkage interface.
Initializes a new instance of the class.
The native pointer.
This interface encapsulates methods for measuring GPU performance.
ID3D11Counter
This interface encapsulates methods for retrieving data from the GPU asynchronously.
ID3D11Asynchronous
Initializes a new instance of the class.
The native pointer.
Get the size of the data (in bytes) that is output when calling .
Size of the data (in bytes) that is output when calling GetData.
unsigned int ID3D11Asynchronous::GetDataSize()
Get the size of the data (in bytes) that is output when calling .
GetDataSize
unsigned int ID3D11Asynchronous::GetDataSize()
Constructs a new based on the specified description.
The device with which to associate the state object.
The counter description.
The newly created object.
Initializes a new instance of the class.
The native pointer.
Get a counter description.
Pointer to a counter description (see ).
void ID3D11Counter::GetDesc([Out] D3D11_COUNTER_DESC* pDesc)
Get a counter description.
GetDesc
void ID3D11Counter::GetDesc([Out] D3D11_COUNTER_DESC* pDesc)
Counter metadata that contains the type, name, units of measure, and a description of an existing counter.
Gets the data type of a counter (see ).
The type.
Gets 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.
The hardware counter count.
Gets a brief name for the counter.
The name.
Gets the units a counter measures.
The units.
Gets a description of the counter.
The description.
The depth-stencil-state interface holds a description for depth-stencil state that you can bind to the output-merger stage.
ID3D11DepthStencilState
Constructs a new based on the specified description.
The device with which to associate the state object.
The state description.
The newly created object.
Constructs a new based on the specified description.
The device with which to associate the state object.
The state description.
The newly created object.
Initializes a new instance of the class.
The native pointer.
Gets the description for depth-stencil state that you used to create the depth-stencil-state object.
A reference to a structure that receives a description of the depth-stencil state.
You use the description for depth-stencil state in a call to the method to create the depth-stencil-state object.
void ID3D11DepthStencilState::GetDesc([Out] D3D11_DEPTH_STENCIL_DESC* pDesc)
Gets the description for depth-stencil state that you used to create the depth-stencil-state object.
You use the description for depth-stencil state in a call to the method to create the depth-stencil-state object.
GetDesc
void ID3D11DepthStencilState::GetDesc([Out] D3D11_DEPTH_STENCIL_DESC* pDesc)
A depth-stencil-view interface accesses a texture resource during depth-stencil testing.
ID3D11DepthStencilView
A view interface specifies the parts of a resource the pipeline can access during rendering.
ID3D11View
Initializes a new instance of the class.
The native pointer.
Get the resource that is accessed through this view.
Address of a reference to the resource that is accessed through this view. (See .)
This function increments the reference count of the resource by one, so it is necessary to call Release on the returned reference when the application is done with it. Destroying (or losing) the returned reference before Release is called will result in a memory leak.
void ID3D11View::GetResource([Out] ID3D11Resource** ppResource)
Get the resource that is accessed through this view.
This function increments the reference count of the resource by one, so it is necessary to call Release on the returned reference when the application is done with it. Destroying (or losing) the returned reference before Release is called will result in a memory leak.
GetResource
void ID3D11View::GetResource([Out] ID3D11Resource** ppResource)
Creates a for accessing resource data.
The device to use when creating this .
The resource that represents the render-target surface. This surface must have been created with the DepthStencil flag.
ID3D11Device::CreateDepthStencilView
Creates a for accessing resource data.
The device to use when creating this .
The resource that represents the render-target surface. This surface must have been created with the DepthStencil flag.
A structure describing the to be created.
ID3D11Device::CreateDepthStencilView
Initializes a new instance of the class.
The native pointer.
Get the depth-stencil view.
Pointer to a depth-stencil-view description (see ).
void ID3D11DepthStencilView::GetDesc([Out] D3D11_DEPTH_STENCIL_VIEW_DESC* pDesc)
Get the depth-stencil view.
GetDesc
void ID3D11DepthStencilView::GetDesc([Out] D3D11_DEPTH_STENCIL_VIEW_DESC* pDesc)
The device interface represents a virtual adapter; it is used to create resources.
ID3D11Device
Constant MultisampleCountMaximum.
D3D11_MAX_MULTISAMPLE_SAMPLE_COUNT
Constructor for a D3D11 Device. See for more information.
Constructor for a D3D11 Device. See for more information.
Constructor for a D3D11 Device. See for more information.
Constructor for a D3D11 Device. See for more information.
Constructor for a D3D11 Device. See for more information.
Constructor for a D3D11 Device. See for more information.
Internal CreateDevice
Initializes a new instance of the class along with a new used for rendering.
The type of device to create.
A list of runtime layers to enable.
Details used to create the swap chain.
When the method completes, contains the created device instance.
When the method completes, contains the created swap chain instance.
A object describing the result of the operation.
Initializes a new instance of the class along with a new used for rendering.
The video adapter on which the device should be created.
A list of runtime layers to enable.
Details used to create the swap chain.
When the method completes, contains the created device instance.
When the method completes, contains the created swap chain instance.
A object describing the result of the operation.
Initializes a new instance of the class along with a new used for rendering.
The type of device to create.
A list of runtime layers to enable.
A list of feature levels which determine the order of feature levels to attempt to create.
Details used to create the swap chain.
When the method completes, contains the created device instance.
When the method completes, contains the created swap chain instance.
A object describing the result of the operation.
Initializes a new instance of the class along with a new used for rendering.
The video adapter on which the device should be created.
A list of runtime layers to enable.
A list of feature levels which determine the order of feature levels to attempt to create.
Details used to create the swap chain.
When the method completes, contains the created device instance.
When the method completes, contains the created swap chain instance.
A object describing the result of the operation.
This overload has been deprecated. Use one of the alternatives that does not take both an adapter and a driver type.
Get the type, name, units of measure, and a description of an existing counter.
The counter description.
Description of the counter
Give a device access to a shared resource created on a different Direct3d device.
The type of the resource we are gaining access to.
A resource handle. See remarks.
This method returns a reference to the resource we are gaining access to.
To share a resource between two Direct3D 10 devices the resource must have been created with the flag, if it was created using the ID3D10Device interface. If it was created using the IDXGIDevice 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(ID3D10Buffer) will get the GUID of the interface to a buffer resource. When sharing a resource between two Direct3D 10 devices the unique handle of the resource can be obtained by querying the resource for the interface and then calling {{GetSharedHandle}}.
IDXGIResource* pOtherResource(NULL);
hr = pOtherDeviceResource->QueryInterface( __uuidof(IDXGIResource), (void**)&pOtherResource );
HANDLE sharedHandle;
pOtherResource->GetSharedHandle(&sharedHandle);
The only resources that can be shared are 2D non-mipmapped textures. To share a resource between a Direct3D 9 device and a Direct3D 10 device the texture must have been created using the pSharedHandle argument of {{CreateTexture}}. The shared Direct3D 9 handle is then passed to OpenSharedResource in the hResource argument. The following code illustrates the method calls involved.
sharedHandle = NULL; // must be set to NULL to create, can use a valid handle here to open in D3D9
pDevice9->CreateTexture(..., pTex2D_9, &sharedHandle);
...
pDevice10->OpenSharedResource(sharedHandle, __uuidof(ID3D10Resource), (void**)(&tempResource10));
tempResource10->QueryInterface(__uuidof(ID3D10Texture2D), (void**)(&pTex2D_10));
tempResource10->Release();
// now use pTex2D_10 with pDevice10
Textures being shared from D3D9 to D3D10 have the following restrictions. Textures must be 2D Only 1 mip level is allowed Texture must have default usage Texture must be write only MSAA textures are not allowed Bind flags must have SHADER_RESOURCE and RENDER_TARGET set Only R10G10B10A2_UNORM, R16G16B16A16_FLOAT and R8G8B8A8_UNORM formats are allowed If a shared texture is updated on one device must be called on that device.
HRESULT ID3D10Device::OpenSharedResource([In] void* hResource,[In] GUID* ReturnedInterface,[Out, Optional] void** ppResource)
Check if this device is supporting compute shaders for the specified format.
The format for which to check support.
Flags indicating usage contexts in which the specified format is supported.
Check if this device is supporting a feature.
The feature to check.
Returns true if this device supports this feature, otherwise false.
Check if this device is supporting threading.
Support concurrent resources.
Support command lists.
A object describing the result of the operation.
Gets the highest supported hardware feature level of the primary adapter.
The highest supported hardware feature level.
Gets the highest supported hardware feature level of the primary adapter.
The adapter.
The highest supported hardware feature level.
Initializes a new instance of the class.
The native pointer.
Creates a buffer (vertex buffer, index buffer, or shader-constant buffer).
A reference to a structure that describes the buffer.
A reference to a 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 ).
Address of a reference to the interface for the buffer object created. Set this parameter to null to validate the other input parameters (S_FALSE indicates a pass).
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.The Direct3D 11.1 runtime, which is available on Windows Developer Preview and later operating systems, provides the following new functionality for CreateBuffer.You can create a constant buffer that is larger than the maximum constant buffer size that a shader can access (4096 32-bit*4-component constants ? 64KB). When you bind the constant buffer to the pipeline (for example, via PSSetConstantBuffers or PSSetConstantBuffers1), you can define a range of the buffer that the shader can access that fits within the 4096 constant limit.The runtime will emulate this feature for feature level 9.1, 9.2, and 9.3; therefore, this feature is supported for feature level 9.1, 9.2, and 9.3. This feature is always available on new drivers for feature level 10 and higher. On existing drivers that are implemented to feature level 10 and higher, a call to CreateBuffer to request a constant buffer that is larger than 4096 fails.
HRESULT ID3D11Device::CreateBuffer([In] const D3D11_BUFFER_DESC* pDesc,[In, Optional] const D3D11_SUBRESOURCE_DATA* pInitialData,[Out, Fast] ID3D11Buffer** ppBuffer)
Creates an array of 1D textures.
No documentation.
No documentation.
No documentation.
If the method succeeds, the return code is . 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 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:pInitialData[0] = 32x1 pInitialData[1] = 16x1 pInitialData[2] = 8x1 pInitialData[3] = 4x1
pInitialData[4] = 2x1
pInitialData[5] = 1x1
HRESULT ID3D11Device::CreateTexture1D([In] const D3D11_TEXTURE1D_DESC* pDesc,[In, Buffer, Optional] const D3D11_SUBRESOURCE_DATA* pInitialData,[Out, Fast] ID3D11Texture1D** ppTexture1D)
Create an array of 2D textures.
No documentation.
No documentation.
No documentation.
If the method succeeds, the return code is . 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 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:pInitialData[0] = 32x32 pInitialData[1] = 16x16 pInitialData[2] = 8x8 pInitialData[3] = 4x4
pInitialData[4] = 2x2
pInitialData[5] = 1x1
HRESULT ID3D11Device::CreateTexture2D([In] const D3D11_TEXTURE2D_DESC* pDesc,[In, Buffer, Optional] const D3D11_SUBRESOURCE_DATA* pInitialData,[Out, Fast] ID3D11Texture2D** ppTexture2D)
Create a single 3D texture.
No documentation.
No documentation.
No documentation.
If the method succeeds, the return code is . 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 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:pInitialData[0] = 32x32 with 4 slices pInitialData[1] = 16x16 with 2 slices pInitialData[2] = 8x8 with 1 slice pInitialData[3] = 4x4
with 1 slice pInitialData[4] = 2x2
with 1 slice pInitialData[5] = 1x1
with 1 slice
HRESULT ID3D11Device::CreateTexture3D([In] const D3D11_TEXTURE3D_DESC* pDesc,[In, Buffer, Optional] const D3D11_SUBRESOURCE_DATA* pInitialData,[Out, Fast] ID3D11Texture3D** ppTexture3D)
Create a shader-resource view for accessing data in a resource.
Pointer to the resource that will serve as input to a shader. This resource must have been created with the flag.
Pointer to a shader-resource view description (see ). Set this parameter to null to create a view that accesses the entire resource (using the format the resource was created with).
Address of a reference to an . Set this parameter to null to validate the other input parameters (the method will return S_FALSE if the other input parameters pass validation).
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: , and .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, ), you must set the flag when you create the buffer.The Direct3D 11.1 runtime, which is available starting with Windows Developer Preview, 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 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 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.
HRESULT ID3D11Device::CreateShaderResourceView([In] ID3D11Resource* pResource,[In, Optional] const D3D11_SHADER_RESOURCE_VIEW_DESC* pDesc,[Out, Fast] ID3D11ShaderResourceView** ppSRView)
Creates a view for accessing an unordered access resource.
No documentation.
No documentation.
No documentation.
This method returns one of the Direct3D 11 Return Codes.
The Direct3D 11.1 runtime, which is available starting with Windows Developer Preview, 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 structure for a created unordered-access view must match the type of video resource, for Texture2D and 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 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.
HRESULT ID3D11Device::CreateUnorderedAccessView([In] ID3D11Resource* pResource,[In, Optional] const D3D11_UNORDERED_ACCESS_VIEW_DESC* pDesc,[Out, Fast] ID3D11UnorderedAccessView** ppUAView)
Creates a render-target view for accessing resource data.
Pointer to a that represents a render target. This resource must have been created with the flag.
Pointer to a 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.
Address of a reference to an . Set this parameter to null to validate the other input parameters (the method will return S_FALSE if the other input parameters pass validation).
This method returns one of the Direct3D 11 Return Codes.
A render-target view can be bound to the output-merger stage by calling .The Direct3D 11.1 runtime, which is available starting with Windows Developer Preview, 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 structure for a created render-target view must match the type of video resource, for Texture2D and 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 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.
HRESULT ID3D11Device::CreateRenderTargetView([In] ID3D11Resource* pResource,[In, Optional] const D3D11_RENDER_TARGET_VIEW_DESC* pDesc,[Out, Fast] ID3D11RenderTargetView** ppRTView)
Create a depth-stencil view for accessing resource data.
Pointer to the resource that will serve as the depth-stencil surface. This resource must have been created with the flag.
Pointer to a depth-stencil-view description (see ). 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).
Address of a reference to an . Set this parameter to null to validate the other input parameters (the method will return S_FALSE if the other input parameters pass validation).
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 .
HRESULT ID3D11Device::CreateDepthStencilView([In] ID3D11Resource* pResource,[In, Optional] const D3D11_DEPTH_STENCIL_VIEW_DESC* pDesc,[Out, Fast] ID3D11DepthStencilView** ppDepthStencilView)
Create an input-layout object to describe the input-buffer data for the input-assembler stage.
An array of the input-assembler stage input data types; each type is described by an element description (see ).
The number of input-data types in the array of input-elements.
A reference to the compiled shader. The compiled shader code contains a input signature which is validated against the array of elements. See remarks.
Size of the compiled shader.
A reference to the input-layout object created (see ). To validate the other input parameters, set this reference to be null and verify that the method returns S_FALSE.
If the method succeeds, the return code is . 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.
HRESULT ID3D11Device::CreateInputLayout([In, Buffer] const D3D11_INPUT_ELEMENT_DESC* pInputElementDescs,[In] unsigned int NumElements,[In] const void* pShaderBytecodeWithInputSignature,[In] SIZE_T BytecodeLength,[Out, Fast] ID3D11InputLayout** ppInputLayout)
Create a vertex-shader object from a compiled shader.
A reference to the compiled shader.
Size of the compiled vertex shader.
A reference to a class linkage interface (see ); the value can be null.
Address of a reference to a 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 .
This method returns one of the Direct3D 11 Return Codes.
The Direct3D 11.1 runtime, which is available starting with Windows Developer Preview, 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.dcl_uav_typed dcl_uav_raw dcl_uav_structured ld_raw ld_structured ld_uav_typed store_raw store_structured store_uav_typed sync_uglobal All atomics and immediate atomics (for example, atomic_and and imm_atomic_and)
HRESULT ID3D11Device::CreateVertexShader([In] const void* pShaderBytecode,[In] SIZE_T BytecodeLength,[In, Optional] ID3D11ClassLinkage* pClassLinkage,[Out, Fast] ID3D11VertexShader** ppVertexShader)
Create a geometry shader.
A reference to the compiled shader.
Size of the compiled geometry shader.
A reference to a class linkage interface (see ); the value can be null.
Address of a reference to a 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 .
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 .The Direct3D 11.1 runtime, which is available starting with Windows Developer Preview, 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.dcl_uav_typed dcl_uav_raw dcl_uav_structured ld_raw ld_structured ld_uav_typed store_raw store_structured store_uav_typed sync_uglobal All atomics and immediate atomics (for example, atomic_and and imm_atomic_and)
HRESULT ID3D11Device::CreateGeometryShader([In] const void* pShaderBytecode,[In] SIZE_T BytecodeLength,[In, Optional] ID3D11ClassLinkage* pClassLinkage,[Out, Fast] ID3D11GeometryShader** ppGeometryShader)
Creates a geometry shader that can write to streaming output buffers.
A reference to the compiled geometry shader for a standard geometry shader plus stream output. For info on how to get this reference, see Getting a Pointer to a Compiled Shader. To create the stream output without using a geometry shader, pass a reference to the output signature for the prior stage. To obtain this output signature, call the compiler function. You can also pass a reference to the compiled shader for the prior stage (for example, the vertex-shader stage or domain-shader stage). This compiled shader provides the output signature for the data.
Size of the compiled geometry shader.
Pointer to a array. Cannot be null if NumEntries > 0.
The number of entries in the stream output declaration ( ranges from 0 to D3D11_SO_STREAM_COUNT * D3D11_SO_OUTPUT_COMPONENT_COUNT ).
An array of buffer strides; each stride is the size of an element for that buffer.
The number of strides (or buffers) in pBufferStrides (ranges from 0 to D3D11_SO_BUFFER_SLOT_COUNT).
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.
A reference to a class linkage interface (see ); the value can be null.
Address of a reference to an 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 .
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 Developer Preview, 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.dcl_uav_typed dcl_uav_raw dcl_uav_structured ld_raw ld_structured ld_uav_typed store_raw store_structured store_uav_typed sync_uglobal All atomics and immediate atomics (for example, atomic_and and imm_atomic_and)
HRESULT ID3D11Device::CreateGeometryShaderWithStreamOutput([In] const void* pShaderBytecode,[In] SIZE_T BytecodeLength,[In, Buffer, Optional] const D3D11_SO_DECLARATION_ENTRY* pSODeclaration,[In] unsigned int NumEntries,[In, Buffer, Optional] const unsigned int* pBufferStrides,[In] unsigned int NumStrides,[In] unsigned int RasterizedStream,[In, Optional] ID3D11ClassLinkage* pClassLinkage,[Out, Fast] ID3D11GeometryShader** ppGeometryShader)
Create a pixel shader.
A reference to the compiled shader.
Size of the compiled pixel shader.
A reference to a class linkage interface (see ); the value can be null.
Address of a reference to a 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 .
This method returns one of the following Direct3D 11 Return Codes.
After creating the pixel shader, you can set it to the device using .
HRESULT ID3D11Device::CreatePixelShader([In] const void* pShaderBytecode,[In] SIZE_T BytecodeLength,[In, Optional] ID3D11ClassLinkage* pClassLinkage,[Out, Fast] ID3D11PixelShader** ppPixelShader)
Create a hull shader.
No documentation.
No documentation.
No documentation.
No documentation.
This method returns one of the Direct3D 11 Return Codes.
The Direct3D 11.1 runtime, which is available starting with Windows Developer Preview, 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.dcl_uav_typed dcl_uav_raw dcl_uav_structured ld_raw ld_structured ld_uav_typed store_raw store_structured store_uav_typed sync_uglobal All atomics and immediate atomics (for example, atomic_and and imm_atomic_and)
HRESULT ID3D11Device::CreateHullShader([In] const void* pShaderBytecode,[In] SIZE_T BytecodeLength,[In, Optional] ID3D11ClassLinkage* pClassLinkage,[Out, Fast] ID3D11HullShader** ppHullShader)
Create a domain shader .
No documentation.
No documentation.
No documentation.
No documentation.
This method returns one of the following Direct3D 11 Return Codes.
The Direct3D 11.1 runtime, which is available starting with Windows Developer Preview, 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.dcl_uav_typed dcl_uav_raw dcl_uav_structured ld_raw ld_structured ld_uav_typed store_raw store_structured store_uav_typed sync_uglobal All atomics and immediate atomics (for example, atomic_and and imm_atomic_and)
HRESULT ID3D11Device::CreateDomainShader([In] const void* pShaderBytecode,[In] SIZE_T BytecodeLength,[In, Optional] ID3D11ClassLinkage* pClassLinkage,[Out, Fast] ID3D11DomainShader** ppDomainShader)
Create a compute shader.
No documentation.
No documentation.
No documentation.
No documentation.
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.
HRESULT ID3D11Device::CreateComputeShader([In] const void* pShaderBytecode,[In] SIZE_T BytecodeLength,[In, Optional] ID3D11ClassLinkage* pClassLinkage,[Out, Fast] ID3D11ComputeShader** ppComputeShader)
Creates class linkage libraries to enable dynamic shader linkage.
A reference to a class-linkage interface reference (see ).
This method returns one of the following Direct3D 11 Return Codes.
The interface returned in ppLinkage is associated with a shader by passing it as a parameter to one of the create shader methods such as .
HRESULT ID3D11Device::CreateClassLinkage([Out, Fast] ID3D11ClassLinkage** ppLinkage)
Create a blend-state object that encapsules blend state for the output-merger stage.
Pointer to a blend-state description (see ).
Address of a reference to the blend-state object created (see ).
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 reference to previous instance instead of creating a duplicate object.
HRESULT ID3D11Device::CreateBlendState([In] const D3D11_BLEND_DESC* pBlendStateDesc,[Out, Fast] ID3D11BlendState** ppBlendState)
Create a depth-stencil state object that encapsulates depth-stencil test information for the output-merger stage.
Pointer to a depth-stencil state description (see ).
Address of a reference to the depth-stencil state object created (see ).
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.
HRESULT ID3D11Device::CreateDepthStencilState([In] const D3D11_DEPTH_STENCIL_DESC* pDepthStencilDesc,[Out, Fast] ID3D11DepthStencilState** ppDepthStencilState)
Create a rasterizer state object that tells the rasterizer stage how to behave.
Pointer to a rasterizer state description (see ).
Address of a reference to the rasterizer state object created (see ).
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.
HRESULT ID3D11Device::CreateRasterizerState([In] const D3D11_RASTERIZER_DESC* pRasterizerDesc,[Out, Fast] ID3D11RasterizerState** ppRasterizerState)
Create a sampler-state object that encapsulates sampling information for a texture.
Pointer to a sampler state description (see ).
Address of a reference to the sampler state object created (see ).
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.
HRESULT ID3D11Device::CreateSamplerState([In] const D3D11_SAMPLER_DESC* pSamplerDesc,[Out, Fast] ID3D11SamplerState** ppSamplerState)
This interface encapsulates methods for querying information from the GPU.
Pointer to a query description (see ).
Address of a reference to the query object created (see ).
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.
HRESULT ID3D11Device::CreateQuery([In] const D3D11_QUERY_DESC* pQueryDesc,[Out, Fast] ID3D11Query** ppQuery)
Creates a predicate.
Pointer to a query description where the type of query must be a or (see ).
Address of a reference to a predicate (see ).
This method returns one of the following Direct3D 11 Return Codes.
HRESULT ID3D11Device::CreatePredicate([In] const D3D11_QUERY_DESC* pPredicateDesc,[Out, Fast] ID3D11Predicate** ppPredicate)
Create a counter object for measuring GPU performance.
Pointer to a counter description (see ).
Address of a reference to a counter (see ).
If this function succeeds, it will return . If it fails, possible return values are: S_FALSE, E_OUTOFMEMORY, , , 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.
HRESULT ID3D11Device::CreateCounter([In] const D3D11_COUNTER_DESC* pCounterDesc,[Out, Fast] ID3D11Counter** ppCounter)
Creates a deferred context for play back of command lists.
Reserved for future use. Pass 0.
Upon completion of the method, the passed reference to an interface reference is initialized.
Returns if successful; otherwise, returns one of the following:Returns if the video card has been physically removed from the system, or a driver upgrade for the video card has occurred. If this error occurs, you should destroy and recreate the device. Returns if the CreateDeferredContext method cannot be called from the current context. For example, if the device was created with the value, CreateDeferredContext returns . Returns E_INVALIDARG if the ContextFlags parameter is invalid. Returns E_OUTOFMEMORY if the application has exhausted available memory.
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 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 value to create the device that is represented by , 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.
HRESULT ID3D11Device::CreateDeferredContext([In] unsigned int ContextFlags,[Out, Fast] ID3D11DeviceContext** ppDeferredContext)
Give a device access to a shared resource created on a different device.
A resource handle. See remarks.
The globally unique identifier () for the resource interface. See remarks.
Address of a reference to the resource we are gaining access to.
This method returns one of the following Direct3D 11 Return Codes.
The REFIID, or , of the interface to the resource can be obtained by using the __uuidof() macro. For example, __uuidof() will get the 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 flag, if it was created using the interface. If it was created using a DXGI device interface, then the resource is always shared.The REFIID, or , of the interface to the resource can be obtained by using the __uuidof() macro. For example, __uuidof() will get the 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 interface and then calling GetSharedHandle.
* pOtherResource(null);
hr = pOtherDeviceResource->QueryInterface( __uuidof(), (void**)&pOtherResource );
HANDLE sharedHandle;
pOtherResource->GetSharedHandle(&sharedHandle);
The only resources that can be shared are 2D non-mipmapped textures.To share a resource between a Direct3D 9 device and a Direct3D 11 device the texture must have been created using the pSharedHandle argument of CreateTexture. The shared Direct3D 9 handle is then passed to OpenSharedResource in the hResource argument.The following code illustrates the method calls involved.
sharedHandle = null; // must be set to null to create, can use a valid handle here to open in D3D9
pDevice9->CreateTexture(..., pTex2D_9, &sharedHandle);
...
pDevice11->OpenSharedResource(sharedHandle, __uuidof(), (void**)(&tempResource11));
tempResource11->QueryInterface(__uuidof(), (void**)(&pTex2D_11));
tempResource11->Release();
// now use pTex2D_11 with pDevice11
Textures being shared from D3D9 to D3D11 have the following restrictions.Textures must be 2D Only 1 mip level is allowed Texture must have default usage Texture must be write only MSAA textures are not allowed Bind flags must have SHADER_RESOURCE and RENDER_TARGET set Only R10G10B10A2_UNORM, R16G16B16A16_FLOAT and R8G8B8A8_UNORM formats are allowedIf a shared texture is updated on one device must be called on that device.
HRESULT ID3D11Device::OpenSharedResource([In] void* hResource,[In] const GUID& ReturnedInterface,[Out, Optional] void** ppResource)
Get the support of a given format on the installed video device.
A enumeration that describes a format for which to check for support.
A bitfield of enumeration values describing how the specified format is supported on the installed device. The values are ORed together.
HRESULT ID3D11Device::CheckFormatSupport([In] DXGI_FORMAT Format,[Out] D3D11_FORMAT_SUPPORT* pFormatSupport)
Get the number of quality levels available during multisampling.
The texture format. See .
The number of samples during multisampling.
Number of quality levels supported by the adapter. See remarks.
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 in D3D11.h. If this method returns 0, the format and sample count combination is not supported for the installed adapter.Furthermore, the definition of a quality level is up to each hardware vendor to define, however no facility is provided by Direct3D to help discover this information.Note that FEATURE_LEVEL_10_1 devices are required to support 4x MSAA for all render targets except R32G32B32A32 and R32G32B32. FEATURE_LEVEL_11_0 devices are required to support 4x MSAA for all render target formats, and 8x MSAA for all render target formats except R32G32B32A32 formats.
HRESULT ID3D11Device::CheckMultisampleQualityLevels([In] DXGI_FORMAT Format,[In] unsigned int SampleCount,[Out] unsigned int* pNumQualityLevels)
Get a counter's information.
void ID3D11Device::CheckCounterInfo([Out] D3D11_COUNTER_INFO* pCounterInfo)
Get the type, name, units of measure, and a description of an existing counter.
Pointer to a counter description (see ). Specifies which counter information is to be retrieved about.
Pointer to the data type of a counter (see ). Specifies the data type of the counter being retrieved.
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.
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.
Length of the string returned to szName. Can be null.
Name of the units a counter measures, provided the memory the reference points to has enough room to hold the string. Can be null. The returned string will always be in English.
Length of the string returned to szUnits. Can be null.
A description of the counter, provided the memory the reference points to has enough room to hold the string. Can be null. The returned string will always be in English.
Length of the string returned to szDescription. Can be null.
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.
HRESULT ID3D11Device::CheckCounter([In] const D3D11_COUNTER_DESC* pDesc,[Out] D3D11_COUNTER_TYPE* pType,[Out] unsigned int* pActiveCounters,[Out, Buffer, Optional] char* szName,[InOut, Optional] unsigned int* pNameLength,[Out, Buffer, Optional] char* szUnits,[InOut, Optional] unsigned int* pUnitsLength,[Out, Buffer, Optional] char* szDescription,[InOut, Optional] unsigned int* pDescriptionLength)
Gets information about the features that are supported by the current graphics driver.
A member of the enumerated type that describes which feature to query for support.
Upon completion of the method, the passed structure is filled with data that describes the feature support.
The size of the structure passed to the pFeatureSupportData parameter.
Returns 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 value to the Feature parameter, pass the structure to the pFeatureSupportData parameter, and pass the size of the structure to the FeatureSupportDataSize parameter.Calling CheckFeatureSupport with Feature set to causes the method to return the same information that would be returned by .
HRESULT ID3D11Device::CheckFeatureSupport([In] D3D11_FEATURE Feature,[Out, Buffer] void* pFeatureSupportData,[In] unsigned int FeatureSupportDataSize)
Get application-defined data from a device.
Guid associated with the data.
A reference to a variable that on input contains the size, in bytes, of the buffer that pData points to, and on output contains the size, in bytes, of the amount of data that GetPrivateData retrieved.
A reference to a buffer that GetPrivateData fills with data from the device if pDataSize points to a value that specifies a buffer large enough to hold the data.
This method returns one of the codes described in the topic Direct3D 11 Return Codes.
HRESULT ID3D11Device::GetPrivateData([In] const GUID& guid,[InOut] unsigned int* pDataSize,[Out, Buffer, Optional] void* pData)
Set data to a device and associate that data with a guid.
Guid associated with the data.
Size of the data.
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.
This method returns one of the following Direct3D 11 Return Codes.
The data stored in the device with this method can be retrieved with .The data and guid set with this method will typically be application-defined.If an application uses this method to change the device type using GUID_DeviceType, results are undefined. However, GUID_DeviceType can be used to retrieve the device type using .The debug layer reports memory leaks by outputting a list of object interface references along with their friendly names. The default friendly name is "<unnamed>". You can set the friendly name so that you can determine if the corresponding object interface reference caused the leak. To set the friendly name, use the SetPrivateData method and the that is in D3Dcommon.h. For example, to give pContext a friendly name of My name, use the following code:
static const char c_szName[] = "My name";
hr = pContext->SetPrivateData( , sizeof( c_szName ) - 1, c_szName );
HRESULT ID3D11Device::SetPrivateData([In] const GUID& guid,[In] unsigned int DataSize,[In, Buffer, Optional] const void* pData)
Associate an -derived interface with this device child and associate that interface with an application-defined guid.
Guid associated with the interface.
Pointer to an -derived interface to be associated with the device child.
This method returns one of the following Direct3D 11 Return Codes.
HRESULT ID3D11Device::SetPrivateDataInterface([In] const GUID& guid,[In, Optional] const IUnknown* pData)
Gets the feature level of the hardware device.
A member of the enumerated type that describes the feature level of the hardware device.
Feature levels determine the capabilities of your device.
D3D_FEATURE_LEVEL ID3D11Device::GetFeatureLevel()
Get the flags used during the call to create the device with .
A bitfield containing the flags used to create the device. See .
unsigned int ID3D11Device::GetCreationFlags()
Get the reason why the device was removed.
Possible return values include: For more detail on these return codes, see DXGI_ERROR.
HRESULT ID3D11Device::GetDeviceRemovedReason()
Gets an immediate context which can record command lists.
Upon completion of the method, the passed reference to an interface reference is initialized.
The GetImmediateContext method returns an object that represents an immediate context which is used to perform rendering that you want immediately submitted to a device. For most applications, an immediate context is the primary object that is used to draw your scene.The GetImmediateContext method increments the reference count of the immediate context by one. Therefore, you must call Release on the returned interface reference when you are done with it to avoid a memory leak.
void ID3D11Device::GetImmediateContext([Out] ID3D11DeviceContext** ppImmediateContext)
Get the exception-mode flags.
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.
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.
HRESULT ID3D11Device::SetExceptionMode([In] unsigned int RaiseFlags)
Get the exception-mode flags.
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.
unsigned int ID3D11Device::GetExceptionMode()
Get the imediate attached to this Device.
Gets or sets the debug-name for this object.
The debug name.
Gets the feature level of the hardware device.
Feature levels determine the capabilities of your device.
GetFeatureLevel
D3D_FEATURE_LEVEL ID3D11Device::GetFeatureLevel()
Get the flags used during the call to create the device with .
GetCreationFlags
unsigned int ID3D11Device::GetCreationFlags()
Get the reason why the device was removed.
GetDeviceRemovedReason
HRESULT ID3D11Device::GetDeviceRemovedReason()
Get the exception-mode flags.
An exception-mode flag is used to elevate an error condition to a non-continuable exception.
GetExceptionMode
unsigned int ID3D11Device::GetExceptionMode()
The interface represents a device context which generates rendering commands.
ID3D11DeviceContext
Set the target output {{buffers}} for the {{StreamOutput}} stage, which enables/disables the pipeline to stream-out data.
Call ID3D10Device::SOSetTargets (before any draw calls) to stream data out; call SOSetTargets with NULL to stop streaming data out. For an example, see Exercise 01 from the GDC 2007 workshop, which sets the stream output rendertargets before calling draw methods in the RenderInstanceToStream function. 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 not hold a reference to the interfaces passed in. For that reason, applications should be careful not to release an interface currently in use by the device.
an array of output buffers (see ) to bind to the device. The buffers must have been created with the flag.
void SOSetTargets([In] int NumBuffers,[In, Buffer, Optional] const ID3D10Buffer** ppSOTargets,[In, Buffer, Optional] const int* pOffsets)
Get the target output {{buffers}} for the {{StreamOutput}} stage of the pipeline.
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.
Number of buffers to get. A maximum of four output buffers can be retrieved.
an array of output buffers (see ) to bind to the device.
void SOGetTargets([In] int NumBuffers,[Out, Buffer, Optional] ID3D10Buffer** ppSOTargets,[Out, Buffer, Optional] int* pOffsets)
Initializes a new instance of the class.
The native pointer.
Set the target output buffers for the stream-output stage of the pipeline.
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.
The array of output buffers (see ) to bind to the device. The buffers must have been created with the flag.
Array of offsets to the output buffers from ppSOTargets, one offset for each buffer. The offset values must be in bytes.
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.
void ID3D11DeviceContext::SOSetTargets([In] unsigned int NumBuffers,[In, Buffer, Optional] const ID3D11Buffer** ppSOTargets,[In, Buffer, Optional] const unsigned int* pOffsets)
Set the target output buffers for the stream-output stage of the pipeline.
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.
The array of output buffers (see ) to bind to the device. The buffers must have been created with the flag.
Array of offsets to the output buffers from ppSOTargets, one offset for each buffer. The offset values must be in bytes.
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.
void ID3D11DeviceContext::SOSetTargets([In] unsigned int NumBuffers,[In, Buffer, Optional] const ID3D11Buffer** ppSOTargets,[In, Buffer, Optional] const unsigned int* pOffsets)
Get the target output buffers for the stream-output stage of the pipeline.
Number of buffers to get.
An array of output buffers (see ) to be retrieved from the device.
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 .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.
void ID3D11DeviceContext::SOGetTargets([In] unsigned int NumBuffers,[Out, Buffer, Optional] ID3D11Buffer** ppSOTargets)
Common Shader class. Provides a common set of methods for a Shader Stage.
TODO: check if usage of abstract is not introducing an unacceptable overhead...
Type of the shader
Functions
Constant ImmediateConstantBufferRegisterComponents.
D3D11_COMMONSHADER_IMMEDIATE_CONSTANT_BUFFER_REGISTER_COMPONENTS
Constant SamplerRegisterComponents.
D3D11_COMMONSHADER_SAMPLER_REGISTER_COMPONENTS
Constant SamplerRegisterCount.
D3D11_COMMONSHADER_SAMPLER_REGISTER_COUNT
Constant TempRegisterReadPorts.
D3D11_COMMONSHADER_TEMP_REGISTER_READ_PORTS
Constant ConstantBufferRegisterReadPorts.
D3D11_COMMONSHADER_CONSTANT_BUFFER_REGISTER_READ_PORTS
Constant TempRegisterCount.
D3D11_COMMONSHADER_TEMP_REGISTER_COUNT
Constant TempRegisterComponents.
D3D11_COMMONSHADER_TEMP_REGISTER_COMPONENTS
Constant FlowcontrolNestingLimit.
D3D11_COMMONSHADER_FLOWCONTROL_NESTING_LIMIT
Constant TempRegisterComponentBitCount.
D3D11_COMMONSHADER_TEMP_REGISTER_COMPONENT_BIT_COUNT
Constant InputResourceRegisterComponents.
D3D11_COMMONSHADER_INPUT_RESOURCE_REGISTER_COMPONENTS
Constant InputResourceSlotCount.
D3D11_COMMONSHADER_INPUT_RESOURCE_SLOT_COUNT
Constant SamplerRegisterReadsPerInst.
D3D11_COMMONSHADER_SAMPLER_REGISTER_READS_PER_INST
Constant InputResourceRegisterReadPorts.
D3D11_COMMONSHADER_INPUT_RESOURCE_REGISTER_READ_PORTS
Constant TexcoordRangeReductionMaximum.
D3D11_COMMONSHADER_TEXCOORD_RANGE_REDUCTION_MAX
Constant SamplerRegisterReadPorts.
D3D11_COMMONSHADER_SAMPLER_REGISTER_READ_PORTS
Constant TexelOffsetMaximumNegative.
D3D11_COMMONSHADER_TEXEL_OFFSET_MAX_NEGATIVE
Constant InputResourceRegisterCount.
D3D11_COMMONSHADER_INPUT_RESOURCE_REGISTER_COUNT
Constant ImmediateConstantBufferRegisterCount.
D3D11_COMMONSHADER_IMMEDIATE_CONSTANT_BUFFER_REGISTER_COUNT
Constant ConstantBufferRegisterCount.
D3D11_COMMONSHADER_CONSTANT_BUFFER_REGISTER_COUNT
Constant ConstantBufferRegisterReadsPerInst.
D3D11_COMMONSHADER_CONSTANT_BUFFER_REGISTER_READS_PER_INST
Constant TexelOffsetMaximumPositive.
D3D11_COMMONSHADER_TEXEL_OFFSET_MAX_POSITIVE
Constant ImmediateConstantBufferRegisterReadsPerInst.
D3D11_COMMONSHADER_IMMEDIATE_CONSTANT_BUFFER_REGISTER_READS_PER_INST
Constant TexcoordRangeReductionMinimum.
D3D11_COMMONSHADER_TEXCOORD_RANGE_REDUCTION_MIN
Constant ConstantBufferComponentBitCount.
D3D11_COMMONSHADER_CONSTANT_BUFFER_COMPONENT_BIT_COUNT
Constant TempRegisterReadsPerInst.
D3D11_COMMONSHADER_TEMP_REGISTER_READS_PER_INST
Constant ImmediateValueComponentBitCount.
D3D11_COMMONSHADER_IMMEDIATE_VALUE_COMPONENT_BIT_COUNT
Constant ConstantBufferHwSlotCount.
D3D11_COMMONSHADER_CONSTANT_BUFFER_HW_SLOT_COUNT
Constant SubroutineNestingLimit.
D3D11_COMMONSHADER_SUBROUTINE_NESTING_LIMIT
Constant SamplerSlotCount.
D3D11_COMMONSHADER_SAMPLER_SLOT_COUNT
Constant ConstantBufferRegisterComponents.
D3D11_COMMONSHADER_CONSTANT_BUFFER_REGISTER_COMPONENTS
Constant ImmediateConstantBufferRegisterReadPorts.
D3D11_COMMONSHADER_IMMEDIATE_CONSTANT_BUFFER_REGISTER_READ_PORTS
Constant ConstantBufferPartialUpdateExtentsByteAlignment.
D3D11_COMMONSHADER_CONSTANT_BUFFER_PARTIAL_UPDATE_EXTENTS_BYTE_ALIGNMENT
Constant InputResourceRegisterReadsPerInst.
D3D11_COMMONSHADER_INPUT_RESOURCE_REGISTER_READS_PER_INST
Constant ConstantBufferApiSlotCount.
D3D11_COMMONSHADER_CONSTANT_BUFFER_API_SLOT_COUNT
Constant ConstantBufferComponents.
D3D11_COMMONSHADER_CONSTANT_BUFFER_COMPONENTS
Initializes a new instance of the class.
The pointer.
Gets the constant buffers used by the shader stage.
Index into the device's zero-based array from which to begin retrieving constant buffers.
Number of buffers to retrieve.
An array of constant buffers.
Gets the sampler states used by the shader stage.
Index into the device's zero-based array from which to begin retrieving samplers.
Number of samplers to retrieve.
An array of sampler states.
Gets the shader resources used by the shader stage.
Index into the device's zero-based array from which to begin retrieving shader resources.
Number of resources to retrieve.
An array of shader resources.
Sets a single constant buffer to be used by the shader stage.
Index into the device's zero-based array to which to set the constant buffer.
constant buffer to set
Sets an array of constant buffers to be used by the shader stage.
Index into the device's zero-based array to which to set the array of constant buffers.
An array of constant buffer to set
Sets an array of constant buffers to be used by the shader stage.
Index into the device's zero-based array to which to set the array of constant buffers.
An array of constant buffer to set
Sets a single sampler to be used by the shader stage.
Index into the device's zero-based array to which to set the sampler.
sampler state to set
Sets an array of samplers to be used by the shader stage.
Index into the device's zero-based array to which to set the array of sampler states.
An array of sampler state to set
Sets an array of samplesr to be used by the shader stage.
Index into the device's zero-based array to which to set the array of sampler states.
An array of sampler state to set
Sets a single shader resource to be used by the shader stage.
Index into the device's zero-based array to which to set the resource.
Resource view to attach
Bind an array of shader resources to the shader stage.
If an overlapping resource view is already bound to an output slot, such as a rendertarget, then this API will fill the destination shader resource slot with NULL.For information about creating shader-resource views, see . The method will hold a reference to the interfaces passed in. This differs from the device state behavior in Direct3D 10.
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).
Array of {{shader resource view}} interfaces to set to the device.
Bind an array of shader resources to the shader stage.
If an overlapping resource view is already bound to an output slot, such as a rendertarget, then this API will fill the destination shader resource slot with NULL.For information about creating shader-resource views, see . The method will hold a reference to the interfaces passed in. This differs from the device state behavior in Direct3D 10.
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).
Array of {{shader resource view}} interfaces to set to the device.
Get the shader resources.
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.
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).
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).
Array of {{shader resource view}} interfaces to be returned by the device.
void PSGetShaderResources([In] UINT StartSlot,[In] UINT NumViews,[Out, Buffer] ID3D11ShaderResourceView** ppShaderResourceViews)
Get an array of sampler states from the shader pipeline stage.
Any returned interfaces will have their reference count incremented by one. Applications should call IUnknown::Release on the returned interfaces when they are no longer needed to avoid memory leaks.
Index into a zero-based array to begin getting samplers from (ranges from 0 to D3D11_COMMONSHADER_SAMPLER_SLOT_COUNT - 1).
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).
Arry of sampler-state interface pointers (see ) to be returned by the device.
void PSGetSamplers([In] UINT StartSlot,[In] UINT NumSamplers,[Out, Buffer] ID3D11SamplerState** ppSamplers)
Get the constant buffers used by the shader pipeline stage.
Any returned interfaces will have their reference count incremented by one. Applications should call IUnknown::Release on the returned interfaces when they are no longer needed to avoid memory leaks.
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).
Number of buffers to retrieve (ranges from 0 to D3D11_COMMONSHADER_CONSTANT_BUFFER_API_SLOT_COUNT - StartSlot).
Array of constant buffer interface pointers (see ) to be returned by the method.
void PSGetConstantBuffers([In] UINT StartSlot,[In] UINT NumBuffers,[Out, Buffer] ID3D11Buffer** ppConstantBuffers)
Bind an array of shader resources to the shader stage.
If an overlapping resource view is already bound to an output slot, such as a rendertarget, then this API will fill the destination shader resource slot with NULL.For information about creating shader-resource views, see . The method will hold a reference to the interfaces passed in. This differs from the device state behavior in Direct3D 10.
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).
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).
Array of {{shader resource view}} interfaces to set to the device.
void PSSetShaderResources([In] UINT StartSlot,[In] UINT NumViews,[In, Buffer] const ID3D11ShaderResourceView** ppShaderResourceViews)
Bind an array of shader resources to the shader stage.
If an overlapping resource view is already bound to an output slot, such as a rendertarget, then this API will fill the destination shader resource slot with NULL.For information about creating shader-resource views, see . The method will hold a reference to the interfaces passed in. This differs from the device state behavior in Direct3D 10.
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).
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).
Array of {{shader resource view}} interfaces to set to the device.
void PSSetShaderResources([In] UINT StartSlot,[In] UINT NumViews,[In, Buffer] const ID3D11ShaderResourceView** ppShaderResourceViews)
Bind an array of shader resources to the shader stage.
If an overlapping resource view is already bound to an output slot, such as a rendertarget, then this API will fill the destination shader resource slot with NULL.For information about creating shader-resource views, see . The method will hold a reference to the interfaces passed in. This differs from the device state behavior in Direct3D 10.
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).
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).
Array of {{shader resource view}} interfaces to set to the device.
void PSSetShaderResources([In] UINT StartSlot,[In] UINT NumViews,[In, Buffer] const ID3D11ShaderResourceView** ppShaderResourceViews)
Set an array of sampler states to the shader pipeline stage.
Any sampler may be set to NULL; this invokes the default state, which is defined to be the following.StateDefault ValueFilterD3D11_FILTER_MIN_MAG_MIP_LINEARAddressUD3D11_TEXTURE_ADDRESS_CLAMPAddressVD3D11_TEXTURE_ADDRESS_CLAMPAddressWD3D11_TEXTURE_ADDRESS_CLAMPMipLODBias0MaxAnisotropy1ComparisonFuncD3D11_COMPARISON_NEVERBorderColor[0]1.0fBorderColor[1]1.0fBorderColor[2]1.0fBorderColor[3]1.0fMinLOD-FLT_MAXMaxLODFLT_MAX The method will hold a reference to the interfaces passed in. This differs from the device state behavior in Direct3D 10.
Index into the device's zero-based array to begin setting samplers to (ranges from 0 to D3D11_COMMONSHADER_SAMPLER_SLOT_COUNT - 1).
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).
Pointer to an array of sampler-state interfaces (see ). See Remarks.
void PSSetSamplers([In] UINT StartSlot,[In] UINT NumSamplers,[In, Buffer] const ID3D11SamplerState** ppSamplers)
Set an array of sampler states to the shader pipeline stage.
Any sampler may be set to NULL; this invokes the default state, which is defined to be the following.StateDefault ValueFilterD3D11_FILTER_MIN_MAG_MIP_LINEARAddressUD3D11_TEXTURE_ADDRESS_CLAMPAddressVD3D11_TEXTURE_ADDRESS_CLAMPAddressWD3D11_TEXTURE_ADDRESS_CLAMPMipLODBias0MaxAnisotropy1ComparisonFuncD3D11_COMPARISON_NEVERBorderColor[0]1.0fBorderColor[1]1.0fBorderColor[2]1.0fBorderColor[3]1.0fMinLOD-FLT_MAXMaxLODFLT_MAX The method will hold a reference to the interfaces passed in. This differs from the device state behavior in Direct3D 10.
Index into the device's zero-based array to begin setting samplers to (ranges from 0 to D3D11_COMMONSHADER_SAMPLER_SLOT_COUNT - 1).
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).
Pointer to an array of sampler-state interfaces (see ). See Remarks.
void PSSetSamplers([In] UINT StartSlot,[In] UINT NumSamplers,[In, Buffer] const ID3D11SamplerState** ppSamplers)
Set the constant buffers used by the shader pipeline stage.
The method will hold a reference to the interfaces passed in. This differs from the device state behavior in Direct3D 10.
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).
Number of buffers to set (ranges from 0 to D3D11_COMMONSHADER_CONSTANT_BUFFER_API_SLOT_COUNT - StartSlot).
Array of constant buffers (see ) being given to the device.
void PSSetConstantBuffers([In] UINT StartSlot,[In] UINT NumBuffers,[In, Buffer] const ID3D11Buffer** ppConstantBuffers)
Set the constant buffers used by the shader pipeline stage.
The method will hold a reference to the interfaces passed in. This differs from the device state behavior in Direct3D 10.
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).
Number of buffers to set (ranges from 0 to D3D11_COMMONSHADER_CONSTANT_BUFFER_API_SLOT_COUNT - StartSlot).
Array of constant buffers (see ) being given to the device.
void PSSetConstantBuffers([In] UINT StartSlot,[In] UINT NumBuffers,[In, Buffer] const ID3D11Buffer** ppConstantBuffers)
Common Shader class. Provides a common set of methods for a Shader Stage.
TODO: check if usage of abstract is not introducing an unacceptable overhead...
Type of the shader
Initializes a new instance of the class.
The pointer.
Gets the shader currently assigned to the device.
The shader (null if no shader is assigned).
Gets the shader currently assigned to the device.
An array that will be used to contain any class instances currently active.
The shader (null if no shader is assigned).
Assigns a compute shader to the device.
The shader to assign to the device. Assign null to disable the compute shader.
Assigns a compute shader to the device.
The shader to assign to the device. Assign null to disable the compute shader.
An array of class-instance interfaces. Each interface used by a shader must have a corresponding class instance or the shader will get disabled.
Assigns a compute shader to the device.
The shader to assign to the device. Assign null to disable the compute shader.
An array of class-instance interfaces. Each interface used by a shader must have a corresponding class instance or the shader will get disabled.
The interface represents a device context which generates rendering commands.
ID3D11DeviceContext
Gets an array of views for an unordered resource.
Any returned interfaces will have their reference count incremented by one. Applications should call IUnknown::Release on the returned interfaces when they are no longer needed to avoid memory leaks.
Index of the first element in the zero-based array to return (ranges from 0 to D3D11_PS_CS_UAV_REGISTER_COUNT - 1).
Number of views to get (ranges from 0 to D3D11_PS_CS_UAV_REGISTER_COUNT - StartSlot).
void CSGetUnorderedAccessViews([In] int StartSlot,[In] int NumUAVs,[Out, Buffer] ID3D11UnorderedAccessView** ppUnorderedAccessViews)
Sets an array of views for an unordered resource.
Index of the first element in the zero-based array to begin setting.
A reference to an references to be set by the method.
void CSSetUnorderedAccessViews([In] int StartSlot,[In] int NumUAVs,[In, Buffer] const ID3D11UnorderedAccessView** ppUnorderedAccessViews,[In, Buffer] const int* pUAVInitialCounts)
Sets an array of views for an unordered resource.
Index of the first element in the zero-based array to begin setting.
A reference to an references to be set by the method.
An Append/Consume buffer offsets. A value of -1 indicates the current offset should be kept. Any other values set the hidden counter for that Appendable/Consumeable UAV. uAVInitialCount is only relevant for UAVs which have the flag, otherwise the argument is ignored.
void CSSetUnorderedAccessViews([In] int StartSlot,[In] int NumUAVs,[In, Buffer] const ID3D11UnorderedAccessView** ppUnorderedAccessViews,[In, Buffer] const int* pUAVInitialCounts)
Sets an array of views for an unordered resource.
Index of the first element in the zero-based array to begin setting.
A reference to an array of references to be set by the method.
void CSSetUnorderedAccessViews([In] int StartSlot,[In] int NumUAVs,[In, Buffer] const ID3D11UnorderedAccessView** ppUnorderedAccessViews,[In, Buffer] const int* pUAVInitialCounts)
Sets an array of views for an unordered resource.
Index of the first element in the zero-based array to begin setting.
A reference to an array of references to be set by the method.
An array of Append/Consume buffer offsets. A value of -1 indicates the current offset should be kept. Any other values set the hidden counter for that Appendable/Consumeable UAV. pUAVInitialCounts is only relevant for UAVs which have the flag, otherwise the argument is ignored.
void CSSetUnorderedAccessViews([In] int StartSlot,[In] int NumUAVs,[In, Buffer] const ID3D11UnorderedAccessView** ppUnorderedAccessViews,[In, Buffer] const int* pUAVInitialCounts)
Initializes a new instance of the class.
The native pointer.
Bind an array of shader resources to the compute-shader stage.
Index into the device's zero-based array to begin setting shader resources to (ranges from 0 to - 1).
Number of shader resources to set. Up to a maximum of 128 slots are available for shader resources(ranges from 0 to - StartSlot).
Array of shader resource view interfaces to set to the device.
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 .The method will hold a reference to the interfaces passed in. This differs from the device state behavior in Direct3D 10.
void ID3D11DeviceContext::CSSetShaderResources([In] unsigned int StartSlot,[In] unsigned int NumViews,[In, Buffer, Optional] const void** ppShaderResourceViews)
Sets an array of views for an unordered resource.
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.
Number of views to set (ranges from 0 to D3D11_1_UAV_SLOT_COUNT - StartSlot).
A reference to an array of references to be set by the method.
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 or specified when the UAV was created; otherwise, the argument is ignored.
void ID3D11DeviceContext::CSSetUnorderedAccessViews([In] unsigned int StartSlot,[In] unsigned int NumUAVs,[In, Buffer, Optional] const ID3D11UnorderedAccessView** ppUnorderedAccessViews,[In, Buffer, Optional] const unsigned int* pUAVInitialCounts)
Sets an array of views for an unordered resource.
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.
Number of views to set (ranges from 0 to D3D11_1_UAV_SLOT_COUNT - StartSlot).
A reference to an array of references to be set by the method.
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 or specified when the UAV was created; otherwise, the argument is ignored.
void ID3D11DeviceContext::CSSetUnorderedAccessViews([In] unsigned int StartSlot,[In] unsigned int NumUAVs,[In, Buffer, Optional] const ID3D11UnorderedAccessView** ppUnorderedAccessViews,[In, Buffer, Optional] const unsigned int* pUAVInitialCounts)
Set a compute shader to the device.
Pointer to a compute shader (see ). Passing in null disables the shader for this pipeline stage.
A reference to an array of class-instance interfaces (see ). 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.
The number of class-instance interfaces in the array.
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.
void ID3D11DeviceContext::CSSetShader([In, Optional] ID3D11ComputeShader* pComputeShader,[In, Buffer, Optional] const ID3D11ClassInstance** ppClassInstances,[In] unsigned int NumClassInstances)
Set a compute shader to the device.
Pointer to a compute shader (see ). Passing in null disables the shader for this pipeline stage.
A reference to an array of class-instance interfaces (see ). 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.
The number of class-instance interfaces in the array.
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.
void ID3D11DeviceContext::CSSetShader([In, Optional] ID3D11ComputeShader* pComputeShader,[In, Buffer, Optional] const ID3D11ClassInstance** ppClassInstances,[In] unsigned int NumClassInstances)
Set an array of sampler states to the compute-shader stage.
Index into the device's zero-based array to begin setting samplers to (ranges from 0 to - 1).
Number of samplers in the array. Each pipeline stage has a total of 16 sampler slots available (ranges from 0 to - StartSlot).
Pointer to an array of sampler-state interfaces (see ). See Remarks.
Any sampler may be set to null; this invokes the default state, which is defined to be the following.
//Default sampler state:
SamplerDesc;
SamplerDesc.Filter = ;
SamplerDesc.AddressU = ;
SamplerDesc.AddressV = ;
SamplerDesc.AddressW = ;
SamplerDesc.MipLODBias = 0;
SamplerDesc.MaxAnisotropy = 1;
SamplerDesc.ComparisonFunc = ;
SamplerDesc.BorderColor[0] = 1.0f;
SamplerDesc.BorderColor[1] = 1.0f;
SamplerDesc.BorderColor[2] = 1.0f;
SamplerDesc.BorderColor[3] = 1.0f;
SamplerDesc.MinLOD = -FLT_MAX;
SamplerDesc.MaxLOD = FLT_MAX;
The method will hold a reference to the interfaces passed in. This differs from the device state behavior in Direct3D 10.
void ID3D11DeviceContext::CSSetSamplers([In] unsigned int StartSlot,[In] unsigned int NumSamplers,[In, Buffer, Optional] const void** ppSamplers)
Sets the constant buffers used by the compute-shader stage.
Index into the zero-based array to begin setting constant buffers to (ranges from 0 to - 1).
Number of buffers to set (ranges from 0 to - StartSlot).
Array of constant buffers (see ) being given to the device.
The method will hold a reference to the interfaces passed in. This differs from the device state behavior in Direct3D 10.The Direct3D 11.1 runtime, which is available starting with Windows Developer Preview, can bind a larger number of 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.
void ID3D11DeviceContext::CSSetConstantBuffers([In] unsigned int StartSlot,[In] unsigned int NumBuffers,[In, Buffer, Optional] const void** ppConstantBuffers)
Get the compute-shader resources.
Index into the device's zero-based array to begin getting shader resources from (ranges from 0 to - 1).
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 - StartSlot).
Array of shader resource view interfaces to be returned by the device.
Any returned interfaces will have their reference count incremented by one. Applications should call IUnknown::Release on the returned interfaces when they are no longer needed to avoid memory leaks.
void ID3D11DeviceContext::CSGetShaderResources([In] unsigned int StartSlot,[In] unsigned int NumViews,[Out, Buffer, Optional] ID3D11ShaderResourceView** ppShaderResourceViews)
Gets an array of views for an unordered resource.
Index of the first element in the zero-based array to return (ranges from 0 to D3D11_PS_CS_UAV_REGISTER_COUNT - 1).
Number of views to get (ranges from 0 to D3D11_PS_CS_UAV_REGISTER_COUNT - StartSlot).
A reference to an array of interface references (see ) to get.
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.
void ID3D11DeviceContext::CSGetUnorderedAccessViews([In] unsigned int StartSlot,[In] unsigned int NumUAVs,[Out, Buffer, Optional] ID3D11UnorderedAccessView** ppUnorderedAccessViews)
Get the compute shader currently set on the device.
Address of a reference to a Compute shader (see ) to be returned by the method.
Pointer to an array of class instance interfaces (see ).
The number of class-instance elements in the array.
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.
void ID3D11DeviceContext::CSGetShader([Out] ID3D11ComputeShader** ppComputeShader,[Out, Buffer, Optional] ID3D11ClassInstance** ppClassInstances,[InOut] unsigned int* pNumClassInstances)
Get an array of sampler state interfaces from the compute-shader stage.
Index into a zero-based array to begin getting samplers from (ranges from 0 to - 1).
Number of samplers to get from a device context. Each pipeline stage has a total of 16 sampler slots available (ranges from 0 to - StartSlot).
Pointer to an array of sampler-state interfaces (see ).
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.
void ID3D11DeviceContext::CSGetSamplers([In] unsigned int StartSlot,[In] unsigned int NumSamplers,[Out, Buffer, Optional] ID3D11SamplerState** ppSamplers)
Get the constant buffers used by the compute-shader stage.
Index into the device's zero-based array to begin retrieving constant buffers from (ranges from 0 to - 1).
Number of buffers to retrieve (ranges from 0 to - StartSlot).
Array of constant buffer interface references (see ) to be returned by the method.
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.
void ID3D11DeviceContext::CSGetConstantBuffers([In] unsigned int StartSlot,[In] unsigned int NumBuffers,[Out, Buffer, Optional] ID3D11Buffer** ppConstantBuffers)
The interface represents a device context which generates rendering commands.
ID3D11DeviceContext
Constructs a new deferred context .
The device with which to associate the state object.
The newly created object.
Create a command list and record graphics commands into it.
A flag indicating whether the immediate context state is saved (prior) and restored (after) the execution of a command list.
The created command list containing the queued rendering commands.
Determines whether asynhronous query data is available.
The data.
true if asynhronous query data is available; otherwise, false.
HRESULT ID3D11DeviceContext::GetData([In] ID3D11Asynchronous* pAsync,[Out, Buffer, Optional] void* pData,[In] unsigned int DataSize,[In] D3D11_ASYNC_GETDATA_FLAG GetDataFlags)
Determines whether asynhronous query data is available.
The data.
true if asynhronous query data is available; otherwise, false.
HRESULT ID3D11DeviceContext::GetData([In] ID3D11Asynchronous* pAsync,[Out, Buffer, Optional] void* pData,[In] unsigned int DataSize,[In] D3D11_ASYNC_GETDATA_FLAG GetDataFlags)
Gets data from the GPU asynchronously.
The asynchronous data provider.
The data retrieved from the GPU.
Gets data from the GPU asynchronously.
The asynchronous data provider.
The data retrieved from the GPU.
Gets data from the GPU asynchronously.
The asynchronous data provider.
The data retrieved from the GPU.
True if result contains valid data, false otherwise.
Gets data from the GPU asynchronously.
The asynchronous data provider.
Flags specifying how the command should operate.
The data retrieved from the GPU.
Gets data from the GPU asynchronously.
The asynchronous data provider.
Flags specifying how the command should operate.
The data retrieved from the GPU.
Gets data from the GPU asynchronously.
The asynchronous data provider.
Flags specifying how the command should operate.
The data retrieved from the GPU.
True if result contains valid data, false otherwise.
Copy the entire contents of the source resource to the destination resource using the GPU.
This method is unusual in that it causes the GPU to perform the copy operation (similar to a memcpy by the CPU). As a result, it has a few restrictions designed for improving performance. For instance, the source and destination resources: Must be different resources. Must be the same type. Must have identical dimensions (including width, height, depth, and size as appropriate). Will only be copied. CopyResource does not support any stretch, color key, blend, or format conversions. Must have compatible DXGI formats, which means the formats must be identical or at least from the same type group. For example, a DXGI_FORMAT_R32G32B32_FLOAT texture can be copied to an DXGI_FORMAT_R32G32B32_UINT texture since both of these formats are in the DXGI_FORMAT_R32G32B32_TYPELESS group. Might not be currently mapped. You cannot use an {{Immutable}} resource as a destination. You can use a {{depth-stencil}} resource as either a source or a destination. Resources created with multisampling capability (see ) can be used as source and destination only if both source and destination have identical multisampled count and quality. If source and destination differ in multisampled count and quality or if one is multisampled and the other is not multisampled the call to ID3D11DeviceContext::CopyResource fails. The method is an asynchronous call which may be added to the command-buffer queue. This attempts to remove pipeline stalls that may occur when copying data. An application that only needs to copy a portion of the data in a resource should use instead.
A reference to the source resource (see ).
A reference to the destination resource (see ).
void ID3D11DeviceContext::CopyResource([In] ID3D11Resource* pDstResource,[In] ID3D11Resource* pSrcResource)
Copy a region from a source resource to a destination resource.
The source box must be within the size of the source resource. The destination offsets, (x, y, and z) allow the source box to be offset when writing into the destination resource; however, the dimensions of the source box and the offsets must be within the size of the resource. If 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: Must be different subresources (although they can be from the same resource). Must be the same type. Must have compatible DXGI formats (identical or from the same type group). For example, a DXGI_FORMAT_R32G32B32_FLOAT texture can be copied to an DXGI_FORMAT_R32G32B32_UINT texture since both of these formats are in the DXGI_FORMAT_R32G32B32_TYPELESS group. May not be currently mapped. CopySubresourceRegion only supports copy; it does not support any stretch, color key, blend, or format conversions. An application that needs to copy an entire resource should use instead. CopySubresourceRegion is an asynchronous call which may be added to the command-buffer queue, this attempts to remove pipeline stalls that may occur when copying data. See performance considerations for more details. Note??If you use CopySubresourceRegion with a depth-stencil buffer or a multisampled resource, you must copy the whole subresource. In this situation, you must pass 0 to the DstX, DstY, and DstZ parameters and NULL to the pSrcBox parameter. In addition, source and destination resources, which are represented by the pSrcResource and pDstResource parameters, should have identical sample count values. Example The following code snippet copies a box (located at (120,100),(200,220)) from a source texture into a reqion (10,20),(90,140) in a destination texture.
D3D11_BOX sourceRegion;
sourceRegion.left = 120;
sourceRegion.right = 200;
sourceRegion.top = 100;
sourceRegion.bottom = 220;
sourceRegion.front = 0;
sourceRegion.back = 1; pd3dDeviceContext->CopySubresourceRegion( pDestTexture, 0, 10, 20, 0, pSourceTexture, 0, &sourceRegion );
Notice, that for a 2D texture, front and back are set to 0 and 1 respectively.
A reference to the source resource (see ).
Source subresource index.
A reference to a 3D box (see ) that defines the source subresources that can be copied. If NULL, the entire source subresource is copied. The box must fit within the source resource.
A reference to the destination resource (see ).
Destination subresource index.
The x-coordinate of the upper left corner of the destination region.
The y-coordinate of the upper left corner of the destination region. For a 1D subresource, this must be zero.
The z-coordinate of the upper left corner of the destination region. For a 1D or 2D subresource, this must be zero.
void ID3D11DeviceContext::CopySubresourceRegion([In] ID3D11Resource* pDstResource,[In] int DstSubresource,[In] int DstX,[In] int DstY,[In] int DstZ,[In] ID3D11Resource* pSrcResource,[In] int SrcSubresource,[In, Optional] const D3D11_BOX* pSrcBox)
Copy a multisampled resource into a non-multisampled resource.
This API is most useful when re-using the resulting rendertarget of one render pass as an input to a second render pass. The source and destination resources must be the same resource type and have the same dimensions. In addition, they must have compatible formats. There are three scenarios for this: ScenarioRequirements Source and destination are prestructured and typedBoth the source and destination must have identical formats and that format must be specified in the Format parameter. One resource is prestructured and typed and the other is prestructured and typelessThe typed resource must have a format that is compatible with the typeless resource (i.e. the typed resource is DXGI_FORMAT_R32_FLOAT and the typeless resource is DXGI_FORMAT_R32_TYPELESS). The format of the typed resource must be specified in the Format parameter. Source and destination are prestructured and typelessBoth the source and desintation must have the same typeless format (i.e. both must have DXGI_FORMAT_R32_TYPELESS), and the Format parameter must specify a format that is compatible with the source and destination (i.e. if both are DXGI_FORMAT_R32_TYPELESS then DXGI_FORMAT_R32_FLOAT could be specified in the Format parameter). For example, given the DXGI_FORMAT_R16G16B16A16_TYPELESS format: The source (or dest) format could be DXGI_FORMAT_R16G16B16A16_UNORM The dest (or source) format could be DXGI_FORMAT_R16G16B16A16_FLOAT ?
Source resource. Must be multisampled.
>The source subresource of the source resource.
Destination resource. Must be a created with the flag and be single-sampled. See .
A zero-based index, that identifies the destination subresource. Use {{D3D11CalcSubresource}} to calculate the index.
A that indicates how the multisampled resource will be resolved to a single-sampled resource. See remarks.
void ID3D11DeviceContext::ResolveSubresource([In] ID3D11Resource* pDstResource,[In] int DstSubresource,[In] ID3D11Resource* pSrcResource,[In] int SrcSubresource,[In] DXGI_FORMAT Format)
Maps the data contained in a subresource to a memory pointer, and denies the GPU access to that subresource.
The resource.
The mip slice.
The array slice.
The mode.
The flags.
The output stream containing the pointer.
The locked
HRESULT ID3D11DeviceContext::Map([In] ID3D11Resource* pResource,[In] unsigned int Subresource,[In] D3D11_MAP MapType,[In] D3D11_MAP_FLAG MapFlags,[Out] D3D11_MAPPED_SUBRESOURCE* pMappedResource)
Maps the data contained in a subresource to a memory pointer, and denies the GPU access to that subresource.
The resource.
The mip slice.
The array slice.
The mode.
The flags.
The output stream containing the pointer.
The locked
HRESULT ID3D11DeviceContext::Map([In] ID3D11Resource* pResource,[In] unsigned int Subresource,[In] D3D11_MAP MapType,[In] D3D11_MAP_FLAG MapFlags,[Out] D3D11_MAPPED_SUBRESOURCE* pMappedResource)
Maps the data contained in a subresource to a memory pointer, and denies the GPU access to that subresource.
The resource.
The mip slice.
The array slice.
The mode.
The flags.
The output stream containing the pointer.
The locked
HRESULT ID3D11DeviceContext::Map([In] ID3D11Resource* pResource,[In] unsigned int Subresource,[In] D3D11_MAP MapType,[In] D3D11_MAP_FLAG MapFlags,[Out] D3D11_MAPPED_SUBRESOURCE* pMappedResource)
Maps the data contained in a subresource to a memory pointer, and denies the GPU access to that subresource.
The resource.
The mode.
The flags.
The output stream containing the pointer.
The locked
HRESULT ID3D11DeviceContext::Map([In] ID3D11Resource* pResource,[In] unsigned int Subresource,[In] D3D11_MAP MapType,[In] D3D11_MAP_FLAG MapFlags,[Out] D3D11_MAPPED_SUBRESOURCE* pMappedResource)
Maps the data contained in a subresource to a memory pointer, and denies the GPU access to that subresource.
The resource.
The mip slice.
The array slice.
The mode.
The flags.
Size of the selected miplevel.
The locked
HRESULT ID3D11DeviceContext::Map([In] ID3D11Resource* pResource,[In] unsigned int Subresource,[In] D3D11_MAP MapType,[In] D3D11_MAP_FLAG MapFlags,[Out] D3D11_MAPPED_SUBRESOURCE* pMappedResource)
Maps the data contained in a subresource to a memory pointer, and denies the GPU access to that subresource.
The resource.
The subresource.
The mode.
The flags.
The output stream containing the pointer.
The locked
HRESULT ID3D11DeviceContext::Map([In] ID3D11Resource* pResource,[In] unsigned int Subresource,[In] D3D11_MAP MapType,[In] D3D11_MAP_FLAG MapFlags,[Out] D3D11_MAPPED_SUBRESOURCE* pMappedResource)
Copies data from the CPU to to a non-mappable subresource region.
Type of the data to upload
A reference to the data to upload.
The destination resource.
The destination subresource.
The row pitch.
The depth pitch.
Copies data from the CPU to to a non-mappable subresource region.
Type of the data to upload
A reference to the data to upload.
The destination resource.
The destination subresource.
The row pitch.
The depth pitch.
Copies data from the CPU to to a non-mappable subresource region.
The source data.
The destination resource.
The destination subresource.
Copies data from the CPU to to a non-mappable subresource region.
The source data.
The destination resource.
The destination subresource.
The destination region within the resource.
Initializes a new instance of the class.
The native pointer.
Update nested inner interfaces pointer
Draw indexed, non-instanced primitives.
Number of indices to draw.
The location of the first index read by the GPU from the index buffer.
A value added to each index before reading a vertex from the vertex buffer.
A draw API submits work to the rendering pipeline.If the sum of both indices is negative, the result of the function call is undefined.
void ID3D11DeviceContext::DrawIndexed([In] unsigned int IndexCount,[In] unsigned int StartIndexLocation,[In] int BaseVertexLocation)
Draw non-indexed, non-instanced primitives.
Number of vertices to draw.
Index of the first vertex, which is usually an offset in a vertex buffer; it could also be used as the first vertex id generated for a shader parameter marked with the SV_TargetId system-value semantic.
A draw API 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. However, you could also provide the vertex data from a shader that has vertex data marked with the SV_VertexId system-value semantic.
void ID3D11DeviceContext::Draw([In] unsigned int VertexCount,[In] unsigned int StartVertexLocation)
Gets a reference to the data contained in a subresource, and denies the GPU access to that subresource.
A reference to a interface.
Index number of the subresource.
Specifies the CPU's read and write permissions for a resource. For possible values, see .
Flag that specifies what the CPU should do when the GPU is busy. This flag is optional.
A reference to the mapped subresource (see ).
If you call Map on a deferred context, you can only pass , , or both to the MapType parameter. Other -typed values are not supported for a deferred context.The Direct3D 11.1 runtime, which is available starting with Windows Developer Preview, can map shader resource views (SRVs) of dynamic buffers with . The Direct3D 11 and earlier runtimes limited mapping to vertex or index buffers.
HRESULT ID3D11DeviceContext::Map([In] ID3D11Resource* pResource,[In] unsigned int Subresource,[In] D3D11_MAP MapType,[In] D3D11_MAP_FLAG MapFlags,[Out] D3D11_MAPPED_SUBRESOURCE* pMappedResource)
Invalidate the reference to a resource and re-enable the GPU's access to that resource.
A reference to a interface.
A subresource to be unmapped.
void ID3D11DeviceContext::Unmap([In] ID3D11Resource* pResource,[In] unsigned int Subresource)
Draw indexed, instanced primitives.
Number of indices read from the index buffer for each instance.
Number of instances to draw.
The location of the first index read by the GPU from the index buffer.
A value added to each index before reading a vertex from the vertex buffer.
A value added to each index before reading per-instance data from a vertex buffer.
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. Indexing requires multiple vertex buffers: at least one for per-vertex data and a second buffer for per-instance data.
void ID3D11DeviceContext::DrawIndexedInstanced([In] unsigned int IndexCountPerInstance,[In] unsigned int InstanceCount,[In] unsigned int StartIndexLocation,[In] int BaseVertexLocation,[In] unsigned int StartInstanceLocation)
Draw non-indexed, instanced primitives.
Number of vertices to draw.
Number of instances to draw.
Index of the first vertex.
A value added to each index before reading per-instance data from a vertex buffer.
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).
void ID3D11DeviceContext::DrawInstanced([In] unsigned int VertexCountPerInstance,[In] unsigned int InstanceCount,[In] unsigned int StartVertexLocation,[In] unsigned int StartInstanceLocation)
Mark the beginning of a series of commands.
A reference to an interface.
Use to mark the ending of the series of commands.
void ID3D11DeviceContext::Begin([In] ID3D11Asynchronous* pAsync)
Mark the end of a series of commands.
A reference to an interface.
Use to mark the beginning of the series of commands.
void ID3D11DeviceContext::End([In] ID3D11Asynchronous* pAsync)
Get data from the graphics processing unit (GPU) asynchronously.
A reference to an interface for the object about which GetData retrieves data.
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.
Size of the data to retrieve or 0. Must be 0 when pData is null.
Optional flags. Can be 0 or any combination of the flags enumerated by .
This method returns one of the Direct3D 11 Return Codes. A return value of 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 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 and . Certain queries only require a call to in which case the data returned by GetData is accurate up to the last call to . For information about the queries that only require a call to and about the type of data that GetData retrieves for each query, see .If DataSize is 0, GetData is only used to check status.An application gathers counter data by calling , issuing some graphics commands, calling , and then calling to get data about what happened in between the Begin and End calls. For information about performance counter types, see . The counter data is of type FLOAT32.
HRESULT ID3D11DeviceContext::GetData([In] ID3D11Asynchronous* pAsync,[Out, Buffer, Optional] void* pData,[In] unsigned int DataSize,[In] D3D11_ASYNC_GETDATA_FLAG GetDataFlags)
Set a rendering predicate.
Pointer to a predicate (see ). A null value indicates "no" predication; in this case, the value of PredicateValue is irrelevent but will be preserved for .
If TRUE, rendering will be affected by when the predicate's conditions are met. If , rendering will be affected when the conditions are not met.
The predicate must be in the "issued" or "signaled" state to be used for predication. While the predicate is set for predication, calls to and are invalid.This method is used 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 graphics commands without taking the performance hit of spinning, waiting for to return. So, Predication can occur while returns S_FALSE. Another way to think of it: an application can also use Predication as a fallback, if it is possible that returns S_FALSE. If returns , the application can skip calling the graphics commands manually with it's own application logic.
void ID3D11DeviceContext::SetPredication([In, Optional] ID3D11Predicate* pPredicate,[In] BOOL PredicateValue)
Draw geometry of an unknown size.
A draw API submits work to the rendering pipeline. This API submits work of an unknown size that was processed by the input assembler, vertex shader, and stream-output stages; the work may or may not have gone through the geometry-shader stage.After data has been streamed out to stream-output stage buffers, those buffers can be again bound to the Input Assembler stage at input slot 0 and DrawAuto will draw them without the application needing to know the amount of data that was written to the buffers. A measurement of the amount of data written to the SO stage buffers is maintained internally when the data is streamed out. This means that the CPU does not need to fetch the measurement before re-binding the data that was streamed as input data. Although this amount is tracked internally, it is still the responsibility of applications to use input layouts to describe the format of the data in the SO stage buffers so that the layouts are available when the buffers are again bound to the input assembler.The following diagram shows the DrawAuto process.Calling DrawAuto does not change the state of the streaming-output buffers that were bound again as inputs.DrawAuto only works when drawing with one input buffer bound as an input to the IA stage at slot 0. Applications must create the SO buffer resource with both binding flags, and .This API does not support indexing or instancing.If an application needs to retrieve the size of the streaming-output buffer, it can query for statistics on streaming output by using .
void ID3D11DeviceContext::DrawAuto()
Draw indexed, instanced, GPU-generated primitives.
A reference to an , which is a buffer containing the GPU generated primitives.
Offset in pBufferForArgs to the start of the GPU generated primitives.
When an application creates a buffer that is associated with the interface that pBufferForArgs points to, the application must set the flag in the MiscFlags member of the structure that describes the buffer. To create the buffer, the application calls the method and in this call passes a reference to in the pDesc parameter.
void ID3D11DeviceContext::DrawIndexedInstancedIndirect([In] ID3D11Buffer* pBufferForArgs,[In] unsigned int AlignedByteOffsetForArgs)
Draw instanced, GPU-generated primitives.
A reference to an , which is a buffer containing the GPU generated primitives.
Offset in pBufferForArgs to the start of the GPU generated primitives.
When an application creates a buffer that is associated with the interface that pBufferForArgs points to, the application must set the flag in the MiscFlags member of the structure that describes the buffer. To create the buffer, the application calls the method and in this call passes a reference to in the pDesc parameter.
void ID3D11DeviceContext::DrawInstancedIndirect([In] ID3D11Buffer* pBufferForArgs,[In] unsigned int AlignedByteOffsetForArgs)
Execute a command list from a thread group.
The number of groups dispatched in the x direction. ThreadGroupCountX must be less than D3D11_CS_DISPATCH_MAX_THREAD_GROUPS_PER_DIMENSION (65535).
The number of groups dispatched in the y direction. ThreadGroupCountY must be less than D3D11_CS_DISPATCH_MAX_THREAD_GROUPS_PER_DIMENSION (65535).
The number of groups dispatched in the z direction. ThreadGroupCountZ must be less than D3D11_CS_DISPATCH_MAX_THREAD_GROUPS_PER_DIMENSION (65535). In feature level 10 the value for ThreadGroupCountZ must be 1.
You call the Dispatch method to execute commands in a compute shader. A compute shader can be run on many threads in parallel, within a thread group. Index a particular thread, within a thread group using a 3D vector given by (x,y,z).In the following illustration, assume a thread group with 50 threads where the size of the group is given by (5,5,2). A single thread is identified from a thread group with 50 threads in it, using the vector (4,1,1).The following illustration shows the relationship between the parameters passed to , Dispatch(5,3,2), the values specified in the numthreads attribute, numthreads(10,8,3), and values that will passed to the compute shader for the thread-related system values
(SV_GroupIndex,SV_DispatchThreadID,SV_GroupThreadID,SV_GroupID).
void ID3D11DeviceContext::Dispatch([In] unsigned int ThreadGroupCountX,[In] unsigned int ThreadGroupCountY,[In] unsigned int ThreadGroupCountZ)
Execute a command list over one or more thread groups.
A reference to an , which must be loaded with data that matches the argument list for .
A byte-aligned offset between the start of the buffer and the arguments.
You call the DispatchIndirect method to execute commands in a compute shader.When an application creates a buffer that is associated with the interface that pBufferForArgs points to, the application must set the flag in the MiscFlags member of the structure that describes the buffer. To create the buffer, the application calls the method and in this call passes a reference to in the pDesc parameter.
void ID3D11DeviceContext::DispatchIndirect([In] ID3D11Buffer* pBufferForArgs,[In] unsigned int AlignedByteOffsetForArgs)
Copy a region from a source resource to a destination resource.
A reference to the destination resource (see ).
Destination subresource index.
The x-coordinate of the upper left corner of the destination region.
The y-coordinate of the upper left corner of the destination region. For a 1D subresource, this must be zero.
The z-coordinate of the upper left corner of the destination region. For a 1D or 2D subresource, this must be zero.
A reference to the source resource (see ).
Source subresource index.
A reference to a 3D box (see ) that defines the source subresources that can be copied. If null, the entire source subresource is copied. The box must fit within the source resource.
The source box must be within the size of the source resource. The destination offsets, (x, y, and z) allow the source box to be offset when writing into the destination resource; however, the dimensions of the source box and the offsets must be within the size of the resource.If 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:Must be different subresources (although they can be from the same resource). Must be the same type. Must have compatible DXGI formats (identical or from the same type group). For example, a texture can be copied to an texture since both of these formats are in the group. May not be currently mapped.CopySubresourceRegion only supports copy; it does not support any stretch, color key, blend, or format conversions. An application that needs to copy an entire resource should use instead.CopySubresourceRegion is an asynchronous call, which may be added to the command-buffer queue, this attempts to remove pipeline stalls that may occur when copying data. For more information about pipeline stalls, see performance considerations.Note??If you use CopySubresourceRegion with a depth-stencil buffer or a multisampled resource, you must copy the whole subresource. In this situation, you must pass 0 to the DstX, DstY, and DstZ parameters and null to the pSrcBox parameter. In addition, source and destination resources, which are represented by the pSrcResource and pDstResource parameters, should have identical sample count values.ExampleThe following code snippet copies a box (located at (120,100),(200,220)) from a source texture into a reqion (10,20),(90,140) in a destination texture.
sourceRegion;
sourceRegion.left = 120;
sourceRegion.right = 200;
sourceRegion.top = 100;
sourceRegion.bottom = 220;
sourceRegion.front = 0;
sourceRegion.back = 1; pd3dDeviceContext->CopySubresourceRegion( pDestTexture, 0, 10, 20, 0, pSourceTexture, 0, &sourceRegion );
Notice, that for a 2D texture, front and back are set to 0 and 1 respectively.
void ID3D11DeviceContext::CopySubresourceRegion([In] ID3D11Resource* pDstResource,[In] unsigned int DstSubresource,[In] unsigned int DstX,[In] unsigned int DstY,[In] unsigned int DstZ,[In] ID3D11Resource* pSrcResource,[In] unsigned int SrcSubresource,[In, Optional] const D3D11_BOX* pSrcBox)
Copy the entire contents of the source resource to the destination resource using the GPU.
A reference to the destination resource (see ).
A reference to the source resource (see ).
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:Must be different resources. Must be the same type. Must have identical dimensions (including width, height, depth, and size as appropriate). Will only be copied. CopyResource does not support any stretch, color key, blend, or format conversions. Must have compatible DXGI formats, which means the formats must be identical or at least from the same type group. For example, a texture can be copied to an texture since both of these formats are in the group. Might not be currently mapped.You cannot use an Immutable resource as a destination. You can use a depth-stencil resource as either a source or a destination. Resources created with multisampling capability (see ) can be used as source and destination only if both source and destination have identical multisampled count and quality. If source and destination differ in multisampled count and quality or if one is multisampled and the other is not multisampled the call to fails.The method is an asynchronous call which may be added to the command-buffer queue. This attempts to remove pipeline stalls that may occur when copying data.An application that only needs to copy a portion of the data in a resource should use instead.
void ID3D11DeviceContext::CopyResource([In] ID3D11Resource* pDstResource,[In] ID3D11Resource* pSrcResource)
The CPU copies data from memory to a subresource created in non-mappable memory.
A reference to the destination resource (see ).
A zero-based index, that identifies the destination subresource. See D3D11CalcSubresource for more details.
A reference to a box that defines the portion of the destination subresource to copy the resource data into. Coordinates are in bytes for buffers and in texels for textures. If null, the data is written to the destination subresource with no offset. The dimensions of the source must fit the destination (see ).
A reference to the source data in memory.
The size of one row of the source data.
The size of one depth slice of source data.
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:the resource is created with immutable or dynamic usage. the resource is created as a depth-stencil resource. the resource is created with multisampling capability (see ).When UpdateSubresource returns, the application is free to change or even free the data pointed to by pSrcData because the method has already copied/snapped away the original contents.The performance of UpdateSubresource depends on whether or not there is contention for the destination resource. For example, contention for a vertex buffer resource occurs when the application executes a Draw call and later calls UpdateSubresource on the same vertex buffer before the Draw call is actually executed by the GPU.When there is contention for the resource, UpdateSubresource will perform 2 copies of the source data. First, the data is copied by the CPU to a temporary storage space accessible by the command buffer. This copy happens before the method returns. A second copy is then performed by the GPU to copy the source data into non-mappable memory. This second copy happens asynchronously because it is executed by GPU when the command buffer is flushed. When there is no resource contention, the behavior of UpdateSubresource is dependent on which is faster (from the CPU's perspective): copying the data to the command buffer and then having a second copy execute when the command buffer is flushed, or having the CPU copy the data to the final resource location. This is dependent on the architecture of the underlying system.To better understand the source row pitch and source depth pitch parameters, the following illustration shows a 3D volume texture.Each block in this visual represents an element of data, and the size of each element is dependent on the resource's format. For example, if the resource format is , the size of each element would be 128 bits, or 16 bytes. This 3D volume texture has a width of two, a height of three, and a depth of four.To calculate the source row pitch and source depth pitch for a given resource, use the following formulas:Source Row Pitch = [size of one element in bytes] * [number of elements in one row] Source Depth Pitch = [Source Row Pitch] * [number of rows (height)]In the case of this example 3D volume texture where the size of each element is 16 bytes, the formulas are as follows:Source Row Pitch = 16 * 2 = 32 Source Depth Pitch = 16 * 2 * 3 = 96The following illustration shows the resource as it is laid out in memory.For example, the following code snippet shows how to specify a destination region in a 2D texture. Assume the destination texture is 512x512 and the operation will copy the data pointed to by pData to [(120,100)..(200,220)] in the destination texture. Also assume that rowPitch has been initialized with the proper value (as explained above). front and back are set to 0 and 1 respectively, because by having front equal to back, the box is technically empty.
destRegion;
destRegion.left = 120;
destRegion.right = 200;
destRegion.top = 100;
destRegion.bottom = 220;
destRegion.front = 0;
destRegion.back = 1; pd3dDeviceContext->UpdateSubresource( pDestTexture, 0, &destRegion, pData, rowPitch, 0 );
The 1D case is similar. The following snippet shows how to specify a destination region in a 1D texture. Use the same assumptions as above, except that the texture is 512 in length.
destRegion;
destRegion.left = 120
destRegion.right = 200;
destRegion.top = 0;
destRegion.bottom = 1;
destRegion.front = 0;
destRegion.back = 1; pd3dDeviceContext->UpdateSubresource( pDestTexture, 0, &destRegion, pData, rowPitch, 0 );
Calling UpdateSubresource on a Deferred ContextIf your application calls UpdateSubresource on a deferred context with a destination box?to which pDstBox points?that has a non-(0,0,0) offset, and if the driver does not support command lists, UpdateSubresource inappropriately applies that destination-box offset to the pSrcData parameter. To work around this behavior, use the following code:
UpdateSubresource_Workaround( *pDevice, *pDeviceContext, *pDstResource, UINT dstSubresource, const *pDstBox, const void *pSrcData, UINT srcBytesPerElement, UINT srcRowPitch, UINT srcDepthPitch, bool* pDidWorkAround )
{ hr = ; bool needWorkaround = false; contextType = pDeviceContext->GetType(); if( pDstBox && ( == contextType) ) { threadingCaps = { , }; hr = pDevice->CheckFeatureSupport( , &threadingCaps, sizeof(threadingCaps) ); if( SUCCEEDED(hr) ) { if( !threadingCaps.DriverCommandLists ) { needWorkaround = true; } } } const void* pAdjustedSrcData = pSrcData; if( needWorkaround ) { alignedBox = *pDstBox; // convert from pixels to blocks if( m_bBC ) { alignedBox.left /= 4; alignedBox.right /= 4; alignedBox.top /= 4; alignedBox.bottom /= 4; } pAdjustedSrcData = ((const BYTE*)pSrcData) - (alignedBox.front * srcDepthPitch) - (alignedBox.top * srcRowPitch) - (alignedBox.left * srcBytesPerElement); } pDeviceContext->UpdateSubresource( pDstResource, dstSubresource, pDstBox, pAdjustedSrcData, srcRowPitch, srcDepthPitch ); if( pDidWorkAround ) { *pDidWorkAround = needWorkaround; } return hr;
}
void ID3D11DeviceContext::UpdateSubresource([In] ID3D11Resource* pDstResource,[In] unsigned int DstSubresource,[In, Optional] const D3D11_BOX* pDstBox,[In] const void* pSrcData,[In] unsigned int SrcRowPitch,[In] unsigned int SrcDepthPitch)
Copies data from a buffer holding variable length data.
Pointer to . This can be any buffer resource that other copy commands, such as or , are able to write to.
Offset from the start of pDstBuffer to write 32-bit UINT structure (vertex) count from pSrcView.
Pointer to an of a Structured Buffer resource created with either or specified when the UAV was created. These types of resources have hidden counters tracking "how many" records have been written.
void ID3D11DeviceContext::CopyStructureCount([In] ID3D11Buffer* pDstBuffer,[In] unsigned int DstAlignedByteOffset,[In] ID3D11UnorderedAccessView* pSrcView)
Set all the elements in a render target to one value.
Pointer to the rendertarget.
A 4-component array that represents the color to fill the render target with.
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.Differences between Direct3D 9 and Direct3D 11/10:
Unlike Direct3D 9, the full extent of the resource view is always cleared. Viewport and scissor settings are not applied.?
void ID3D11DeviceContext::ClearRenderTargetView([In] ID3D11RenderTargetView* pRenderTargetView,[In] const SHARPDX_COLOR4* ColorRGBA)
Clears an unordered access resource with bit-precise values.
No documentation.
No documentation.
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.
void ID3D11DeviceContext::ClearUnorderedAccessViewUint([In] ID3D11UnorderedAccessView* pUnorderedAccessView,[In] const unsigned int* Values)
Clears an unordered access resource with a float value.
No documentation.
No documentation.
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.
void ID3D11DeviceContext::ClearUnorderedAccessViewFloat([In] ID3D11UnorderedAccessView* pUnorderedAccessView,[In] const float* Values)
Clears the depth-stencil resource.
Pointer to the depth stencil to be cleared.
Identify the type of data to clear (see ).
Clear the depth buffer with this value. This value will be clamped between 0 and 1.
Clear the stencil buffer with this value.
Differences between Direct3D 9 and Direct3D 11/10:
Unlike Direct3D 9, the full extent of the resource view is always cleared. Viewport and scissor settings are not applied.?
void ID3D11DeviceContext::ClearDepthStencilView([In] ID3D11DepthStencilView* pDepthStencilView,[In] D3D11_CLEAR_FLAG ClearFlags,[In] float Depth,[In] unsigned char Stencil)
Generate mipmaps for the given shader resource.
Pointer to an interface that represents the shader resource.
GenerateMips may be called on any shader-resource view in order to generate the lower mipmap levels. GenerateMips uses the largest mipmap level of the view to recursively generate the lower levels of the mip, stopping with the smallest level specified by the view. If the base resource was not created with and , this call has no effect.All video adapters support generating mipmaps if you are using any of the following formats:
Some video adapters support generating mipmaps if you are using this format:
For all other unsupported formats, this method will silently fail.
void ID3D11DeviceContext::GenerateMips([In] ID3D11ShaderResourceView* pShaderResourceView)
Sets the minimum level-of-detail (LOD) for a resource.
A reference to an that represents the resource.
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 structure.
To use a resource with SetResourceMinLOD, you must set the 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.
void ID3D11DeviceContext::SetResourceMinLOD([In] ID3D11Resource* pResource,[In] float MinLOD)
Gets the minimum level-of-detail (LOD).
A reference to an which represents the resource.
Returns the minimum LOD.
float ID3D11DeviceContext::GetResourceMinLOD([In] ID3D11Resource* pResource)
Copy a multisampled resource into a non-multisampled resource.
Destination resource. Must be a created with the flag and be single-sampled. See .
A zero-based index, that identifies the destination subresource. Use D3D11CalcSubresource to calculate the index.
Source resource. Must be multisampled.
>The source subresource of the source resource.
A that indicates how the multisampled resource will be resolved to a single-sampled resource. See remarks.
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:ScenarioRequirements Source and destination are prestructured and typedBoth the source and destination must have identical formats and that format must be specified in the Format parameter. One resource is prestructured and typed and the other is prestructured and typelessThe typed resource must have a format that is compatible with the typeless resource (i.e. the typed resource is and the typeless resource is ). The format of the typed resource must be specified in the Format parameter. Source and destination are prestructured and typelessBoth the source and desintation must have the same typeless format (i.e. both must have ), and the Format parameter must specify a format that is compatible with the source and destination (i.e. if both are then could be specified in the Format parameter). For example, given the format:
The source (or dest) format could be The dest (or source) format could be ?
void ID3D11DeviceContext::ResolveSubresource([In] ID3D11Resource* pDstResource,[In] unsigned int DstSubresource,[In] ID3D11Resource* pSrcResource,[In] unsigned int SrcSubresource,[In] DXGI_FORMAT Format)
Queues commands from a command list onto a device.
A reference to an interface that encapsulates a command list.
A Boolean flag that determines whether the immediate 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 to indicate that no state shall be saved or restored, which causes the immediate context to return to its default state after the command list executes. Applications should typically use 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 , they can avoid unnecessary and inefficient state transitions.
Use this method to play back a command list that was recorded by a deferred context on any thread.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 ( is performed, unless the application indicates to preserve the device context state).
void ID3D11DeviceContext::ExecuteCommandList([In] ID3D11CommandList* pCommandList,[In] BOOL RestoreContextState)
Get the rendering predicate state.
Address of a boolean to fill with the predicate comparison value. upon device creation.
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.
void ID3D11DeviceContext::GetPredication([Out, Optional] ID3D11Predicate** ppPredicate,[Out, Optional] BOOL* pPredicateValue)
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 and throw away the resulting .
void ID3D11DeviceContext::ClearState()
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 method with the value to create an event query; you can then use that event query in a call to the 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 , and then call Flush.Deferred Destruction Issues with Flip Presentation Swap ChainsDirect3D?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 flag set. When you create a flip presentation model swap chain, you can associate only one swap chain at a time with an , 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 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 (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 , , or again to create a new swap chain.
void ID3D11DeviceContext::Flush()
Gets the type of device context.
A member of that indicates the type of device context.
D3D11_DEVICE_CONTEXT_TYPE ID3D11DeviceContext::GetType()
Gets the initialization flags associated with the current deferred context.
No documentation.
The GetContextFlags method gets the flags that were supplied to the ContextFlags parameter of ; however, the context flag is reserved for future use.
unsigned int ID3D11DeviceContext::GetContextFlags()
Create a command list and record graphics commands into it.
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 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 . Typically, use unless you restore the state to be nearly equivalent to the state that the runtime would restore if you passed TRUE. When you use , 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.
Upon completion of the method, the passed reference to an interface reference is initialized with the recorded command list information.
Returns if successful; otherwise, returns one of the following:Returns if the video card has been physically removed from the system, or a driver upgrade for the video card has occurred. If this error occurs, you should destroy and recreate the device. Returns if FinishCommandList cannot be called from the current context. See remarks. Returns E_OUTOFMEMORY if the application has exhausted available memory.
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 .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 or .For more information about how to use FinishCommandList, see How to: Record a Command List.
HRESULT ID3D11DeviceContext::FinishCommandList([In] BOOL RestoreDeferredContextState,[Out, Optional] ID3D11CommandList** ppCommandList)
Inner interface giving access to VertexShaderStage methods.
Inner interface giving access to PixelShaderStage methods.
Inner interface giving access to InputAssemblerStage methods.
Inner interface giving access to GeometryShaderStage methods.
Inner interface giving access to OutputMergerStage methods.
Inner interface giving access to StreamOutputStage methods.
Inner interface giving access to RasterizerStage methods.
Inner interface giving access to HullShaderStage methods.
Inner interface giving access to DomainShaderStage methods.
Inner interface giving access to ComputeShaderStage methods.
Gets the type of device context.
GetType
D3D11_DEVICE_CONTEXT_TYPE ID3D11DeviceContext::GetType()
Gets the initialization flags associated with the current deferred context.
The GetContextFlags method gets the flags that were supplied to the ContextFlags parameter of ; however, the context flag is reserved for future use.
GetContextFlags
unsigned int ID3D11DeviceContext::GetContextFlags()
The interface represents a device context which generates rendering commands.
ID3D11DeviceContext
Constant IndexInputResourceSlotCount.
D3D11_IA_INDEX_INPUT_RESOURCE_SLOT_COUNT
Constant VertexIdBitCount.
D3D11_IA_VERTEX_ID_BIT_COUNT
Constant IntegerArithmeticBitCount.
D3D11_IA_INTEGER_ARITHMETIC_BIT_COUNT
Constant VertexInputResourceSlotCount.
D3D11_IA_VERTEX_INPUT_RESOURCE_SLOT_COUNT
Constant DefaultIndexBufferOffsetInBytes.
D3D11_IA_DEFAULT_INDEX_BUFFER_OFFSET_IN_BYTES
Constant DefaultPrimitiveTopology.
D3D11_IA_DEFAULT_PRIMITIVE_TOPOLOGY
Constant DefaultVertexBufferOffsetInBytes.
D3D11_IA_DEFAULT_VERTEX_BUFFER_OFFSET_IN_BYTES
Constant InstanceIdBitCount.
D3D11_IA_INSTANCE_ID_BIT_COUNT
Constant VertexInputStructureElementsComponents.
D3D11_IA_VERTEX_INPUT_STRUCTURE_ELEMENTS_COMPONENTS
Constant VertexInputStructureElementCount.
D3D11_IA_VERTEX_INPUT_STRUCTURE_ELEMENT_COUNT
Constant PrimitiveIdBitCount.
D3D11_IA_PRIMITIVE_ID_BIT_COUNT
Constant PatchMaximumControlPointCount.
D3D11_IA_PATCH_MAX_CONTROL_POINT_COUNT
Binds a single vertex buffer to the input assembler.
Index of the slot to which to bind the vertex buffer.
A binding for the input vertex buffer.
Binds an array of vertex buffers to the input assembler.
Index of the first input slot to use 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. There are 16 input slots.
An array of bindings for input vertex buffers.
Binds an array of vertex buffers to the input assembler.
Index of the first input slot to use 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. There are 16 input slots.
The vertex buffers.
The strides.
The offsets.
Initializes a new instance of the class.
The native pointer.
Bind an input-layout object to the input-assembler stage.
A reference to the input-layout object (see ), which describes the input buffers that will be read by the IA stage.
Input-layout objects describe how vertex buffer data is streamed into the IA pipeline stage. To create an input-layout object, call .The method will hold a reference to the interfaces passed in. This differs from the device state behavior in Direct3D 10.
void ID3D11DeviceContext::IASetInputLayout([In, Optional] ID3D11InputLayout* pInputLayout)
Bind an array of vertex buffers to the input-assembler stage.
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 - 1) are available; the maximum number of input slots depends on the feature level.
The number of vertex buffers in the array. The number of buffers (plus the starting slot) cannot exceed the total number of IA-stage input slots (ranges from 0 to - StartSlot).
A reference to an array of vertex buffers (see ). The vertex buffers must have been created with the flag.
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.
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.
For information about creating vertex buffers, see Create a Vertex 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.
void ID3D11DeviceContext::IASetVertexBuffers([In] unsigned int StartSlot,[In] unsigned int NumBuffers,[In, Buffer, Optional] const void* ppVertexBuffers,[In, Buffer, Optional] const void* pStrides,[In, Buffer, Optional] const void* pOffsets)
Bind an index buffer to the input-assembler stage.
A reference to an object, that contains indices. The index buffer must have been created with the flag.
A that specifies the format of the data in the index buffer. The only formats allowed for index buffer data are 16-bit () and 32-bit () integers.
Offset (in bytes) from the start of the index buffer to the first index to use.
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.
void ID3D11DeviceContext::IASetIndexBuffer([In, Optional] ID3D11Buffer* pIndexBuffer,[In] DXGI_FORMAT Format,[In] unsigned int Offset)
Bind information about the primitive type, and data order that describes input data for the input assembler stage.
The type of primitive and ordering of the primitive data (see D3D11_PRIMITIVE_TOPOLOGY).
void ID3D11DeviceContext::IASetPrimitiveTopology([In] D3D_PRIMITIVE_TOPOLOGY Topology)
Get a reference to the input-layout object that is bound to the input-assembler stage.
A reference to the input-layout object (see ), which describes the input buffers that will be read by the IA stage.
For information about creating an input-layout object, see Creating the Input-Layout Object.Any returned interfaces will have their reference count incremented by one. Applications should call IUnknown::Release on the returned interfaces when they are no longer needed to avoid memory leaks.
void ID3D11DeviceContext::IAGetInputLayout([Out] ID3D11InputLayout** ppInputLayout)
Get the vertex buffers bound to the input-assembler stage.
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 - 1) are available; the maximum number of input slots depends on the feature level.
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.
A reference to an array of vertex buffers returned by the method (see ).
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.
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.
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.
void ID3D11DeviceContext::IAGetVertexBuffers([In] unsigned int StartSlot,[In] unsigned int NumBuffers,[Out, Buffer, Optional] ID3D11Buffer** ppVertexBuffers,[Out, Buffer, Optional] unsigned int* pStrides,[Out, Buffer, Optional] unsigned int* pOffsets)
Get a reference to the index buffer that is bound to the input-assembler stage.
A reference to an index buffer returned by the method (see ).
Specifies format of the data in the index buffer (see ). These formats provide the size and type of the data in the buffer. The only formats allowed for index buffer data are 16-bit () and 32-bit () integers.
Offset (in bytes) from the start of the index buffer, to the first index to use.
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.
void ID3D11DeviceContext::IAGetIndexBuffer([Out, Optional] ID3D11Buffer** pIndexBuffer,[Out, Optional] DXGI_FORMAT* Format,[Out, Optional] unsigned int* Offset)
Get information about the primitive type, and data order that describes input data for the input assembler stage.
A reference to the type of primitive, and ordering of the primitive data (see D3D11_PRIMITIVE_TOPOLOGY).
void ID3D11DeviceContext::IAGetPrimitiveTopology([Out] D3D_PRIMITIVE_TOPOLOGY* pTopology)
Get a reference to the input-layout object that is bound to the input-assembler stage.
For information about creating an input-layout object, see Creating the Input-Layout Object.Any returned interfaces will have their reference count incremented by one. Applications should call IUnknown::Release on the returned interfaces when they are no longer needed to avoid memory leaks.
IAGetInputLayout
void ID3D11DeviceContext::IAGetInputLayout([Out] ID3D11InputLayout** ppInputLayout)
Get information about the primitive type, and data order that describes input data for the input assembler stage.
IAGetPrimitiveTopology
void ID3D11DeviceContext::IAGetPrimitiveTopology([Out] D3D_PRIMITIVE_TOPOLOGY* pTopology)
The interface represents a device context which generates rendering commands.
ID3D11DeviceContext
Get references to the render targets that are available to the {{output-merger stage}}.
Any returned interfaces will have their reference count incremented by one. Applications should call {{IUnknown::Release}} on the returned interfaces when they are no longer needed to avoid memory leaks.
a depth-stencil view (see ) to be filled with the depth-stencil information from the device.
void OMGetRenderTargets([In] int NumViews,[Out, Buffer, Optional] ID3D10RenderTargetView** ppRenderTargetViews,[Out, Optional] ID3D10DepthStencilView** ppDepthStencilView)
Get references to the render targets that are available to the {{output-merger stage}}.
Any returned interfaces will have their reference count incremented by one. Applications should call {{IUnknown::Release}} on the returned interfaces when they are no longer needed to avoid memory leaks.
Number of render targets to retrieve.
an array of render targets views (see ) to be filled with the render targets from the device.
void OMGetRenderTargets([In] int NumViews,[Out, Buffer, Optional] ID3D10RenderTargetView** ppRenderTargetViews,[Out, Optional] ID3D10DepthStencilView** ppDepthStencilView)
Get references to the render targets and the depth-stencil buffer that are available to the {{output-merger stage}}.
Any returned interfaces will have their reference count incremented by one. Applications should call {{IUnknown::Release}} on the returned interfaces when they are no longer needed to avoid memory leaks.
Number of render targets to retrieve.
Pointer to a depth-stencil view (see ) to be filled with the depth-stencil information from the device.
an array of render targets views (see ) to be filled with the render targets from the device.
void OMGetRenderTargets([In] int NumViews,[Out, Buffer, Optional] ID3D10RenderTargetView** ppRenderTargetViews,[Out, Optional] ID3D10DepthStencilView** ppDepthStencilView)
Get the {{blend state}} of the output-merger stage.
The reference count of the returned interface will be incremented by one when the blend state is retrieved. Applications must release returned reference(s) when they are no longer needed, or else there will be a memory leak.
Array of blend factors, one for each RGBA component.
Pointer to a {{sample mask}}.
a reference to a blend-state interface (see ).
void OMGetBlendState([Out, Optional] ID3D10BlendState** ppBlendState,[Out, Optional] float BlendFactor[4],[Out, Optional] int* pSampleMask)
Gets the {{depth-stencil}} state of the output-merger stage.
Any returned interfaces will have their reference count incremented by one. Applications should call {{IUnknown::Release}} on the returned interfaces when they are no longer needed to avoid memory leaks.
Pointer to the stencil reference value used in the {{depth-stencil}} test.
a reference to a depth-stencil state interface (see ) to be filled with information from the device.
void OMGetDepthStencilState([Out, Optional] ID3D10DepthStencilState** ppDepthStencilState,[Out, Optional] int* pStencilRef)
Gets an array of views for an unordered resource.
Any returned interfaces will have their reference count incremented by one. Applications should call IUnknown::Release on the returned interfaces when they are no longer needed to avoid memory leaks.
Index of the first element in the zero-based array to return (ranges from 0 to D3D11_PS_CS_UAV_REGISTER_COUNT - 1).
Number of views to get (ranges from 0 to D3D11_PS_CS_UAV_REGISTER_COUNT - StartSlot).
void OMGetRenderTargetsAndUnorderedAccessViews([In] int NumRTVs,[Out, Buffer, Optional] ID3D11RenderTargetView** ppRenderTargetViews,[Out, Optional] ID3D11DepthStencilView** ppDepthStencilView,[In] int UAVStartSlot,[In] int NumUAVs,[Out, Buffer, Optional] ID3D11UnorderedAccessView** ppUnorderedAccessViews)
Unbinds all depth-stencil buffer and render targets from the output-merger stage.
Binds a set of render targets to the output-merger stage.
A set of render target views to bind.
Binds a single render target to the output-merger stage.
A view of the render target to bind.
Binds a depth-stencil buffer and a set of render targets to the output-merger stage.
A view of the depth-stencil buffer to bind.
A set of render target views to bind.
Binds a depth-stencil buffer and a single render target to the output-merger stage.
A view of the depth-stencil buffer to bind.
A view of the render target to bind.
Binds a depth-stencil buffer and a set of render targets to the output-merger stage.
A view of the depth-stencil buffer to bind.
A set of render target views to bind.
void ID3D11DeviceContext::OMSetRenderTargets([In] unsigned int NumViews,[In, Buffer, Optional] const ID3D11RenderTargetView** ppRenderTargetViews,[In, Optional] ID3D11DepthStencilView* pDepthStencilView)
Binds a set of render targets to the output-merger stage and clear the depth stencil view.
A set of render target views to bind.
void ID3D11DeviceContext::OMSetRenderTargets([In] unsigned int NumViews,[In, Buffer, Optional] const ID3D11RenderTargetView** ppRenderTargetViews,[In, Optional] ID3D11DepthStencilView* pDepthStencilView)
Binds a set of unordered access views and a single render target to the output-merger stage.
Index into a zero-based array to begin setting unordered access views.
A set of unordered access views to bind.
A view of the render target to bind.
Binds a set of unordered access views and a set of render targets to the output-merger stage.
Index into a zero-based array to begin setting unordered access views.
A set of unordered access views to bind.
A set of render target views to bind.
Binds a depth-stencil buffer, a set of unordered access views, and a single render target to the output-merger stage.
A view of the depth-stencil buffer to bind.
Index into a zero-based array to begin setting unordered access views.
A set of unordered access views to bind.
A view of the render target to bind.
Binds a depth-stencil buffer, a set of unordered access views, and a set of render targets to the output-merger stage.
A view of the depth-stencil buffer to bind.
Index into a zero-based array to begin setting unordered access views.
A set of unordered access views to bind.
A set of render target views to bind.
Binds a set of unordered access views and a single render target to the output-merger stage.
Index into a zero-based array to begin setting unordered access views.
A set of unordered access views to bind.
A view of the render target to bind.
An array of Append/Consume buffer offsets. A value of -1 indicates the current offset should be kept. Any other values set the hidden counter for that Appendable/Consumeable UAV.
Binds a set of unordered access views and a set of render targets to the output-merger stage.
Index into a zero-based array to begin setting unordered access views.
A set of unordered access views to bind.
A set of render target views to bind.
An array of Append/Consume buffer offsets. A value of -1 indicates the current offset should be kept. Any other values set the hidden counter for that Appendable/Consumeable UAV.
Binds a depth-stencil buffer, a set of unordered access views, and a single render target to the output-merger stage.
A view of the depth-stencil buffer to bind.
Index into a zero-based array to begin setting unordered access views.
A set of unordered access views to bind.
A view of the render target to bind.
An array of Append/Consume buffer offsets. A value of -1 indicates the current offset should be kept. Any other values set the hidden counter for that Appendable/Consumeable UAV.
Binds a depth-stencil buffer, a set of unordered access views, and a set of render targets to the output-merger stage.
A view of the depth-stencil buffer to bind.
Index into a zero-based array to begin setting unordered access views.
A set of unordered access views to bind.
A set of render target views to bind.
An array of Append/Consume buffer offsets. A value of -1 indicates the current offset should be kept. Any other values set the hidden counter for that Appendable/Consumeable UAV.
void ID3D11DeviceContext::OMSetRenderTargets([In] unsigned int NumViews,[In, Buffer, Optional] const ID3D11RenderTargetView** ppRenderTargetViews,[In, Optional] ID3D11DepthStencilView* pDepthStencilView)
Initializes a new instance of the class.
The native pointer.
Bind one or more render targets atomically and the depth-stencil buffer to the output-merger stage.
Number of render targets to bind (ranges between 0 and D3D11_SIMULTANEOUS_RENDER_TARGET_COUNT).
Pointer to an array of render targets (see ) to bind to the device. If this parameter is null, no render targets are bound. See Remarks.
Pointer to a depth-stencil view (see ) to bind to the device. If this parameter is null, the depth-stencil state is not bound.
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, then 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.
void ID3D11DeviceContext::OMSetRenderTargets([In] unsigned int NumViews,[In] const void** ppRenderTargetViews,[In, Optional] ID3D11DepthStencilView* pDepthStencilView)
Binds resources to the output-merger stage.
Number of render-target views (ppRenderTargetViews) and depth-stencil view (ppDepthStencilView) to bind. If you set NumViews 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).
Pointer to an array of ID3D11RenderTargetViews, which represent render-target views. Specify null to set none.
Pointer to a , which represents a depth-stencil view. Specify null to set none.
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 Developer Preview, 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.
Number of unordered-access views (UAVs) in ppUnorderedAccessView. 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 Developer Preview, this value can range from 0 to D3D11_1_UAV_SLOT_COUNT - UAVStartSlot.
Pointer to an array of ID3D11UnorderedAccessViews, which represent unordered-access views.
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 or specified when the UAV was created; otherwise, the argument is ignored.
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:NumViews != D3D11_KEEP_RENDER_TARGETS_AND_DEPTH_STENCIL and NumUAVs != D3D11_KEEP_UNORDERED_ACCESS_VIEWS
The following conditions must be true for OMSetRenderTargetsAndUnorderedAccessViews to succeed and for the runtime to pass the bind information to the driver:
NumViews <= 8 UAVStartSlot >= NumViews UAVStartSlot + NumUAVs <= 8 There must be no conflicts in the set of all ppRenderTargetViews and ppUnorderedAccessView. ppDepthStencilView must match the render-target views. For more information about resource views, see Introduction to a Resource in Direct3D 11. OMSetRenderTargetsAndUnorderedAccessViews performs the following tasks:
Unbinds all currently bound conflicting resources (stream-output target resources (SOTargets), compute shader (CS) UAVs, shader-resource views (SRVs)). Binds ppRenderTargetViews, ppDepthStencilView, and ppUnorderedAccessView. NumViews == D3D11_KEEP_RENDER_TARGETS_AND_DEPTH_STENCIL
In this situation, OMSetRenderTargetsAndUnorderedAccessViews binds only UAVs.
The following conditions must be true for OMSetRenderTargetsAndUnorderedAccessViews to succeed and for the runtime to pass the bind information to the driver:
UAVStartSlot + NumUAVs <= 8 There must be no conflicts in ppUnorderedAccessView. OMSetRenderTargetsAndUnorderedAccessViews unbinds the following items:
All RTVs in slots >= UAVStartSlot All RTVs that conflict with any UAVs in ppUnorderedAccessView All currently bound resources (SOTargets, CS UAVs, SRVs) that conflict with ppUnorderedAccessView OMSetRenderTargetsAndUnorderedAccessViews binds ppUnorderedAccessView.
OMSetRenderTargetsAndUnorderedAccessViews ignores ppDepthStencilView, and the current depth-stencil view remains bound.
NumUAVs == D3D11_KEEP_UNORDERED_ACCESS_VIEWS
In this situation, OMSetRenderTargetsAndUnorderedAccessViews binds only RTVs and DSV.
The following conditions must be true for OMSetRenderTargetsAndUnorderedAccessViews to succeed and for the runtime to pass the bind information to the driver:
NumViews <= 8 There must be no conflicts in ppRenderTargetViews. ppDepthStencilView must match the render-target views. For more information about resource views, see Introduction to a Resource in Direct3D 11. OMSetRenderTargetsAndUnorderedAccessViews unbinds the following items:
All UAVs in slots < NumViews All UAVs that conflict with any RTVs in ppRenderTargetViews All currently bound resources (SOTargets, CS UAVs, SRVs) that conflict with ppRenderTargetViews OMSetRenderTargetsAndUnorderedAccessViews binds ppRenderTargetViews and ppDepthStencilView.
OMSetRenderTargetsAndUnorderedAccessViews ignores UAVStartSlot.
void ID3D11DeviceContext::OMSetRenderTargetsAndUnorderedAccessViews([In] unsigned int NumRTVs,[In, Buffer, Optional] const ID3D11RenderTargetView** ppRenderTargetViews,[In, Optional] ID3D11DepthStencilView* pDepthStencilView,[In] unsigned int UAVStartSlot,[In] unsigned int NumUAVs,[In, Buffer, Optional] const ID3D11UnorderedAccessView** ppUnorderedAccessViews,[In, Buffer, Optional] const unsigned int* pUAVInitialCounts)
Binds resources to the output-merger stage.
Number of render-target views (ppRenderTargetViews) and depth-stencil view (ppDepthStencilView) to bind. If you set NumViews 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).
Pointer to an array of ID3D11RenderTargetViews, which represent render-target views. Specify null to set none.
Pointer to a , which represents a depth-stencil view. Specify null to set none.
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 Developer Preview, 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.
Number of unordered-access views (UAVs) in ppUnorderedAccessView. 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 Developer Preview, this value can range from 0 to D3D11_1_UAV_SLOT_COUNT - UAVStartSlot.
Pointer to an array of ID3D11UnorderedAccessViews, which represent unordered-access views.
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 or specified when the UAV was created; otherwise, the argument is ignored.
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:NumViews != D3D11_KEEP_RENDER_TARGETS_AND_DEPTH_STENCIL and NumUAVs != D3D11_KEEP_UNORDERED_ACCESS_VIEWS
The following conditions must be true for OMSetRenderTargetsAndUnorderedAccessViews to succeed and for the runtime to pass the bind information to the driver:
NumViews <= 8 UAVStartSlot >= NumViews UAVStartSlot + NumUAVs <= 8 There must be no conflicts in the set of all ppRenderTargetViews and ppUnorderedAccessView. ppDepthStencilView must match the render-target views. For more information about resource views, see Introduction to a Resource in Direct3D 11. OMSetRenderTargetsAndUnorderedAccessViews performs the following tasks:
Unbinds all currently bound conflicting resources (stream-output target resources (SOTargets), compute shader (CS) UAVs, shader-resource views (SRVs)). Binds ppRenderTargetViews, ppDepthStencilView, and ppUnorderedAccessView. NumViews == D3D11_KEEP_RENDER_TARGETS_AND_DEPTH_STENCIL
In this situation, OMSetRenderTargetsAndUnorderedAccessViews binds only UAVs.
The following conditions must be true for OMSetRenderTargetsAndUnorderedAccessViews to succeed and for the runtime to pass the bind information to the driver:
UAVStartSlot + NumUAVs <= 8 There must be no conflicts in ppUnorderedAccessView. OMSetRenderTargetsAndUnorderedAccessViews unbinds the following items:
All RTVs in slots >= UAVStartSlot All RTVs that conflict with any UAVs in ppUnorderedAccessView All currently bound resources (SOTargets, CS UAVs, SRVs) that conflict with ppUnorderedAccessView OMSetRenderTargetsAndUnorderedAccessViews binds ppUnorderedAccessView.
OMSetRenderTargetsAndUnorderedAccessViews ignores ppDepthStencilView, and the current depth-stencil view remains bound.
NumUAVs == D3D11_KEEP_UNORDERED_ACCESS_VIEWS
In this situation, OMSetRenderTargetsAndUnorderedAccessViews binds only RTVs and DSV.
The following conditions must be true for OMSetRenderTargetsAndUnorderedAccessViews to succeed and for the runtime to pass the bind information to the driver:
NumViews <= 8 There must be no conflicts in ppRenderTargetViews. ppDepthStencilView must match the render-target views. For more information about resource views, see Introduction to a Resource in Direct3D 11. OMSetRenderTargetsAndUnorderedAccessViews unbinds the following items:
All UAVs in slots < NumViews All UAVs that conflict with any RTVs in ppRenderTargetViews All currently bound resources (SOTargets, CS UAVs, SRVs) that conflict with ppRenderTargetViews OMSetRenderTargetsAndUnorderedAccessViews binds ppRenderTargetViews and ppDepthStencilView.
OMSetRenderTargetsAndUnorderedAccessViews ignores UAVStartSlot.
void ID3D11DeviceContext::OMSetRenderTargetsAndUnorderedAccessViews([In] unsigned int NumRTVs,[In, Buffer, Optional] const ID3D11RenderTargetView** ppRenderTargetViews,[In, Optional] ID3D11DepthStencilView* pDepthStencilView,[In] unsigned int UAVStartSlot,[In] unsigned int NumUAVs,[In, Buffer, Optional] const ID3D11UnorderedAccessView** ppUnorderedAccessViews,[In, Buffer, Optional] const unsigned int* pUAVInitialCounts)
Set the blend state of the output-merger stage.
Pointer to a blend-state interface (see ). Passing in null implies a default blend state. See remarks for further details.
Array of blend factors, one for each RGBA component. This requires a blend state object that specifies the option.
32-bit sample coverage. The default value is 0xffffffff. See remarks.
Blend state is used by the output-merger stage to determine how to blend together two pixel values. The two values are commonly the current pixel value and the pixel value already in the output render target. Use the blend operation to control where the two pixel values come from and how they are mathematically combined.To create a blend-state interface, call .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.StateDefault Value AlphaToCoverageEnableFALSE BlendEnableFALSE[8] SrcBlendD3D11_BLEND_ONE DstBlendD3D11_BLEND_ZERO BlendOpD3D11_BLEND_OP_ADD SrcBlendAlphaD3D11_BLEND_ONE DstBlendAlphaD3D11_BLEND_ZERO BlendOpAlphaD3D11_BLEND_OP_ADD RenderTargetWriteMask[8][8]?A sample mask determines which samples get updated in all the active render targets. The mapping of bits in a sample mask to samples in a multisample render target is the responsibility of an individual application. A sample mask is always applied; it is independent of whether multisampling is enabled, and does not depend on whether an application uses multisample render targets.The method will hold a reference to the interfaces passed in. This differs from the device state behavior in Direct3D 10.
void ID3D11DeviceContext::OMSetBlendState([In, Optional] ID3D11BlendState* pBlendState,[In, Optional] const SHARPDX_COLOR4* BlendFactor,[In] unsigned int SampleMask)
Sets the depth-stencil state of the output-merger stage.
Pointer to a depth-stencil state interface (see ) to bind to the device. Set this to null to use the default state listed in .
Reference value to perform against when doing a depth-stencil test. See remarks.
To create a depth-stencil state interface, call .The method will hold a reference to the interfaces passed in. This differs from the device state behavior in Direct3D 10.
void ID3D11DeviceContext::OMSetDepthStencilState([In, Optional] ID3D11DepthStencilState* pDepthStencilState,[In] unsigned int StencilRef)
Get references to the resources bound to the output-merger stage.
Number of render targets to retrieve.
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.
Pointer to a , which represents a depth-stencil view. Specify null for this parameter when retrieval of the depth-stencil view is not needed.
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.
void ID3D11DeviceContext::OMGetRenderTargets([In] unsigned int NumViews,[Out, Buffer, Optional] ID3D11RenderTargetView** ppRenderTargetViews,[Out, Optional] ID3D11DepthStencilView** ppDepthStencilView)
Get references to the resources bound to the output-merger stage.
The number of render-target views to retrieve.
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.
Pointer to a , which represents a depth-stencil view. Specify null for this parameter when retrieval of the depth-stencil view is not required.
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.
Number of unordered-access views to return in ppUnorderedAccessViews. This number ranges from 0 to D3D11_PS_CS_UAV_REGISTER_COUNT - UAVStartSlot.
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.
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.
void ID3D11DeviceContext::OMGetRenderTargetsAndUnorderedAccessViews([In] unsigned int NumRTVs,[Out, Buffer, Optional] ID3D11RenderTargetView** ppRenderTargetViews,[Out, Optional] ID3D11DepthStencilView** ppDepthStencilView,[In] unsigned int UAVStartSlot,[In] unsigned int NumUAVs,[Out, Buffer, Optional] ID3D11UnorderedAccessView** ppUnorderedAccessViews)
Get the blend state of the output-merger stage.
Address of a reference to a blend-state interface (see ).
Array of blend factors, one for each RGBA component.
Pointer to a sample mask.
The reference count of the returned interface will be incremented by one when the blend state is retrieved. Applications must release returned reference(s) when they are no longer needed, or else there will be a memory leak.
void ID3D11DeviceContext::OMGetBlendState([Out, Optional] ID3D11BlendState** ppBlendState,[Out, Optional] SHARPDX_COLOR4* BlendFactor,[Out, Optional] unsigned int* pSampleMask)
Gets the depth-stencil state of the output-merger stage.
Address of a reference to a depth-stencil state interface (see ) to be filled with information from the device.
Pointer to the stencil reference value used in the depth-stencil test.
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.
void ID3D11DeviceContext::OMGetDepthStencilState([Out, Optional] ID3D11DepthStencilState** ppDepthStencilState,[Out, Optional] unsigned int* pStencilRef)
Gets or sets the blend factor.
The blend factor.
Gets or sets the blend sample mask.
The blend sample mask.
Gets or sets the state of the blend.
The state of the blend.
Gets or sets the depth stencil reference.
The depth stencil reference.
Gets or sets the state of the depth stencil.
The state of the depth stencil.
The interface represents a device context which generates rendering commands.
ID3D11DeviceContext
Get the array of {{viewports}} bound to the {{rasterizer stage}}
An array of viewports (see ).
void RSGetViewports([InOut] int* NumViewports,[Out, Buffer, Optional] D3D10_VIEWPORT* pViewports)
Get the array of {{viewports}} bound to the {{rasterizer stage}}
An array of viewports (see ).
void RSGetViewports([InOut] int* NumViewports,[Out, Buffer, Optional] D3D10_VIEWPORT* pViewports)
Get the array of {{scissor rectangles}} bound to the {{rasterizer stage}}.
An array of scissor rectangles (see ).
void RSGetScissorRects([InOut] int* NumRects,[Out, Buffer, Optional] D3D10_RECT* pRects)
Get the array of {{scissor rectangles}} bound to the {{rasterizer stage}}.
An array of scissor rectangles (see ).
void RSGetScissorRects([InOut] int* NumRects,[Out, Buffer, Optional] D3D10_RECT* pRects)
Binds a single scissor rectangle to the rasterizer stage.
The left.
The top.
The right.
The bottom.
Binds a set of scissor rectangles to the rasterizer stage.
The set of scissor rectangles to bind.
Binds a single viewport to the rasterizer stage.
The x coord of the viewport.
The x coord of the viewport.
The width.
The height.
The min Z.
The max Z.
Binds a single viewport to the rasterizer stage.
The viewport.
Binds a set of viewports to the rasterizer stage.
The set of viewports to bind.
Initializes a new instance of the class.
The native pointer.
Set the rasterizer state for the rasterizer stage of the pipeline.
No documentation.
To create a rasterizer state interface, call .The method will hold a reference to the interfaces passed in. This differs from the device state behavior in Direct3D 10.
void ID3D11DeviceContext::RSSetState([In, Optional] ID3D11RasterizerState* pRasterizerState)
Bind an array of viewports to the rasterizer stage of the pipeline.
Number of viewports to bind.
An array of 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.
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.
void ID3D11DeviceContext::RSSetViewports([In] unsigned int NumViewports,[In, Buffer, Optional] const void* pViewports)
Bind an array of scissor rectangles to the rasterizer stage.
Number of scissor rectangles to bind.
An array of scissor rectangles (see D3D11_RECT).
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 ).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 ).
void ID3D11DeviceContext::RSSetScissorRects([In] unsigned int NumRects,[In, Buffer, Optional] const void* pRects)
Get the rasterizer state from the rasterizer stage of the pipeline.
No documentation.
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.
void ID3D11DeviceContext::RSGetState([Out] ID3D11RasterizerState** ppRasterizerState)
Get the array of viewports bound to the rasterizer stage
The input specifies the number of viewports (ranges from 0 to D3D11_VIEWPORT_AND_SCISSORRECT_OBJECT_COUNT_PER_PIPELINE) in pViewports, the output contains the actual number of viewports returned. If pViewports is null, this will be filled with the number of viewports currently bound.
An array of structures that are bound to the device. If the number of viewports (in pNumViewports) is greater than the actual number of viewports currently bound, then unused members of the array will contain 0. 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.
void ID3D11DeviceContext::RSGetViewports([InOut] unsigned int* pNumViewports,[Out, Buffer, Optional] D3D11_VIEWPORT* pViewports)
Get the array of scissor rectangles bound to the rasterizer stage.
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.
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.
void ID3D11DeviceContext::RSGetScissorRects([InOut] unsigned int* pNumRects,[Out, Buffer, Optional] RECT* pRects)
Get the rasterizer state from the rasterizer stage of the pipeline.
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.
RSGetState
void ID3D11DeviceContext::RSGetState([Out] ID3D11RasterizerState** ppRasterizerState)
A domain-shader interface manages an executable program (a domain shader) that controls the domain-shader stage.
ID3D11DomainShader
Initializes a new instance of the class.
The device used to create the shader.
The compiled shader bytecode.
Initializes a new instance of the class.
The device used to create the shader.
The compiled shader bytecode.
A dynamic class linkage interface.
Initializes a new instance of the class.
The native pointer.
Optional flags that control the behavior of .
D3D11_ASYNC_GETDATA_FLAG
No documentation.
D3D11_ASYNC_GETDATA_DONOTFLUSH
None.
None
No documentation.
D3D11_AUTHENTICATED_CHANNEL_TYPE
No documentation.
D3D11_AUTHENTICATED_CHANNEL_D3D11
No documentation.
D3D11_AUTHENTICATED_CHANNEL_DRIVER_SOFTWARE
No documentation.
D3D11_AUTHENTICATED_CHANNEL_DRIVER_HARDWARE
[This documentation is preliminary and is subject to change.]
D3D11_AUTHENTICATED_PROCESS_IDENTIFIER_TYPE
No documentation.
D3D11_PROCESSIDTYPE_UNKNOWN
No documentation.
D3D11_PROCESSIDTYPE_DWM
No documentation.
D3D11_PROCESSIDTYPE_HANDLE
Identifies how to bind a resource to the pipeline.
In general, binding flags can be combined using a logical OR (except the constant-buffer flag); however, you should use a single flag to allow the device to optimize the resource usage.This enumeration is used by a:Buffer description when creating a buffer. Texture description when creating a texture (see or or ).A shader-resource buffer is NOT a constant buffer; rather, it is a texture or buffer resource that is bound to a shader, that contains texture or buffer data (it is not limited to a single element type in the buffer). A shader-resource buffer is created with the flag and is bound to the pipeline using one of these APIs: , , or . Furthermore, a shader-resource buffer cannot use the flag.
D3D11_BIND_FLAG
Bind a buffer as a vertex buffer to the input-assembler stage.
D3D11_BIND_VERTEX_BUFFER
Bind a buffer as an index buffer to the input-assembler stage.
D3D11_BIND_INDEX_BUFFER
Bind a buffer as a constant buffer to a shader stage; this flag may NOT be combined with any other bind flag.
D3D11_BIND_CONSTANT_BUFFER
Bind a buffer or texture to a shader stage; this flag cannot be used with the flag.
D3D11_BIND_SHADER_RESOURCE
Bind an output buffer for the stream-output stage.
D3D11_BIND_STREAM_OUTPUT
Bind a texture as a render target for the output-merger stage.
D3D11_BIND_RENDER_TARGET
Bind a texture as a depth-stencil target for the output-merger stage.
D3D11_BIND_DEPTH_STENCIL
Bind an unordered access resource.
D3D11_BIND_UNORDERED_ACCESS
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 method to create an array of 2D textures. However, you cannot use texture arrays that are created with this flag in calls to .
Direct 3D 11:??This value is not supported until Direct3D 11.1.
D3D11_BIND_DECODER
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 method to create an array of 2D textures. However, you cannot use texture arrays that are created with this flag in calls to .
Direct 3D 11:??This value is not supported until Direct3D 11.1.
D3D11_BIND_VIDEO_ENCODER
None.
None
RGB or alpha blending operation.
The runtime implements RGB blending and alpha blending separately. Therefore, blend state requires separate blend operations for RGB data and alpha data. These blend operations are specified in a blend description. The two sources?Source 1, called SrcBlend and SrcBlendAlpha, and Source 2, called DestBlend and DestBlendAlpha?are shown in the blending block diagram.
D3D11_BLEND_OP
Add source 1 and source 2.
D3D11_BLEND_OP_ADD
Subtract source 1 from source 2.
D3D11_BLEND_OP_SUBTRACT
Subtract source 2 from source 1.
D3D11_BLEND_OP_REV_SUBTRACT
Find the minimum of source 1 and source 2.
D3D11_BLEND_OP_MIN
Find the maximum of source 1 and source 2.
D3D11_BLEND_OP_MAX
Describes the blend state that you use in a call to to create a blend-state object.
Here are the default values for blend state.StateDefault Value AlphaToCoverageEnableFALSE IndependentBlendEnableFALSE RenderTarget[0].BlendEnableFALSE RenderTarget[0].SrcBlendD3D11_BLEND_ONE RenderTarget[0].DestBlendD3D11_BLEND_ZERO RenderTarget[0].BlendOpD3D11_BLEND_OP_ADD RenderTarget[0].SrcBlendAlphaD3D11_BLEND_ONE RenderTarget[0].DestBlendAlphaD3D11_BLEND_ZERO RenderTarget[0].BlendOpAlphaD3D11_BLEND_OP_ADD RenderTarget[0].RenderTargetWriteMaskD3D11_COLOR_WRITE_ENABLE_ALL?Note?? is identical to .If the driver type is set to , the feature level is set to less than or equal to , and the pixel format of the render target is set to , , or , the display device performs the blend in standard RGB (sRGB) space and not in linear space. However, if the feature level is set to greater than , the display device performs the blend in linear space, which is ideal.
D3D11_BLEND
No documentation.
D3D11_BLEND_ZERO
No documentation.
D3D11_BLEND_ONE
No documentation.
D3D11_BLEND_SRC_COLOR
No documentation.
D3D11_BLEND_INV_SRC_COLOR
No documentation.
D3D11_BLEND_SRC_ALPHA
No documentation.
D3D11_BLEND_INV_SRC_ALPHA
No documentation.
D3D11_BLEND_DEST_ALPHA
No documentation.
D3D11_BLEND_INV_DEST_ALPHA
No documentation.
D3D11_BLEND_DEST_COLOR
No documentation.
D3D11_BLEND_INV_DEST_COLOR
No documentation.
D3D11_BLEND_SRC_ALPHA_SAT
No documentation.
D3D11_BLEND_BLEND_FACTOR
No documentation.
D3D11_BLEND_INV_BLEND_FACTOR
No documentation.
D3D11_BLEND_SRC1_COLOR
No documentation.
D3D11_BLEND_INV_SRC1_COLOR
No documentation.
D3D11_BLEND_SRC1_ALPHA
No documentation.
D3D11_BLEND_INV_SRC1_ALPHA
[This documentation is preliminary and is subject to change.]
D3D11_BUS_TYPE
Indicates a type of bus other than the types listed here.
D3D11_BUS_TYPE_OTHER
PCI bus.
D3D11_BUS_TYPE_PCI
PCI-X bus.
D3D11_BUS_TYPE_PCIX
PCI Express bus.
D3D11_BUS_TYPE_PCIEXPRESS
Accelerated Graphics Port (AGP) bus.
D3D11_BUS_TYPE_AGP
The implementation for the graphics adapter is in a motherboard chipset's north bridge. This flag implies that data never goes over an expansion bus (such as PCI or AGP) when it is transferred from main memory to the graphics adapter.
D3D11_BUS_IMPL_MODIFIER_INSIDE_OF_CHIPSET
Indicates that the graphics adapter is connected to a motherboard chipset's north bridge by tracks on the motherboard, and all of the graphics adapter's chips are soldered to the motherboard. This flag implies that data never goes over an expansion bus (such as PCI or AGP) when it is transferred from main memory to the graphics adapter.
D3D11_BUS_IMPL_MODIFIER_TRACKS_ON_MOTHER_BOARD_TO_CHIP
The graphics adapter is connected to a motherboard chipset's north bridge by tracks on the motherboard, and all of the graphics adapter's chips are connected through sockets to the motherboard.
D3D11_BUS_IMPL_MODIFIER_TRACKS_ON_MOTHER_BOARD_TO_SOCKET
The graphics adapter is connected to the motherboard through a daughterboard connector.
D3D11_BUS_IMPL_MODIFIER_DAUGHTER_BOARD_CONNECTOR
The graphics adapter is connected to the motherboard through a daughterboard connector, and the graphics adapter is inside an enclosure that is not user accessible.
D3D11_BUS_IMPL_MODIFIER_DAUGHTER_BOARD_CONNECTOR_INSIDE_OF_NUAE
One of the D3D11_BUS_IMPL_MODIFIER_Xxx flags is set.
D3D11_BUS_IMPL_MODIFIER_NON_STANDARD
Identify which components of each pixel of a render target are writable during blending.
These flags can be combined with a bitwise OR.
D3D11_COLOR_WRITE_ENABLE
Allow data to be stored in the red component.
D3D11_COLOR_WRITE_ENABLE_RED
Allow data to be stored in the green component.
D3D11_COLOR_WRITE_ENABLE_GREEN
Allow data to be stored in the blue component.
D3D11_COLOR_WRITE_ENABLE_BLUE
Allow data to be stored in the alpha component.
D3D11_COLOR_WRITE_ENABLE_ALPHA
Allow data to be stored in all components.
D3D11_COLOR_WRITE_ENABLE_ALL
Comparison options.
A comparison option determines whether how the runtime compares source (new) data against destination (existing) data before storing the new data. The comparison option is declared in a description before an object is created. The API allows you to set a comparison option for a depth-stencil buffer (see ), depth-stencil operations (see ), or sampler state (see ).
D3D11_COMPARISON_FUNC
Never pass the comparison.
D3D11_COMPARISON_NEVER
If the source data is less than the destination data, the comparison passes.
D3D11_COMPARISON_LESS
If the source data is equal to the destination data, the comparison passes.
D3D11_COMPARISON_EQUAL
If the source data is less than or equal to the destination data, the comparison passes.
D3D11_COMPARISON_LESS_EQUAL
If the source data is greater than the destination data, the comparison passes.
D3D11_COMPARISON_GREATER
If the source data is not equal to the destination data, the comparison passes.
D3D11_COMPARISON_NOT_EQUAL
If the source data is greater than or equal to the destination data, the comparison passes.
D3D11_COMPARISON_GREATER_EQUAL
Always pass the comparison.
D3D11_COMPARISON_ALWAYS
Unordered resource support options for a compute shader resource (see ).
D3D11_FORMAT_SUPPORT2
No documentation.
D3D11_FORMAT_SUPPORT2_UAV_ATOMIC_ADD
No documentation.
D3D11_FORMAT_SUPPORT2_UAV_ATOMIC_BITWISE_OPS
No documentation.
D3D11_FORMAT_SUPPORT2_UAV_ATOMIC_COMPARE_STORE_OR_COMPARE_EXCHANGE
No documentation.
D3D11_FORMAT_SUPPORT2_UAV_ATOMIC_EXCHANGE
No documentation.
D3D11_FORMAT_SUPPORT2_UAV_ATOMIC_SIGNED_MIN_OR_MAX
No documentation.
D3D11_FORMAT_SUPPORT2_UAV_ATOMIC_UNSIGNED_MIN_OR_MAX
No documentation.
D3D11_FORMAT_SUPPORT2_UAV_TYPED_LOAD
No documentation.
D3D11_FORMAT_SUPPORT2_UAV_TYPED_STORE
No documentation.
D3D11_FORMAT_SUPPORT2_OUTPUT_MERGER_LOGIC_OP
None.
None
No documentation.
D3D11_CONTENT_PROTECTION_CAPS
No documentation.
D3D11_CONTENT_PROTECTION_CAPS_SOFTWARE
No documentation.
D3D11_CONTENT_PROTECTION_CAPS_HARDWARE
No documentation.
D3D11_CONTENT_PROTECTION_CAPS_PROTECTION_ALWAYS_ON
No documentation.
D3D11_CONTENT_PROTECTION_CAPS_PARTIAL_DECRYPTION
No documentation.
D3D11_CONTENT_PROTECTION_CAPS_CONTENT_KEY
No documentation.
D3D11_CONTENT_PROTECTION_CAPS_FRESHEN_SESSION_KEY
No documentation.
D3D11_CONTENT_PROTECTION_CAPS_ENCRYPTED_READ_BACK
No documentation.
D3D11_CONTENT_PROTECTION_CAPS_ENCRYPTED_READ_BACK_KEY
No documentation.
D3D11_CONTENT_PROTECTION_CAPS_SEQUENTIAL_CTR_IV
No documentation.
D3D11_CONTENT_PROTECTION_CAPS_ENCRYPT_SLICEDATA_ONLY
No documentation.
D3D11_CONTENT_PROTECTION_CAPS_DECRYPTION_BLT
[This documentation is preliminary and is subject to change.]
D3D11_COPY_FLAGS
The existing contents of the resource cannot be overwritten.
D3D11_COPY_NO_OVERWRITE
The existing contents of the resource are undefined and can be discarded.
D3D11_COPY_DISCARD
None.
None
Describes a counter.
This structure is used by , and .
D3D11_COUNTER
Type of counter (see ).
D3D11_COUNTER_DEVICE_DEPENDENT_0
Data type of a performance counter.
These flags are an output parameter in .
D3D11_COUNTER_TYPE
32-bit floating point.
D3D11_COUNTER_TYPE_FLOAT32
16-bit unsigned integer.
D3D11_COUNTER_TYPE_UINT16
32-bit unsigned integer.
D3D11_COUNTER_TYPE_UINT32
64-bit unsigned integer.
D3D11_COUNTER_TYPE_UINT64
Specifies the types of CPU access allowed for a resource.
This enumeration is used in , , , .Applications may combine one or more of these flags with a logical OR. When possible, create resources with no CPU access flags, as this enables better resource optimiztion.
D3D11_CPU_ACCESS_FLAG
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_CPU_ACCESS_WRITE
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_CPU_ACCESS_READ
None.
None
[This documentation is preliminary and is subject to change.]
D3D11_1_CREATE_DEVICE_CONTEXT_STATE_FLAG
No documentation.
D3D11_1_CREATE_DEVICE_CONTEXT_STATE_SINGLETHREADED
None.
None
Indicates triangles facing a particular direction are not drawn.
This enumeration is part of a rasterizer-state object description (see ).
D3D11_CULL_MODE
Always draw all triangles.
D3D11_CULL_NONE
Do not draw triangles that are front-facing.
D3D11_CULL_FRONT
Do not draw triangles that are back-facing.
D3D11_CULL_BACK
No documentation.
D3D11_DEBUG_FEATURE_FLAGS
Specifies the parts of the depth stencil to clear.
These flags are used when calling ; the flags can be combined with a bitwise OR.
D3D11_CLEAR_FLAG
Clear the depth buffer.
D3D11_CLEAR_DEPTH
Clear the stencil buffer.
D3D11_CLEAR_STENCIL
Specifies how to access a resource used in a depth-stencil view.
This enumeration is used in to create a depth-stencil view.
D3D11_DSV_DIMENSION
is not a valid value for and is not used.
D3D11_DSV_DIMENSION_UNKNOWN
The resource will be accessed as a 1D texture.
D3D11_DSV_DIMENSION_TEXTURE1D
The resource will be accessed as an array of 1D textures.
D3D11_DSV_DIMENSION_TEXTURE1DARRAY
The resource will be accessed as a 2D texture.
D3D11_DSV_DIMENSION_TEXTURE2D
The resource will be accessed as an array of 2D textures.
D3D11_DSV_DIMENSION_TEXTURE2DARRAY
The resource will be accessed as a 2D texture with multisampling.
D3D11_DSV_DIMENSION_TEXTURE2DMS
The resource will be accessed as an array of 2D textures with multisampling.
D3D11_DSV_DIMENSION_TEXTURE2DMSARRAY
Depth-stencil view options.
This enumeration is used by .Limiting a depth-stencil buffer to read-only access allows more than one depth-stencil view to be bound to the pipeline simultaneously, since it is not possible to have a read/write conflicts between separate views.
D3D11_DSV_FLAG
Indicates that depth values are read only.
D3D11_DSV_READ_ONLY_DEPTH
Indicates that stencil values are read only.
D3D11_DSV_READ_ONLY_STENCIL
None.
None
Identify the portion of a depth-stencil buffer for writing depth data.
D3D11_DEPTH_WRITE_MASK
Turn off writes to the depth-stencil buffer.
D3D11_DEPTH_WRITE_MASK_ZERO
Turn on writes to the depth-stencil buffer.
D3D11_DEPTH_WRITE_MASK_ALL
Device context options.
This enumeration is used by .
D3D11_DEVICE_CONTEXT_TYPE
The device context is an immediate context.
D3D11_DEVICE_CONTEXT_IMMEDIATE
The device context is a deferred context.
D3D11_DEVICE_CONTEXT_DEFERRED
Describes parameters that are used to create a device.
Device creation flags are used by and .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 to request that the runtime and video driver not create any additional threads that might interfere with the application.
D3D11_CREATE_DEVICE_FLAG
You should use this flag if your application will only call methods of Direct3D?11 interfaces from a single thread. By default, the 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.
D3D11_CREATE_DEVICE_SINGLETHREADED
Creates a device that supports the debug layer.
D3D11_CREATE_DEVICE_DEBUG
Note??This flag is not supported in Direct3D?11.
D3D11_CREATE_DEVICE_SWITCH_TO_REF
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.
D3D11_CREATE_DEVICE_PREVENT_INTERNAL_THREADING_OPTIMIZATIONS
Required for Direct2D interoperability with Direct3D resources.
D3D11_CREATE_DEVICE_BGRA_SUPPORT
TBD
Direct 3D 11:??This value is not supported until Direct3D 11.1.
D3D11_CREATE_DEVICE_DEBUGGABLE
TBD
Direct 3D 11:??This value is not supported until Direct3D 11.1.
D3D11_CREATE_DEVICE_PREVENT_ALTERING_LAYER_SETTINGS_FROM_REGISTRY
TBD
Direct 3D 11:??This value is not supported until Direct3D 11.1.
D3D11_CREATE_DEVICE_DISABLE_GPU_TIMEOUT
Forces the creation of the Direct3D device to fail if the display driver is not implemented to the WDDM for Windows Developer Preview (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 , , or , 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 , device creation succeeds to allow software fallback for video.
Direct 3D 11:??This value is not supported until Direct3D 11.1.
D3D11_CREATE_DEVICE_VIDEO_SUPPORT
None.
None
No documentation.
D3DX11_EFFECT_VARIABLE_FLAGS
None.
None
Direct3D 11 feature options.
This enumeration is used when querying a driver about support for these features by calling . Each value in this enumeration has a corresponding data structure that is required to be passed to the pFeatureSupportData parameter of .The following table shows the structures associated with each enumerant.EnumerantAssociated Structure ?
D3D11_FEATURE
The driver supports multithreading. To see an example of testing a driver for multithread support, see How To: Check for Driver Support.
D3D11_FEATURE_THREADING
Supports the use of the double-precision shaders in HLSL.
D3D11_FEATURE_DOUBLES
Supports the formats in .
D3D11_FEATURE_FORMAT_SUPPORT
Supports the formats in .
D3D11_FEATURE_FORMAT_SUPPORT2
Supports compute shaders and raw and structured buffers.
D3D11_FEATURE_D3D10_X_HARDWARE_OPTIONS
Supports Direct3D 11.1 feature options.
Direct3D 11:??This value is not supported until Direct3D 11.1.
D3D11_FEATURE_D3D11_OPTIONS
Supports specific adapter architecture.
Direct3D 11:??This value is not supported until Direct3D 11.1.
D3D11_FEATURE_ARCHITECTURE_INFO
Supports Direct3D?9 feature options.
Direct3D 11:??This value is not supported until Direct3D 11.1.
D3D11_FEATURE_D3D9_OPTIONS
Supports minimum precision of shaders.
Direct3D 11:??This value is not supported until Direct3D 11.1.
D3D11_FEATURE_SHADER_MIN_PRECISION_SUPPORT
Determines the fill mode to use when rendering triangles.
This enumeration is part of a rasterizer-state object description (see ).
D3D11_FILL_MODE
Draw lines connecting the vertices. Adjacent vertices are not drawn.
D3D11_FILL_WIREFRAME
Fill the triangles formed by the vertices. Adjacent vertices are not drawn.
D3D11_FILL_SOLID
Types of magnification or minification sampler filters.
D3D11_FILTER
Point filtering used as a texture magnification or minification filter. The texel with coordinates nearest to the desired pixel value is used. The texture filter to be used between mipmap levels is nearest-point mipmap filtering. The rasterizer uses the color from the texel of the nearest mipmap texture.
D3D11_FILTER_MIN_MAG_MIP_POINT
Bilinear interpolation filtering used as a texture magnification or minification filter. A weighted average of a 2 x 2 area of texels surrounding the desired pixel is used. The texture filter to use between mipmap levels is trilinear mipmap interpolation. The rasterizer linearly interpolates pixel color, using the texels of the two nearest mipmap textures.
D3D11_FILTER_MIN_MAG_POINT_MIP_LINEAR
No documentation.
D3D11_FILTER_MIN_POINT_MAG_LINEAR_MIP_POINT
No documentation.
D3D11_FILTER_MIN_POINT_MAG_MIP_LINEAR
No documentation.
D3D11_FILTER_MIN_LINEAR_MAG_MIP_POINT
No documentation.
D3D11_FILTER_MIN_LINEAR_MAG_POINT_MIP_LINEAR
No documentation.
D3D11_FILTER_MIN_MAG_LINEAR_MIP_POINT
No documentation.
D3D11_FILTER_MIN_MAG_MIP_LINEAR
No documentation.
D3D11_FILTER_ANISOTROPIC
No documentation.
D3D11_FILTER_COMPARISON_MIN_MAG_MIP_POINT
No documentation.
D3D11_FILTER_COMPARISON_MIN_MAG_POINT_MIP_LINEAR
No documentation.
D3D11_FILTER_COMPARISON_MIN_POINT_MAG_LINEAR_MIP_POINT
No documentation.
D3D11_FILTER_COMPARISON_MIN_POINT_MAG_MIP_LINEAR
No documentation.
D3D11_FILTER_COMPARISON_MIN_LINEAR_MAG_MIP_POINT
No documentation.
D3D11_FILTER_COMPARISON_MIN_LINEAR_MAG_POINT_MIP_LINEAR
No documentation.
D3D11_FILTER_COMPARISON_MIN_MAG_LINEAR_MIP_POINT
No documentation.
D3D11_FILTER_COMPARISON_MIN_MAG_MIP_LINEAR
No documentation.
D3D11_FILTER_COMPARISON_ANISOTROPIC
Types of magnification or minification sampler filters.
D3D11_FILTER_TYPE
Point filtering used as a texture magnification or minification filter. The texel with coordinates nearest to the desired pixel value is used. The texture filter to be used between mipmap levels is nearest-point mipmap filtering. The rasterizer uses the color from the texel of the nearest mipmap texture.
D3D11_FILTER_TYPE_POINT
Bilinear interpolation filtering used as a texture magnification or minification filter. A weighted average of a 2 x 2 area of texels surrounding the desired pixel is used. The texture filter to use between mipmap levels is trilinear mipmap interpolation. The rasterizer linearly interpolates pixel color, using the texels of the two nearest mipmap textures.
D3D11_FILTER_TYPE_LINEAR
Which resources are supported for a given format and given device (see and ).
D3D11_FORMAT_SUPPORT
No documentation.
D3D11_FORMAT_SUPPORT_BUFFER
No documentation.
D3D11_FORMAT_SUPPORT_IA_VERTEX_BUFFER
No documentation.
D3D11_FORMAT_SUPPORT_IA_INDEX_BUFFER
No documentation.
D3D11_FORMAT_SUPPORT_SO_BUFFER
No documentation.
D3D11_FORMAT_SUPPORT_TEXTURE1D
No documentation.
D3D11_FORMAT_SUPPORT_TEXTURE2D
No documentation.
D3D11_FORMAT_SUPPORT_TEXTURE3D
No documentation.
D3D11_FORMAT_SUPPORT_TEXTURECUBE
No documentation.
D3D11_FORMAT_SUPPORT_SHADER_LOAD
No documentation.
D3D11_FORMAT_SUPPORT_SHADER_SAMPLE
No documentation.
D3D11_FORMAT_SUPPORT_SHADER_SAMPLE_COMPARISON
No documentation.
D3D11_FORMAT_SUPPORT_SHADER_SAMPLE_MONO_TEXT
No documentation.
D3D11_FORMAT_SUPPORT_MIP
No documentation.
D3D11_FORMAT_SUPPORT_MIP_AUTOGEN
No documentation.
D3D11_FORMAT_SUPPORT_RENDER_TARGET
No documentation.
D3D11_FORMAT_SUPPORT_BLENDABLE
No documentation.
D3D11_FORMAT_SUPPORT_DEPTH_STENCIL
No documentation.
D3D11_FORMAT_SUPPORT_CPU_LOCKABLE
No documentation.
D3D11_FORMAT_SUPPORT_MULTISAMPLE_RESOLVE
No documentation.
D3D11_FORMAT_SUPPORT_DISPLAY
No documentation.
D3D11_FORMAT_SUPPORT_CAST_WITHIN_BIT_LAYOUT
No documentation.
D3D11_FORMAT_SUPPORT_MULTISAMPLE_RENDERTARGET
No documentation.
D3D11_FORMAT_SUPPORT_MULTISAMPLE_LOAD
No documentation.
D3D11_FORMAT_SUPPORT_SHADER_GATHER
No documentation.
D3D11_FORMAT_SUPPORT_BACK_BUFFER_CAST
No documentation.
D3D11_FORMAT_SUPPORT_TYPED_UNORDERED_ACCESS_VIEW
No documentation.
D3D11_FORMAT_SUPPORT_SHADER_GATHER_COMPARISON
No documentation.
D3D11_FORMAT_SUPPORT_DECODER_OUTPUT
No documentation.
D3D11_FORMAT_SUPPORT_VIDEO_PROCESSOR_OUTPUT
No documentation.
D3D11_FORMAT_SUPPORT_VIDEO_PROCESSOR_INPUT
No documentation.
D3D11_FORMAT_SUPPORT_VIDEO_ENCODER
None.
None
Type of data contained in an input slot.
Use these values to specify the type of data for a particular input element (see ) of an input-layout object.
D3D11_INPUT_CLASSIFICATION
Input data is per-vertex data.
D3D11_INPUT_PER_VERTEX_DATA
Input data is per-instance data.
D3D11_INPUT_PER_INSTANCE_DATA
[This documentation is preliminary and is subject to change.]
D3D11_LOGIC_OP
Clears the render target.
D3D11_LOGIC_OP_CLEAR
Sets the render target.
D3D11_LOGIC_OP_SET
Copys the render target.
D3D11_LOGIC_OP_COPY
Performs an inverted-copy of the render target.
D3D11_LOGIC_OP_COPY_INVERTED
No operation is performed on the render target.
D3D11_LOGIC_OP_NOOP
Inverts the render target.
D3D11_LOGIC_OP_INVERT
Performs a logical AND operation on the render target.
D3D11_LOGIC_OP_AND
Performs a logical NAND operation on the render target.
D3D11_LOGIC_OP_NAND
Performs a logical OR operation on the render target.
D3D11_LOGIC_OP_OR
Performs a logical NOR operation on the render target.
D3D11_LOGIC_OP_NOR
Performs a logical XOR operation on the render target.
D3D11_LOGIC_OP_XOR
Performs a logical equal operation on the render target.
D3D11_LOGIC_OP_EQUIV
Performs a logical AND and reverse operation on the render target.
D3D11_LOGIC_OP_AND_REVERSE
Performs a logical AND and invert operation on the render target.
D3D11_LOGIC_OP_AND_INVERTED
Performs a logical OR and reverse operation on the render target.
D3D11_LOGIC_OP_OR_REVERSE
Performs a logical OR and invert operation on the render target.
D3D11_LOGIC_OP_OR_INVERTED
Specifies how the CPU should respond when an application calls the method on a resource that is being used by the GPU.
This enumeration is used by .D3D11_MAP_FLAG_DO_NOT_WAIT cannot be used with or D3D11_MAP_WRITE_NOOVERWRITE.
D3D11_MAP_FLAG
No documentation.
D3D11_MAP_FLAG_DO_NOT_WAIT
None.
None
Identifies a resource to be accessed for reading and writing by the CPU. Applications may combine one or more of these flags.
This enumeration is used in .These remarks are divided into the following topics:Meaning CommonMeaning of 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.However, ensuring this can be difficult, because the GPU is often many frames behind the CPU in terms of which frame it is currently processing. Keeping track of which sections of a resource are being used because of calls made 2 to 5 frames ago is difficult and error-prone. Because of this, it is recommended that applications only write to the uninitialized portions of a resource when using .Common Usage of with D3D11_MAP_WRITE_DISCARD and are normally used in conjunction with dynamic index/vertex buffers. can also be used with dynamic textures. However, cannot be used with dynamic textures.A common use of these two flags involves filling dynamic index/vertex buffers with geometry that can be seen from the camera's current position. The first time that data is entered into the buffer on a given frame, Map is called with ; doing so invalidates the previous contents of the buffer. The buffer is then filled with all available data.Subsequent writes to the buffer within the same frame should use . This will enable the CPU to access a resource that is potentially being used by the GPU as long as the restrictions described previously are respected.
D3D11_MAP
Resource is mapped for reading. The resource must have been created with read access (see ).
D3D11_MAP_READ
Resource is mapped for writing. The resource must have been created with write access (see ).
D3D11_MAP_WRITE
Resource is mapped for reading and writing. The resource must have been created with read and write access (see and ).
D3D11_MAP_READ_WRITE
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 and ).
D3D11_MAP_WRITE_DISCARD
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 ). Cannot be used on a resource created with the flag.
D3D11_MAP_WRITE_NO_OVERWRITE
Flags that describe miscellaneous query behavior.
This flag is part of a query description (see ).
D3D11_QUERY_MISC_FLAG
Tell the hardware that if it is not yet sure if something is hidden or not to draw it anyway. This is only used with an occlusion predicate. Predication data cannot be returned to your application via when using this flag.
D3D11_QUERY_MISC_PREDICATEHINT
None.
None
Query types.
Create a query with .
D3D11_QUERY
Determines whether or not the GPU is finished processing commands. When the GPU is finished processing commands will return , and pData will point to a with a value of TRUE. When using this type of query, is disabled.
D3D11_QUERY_EVENT
Get the number of samples that passed the depth and stencil tests in between and . returns a UINT64. If a depth or stencil test is disabled, then each of those tests will be counted as a pass.
D3D11_QUERY_OCCLUSION
Get a timestamp value where returns a UINT64. This kind of query is only useful if two timestamp queries are done in the middle of a query. The difference of two timestamps can be used to determine how many ticks have elapsed, and the 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 . When using this type of query, is disabled.
D3D11_QUERY_TIMESTAMP
Determines whether or not a is returning reliable values, and also gives the frequency of the processor enabling you to convert the number of elapsed ticks into seconds. will return a . This type of query should only be invoked once per frame or less.
D3D11_QUERY_TIMESTAMP_DISJOINT
Get pipeline statistics, such as the number of pixel shader invocations in between and . will return a .
D3D11_QUERY_PIPELINE_STATISTICS
Similar to , except returns a indicating whether or not any samples passed the depth and stencil tests - TRUE meaning at least one passed, meaning none passed.
D3D11_QUERY_OCCLUSION_PREDICATE
Get streaming output statistics, such as the number of primitives streamed out in between and . will return a structure.
D3D11_QUERY_SO_STATISTICS
Determines whether or not any of the streaming output buffers overflowed in between and . returns a - TRUE meaning there was an overflow, 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.
D3D11_QUERY_SO_OVERFLOW_PREDICATE
Get streaming output statistics for stream 0, such as the number of primitives streamed out in between and . will return a structure.
D3D11_QUERY_SO_STATISTICS_STREAM0
Determines whether or not the stream 0 output buffers overflowed in between and . returns a - TRUE meaning there was an overflow, 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.
D3D11_QUERY_SO_OVERFLOW_PREDICATE_STREAM0
Get streaming output statistics for stream 1, such as the number of primitives streamed out in between and . will return a structure.
D3D11_QUERY_SO_STATISTICS_STREAM1
Determines whether or not the stream 1 output buffers overflowed in between and . returns a - TRUE meaning there was an overflow, 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.
D3D11_QUERY_SO_OVERFLOW_PREDICATE_STREAM1
Get streaming output statistics for stream 2, such as the number of primitives streamed out in between and . will return a structure.
D3D11_QUERY_SO_STATISTICS_STREAM2
Determines whether or not the stream 2 output buffers overflowed in between and . returns a - TRUE meaning there was an overflow, 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.
D3D11_QUERY_SO_OVERFLOW_PREDICATE_STREAM2
Get streaming output statistics for stream 3, such as the number of primitives streamed out in between and . will return a structure.
D3D11_QUERY_SO_STATISTICS_STREAM3
Determines whether or not the stream 3 output buffers overflowed in between and . returns a - TRUE meaning there was an overflow, 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.
D3D11_QUERY_SO_OVERFLOW_PREDICATE_STREAM3
These flags identify the type of resource that will be viewed as a render target.
This enumeration is used in to create a render-target view.
D3D11_RTV_DIMENSION
Do not use this value, as it will cause to fail.
D3D11_RTV_DIMENSION_UNKNOWN
The resource will be accessed as a buffer.
D3D11_RTV_DIMENSION_BUFFER
The resource will be accessed as a 1D texture.
D3D11_RTV_DIMENSION_TEXTURE1D
The resource will be accessed as an array of 1D textures.
D3D11_RTV_DIMENSION_TEXTURE1DARRAY
The resource will be accessed as a 2D texture.
D3D11_RTV_DIMENSION_TEXTURE2D
The resource will be accessed as an array of 2D textures.
D3D11_RTV_DIMENSION_TEXTURE2DARRAY
The resource will be accessed as a 2D texture with multisampling.
D3D11_RTV_DIMENSION_TEXTURE2DMS
The resource will be accessed as an array of 2D textures with multisampling.
D3D11_RTV_DIMENSION_TEXTURE2DMSARRAY
The resource will be accessed as a 3D texture.
D3D11_RTV_DIMENSION_TEXTURE3D
Identifies the type of resource being used.
This enumeration is used in .
D3D11_RESOURCE_DIMENSION
Resource is of unknown type.
D3D11_RESOURCE_DIMENSION_UNKNOWN
Resource is a buffer.
D3D11_RESOURCE_DIMENSION_BUFFER
Resource is a 1D texture.
D3D11_RESOURCE_DIMENSION_TEXTURE1D
Resource is a 2D texture.
D3D11_RESOURCE_DIMENSION_TEXTURE2D
Resource is a 3D texture.
D3D11_RESOURCE_DIMENSION_TEXTURE3D
Identifies options for resources.
This enumeration is used in , , , .These flags can be combined by bitwise OR.
D3D11_RESOURCE_MISC_FLAG
Enables MIP map generation by using 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.
D3D11_RESOURCE_MISC_GENERATE_MIPS
Enables resource data sharing between two or more Direct3D devices. The only resources that can be shared are 2D non-mipmapped textures.
and 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.
D3D11_RESOURCE_MISC_SHARED
Sets a resource to be a cube texture created from a Texture2DArray that contains 6 textures.
D3D11_RESOURCE_MISC_TEXTURECUBE
Enables instancing of GPU-generated content.
D3D11_RESOURCE_MISC_DRAWINDIRECT_ARGS
Enables a resource as a byte address buffer.
D3D11_RESOURCE_MISC_BUFFER_ALLOW_RAW_VIEWS
Enables a resource as a structured buffer.
D3D11_RESOURCE_MISC_BUFFER_STRUCTURED
Enables a resource with MIP map clamping for use with .
D3D11_RESOURCE_MISC_RESOURCE_CLAMP
Enables the resource to be synchronized by using the and APIs. The following Direct3D?11 resource creation APIs, that take parameters, have been extended to support the new flag.
If you call any of these methods with the flag set, the interface returned will support the interface. You can retrieve a reference to the interface from the resource by using IUnknown::QueryInterface. The interface implements the and APIs to synchronize access to the surface. The device that creates the surface, and any other device that opens the surface by using OpenSharedResource, must call before they issue any rendering commands to the surface. When those devices finish rendering, they must call .
and 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.
D3D11_RESOURCE_MISC_SHARED_KEYEDMUTEX
Enables a resource compatible with GDI. You must set the flag on surfaces that you use with GDI. Setting the flag allows GDI rendering on the surface via .
Consider the following programming tips for using when you create a texture or use that texture in a swap chain:
and are mutually exclusive. Therefore, do not use them together. and are mutually exclusive. Therefore, do not use them together. You must bind the texture as a render target for the output-merger stage. For example, set the flag in the BindFlags member of the structure. You must set the maximum number of MIP map levels to 1. For example, set the MipLevels member of the structure to 1. You must specify that the texture requires read and write access by the GPU. For example, set the Usage member of the structure to . You must set the texture format to one of the following types.
For example, set the Format member of the structure to one of these types. You cannot use with multisampling. Therefore, set the Count member of the structure to 1. Then, set the SampleDesc member of the structure to this structure.
D3D11_RESOURCE_MISC_GDI_COMPATIBLE
Set this flag to enable the use NT HANDLE values when you create a shared resource. By enabling this flag, you deprecate the use of existing HANDLE values.
You must combine this flag only with the flag by using a bitwise OR operation. The resulting value specifies a new shared resource type that directs the runtime to use NT HANDLE values for the shared resource. The runtime then must confirm that the shared resource works on all hardware at the specified feature level.
Without this flag set, the runtime does not strictly validate shared resource parameters (that is, formats, flags, usage, and so on). When the runtime does not validate shared resource parameters, behavior of much of the Direct3D API might be undefined and might vary from driver to driver.
Direct 3D 11 and earlier:??This value is not supported until Direct3D 11.1.
D3D11_RESOURCE_MISC_SHARED_NTHANDLE
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.
Direct 3D 11:??This value is not supported until Direct3D 11.1.
D3D11_RESOURCE_MISC_RESTRICTED_CONTENT
Set this flag to indicate that the operating system restricts access to the shared surface. You can use this flag together with the flag and only when you create a shared surface. The process that creates the shared resource can always open the shared resource.
Direct 3D 11:??This value is not supported until Direct3D 11.1.
D3D11_RESOURCE_MISC_RESTRICT_SHARED_RESOURCE
Set this flag to indicate that the driver restricts access to the shared surface. You can use this flag in conjunction with the flag and only when you create a shared surface. The process that creates the shared resource can always open the shared resource.
Direct 3D 11:??This value is not supported until Direct3D 11.1.
D3D11_RESOURCE_MISC_RESTRICT_SHARED_RESOURCE_DRIVER
None.
None
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: , , , .Differences between Direct3D 9 and Direct3D 10/11:
In Direct3D 9, you specify the type of memory a resource should be created in at resource creation time (using D3DPOOL). It was an application's job to decide what memory pool would provide the best combination of functionality and performance.
In Direct3D 10/11, an application no longer specifies what type of memory (the pool) to create a resource in. Instead, you specify the intended usage of the resource, and let the runtime (in concert with the driver and a memory manager) choose the type of memory that will achieve the best performance.?Resource Usage RestrictionsEach usage dictates a tradeoff between accessibility for the CPU and accessibility for the GPU. In general, higher-performance access for one of these two processors means lower-performance access for the other. At either extreme are the and usages. restricts access almost entirely to the GPU. restricts access almost entirely to the CPU and allows only a data transfer (copy) of a resource between the GPU and the CPU. You can perform these copy operations via the and methods. You can also use these copy methods to copy data between two resources of the same usage. You can also use the method to copy memory directly from a CPU-supplied reference to any resource, most usefully a resource with .D3D11_USAGE_DYNAMIC usage is a special case that optimizes the flow of data from CPU to GPU when the CPU generates that data on-the-fly and sends that data with high frequency. is typically used on resources with vertex data and on constant buffers. Use the and methods to write data to these resources. To achieve the highest performance for data consumed serially, like vertex data, use the and sequence. For more info about this sequence, see Common Usage of with .D3D11_USAGE_IMMUTABLE usage is another special case that causes the GPU to generate data just once when you create a resource. is well-suited to data such as textures because such data is typically read into memory from some file format. Therefore, when you create a texture with , the GPU directly reads that texture into memory.Use the following table to choose the usage that best describes how the resource will need to be accessed by the CPU and/or the GPU. Of course, there will be performance tradeoffs.Resource UsageDefaultDynamicImmutableStaging GPU-Readyesyesyesyes1 GPU-Writeyesyes1 CPU-Readyes1 CPU-Writeyesyes1?1 - GPU read or write of a resource with the usage is restricted to copy operations. You use and for these copy operations. Also, because depth-stencil formats and multisample layouts are implementation details of a particular GPU design, the operating system can?t expose these formats and layouts to the CPU in general. Therefore, staging resources can't be a depth-stencil buffer or a multisampled render target.Note??You can technically use to copy to a resource with any usage except . However, we recommend to use to update only a resource with . We recommend to use and to update resources with because that is the specific purpose of resources, and is therefore the most optimized path.Note?? resources consume specific hardware capabilities. Therefore, use them sparingly. The display driver typically allocates memory for resources with a caching algorithm that favors CPU writes and hinders CPU reads. Furthermore, the memory behind resources might not even be the same for successive calls to . Therefore, do not expect high performance or even consistent CPU reads from resources.Note?? is a special case of GPU-to-CPU copy. Use only with unordered access views (UAVs) of buffers.Resource Bind OptionsTo maximize performance, not all resource usage options can be used as input or output resources to the pipeline. This table identifies these limitations.Resource Can Be Bound AsDefaultDynamicImmutableStaging Input to a Stageyes2yes3yes Output from a Stageyes2?2 - If bound as an input and an output using different views, each view must use different subresources. 3 - The resource can only be created with a single subresource. The resource cannot be a texture array. The resource cannot be a mipmap chain.
D3D11_USAGE
A resource that requires read and write access by the GPU. This is likely to be the most common usage choice.
D3D11_USAGE_DEFAULT
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.
D3D11_USAGE_IMMUTABLE
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.
D3D11_USAGE_DYNAMIC
A resource that supports data transfer (copy) from the GPU to the CPU.
D3D11_USAGE_STAGING
[This documentation is preliminary and is subject to change.]
D3D11_SHADER_MIN_PRECISION_SUPPORT
Minimum precision levels are 8-bit and 10-bit.
D3D11_SHADER_MIN_PRECISION_8_AND_10_BIT
Minimum precision level is 16-bit.
D3D11_SHADER_MIN_PRECISION_16_BIT
Identifies how to bind a raw-buffer resource to the pipeline.
This enumeration is used by
D3D11_BUFFEREX_SRV_FLAG
Bind a raw buffer to the input-assembler stage.
D3D11_BUFFEREX_SRV_FLAG_RAW
None.
None
Specifies a multi-sample pattern type.
D3D11_STANDARD_MULTISAMPLE_QUALITY_LEVELS
Pre-defined multi-sample patterns required for DX11 and DX10.1 hardware.
D3D11_STANDARD_MULTISAMPLE_PATTERN
Pattern where all of the samples are located at the pixel center.
D3D11_CENTER_MULTISAMPLE_PATTERN
The stencil operations that can be performed during depth-stencil testing.
D3D11_STENCIL_OP
Keep the existing stencil data.
D3D11_STENCIL_OP_KEEP
Set the stencil data to 0.
D3D11_STENCIL_OP_ZERO
Set the stencil data to the reference value set by calling .
D3D11_STENCIL_OP_REPLACE
Increment the stencil value by 1, and clamp the result.
D3D11_STENCIL_OP_INCR_SAT
Decrement the stencil value by 1, and clamp the result.
D3D11_STENCIL_OP_DECR_SAT
Invert the stencil data.
D3D11_STENCIL_OP_INVERT
Increment the stencil value by 1, and wrap the result if necessary.
D3D11_STENCIL_OP_INCR
Increment the stencil value by 1, and wrap the result if necessary.
D3D11_STENCIL_OP_DECR
Identify a technique for resolving texture coordinates that are outside of the boundaries of a texture.
D3D11_TEXTURE_ADDRESS_MODE
Tile the texture at every (u,v) integer junction. For example, for u values between 0 and 3, the texture is repeated three times.
D3D11_TEXTURE_ADDRESS_WRAP
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.
D3D11_TEXTURE_ADDRESS_MIRROR
Texture coordinates outside the range [0.0, 1.0] are set to the texture color at 0.0 or 1.0, respectively.
D3D11_TEXTURE_ADDRESS_CLAMP
Texture coordinates outside the range [0.0, 1.0] are set to the border color specified in or HLSL code.
D3D11_TEXTURE_ADDRESS_BORDER
Similar to and . Takes the absolute value of the texture coordinate (thus, mirroring around 0), and then clamps to the maximum value.
D3D11_TEXTURE_ADDRESS_MIRROR_ONCE
The different faces of a cube texture.
D3D11_TEXTURECUBE_FACE
Positive X face.
D3D11_TEXTURECUBE_FACE_POSITIVE_X
Negative X face.
D3D11_TEXTURECUBE_FACE_NEGATIVE_X
Positive Y face.
D3D11_TEXTURECUBE_FACE_POSITIVE_Y
Negative Y face.
D3D11_TEXTURECUBE_FACE_NEGATIVE_Y
Positive Z face.
D3D11_TEXTURECUBE_FACE_POSITIVE_Z
Negative Z face.
D3D11_TEXTURECUBE_FACE_NEGATIVE_Z
Unordered-access-view buffer options.
D3D11_BUFFER_UAV_FLAG
Resource contains raw, unstructured data. Requires the UAV format to be .
D3D11_BUFFER_UAV_FLAG_RAW
Allow data to be appended to the end of the buffer. flag must also be used for any view that will be used as a AppendStructuredBuffer or a ConsumeStructuredBuffer. Requires the UAV format to be .
D3D11_BUFFER_UAV_FLAG_APPEND
Adds a counter to the unordered-access-view buffer. can only be used on a UAV that is a RWStructuredBuffer and it enables the functionality needed for the IncrementCounter and DecrementCounter methods in HLSL. Requires the UAV format to be .
D3D11_BUFFER_UAV_FLAG_COUNTER
None.
None
Unordered-access view options.
This enumeration is used by a unordered access-view description (see ).
D3D11_UAV_DIMENSION
The view type is unknown.
D3D11_UAV_DIMENSION_UNKNOWN
View the resource as a buffer.
D3D11_UAV_DIMENSION_BUFFER
View the resource as a 1D texture.
D3D11_UAV_DIMENSION_TEXTURE1D
View the resource as a 1D texture array.
D3D11_UAV_DIMENSION_TEXTURE1DARRAY
View the resource as a 2D texture.
D3D11_UAV_DIMENSION_TEXTURE2D
View the resource as a 2D texture array.
D3D11_UAV_DIMENSION_TEXTURE2DARRAY
View the resource as a 3D texture array.
D3D11_UAV_DIMENSION_TEXTURE3D
No documentation.
D3D11_VDOV_DIMENSION
No documentation.
D3D11_VDOV_DIMENSION_UNKNOWN
No documentation.
D3D11_VDOV_DIMENSION_TEXTURE2D
[This documentation is preliminary and is subject to change.]
D3D11_VIDEO_DECODER_BUFFER_TYPE
Picture decoding parameter buffer.
D3D11_VIDEO_DECODER_BUFFER_PICTURE_PARAMETERS
Macroblock control command buffer.
D3D11_VIDEO_DECODER_BUFFER_MACROBLOCK_CONTROL
Residual difference block data buffer.
D3D11_VIDEO_DECODER_BUFFER_RESIDUAL_DIFFERENCE
Deblocking filter control command buffer.
D3D11_VIDEO_DECODER_BUFFER_DEBLOCKING_CONTROL
Inverse quantization matrix buffer.
D3D11_VIDEO_DECODER_BUFFER_INVERSE_QUANTIZATION_MATRIX
Slice-control buffer.
D3D11_VIDEO_DECODER_BUFFER_SLICE_CONTROL
Bitstream data buffer.
D3D11_VIDEO_DECODER_BUFFER_BITSTREAM
Motion vector buffer.
D3D11_VIDEO_DECODER_BUFFER_MOTION_VECTOR
Film grain synthesis data buffer.
D3D11_VIDEO_DECODER_BUFFER_FILM_GRAIN
No documentation.
D3D11_VIDEO_FRAME_FORMAT
No documentation.
D3D11_VIDEO_FRAME_FORMAT_PROGRESSIVE
No documentation.
D3D11_VIDEO_FRAME_FORMAT_INTERLACED_TOP_FIELD_FIRST
No documentation.
D3D11_VIDEO_FRAME_FORMAT_INTERLACED_BOTTOM_FIELD_FIRST
No documentation.
D3D11_VIDEO_PROCESSOR_ALPHA_FILL_MODE
No documentation.
D3D11_VIDEO_PROCESSOR_ALPHA_FILL_MODE_OPAQUE
No documentation.
D3D11_VIDEO_PROCESSOR_ALPHA_FILL_MODE_BACKGROUND
No documentation.
D3D11_VIDEO_PROCESSOR_ALPHA_FILL_MODE_DESTINATION
No documentation.
D3D11_VIDEO_PROCESSOR_ALPHA_FILL_MODE_SOURCE_STREAM
No documentation.
D3D11_VIDEO_PROCESSOR_AUTO_STREAM_CAPS
No documentation.
D3D11_VIDEO_PROCESSOR_AUTO_STREAM_CAPS_DENOISE
No documentation.
D3D11_VIDEO_PROCESSOR_AUTO_STREAM_CAPS_DERINGING
No documentation.
D3D11_VIDEO_PROCESSOR_AUTO_STREAM_CAPS_EDGE_ENHANCEMENT
No documentation.
D3D11_VIDEO_PROCESSOR_AUTO_STREAM_CAPS_COLOR_CORRECTION
No documentation.
D3D11_VIDEO_PROCESSOR_AUTO_STREAM_CAPS_FLESH_TONE_MAPPING
No documentation.
D3D11_VIDEO_PROCESSOR_AUTO_STREAM_CAPS_IMAGE_STABILIZATION
No documentation.
D3D11_VIDEO_PROCESSOR_AUTO_STREAM_CAPS_SUPER_RESOLUTION
No documentation.
D3D11_VIDEO_PROCESSOR_AUTO_STREAM_CAPS_ANAMORPHIC_SCALING
[This documentation is preliminary and is subject to change.]
D3D11_VIDEO_PROCESSOR_DEVICE_CAPS
The video processor can blend video content in linear color space. Most video content is gamma corrected, resulting in nonlinear values. This capability flag means that the video processor converts colors to linear space before blending, which produces better results.
D3D11_VIDEO_PROCESSOR_DEVICE_CAPS_LINEAR_SPACE
The video processor supports the xvYCC color space for YCbCr data.
D3D11_VIDEO_PROCESSOR_DEVICE_CAPS_xvYCC
The video processor can perform range conversion when the input and output are both RGB but use different color ranges (0-255 or 16-235, for 8-bit RGB).
D3D11_VIDEO_PROCESSOR_DEVICE_CAPS_RGB_RANGE_CONVERSION
The video processor can apply a matrix conversion to YCbCr values when the input and output are both YCbCr. For example, the driver can convert colors from BT.601 to BT.709.
D3D11_VIDEO_PROCESSOR_DEVICE_CAPS_YCbCr_MATRIX_CONVERSION
No documentation.
D3D11_VIDEO_PROCESSOR_FEATURE_CAPS
No documentation.
D3D11_VIDEO_PROCESSOR_FEATURE_CAPS_ALPHA_FILL
No documentation.
D3D11_VIDEO_PROCESSOR_FEATURE_CAPS_CONSTRICTION
No documentation.
D3D11_VIDEO_PROCESSOR_FEATURE_CAPS_LUMA_KEY
No documentation.
D3D11_VIDEO_PROCESSOR_FEATURE_CAPS_ALPHA_PALETTE
No documentation.
D3D11_VIDEO_PROCESSOR_FEATURE_CAPS_LEGACY
No documentation.
D3D11_VIDEO_PROCESSOR_FEATURE_CAPS_STEREO
No documentation.
D3D11_VIDEO_PROCESSOR_FEATURE_CAPS_ROTATION
No documentation.
D3D11_VIDEO_PROCESSOR_FEATURE_CAPS_ALPHA_STREAM
No documentation.
D3D11_VIDEO_PROCESSOR_FEATURE_CAPS_PIXEL_ASPECT_RATIO
[This documentation is preliminary and is subject to change.]
The multiplier enables the filter range to have a fractional step value.For example, a hue filter might have an actual range of [?180.0 ... +180.0] with a step size of 0.25. The device would report the following range and multiplier:Minimum: ?720 Maximum: +720 Multiplier: 0.25In this case, a filter value of 2 would be interpreted by the device as 0.50 (or 2 ? 0.25).The device should use a multiplier that can be represented exactly as a base-2 fraction.
D3D11_VIDEO_PROCESSOR_FILTER
The minimum value of the filter.
D3D11_VIDEO_PROCESSOR_FILTER_BRIGHTNESS
The maximum value of the filter.
D3D11_VIDEO_PROCESSOR_FILTER_CONTRAST
The default value of the filter.
D3D11_VIDEO_PROCESSOR_FILTER_HUE
A multiplier. Use the following formula to translate the filter setting into the actual filter value: Actual Value = Set Value???Multiplier.
D3D11_VIDEO_PROCESSOR_FILTER_SATURATION
No documentation.
D3D11_VIDEO_PROCESSOR_FILTER_NOISE_REDUCTION
No documentation.
D3D11_VIDEO_PROCESSOR_FILTER_EDGE_ENHANCEMENT
No documentation.
D3D11_VIDEO_PROCESSOR_FILTER_ANAMORPHIC_SCALING
No documentation.
D3D11_VIDEO_PROCESSOR_FILTER_STEREO_ADJUSTMENT
No documentation.
D3D11_VIDEO_PROCESSOR_FILTER_CAPS
No documentation.
D3D11_VIDEO_PROCESSOR_FILTER_CAPS_BRIGHTNESS
No documentation.
D3D11_VIDEO_PROCESSOR_FILTER_CAPS_CONTRAST
No documentation.
D3D11_VIDEO_PROCESSOR_FILTER_CAPS_HUE
No documentation.
D3D11_VIDEO_PROCESSOR_FILTER_CAPS_SATURATION
No documentation.
D3D11_VIDEO_PROCESSOR_FILTER_CAPS_NOISE_REDUCTION
No documentation.
D3D11_VIDEO_PROCESSOR_FILTER_CAPS_EDGE_ENHANCEMENT
No documentation.
D3D11_VIDEO_PROCESSOR_FILTER_CAPS_ANAMORPHIC_SCALING
No documentation.
D3D11_VIDEO_PROCESSOR_FILTER_CAPS_STEREO_ADJUSTMENT
[This documentation is preliminary and is subject to change.]
These flags define video processing capabilities that usually are not needed, and that video devices are therefore not required to support.The first three flags relate to RGB support for functions that are normally applied to YCbCr video: deinterlacing, color adjustment, and luma keying. A device that supports these functions for YCbCr is not required to support them for RGB input. Supporting RGB input for these functions is an additional capability, reflected by these constants. Note that the driver might convert the input to another color space, perform the indicated function, and then convert the result back to RGB.Similarly, a device that supports deinterlacing is not required to support deinterlacing of palettized formats. This capability is indicated by the flag.
D3D11_VIDEO_PROCESSOR_FORMAT_CAPS
The video processor can deinterlace an input stream that contains interlaced RGB video.
D3D11_VIDEO_PROCESSOR_FORMAT_CAPS_RGB_INTERLACED
The video processor can perform color adjustment on RGB video.
D3D11_VIDEO_PROCESSOR_FORMAT_CAPS_RGB_PROCAMP
The video processor can perform luma keying on RGB video.
D3D11_VIDEO_PROCESSOR_FORMAT_CAPS_RGB_LUMA_KEY
The video processor can deinterlace input streams with palettized color formats.
D3D11_VIDEO_PROCESSOR_FORMAT_CAPS_PALETTE_INTERLACED
[This documentation is preliminary and is subject to change.]
D3D11_VIDEO_PROCESSOR_FORMAT_SUPPORT
The format can be used as the input to the video processor.
D3D11_VIDEO_PROCESSOR_FORMAT_SUPPORT_INPUT
The format can be used as the output from the video processor.
D3D11_VIDEO_PROCESSOR_FORMAT_SUPPORT_OUTPUT
[This documentation is preliminary and is subject to change.]
D3D11_VIDEO_PROCESSOR_ITELECINE_CAPS
The video processor can reverse 3:2 pulldown.
D3D11_VIDEO_PROCESSOR_ITELECINE_CAPS_32
The video processor can reverse 2:2 pulldown.
D3D11_VIDEO_PROCESSOR_ITELECINE_CAPS_22
The video processor can reverse 2:2:2:4 pulldown.
D3D11_VIDEO_PROCESSOR_ITELECINE_CAPS_2224
The video processor can reverse 2:3:3:2 pulldown.
D3D11_VIDEO_PROCESSOR_ITELECINE_CAPS_2332
The video processor can reverse 3:2:3:2:2 pulldown.
D3D11_VIDEO_PROCESSOR_ITELECINE_CAPS_32322
The video processor can reverse 5:5 pulldown.
D3D11_VIDEO_PROCESSOR_ITELECINE_CAPS_55
The video processor can reverse 6:4 pulldown.
D3D11_VIDEO_PROCESSOR_ITELECINE_CAPS_64
The video processor can reverse 8:7 pulldown.
D3D11_VIDEO_PROCESSOR_ITELECINE_CAPS_87
The video processor can reverse 2:2:2:2:2:2:2:2:2:2:2:3 pulldown.
D3D11_VIDEO_PROCESSOR_ITELECINE_CAPS_222222222223
The video processor can reverse other telecine modes not listed here.
D3D11_VIDEO_PROCESSOR_ITELECINE_CAPS_OTHER
[This documentation is preliminary and is subject to change.]
D3D11_VIDEO_PROCESSOR_OUTPUT_RATE
The output is the normal frame rate.
D3D11_VIDEO_PROCESSOR_OUTPUT_RATE_NORMAL
The output is half the frame rate.
D3D11_VIDEO_PROCESSOR_OUTPUT_RATE_HALF
The output is a custom frame rate.
D3D11_VIDEO_PROCESSOR_OUTPUT_RATE_CUSTOM
No documentation.
D3D11_VIDEO_PROCESSOR_PROCESSOR_CAPS
No documentation.
D3D11_VIDEO_PROCESSOR_PROCESSOR_CAPS_DEINTERLACE_BLEND
No documentation.
D3D11_VIDEO_PROCESSOR_PROCESSOR_CAPS_DEINTERLACE_BOB
No documentation.
D3D11_VIDEO_PROCESSOR_PROCESSOR_CAPS_DEINTERLACE_ADAPTIVE
No documentation.
D3D11_VIDEO_PROCESSOR_PROCESSOR_CAPS_DEINTERLACE_MOTION_COMPENSATION
No documentation.
D3D11_VIDEO_PROCESSOR_PROCESSOR_CAPS_INVERSE_TELECINE
No documentation.
D3D11_VIDEO_PROCESSOR_PROCESSOR_CAPS_FRAME_RATE_CONVERSION
No documentation.
D3D11_VIDEO_PROCESSOR_ROTATION
No documentation.
D3D11_VIDEO_PROCESSOR_ROTATION_IDENTITY
No documentation.
D3D11_VIDEO_PROCESSOR_ROTATION_90
No documentation.
D3D11_VIDEO_PROCESSOR_ROTATION_180
No documentation.
D3D11_VIDEO_PROCESSOR_ROTATION_270
No documentation.
D3D11_VIDEO_PROCESSOR_STEREO_CAPS
No documentation.
D3D11_VIDEO_PROCESSOR_STEREO_CAPS_MONO_OFFSET
No documentation.
D3D11_VIDEO_PROCESSOR_STEREO_CAPS_ROW_INTERLEAVED
No documentation.
D3D11_VIDEO_PROCESSOR_STEREO_CAPS_COLUMN_INTERLEAVED
No documentation.
D3D11_VIDEO_PROCESSOR_STEREO_CAPS_CHECKERBOARD
No documentation.
D3D11_VIDEO_PROCESSOR_STEREO_CAPS_FLIP_MODE
No documentation.
D3D11_VIDEO_PROCESSOR_STEREO_FLIP_MODE
No documentation.
D3D11_VIDEO_PROCESSOR_STEREO_FLIP_NONE
No documentation.
D3D11_VIDEO_PROCESSOR_STEREO_FLIP_FRAME0
No documentation.
D3D11_VIDEO_PROCESSOR_STEREO_FLIP_FRAME1
[This documentation is preliminary and is subject to change.]
This enumeration designates the two stereo views as "frame 0" and "frame 1". The LeftViewFrame0 parameter of the VideoProcessorSetStreamStereoFormat method specifies which view is the left view, and which is the right view.For packed formats, if the source rectangle clips part of the surface, the driver interprets the rectangle in logical coordinates relative to the stereo view, rather than absolute pixel coordinates. The result is that frame 0 and frame 1 are clipped proportionately.To query whether the device supports stereo 3D video, call and check for the flag in the FeatureCaps member of the structure. If this capability flag is present, it means that the driver supports all of the stereo formats that are not listed as optional. To find out which optional formats are supported, call GetVideoProcessorCaps and check the StereoCaps member of the structure.
D3D11_VIDEO_PROCESSOR_STEREO_FORMAT
The sample does not contain stereo data. If the stereo format is not specified, this value is the default.
D3D11_VIDEO_PROCESSOR_STEREO_FORMAT_MONO
Frame 0 and frame 1 are packed side-by-side, as shown in the following diagram.
All drivers that support stereo video must support this format.
D3D11_VIDEO_PROCESSOR_STEREO_FORMAT_HORIZONTAL
Frame 0 and frame 1 are packed top-to-bottom, as shown in the following diagram.
All drivers that support stereo video must support this format.
D3D11_VIDEO_PROCESSOR_STEREO_FORMAT_VERTICAL
Frame 0 and frame 1 are placed in separate resources or in separate texture array elements within the same resource.
All drivers that support stereo video must support this format.
D3D11_VIDEO_PROCESSOR_STEREO_FORMAT_SEPARATE
The sample contains non-stereo data. However, the driver should create a left/right output of this sample using a specified offset. The offset is specified in the MonoOffset parameter of the method.
This format is primarily intended for subtitles and other subpicture data, where the entire sample is presented on the same plane.
Support for this stereo format is optional.
D3D11_VIDEO_PROCESSOR_STEREO_FORMAT_MONO_OFFSET
Frame 0 and frame 1 are packed into interleaved rows, as shown in the following diagram.
Support for this stereo format is optional.
D3D11_VIDEO_PROCESSOR_STEREO_FORMAT_ROW_INTERLEAVED
Frame 0 and frame 1 are packed into interleaved columns, as shown in the following diagram.
Support for this stereo format is optional.
D3D11_VIDEO_PROCESSOR_STEREO_FORMAT_COLUMN_INTERLEAVED
Frame 0 and frame 1 are packed in a checkerboard format, as shown in the following diagram.
Support for this stereo format is optional.
D3D11_VIDEO_PROCESSOR_STEREO_FORMAT_CHECKERBOARD
[This documentation is preliminary and is subject to change.]
D3D11_VIDEO_USAGE
Normal video playback. The graphics driver should expose a set of capabilities that are appropriate for real-time video playback.
D3D11_VIDEO_USAGE_PLAYBACK_NORMAL
Optimal speed. The graphics driver should expose a minimal set of capabilities that are optimized for performance.
Use this setting if you want better performance and can accept some reduction in video quality. For example, you might use this setting in power-saving mode or to play video thumbnails.
D3D11_VIDEO_USAGE_OPTIMAL_SPEED
Optimal quality. The grahics driver should expose its maximum set of capabilities.
Specify this setting to get the best video quality possible. It is appropriate for tasks such as video editing, when quality is more important than speed. It is not appropriate for real-time playback.
D3D11_VIDEO_USAGE_OPTIMAL_QUALITY
No documentation.
D3D11_VPIV_DIMENSION
No documentation.
D3D11_VPIV_DIMENSION_UNKNOWN
No documentation.
D3D11_VPIV_DIMENSION_TEXTURE2D
[This documentation is preliminary and is subject to change.]
This enumeration is used with the structure.
D3D11_VPOV_DIMENSION
Not a valid value.
D3D11_VPOV_DIMENSION_UNKNOWN
The resource will be accessed as a 2D texture.
D3D11_VPOV_DIMENSION_TEXTURE2D
The resource will be accessed as an array of 2D textures.
D3D11_VPOV_DIMENSION_TEXTURE2DARRAY
Functions
Constant SdkVersion.
D3D11_SDK_VERSION
Creates a device that represents the display adapter.
A reference to the video adapter to use when creating a device. Pass null to use the default adapter, which is the first adapter that is enumerated by IDXGIFactory1::EnumAdapters. Note??Do not mix the use of DXGI 1.0 () and DXGI 1.1 () in an application. Use or , but not both in an application.
The , which represents the driver type to create.
A handle to a DLL that implements a software rasterizer. If DriverType is , Software must not be null. Get the handle by calling LoadLibrary, LoadLibraryEx , or GetModuleHandle.
The runtime layers to enable (see ); values can be bitwise OR'd together.
A reference to an array of D3D_FEATURE_LEVELs, which determine the order of feature levels to attempt to create. Use default parameters to get the greatest feature level available. If pFeatureLevels is set to null, the following array of feature levels will be used: { , , , , , ,};
The number of elements in pFeatureLevels.
The SDK version; use .
Returns the address of a reference to an object that represents the device created.
If successful, returns the first from the pFeatureLevels array which succeeded. Otherwise, returns 0.
Returns the address of a reference to an object that represents the device context.
This method returns one of the following Direct3D 11 Return Codes.
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).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 .If you set the pAdapter parameter to a non-null value, you must also set the DriverType parameter to the value. If you set the pAdapter parameter to a non-null value and the DriverType parameter to the value, returns an of E_INVALIDARG.Differences between Direct3D 10 and Direct3D 11:
In Direct3D 10, the presence of pAdapter dictated which adapter to use and the DriverType could mismatch what the adapter was.
In Direct3D 11, if you are trying to create a hardware or a software device, set pAdapter != null which constrains the other inputs to be:
DriverType must be Software must be null. On the other hand, if pAdapter == null, the DriverType cannot be set to ; it can be set to either:
If DriverType == , Software cannot be null. If DriverType == , the adapter used will be the default adapter, which is the first adapter that is enumerated by IDXGIFactory1::EnumAdapters?
HRESULT D3D11CreateDevice([In, Optional] IDXGIAdapter* pAdapter,[In] D3D_DRIVER_TYPE DriverType,[In] HINSTANCE Software,[In] D3D11_CREATE_DEVICE_FLAG Flags,[In, Buffer, Optional] const D3D_FEATURE_LEVEL* pFeatureLevels,[In] unsigned int FeatureLevels,[In] unsigned int SDKVersion,[Out, Fast] ID3D11Device** ppDevice,[Out, Optional] D3D_FEATURE_LEVEL* pFeatureLevel,[Out, Optional] ID3D11DeviceContext** ppImmediateContext)
Creates a device that represents the display adapter and a swap chain used for rendering.
A reference to the video adapter to use when creating a device. Pass null to use the default adapter, which is the first adapter enumerated by IDXGIFactory1::EnumAdapters. Note??Do not mix the use of DXGI 1.0 () and DXGI 1.1 () in an application. Use or , but not both in an application.
The , which represents the driver type to create.
A handle to a DLL that implements a software rasterizer. If DriverType is , Software must not be null. Get the handle by calling LoadLibrary, LoadLibraryEx , or GetModuleHandle. The value should be non-null when is and null otherwise.
The runtime layers to enable (see ); values can be bitwise OR'd together.
A reference to an array of D3D_FEATURE_LEVELs, which determine the order of feature levels to attempt to create. Use default parameters to get the greatest feature level available. If pFeatureLevels is set to null, the following array of feature levels will be used: { , , , , , ,};
The number of elements in pFeatureLevels.
The SDK version; use .
A reference to a swap chain description (see ) that contains initialization parameters for the swap chain.
Returns the address of a reference to the object that represents the swap chain used for rendering.
Returns the address of a reference to an object that represents the device created. Supply null as an input to return the highest supported feature level in pFeatureLevel.
Returns a reference to a , which represents the first element in an array of feature levels supported by the device.
Returns the address of a reference to an object that represents the device context.
This method returns one of the following Direct3D 11 Return Codes.
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).Also, see the remarks section in for details about input parameter dependencies. To create a device without creating a swap chain, use the function.If you set the pAdapter parameter to a non-null value, you must also set the DriverType parameter to the value. If you set the pAdapter parameter to a non-null value and the DriverType parameter to the value, returns an of E_INVALIDARG.Notes for Metro style appsThe function does not exist for Metro style apps. Instead, Metro style apps use the function and then use the method.
HRESULT D3D11CreateDeviceAndSwapChain([In, Optional] IDXGIAdapter* pAdapter,[In] D3D_DRIVER_TYPE DriverType,[In] HINSTANCE Software,[In] D3D11_CREATE_DEVICE_FLAG Flags,[In, Buffer, Optional] const D3D_FEATURE_LEVEL* pFeatureLevels,[In] unsigned int FeatureLevels,[In] unsigned int SDKVersion,[In] const DXGI_SWAP_CHAIN_DESC* pSwapChainDesc,[Out, Optional] IDXGISwapChain** ppSwapChain,[Out, Optional] ID3D11Device** ppDevice,[Out, Optional] D3D_FEATURE_LEVEL* pFeatureLevel,[Out, Optional] ID3D11DeviceContext** ppImmediateContext)
Functions
Functions
Functions
Functions
Constant TooManyUniqueViewObjects.
D3D11_ERROR_TOO_MANY_UNIQUE_VIEW_OBJECTS
Constant FileNotFound.
D3D11_ERROR_FILE_NOT_FOUND
Constant DeferredContextMapWithoutInitialDiscard.
D3D11_ERROR_DEFERRED_CONTEXT_MAP_WITHOUT_INITIAL_DISCARD
Constant TooManyUniqueStateObjects.
D3D11_ERROR_TOO_MANY_UNIQUE_STATE_OBJECTS
[This documentation is preliminary and is subject to change.]
ID3D11AuthenticatedChannel
Initializes a new instance of the class.
The native pointer.
[This documentation is preliminary and is subject to change.]
Receives the size of the certificate chain, in bytes.
If this method succeeds, it returns . Otherwise, it returns an error code.
HRESULT ID3D11AuthenticatedChannel::GetCertificateSize([Out] unsigned int* pCertificateSize)
No documentation.
No documentation.
No documentation.
No documentation.
HRESULT ID3D11AuthenticatedChannel::GetCertificate([In] unsigned int CertificateSize,[Out, Buffer] unsigned char* pCertificate)
[This documentation is preliminary and is subject to change.]
Receives a handle to the channel.
void ID3D11AuthenticatedChannel::GetChannelHandle([Out] void** pChannelHandle)
[This documentation is preliminary and is subject to change.]
GetCertificateSize
HRESULT ID3D11AuthenticatedChannel::GetCertificateSize([Out] unsigned int* pCertificateSize)
[This documentation is preliminary and is subject to change.]
GetChannelHandle
void ID3D11AuthenticatedChannel::GetChannelHandle([Out] void** pChannelHandle)
[This documentation is preliminary and is subject to change.]
ID3D11BlendState1
Initializes a new instance of the class.
The native pointer.
[This documentation is preliminary and is subject to change.]
A reference to a structure that receives a description of the blend state. This blend state can specify logical operations as well as blending operations.
You use the description for blending state in a call to the method to create the blend-state object.
void ID3D11BlendState1::GetDesc1([Out] D3D11_BLEND_DESC1* pDesc)
[This documentation is preliminary and is subject to change.]
You use the description for blending state in a call to the method to create the blend-state object.
GetDesc1
void ID3D11BlendState1::GetDesc1([Out] D3D11_BLEND_DESC1* pDesc)
The interface encapsulates a list of graphics commands for play back.
ID3D11CommandList
Initializes a new instance of the class.
The native pointer.
Gets the initialization flags associated with the deferred context that created the command list.
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 ; however, the context flag is reserved for future use.
unsigned int ID3D11CommandList::GetContextFlags()
Gets the initialization flags associated with the deferred context that created the command list.
The GetContextFlags method gets the flags that were supplied to the ContextFlags parameter of ; however, the context flag is reserved for future use.
GetContextFlags
unsigned int ID3D11CommandList::GetContextFlags()
[This documentation is preliminary and is subject to change.]
ID3D11CryptoSession
Initializes a new instance of the class.
The native pointer.
No documentation.
No documentation.
void ID3D11CryptoSession::GetDecoderProfile([Out] GUID* pDecoderProfile)
[This documentation is preliminary and is subject to change.]
Receives the size of the certificate chain, in bytes.
If this method succeeds, it returns . Otherwise, it returns an error code.
To get the certificate, call .
HRESULT ID3D11CryptoSession::GetCertificateSize([Out] unsigned int* pCertificateSize)
[This documentation is preliminary and is subject to change.]
Receives the size of the certificate chain, in bytes.
No documentation.
If this method succeeds, it returns . Otherwise, it returns an error code.
To get the certificate, call .
HRESULT ID3D11CryptoSession::GetCertificate([In] unsigned int CertificateSize,[Out, Buffer] unsigned char* pCertificate)
[This documentation is preliminary and is subject to change.]
Receives a handle to the session.
You can use this handle to associate the session with a decoder. This enables the decoder to decrypt data that is encrypted using this session.
void ID3D11CryptoSession::GetCryptoSessionHandle([Out] void** pCryptoSessionHandle)
[This documentation is preliminary and is subject to change.]
The application specifies the encryption type when it creates the session.
GetCryptoType
void ID3D11CryptoSession::GetCryptoType([Out] GUID* pCryptoType)
No documentation.
GetDecoderProfile
void ID3D11CryptoSession::GetDecoderProfile([Out] GUID* pDecoderProfile)
[This documentation is preliminary and is subject to change.]
To get the certificate, call .
GetCertificateSize
HRESULT ID3D11CryptoSession::GetCertificateSize([Out] unsigned int* pCertificateSize)
[This documentation is preliminary and is subject to change.]
You can use this handle to associate the session with a decoder. This enables the decoder to decrypt data that is encrypted using this session.
GetCryptoSessionHandle
void ID3D11CryptoSession::GetCryptoSessionHandle([Out] void** pCryptoSessionHandle)
[This documentation is preliminary and is subject to change.]
ID3D11Device1
Initializes a new instance of the class.
The native pointer.
No documentation.
No documentation.
void ID3D11Device1::GetImmediateContext1([Out] ID3D11DeviceContext1** ppImmediateContext)
[This documentation is preliminary and is subject to change.]
Reserved for future use. Pass 0.
Upon completion of the method, the passed reference to an interface reference is initialized.
Returns if successful; otherwise, returns one of the following:Returns if the graphics adapter has been physically removed from the computer or a driver upgrade for the graphics adapter has occurred. If this error occurs, you should destroy and re-create the device. Returns if the CreateDeferredContext1 method cannot be called from the current context. For example, if the device was created with the value, CreateDeferredContext1 returns . Returns E_INVALIDARG if the ContextFlags parameter is invalid. Returns E_OUTOFMEMORY if the application has exhausted available memory.
HRESULT ID3D11Device1::CreateDeferredContext1([In] unsigned int ContextFlags,[Out, Fast] ID3D11DeviceContext1** ppDeferredContext)
[This documentation is preliminary and is subject to change.]
A reference to a structure that describes blend state.
Address of a reference to the interface for the blend-state object created.
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.
HRESULT ID3D11Device1::CreateBlendState1([In] const D3D11_BLEND_DESC1* pBlendStateDesc,[Out, Fast] ID3D11BlendState1** ppBlendState)
[This documentation is preliminary and is subject to change.]
A reference to a structure that describes the rasterizer state.
Address of a reference to the interface for the rasterizer state object created.
This method returns E_OUTOFMEMORY if there is insufficient memory to create the rasterizer state object. See Direct3D 11 Return Codes for other possible return values.
HRESULT ID3D11Device1::CreateRasterizerState1([In] const D3D11_RASTERIZER_DESC1* pRasterizerDesc,[Out, Fast] ID3D11RasterizerState1** ppRasterizerState)
[This documentation is preliminary and is subject to change.]
A combination of values that are combined by using a bitwise OR operation. The resulting value specifies how to create the context state object. The flag is currently the only defined flag. If the original device was created with , you must create all context state objects from that device with the flag. The context state object that CreateDeviceContextState creates inherits the threading model of its associated device context. By default the context state object is rent-threaded, so that an application synchronizes access to the device context, typically by use of critical sections. In contrast, the context state object is free-threaded if you used the ID3D10Multithread interface to turn on thread protection for the device context. If you set the single-threaded flag for both the context state object and the device, you guarantee that you will call the whole set of context methods and device methods only from one thread. You therefore do not need to use critical sections to synchronize access to the device context, and the runtime can avoid working with those processor-intensive critical sections.
A reference to an array of values. The array determines the order of feature levels for which creation is attempted. To get the greatest feature level available, set pFeatureLevels to null, so that CreateDeviceContextState uses the following array of feature level values: { , , , , , , ,};
The number of elements in pFeatureLevels.
The SDK version. You must set this parameter to .
The globally unique identifier () for the emulated interface. This value specifies the behavior of the device when the context state object is active. Valid values are , , , and . See Remarks.
A reference to a variable that receives a value from the pFeatureLevels array. This is the first array value with which CreateDeviceContextState succeeded in creating the context state object. If the call to CreateDeviceContextState fails, the variable pointed to by pChosenFeatureLevel is set to zero.
The address of a reference to an object that represents the state of a Direct3D device.
This method returns one of the Direct3D 11 Return Codes.
The REFIID value of the emulated interface is a obtained by use of the __uuidof operator. For example, __uuidof() gets the of the interface to a Microsoft Direct3D?11 device.Call the method to activate the context state object. When the context state object is active, the device behaviors that are associated with both the context state object's feature level and its compatible interface are activated on the Direct3D device until the next call to SwapDeviceContextState.When a context state object is active, the runtime disables certain methods on the device and context interfaces. For example, a context state object that is created with __uuidof() will cause the runtime to turn off most of the Microsoft Direct3D?10 device interfaces, and a context state object that is created with __uuidof() or __uuidof() will cause the runtime to turn off most of the methods.
This behavior ensures that a user of either emulated interface cannot set device state that the other emulated interface is unable to express. This restriction helps guarantee that the emulated interface accurately reflects the full state of the pipeline and that the emulated interface will not operate contrary to its original interface definition.For example, suppose the tessellation stage is made active through the interface
when you create the device through or , instead of through the Direct3D?10 equivalents. Because the Direct3D?11 context is active, a Direct3D?10 interface is inactive when you first retrieve it via QueryInterface. This means that you cannot immediately pass a Direct3D?10 interface that you retrieved from a Direct3D?11 device to a function. You must first call SwapDeviceContextState to activate a Direct3D?10-compatible context state object.The following table shows the methods that are active and inactive for each emulated interface.Emulated interface Active device or immediate context interfaces Inactive device or immediate context interfaces or
+
+
ID3D10Multithread
or
+
ID3D10Multithread
(As published by the immediate context. The Direct3D?10 or Microsoft Direct3D?10.1 emulated interface has no effect on deferred contexts.)?The following table shows the immediate context methods that the runtime disables when the indicated context state objects are active.Methods of when __uuidof() or __uuidof() is active Methods of when __uuidof() is active Begin
ClearDepthStencilView
ClearDepthStencilView
ClearRenderTargetView
ClearRenderTargetView
ClearState
ClearState
ClearUnorderedAccessViewUint
ClearUnorderedAccessViewFloat
CopyResource
CopyResource
CopyStructureCount
CopySubresourceRegion
CopySubresourceRegion
CSGetConstantBuffers
CSGetSamplers
CSGetShader
CSGetShaderResources
CSGetUnorderedAccessViews
CSSetConstantBuffers
CSSetSamplers
CSSetShader
CSSetShaderResources
CSSetUnorderedAccessViews
Dispatch
DispatchIndirect
CreateBlendState
Draw
Draw
DrawAuto
DrawAuto
DrawIndexed
DrawIndexed
DrawIndexedInstanced
DrawIndexedInstanced
DrawIndexedInstancedIndirect
DrawInstanced
DrawInstanced
DrawInstancedIndirect
DSGetConstantBuffers
DSGetSamplers
DSGetShader
DSGetShaderResources
DSSetConstantBuffers
DSSetSamplers
DSSetShader
DSSetShaderResources
End
ExecuteCommandList
FinishCommandList
Flush
Flush
GenerateMips
GenerateMips
GetData
GetPredication
GetPredication
GetResourceMinLOD
GetType
GetTextFilterSize
GSGetConstantBuffers
GSGetConstantBuffers
GSGetSamplers
GSGetSamplers
GSGetShader
GSGetShader
GSGetShaderResources
GSGetShaderResources
GSSetConstantBuffers
GSSetConstantBuffers
GSSetSamplers
GSSetSamplers
GSSetShader
GSSetShader
GSSetShaderResources
GSSetShaderResources
HSGetConstantBuffers
HSGetSamplers
HSGetShader
HSGetShaderResources
HSSetConstantBuffers
HSSetSamplers
HSSetShader
HSSetShaderResources
IAGetIndexBuffer
IAGetIndexBuffer
IAGetInputLayout
IAGetInputLayout
IAGetPrimitiveTopology
IAGetPrimitiveTopology
IAGetVertexBuffers
IASetIndexBuffer
IASetInputLayout
IASetPrimitiveTopology
IASetVertexBuffers
OMGetBlendState
OMGetBlendState
OMGetDepthStencilState
OMGetDepthStencilState
OMGetRenderTargets
OMGetRenderTargets
OMGetRenderTargetsAndUnorderedAccessViews
OMSetBlendState
OMSetBlendState
OMSetDepthStencilState
OMSetDepthStencilState
OMSetRenderTargets
OMSetRenderTargets
OMSetRenderTargetsAndUnorderedAccessViews
PSGetConstantBuffers
PSGetConstantBuffers
PSGetSamplers
PSGetSamplers
PSGetShader
PSGetShader
PSGetShaderResources
PSGetShaderResources
PSSetConstantBuffers
PSSetConstantBuffers
PSSetSamplers
PSSetSamplers
PSSetShader
PSSetShader
PSSetShaderResources
PSSetShaderResources
ResolveSubresource
ResolveSubresource
RSGetScissorRects
RSGetScissorRects
RSGetState
RSGetState
RSGetViewports
RSGetViewports
RSSetScissorRects
RSSetScissorRects
RSSetState
RSSetState
RSSetViewports
RSSetViewports
SetPredication
SetPredication
SetResourceMinLOD
SetTextFilterSize
SOGetTargets
SOGetTargets
SOSetTargets
SOSetTargets
UpdateSubresource
UpdateSubresource
VSGetConstantBuffers
VSGetConstantBuffers
VSGetSamplers
VSGetSamplers
VSGetShader
VSGetShader
VSGetShaderResources
VSGetShaderResources
VSSetConstantBuffers
VSSetConstantBuffers
VSSetSamplers
VSSetSamplers
VSSetShader
VSSetShader
VSSetShaderResources
VSSetShaderResources ?The following table shows the immediate context methods that the runtime does not disable when the indicated context state objects are active.Methods of when __uuidof() or __uuidof() is active Methods of when __uuidof() is active GetCreationFlags
GetPrivateData
GetContextFlags
Map
Unmap ?The following table shows the interface methods that the runtime does not disable because they are not immediate context methods.Methods of CheckCounter
CheckCounterInfo
Create*, like CreateQuery
GetDeviceRemovedReason
GetExceptionMode
OpenSharedResource
SetExceptionMode
SetPrivateData
SetPrivateDataInterface ?
HRESULT ID3D11Device1::CreateDeviceContextState([In] unsigned int Flags,[In, Buffer] const D3D_FEATURE_LEVEL* pFeatureLevels,[In] unsigned int FeatureLevels,[In] unsigned int SDKVersion,[In] const GUID& EmulatedInterface,[Out, Optional] D3D_FEATURE_LEVEL* pChosenFeatureLevel,[Out, Fast] ID3DDeviceContextState** ppContextState)
[This documentation is preliminary and is subject to change.]
No documentation.
No documentation.
No documentation.
This method returns one of the Direct3D 11 return codes. This method also returns E_ACCESSDENIED if the permissions to access the resource aren't valid.
The behavior of OpenSharedResource1 is similar to the behavior of the method; each call to OpenSharedResource1 to access a resource creates a new resource object. In other words, if you call OpenSharedResource1 twice and pass the same resource handle to hResource, you receive two resource objects with different references.To share a resource between two devicesCreate the resource as shared and specify that it uses NT handles, by setting the flag. Obtain the REFIID, or , of the interface to the resource by using the __uuidof() macro. For example, __uuidof() retrieves the of the interface to a 2D texture. Query the resource for the interface. Call the method to obtain the unique handle to the resource.
HRESULT ID3D11Device1::OpenSharedResource1([In] void* hResource,[In] const GUID& returnedInterface,[Out] void** ppResource)
[This documentation is preliminary and is subject to change.]
No documentation.
No documentation.
No documentation.
No documentation.
This method returns one of the Direct3D 11 return codes. This method also returns E_ACCESSDENIED if the permissions to access the resource aren't valid.
The behavior of OpenSharedResourceByName is similar to the behavior of the method; each call to OpenSharedResourceByName to access a resource creates a new resource object. In other words, if you call OpenSharedResourceByName twice and pass the same resource name to lpName, you receive two resource objects with different references.To share a resource between two devicesCreate the resource as shared and specify that it uses NT handles, by setting the flag. Obtain the REFIID, or , of the interface to the resource by using the __uuidof() macro. For example, __uuidof() retrieves the of the interface to a 2D texture. Query the resource for the interface. Call the method to obtain the unique handle to the resource. In this call, you must pass a name for the resource if you want to subsequently call OpenSharedResourceByName to access the resource by name.
HRESULT ID3D11Device1::OpenSharedResourceByName([In] const wchar_t* lpName,[In] unsigned int dwDesiredAccess,[In] const GUID& returnedInterface,[Out] void** ppResource)
No documentation.
GetImmediateContext1
void ID3D11Device1::GetImmediateContext1([Out] ID3D11DeviceContext1** ppImmediateContext)
[This documentation is preliminary and is subject to change.]
ID3D11DeviceContext1
Initializes a new instance of the class.
The native pointer.
[This documentation is preliminary and is subject to change.]
A reference to the destination resource.
Destination subresource index.
The x-coordinate of the upper-left corner of the destination region.
The y-coordinate of the upper-left corner of the destination region. For a 1D subresource, this must be zero.
The z-coordinate of the upper-left corner of the destination region. For a 1D or 2D subresource, this must be zero.
A reference to the source resource.
Source subresource index.
A reference to a 3D box that defines the source subresources that can be copied. If null, the entire source subresource is copied. The box must fit within the source resource.
A -typed value that specifies how to perform the copy operation. If you specify zero for no copy option, CopySubresourceRegion1 behaves like . For existing display drivers that can't process these flags, the runtime doesn't use them.
The source and destination resources can be identical, and the source and destination regions can overlap each other. For existing display drivers that don?t support overlapping, the runtime drops the call (that is, the runtime doesn't call the corresponding device driver interface (DDI)).
This overlapping support enables additional scroll functionality in a call to .
void ID3D11DeviceContext1::CopySubresourceRegion1([In] ID3D11Resource* pDstResource,[In] unsigned int DstSubresource,[In] unsigned int DstX,[In] unsigned int DstY,[In] unsigned int DstZ,[In] ID3D11Resource* pSrcResource,[In] unsigned int SrcSubresource,[In, Optional] const D3D11_BOX* pSrcBox,[In] unsigned int CopyFlags)
[This documentation is preliminary and is subject to change.]
A reference to the destination resource.
A zero-based index that identifies the destination subresource. See D3D11CalcSubresource for more details.
A reference to a box that defines the portion of the destination subresource to copy the resource data into. Coordinates are in bytes for buffers and in texels for textures. If null, the data is written to the destination subresource with no offset. The dimensions of the source must fit the destination.
A reference to the source data in memory.
The size of one row of the source data.
The size of one depth slice of source data.
A -typed value that specifies how to perform the update operation. If you specify zero for no update option, UpdateSubresource1 behaves like . For existing display drivers that can't process these flags, the runtime doesn't use them.
If you call UpdateSubresource1 to update a constant buffer, pass any region, and the driver has not been implemented to Windows Developer Preview, the runtime drops the call (except feature level 9.1, 9.2, and 9.3 where the runtime emulates support). The runtime also drops the call if you update a constant buffer with a partial region whose extent is not aligned to 16-byte granularity (16 bytes being a full constant). When the runtime drops the call, the runtime doesn't call the corresponding device driver interface (DDI).When you record a call to UpdateSubresource with an offset pDstBox in a software command list, the offset in pDstBox is incorrectly applied to pSrcData when you play back the command list. The new-for-Windows Developer PreviewUpdateSubresource1 fixes this issue. In a call to UpdateSubresource1, pDstBox does not affect pSrcData.
void ID3D11DeviceContext1::UpdateSubresource1([In] ID3D11Resource* pDstResource,[In] unsigned int DstSubresource,[In, Optional] const D3D11_BOX* pDstBox,[In] const void* pSrcData,[In] unsigned int SrcRowPitch,[In] unsigned int SrcDepthPitch,[In] unsigned int CopyFlags)
[This documentation is preliminary and is subject to change.]
A reference to the interface for the resource to discard. The resource must have been created with usage or , otherwise the runtime drops the call to DiscardResource; if the debug layer is enabled, the runtime returns an error message.
DiscardResource informs the graphics processing unit (GPU) that the existing content in the resource that pResource points to is no longer needed.
void ID3D11DeviceContext1::DiscardResource([In] ID3D11Resource* pResource)
[This documentation is preliminary and is subject to change.]
A reference to the interface for the resource view to discard. The resource that underlies the view must have been created with usage or , otherwise the runtime drops the call to DiscardView; if the debug layer is enabled, the runtime returns an error message.
DiscardView informs the graphics processing unit (GPU) that the existing content in the resource view that pResourceView points to is no longer needed. The view can be an SRV, RTV, UAV, or DSV. DiscardView is a variation on the DiscardResource method. DiscardView allows you to discard a subset of a resource that is in a view (such as a single miplevel). More importantly, DiscardView provides a convenience because often views are what are being bound and unbound at the pipeline. Some pipeline bindings do not have views, such as stream output. In that situation, DiscardResource can do the job for any resource.
void ID3D11DeviceContext1::DiscardView([In] ID3D11View* pResourceView)
[This documentation is preliminary and is subject to change.]
Index into the device's zero-based array to begin setting constant buffers to (ranges from 0 to - 1).
Number of buffers to set (ranges from 0 to - StartSlot).
Array of constant buffers being given to the device.
A reference to an array that holds the offsets into the buffers that ppConstantBuffers specifies. Each offset specifies where, from the shader's point of view, each constant buffer starts. Each offset is measured in shader constants, which are 16 bytes (4*32-bit components). Therefore, an offset of 2 indicates that the start of the associated constant buffer is 32 bytes into the constant buffer.
A reference to an array that holds the numbers of constants in the buffers that ppConstantBuffers specifies. Each number specifies the number of constants that are contained in the constant buffer that the shader uses. Each number of constants starts from its respective offset that is specified in the pFirstConstant array.
The runtime drops the call to VSSetConstantBuffers1 if the number of constants to which pNumConstants points is larger than the maximum constant buffer size that is supported by shaders (4096 constants ? 4*32-bit components each). The values in the elements of the pFirstConstant and pFirstConstant + pNumConstants arrays can exceed the length of each buffer; from the shader's point of view, the constant buffer is the intersection of the actual memory allocation for the buffer and the window [value in an element of pFirstConstant, value in an element of pFirstConstant + value in an element of pNumConstants]. The runtime also drops the call to VSSetConstantBuffers1 on existing drivers that do not support this offsetting.The runtime will emulate this feature for feature level 9.1, 9.2, and 9.3; therefore, this feature is supported for feature level 9.1, 9.2, and 9.3. This feature is always available on new drivers for feature level 10 and higher.From the shader?s point of view, element [0] in the constant buffers array is the constant at pFirstConstant.Out of bounds access to the constant buffers from the shader to the range that is defined by pFirstConstant and pNumConstants returns 0.If pFirstConstant and pNumConstants arrays are null, you get the same result as if you were binding the entire buffer into view. You get this same result if you call the VSSetConstantBuffers method. If the buffer is larger than the maximum constant buffer size that is supported by shaders (4096 elements), the shader can access only the first 4096 constants.If either pFirstConstant or pNumConstants is null, the other parameter must also be null.
void ID3D11DeviceContext1::VSSetConstantBuffers1([In] unsigned int StartSlot,[In] unsigned int NumBuffers,[In, Buffer, Optional] const ID3D11Buffer** ppConstantBuffers,[In, Buffer, Optional] const unsigned int* pFirstConstant,[In, Buffer, Optional] const unsigned int* pNumConstants)
[This documentation is preliminary and is subject to change.]
Index into the device's zero-based array to begin setting constant buffers to (ranges from 0 to - 1).
Number of buffers to set (ranges from 0 to - StartSlot).
Array of constant buffers being given to the device.
A reference to an array that holds the offsets into the buffers that ppConstantBuffers specifies. Each offset specifies where, from the shader's point of view, each constant buffer starts. Each offset is measured in shader constants, which are 16 bytes (4*32-bit components). Therefore, an offset of 2 indicates that the start of the associated constant buffer is 32 bytes into the constant buffer.
A reference to an array that holds the numbers of constants in the buffers that ppConstantBuffers specifies. Each number specifies the number of constants that are contained in the constant buffer that the shader uses. Each number of constants starts from its respective offset that is specified in the pFirstConstant array.
The runtime drops the call to VSSetConstantBuffers1 if the number of constants to which pNumConstants points is larger than the maximum constant buffer size that is supported by shaders (4096 constants ? 4*32-bit components each). The values in the elements of the pFirstConstant and pFirstConstant + pNumConstants arrays can exceed the length of each buffer; from the shader's point of view, the constant buffer is the intersection of the actual memory allocation for the buffer and the window [value in an element of pFirstConstant, value in an element of pFirstConstant + value in an element of pNumConstants]. The runtime also drops the call to VSSetConstantBuffers1 on existing drivers that do not support this offsetting.The runtime will emulate this feature for feature level 9.1, 9.2, and 9.3; therefore, this feature is supported for feature level 9.1, 9.2, and 9.3. This feature is always available on new drivers for feature level 10 and higher.From the shader?s point of view, element [0] in the constant buffers array is the constant at pFirstConstant.Out of bounds access to the constant buffers from the shader to the range that is defined by pFirstConstant and pNumConstants returns 0.If pFirstConstant and pNumConstants arrays are null, you get the same result as if you were binding the entire buffer into view. You get this same result if you call the VSSetConstantBuffers method. If the buffer is larger than the maximum constant buffer size that is supported by shaders (4096 elements), the shader can access only the first 4096 constants.If either pFirstConstant or pNumConstants is null, the other parameter must also be null.
void ID3D11DeviceContext1::VSSetConstantBuffers1([In] unsigned int StartSlot,[In] unsigned int NumBuffers,[In, Buffer, Optional] const ID3D11Buffer** ppConstantBuffers,[In, Buffer, Optional] const unsigned int* pFirstConstant,[In, Buffer, Optional] const unsigned int* pNumConstants)
[This documentation is preliminary and is subject to change.]
No documentation.
No documentation.
No documentation.
No documentation.
No documentation.
The runtime drops the call to HSSetConstantBuffers1 if the numbers of constants to which pNumConstants points is larger than the maximum constant buffer size that is supported by shaders (4096 constants ? 4*32-bit components each). The values in the elements of the pFirstConstant and pFirstConstant + pNumConstants arrays can exceed the length of each buffer; from the shader's point of view, the constant buffer is the intersection of the actual memory allocation for the buffer and the window [value in an element of pFirstConstant, value in an element of pFirstConstant + value in an element of pNumConstants]. The runtime also drops the call to HSSetConstantBuffers1 on existing drivers that do not support this offsetting.The runtime will emulate this feature for feature level 9.1, 9.2, and 9.3; therefore, this feature is supported for feature level 9.1, 9.2, and 9.3. This feature is always available on new drivers for feature level 10 and higher.From the shader?s point of view, element [0] in the constant buffers array is the constant at pFirstConstant.Out of bounds access to the constant buffers from the shader to the range that is defined by pFirstConstant and pNumConstants returns 0.If the pFirstConstant and pNumConstants arrays are null, you get the same result as if you were binding the entire buffer into view. You get this same result if you call the HSSetConstantBuffers method. If the buffer is larger than the maximum constant buffer size that is supported by shaders (4096 elements), the shader can access only the first 4096 constants.If either pFirstConstant or pNumConstants is null, the other parameter must also be null.
void ID3D11DeviceContext1::HSSetConstantBuffers1([In] unsigned int StartSlot,[In] unsigned int NumBuffers,[In, Buffer, Optional] const ID3D11Buffer** ppConstantBuffers,[In, Buffer, Optional] const unsigned int* pFirstConstant,[In, Buffer, Optional] const unsigned int* pNumConstants)
[This documentation is preliminary and is subject to change.]
No documentation.
No documentation.
No documentation.
No documentation.
No documentation.
The runtime drops the call to HSSetConstantBuffers1 if the numbers of constants to which pNumConstants points is larger than the maximum constant buffer size that is supported by shaders (4096 constants ? 4*32-bit components each). The values in the elements of the pFirstConstant and pFirstConstant + pNumConstants arrays can exceed the length of each buffer; from the shader's point of view, the constant buffer is the intersection of the actual memory allocation for the buffer and the window [value in an element of pFirstConstant, value in an element of pFirstConstant + value in an element of pNumConstants]. The runtime also drops the call to HSSetConstantBuffers1 on existing drivers that do not support this offsetting.The runtime will emulate this feature for feature level 9.1, 9.2, and 9.3; therefore, this feature is supported for feature level 9.1, 9.2, and 9.3. This feature is always available on new drivers for feature level 10 and higher.From the shader?s point of view, element [0] in the constant buffers array is the constant at pFirstConstant.Out of bounds access to the constant buffers from the shader to the range that is defined by pFirstConstant and pNumConstants returns 0.If the pFirstConstant and pNumConstants arrays are null, you get the same result as if you were binding the entire buffer into view. You get this same result if you call the HSSetConstantBuffers method. If the buffer is larger than the maximum constant buffer size that is supported by shaders (4096 elements), the shader can access only the first 4096 constants.If either pFirstConstant or pNumConstants is null, the other parameter must also be null.
void ID3D11DeviceContext1::HSSetConstantBuffers1([In] unsigned int StartSlot,[In] unsigned int NumBuffers,[In, Buffer, Optional] const ID3D11Buffer** ppConstantBuffers,[In, Buffer, Optional] const unsigned int* pFirstConstant,[In, Buffer, Optional] const unsigned int* pNumConstants)
[This documentation is preliminary and is subject to change.]
Index into the zero-based array to begin setting constant buffers to (ranges from 0 to - 1).
Number of buffers to set (ranges from 0 to - StartSlot).
Array of constant buffers being given to the device.
A reference to an array that holds the offsets into the buffers that ppConstantBuffers specifies. Each offset specifies where, from the shader's point of view, each constant buffer starts. Each offset is measured in shader constants, which are 16 bytes (4*32-bit components). Therefore, an offset of 2 indicates that the start of the associated constant buffer is 32 bytes into the constant buffer.
A reference to an array that holds the numbers of constants in the buffers that ppConstantBuffers specifies. Each number specifies the number of constants that are contained in the constant buffer that the shader uses. Each number of constants starts from its respective offset that is specified in the pFirstConstant array.
The runtime drops the call to DSSetConstantBuffers1 if the number of constants to which pNumConstants points is larger than the maximum constant buffer size that is supported by shaders (4096 constants ? 4*32-bit components each). The values in the elements of the pFirstConstant and pFirstConstant + pNumConstants arrays can exceed the length of each buffer; from the shader's point of view, the constant buffer is the intersection of the actual memory allocation for the buffer and the window [value in an element of pFirstConstant, value in an element of pFirstConstant + value in an element of pNumConstants]. The runtime also drops the call to DSSetConstantBuffers1 on existing drivers that do not support this offsetting.The runtime will emulate this feature for feature level 9.1, 9.2, and 9.3; therefore, this feature is supported for feature level 9.1, 9.2, and 9.3. This feature is always available on new drivers for feature level 10 and higher.From the shader?s point of view, element [0] in the constant buffers array is the constant at pFirstConstant.Out of bounds access to the constant buffers from the shader to the range that is defined by pFirstConstant and pNumConstants returns 0.If pFirstConstant and pNumConstants arrays are null, you get the same result as if you were binding the entire buffer into view. You get this same result if you call the DSSetConstantBuffers method. If the buffer is larger than the maximum constant buffer size that is supported by shaders (4096 elements), the shader can access only the first 4096 constants.If either pFirstConstant or pNumConstants is null, the other parameter must also be null.
void ID3D11DeviceContext1::DSSetConstantBuffers1([In] unsigned int StartSlot,[In] unsigned int NumBuffers,[In, Buffer, Optional] const ID3D11Buffer** ppConstantBuffers,[In, Buffer, Optional] const unsigned int* pFirstConstant,[In, Buffer, Optional] const unsigned int* pNumConstants)
[This documentation is preliminary and is subject to change.]
Index into the zero-based array to begin setting constant buffers to (ranges from 0 to - 1).
Number of buffers to set (ranges from 0 to - StartSlot).
Array of constant buffers being given to the device.
A reference to an array that holds the offsets into the buffers that ppConstantBuffers specifies. Each offset specifies where, from the shader's point of view, each constant buffer starts. Each offset is measured in shader constants, which are 16 bytes (4*32-bit components). Therefore, an offset of 2 indicates that the start of the associated constant buffer is 32 bytes into the constant buffer.
A reference to an array that holds the numbers of constants in the buffers that ppConstantBuffers specifies. Each number specifies the number of constants that are contained in the constant buffer that the shader uses. Each number of constants starts from its respective offset that is specified in the pFirstConstant array.
The runtime drops the call to DSSetConstantBuffers1 if the number of constants to which pNumConstants points is larger than the maximum constant buffer size that is supported by shaders (4096 constants ? 4*32-bit components each). The values in the elements of the pFirstConstant and pFirstConstant + pNumConstants arrays can exceed the length of each buffer; from the shader's point of view, the constant buffer is the intersection of the actual memory allocation for the buffer and the window [value in an element of pFirstConstant, value in an element of pFirstConstant + value in an element of pNumConstants]. The runtime also drops the call to DSSetConstantBuffers1 on existing drivers that do not support this offsetting.The runtime will emulate this feature for feature level 9.1, 9.2, and 9.3; therefore, this feature is supported for feature level 9.1, 9.2, and 9.3. This feature is always available on new drivers for feature level 10 and higher.From the shader?s point of view, element [0] in the constant buffers array is the constant at pFirstConstant.Out of bounds access to the constant buffers from the shader to the range that is defined by pFirstConstant and pNumConstants returns 0.If pFirstConstant and pNumConstants arrays are null, you get the same result as if you were binding the entire buffer into view. You get this same result if you call the DSSetConstantBuffers method. If the buffer is larger than the maximum constant buffer size that is supported by shaders (4096 elements), the shader can access only the first 4096 constants.If either pFirstConstant or pNumConstants is null, the other parameter must also be null.
void ID3D11DeviceContext1::DSSetConstantBuffers1([In] unsigned int StartSlot,[In] unsigned int NumBuffers,[In, Buffer, Optional] const ID3D11Buffer** ppConstantBuffers,[In, Buffer, Optional] const unsigned int* pFirstConstant,[In, Buffer, Optional] const unsigned int* pNumConstants)
[This documentation is preliminary and is subject to change.]
Index into the device's zero-based array to begin setting constant buffers to (ranges from 0 to - 1).
Number of buffers to set (ranges from 0 to - StartSlot).
Array of constant buffers (see ) being given to the device.
A reference to an array that holds the offsets into the buffers that ppConstantBuffers specifies. Each offset specifies where, from the shader's point of view, each constant buffer starts. Each offset is measured in shader constants, which are 16 bytes (4*32-bit components). Therefore, an offset of 2 indicates that the start of the associated constant buffer is 32 bytes into the constant buffer.
A reference to an array that holds the numbers of constants in the buffers that ppConstantBuffers specifies. Each number specifies the number of constants that are contained in the constant buffer that the shader uses. Each number of constants starts from its respective offset that is specified in the pFirstConstant array.
The runtime drops the call to GSSetConstantBuffers1 if the numbers of constants to which pNumConstants points is larger than the maximum constant buffer size that is supported by shaders (4096 constants ? 4*32-bit components each). The values in the elements of the pFirstConstant and pFirstConstant + pNumConstants arrays can exceed the length of each buffer; from the shader's point of view, the constant buffer is the intersection of the actual memory allocation for the buffer and the window [value in an element of pFirstConstant, value in an element of pFirstConstant + value in an element of pNumConstants]. The runtime also drops the call to GSSetConstantBuffers1 on existing drivers that do not support this offsetting.The runtime will emulate this feature for feature level 9.1, 9.2, and 9.3; therefore, this feature is supported for feature level 9.1, 9.2, and 9.3. This feature is always available on new drivers for feature level 10 and higher.From the shader?s point of view, element [0] in the constant buffers array is the constant at pFirstConstant.Out of bounds access to the constant buffers from the shader to the range that is defined by pFirstConstant and pNumConstants returns 0.If pFirstConstant and pNumConstants arrays are null, you get the same result as if you were binding the entire buffer into view. You get this same result if you call the GSSetConstantBuffers method. If the buffer is larger than the maximum constant buffer size that is supported by shaders (4096 elements), the shader can access only the first 4096 constants.If either pFirstConstant or pNumConstants is null, the other parameter must also be null.
void ID3D11DeviceContext1::GSSetConstantBuffers1([In] unsigned int StartSlot,[In] unsigned int NumBuffers,[In, Buffer, Optional] const ID3D11Buffer** ppConstantBuffers,[In, Buffer, Optional] const unsigned int* pFirstConstant,[In, Buffer, Optional] const unsigned int* pNumConstants)
[This documentation is preliminary and is subject to change.]
Index into the device's zero-based array to begin setting constant buffers to (ranges from 0 to - 1).
Number of buffers to set (ranges from 0 to - StartSlot).
Array of constant buffers (see ) being given to the device.
A reference to an array that holds the offsets into the buffers that ppConstantBuffers specifies. Each offset specifies where, from the shader's point of view, each constant buffer starts. Each offset is measured in shader constants, which are 16 bytes (4*32-bit components). Therefore, an offset of 2 indicates that the start of the associated constant buffer is 32 bytes into the constant buffer.
A reference to an array that holds the numbers of constants in the buffers that ppConstantBuffers specifies. Each number specifies the number of constants that are contained in the constant buffer that the shader uses. Each number of constants starts from its respective offset that is specified in the pFirstConstant array.
The runtime drops the call to GSSetConstantBuffers1 if the numbers of constants to which pNumConstants points is larger than the maximum constant buffer size that is supported by shaders (4096 constants ? 4*32-bit components each). The values in the elements of the pFirstConstant and pFirstConstant + pNumConstants arrays can exceed the length of each buffer; from the shader's point of view, the constant buffer is the intersection of the actual memory allocation for the buffer and the window [value in an element of pFirstConstant, value in an element of pFirstConstant + value in an element of pNumConstants]. The runtime also drops the call to GSSetConstantBuffers1 on existing drivers that do not support this offsetting.The runtime will emulate this feature for feature level 9.1, 9.2, and 9.3; therefore, this feature is supported for feature level 9.1, 9.2, and 9.3. This feature is always available on new drivers for feature level 10 and higher.From the shader?s point of view, element [0] in the constant buffers array is the constant at pFirstConstant.Out of bounds access to the constant buffers from the shader to the range that is defined by pFirstConstant and pNumConstants returns 0.If pFirstConstant and pNumConstants arrays are null, you get the same result as if you were binding the entire buffer into view. You get this same result if you call the GSSetConstantBuffers method. If the buffer is larger than the maximum constant buffer size that is supported by shaders (4096 elements), the shader can access only the first 4096 constants.If either pFirstConstant or pNumConstants is null, the other parameter must also be null.
void ID3D11DeviceContext1::GSSetConstantBuffers1([In] unsigned int StartSlot,[In] unsigned int NumBuffers,[In, Buffer, Optional] const ID3D11Buffer** ppConstantBuffers,[In, Buffer, Optional] const unsigned int* pFirstConstant,[In, Buffer, Optional] const unsigned int* pNumConstants)
[This documentation is preliminary and is subject to change.]
Index into the device's zero-based array to begin setting constant buffers to (ranges from 0 to - 1).
Number of buffers to set (ranges from 0 to - StartSlot).
Array of constant buffers (see ) being given to the device.
A reference to an array that holds the offsets into the buffers that ppConstantBuffers specifies. Each offset specifies where, from the shader's point of view, each constant buffer starts. Each offset is measured in shader constants, which are 16 bytes (4*32-bit components). Therefore, an offset of 2 indicates that the start of the associated constant buffer is 32 bytes into the constant buffer.
A reference to an array that holds the numbers of constants in the buffers that ppConstantBuffers specifies. Each number specifies the number of constants that are contained in the constant buffer that the shader uses. Each number of constants starts from its respective offset that is specified in the pFirstConstant array.
The runtime drops the call to PSSetConstantBuffers1 if the numbers of constants to which pNumConstants points is larger than the maximum constant buffer size that is supported by shaders (4096 constants ? 4*32-bit components each). The values in the elements of the pFirstConstant and pFirstConstant + pNumConstants arrays can exceed the length of each buffer; from the shader's point of view, the constant buffer is the intersection of the actual memory allocation for the buffer and the window [value in an element of pFirstConstant, value in an element of pFirstConstant + value in an element of pNumConstants]. The runtime also drops the call to PSSetConstantBuffers1 on existing drivers that do not support this offsetting.The runtime will emulate this feature for feature level 9.1, 9.2, and 9.3; therefore, this feature is supported for feature level 9.1, 9.2, and 9.3. This feature is always available on new drivers for feature level 10 and higher.From the shader?s point of view, element [0] in the constant buffers array is the constant at pFirstConstant.Out of bounds access to the constant buffers from the shader to the range that is defined by pFirstConstant and pNumConstants returns 0.If pFirstConstant and pNumConstants arrays are null, you get the same result as if you were binding the entire buffer into view. You get this same result if you call the PSSetConstantBuffers method. If the buffer is larger than the maximum constant buffer size that is supported by shaders (4096 elements), the shader can access only the first 4096 constants.If either pFirstConstant or pNumConstants is null, the other parameter must also be null.
void ID3D11DeviceContext1::PSSetConstantBuffers1([In] unsigned int StartSlot,[In] unsigned int NumBuffers,[In, Buffer, Optional] const ID3D11Buffer** ppConstantBuffers,[In, Buffer, Optional] const unsigned int* pFirstConstant,[In, Buffer, Optional] const unsigned int* pNumConstants)
[This documentation is preliminary and is subject to change.]
Index into the device's zero-based array to begin setting constant buffers to (ranges from 0 to - 1).
Number of buffers to set (ranges from 0 to - StartSlot).
Array of constant buffers (see ) being given to the device.
A reference to an array that holds the offsets into the buffers that ppConstantBuffers specifies. Each offset specifies where, from the shader's point of view, each constant buffer starts. Each offset is measured in shader constants, which are 16 bytes (4*32-bit components). Therefore, an offset of 2 indicates that the start of the associated constant buffer is 32 bytes into the constant buffer.
A reference to an array that holds the numbers of constants in the buffers that ppConstantBuffers specifies. Each number specifies the number of constants that are contained in the constant buffer that the shader uses. Each number of constants starts from its respective offset that is specified in the pFirstConstant array.
The runtime drops the call to PSSetConstantBuffers1 if the numbers of constants to which pNumConstants points is larger than the maximum constant buffer size that is supported by shaders (4096 constants ? 4*32-bit components each). The values in the elements of the pFirstConstant and pFirstConstant + pNumConstants arrays can exceed the length of each buffer; from the shader's point of view, the constant buffer is the intersection of the actual memory allocation for the buffer and the window [value in an element of pFirstConstant, value in an element of pFirstConstant + value in an element of pNumConstants]. The runtime also drops the call to PSSetConstantBuffers1 on existing drivers that do not support this offsetting.The runtime will emulate this feature for feature level 9.1, 9.2, and 9.3; therefore, this feature is supported for feature level 9.1, 9.2, and 9.3. This feature is always available on new drivers for feature level 10 and higher.From the shader?s point of view, element [0] in the constant buffers array is the constant at pFirstConstant.Out of bounds access to the constant buffers from the shader to the range that is defined by pFirstConstant and pNumConstants returns 0.If pFirstConstant and pNumConstants arrays are null, you get the same result as if you were binding the entire buffer into view. You get this same result if you call the PSSetConstantBuffers method. If the buffer is larger than the maximum constant buffer size that is supported by shaders (4096 elements), the shader can access only the first 4096 constants.If either pFirstConstant or pNumConstants is null, the other parameter must also be null.
void ID3D11DeviceContext1::PSSetConstantBuffers1([In] unsigned int StartSlot,[In] unsigned int NumBuffers,[In, Buffer, Optional] const ID3D11Buffer** ppConstantBuffers,[In, Buffer, Optional] const unsigned int* pFirstConstant,[In, Buffer, Optional] const unsigned int* pNumConstants)
[This documentation is preliminary and is subject to change.]
Index into the zero-based array to begin setting constant buffers to (ranges from 0 to - 1).
Number of buffers to set (ranges from 0 to - StartSlot).
Array of constant buffers (see ) being given to the device.
A reference to an array that holds the offsets into the buffers that ppConstantBuffers specifies. Each offset specifies where, from the shader's point of view, each constant buffer starts. Each offset is measured in shader constants, which are 16 bytes (4*32-bit components). Therefore, an offset of 2 indicates that the start of the associated constant buffer is 32 bytes into the constant buffer.
A reference to an array that holds the numbers of constants in the buffers that ppConstantBuffers specifies. Each number specifies the number of constants that are contained in the constant buffer that the shader uses. Each number of constants starts from its respective offset that is specified in the pFirstConstant array.
The runtime drops the call to CSSetConstantBuffers1 if the number of constants to which pNumConstants points is larger than the maximum constant buffer size that is supported by shaders (4096 constants ? 4*32-bit components each). The values in the elements of the pFirstConstant and pFirstConstant + pNumConstants arrays can exceed the length of each buffer; from the shader's point of view, the constant buffer is the intersection of the actual memory allocation for the buffer and the window [value in an element of pFirstConstant, value in an element of pFirstConstant + value in an element of pNumConstants]. The runtime also drops the call to CSSetConstantBuffers1 on existing drivers that do not support this offsetting.The runtime will emulate this feature for feature level 9.1, 9.2, and 9.3; therefore, this feature is supported for feature level 9.1, 9.2, and 9.3. This feature is always available on new drivers for feature level 10 and higher.From the shader?s point of view, element [0] in the constant buffers array is the constant at pFirstConstant.Out of bounds access to the constant buffers from the shader to the range that is defined by pFirstConstant and pNumConstants returns 0.If pFirstConstant and pNumConstants arrays are null, you get the same result as if you were binding the entire buffer into view. You get this same result if you call the CSSetConstantBuffers method. If the buffer is larger than the maximum constant buffer size that is supported by shaders (4096 elements), the shader can access only the first 4096 constants.If either pFirstConstant or pNumConstants is null, the other parameter must also be null.
void ID3D11DeviceContext1::CSSetConstantBuffers1([In] unsigned int StartSlot,[In] unsigned int NumBuffers,[In, Buffer, Optional] const ID3D11Buffer** ppConstantBuffers,[In, Buffer, Optional] const unsigned int* pFirstConstant,[In, Buffer, Optional] const unsigned int* pNumConstants)
[This documentation is preliminary and is subject to change.]
Index into the zero-based array to begin setting constant buffers to (ranges from 0 to - 1).
Number of buffers to set (ranges from 0 to - StartSlot).
Array of constant buffers (see ) being given to the device.
A reference to an array that holds the offsets into the buffers that ppConstantBuffers specifies. Each offset specifies where, from the shader's point of view, each constant buffer starts. Each offset is measured in shader constants, which are 16 bytes (4*32-bit components). Therefore, an offset of 2 indicates that the start of the associated constant buffer is 32 bytes into the constant buffer.
A reference to an array that holds the numbers of constants in the buffers that ppConstantBuffers specifies. Each number specifies the number of constants that are contained in the constant buffer that the shader uses. Each number of constants starts from its respective offset that is specified in the pFirstConstant array.
The runtime drops the call to CSSetConstantBuffers1 if the number of constants to which pNumConstants points is larger than the maximum constant buffer size that is supported by shaders (4096 constants ? 4*32-bit components each). The values in the elements of the pFirstConstant and pFirstConstant + pNumConstants arrays can exceed the length of each buffer; from the shader's point of view, the constant buffer is the intersection of the actual memory allocation for the buffer and the window [value in an element of pFirstConstant, value in an element of pFirstConstant + value in an element of pNumConstants]. The runtime also drops the call to CSSetConstantBuffers1 on existing drivers that do not support this offsetting.The runtime will emulate this feature for feature level 9.1, 9.2, and 9.3; therefore, this feature is supported for feature level 9.1, 9.2, and 9.3. This feature is always available on new drivers for feature level 10 and higher.From the shader?s point of view, element [0] in the constant buffers array is the constant at pFirstConstant.Out of bounds access to the constant buffers from the shader to the range that is defined by pFirstConstant and pNumConstants returns 0.If pFirstConstant and pNumConstants arrays are null, you get the same result as if you were binding the entire buffer into view. You get this same result if you call the CSSetConstantBuffers method. If the buffer is larger than the maximum constant buffer size that is supported by shaders (4096 elements), the shader can access only the first 4096 constants.If either pFirstConstant or pNumConstants is null, the other parameter must also be null.
void ID3D11DeviceContext1::CSSetConstantBuffers1([In] unsigned int StartSlot,[In] unsigned int NumBuffers,[In, Buffer, Optional] const ID3D11Buffer** ppConstantBuffers,[In, Buffer, Optional] const unsigned int* pFirstConstant,[In, Buffer, Optional] const unsigned int* pNumConstants)
[This documentation is preliminary and is subject to change.]
Index into the device's zero-based array to begin retrieving constant buffers from (ranges from 0 to - 1).
Number of buffers to retrieve (ranges from 0 to - StartSlot).
Array of constant buffer interface references to be returned by the method.
A reference to an array that receives the offsets into the buffers that ppConstantBuffers specifies. Each offset specifies where, from the shader's point of view, each constant buffer starts. Each offset is measured in shader constants, which are 16 bytes (4*32-bit components). Therefore, an offset of 2 indicates that the start of the associated constant buffer is 32 bytes into the constant buffer. The runtime sets pFirstConstant to null if the buffers do not have offsets.
A reference to an array that receives the numbers of constants in the buffers that ppConstantBuffers specifies. Each number specifies the number of constants that are contained in the constant buffer that the shader uses. Each number of constants starts from its respective offset that is specified in the pFirstConstant array. The runtime sets pNumConstants to null if it doesn't specify the numbers of constants in each buffer.
If no buffer is bound at a slot, pFirstConstant and pNumConstants are null for that slot.
void ID3D11DeviceContext1::VSGetConstantBuffers1([In] unsigned int StartSlot,[In] unsigned int NumBuffers,[Out, Buffer, Optional] ID3D11Buffer** ppConstantBuffers,[Out, Buffer, Optional] unsigned int* pFirstConstant,[Out, Buffer, Optional] unsigned int* pNumConstants)
[This documentation is preliminary and is subject to change.]
No documentation.
No documentation.
No documentation.
No documentation.
No documentation.
If no buffer is bound at a slot, pFirstConstant and pNumConstants are null for that slot.
void ID3D11DeviceContext1::HSGetConstantBuffers1([In] unsigned int StartSlot,[In] unsigned int NumBuffers,[Out, Buffer, Optional] ID3D11Buffer** ppConstantBuffers,[Out, Buffer, Optional] unsigned int* pFirstConstant,[Out, Buffer, Optional] unsigned int* pNumConstants)
[This documentation is preliminary and is subject to change.]
Index into the device's zero-based array to begin retrieving constant buffers from (ranges from 0 to - 1).
Number of buffers to retrieve (ranges from 0 to - StartSlot).
Array of constant buffer interface references to be returned by the method.
A reference to an array that receives the offsets into the buffers that ppConstantBuffers specifies. Each offset specifies where, from the shader's point of view, each constant buffer starts. Each offset is measured in shader constants, which are 16 bytes (4*32-bit components). Therefore, an offset of 2 indicates that the start of the associated constant buffer is 32 bytes into the constant buffer. The runtime sets pFirstConstant to null if the buffers do not have offsets.
A reference to an array that receives the numbers of constants in the buffers that ppConstantBuffers specifies. Each number specifies the number of constants that are contained in the constant buffer that the shader uses. Each number of constants starts from its respective offset that is specified in the pFirstConstant array. The runtime sets pNumConstants to null if it doesn't specify the numbers of constants in each buffer.
If no buffer is bound at a slot, pFirstConstant and pNumConstants are null for that slot.
void ID3D11DeviceContext1::DSGetConstantBuffers1([In] unsigned int StartSlot,[In] unsigned int NumBuffers,[Out, Buffer, Optional] ID3D11Buffer** ppConstantBuffers,[Out, Buffer, Optional] unsigned int* pFirstConstant,[Out, Buffer, Optional] unsigned int* pNumConstants)
[This documentation is preliminary and is subject to change.]
Index into the device's zero-based array to begin retrieving constant buffers from (ranges from 0 to - 1).
Number of buffers to retrieve (ranges from 0 to - StartSlot).
Array of constant buffer interface references to be returned by the method.
A reference to an array that receives the offsets into the buffers that ppConstantBuffers specifies. Each offset specifies where, from the shader's point of view, each constant buffer starts. Each offset is measured in shader constants, which are 16 bytes (4*32-bit components). Therefore, an offset of 2 indicates that the start of the associated constant buffer is 32 bytes into the constant buffer. The runtime sets pFirstConstant to null if the buffers do not have offsets.
A reference to an array that receives the numbers of constants in the buffers that ppConstantBuffers specifies. Each number specifies the number of constants that are contained in the constant buffer that the shader uses. Each number of constants starts from its respective offset that is specified in the pFirstConstant array. The runtime sets pNumConstants to null if it doesn't specify the numbers of constants in each buffer.
If no buffer is bound at a slot, pFirstConstant and pNumConstants are null for that slot.
void ID3D11DeviceContext1::GSGetConstantBuffers1([In] unsigned int StartSlot,[In] unsigned int NumBuffers,[Out, Buffer, Optional] ID3D11Buffer** ppConstantBuffers,[Out, Buffer, Optional] unsigned int* pFirstConstant,[Out, Buffer, Optional] unsigned int* pNumConstants)
[This documentation is preliminary and is subject to change.]
Index into the device's zero-based array to begin retrieving constant buffers from (ranges from 0 to - 1).
Number of buffers to retrieve (ranges from 0 to - StartSlot).
Array of constant buffer interface references to be returned by the method.
A reference to an array that receives the offsets into the buffers that ppConstantBuffers specifies. Each offset specifies where, from the shader's point of view, each constant buffer starts. Each offset is measured in shader constants, which are 16 bytes (4*32-bit components). Therefore, an offset of 2 indicates that the start of the associated constant buffer is 32 bytes into the constant buffer. The runtime sets pFirstConstant to null if the buffers do not have offsets.
A reference to an array that receives the numbers of constants in the buffers that ppConstantBuffers specifies. Each number specifies the number of constants that are contained in the constant buffer that the shader uses. Each number of constants starts from its respective offset that is specified in the pFirstConstant array. The runtime sets pNumConstants to null if it doesn't specify the numbers of constants in each buffer.
If no buffer is bound at a slot, pFirstConstant and pNumConstants are null for that slot.
void ID3D11DeviceContext1::PSGetConstantBuffers1([In] unsigned int StartSlot,[In] unsigned int NumBuffers,[Out, Buffer, Optional] ID3D11Buffer** ppConstantBuffers,[Out, Buffer, Optional] unsigned int* pFirstConstant,[Out, Buffer, Optional] unsigned int* pNumConstants)
[This documentation is preliminary and is subject to change.]
Index into the device's zero-based array to begin retrieving constant buffers from (ranges from 0 to - 1).
Number of buffers to retrieve (ranges from 0 to - StartSlot).
Array of constant buffer interface references to be returned by the method.
A reference to an array that receives the offsets into the buffers that ppConstantBuffers specifies. Each offset specifies where, from the shader's point of view, each constant buffer starts. Each offset is measured in shader constants, which are 16 bytes (4*32-bit components). Therefore, an offset of 2 indicates that the start of the associated constant buffer is 32 bytes into the constant buffer. The runtime sets pFirstConstant to null if the buffers do not have offsets.
A reference to an array that receives the numbers of constants in the buffers that ppConstantBuffers specifies. Each number specifies the number of constants that are contained in the constant buffer that the shader uses. Each number of constants starts from its respective offset that is specified in the pFirstConstant array. The runtime sets pNumConstants to null if it doesn't specify the numbers of constants in each buffer.
If no buffer is bound at a slot, pFirstConstant and pNumConstants are null for that slot.
void ID3D11DeviceContext1::CSGetConstantBuffers1([In] unsigned int StartSlot,[In] unsigned int NumBuffers,[Out, Buffer, Optional] ID3D11Buffer** ppConstantBuffers,[Out, Buffer, Optional] unsigned int* pFirstConstant,[Out, Buffer, Optional] unsigned int* pNumConstants)
[This documentation is preliminary and is subject to change.]
A reference to the interface for the context state object that was previously created through the method. If SwapDeviceContextState is called with pState set to null, the call has no effect.
A reference to a variable that receives a reference to the interface for the previously-activated context state object.
SwapDeviceContextState changes device behavior. This device behavior depends on the emulated interface that you passed to the EmulatedInterface parameter of the method when you created the context state object.SwapDeviceContextState disables the incompatible device interfaces , , , and . When a context state object is active, the runtime disables certain methods on the device and context interfaces. A context state object that is created with __uuidof() or __uuidof() turns off most of the Direct3D?10 device interfaces. A context state object that is created with __uuidof() or __uuidof() turns off most of the methods.
For more information about this behavior, see .SwapDeviceContextState activates the context state object specified by pState. This means that the device behaviors that are associated with the context state object's feature level and compatible interface are activated on the Microsoft Direct3D device until the next call to SwapDeviceContextState. In addition, any state that was saved when this context state object was last active is now reactivated, so that the previous state is replaced.SwapDeviceContextState sets ppPreviousState to the most recently activated context state object. The object allows the caller to save and then later restore the previous device state. This behavior is useful in a plug-in architecture such as Direct2D that shares a Direct3D device with its plug-ins. A Direct2D interface can use context state objects to save and restore the application's state.If the caller did not previously call the method to create a previous context state object, SwapDeviceContextState sets ppPreviousState to the default context state object. In either case, usage of SwapDeviceContextState is the same.The feature level that is specified by the application, and that is chosen by the context state object from the acceptable list that the application supplies to , controls the feature level of the immediate context whenever the context state object is active. Because the Direct3D?11 device is free-threaded, the context state objects cannot assert the device's feature level. Instead, the device runs at a feature level that is the maximum of all previously created context state objects' feature levels. This means that the device's feature level can increase dynamically.The feature level of the context state object controls the functionality available from the immediate context. However, to maintain the free-threaded contract of the Direct3D?11 device methods?the resource-creation methods in particular?the upper-bound feature level of all created context state objects controls the set of resources that the device creates.Because the context state object interface is published by the immediate context, the interface requires the same threading model as the immediate context. Specifically, SwapDeviceContextState is single-threaded with respect to the other immediate context methods and with respect to the equivalent methods of .Crucially, because only one of the Direct3D?10 or Direct3D?11 ref-count behaviors can be available at a time, one of the Direct3D?10 and Direct3D?11 interfaces must break its ref-count contract. To avoid this situation, the activation of a context state object turns off the incompatible version interface. Also, if you call a method of an incompatible version interface, the call silently fails if the method has return type void, returns an value of E_INVALIDARG, or sets any out parameter to null.When you switch from Direct3D?11 mode to either Direct3D?10 mode or Direct3D?10.1 mode, the binding behavior of the device changes. Specifically, the final release of a resource induces unbind in Direct3D?10 mode or Direct3D?10.1 mode. During final release an application releases all of the resource's references, including indirect references such as the linkage from view to resource, and the linkage from context state object to any of the context state object's bound resources. Any bound resource to which the application has no reference is unbound and destroyed, in order to maintain the Direct3D?10 behavior.SwapDeviceContextState does not affect any state that sets.If deferred contexts activate context state objects, only one context can use a context state object at a time, a condition that SwapDeviceContextState verifies. SwapDeviceContextState causes a sync across all contexts. Command lists that are generated by deferred contexts do not hold a reference to context state objects and are not affected by future updates to context state objects.No asynchronous objects are affected by SwapDeviceContextState. For example, if a query is active before a call to SwapDeviceContextState, it is still active after the call.
void ID3D11DeviceContext1::SwapDeviceContextState([In] ID3DDeviceContextState* pState,[Out, Optional] ID3DDeviceContextState** ppPreviousState)
[This documentation is preliminary and is subject to change.]
A reference to the interface that represents the resource view to clear.
A 4-component array that represents the color to use to clear the resource view.
An array of D3D11_RECT structures for the rectangles in the resource view to clear. If null, ClearView clears the entire surface.
Number of rectangles in the array that the pRect parameter specifies.
ClearView works only on render-target views (RTVs), unordered-access views (UAVs), or any video view of a Texture2D surface. The runtime drops invalid calls. ClearView applies the same color value to all array slices in the view. Each rectangle in the pRect array corresponds to each array slice.The runtime converts and clamps color values to the destination format as appropriate per Microsoft Direct3D conversion rules. For example, if the format of the view is , the runtime clamps inputs to 0.0f to 1.0f (INF/NaN -> 0).If the format is integer, such as , the runtime interprets inputs as integral floats. Therefore, 235.0f maps to 235 (rounds to zero, out of range/INF values clamp to target range, and NaN to 0).Here are the color mappings:Color[0]: R (or Y for video) Color[1]: G (or U/Cb for video) Color[2]: B (or V/Cr for video) Color[3]: AFor video views with YUV or YCbBr formats, ClearView doesn't convert color values. In situations where the format name doesn?t indicate _UNORM, _UINT, and so on, ClearView assumes _UINT. Therefore, 235.0f maps to 235 (rounds to zero, out of range/INF values clamp to target range, and NaN to 0).
void ID3D11DeviceContext1::ClearView([In] ID3D11View* pView,[In] const float* Color,[In, Buffer, Optional] const RECT* pRect,[In] unsigned int NumRects)
The interface represents a device context which generates rendering commands.
ID3D11DeviceContext
Initializes a new instance of the class.
The native pointer.
Bind an array of shader resources to the domain-shader stage.
Index into the device's zero-based array to begin setting shader resources to (ranges from 0 to - 1).
Number of shader resources to set. Up to a maximum of 128 slots are available for shader resources(ranges from 0 to - StartSlot).
Array of shader resource view interfaces to set to the device.
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 .The method will hold a reference to the interfaces passed in. This differs from the device state behavior in Direct3D 10.
void ID3D11DeviceContext::DSSetShaderResources([In] unsigned int StartSlot,[In] unsigned int NumViews,[In, Buffer, Optional] const void** ppShaderResourceViews)
Set a domain shader to the device.
Pointer to a domain shader (see ). Passing in null disables the shader for this pipeline stage.
A reference to an array of class-instance interfaces (see ). 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.
The number of class-instance interfaces in the array.
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.
void ID3D11DeviceContext::DSSetShader([In, Optional] ID3D11DomainShader* pDomainShader,[In, Buffer, Optional] const ID3D11ClassInstance** ppClassInstances,[In] unsigned int NumClassInstances)
Set a domain shader to the device.
Pointer to a domain shader (see ). Passing in null disables the shader for this pipeline stage.
A reference to an array of class-instance interfaces (see ). 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.
The number of class-instance interfaces in the array.
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.
void ID3D11DeviceContext::DSSetShader([In, Optional] ID3D11DomainShader* pDomainShader,[In, Buffer, Optional] const ID3D11ClassInstance** ppClassInstances,[In] unsigned int NumClassInstances)
Set an array of sampler states to the domain-shader stage.
Index into the device's zero-based array to begin setting samplers to (ranges from 0 to - 1).
Number of samplers in the array. Each pipeline stage has a total of 16 sampler slots available (ranges from 0 to - StartSlot).
Pointer to an array of sampler-state interfaces (see ). See Remarks.
Any sampler may be set to null; this invokes the default state, which is defined to be the following.
//Default sampler state:
SamplerDesc;
SamplerDesc.Filter = ;
SamplerDesc.AddressU = ;
SamplerDesc.AddressV = ;
SamplerDesc.AddressW = ;
SamplerDesc.MipLODBias = 0;
SamplerDesc.MaxAnisotropy = 1;
SamplerDesc.ComparisonFunc = ;
SamplerDesc.BorderColor[0] = 1.0f;
SamplerDesc.BorderColor[1] = 1.0f;
SamplerDesc.BorderColor[2] = 1.0f;
SamplerDesc.BorderColor[3] = 1.0f;
SamplerDesc.MinLOD = -FLT_MAX;
SamplerDesc.MaxLOD = FLT_MAX;
The method will hold a reference to the interfaces passed in. This differs from the device state behavior in Direct3D 10.
void ID3D11DeviceContext::DSSetSamplers([In] unsigned int StartSlot,[In] unsigned int NumSamplers,[In, Buffer, Optional] const void** ppSamplers)
Sets the constant buffers used by the domain-shader stage.
Index into the zero-based array to begin setting constant buffers to (ranges from 0 to - 1).
Number of buffers to set (ranges from 0 to - StartSlot).
Array of constant buffers (see ) being given to the device.
The method will hold a reference to the interfaces passed in. This differs from the device state behavior in Direct3D 10.The Direct3D 11.1 runtime, which is available starting with Windows Developer Preview, can bind a larger number of 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.
void ID3D11DeviceContext::DSSetConstantBuffers([In] unsigned int StartSlot,[In] unsigned int NumBuffers,[In, Buffer, Optional] const void** ppConstantBuffers)
Get the domain-shader resources.
Index into the device's zero-based array to begin getting shader resources from (ranges from 0 to - 1).
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 - StartSlot).
Array of shader resource view interfaces to be returned by the device.
Any returned interfaces will have their reference count incremented by one. Applications should call IUnknown::Release on the returned interfaces when they are no longer needed to avoid memory leaks.
void ID3D11DeviceContext::DSGetShaderResources([In] unsigned int StartSlot,[In] unsigned int NumViews,[Out, Buffer, Optional] ID3D11ShaderResourceView** ppShaderResourceViews)
Get the domain shader currently set on the device.
Address of a reference to a domain shader (see ) to be returned by the method.
Pointer to an array of class instance interfaces (see ).
The number of class-instance elements in the array.
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.
void ID3D11DeviceContext::DSGetShader([Out] ID3D11DomainShader** ppDomainShader,[Out, Buffer, Optional] ID3D11ClassInstance** ppClassInstances,[InOut] unsigned int* pNumClassInstances)
Get an array of sampler state interfaces from the domain-shader stage.
Index into a zero-based array to begin getting samplers from (ranges from 0 to - 1).
Number of samplers to get from a device context. Each pipeline stage has a total of 16 sampler slots available (ranges from 0 to - StartSlot).
Pointer to an array of sampler-state interfaces (see ).
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.
void ID3D11DeviceContext::DSGetSamplers([In] unsigned int StartSlot,[In] unsigned int NumSamplers,[Out, Buffer, Optional] ID3D11SamplerState** ppSamplers)
Get the constant buffers used by the domain-shader stage.
Index into the device's zero-based array to begin retrieving constant buffers from (ranges from 0 to - 1).
Number of buffers to retrieve (ranges from 0 to - StartSlot).
Array of constant buffer interface references (see ) to be returned by the method.
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.
void ID3D11DeviceContext::DSGetConstantBuffers([In] unsigned int StartSlot,[In] unsigned int NumBuffers,[Out, Buffer, Optional] ID3D11Buffer** ppConstantBuffers)
A geometry-shader interface manages an executable program (a geometry shader) that controls the geometry-shader stage.
ID3D11GeometryShader
Initializes a new instance of the class.
The native pointer.
Initializes a new instance of the class.
The device used to create the shader.
The compiled shader bytecode.
Initializes a new instance of the class.
The device used to create the shader.
The compiled shader bytecode.
A dynamic class linkage interface.
Initializes a new instance of the class.
The device used to create the shader.
The compiled shader bytecode.
An array of instances describing the layout of the output buffers.
An array of buffer strides; each stride is the size of an element for that buffer.
The index number of the stream to be sent to the rasterizer stage. Set to NoRasterizedStream if no stream is to be rasterized.
Initializes a new instance of the class.
The device used to create the shader.
The compiled shader bytecode.
An array of instances describing the layout of the output buffers.
An array of buffer strides; each stride is the size of an element for that buffer.
The index number of the stream to be sent to the rasterizer stage. Set to NoRasterizedStream if no stream is to be rasterized.
A dynamic class linkage interface.
The interface represents a device context which generates rendering commands.
ID3D11DeviceContext
Initializes a new instance of the class.
The native pointer.
Sets the constant buffers used by the geometry shader pipeline stage.
Index into the device's zero-based array to begin setting constant buffers to (ranges from 0 to - 1).
Number of buffers to set (ranges from 0 to - StartSlot).
Array of constant buffers (see ) being given to the device.
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 interface to get information about what is currently bound to the pipeline in the device context. But you can use to get information from a compiled shader. For example, you can use and to determine the slot in which a geometry shader expects a constant buffer. You can then pass this slot number to GSSetConstantBuffers to set the constant buffer. You can call the D3D11Reflect function to retrieve the address of a reference to the interface and then call to get a reference to .The Direct3D 11.1 runtime, which is available starting with Windows Developer Preview, can bind a larger number of 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.
void ID3D11DeviceContext::GSSetConstantBuffers([In] unsigned int StartSlot,[In] unsigned int NumBuffers,[In, Buffer, Optional] const void** ppConstantBuffers)
Set a geometry shader to the device.
Pointer to a geometry shader (see ). Passing in null disables the shader for this pipeline stage.
A reference to an array of class-instance interfaces (see ). 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.
The number of class-instance interfaces in the array.
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.
void ID3D11DeviceContext::GSSetShader([In, Optional] ID3D11GeometryShader* pShader,[In, Buffer, Optional] const ID3D11ClassInstance** ppClassInstances,[In] unsigned int NumClassInstances)
Set a geometry shader to the device.
Pointer to a geometry shader (see ). Passing in null disables the shader for this pipeline stage.
A reference to an array of class-instance interfaces (see ). 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.
The number of class-instance interfaces in the array.
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.
void ID3D11DeviceContext::GSSetShader([In, Optional] ID3D11GeometryShader* pShader,[In, Buffer, Optional] const ID3D11ClassInstance** ppClassInstances,[In] unsigned int NumClassInstances)
Bind an array of shader resources to the geometry shader stage.
Index into the device's zero-based array to begin setting shader resources to (ranges from 0 to - 1).
Number of shader resources to set. Up to a maximum of 128 slots are available for shader resources(ranges from 0 to - StartSlot).
Array of shader resource view interfaces to set to the device.
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 .The method will hold a reference to the interfaces passed in. This differs from the device state behavior in Direct3D 10.
void ID3D11DeviceContext::GSSetShaderResources([In] unsigned int StartSlot,[In] unsigned int NumViews,[In, Buffer, Optional] const void** ppShaderResourceViews)
Set an array of sampler states to the geometry shader pipeline stage.
Index into the device's zero-based array to begin setting samplers to (ranges from 0 to - 1).
Number of samplers in the array. Each pipeline stage has a total of 16 sampler slots available (ranges from 0 to - StartSlot).
Pointer to an array of sampler-state interfaces (see ). See Remarks.
Any sampler may be set to null; this invokes the default state, which is defined to be the following.
//Default sampler state:
SamplerDesc;
SamplerDesc.Filter = ;
SamplerDesc.AddressU = ;
SamplerDesc.AddressV = ;
SamplerDesc.AddressW = ;
SamplerDesc.MipLODBias = 0;
SamplerDesc.MaxAnisotropy = 1;
SamplerDesc.ComparisonFunc = ;
SamplerDesc.BorderColor[0] = 1.0f;
SamplerDesc.BorderColor[1] = 1.0f;
SamplerDesc.BorderColor[2] = 1.0f;
SamplerDesc.BorderColor[3] = 1.0f;
SamplerDesc.MinLOD = -FLT_MAX;
SamplerDesc.MaxLOD = FLT_MAX;
The method will hold a reference to the interfaces passed in. This differs from the device state behavior in Direct3D 10.
void ID3D11DeviceContext::GSSetSamplers([In] unsigned int StartSlot,[In] unsigned int NumSamplers,[In, Buffer, Optional] const void** ppSamplers)
Get the constant buffers used by the geometry shader pipeline stage.
Index into the device's zero-based array to begin retrieving constant buffers from (ranges from 0 to - 1).
Number of buffers to retrieve (ranges from 0 to - StartSlot).
Array of constant buffer interface references (see ) to be returned by the method.
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.
void ID3D11DeviceContext::GSGetConstantBuffers([In] unsigned int StartSlot,[In] unsigned int NumBuffers,[Out, Buffer, Optional] ID3D11Buffer** ppConstantBuffers)
Get the geometry shader currently set on the device.
Address of a reference to a geometry shader (see ) to be returned by the method.
Pointer to an array of class instance interfaces (see ).
The number of class-instance elements in the array.
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.
void ID3D11DeviceContext::GSGetShader([Out] ID3D11GeometryShader** ppGeometryShader,[Out, Buffer, Optional] ID3D11ClassInstance** ppClassInstances,[InOut] unsigned int* pNumClassInstances)
Get the geometry shader resources.
Index into the device's zero-based array to begin getting shader resources from (ranges from 0 to - 1).
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 - StartSlot).
Array of shader resource view interfaces to be returned by the device.
Any returned interfaces will have their reference count incremented by one. Applications should call IUnknown::Release on the returned interfaces when they are no longer needed to avoid memory leaks.
void ID3D11DeviceContext::GSGetShaderResources([In] unsigned int StartSlot,[In] unsigned int NumViews,[Out, Buffer, Optional] ID3D11ShaderResourceView** ppShaderResourceViews)
Get an array of sampler state interfaces from the geometry shader pipeline stage.
Index into a zero-based array to begin getting samplers from (ranges from 0 to - 1).
Number of samplers to get from a device context. Each pipeline stage has a total of 16 sampler slots available (ranges from 0 to - StartSlot).
Pointer to an array of sampler-state interfaces (see ).
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.
void ID3D11DeviceContext::GSGetSamplers([In] unsigned int StartSlot,[In] unsigned int NumSamplers,[Out, Buffer, Optional] ID3D11SamplerState** ppSamplers)
A hull-shader interface manages an executable program (a hull shader) that controls the hull-shader stage.
ID3D11HullShader
Initializes a new instance of the class.
The native pointer.
Initializes a new instance of the class.
The device used to create the shader.
The compiled shader bytecode.
Initializes a new instance of the class.
The device used to create the shader.
The compiled shader bytecode.
A dynamic class linkage interface.
The interface represents a device context which generates rendering commands.
ID3D11DeviceContext
Initializes a new instance of the class.
The native pointer.
Bind an array of shader resources to the hull-shader stage.
No documentation.
No documentation.
No documentation.
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 .The method will hold a reference to the interfaces passed in. This differs from the device state behavior in Direct3D 10.
void ID3D11DeviceContext::HSSetShaderResources([In] unsigned int StartSlot,[In] unsigned int NumViews,[In, Buffer, Optional] const void** ppShaderResourceViews)
Set a hull shader to the device.
Pointer to a hull shader (see ). Passing in null disables the shader for this pipeline stage.
A reference to an array of class-instance interfaces (see ). 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.
The number of class-instance interfaces in the array.
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.
void ID3D11DeviceContext::HSSetShader([In, Optional] ID3D11HullShader* pHullShader,[In, Buffer, Optional] const ID3D11ClassInstance** ppClassInstances,[In] unsigned int NumClassInstances)
Set a hull shader to the device.
Pointer to a hull shader (see ). Passing in null disables the shader for this pipeline stage.
A reference to an array of class-instance interfaces (see ). 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.
The number of class-instance interfaces in the array.
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.
void ID3D11DeviceContext::HSSetShader([In, Optional] ID3D11HullShader* pHullShader,[In, Buffer, Optional] const ID3D11ClassInstance** ppClassInstances,[In] unsigned int NumClassInstances)
Set an array of sampler states to the hull-shader stage.
No documentation.
No documentation.
No documentation.
Any sampler may be set to null; this invokes the default state, which is defined to be the following.
//Default sampler state:
SamplerDesc;
SamplerDesc.Filter = ;
SamplerDesc.AddressU = ;
SamplerDesc.AddressV = ;
SamplerDesc.AddressW = ;
SamplerDesc.MipLODBias = 0;
SamplerDesc.MaxAnisotropy = 1;
SamplerDesc.ComparisonFunc = ;
SamplerDesc.BorderColor[0] = 1.0f;
SamplerDesc.BorderColor[1] = 1.0f;
SamplerDesc.BorderColor[2] = 1.0f;
SamplerDesc.BorderColor[3] = 1.0f;
SamplerDesc.MinLOD = -FLT_MAX;
SamplerDesc.MaxLOD = FLT_MAX;
The method will hold a reference to the interfaces passed in. This differs from the device state behavior in Direct3D 10.
void ID3D11DeviceContext::HSSetSamplers([In] unsigned int StartSlot,[In] unsigned int NumSamplers,[In, Buffer, Optional] const void** ppSamplers)
Set the constant buffers used by the hull-shader stage.
No documentation.
No documentation.
No documentation.
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 Developer Preview, can bind a larger number of 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.
void ID3D11DeviceContext::HSSetConstantBuffers([In] unsigned int StartSlot,[In] unsigned int NumBuffers,[In, Buffer, Optional] const void** ppConstantBuffers)
Get the hull-shader resources.
Index into the device's zero-based array to begin getting shader resources from (ranges from 0 to - 1).
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 - StartSlot).
Array of shader resource view interfaces to be returned by the device.
Any returned interfaces will have their reference count incremented by one. Applications should call IUnknown::Release on the returned interfaces when they are no longer needed to avoid memory leaks.
void ID3D11DeviceContext::HSGetShaderResources([In] unsigned int StartSlot,[In] unsigned int NumViews,[Out, Buffer, Optional] ID3D11ShaderResourceView** ppShaderResourceViews)
Get the hull shader currently set on the device.
Address of a reference to a hull shader (see ) to be returned by the method.
Pointer to an array of class instance interfaces (see ).
The number of class-instance elements in the array.
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.
void ID3D11DeviceContext::HSGetShader([Out] ID3D11HullShader** ppHullShader,[Out, Buffer, Optional] ID3D11ClassInstance** ppClassInstances,[InOut] unsigned int* pNumClassInstances)
Get an array of sampler state interfaces from the hull-shader stage.
No documentation.
No documentation.
No documentation.
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.
void ID3D11DeviceContext::HSGetSamplers([In] unsigned int StartSlot,[In] unsigned int NumSamplers,[Out, Buffer, Optional] ID3D11SamplerState** ppSamplers)
Get the constant buffers used by the hull-shader stage.
No documentation.
No documentation.
No documentation.
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.
void ID3D11DeviceContext::HSGetConstantBuffers([In] unsigned int StartSlot,[In] unsigned int NumBuffers,[Out, Buffer, Optional] ID3D11Buffer** ppConstantBuffers)
[This documentation is preliminary and is subject to change.]
ID3DDeviceContextState
Initializes a new instance of the class.
The native pointer.
[This documentation is preliminary and is subject to change.]
ID3DUserDefinedAnnotation
Initializes a new instance of the class.
The native pointer.
[This documentation is preliminary and is subject to change.]
A null-terminated UNICODE string that contains the name of the event. The name is not relevant to the operating system. You can choose a name that is meaningful when the calling application is running under the Direct3D profiling tool.A null reference produces undefined results.
Returns the number of previous calls to BeginEvent that have not yet been finalized by calls to the method.The return value is ?1 if the calling application is not running under a Direct3D profiling tool.
You call the EndEvent method to mark the end of the section of event code.A user can visualize the event when the calling application is running under an enabled Direct3D profiling tool such as Microsoft Visual Studio 11 Ultimate Developer Preview.BeginEvent has no effect if the calling application is not running under an enabled Direct3D profiling tool.
int ID3DUserDefinedAnnotation::BeginEvent([In] const wchar_t* Name)
No documentation.
No documentation.
int ID3DUserDefinedAnnotation::EndEvent()
[This documentation is preliminary and is subject to change.]
A null-terminated UNICODE string that contains the name of the marker. The name is not relevant to the operating system. You can choose a name that is meaningful when the calling application is running under the Direct3D profiling tool.A null reference produces undefined results.
A user can visualize the marker when the calling application is running under an enabled Direct3D profiling tool such as Microsoft Visual Studio 11 Ultimate Developer Preview.SetMarker has no effect if the calling application is not running under an enabled Direct3D profiling tool.
void ID3DUserDefinedAnnotation::SetMarker([In] const wchar_t* Name)
[This documentation is preliminary and is subject to change.]
The return value is nonzero if the calling application is running under a Direct3D profiling tool such as Visual Studio 11 Ultimate Developer Preview, and zero otherwise.
You can call GetStatus to determine whether your application is running under a Direct3D profiling tool before you make further calls to other methods of the interface. For example, the and methods have no effect if the calling application is not running under an enabled Direct3D profiling tool. Therefore, you do not need to call these methods unless your application is running under a Direct3D profiling tool.
BOOL ID3DUserDefinedAnnotation::GetStatus()
[This documentation is preliminary and is subject to change.]
A user can visualize the marker when the calling application is running under an enabled Direct3D profiling tool such as Microsoft Visual Studio 11 Ultimate Developer Preview.SetMarker has no effect if the calling application is not running under an enabled Direct3D profiling tool.
SetMarker
void ID3DUserDefinedAnnotation::SetMarker([In] const wchar_t* Name)
[This documentation is preliminary and is subject to change.]
You can call GetStatus to determine whether your application is running under a Direct3D profiling tool before you make further calls to other methods of the interface. For example, the and methods have no effect if the calling application is not running under an enabled Direct3D profiling tool. Therefore, you do not need to call these methods unless your application is running under a Direct3D profiling tool.
GetStatus
BOOL ID3DUserDefinedAnnotation::GetStatus()
An input-layout interface holds a definition of how to feed vertex data that is laid out in memory into the input-assembler stage of the graphics pipeline.
ID3D11InputLayout
Initializes a new instance of the class.
The native pointer.
Initializes a new instance of the object to describe the
input-buffer data for the input-assembler stage.
ID3D11Device::CreateInputLayout
The device used to create the layout.
An array of input elements describing the layout of the input data.
The compiled shader used to validate the input elements.
Initializes a new instance of the object to describe the
input-buffer data for the input-assembler stage.
ID3D11Device::CreateInputLayout
The device used to create the layout.
An array of input elements describing the layout of the input data.
The shader signature used to validate the input elements.
A pixel-shader interface manages an executable program (a pixel shader) that controls the pixel-shader stage.
ID3D11PixelShader
Initializes a new instance of the class.
The native pointer.
Initializes a new instance of the class.
The device used to create the shader.
The compiled shader bytecode.
Initializes a new instance of the class.
The device used to create the shader.
The compiled shader bytecode.
A dynamic class linkage interface.
The interface represents a device context which generates rendering commands.
ID3D11DeviceContext
Initializes a new instance of the class.
The native pointer.
Bind an array of shader resources to the pixel shader stage.
Index into the device's zero-based array to begin setting shader resources to (ranges from 0 to - 1).
Number of shader resources to set. Up to a maximum of 128 slots are available for shader resources (ranges from 0 to - StartSlot).
Array of shader resource view interfaces to set to the device.
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 .The method will hold a reference to the interfaces passed in. This differs from the device state behavior in Direct3D 10.
void ID3D11DeviceContext::PSSetShaderResources([In] unsigned int StartSlot,[In] unsigned int NumViews,[In, Buffer, Optional] const void** ppShaderResourceViews)
Sets a pixel shader to the device.
Pointer to a pixel shader (see ). Passing in null disables the shader for this pipeline stage.
A reference to an array of class-instance interfaces (see ). 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.
The number of class-instance interfaces in the array.
The method will hold a reference to the interfaces passed in. This differs from the device state behavior in Direct3D 10.The maximum number of instances a shader can have is 256.Set ppClassInstances to null if no interfaces are used in the shader. If it is not null, the number of class instances must match the number of interfaces used in the shader. Furthermore, each interface reference must have a corresponding class instance or the assigned shader will be disabled.
void ID3D11DeviceContext::PSSetShader([In, Optional] ID3D11PixelShader* pPixelShader,[In, Buffer, Optional] const ID3D11ClassInstance** ppClassInstances,[In] unsigned int NumClassInstances)
Sets a pixel shader to the device.
Pointer to a pixel shader (see ). Passing in null disables the shader for this pipeline stage.
A reference to an array of class-instance interfaces (see ). 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.
The number of class-instance interfaces in the array.
The method will hold a reference to the interfaces passed in. This differs from the device state behavior in Direct3D 10.The maximum number of instances a shader can have is 256.Set ppClassInstances to null if no interfaces are used in the shader. If it is not null, the number of class instances must match the number of interfaces used in the shader. Furthermore, each interface reference must have a corresponding class instance or the assigned shader will be disabled.
void ID3D11DeviceContext::PSSetShader([In, Optional] ID3D11PixelShader* pPixelShader,[In, Buffer, Optional] const ID3D11ClassInstance** ppClassInstances,[In] unsigned int NumClassInstances)
Set an array of sampler states to the pixel shader pipeline stage.
Index into the device's zero-based array to begin setting samplers to (ranges from 0 to - 1).
Number of samplers in the array. Each pipeline stage has a total of 16 sampler slots available (ranges from 0 to - StartSlot).
Pointer to an array of sampler-state interfaces (see ). See Remarks.
Any sampler may be set to null; this invokes the default state, which is defined to be the following.StateDefault Value FilterD3D11_FILTER_MIN_MAG_MIP_LINEAR AddressUD3D11_TEXTURE_ADDRESS_CLAMP AddressVD3D11_TEXTURE_ADDRESS_CLAMP AddressWD3D11_TEXTURE_ADDRESS_CLAMP MipLODBias0 MaxAnisotropy1 ComparisonFuncD3D11_COMPARISON_NEVER BorderColor[0]1.0f BorderColor[1]1.0f BorderColor[2]1.0f BorderColor[3]1.0f MinLOD-FLT_MAX MaxLODFLT_MAX?The method will hold a reference to the interfaces passed in. This differs from the device state behavior in Direct3D 10.
void ID3D11DeviceContext::PSSetSamplers([In] unsigned int StartSlot,[In] unsigned int NumSamplers,[In, Buffer, Optional] const void** ppSamplers)
Sets the constant buffers used by the pixel shader pipeline stage.
Index into the device's zero-based array to begin setting constant buffers to (ranges from 0 to - 1).
Number of buffers to set (ranges from 0 to - StartSlot).
Array of constant buffers (see ) being given to the device.
The method will hold a reference to the interfaces passed in. This differs from the device state behavior in Direct3D 10.The Direct3D 11.1 runtime, which is available on Windows Developer Preview and later operating systems, can bind a larger number of 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 PSSetConstantBuffers1 method instead.
void ID3D11DeviceContext::PSSetConstantBuffers([In] unsigned int StartSlot,[In] unsigned int NumBuffers,[In, Buffer, Optional] const void** ppConstantBuffers)
Get the pixel shader resources.
Index into the device's zero-based array to begin getting shader resources from (ranges from 0 to - 1).
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 - StartSlot).
Array of shader resource view interfaces to be returned by the device.
Any returned interfaces will have their reference count incremented by one. Applications should call IUnknown::Release on the returned interfaces when they are no longer needed to avoid memory leaks.
void ID3D11DeviceContext::PSGetShaderResources([In] unsigned int StartSlot,[In] unsigned int NumViews,[Out, Buffer, Optional] ID3D11ShaderResourceView** ppShaderResourceViews)
Get the pixel shader currently set on the device.
Address of a reference to a pixel shader (see ) to be returned by the method.
Pointer to an array of class instance interfaces (see ).
The number of class-instance elements in the array.
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.
void ID3D11DeviceContext::PSGetShader([Out] ID3D11PixelShader** ppPixelShader,[Out, Buffer, Optional] ID3D11ClassInstance** ppClassInstances,[InOut] unsigned int* pNumClassInstances)
Get an array of sampler states from the pixel shader pipeline stage.
Index into a zero-based array to begin getting samplers from (ranges from 0 to - 1).
Number of samplers to get from a device context. Each pipeline stage has a total of 16 sampler slots available (ranges from 0 to - StartSlot).
Arry of sampler-state interface references (see ) to be returned by the device.
Any returned interfaces will have their reference count incremented by one. Applications should call IUnknown::Release on the returned interfaces when they are no longer needed to avoid memory leaks.
void ID3D11DeviceContext::PSGetSamplers([In] unsigned int StartSlot,[In] unsigned int NumSamplers,[Out, Buffer, Optional] ID3D11SamplerState** ppSamplers)
Get the constant buffers used by the pixel shader pipeline stage.
Index into the device's zero-based array to begin retrieving constant buffers from (ranges from 0 to - 1).
Number of buffers to retrieve (ranges from 0 to - StartSlot).
Array of constant buffer interface references (see ) to be returned by the method.
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.
void ID3D11DeviceContext::PSGetConstantBuffers([In] unsigned int StartSlot,[In] unsigned int NumBuffers,[Out, Buffer, Optional] ID3D11Buffer** ppConstantBuffers)
A predicate interface determines whether geometry should be processed depending on the results of a previous draw call.
ID3D11Predicate
A query interface queries information from the GPU.
ID3D11Query
Initializes a new instance of the class.
The native pointer.
Get a query description.
Pointer to a query description (see ).
void ID3D11Query::GetDesc([Out] D3D11_QUERY_DESC* pDesc)
Constructs a new based on the specified description.
The device with which to associate the state object.
The query description.
The newly created object.
Get a query description.
GetDesc
void ID3D11Query::GetDesc([Out] D3D11_QUERY_DESC* pDesc)
Initializes a new instance of the class.
The native pointer.
Constructs a new based on the specified description.
The device with which to associate the state object.
The query description.
The newly created object.
The rasterizer-state interface holds a description for rasterizer state that you can bind to the rasterizer stage.
ID3D11RasterizerState
Initializes a new instance of the class.
The native pointer.
Gets the description for rasterizer state that you used to create the rasterizer-state object.
A reference to a structure that receives a description of the rasterizer state.
You use the description for rasterizer state in a call to the method to create the rasterizer-state object.
void ID3D11RasterizerState::GetDesc([Out] D3D11_RASTERIZER_DESC* pDesc)
Constructs a new based on the specified description.
The device with which to associate the state object.
The state description.
The newly created object.
Constructs a new based on the specified description.
The device with which to associate the state object.
The state description.
The newly created object.
Gets the description for rasterizer state that you used to create the rasterizer-state object.
You use the description for rasterizer state in a call to the method to create the rasterizer-state object.
GetDesc
void ID3D11RasterizerState::GetDesc([Out] D3D11_RASTERIZER_DESC* pDesc)
[This documentation is preliminary and is subject to change.]
ID3D11RasterizerState1
Initializes a new instance of the class.
The native pointer.
No documentation.
No documentation.
void ID3D11RasterizerState1::GetDesc1([Out] D3D11_RASTERIZER_DESC1* pDesc)
No documentation.
GetDesc1
void ID3D11RasterizerState1::GetDesc1([Out] D3D11_RASTERIZER_DESC1* pDesc)
A render-target-view interface identifies the render-target subresources that can be accessed during rendering.
ID3D11RenderTargetView
Initializes a new instance of the class.
The native pointer.
Get the properties of a render target view.
Pointer to the description of a render target view (see ).
void ID3D11RenderTargetView::GetDesc([Out] D3D11_RENDER_TARGET_VIEW_DESC* pDesc)
Creates a for accessing resource data.
The device to use when creating this .
The resource that represents the render-target surface. This surface must have been created with the RenderTarget flag.
ID3D11Device::CreateRenderTargetView
Creates a for accessing resource data.
The device to use when creating this .
The resource that represents the render-target surface. This surface must have been created with the RenderTarget flag.
A structure describing the to be created.
ID3D11Device::CreateRenderTargetView
Get the properties of a render target view.
GetDesc
void ID3D11RenderTargetView::GetDesc([Out] D3D11_RENDER_TARGET_VIEW_DESC* pDesc)
The sampler-state interface holds a description for sampler state that you can bind to any shader stage of the pipeline for reference by texture sample operations.
ID3D11SamplerState
Initializes a new instance of the class.
The native pointer.
Gets the description for sampler state that you used to create the sampler-state object.
A reference to a structure that receives a description of the sampler state.
You use the description for sampler state in a call to the method to create the sampler-state object.
void ID3D11SamplerState::GetDesc([Out] D3D11_SAMPLER_DESC* pDesc)
Constructs a new based on the specified description.
The device with which to associate the state object.
The state description.
The newly created object.
Constructs a new based on the specified description.
The device with which to associate the state object.
The state description.
The newly created object.
Gets the description for sampler state that you used to create the sampler-state object.
You use the description for sampler state in a call to the method to create the sampler-state object.
GetDesc
void ID3D11SamplerState::GetDesc([Out] D3D11_SAMPLER_DESC* pDesc)
A shader-resource-view interface specifies the subresources a shader can access during rendering. Examples of shader resources include a constant buffer, a texture buffer, a texture or a sampler.
ID3D11ShaderResourceView
Initializes a new instance of the class.
The native pointer.
Get the shader resource view's description.
A reference to a structure to be filled with data about the shader resource view.
void ID3D11ShaderResourceView::GetDesc([Out] D3D11_SHADER_RESOURCE_VIEW_DESC* pDesc)
Creates a for accessing resource data.
The device to use when creating this .
The resource that represents the render-target surface. This surface must have been created with the ShaderResource flag.
ID3D11Device::CreateShaderResourceView
Creates a for accessing resource data.
The device to use when creating this .
The resource that represents the render-target surface. This surface must have been created with the ShaderResource flag.
A structure describing the to be created.
ID3D11Device::CreateShaderResourceView
Get the shader resource view's description.
GetDesc
void ID3D11ShaderResourceView::GetDesc([Out] D3D11_SHADER_RESOURCE_VIEW_DESC* pDesc)
A 1D texture interface accesses texel data, which is structured memory.
ID3D11Texture1D
Initializes a new instance of the class.
The native pointer.
Get the properties of the texture resource.
Pointer to a resource description (see ).
void ID3D11Texture1D::GetDesc([Out] D3D11_TEXTURE1D_DESC* pDesc)
Initializes a new instance of the class.
The device with which to associate the texture.
The description of the texture.
Initializes a new instance of the class.
The device with which to associate the texture.
The description of the texture.
An array of initial texture data for each subresource.
Get the properties of the texture resource.
GetDesc
void ID3D11Texture1D::GetDesc([Out] D3D11_TEXTURE1D_DESC* pDesc)
A 2D texture interface manages texel data, which is structured memory.
ID3D11Texture2D
Initializes a new instance of the class.
The native pointer.
Get the properties of the texture resource.
Pointer to a resource description (see ).
void ID3D11Texture2D::GetDesc([Out] D3D11_TEXTURE2D_DESC* pDesc)
Initializes a new instance of the class.
The device with which to associate the texture.
The description of the texture.
Initializes a new instance of the class.
The device with which to associate the texture.
The description of the texture.
An array of initial texture data for each subresource.
Get the properties of the texture resource.
GetDesc
void ID3D11Texture2D::GetDesc([Out] D3D11_TEXTURE2D_DESC* pDesc)
A 3D texture interface accesses texel data, which is structured memory.
ID3D11Texture3D
Initializes a new instance of the class.
The native pointer.
Get the properties of the texture resource.
Pointer to a resource description (see ).
void ID3D11Texture3D::GetDesc([Out] D3D11_TEXTURE3D_DESC* pDesc)
Initializes a new instance of the class.
The device with which to associate the texture.
The description of the texture.
Initializes a new instance of the class.
The device with which to associate the texture.
The description of the texture.
An array of initial texture data for each subresource.
Get the properties of the texture resource.
GetDesc
void ID3D11Texture3D::GetDesc([Out] D3D11_TEXTURE3D_DESC* pDesc)
A view interface specifies the parts of a resource the pipeline can access during rendering.
ID3D11UnorderedAccessView
Initializes a new instance of the class.
The native pointer.
Get a description of the resource.
Pointer to a resource description (see .)
void ID3D11UnorderedAccessView::GetDesc([Out] D3D11_UNORDERED_ACCESS_VIEW_DESC* pDesc)
Creates a for accessing resource data.
The device to use when creating this .
The resource that represents the render-target surface. This surface must have been created with the UnorderedAccess flag.
ID3D11Device::CreateUnorderedAccessView
Creates a for accessing resource data.
The device to use when creating this .
The resource that represents the render-target surface. This surface must have been created with the UnorderedAccess flag.
A structure describing the to be created.
ID3D11Device::CreateUnorderedAccessView
Get a description of the resource.
GetDesc
void ID3D11UnorderedAccessView::GetDesc([Out] D3D11_UNORDERED_ACCESS_VIEW_DESC* pDesc)
A vertex-shader interface manages an executable program (a vertex shader) that controls the vertex-shader stage.
ID3D11VertexShader
Initializes a new instance of the class.
The native pointer.
Initializes a new instance of the class.
The device used to create the shader.
The compiled shader bytecode.
Initializes a new instance of the class.
The device used to create the shader.
The compiled shader bytecode.
A dynamic class linkage interface.
The interface represents a device context which generates rendering commands.
ID3D11DeviceContext
Initializes a new instance of the class.
The native pointer.
Sets the constant buffers used by the vertex shader pipeline stage.
Index into the device's zero-based array to begin setting constant buffers to (ranges from 0 to - 1).
Number of buffers to set (ranges from 0 to - StartSlot).
Array of constant buffers (see ) being given to the device.
The method will hold a reference to the interfaces passed in. This differs from the device state behavior in Direct3D 10.The Direct3D 11.1 runtime, which is available starting with Windows Developer Preview, can bind a larger number of 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.
void ID3D11DeviceContext::VSSetConstantBuffers([In] unsigned int StartSlot,[In] unsigned int NumBuffers,[In, Buffer, Optional] const void** ppConstantBuffers)
Set a vertex shader to the device.
Pointer to a vertex shader (see ). Passing in null disables the shader for this pipeline stage.
A reference to an array of class-instance interfaces (see ). 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.
The number of class-instance interfaces in the array.
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.
void ID3D11DeviceContext::VSSetShader([In, Optional] ID3D11VertexShader* pVertexShader,[In, Buffer, Optional] const ID3D11ClassInstance** ppClassInstances,[In] unsigned int NumClassInstances)
Set a vertex shader to the device.
Pointer to a vertex shader (see ). Passing in null disables the shader for this pipeline stage.
A reference to an array of class-instance interfaces (see ). 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.
The number of class-instance interfaces in the array.
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.
void ID3D11DeviceContext::VSSetShader([In, Optional] ID3D11VertexShader* pVertexShader,[In, Buffer, Optional] const ID3D11ClassInstance** ppClassInstances,[In] unsigned int NumClassInstances)
Bind an array of shader resources to the vertex-shader stage.
Index into the device's zero-based array to begin setting shader resources to (range is from 0 to - 1).
Number of shader resources to set. Up to a maximum of 128 slots are available for shader resources (range is from 0 to - StartSlot).
Array of shader resource view interfaces to set to the device.
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 .The method will hold a reference to the interfaces passed in. This differs from the device state behavior in Direct3D 10.
void ID3D11DeviceContext::VSSetShaderResources([In] unsigned int StartSlot,[In] unsigned int NumViews,[In, Buffer, Optional] const void** ppShaderResourceViews)
Set an array of sampler states to the vertex shader pipeline stage.
Index into the device's zero-based array to begin setting samplers to (ranges from 0 to - 1).
Number of samplers in the array. Each pipeline stage has a total of 16 sampler slots available (ranges from 0 to - StartSlot).
Pointer to an array of sampler-state interfaces (see ). See Remarks.
Any sampler may be set to null; this invokes the default state, which is defined to be the following.
//Default sampler state:
SamplerDesc;
SamplerDesc.Filter = ;
SamplerDesc.AddressU = ;
SamplerDesc.AddressV = ;
SamplerDesc.AddressW = ;
SamplerDesc.MipLODBias = 0;
SamplerDesc.MaxAnisotropy = 1;
SamplerDesc.ComparisonFunc = ;
SamplerDesc.BorderColor[0] = 1.0f;
SamplerDesc.BorderColor[1] = 1.0f;
SamplerDesc.BorderColor[2] = 1.0f;
SamplerDesc.BorderColor[3] = 1.0f;
SamplerDesc.MinLOD = -FLT_MAX;
SamplerDesc.MaxLOD = FLT_MAX;
The method will hold a reference to the interfaces passed in. This differs from the device state behavior in Direct3D 10.
void ID3D11DeviceContext::VSSetSamplers([In] unsigned int StartSlot,[In] unsigned int NumSamplers,[In, Buffer, Optional] const void** ppSamplers)
Get the constant buffers used by the vertex shader pipeline stage.
Index into the device's zero-based array to begin retrieving constant buffers from (ranges from 0 to - 1).
Number of buffers to retrieve (ranges from 0 to - StartSlot).
Array of constant buffer interface references (see ) to be returned by the method.
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.
void ID3D11DeviceContext::VSGetConstantBuffers([In] unsigned int StartSlot,[In] unsigned int NumBuffers,[Out, Buffer, Optional] ID3D11Buffer** ppConstantBuffers)
Get the vertex shader currently set on the device.
Address of a reference to a vertex shader (see ) to be returned by the method.
Pointer to an array of class instance interfaces (see ).
The number of class-instance elements in the array.
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.
void ID3D11DeviceContext::VSGetShader([Out] ID3D11VertexShader** ppVertexShader,[Out, Buffer, Optional] ID3D11ClassInstance** ppClassInstances,[InOut] unsigned int* pNumClassInstances)
Get the vertex shader resources.
Index into the device's zero-based array to begin getting shader resources from (ranges from 0 to - 1).
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 - StartSlot).
Array of shader resource view interfaces to be returned by the device.
Any returned interfaces will have their reference count incremented by one. Applications should call IUnknown::Release on the returned interfaces when they are no longer needed to avoid memory leaks.
void ID3D11DeviceContext::VSGetShaderResources([In] unsigned int StartSlot,[In] unsigned int NumViews,[Out, Buffer, Optional] ID3D11ShaderResourceView** ppShaderResourceViews)
Get an array of sampler states from the vertex shader pipeline stage.
Index into a zero-based array to begin getting samplers from (ranges from 0 to - 1).
Number of samplers to get from a device context. Each pipeline stage has a total of 16 sampler slots available (ranges from 0 to - StartSlot).
Arry of sampler-state interface references (see ) to be returned by the device.
Any returned interfaces will have their reference count incremented by one. Applications should call IUnknown::Release on the returned interfaces when they are no longer needed to avoid memory leaks.
void ID3D11DeviceContext::VSGetSamplers([In] unsigned int StartSlot,[In] unsigned int NumSamplers,[Out, Buffer, Optional] ID3D11SamplerState** ppSamplers)
[This documentation is preliminary and is subject to change.]
ID3D11VideoContext
Initializes a new instance of the class.
The native pointer.
[This documentation is preliminary and is subject to change.]
A reference to the interface. To get this reference, call .
The type of buffer to retrieve, specified as a member of the enumeration.
Receives the size of the buffer, in bytes.
Receives a reference to the start of the memory buffer.
If this method succeeds, it returns . Otherwise, it returns an error code.
The graphics driver allocates the buffers that are used for DXVA decoding. This method locks the Microsoft Direct3D surface that contains the buffer. When you are done using the buffer, call to unlock the surface.
HRESULT ID3D11VideoContext::GetDecoderBuffer([In] ID3D11VideoDecoder* pDecoder,[In] D3D11_VIDEO_DECODER_BUFFER_TYPE Type,[Out] unsigned int* pBufferSize,[Out, Buffer, Optional] void** ppBuffer)
No documentation.
No documentation.
No documentation.
No documentation.
HRESULT ID3D11VideoContext::ReleaseDecoderBuffer([In] ID3D11VideoDecoder* pDecoder,[In] D3D11_VIDEO_DECODER_BUFFER_TYPE Type)
No documentation.
No documentation.
No documentation.
No documentation.
No documentation.
No documentation.
HRESULT ID3D11VideoContext::DecoderBeginFrame([In] ID3D11VideoDecoder* pDecoder,[In] ID3D11VideoDecoderOutputView* pView,[In] unsigned int ContentKeySize,[In, Buffer, Optional] const void* pContentKey)
[This documentation is preliminary and is subject to change.]
A reference to the interface. To get this reference, call .
If this method succeeds, it returns . Otherwise, it returns an error code.
HRESULT ID3D11VideoContext::DecoderEndFrame([In] ID3D11VideoDecoder* pDecoder)
[This documentation is preliminary and is subject to change.]
A reference to the interface. To get this reference, call the method.
The number of buffers submitted for decoding.
A reference to an array of structures. The NumBuffers parameter specifies the number of elements in the array. Each element in the array describes a compressed buffer for decoding.
If this method succeeds, it returns . Otherwise, it returns an error code.
HRESULT ID3D11VideoContext::SubmitDecoderBuffers([In] ID3D11VideoDecoder* pDecoder,[In] unsigned int NumBuffers,[In, Buffer] const D3D11_VIDEO_DECODER_BUFFER_DESC* pBufferDesc)
[This documentation is preliminary and is subject to change.]
A reference to the interface. To get this reference, call .
A reference to a structure that contains data for the function.
If this method succeeds, it returns . Otherwise, it returns an error code.
HRESULT ID3D11VideoContext::DecoderExtension([In] ID3D11VideoDecoder* pDecoder,[In] const D3D11_VIDEO_DECODER_EXTENSION* pExtensionData)
[This documentation is preliminary and is subject to change.]
A reference to the interface. To get this reference, call .
Specifies whether to apply the target rectangle.
A reference to a structure that specifies the target rectangle. If Enable is , this parameter is ignored.
The target rectangle is the area within the destination surface where the output will be drawn. The target rectangle is given in pixel coordinates, relative to the destination surface.If this method is never called, or if the Enable parameter is , the video processor writes to the entire destination surface.
void ID3D11VideoContext::VideoProcessorSetOutputTargetRect([In] ID3D11VideoProcessor* pVideoProcessor,[In] BOOL Enable,[In, Optional] const RECT* pRect)
No documentation.
No documentation.
No documentation.
No documentation.
void ID3D11VideoContext::VideoProcessorSetOutputBackgroundColor([In] ID3D11VideoProcessor* pVideoProcessor,[In] BOOL YCbCr,[In] const D3D11_VIDEO_COLOR* pColor)
[This documentation is preliminary and is subject to change.]
A reference to the interface. To get this reference, call .
A reference to a structure that specifies the color space.
void ID3D11VideoContext::VideoProcessorSetOutputColorSpace([In] ID3D11VideoProcessor* pVideoProcessor,[In] const D3D11_VIDEO_PROCESSOR_COLOR_SPACE* pColorSpace)
[This documentation is preliminary and is subject to change.]
A reference to the interface. To get this reference, call .
The alpha fill mode, specified as a value.
The zero-based index of an input stream. This parameter is used if AlphaFillMode is . Otherwise, the parameter is ignored.
To find out which fill modes the device supports, call the method. If the driver reports the capability, the driver supports all of the fill modes. Otherwise, the AlphaFillMode parameter must be .The default fill mode is .
void ID3D11VideoContext::VideoProcessorSetOutputAlphaFillMode([In] ID3D11VideoProcessor* pVideoProcessor,[In] D3D11_VIDEO_PROCESSOR_ALPHA_FILL_MODE AlphaFillMode,[In] unsigned int StreamIndex)
[This documentation is preliminary and is subject to change.]
A reference to the interface. To get this reference, call .
If TRUE, downsampling is enabled. Otherwise, downsampling is disabled and the Size member is ignored.
The sampling size.
Downsampling is sometimes used to reduce the quality of premium content when other forms of content protection are not available. By default, downsampling is disabled.If the Enable parameter is TRUE, the driver downsamples the composed image to the specified size, and then scales it back to the size of the target rectangle.The width and height of Size must be greater than zero. If the size is larger than the target rectangle, downsampling does not occur.To use this feature, the driver must support downsampling, indicated by the capability flag. To query for this capability, call .
void ID3D11VideoContext::VideoProcessorSetOutputConstriction([In] ID3D11VideoProcessor* pVideoProcessor,[In] BOOL Enable,[In] SIZE Size)
[This documentation is preliminary and is subject to change.]
A reference to the interface. To get this reference, call .
If TRUE, stereo output is enabled. Otherwise, the video processor produces mono video frames.
By default, the video processor produces mono video frames. If stereo video is enabled, set the stereo output format by calling .To use this feature, the driver must support stereo video, indicated by the capability flag. To query for this capability, call .
void ID3D11VideoContext::VideoProcessorSetOutputStereoMode([In] ID3D11VideoProcessor* pVideoProcessor,[In] BOOL Enable)
No documentation.
No documentation.
No documentation.
No documentation.
No documentation.
No documentation.
HRESULT ID3D11VideoContext::VideoProcessorSetOutputExtension([In] ID3D11VideoProcessor* pVideoProcessor,[In] const GUID* pExtensionGuid,[In] unsigned int DataSize,[In] void* pData)
No documentation.
No documentation.
No documentation.
No documentation.
void ID3D11VideoContext::VideoProcessorGetOutputTargetRect([In] ID3D11VideoProcessor* pVideoProcessor,[Out] BOOL* Enabled,[Out] RECT* pRect)
[This documentation is preliminary and is subject to change.]
A reference to the interface. To get this reference, call .
Receives the value TRUE if the background color is a YCbCr color, or if the background color is an RGB color.
A reference to a structure. The method fills in the structure with the background color.
void ID3D11VideoContext::VideoProcessorGetOutputBackgroundColor([In] ID3D11VideoProcessor* pVideoProcessor,[Out] BOOL* pYCbCr,[Out] D3D11_VIDEO_COLOR* pColor)
No documentation.
No documentation.
No documentation.
void ID3D11VideoContext::VideoProcessorGetOutputColorSpace([In] ID3D11VideoProcessor* pVideoProcessor,[Out] D3D11_VIDEO_PROCESSOR_COLOR_SPACE* pColorSpace)
[This documentation is preliminary and is subject to change.]
A reference to the interface. To get this reference, call .
Receives the alpha fill mode, as a value.
If the alpha fill mode is , this parameter receives the zero-based index of an input stream. The input stream provides the alpha values for the alpha fill.
void ID3D11VideoContext::VideoProcessorGetOutputAlphaFillMode([In] ID3D11VideoProcessor* pVideoProcessor,[Out] D3D11_VIDEO_PROCESSOR_ALPHA_FILL_MODE* pAlphaFillMode,[Out] unsigned int* pStreamIndex)
No documentation.
No documentation.
No documentation.
No documentation.
void ID3D11VideoContext::VideoProcessorGetOutputConstriction([In] ID3D11VideoProcessor* pVideoProcessor,[Out] BOOL* pEnabled,[Out] SIZE* pSize)
[This documentation is preliminary and is subject to change.]
A reference to the interface. To get this reference, call .
Receives the value TRUE if stereo output is enabled, or otherwise.
void ID3D11VideoContext::VideoProcessorGetOutputStereoMode([In] ID3D11VideoProcessor* pVideoProcessor,[Out] BOOL* pEnabled)
[This documentation is preliminary and is subject to change.]
A reference to the interface. To get this reference, call .
A reference to a that identifies the state. The meaning of this is defined by the graphics driver.
The size of the pData buffer, in bytes.
A reference to a buffer that receives the private state data.
If this method succeeds, it returns . Otherwise, it returns an error code.
HRESULT ID3D11VideoContext::VideoProcessorGetOutputExtension([In] ID3D11VideoProcessor* pVideoProcessor,[In] const GUID* pExtensionGuid,[In] unsigned int DataSize,[Out] void* pData)
No documentation.
No documentation.
No documentation.
No documentation.
void ID3D11VideoContext::VideoProcessorSetStreamFrameFormat([In] ID3D11VideoProcessor* pVideoProcessor,[In] unsigned int StreamIndex,[In] D3D11_VIDEO_FRAME_FORMAT FrameFormat)
No documentation.
No documentation.
No documentation.
No documentation.
void ID3D11VideoContext::VideoProcessorSetStreamColorSpace([In] ID3D11VideoProcessor* pVideoProcessor,[In] unsigned int StreamIndex,[In] const D3D11_VIDEO_PROCESSOR_COLOR_SPACE* pColorSpace)
No documentation.
No documentation.
No documentation.
No documentation.
No documentation.
No documentation.
void ID3D11VideoContext::VideoProcessorSetStreamOutputRate([In] ID3D11VideoProcessor* pVideoProcessor,[In] unsigned int StreamIndex,[In] D3D11_VIDEO_PROCESSOR_OUTPUT_RATE OutputRate,[In] BOOL RepeatFrame,[In, Optional] const DXGI_RATIONAL* pCustomRate)
[This documentation is preliminary and is subject to change.]
A reference to the interface. To get this reference, call .
The zero-based index of the input stream. To get the maximum number of streams, call and check the MaxStreamStates structure member.
Specifies whether to apply the source rectangle.
A reference to a structure that specifies the source rectangle. If Enable is , this parameter is ignored.
The source rectangle is the portion of the input surface that is blitted to the destination surface. The source rectangle is given in pixel coordinates, relative to the input surface.If this method is never called, or if the Enable parameter is , the video processor reads from the entire input surface.
void ID3D11VideoContext::VideoProcessorSetStreamSourceRect([In] ID3D11VideoProcessor* pVideoProcessor,[In] unsigned int StreamIndex,[In] BOOL Enable,[In, Optional] const RECT* pRect)
[This documentation is preliminary and is subject to change.]
A reference to the interface. To get this reference, call .
The zero-based index of the input stream. To get the maximum number of streams, call and check the MaxStreamStates structure member.
Specifies whether to apply the destination rectangle.
A reference to a structure that specifies the destination rectangle. If Enable is , this parameter is ignored.
The destination rectangle is the portion of the output surface that receives the blit for this stream. The destination rectangle is given in pixel coordinates, relative to the output surface.The default destination rectangle is an empty rectangle (0, 0, 0, 0). If this method is never called, or if the Enable parameter is , no data is written from this stream.
void ID3D11VideoContext::VideoProcessorSetStreamDestRect([In] ID3D11VideoProcessor* pVideoProcessor,[In] unsigned int StreamIndex,[In] BOOL Enable,[In, Optional] const RECT* pRect)
[This documentation is preliminary and is subject to change.]
A reference to the interface. To get this reference, call .
The zero-based index of the input stream. To get the maximum number of streams, call and check the MaxStreamStates structure member.
Specifies whether alpha blending is enabled.
The planar alpha value. The value can range from 0.0 (transparent) to 1.0 (opaque). If Enable is , this parameter is ignored.
Alpha blending is disabled by default.For each pixel, the destination color value is computed as follows:Cd = Cs * (As * Ap * Ae) + Cd * (1.0 - As * Ap * Ae)where:Cd = The color value of the destination pixel Cs = The color value of the source pixel As = The per-pixel source alpha Ap = The planar alpha value Ae = The palette-entry alpha value, or 1.0 (see Note)Note??Palette-entry alpha values apply only to palettized color formats, and only when the device supports the capability. Otherwise, this factor equals 1.0.The destination alpha value is computed according to the alpha fill mode. For more information, see .
void ID3D11VideoContext::VideoProcessorSetStreamAlpha([In] ID3D11VideoProcessor* pVideoProcessor,[In] unsigned int StreamIndex,[In] BOOL Enable,[In] float Alpha)
[This documentation is preliminary and is subject to change.]
A reference to the interface. To get this reference, call .
The zero-based index of the input stream. To get the maximum number of streams, call and check the MaxStreamStates structure member.
The number of elements in the pEntries array.
A reference to an array of palette entries. For RGB streams, the palette entries use the DXGI_FORMAT_B8G8R8A8 representation. For YCbCr streams, the palette entries use the representation. The caller allocates the array.
This method applies only to input streams that have a palettized color format. Palettized formats with 4 bits per pixel (bpp) use the first 16 entries in the list. Formats with 8 bpp use the first 256 entries.If a pixel has a palette index greater than the number of entries, the device treats the pixel as white with opaque alpha. For full-range RGB, this value is (255, 255, 255, 255); for YCbCr the value is (255, 235, 128, 128).If the driver does not report the capability flag, every palette entry must have an alpha value of 0xFF (opaque). To query for this capability, call .
void ID3D11VideoContext::VideoProcessorSetStreamPalette([In] ID3D11VideoProcessor* pVideoProcessor,[In] unsigned int StreamIndex,[In] unsigned int Count,[In, Buffer, Optional] const unsigned int* pEntries)
[This documentation is preliminary and is subject to change.]
A reference to the interface. To get this reference, call .
The zero-based index of the input stream. To get the maximum number of streams, call and check the MaxStreamStates structure member.
Specifies whether the pSourceAspectRatio and pDestinationAspectRatio parameters contain valid values. Otherwise, the pixel aspect ratios are unspecified.
A reference to a structure that contains the pixel aspect ratio of the source rectangle. If Enable is , this parameter can be null.
A reference to a structure that contains the pixel aspect ratio of the destination rectangle. If Enable is , this parameter can be null.
Pixel aspect ratios of the form 0/n and n/0 are not valid.The default pixel aspect ratio is 1:1 (square pixels).
void ID3D11VideoContext::VideoProcessorSetStreamPixelAspectRatio([In] ID3D11VideoProcessor* pVideoProcessor,[In] unsigned int StreamIndex,[In] BOOL Enable,[In, Optional] const DXGI_RATIONAL* pSourceAspectRatio,[In, Optional] const DXGI_RATIONAL* pDestinationAspectRatio)
No documentation.
No documentation.
No documentation.
No documentation.
No documentation.
No documentation.
void ID3D11VideoContext::VideoProcessorSetStreamLumaKey([In] ID3D11VideoProcessor* pVideoProcessor,[In] unsigned int StreamIndex,[In] BOOL Enable,[In] float Lower,[In] float Upper)
No documentation.
No documentation.
No documentation.
No documentation.
No documentation.
No documentation.
No documentation.
No documentation.
No documentation.
void ID3D11VideoContext::VideoProcessorSetStreamStereoFormat([In] ID3D11VideoProcessor* pVideoProcessor,[In] unsigned int StreamIndex,[In] BOOL Enable,[In] D3D11_VIDEO_PROCESSOR_STEREO_FORMAT Format,[In] BOOL LeftViewFrame0,[In] BOOL BaseViewFrame0,[In] D3D11_VIDEO_PROCESSOR_STEREO_FLIP_MODE FlipMode,[In] int MonoOffset)
[This documentation is preliminary and is subject to change.]
A reference to the interface. To get this reference, call .
The zero-based index of the input stream. To get the maximum number of streams, call and check the MaxStreamStates structure member.
If TRUE, automatic processing features are enabled. If , the driver disables any extra video processing that it might be performing.
By default, the driver might perform certain processing tasks automatically during the video processor blit. This method enables the application to disable these extra video processing features. For example, if you provide your own pixel shader for the video processor, you might want to disable the driver's automatic processing.
void ID3D11VideoContext::VideoProcessorSetStreamAutoProcessingMode([In] ID3D11VideoProcessor* pVideoProcessor,[In] unsigned int StreamIndex,[In] BOOL Enable)
No documentation.
No documentation.
No documentation.
No documentation.
No documentation.
No documentation.
void ID3D11VideoContext::VideoProcessorSetStreamFilter([In] ID3D11VideoProcessor* pVideoProcessor,[In] unsigned int StreamIndex,[In] D3D11_VIDEO_PROCESSOR_FILTER Filter,[In] BOOL Enable,[In] int Level)
[This documentation is preliminary and is subject to change.]
A reference to the interface. To get this reference, call .
The zero-based index of the input stream. To get the maximum number of streams, call and check the MaxStreamStates structure member.
A reference to a that identifies the operation. The meaning of this is defined by the graphics driver.
The size of the pData buffer, in bytes.
A reference to a buffer that contains private state data. The method passes this buffer directly to the driver without validation. It is the responsibility of the driver to validate the data.
If this method succeeds, it returns . Otherwise, it returns an error code.
HRESULT ID3D11VideoContext::VideoProcessorSetStreamExtension([In] ID3D11VideoProcessor* pVideoProcessor,[In] unsigned int StreamIndex,[In] const GUID* pExtensionGuid,[In] unsigned int DataSize,[In] void* pData)
[This documentation is preliminary and is subject to change.]
A reference to the interface. To get this reference, call .
The zero-based index of the input stream. To get the maximum number of streams, call and check the MaxStreamStates structure member.
Receives a value that specifies whether the stream contains interlaced or progressive frames.
void ID3D11VideoContext::VideoProcessorGetStreamFrameFormat([In] ID3D11VideoProcessor* pVideoProcessor,[In] unsigned int StreamIndex,[Out] D3D11_VIDEO_FRAME_FORMAT* pFrameFormat)
[This documentation is preliminary and is subject to change.]
A reference to the interface. To get this reference, call .
The zero-based index of the input stream. To get the maximum number of streams, call and check the MaxStreamStates structure member.
Receives a value that specifies the color space.
void ID3D11VideoContext::VideoProcessorGetStreamColorSpace([In] ID3D11VideoProcessor* pVideoProcessor,[In] unsigned int StreamIndex,[Out] D3D11_VIDEO_PROCESSOR_COLOR_SPACE* pColorSpace)
No documentation.
No documentation.
No documentation.
No documentation.
No documentation.
void ID3D11VideoContext::VideoProcessorGetStreamSourceRect([In] ID3D11VideoProcessor* pVideoProcessor,[In] unsigned int StreamIndex,[Out] BOOL* pEnabled,[Out] RECT* pRect)
[This documentation is preliminary and is subject to change.]
A reference to the interface. To get this reference, call .
The zero-based index of the input stream. To get the maximum number of streams, call and check the MaxStreamStates structure member.
Receives the value TRUE if the destination rectangle is enabled, or otherwise.
A reference to a structure that receives the destination rectangle.
void ID3D11VideoContext::VideoProcessorGetStreamDestRect([In] ID3D11VideoProcessor* pVideoProcessor,[In] unsigned int StreamIndex,[Out] BOOL* pEnabled,[Out] RECT* pRect)
No documentation.
No documentation.
No documentation.
No documentation.
No documentation.
void ID3D11VideoContext::VideoProcessorGetStreamAlpha([In] ID3D11VideoProcessor* pVideoProcessor,[In] unsigned int StreamIndex,[Out] BOOL* pEnabled,[Out] float* pAlpha)
[This documentation is preliminary and is subject to change.]
A reference to the interface. To get this reference, call .
The zero-based index of the input stream. To get the maximum number of streams, call and check the MaxStreamStates structure member.
The number of entries in the pEntries array.
A reference to a UINT array allocated by the caller. The method fills the array with the palette entries. For RGB streams, the palette entries use the DXGI_FORMAT_B8G8R8A8 representation. For YCbCr streams, the palette entries use the representation.
This method applies only to input streams that have a palettized color format. Palettized formats with 4 bits per pixel (bpp) use 16 palette entries. Formats with 8 bpp use 256 entries.
void ID3D11VideoContext::VideoProcessorGetStreamPalette([In] ID3D11VideoProcessor* pVideoProcessor,[In] unsigned int StreamIndex,[In] unsigned int Count,[Out, Buffer] unsigned int* pEntries)
No documentation.
No documentation.
No documentation.
No documentation.
No documentation.
No documentation.
void ID3D11VideoContext::VideoProcessorGetStreamPixelAspectRatio([In] ID3D11VideoProcessor* pVideoProcessor,[In] unsigned int StreamIndex,[Out] BOOL* pEnabled,[Out] DXGI_RATIONAL* pSourceAspectRatio,[Out] DXGI_RATIONAL* pDestinationAspectRatio)
No documentation.
No documentation.
No documentation.
No documentation.
No documentation.
No documentation.
void ID3D11VideoContext::VideoProcessorGetStreamLumaKey([In] ID3D11VideoProcessor* pVideoProcessor,[In] unsigned int StreamIndex,[Out] BOOL* pEnabled,[Out] float* pLower,[Out] float* pUpper)
No documentation.
No documentation.
No documentation.
No documentation.
No documentation.
No documentation.
No documentation.
No documentation.
No documentation.
void ID3D11VideoContext::VideoProcessorGetStreamStereoFormat([In] ID3D11VideoProcessor* pVideoProcessor,[In] unsigned int StreamIndex,[Out] BOOL* pEnable,[Out] D3D11_VIDEO_PROCESSOR_STEREO_FORMAT* pFormat,[Out] BOOL* pLeftViewFrame0,[Out] BOOL* pBaseViewFrame0,[Out] D3D11_VIDEO_PROCESSOR_STEREO_FLIP_MODE* pFlipMode,[Out] int* MonoOffset)
[This documentation is preliminary and is subject to change.]
A reference to the interface. To get this reference, call .
The zero-based index of the input stream. To get the maximum number of streams, call and check the MaxStreamStates structure member.
Receives the value TRUE if automatic processing features are enabled, or otherwise.
void ID3D11VideoContext::VideoProcessorGetStreamAutoProcessingMode([In] ID3D11VideoProcessor* pVideoProcessor,[In] unsigned int StreamIndex,[Out] BOOL* pEnabled)
No documentation.
No documentation.
No documentation.
No documentation.
No documentation.
No documentation.
void ID3D11VideoContext::VideoProcessorGetStreamFilter([In] ID3D11VideoProcessor* pVideoProcessor,[In] unsigned int StreamIndex,[In] D3D11_VIDEO_PROCESSOR_FILTER Filter,[Out] BOOL* pEnabled,[Out] int* pLevel)
No documentation.
No documentation.
No documentation.
No documentation.
No documentation.
No documentation.
No documentation.
HRESULT ID3D11VideoContext::VideoProcessorGetStreamExtension([In] ID3D11VideoProcessor* pVideoProcessor,[In] unsigned int StreamIndex,[In] const GUID* pExtensionGuid,[In] unsigned int DataSize,[Out] void* pData)
[This documentation is preliminary and is subject to change.]
A reference to the interface. To get this reference, call the method.
A reference to the interface for the output surface. The output of the video processing operation will be written to this surface.
The frame number of the output video frame, indexed from zero.
The number of input streams to process.
A reference to an array of structures that contain information about the input streams. The caller allocates the array and fills in each structure. The number of elements in the array is given in the StreamCount parameter.
If this method succeeds, it returns . Otherwise, it returns an error code.
The maximum value of StreamCount is given in the MaxStreamStates member of the structure. The maximum numbr of streams that can be enabled at one time is given in the MaxInputStreams member of that structure.
HRESULT ID3D11VideoContext::VideoProcessorBlt([In] ID3D11VideoProcessor* pVideoProcessor,[In] ID3D11VideoProcessorOutputView* pView,[In] unsigned int OutputFrame,[In] unsigned int StreamCount,[In, Buffer] const D3D11_VIDEO_PROCESSOR_STREAM* pStreams)
No documentation.
No documentation.
No documentation.
No documentation.
No documentation.
HRESULT ID3D11VideoContext::NegotiateCryptoSessionKeyExchange([In] ID3D11CryptoSession* pCryptoSession,[In] unsigned int DataSize,[Out, Buffer] void* pData)
No documentation.
No documentation.
No documentation.
No documentation.
No documentation.
No documentation.
void ID3D11VideoContext::EncryptionBlt([In] ID3D11CryptoSession* pCryptoSession,[In] ID3D11Texture2D* pSrcSurface,[In] ID3D11Texture2D* pDstSurface,[In] unsigned int IVSize,[In, Buffer, Optional] void* pIV)
[This documentation is preliminary and is subject to change.]
A reference to the interface.
A reference to the surface that contains the source data.
A reference to the protected surface where the encrypted data is written.
A reference to a structure, or null. If the driver supports partially encrypted buffers, pEncryptedBlockInfo indicates which portions of the buffer are encrypted. If the entire surface is encrypted, set this parameter to null. To check whether the driver supports partially encrypted buffers, call and check for the capabilities flag. If the driver does not support partially encrypted buffers, set this parameter to null.
A reference to a buffer that contains a content encryption key, or null. To query whether the driver supports the use of content keys, call and check for the capabilities flag. If the driver supports content keys, use the content key to encrypt the surface. Encrypt the content key using the session key, and place the resulting cipher text in pContentKey. If the driver does not support content keys, use the session key to encrypt the surface and set pContentKey to null.
The size of the encrypted content key, in bytes.
A reference to a buffer that contains the initialization vector (IV). For 128-bit AES-CTR encryption, pIV points to a structure. The caller allocates the structure and generates the IV. When you generate the first IV, initialize the structure to a random number. For each subsequent IV, simply increment the IV member of the structure, ensuring that the value always increases. This procedure enables the driver to validate that the same IV is never used more than once with the same key pair. For other encryption types, a different structure might be used, or the encryption might not use an IV.
The size of the pIV buffer, in bytes.
Not all hardware or drivers support this functionality for all cryptographic types.This method does not support writing to subrectangles of the surface.
void ID3D11VideoContext::DecryptionBlt([In] ID3D11CryptoSession* pCryptoSession,[In] ID3D11Texture2D* pSrcSurface,[In] ID3D11Texture2D* pDstSurface,[In, Optional] D3D11_ENCRYPTED_BLOCK_INFO* pEncryptedBlockInfo,[In] unsigned int ContentKeySize,[In, Buffer, Optional] const void* pContentKey,[In] unsigned int IVSize,[In, Buffer, Optional] void* pIV)
No documentation.
No documentation.
No documentation.
No documentation.
void ID3D11VideoContext::StartSessionKeyRefresh([In] ID3D11CryptoSession* pCryptoSession,[In] unsigned int RandomNumberSize,[Out, Buffer] void* pRandomNumber)
[This documentation is preliminary and is subject to change.]
A reference to the interface.
Before calling this method, call . The StartSessionKeyRefresh method gets a random number from the driver, which is used to create a new session key. The new session key does not become active until the application calls FinishSessionKeyRefresh. After the application calls FinishSessionKeyRefresh, all protected surfaces are encrypted using the new session key.
void ID3D11VideoContext::FinishSessionKeyRefresh([In] ID3D11CryptoSession* pCryptoSession)
No documentation.
No documentation.
No documentation.
No documentation.
No documentation.
HRESULT ID3D11VideoContext::GetEncryptionBltKey([In] ID3D11CryptoSession* pCryptoSession,[In] unsigned int KeySize,[Out, Buffer] void* pReadbackKey)
[This documentation is preliminary and is subject to change.]
A reference to the interface.
The size of the data in the pData array, in bytes.
A reference to a byte array that contains the encrypted session key. The buffer must contain 256 bytes of data, encrypted using RSA Encryption Scheme - Optimal Asymmetric Encryption Padding (RSAES-OAEP).
If this method succeeds, it returns . Otherwise, it returns an error code.
HRESULT ID3D11VideoContext::NegotiateAuthenticatedChannelKeyExchange([In] ID3D11AuthenticatedChannel* pChannel,[In] unsigned int DataSize,[Out, Buffer] void* pData)
No documentation.
No documentation.
No documentation.
No documentation.
No documentation.
No documentation.
No documentation.
HRESULT ID3D11VideoContext::QueryAuthenticatedChannel([In] ID3D11AuthenticatedChannel* pChannel,[In] unsigned int InputSize,[In, Buffer] const void* pInput,[In] unsigned int OutputSize,[Out, Buffer] void* pOutput)
[This documentation is preliminary and is subject to change.]
A reference to the interface.
The size of the pInput array, in bytes.
A reference to a byte array that contains input data for the command. This buffer always starts with a structure. The ConfigureType member of the structure specifies the command and defines the meaning of the rest of the buffer.
A reference to a structure that receives the response to the command.
If this method succeeds, it returns . Otherwise, it returns an error code.
HRESULT ID3D11VideoContext::ConfigureAuthenticatedChannel([In] ID3D11AuthenticatedChannel* pChannel,[In] unsigned int InputSize,[In, Buffer] const void* pInput,[Out] D3D11_AUTHENTICATED_CONFIGURE_OUTPUT* pOutput)
No documentation.
No documentation.
No documentation.
No documentation.
No documentation.
void ID3D11VideoContext::VideoProcessorSetStreamRotation([In] ID3D11VideoProcessor* pVideoProcessor,[In] unsigned int StreamIndex,[In] BOOL Enable,[In] D3D11_VIDEO_PROCESSOR_ROTATION Rotation)
No documentation.
No documentation.
No documentation.
No documentation.
No documentation.
void ID3D11VideoContext::VideoProcessorGetStreamRotation([In] ID3D11VideoProcessor* pVideoProcessor,[In] unsigned int StreamIndex,[Out] BOOL* pEnable,[Out] D3D11_VIDEO_PROCESSOR_ROTATION* pRotation)
[This documentation is preliminary and is subject to change.]
ID3D11VideoDecoder
Initializes a new instance of the class.
The native pointer.
[This documentation is preliminary and is subject to change.]
A reference to a structure that receives a description of the video stream.
A reference to a structure that receives the decoder configuration.
If this method succeeds, it returns . Otherwise, it returns an error code.
HRESULT ID3D11VideoDecoder::GetCreationParameters([Out] D3D11_VIDEO_DECODER_DESC* pVideoDesc,[Out] D3D11_VIDEO_DECODER_CONFIG* pConfig)
[This documentation is preliminary and is subject to change.]
Receives a handle to the driver.
If this method succeeds, it returns . Otherwise, it returns an error code.
The driver handle can be used to configure content protection.
HRESULT ID3D11VideoDecoder::GetDriverHandle([Out] void** pDriverHandle)
[This documentation is preliminary and is subject to change.]
The driver handle can be used to configure content protection.
GetDriverHandle
HRESULT ID3D11VideoDecoder::GetDriverHandle([Out] void** pDriverHandle)
[This documentation is preliminary and is subject to change.]
ID3D11VideoDecoderOutputView
Initializes a new instance of the class.
The native pointer.
[This documentation is preliminary and is subject to change.]
A reference to a structure. The method fills the structure with the view properties.
void ID3D11VideoDecoderOutputView::GetDesc([Out] D3D11_VIDEO_DECODER_OUTPUT_VIEW_DESC* pDesc)
[This documentation is preliminary and is subject to change.]
GetDesc
void ID3D11VideoDecoderOutputView::GetDesc([Out] D3D11_VIDEO_DECODER_OUTPUT_VIEW_DESC* pDesc)
[This documentation is preliminary and is subject to change.]
ID3D11VideoDevice
Initializes a new instance of the class.
The native pointer.
[This documentation is preliminary and is subject to change.]
A reference to a structure that describes the video stream and the decoder profile.
A reference to a structure that specifies the decoder configuration.
Receives a reference to the interface. The caller must release the interface.
If this method succeeds, it returns . Otherwise, it returns an error code.
This method allocates the necessary decoder buffers.The method does not affect the internal state of the video decoder.
HRESULT ID3D11VideoDevice::CreateVideoDecoder([In] const D3D11_VIDEO_DECODER_DESC* pVideoDesc,[In] const D3D11_VIDEO_DECODER_CONFIG* pConfig,[Out] ID3D11VideoDecoder** ppDecoder)
[This documentation is preliminary and is subject to change.]
A reference to the interface. To get this reference, call .
Specifies the frame-rate conversion capabilities for the video processor. The value is a zero-based index that corresponds to the TypeIndex parameter of the method.
Receives a reference to the interface. The caller must release the interface.
If this method succeeds, it returns . Otherwise, it returns an error code.
The method does not affect the internal state of the video processor.
HRESULT ID3D11VideoDevice::CreateVideoProcessor([In] ID3D11VideoProcessorEnumerator* pEnum,[In] unsigned int RateConversionIndex,[Out] ID3D11VideoProcessor** ppVideoProcessor)
No documentation.
No documentation.
No documentation.
No documentation.
HRESULT ID3D11VideoDevice::CreateAuthenticatedChannel([In] D3D11_AUTHENTICATED_CHANNEL_TYPE ChannelType,[Out] ID3D11AuthenticatedChannel** ppAuthenticatedChannel)
No documentation.
No documentation.
No documentation.
No documentation.
No documentation.
No documentation.
HRESULT ID3D11VideoDevice::CreateCryptoSession([In] const GUID* pCryptoType,[In, Optional] const GUID* pDecoderProfile,[In] const GUID* pKeyExchangeType,[Out] ID3D11CryptoSession** ppCryptoSession)
No documentation.
No documentation.
No documentation.
No documentation.
No documentation.
HRESULT ID3D11VideoDevice::CreateVideoDecoderOutputView([In] ID3D11Resource* pResource,[In] const D3D11_VIDEO_DECODER_OUTPUT_VIEW_DESC* pDesc,[Out, Optional] ID3D11VideoDecoderOutputView** ppVDOVView)
[This documentation is preliminary and is subject to change.]
A reference to the interface of the input surface.
A reference to the interface that specifies the video processor. To get this reference, call .
A reference to a structure that describes the view.
Receives a reference to the interface. The caller must release the resource. If this parameter is null, the method checks whether the view is supported, but does not create the view.
If this method succeeds, it returns . Otherwise, it returns an error code.
Set the ppVPIView parameter to null to test whether a view is supported.The surface format is given in the FourCC member of the structure. The method fails if the video processor does not support this format as an input sample.
HRESULT ID3D11VideoDevice::CreateVideoProcessorInputView([In] ID3D11Resource* pResource,[In] ID3D11VideoProcessorEnumerator* pEnum,[In] const D3D11_VIDEO_PROCESSOR_INPUT_VIEW_DESC* pDesc,[Out, Optional] ID3D11VideoProcessorInputView** ppVPIView)
No documentation.
No documentation.
No documentation.
No documentation.
No documentation.
No documentation.
HRESULT ID3D11VideoDevice::CreateVideoProcessorOutputView([In] ID3D11Resource* pResource,[In] ID3D11VideoProcessorEnumerator* pEnum,[In] const D3D11_VIDEO_PROCESSOR_OUTPUT_VIEW_DESC* pDesc,[Out, Optional] ID3D11VideoProcessorOutputView** ppVPOView)
[This documentation is preliminary and is subject to change.]
A reference to a structure that describes the video content.
Receives a reference to the interface. The caller must release the interface.
If this method succeeds, it returns . Otherwise, it returns an error code.
To create the video processor device, pass the reference to the method.
HRESULT ID3D11VideoDevice::CreateVideoProcessorEnumerator([In] const D3D11_VIDEO_PROCESSOR_CONTENT_DESC* pDesc,[Out] ID3D11VideoProcessorEnumerator** ppEnum)
[This documentation is preliminary and is subject to change.]
Returns the number of DXVA profiles.
To enumerate the profiles, call .
unsigned int ID3D11VideoDevice::GetVideoDecoderProfileCount()
No documentation.
No documentation.
No documentation.
No documentation.
HRESULT ID3D11VideoDevice::GetVideoDecoderProfile([In] unsigned int Index,[Out] GUID* pDecoderProfile)
[This documentation is preliminary and is subject to change.]
A reference to a that identifies the DXVA profile. To get the list of supported profiles, call .
A value that specifies the output format. Typical values include and .
Receives the value TRUE if the format is supported, or otherwise.
If this method succeeds, it returns . Otherwise, it returns an error code.
If the driver does not support the DXVA profile given in pDecoderProfile, the method returns E_INVALIDARG. If the driver supports the profile, but the DXGI format is not compatible with the profile, the method succeeds but returns the value in pSupported.
HRESULT ID3D11VideoDevice::CheckVideoDecoderFormat([In] const GUID* pDecoderProfile,[In] DXGI_FORMAT Format,[Out] BOOL* pSupported)
[This documentation is preliminary and is subject to change.]
A reference to a structure that describes the video stream.
Receives the number of decoder configurations.
If this method succeeds, it returns . Otherwise, it returns an error code.
To enumerate the decoder configurations, call .
HRESULT ID3D11VideoDevice::GetVideoDecoderConfigCount([In] const D3D11_VIDEO_DECODER_DESC* pDesc,[Out] unsigned int* pCount)
[This documentation is preliminary and is subject to change.]
A reference to a structure that describes the video stream.
The zero-based index of the decoder configuration. To get the number of configurations that the driver supports, call .
A reference to a structure. The method fills in the structure with the decoder configuration.
If this method succeeds, it returns . Otherwise, it returns an error code.
HRESULT ID3D11VideoDevice::GetVideoDecoderConfig([In] const D3D11_VIDEO_DECODER_DESC* pDesc,[In] unsigned int Index,[Out] D3D11_VIDEO_DECODER_CONFIG* pConfig)
No documentation.
No documentation.
No documentation.
No documentation.
No documentation.
HRESULT ID3D11VideoDevice::GetContentProtectionCaps([In, Optional] const GUID* pCryptoType,[In, Optional] const GUID* pDecoderProfile,[Out] D3D11_VIDEO_CONTENT_PROTECTION_CAPS* pCaps)
No documentation.
No documentation.
No documentation.
No documentation.
No documentation.
No documentation.
HRESULT ID3D11VideoDevice::CheckCryptoKeyExchange([In] const GUID* pCryptoType,[In, Optional] const GUID* pDecoderProfile,[In] unsigned int Index,[Out] GUID* pKeyExchangeType)
[This documentation is preliminary and is subject to change.]
The associated with the data.
The size of the data, in bytes.
A reference to the data.
If this method succeeds, it returns . Otherwise, it returns an error code.
HRESULT ID3D11VideoDevice::SetPrivateData([In] const GUID& guid,[In] unsigned int DataSize,[In, Buffer, Optional] const void* pData)
No documentation.
No documentation.
No documentation.
No documentation.
HRESULT ID3D11VideoDevice::SetPrivateDataInterface([In] const GUID& guid,[In, Optional] const IUnknown* pData)
[This documentation is preliminary and is subject to change.]
To enumerate the profiles, call .
GetVideoDecoderProfileCount
unsigned int ID3D11VideoDevice::GetVideoDecoderProfileCount()
[This documentation is preliminary and is subject to change.]
ID3D11VideoProcessor
Initializes a new instance of the class.
The native pointer.
No documentation.
No documentation.
void ID3D11VideoProcessor::GetContentDesc([Out] D3D11_VIDEO_PROCESSOR_CONTENT_DESC* pDesc)
[This documentation is preliminary and is subject to change.]
A reference to a structure that receives the rate conversion capabilities.
void ID3D11VideoProcessor::GetRateConversionCaps([Out] D3D11_VIDEO_PROCESSOR_RATE_CONVERSION_CAPS* pCaps)
No documentation.
GetContentDesc
void ID3D11VideoProcessor::GetContentDesc([Out] D3D11_VIDEO_PROCESSOR_CONTENT_DESC* pDesc)
[This documentation is preliminary and is subject to change.]
GetRateConversionCaps
void ID3D11VideoProcessor::GetRateConversionCaps([Out] D3D11_VIDEO_PROCESSOR_RATE_CONVERSION_CAPS* pCaps)
[This documentation is preliminary and is subject to change.]
ID3D11VideoProcessorEnumerator
Initializes a new instance of the class.
The native pointer.
No documentation.
No documentation.
No documentation.
HRESULT ID3D11VideoProcessorEnumerator::GetVideoProcessorContentDesc([Out] D3D11_VIDEO_PROCESSOR_CONTENT_DESC* pContentDesc)
[This documentation is preliminary and is subject to change.]
The video format to query, specified as a value.
Receives a bitwise OR of zero or more flags from the enumeration.
If this method succeeds, it returns . Otherwise, it returns an error code.
HRESULT ID3D11VideoProcessorEnumerator::CheckVideoProcessorFormat([In] DXGI_FORMAT Format,[Out] unsigned int* pFlags)
[This documentation is preliminary and is subject to change.]
A reference to a structure that receives the capabilities.
If this method succeeds, it returns . Otherwise, it returns an error code.
HRESULT ID3D11VideoProcessorEnumerator::GetVideoProcessorCaps([Out] D3D11_VIDEO_PROCESSOR_CAPS* pCaps)
No documentation.
No documentation.
No documentation.
No documentation.
HRESULT ID3D11VideoProcessorEnumerator::GetVideoProcessorRateConversionCaps([In] unsigned int TypeIndex,[Out] D3D11_VIDEO_PROCESSOR_RATE_CONVERSION_CAPS* pCaps)
No documentation.
No documentation.
No documentation.
No documentation.
No documentation.
HRESULT ID3D11VideoProcessorEnumerator::GetVideoProcessorCustomRate([In] unsigned int TypeIndex,[In] unsigned int CustomRateIndex,[Out] D3D11_VIDEO_PROCESSOR_CUSTOM_RATE* pRate)
No documentation.
No documentation.
No documentation.
No documentation.
HRESULT ID3D11VideoProcessorEnumerator::GetVideoProcessorFilterRange([In] D3D11_VIDEO_PROCESSOR_FILTER Filter,[Out] D3D11_VIDEO_PROCESSOR_FILTER_RANGE* pRange)
No documentation.
GetVideoProcessorContentDesc
HRESULT ID3D11VideoProcessorEnumerator::GetVideoProcessorContentDesc([Out] D3D11_VIDEO_PROCESSOR_CONTENT_DESC* pContentDesc)
[This documentation is preliminary and is subject to change.]
GetVideoProcessorCaps
HRESULT ID3D11VideoProcessorEnumerator::GetVideoProcessorCaps([Out] D3D11_VIDEO_PROCESSOR_CAPS* pCaps)
[This documentation is preliminary and is subject to change.]
ID3D11VideoProcessorInputView
Initializes a new instance of the class.
The native pointer.
[This documentation is preliminary and is subject to change.]
A reference to a structure. The method fills the structure with the view properties.
void ID3D11VideoProcessorInputView::GetDesc([Out] D3D11_VIDEO_PROCESSOR_INPUT_VIEW_DESC* pDesc)
[This documentation is preliminary and is subject to change.]
GetDesc
void ID3D11VideoProcessorInputView::GetDesc([Out] D3D11_VIDEO_PROCESSOR_INPUT_VIEW_DESC* pDesc)
[This documentation is preliminary and is subject to change.]
ID3D11VideoProcessorOutputView
Initializes a new instance of the class.
The native pointer.
No documentation.
No documentation.
void ID3D11VideoProcessorOutputView::GetDesc([Out] D3D11_VIDEO_PROCESSOR_OUTPUT_VIEW_DESC* pDesc)
No documentation.
GetDesc
void ID3D11VideoProcessorOutputView::GetDesc([Out] D3D11_VIDEO_PROCESSOR_OUTPUT_VIEW_DESC* pDesc)
No documentation.
D3D11_AES_CTR_IV
No documentation.
unsigned longlong IV
No documentation.
unsigned longlong Count
No documentation.
D3D11_AUTHENTICATED_CONFIGURE_ACCESSIBLE_ENCRYPTION_INPUT
No documentation.
D3D11_AUTHENTICATED_CONFIGURE_INPUT Parameters
No documentation.
GUID EncryptionGuid
[This documentation is preliminary and is subject to change.]
D3D11_AUTHENTICATED_CONFIGURE_CRYPTO_SESSION_INPUT
A structure that contains the command and other data.
D3D11_AUTHENTICATED_CONFIGURE_INPUT Parameters
A handle to the decoder device.
void* DecoderHandle
A handle to the cryptographic session.
void* CryptoSessionHandle
A handle to the Direct3D device.
void* DeviceHandle
[This documentation is preliminary and is subject to change.]
D3D11_AUTHENTICATED_CONFIGURE_INITIALIZE_INPUT
A structure that contains the command and other data.
D3D11_AUTHENTICATED_CONFIGURE_INPUT Parameters
The initial sequence number for queries.
unsigned int StartSequenceQuery
The initial sequence number for commands.
unsigned int StartSequenceConfigure
No documentation.
D3D11_AUTHENTICATED_CONFIGURE_INPUT
No documentation.
D3D11_OMAC omac
No documentation.
GUID ConfigureType
No documentation.
void* hChannel
No documentation.
unsigned int SequenceNumber
[This documentation is preliminary and is subject to change.]
D3D11_AUTHENTICATED_CONFIGURE_OUTPUT
No documentation.
D3D11_OMAC omac
No documentation.
GUID ConfigureType
No documentation.
void* hChannel
No documentation.
unsigned int SequenceNumber
No documentation.
HRESULT ReturnCode
[This documentation is preliminary and is subject to change.]
D3D11_AUTHENTICATED_CONFIGURE_PROTECTION_INPUT
A structure that contains the command and other data.
D3D11_AUTHENTICATED_CONFIGURE_INPUT Parameters
A union that specifies the protection level.
D3D11_AUTHENTICATED_PROTECTION_FLAGS Protections
No documentation.
D3D11_AUTHENTICATED_CONFIGURE_SHARED_RESOURCE_INPUT
No documentation.
D3D11_AUTHENTICATED_CONFIGURE_INPUT Parameters
No documentation.
D3D11_AUTHENTICATED_PROCESS_IDENTIFIER_TYPE ProcessType
No documentation.
void* ProcessHandle
No documentation.
BOOL AllowAccess
[This documentation is preliminary and is subject to change.]
D3D11_AUTHENTICATED_PROTECTION_FLAGS
- ProtectionEnabled If 1, video content protection is enabled.
- OverlayOrFullscreenRequired If 1, the application requires video to be displayed using either a hardware overlay or full-screen exclusive mode.
- Reserved Reserved. Set all bits to zero.
D3D11_AUTHENTICATED_PROTECTION_FLAGS___MIDL___MIDL_itf_d3d11_0000_0034_0001_INNER Flags
Use this member to access all of the bits in the union.
unsigned int Value
No documentation.
D3D11_AUTHENTICATED_PROTECTION_FLAGS___MIDL___MIDL_itf_d3d11_0000_0034_0001_INNER
No documentation.
unsigned int ProtectionEnabled
No documentation.
unsigned int OverlayOrFullscreenRequired
No documentation.
unsigned int Reserved
No documentation.
D3D11_AUTHENTICATED_QUERY_ACCESSIBILITY_ENCRYPTION_GUID_COUNT_OUTPUT
No documentation.
D3D11_AUTHENTICATED_QUERY_OUTPUT Output
No documentation.
unsigned int EncryptionGuidCount
No documentation.
D3D11_AUTHENTICATED_QUERY_ACCESSIBILITY_ENCRYPTION_GUID_INPUT
No documentation.
D3D11_AUTHENTICATED_QUERY_INPUT Input
No documentation.
unsigned int EncryptionGuidIndex
No documentation.
D3D11_AUTHENTICATED_QUERY_ACCESSIBILITY_ENCRYPTION_GUID_OUTPUT
No documentation.
D3D11_AUTHENTICATED_QUERY_OUTPUT Output
No documentation.
unsigned int EncryptionGuidIndex
No documentation.
GUID EncryptionGuid
No documentation.
D3D11_AUTHENTICATED_QUERY_ACESSIBILITY_OUTPUT
No documentation.
D3D11_AUTHENTICATED_QUERY_OUTPUT Output
No documentation.
D3D11_BUS_TYPE BusType
No documentation.
BOOL AccessibleInContiguousBlocks
No documentation.
BOOL AccessibleInNonContiguousBlocks
No documentation.
D3D11_AUTHENTICATED_QUERY_CHANNEL_TYPE_OUTPUT
No documentation.
D3D11_AUTHENTICATED_QUERY_OUTPUT Output
No documentation.
D3D11_AUTHENTICATED_CHANNEL_TYPE ChannelType
[This documentation is preliminary and is subject to change.]
D3D11_AUTHENTICATED_QUERY_CRYPTO_SESSION_INPUT
A structure that contains the for the query and other data.
D3D11_AUTHENTICATED_QUERY_INPUT Input
A handle to a decoder device.
void* DecoderHandle
No documentation.
D3D11_AUTHENTICATED_QUERY_CRYPTO_SESSION_OUTPUT
No documentation.
D3D11_AUTHENTICATED_QUERY_OUTPUT Output
No documentation.
void* DecoderHandle
No documentation.
void* CryptoSessionHandle
No documentation.
void* DeviceHandle
[This documentation is preliminary and is subject to change.]
D3D11_AUTHENTICATED_QUERY_CURRENT_ACCESSIBILITY_ENCRYPTION_OUTPUT
A structure that contains a Message Authentication Code (MAC) and other data.
D3D11_AUTHENTICATED_QUERY_OUTPUT Output
A that specifies the current encryption type.
GUID EncryptionGuid
[This documentation is preliminary and is subject to change.]
D3D11_AUTHENTICATED_QUERY_DEVICE_HANDLE_OUTPUT
A structure that contains a Message Authentication Code (MAC) and other data.
D3D11_AUTHENTICATED_QUERY_OUTPUT Output
A handle to the device.
void* DeviceHandle
No documentation.
D3D11_AUTHENTICATED_QUERY_INPUT
No documentation.
GUID QueryType
No documentation.
void* hChannel
No documentation.
unsigned int SequenceNumber
[This documentation is preliminary and is subject to change.]
D3D11_AUTHENTICATED_QUERY_OUTPUT
A structure that contains a Message Authentication Code (MAC) and other data.
D3D11_OMAC omac
A handle to the device.
GUID QueryType
A handle to the cryptographic session.
void* hChannel
The number of output IDs associated with the specified device and cryptographic session.
unsigned int SequenceNumber
No documentation.
HRESULT ReturnCode
[This documentation is preliminary and is subject to change.]
D3D11_AUTHENTICATED_QUERY_OUTPUT_ID_COUNT_INPUT
A structure that contains the for the query and other data.
D3D11_AUTHENTICATED_QUERY_INPUT Input
A handle to the device.
void* DeviceHandle
A handle to the cryptographic session.
void* CryptoSessionHandle
[This documentation is preliminary and is subject to change.]
D3D11_AUTHENTICATED_QUERY_OUTPUT_ID_COUNT_OUTPUT
A structure that contains a Message Authentication Code (MAC) and other data.
D3D11_AUTHENTICATED_QUERY_OUTPUT Output
A handle to the device.
void* DeviceHandle
A handle to the cryptographic session.
void* CryptoSessionHandle
The number of output IDs associated with the specified device and cryptographic session.
unsigned int OutputIDCount
[This documentation is preliminary and is subject to change.]
D3D11_AUTHENTICATED_QUERY_OUTPUT_ID_INPUT
A structure that contains the for the query and other data.
D3D11_AUTHENTICATED_QUERY_INPUT Input
A handle to the device.
void* DeviceHandle
A handle to the cryptographic session.
void* CryptoSessionHandle
The index of the output ID.
unsigned int OutputIDIndex
No documentation.
D3D11_AUTHENTICATED_QUERY_OUTPUT_ID_OUTPUT
No documentation.
D3D11_AUTHENTICATED_QUERY_OUTPUT Output
No documentation.
void* DeviceHandle
No documentation.
void* CryptoSessionHandle
No documentation.
unsigned int OutputIDIndex
No documentation.
unsigned longlong OutputID
No documentation.
D3D11_AUTHENTICATED_QUERY_PROTECTION_OUTPUT
No documentation.
D3D11_AUTHENTICATED_QUERY_OUTPUT Output
No documentation.
D3D11_AUTHENTICATED_PROTECTION_FLAGS ProtectionFlags
No documentation.
D3D11_AUTHENTICATED_QUERY_RESTRICTED_SHARED_RESOURCE_PROCESS_COUNT_OUTPUT
No documentation.
D3D11_AUTHENTICATED_QUERY_OUTPUT Output
No documentation.
unsigned int RestrictedSharedResourceProcessCount
No documentation.
D3D11_AUTHENTICATED_QUERY_RESTRICTED_SHARED_RESOURCE_PROCESS_INPUT
No documentation.
D3D11_AUTHENTICATED_QUERY_INPUT Input
No documentation.
unsigned int ProcessIndex
No documentation.
D3D11_AUTHENTICATED_QUERY_RESTRICTED_SHARED_RESOURCE_PROCESS_OUTPUT
No documentation.
D3D11_AUTHENTICATED_QUERY_OUTPUT Output
No documentation.
unsigned int ProcessIndex
No documentation.
D3D11_AUTHENTICATED_PROCESS_IDENTIFIER_TYPE ProcessIdentifier
No documentation.
void* ProcessHandle
No documentation.
D3D11_AUTHENTICATED_QUERY_UNRESTRICTED_PROTECTED_SHARED_RESOURCE_COUNT_OUTPUT
No documentation.
D3D11_AUTHENTICATED_QUERY_OUTPUT Output
No documentation.
unsigned int UnrestrictedProtectedSharedResourceCount
[This documentation is preliminary and is subject to change.]
Here are the default values for blend state.StateDefault Value AlphaToCoverageEnableFALSE IndependentBlendEnableFALSE RenderTarget[0].BlendEnableFALSE RenderTarget[0].SrcBlendD3D11_BLEND_ONE RenderTarget[0].DestBlendD3D11_BLEND_ZERO RenderTarget[0].BlendOpD3D11_BLEND_OP_ADD RenderTarget[0].SrcBlendAlphaD3D11_BLEND_ONE RenderTarget[0].DestBlendAlphaD3D11_BLEND_ZERO RenderTarget[0].BlendOpAlphaD3D11_BLEND_OP_ADD RenderTarget[0].RenderTargetWriteMaskD3D11_COLOR_WRITE_ENABLE_ALL?If the driver type is set to , the feature level is set to less than or equal to , and the pixel format of the render target is set to , , or , the display device performs the blend in standard RGB (sRGB) space and not in linear space. However, if the feature level is set to greater than , the display device performs the blend in linear space, which is ideal.When you set the LogicOpEnable member of the first element of the RenderTarget array (RenderTarget[0]) to TRUE, you must also set the BlendEnable member of RenderTarget[0] to , and the IndependentBlendEnable member of this to . This reflects the limitation in hardware that you can't mix logic operations with blending across multiple render targets, and that when you use a logic operation, you must apply the same logic operation to all render targets.
D3D11_BLEND_DESC1
No documentation.
BOOL AlphaToCoverageEnable
No documentation.
BOOL IndependentBlendEnable
No documentation.
D3D11_RENDER_TARGET_BLEND_DESC1 RenderTarget[8]
Describes the blend state that you use in a call to to create a blend-state object.
Here are the default values for blend state.StateDefault Value AlphaToCoverageEnableFALSE IndependentBlendEnableFALSE RenderTarget[0].BlendEnableFALSE RenderTarget[0].SrcBlendD3D11_BLEND_ONE RenderTarget[0].DestBlendD3D11_BLEND_ZERO RenderTarget[0].BlendOpD3D11_BLEND_OP_ADD RenderTarget[0].SrcBlendAlphaD3D11_BLEND_ONE RenderTarget[0].DestBlendAlphaD3D11_BLEND_ZERO RenderTarget[0].BlendOpAlphaD3D11_BLEND_OP_ADD RenderTarget[0].RenderTargetWriteMaskD3D11_COLOR_WRITE_ENABLE_ALL?Note?? is identical to .If the driver type is set to , the feature level is set to less than or equal to , and the pixel format of the render target is set to , , or , the display device performs the blend in standard RGB (sRGB) space and not in linear space. However, if the feature level is set to greater than , the display device performs the blend in linear space, which is ideal.
D3D11_BLEND_DESC
No documentation.
BOOL AlphaToCoverageEnable
No documentation.
BOOL IndependentBlendEnable
No documentation.
D3D11_RENDER_TARGET_BLEND_DESC RenderTarget[8]
No documentation.
CD3D11_VIDEO_DEFAULT
Describes an HLSL class instance.
The structure is returned by the method.The members of this structure except InstanceIndex are valid (non default values) if they describe a class instance aquired using . The InstanceIndex member is only valid when the class instance is aquired using .
D3D11_CLASS_INSTANCE_DESC
The instance ID of an HLSL class; the default value is 0.
unsigned int InstanceId
The instance index of an HLSL class; the default value is 0.
unsigned int InstanceIndex
The type ID of an HLSL class; the default value is 0.
unsigned int TypeId
Describes the constant buffer associated with an HLSL class; the default value is 0.
unsigned int ConstantBuffer
The base constant buffer offset associated with an HLSL class; the default value is 0.
unsigned int BaseConstantBufferOffset
The base texture associated with an HLSL class; the default value is 127.
unsigned int BaseTexture
The base sampler associated with an HLSL class; the default value is 15.
unsigned int BaseSampler
True if the class was created; the default value is false.
BOOL Created
Information about the video card's performance counter capabilities.
This structure is returned by .
D3D11_COUNTER_INFO
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 . See .
D3D11_COUNTER LastDeviceDependentCounter
Number of counters that can be simultaneously supported.
unsigned int NumSimultaneousCounters
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.
unsigned char NumDetectableParallelUnits
Describes a counter.
This structure is used by , and .
D3D11_COUNTER_DESC
Type of counter (see ).
D3D11_COUNTER Counter
Reserved.
unsigned int MiscFlags
Stencil operations that can be performed based on the results of stencil test.
All stencil operations are specified as a . 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.
D3D11_DEPTH_STENCILOP_DESC
The stencil operation to perform when stencil testing fails.
D3D11_STENCIL_OP StencilFailOp
The stencil operation to perform when stencil testing passes and depth testing fails.
D3D11_STENCIL_OP StencilDepthFailOp
The stencil operation to perform when stencil testing and depth testing both pass.
D3D11_STENCIL_OP StencilPassOp
A function that compares stencil data against existing stencil data. The function options are listed in .
D3D11_COMPARISON_FUNC StencilFunc
Describes depth-stencil state.
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.StateDefault Value DepthEnableTRUE DepthWriteMaskD3D11_DEPTH_WRITE_MASK_ALL DepthFuncD3D11_COMPARISON_LESS StencilEnableFALSE StencilReadMaskD3D11_DEFAULT_STENCIL_READ_MASK StencilWriteMaskD3D11_DEFAULT_STENCIL_WRITE_MASK FrontFace.StencilFunc
and
BackFace.StencilFunc
FrontFace.StencilDepthFailOp
and
BackFace.StencilDepthFailOp
FrontFace.StencilPassOp
and
BackFace.StencilPassOp
FrontFace.StencilFailOp
and
BackFace.StencilFailOp
?The formats that support stenciling are and .
D3D11_DEPTH_STENCIL_DESC
Identify a portion of the depth-stencil buffer that can be modified by depth data (see ).
D3D11_DEPTH_WRITE_MASK DepthWriteMask
A function that compares depth data against existing depth data. The function options are listed in .
D3D11_COMPARISON_FUNC DepthFunc
Identify a portion of the depth-stencil buffer for reading stencil data.
unsigned char StencilReadMask
Identify a portion of the depth-stencil buffer for writing stencil data.
unsigned char StencilWriteMask
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 FrontFace
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 BackFace
Enable depth testing.
BOOL DepthEnable
Enable stencil testing.
BOOL StencilEnable
Specifies the subresources of a texture that are accessible from a depth-stencil view.
These are valid formats for a depth-stencil view: A depth-stencil view cannot use a typeless format. If the format chosen is , then the format of the parent resource is used.A depth-stencil-view description is needed when calling .
D3D11_DEPTH_STENCIL_VIEW_DESC
Resource data format (see ). See remarks for allowable formats.
DXGI_FORMAT Format
Type of resource (see ). Specifies how a depth-stencil resource will be accessed; the value is stored in the union in this structure.
D3D11_DSV_DIMENSION ViewDimension
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 enumerated type.
D3D11_DSV_FLAG Flags
Specifies a 1D texture subresource (see ).
D3D11_TEX1D_DSV Texture1D
Specifies an array of 1D texture subresources (see ).
D3D11_TEX1D_ARRAY_DSV Texture1DArray
Specifies a 2D texture subresource (see ).
D3D11_TEX2D_DSV Texture2D
Specifies an array of 2D texture subresources (see ).
D3D11_TEX2D_ARRAY_DSV Texture2DArray
Specifies a multisampled 2D texture (see ).
D3D11_TEX2DMS_DSV Texture2DMS
Specifies an array of multisampled 2D textures (see ).
D3D11_TEX2DMS_ARRAY_DSV Texture2DMSArray
Specifies the subresource from a multisampled 2D texture that is accessible to a depth-stencil view.
Because a multisampled 2D texture contains a single subtexture, there is nothing to specify; this unused member is included so that this structure will compile in C.
D3D11_TEX2DMS_DSV
Unused.
unsigned int UnusedField_NothingToDefine
Specifies the subresource from a 2D texture that is accessible to a depth-stencil view.
This structure is one member of a depth-stencil-view description (see ).
D3D11_TEX2D_DSV
The index of the first mipmap level to use.
unsigned int MipSlice
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_TEX1D_ARRAY_DSV
The index of the first mipmap level to use.
unsigned int MipSlice
The index of the first texture to use in an array of textures.
unsigned int FirstArraySlice
Number of textures to use.
unsigned int ArraySize
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_TEX2DMS_ARRAY_DSV
The index of the first texture to use in an array of textures.
unsigned int FirstArraySlice
Number of textures to use.
unsigned int ArraySize
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_TEX2D_ARRAY_DSV
The index of the first mipmap level to use.
unsigned int MipSlice
The index of the first texture to use in an array of textures.
unsigned int FirstArraySlice
Number of textures to use.
unsigned int ArraySize
Specifies the subresource from a 1D texture that is accessible to a depth-stencil view.
This structure is one member of a depth-stencil-view description (see ).
D3D11_TEX1D_DSV
The index of the first mipmap level to use.
unsigned int MipSlice
[This documentation is preliminary and is subject to change.]
D3D11_ENCRYPTED_BLOCK_INFO
The number of bytes that are encrypted at the start of the buffer.
unsigned int NumEncryptedBytesAtBeginning
The number of bytes that are skipped after the first NumEncryptedBytesAtBeginning bytes, and then after each block of NumBytesInEncryptPattern bytes. Skipped bytes are not encrypted.
unsigned int NumBytesInSkipPattern
The number of bytes that are encrypted after each block of skipped bytes.
unsigned int NumBytesInEncryptPattern
[This documentation is preliminary and is subject to change.]
D3D11_FEATURE_DATA_ARCHITECTURE_INFO
Specifies whether a rendering device batches rendering commands and performs multipass rendering into tiles or bins over a render area. Certain API usage patterns that are fine TileBasedDefferredRenderers (TBDRs) can perform worse on non-TBDRs and vice versa. Applications that are careful about rendering can be friendly to both TBDR and non-TBDR architectures. TRUE if the rendering device batches rendering commands and otherwise.
BOOL TileBasedDeferredRenderer
Describes compute shader and raw and structured buffer support in the current graphics driver.
Direct3D 11 devices () are required to support Compute Shader model 5.0. Direct3D 10.x devices (, ) can optionally support Compute Shader model 4.0 or 4.1.
D3D11_FEATURE_DATA_D3D10_X_HARDWARE_OPTIONS
TRUE if compute shaders and raw and structured buffers are supported; otherwise .
BOOL ComputeShaders_Plus_RawAndStructuredBuffers_Via_Shader_4_x
[This documentation is preliminary and is subject to change.]
If a Microsoft Direct3D device supports feature level 11.1 (), when you call with , CheckFeatureSupport returns a reference to with all member set to TRUE except the SAD4ShaderInstructions and ExtendedDoublesShaderInstructions members, which are optionally supported by the hardware and driver and therefore can be TRUE or .Feature level 11.1 provides the following additional features:UAVs at every shader stage with 64 UAV bind slots instead of 8. Target-independent rasterization, which enables you to set the ForcedSampleCount member of to 1, 4, 8, or 16 and to render to RTVs with a single sample. UAV-only rendering with the ForcedSampleCount member of set to up to 16 (only up to 8 for feature level 11).The runtime always sets the following groupings of members identically. That is, all the values in a grouping are TRUE or together:DiscardAPIsSeenByDriver and FlagsForUpdateAndCopySeenByDriver ClearView, CopyWithOverlap, ConstantBufferPartialUpdate, ConstantBufferOffsetting, and MapNoOverwriteOnDynamicConstantBuffer MapNoOverwriteOnDynamicBufferSRV and MultisampleRTVWithForcedSampleCountOne
D3D11_FEATURE_DATA_D3D11_OPTIONS
Specifies whether logic operations are available in blend state. The runtime sets this member to TRUE if logic operations are available in blend state and otherwise. This member is for feature level 9.1, 9.2, and 9.3. This member is optional for feature level 10, 10.1, and 11. This member is TRUE for feature level 11.1.
BOOL OutputMergerLogicOp
Specifies whether the driver can render with no RTVs or DSVs and only UAVs bound. The runtime sets this member to TRUE if the driver can render with no RTVs or DSVs and only UAVs bound and otherwise. If TRUE, you can set the ForcedSampleCount member of to 1, 4, or 8 when you render with no RTVs or DSV and only UAVs bound. For feature level 11.1, this member is always TRUE and you can also set ForcedSampleCount to 16 in addition to 1, 4, or 8. The default value of ForcedSampleCount is 0, which means the same as if the value is set to 1. You can always set ForcedSampleCount to 0 or 1 for UAV-only rendering independently of how this member is set.
BOOL UAVOnlyRenderingForcedSampleCount
Specifies whether the driver supports the and methods. The runtime sets this member to TRUE if the driver supports these methods and otherwise. How this member is set does not indicate whether the driver actually uses these methods; that is, the driver might ignore these methods if they are not useful to the hardware. If , the runtime does not expose these methods to the driver because the driver does not support them. You can monitor this member during development to rule out legacy drivers on hardware where these methods might have otherwise been beneficial. You are not required to write separate code paths based on whether this member is TRUE or ; you can call these methods whenever applicable.
BOOL DiscardAPIsSeenByDriver
Specifies whether the driver supports new semantics for copy and update that are exposed by the and methods. The runtime sets this member to TRUE if the driver supports new semantics for copy and update. The runtime sets this member to only for legacy drivers. The runtime handles this member similarly to the DiscardAPIsSeenByDriver member.
BOOL FlagsForUpdateAndCopySeenByDriver
Specifies whether the driver supports the method. The runtime sets this member to TRUE if the driver supports this method and otherwise. If , the runtime does not expose this method to the driver because the driver does not support it.
Note??For feature level 9.1, 9.2, and 9.3, this member is always TRUE because the option is emulated by the runtime.
BOOL ClearView
Specifies whether you can call with overlapping source and destination rectangles. The runtime sets this member to TRUE if you can call CopySubresourceRegion1 with overlapping source and destination rectangles and otherwise. If , the runtime does not expose this method to the driver because the driver does not support it.
Note??For feature level 9.1, 9.2, and 9.3, this member is always TRUE because the option is emulated by the runtime.
BOOL CopyWithOverlap
Specifies whether the driver supports partial updates of constant buffers. The runtime sets this member to TRUE if the driver supports partial updates of constant buffers and otherwise. If , the runtime does not expose this operation to the driver because the driver does not support it.
Note??For feature level 9.1, 9.2, and 9.3, this member is always TRUE because the option is emulated by the runtime.
BOOL ConstantBufferPartialUpdate
Specifies whether the driver supports new semantics for setting offsets in constant buffers for a shader. The runtime sets this member to TRUE if the driver supports allowing you to specify offsets when you call new methods like the method and otherwise. If , the runtime does not expose this operation to the driver because the driver does not support it.
Note??For feature level 9.1, 9.2, and 9.3, this member is always TRUE because the option is emulated by the runtime.
BOOL ConstantBufferOffsetting
Specifies whether you can call with on a dynamic constant buffer (that is, whether the driver supports this operation). The runtime sets this member to TRUE if the driver supports this operation and otherwise. If , the runtime fails this method because the driver does not support the operation.
Note??For feature level 9.1, 9.2, and 9.3, this member is always TRUE because the option is emulated by the runtime.
BOOL MapNoOverwriteOnDynamicConstantBuffer
Specifies whether you can call with on a dynamic buffer SRV (that is, whether the driver supports this operation). The runtime sets this member to TRUE if the driver supports this operation and otherwise. If , the runtime fails this method because the driver does not support the operation.
BOOL MapNoOverwriteOnDynamicBufferSRV
Specifies whether the driver supports multisample rendering when you render with RTVs bound. If TRUE, you can set the ForcedSampleCount member of to 1 with a multisample RTV bound. The driver can support this option on feature level 10 and higher. If , the rasterizer-state creation will fail because the driver is legacy or the feature level is too low.
BOOL MultisampleRTVWithForcedSampleCountOne
Specifies whether the hardware and driver support SAD4 instructions in shaders. The runtime sets this member to TRUE if the hardware and driver support SAD4 instructions in shaders. If , the driver is legacy or the hardware does not support the option; the runtime will fail shader creation for shaders that use SAD4 instructions.
BOOL SAD4ShaderInstructions
Specifies whether the hardware and driver support extended doubles instructions in shaders. The runtime sets this member to TRUE if the hardware and driver support extended doubles instructions in shaders (shader model 5 and higher). Support of this option implies support of basic double-precision shader instructions as well. You can use the value to query for support of double-precision shaders. If , the hardware and driver do not support the option; the runtime will fail shader creation for shaders that use extended doubles instructions.
BOOL ExtendedDoublesShaderInstructions
[This documentation is preliminary and is subject to change.]
D3D11_FEATURE_DATA_D3D9_OPTIONS
Specifies whether the driver supports the nonpowers-of-2-unconditionally feature. For more information about this feature, see feature level. The runtime sets this member to TRUE for hardware at Direct3D 10 and higher feature levels. For hardware at Direct3D 9.3 and lower feature levels, the runtime sets this member to if the hardware and driver support the powers-of-2 (2D textures must have widths and heights specified as powers of two) feature or the nonpowers-of-2-conditionally feature. For more information about this feature, see feature level.
BOOL FullNonPow2TextureSupport
Describes double data type support in the current graphics driver.
If the runtime sets DoublePrecisionFloatShaderOps to TRUE, the hardware and driver support the following Shader Model 5 instructions:dadd dmax dmin dmul deq dge dlt dne dmov dmovc dtof ftodNote??If DoublePrecisionFloatShaderOps is TRUE, the hardware and driver do not necessarily support double-precision division.
D3D11_FEATURE_DATA_DOUBLES
Specifies whether double types are allowed. If TRUE, double types are allowed; otherwise . The runtime must set DoublePrecisionFloatShaderOps to TRUE in order for you to use any HLSL shader that is compiled with a double type.
BOOL DoublePrecisionFloatShaderOps
Describes which resources are supported by the current graphics driver for a given format.
D3D11_FEATURE_DATA_FORMAT_SUPPORT
to return information on.
DXGI_FORMAT InFormat
Combination of flags indicating which resources are supported.
D3D11_FORMAT_SUPPORT OutFormatSupport
Describes which unordered resource options are supported by the current graphics driver for a given format.
D3D11_FEATURE_DATA_FORMAT_SUPPORT2
to return information on.
DXGI_FORMAT InFormat
Combination of flags indicating which unordered resource options are supported.
D3D11_FORMAT_SUPPORT2 OutFormatSupport2
No documentation.
D3D11_FEATURE_DATA_SHADER_MIN_PRECISION_SUPPORT
No documentation.
unsigned int PixelShaderMinPrecision
No documentation.
unsigned int AllOtherShaderStagesMinPrecision
Describes the multi-threading features that are supported by the current graphics driver.
Use the structure with the method to determine multi-threading support.
D3D11_FEATURE_DATA_THREADING
TRUE means resources can be created concurrently on multiple threads while drawing; means that the presence of coarse synchronization will prevent concurrency.
BOOL DriverConcurrentCreates
TRUE means command lists are supported by the current driver; means that the API will emulate deferred contexts and command lists with software.
BOOL DriverCommandLists
A description of a single element for the input-assembler stage.
An input-layout object contains an array of structures, each structure defines one element being read from an input slot. Create an input-layout object by calling . For an example, see the "Create the Input-Layout Object" subtopic under the Getting Started with the Input-Assembler Stage topic.
D3D11_INPUT_ELEMENT_DESC
The HLSL semantic associated with this element in a shader input-signature.
const char* SemanticName
The semantic index for the element. A semantic index modifies a semantic, with an integer index number. A semantic index is only needed in a case where there is more than one element with the same semantic. For example, a 4x4 matrix would have four components each with the semantic name
matrix
, however each of the four component would have different semantic indices (0, 1, 2, and 3).
unsigned int SemanticIndex
The data type of the element data. See .
DXGI_FORMAT Format
An integer value that identifies the input-assembler (see input slot). Valid values are between 0 and 15, defined in D3D11.h.
unsigned int InputSlot
Optional. Offset (in bytes) between each element. Use D3D11_APPEND_ALIGNED_ELEMENT for convenience to define the current element directly after the previous one, including any packing if necessary.
unsigned int AlignedByteOffset
Identifies the input data class for a single input slot (see ).
D3D11_INPUT_CLASSIFICATION InputSlotClass
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 ).
unsigned int InstanceDataStepRate
Initializes a new instance of the struct.
The HLSL semantic associated with this element in a shader input-signature.
The semantic index for the element. A semantic index modifies a semantic, with an integer index number. A semantic index is only needed in a case where there is more than one element with the same semantic. For example, a 4x4 matrix would have four components each with the semantic name matrix, however each of the four component would have different semantic indices (0, 1, 2, and 3).
The data type of the element data.
Offset (in bytes) between each element. Use AppendAligned for convenience to define the current element directly after the previous one, including any packing if necessary.
An integer value that identifies the input-assembler. Valid values are between 0 and 15.
Identifies the input data class for a single input slot.
The number of instances to draw using the same per-instance data before advancing in the buffer by one element. This value must be 0 for an element that contains per-vertex data.
Initializes a new instance of the struct.
The HLSL semantic associated with this element in a shader input-signature.
The semantic index for the element. A semantic index modifies a semantic, with an integer index number. A semantic index is only needed in a case where there is more than one element with the same semantic. For example, a 4x4 matrix would have four components each with the semantic name matrix, however each of the four component would have different semantic indices (0, 1, 2, and 3).
The data type of the element data.
Offset (in bytes) between each element. Use AppendAligned for convenience to define the current element directly after the previous one, including any packing if necessary.
An integer value that identifies the input-assembler. Valid values are between 0 and 15.
Initializes a new instance of the struct.
The HLSL semantic associated with this element in a shader input-signature.
The semantic index for the element. A semantic index modifies a semantic, with an integer index number. A semantic index is only needed in a case where there is more than one element with the same semantic. For example, a 4x4 matrix would have four components each with the semantic name matrix, however each of the four component would have different semantic indices (0, 1, 2, and 3).
The data type of the element data.
An integer value that identifies the input-assembler. Valid values are between 0 and 15.
Determines whether the specified is equal to this instance.
The to compare with this instance.
true if the specified is equal to this instance; otherwise, false.
Implements the operator ==.
The left.
The right.
The result of the operator.
Implements the operator !=.
The left.
The right.
The result of the operator.
Returns a value that can be used for the offset parameter of an InputElement to indicate that the element
should be aligned directly after the previous element, including any packing if neccessary.
A value used to align input elements.
D3D11_APPEND_ALIGNED_ELEMENT
No documentation.
D3D11_OMAC
No documentation.
unsigned char Omac[16]
Query information about graphics-pipeline activity in between calls to and .
D3D11_QUERY_DATA_PIPELINE_STATISTICS
No documentation.
unsigned longlong IAVertices
No documentation.
unsigned longlong IAPrimitives
No documentation.
unsigned longlong VSInvocations
No documentation.
unsigned longlong GSInvocations
No documentation.
unsigned longlong GSPrimitives
No documentation.
unsigned longlong CInvocations
No documentation.
unsigned longlong CPrimitives
No documentation.
unsigned longlong PSInvocations
No documentation.
unsigned longlong HSInvocations
No documentation.
unsigned longlong DSInvocations
No documentation.
unsigned longlong CSInvocations
Query information about the reliability of a timestamp query.
For a list of query types see .
D3D11_QUERY_DATA_TIMESTAMP_DISJOINT
How frequently the GPU counter increments in Hz.
unsigned longlong Frequency
If this is TRUE, something occurred in between the query's and calls that caused the timestamp counter to become discontinuous or disjoint, such as unplugging the AC chord on a laptop, overheating, or throttling up/down due to laptop savings events. The timestamp returned by for a timestamp query is only reliable if Disjoint is .
BOOL Disjoint
Describes a query.
D3D11_QUERY_DESC
Type of query (see ).
D3D11_QUERY Query
Miscellaneous flags (see ).
D3D11_QUERY_MISC_FLAG MiscFlags
[This documentation is preliminary and is subject to change.]
Rasterizer state defines the behavior of the rasterizer stage. To set rasterizer state, call .If you do not specify some rasterizer state, the Microsoft Direct3D runtime uses the following default values for rasterizer state.StateDefault Value FillModeSolid CullModeBack FrontCounterClockwiseFALSE DepthBias0 SlopeScaledDepthBias0.0f DepthBiasClamp0.0f DepthClipEnableTRUE ScissorEnableFALSE MultisampleEnableFALSE AntialiasedLineEnableFALSE ForcedSampleCount0?
D3D11_RASTERIZER_DESC1
Determines the fill mode to use when rendering.
D3D11_FILL_MODE FillMode
Indicates that triangles facing the specified direction are not drawn.
D3D11_CULL_MODE CullMode
Depth value added to a given pixel.
int DepthBias
Maximum depth bias of a pixel.
float DepthBiasClamp
Scalar on a given pixel's slope.
float SlopeScaledDepthBias
The sample count that is forced while UAV rendering or rasterizing. Valid values are 0, 1, 2, 4, 8, and optionally 16. 0 indicates that the sample count is not forced.
unsigned int ForcedSampleCount
Specifies whether a triangle is front- or back-facing. If TRUE, a triangle will be considered front-facing if its vertices are counter-clockwise on the render target and considered back-facing if they are clockwise. If , the opposite is true.
BOOL FrontCounterClockwise
Specifies whether to enable clipping based on distance.
The hardware always performs x and y clipping of rasterized coordinates. When DepthClipEnable is set to the default?TRUE, the hardware also clips the z value (that is, the hardware performs the last step of the following algorithm).
0 < w
-w <= x <= w (or arbitrarily wider range if implementation uses a guard band to reduce clipping burden)
-w <= y <= w (or arbitrarily wider range if implementation uses a guard band to reduce clipping burden)
0 <= z <= w
When you set DepthClipEnable to , the hardware skips the z clipping (that is, the last step in the preceding algorithm). However, the hardware still performs the "0 < w" clipping. When z clipping is disabled, improper depth ordering at the pixel level might result. However, when z clipping is disabled, stencil shadow implementations are simplified. In other words, you can avoid complex special-case handling for geometry that goes beyond the back clipping plane.
BOOL DepthClipEnable
Specifies whether to enable scissor-rectangle culling. All pixels ouside an active scissor rectangle are culled.
BOOL ScissorEnable
Specifies whether to enable multisample antialiasing.
BOOL MultisampleEnable
Specifies whether to enable line antialiasing; only applies if doing line drawing and MultisampleEnable is .
BOOL AntialiasedLineEnable
Describes rasterizer state.
Rasterizer state defines the behavior of the rasterizer stage; to set rasterizer state, call .These are the default values for rasterizer state.StateDefault Value FillModeSolid CullModeBack FrontCounterClockwiseFALSE DepthBias0 SlopeScaledDepthBias0.0f DepthBiasClamp0.0f DepthClipEnableTRUE ScissorEnableFALSE MultisampleEnableFALSE AntialiasedLineEnableFALSE?
D3D11_RASTERIZER_DESC
Determines the fill mode to use when rendering (see ).
D3D11_FILL_MODE FillMode
Indicates triangles facing the specified direction are not drawn (see ).
D3D11_CULL_MODE CullMode
Depth value added to a given pixel.
int DepthBias
Maximum depth bias of a pixel.
float DepthBiasClamp
Scalar on a given pixel's slope.
float SlopeScaledDepthBias
Determines if a triangle is front- or back-facing. If this parameter is true, then 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 then the opposite is true.
BOOL FrontCounterClockwise
Enable clipping based on distance.
The hardware always performs x and y clipping of rasterized coordinates. When DepthClipEnable is set to the default?TRUE, the hardware also clips the z value (that is, the hardware performs the last step of the following algorithm).
0 < w
-w <= x <= w (or arbitrarily wider range if implementation uses a guard band to reduce clipping burden)
-w <= y <= w (or arbitrarily wider range if implementation uses a guard band to reduce clipping burden)
0 <= z <= w
When you set DepthClipEnable to , the hardware skips the z clipping (that is, the last step in the preceding algorithm). However, the hardware still performs the "0 < w" clipping. When z clipping is disabled, improper depth ordering at the pixel level might result. However, when z clipping is disabled, stencil shadow implementations are simplified. In other words, you can avoid complex special-case handling for geometry that goes beyond the back clipping plane.
BOOL DepthClipEnable
Enable scissor-rectangle culling. All pixels ouside an active scissor rectangle are culled.
BOOL ScissorEnable
Enable multisample antialiasing.
BOOL MultisampleEnable
Enable line antialiasing; only applies if doing line drawing and MultisampleEnable is false.
BOOL AntialiasedLineEnable
Describes the blend state for a render target.
For info about how blending is done, see the output-merger stage.Here are the default values for blend state.StateDefault Value BlendEnableFALSE SrcBlendD3D11_BLEND_ONE DestBlendD3D11_BLEND_ZERO BlendOpD3D11_BLEND_OP_ADD SrcBlendAlphaD3D11_BLEND_ONE DestBlendAlphaD3D11_BLEND_ZERO BlendOpAlphaD3D11_BLEND_OP_ADD RenderTargetWriteMaskD3D11_COLOR_WRITE_ENABLE_ALL?
D3D11_RENDER_TARGET_BLEND_DESC
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.
D3D11_BLEND SrcBlend
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.
D3D11_BLEND DestBlend
This blend operation defines how to combine the SrcBlend and DestBlend operations.
D3D11_BLEND_OP BlendOp
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.
D3D11_BLEND SrcBlendAlpha
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.
D3D11_BLEND DestBlendAlpha
This blend operation defines how to combine the SrcBlendAlpha and DestBlendAlpha operations.
D3D11_BLEND_OP BlendOpAlpha
A write mask.
D3D11_COLOR_WRITE_ENABLE RenderTargetWriteMask
Enable (or disable) blending.
BOOL BlendEnable
[This documentation is preliminary and is subject to change.]
For info about how blending is done, see the output-merger stage.Here are the default values for blend state.StateDefault Value BlendEnableFALSE LogicOpEnableFALSE SrcBlendD3D11_BLEND_ONE DestBlendD3D11_BLEND_ZERO BlendOpD3D11_BLEND_OP_ADD SrcBlendAlphaD3D11_BLEND_ONE DestBlendAlphaD3D11_BLEND_ZERO BlendOpAlphaD3D11_BLEND_OP_ADD RenderTargetWriteMaskD3D11_COLOR_WRITE_ENABLE_ALL?
D3D11_RENDER_TARGET_BLEND_DESC1
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.
D3D11_BLEND SrcBlend
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.
D3D11_BLEND DestBlend
This blend operation defines how to combine the SrcBlend and DestBlend operations.
D3D11_BLEND_OP BlendOp
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.
D3D11_BLEND SrcBlendAlpha
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.
D3D11_BLEND DestBlendAlpha
This blend operation defines how to combine the SrcBlendAlpha and DestBlendAlpha operations.
D3D11_BLEND_OP BlendOpAlpha
A -typed value that specifies the logical operation to configure for the render target.
D3D11_LOGIC_OP LogicOp
A write mask.
D3D11_COLOR_WRITE_ENABLE RenderTargetWriteMask
Enable (or disable) blending.
BOOL BlendEnable
Enable (or disable) a logical operation.
BOOL LogicOpEnable
Specifies the subresources from a resource that are accessible using a render-target view.
A render-target-view description is passed into to create a render target.A render-target-view cannot use the following formats:Any typeless format. DXGI_FORMAT_R32G32B32 if the view will be used to bind a buffer (vertex, index, constant, or stream-output).If the format is set to , then the format of the resource that the view binds to the pipeline will be used.
D3D11_RENDER_TARGET_VIEW_DESC
The data format (see ).
DXGI_FORMAT Format
The resource type (see ), which specifies how the render-target resource will be accessed.
D3D11_RTV_DIMENSION ViewDimension
Specifies which buffer elements can be accessed (see ).
D3D11_BUFFER_RTV Buffer
Specifies the subresources in a 1D texture that can be accessed (see ).
D3D11_TEX1D_RTV Texture1D
Specifies the subresources in a 1D texture array that can be accessed (see ).
D3D11_TEX1D_ARRAY_RTV Texture1DArray
Specifies the subresources in a 2D texture that can be accessed (see ).
D3D11_TEX2D_RTV Texture2D
Specifies the subresources in a 2D texture array that can be accessed (see ).
D3D11_TEX2D_ARRAY_RTV Texture2DArray
Specifies a single subresource because a multisampled 2D texture only contains one subresource (see ).
D3D11_TEX2DMS_RTV Texture2DMS
Specifies the subresources in a multisampled 2D texture array that can be accessed (see ).
D3D11_TEX2DMS_ARRAY_RTV Texture2DMSArray
Specifies subresources in a 3D texture that can be accessed (see ).
D3D11_TEX3D_RTV Texture3D
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_TEX2D_ARRAY_RTV
The index of the mipmap level to use mip slice.
unsigned int MipSlice
The index of the first texture to use in an array of textures.
unsigned int FirstArraySlice
Number of textures in the array to use in the render target view, starting from FirstArraySlice.
unsigned int ArraySize
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_TEX2DMS_ARRAY_RTV
The index of the first texture to use in an array of textures.
unsigned int FirstArraySlice
Number of textures to use.
unsigned int ArraySize
Specifies the subresource from a multisampled 2D texture to use in a render-target view.
Since a multisampled 2D texture contains a single subresource, there is actually nothing to specify in . Consequently, UnusedField_NothingToDefine is included so that this structure will compile in C.
D3D11_TEX2DMS_RTV
Integer of any value. See remarks.
unsigned int UnusedField_NothingToDefine
Specifies the subresource from a 1D texture to use in a render-target view.
This structure is one member of a render-target-view description (see ).
D3D11_TEX1D_RTV
The index of the mipmap level to use mip slice.
unsigned int MipSlice
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_TEX3D_RTV
The index of the mipmap level to use mip slice.
unsigned int MipSlice
First depth level to use.
unsigned int FirstWSlice
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.
unsigned int WSize
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 ). Create a render-target view by calling .
D3D11_BUFFER_RTV
Number of bytes between the beginning of the buffer and the first element to access.
unsigned int FirstElement
The offset of the first element in the view to access, relative to element 0.
unsigned int ElementOffset
The total number of elements in the view.
unsigned int NumElements
The width of each element (in bytes). This can be determined from the format stored in the render-target-view description.
unsigned int ElementWidth
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_TEX1D_ARRAY_RTV
The index of the mipmap level to use mip slice.
unsigned int MipSlice
The index of the first texture to use in an array of textures.
unsigned int FirstArraySlice
Number of textures to use.
unsigned int ArraySize
Specifies the subresource from a 2D texture to use in a render-target view.
This structure is one member of a render-target-view description (see ).
D3D11_TEX2D_RTV
The index of the mipmap level to use mip slice.
unsigned int MipSlice
Defines a 3D box.
The following diagram shows a 3D box, where the origin is the left, front, top corner.The values for right, bottom, and back are each one pixel past the end of the pixels that are included in the box region. That is, the values for left, top, and front are included in the box region while the values for right, bottom, and back are excluded from the box region. For example, for a box that is one pixel wide, (right - left) == 1; the box region includes the left pixel but not the right pixel.
D3D11_BOX
The x position of the left hand side of the box.
unsigned int left
The y position of the top of the box.
unsigned int top
The z position of the front of the box.
unsigned int front
The x position of the right hand side of the box.
unsigned int right
The y position of the bottom of the box.
unsigned int bottom
The z position of the back of the box.
unsigned int back
Describes a sampler state.
These are the default values for sampler state.StateDefault Value FilterMIN_MAG_MIP_LINEAR AddressUClamp AddressVClamp AddressWClamp MinLOD-3.402823466e+38F (-FLT_MAX) MaxLOD3.402823466e+38F (FLT_MAX) MipMapLODBias0.0f MaxAnisotropy16 ComparisonFuncNever BorderColorfloat4(0.0f,0.0f,0.0f,0.0f) TextureN/A?
D3D11_SAMPLER_DESC
Filtering method to use when sampling a texture (see ).
D3D11_FILTER Filter
Method to use for resolving a u texture coordinate that is outside the 0 to 1 range (see ).
D3D11_TEXTURE_ADDRESS_MODE AddressU
Method to use for resolving a v texture coordinate that is outside the 0 to 1 range.
D3D11_TEXTURE_ADDRESS_MODE AddressV
Method to use for resolving a w texture coordinate that is outside the 0 to 1 range.
D3D11_TEXTURE_ADDRESS_MODE AddressW
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.
float MipLODBias
Clamping value used if or is specified in Filter. Valid values are between 1 and 16.
unsigned int MaxAnisotropy
A function that compares sampled data against existing sampled data. The function options are listed in .
D3D11_COMPARISON_FUNC ComparisonFunc
Border color to use if is specified for AddressU, AddressV, or AddressW. Range must be between 0.0 and 1.0 inclusive.
SHARPDX_COLOR4 BorderColor
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.
float MinLOD
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.
float MaxLOD
Describes a shader-resource view.
A view is a format-specific way to look at the data in a resource. The view determines what data to look at, and how it is cast when read.When viewing a resource, the resource-view description must specify a typed format, that is compatible with the resource format. So that means that you cannot create a resource-view description using any format with _TYPELESS in the name. You can however view a typeless resource by specifying a typed format for the view. For example, a resource can be viewed with one of these typed formats: , , and , since these typed formats are compatible with the typeless resource.Create a shader-resource-view description by calling . To view a shader-resource-view description, call .
D3D11_SHADER_RESOURCE_VIEW_DESC
A specifying the viewing format. See remarks.
DXGI_FORMAT Format
The resource type of the view. See D3D11_SRV_DIMENSION. This should be the same as the resource type of the underlying resource. This parameter also determines which _SRV to use in the union below.
D3D_SRV_DIMENSION ViewDimension
View the resource as a buffer using information from a shader-resource view (see ).
D3D11_BUFFER_SRV Buffer
View the resource as a 1D texture using information from a shader-resource view (see ).
D3D11_TEX1D_SRV Texture1D
View the resource as a 1D-texture array using information from a shader-resource view (see ).
D3D11_TEX1D_ARRAY_SRV Texture1DArray
View the resource as a 2D-texture using information from a shader-resource view (see ).
D3D11_TEX2D_SRV Texture2D
View the resource as a 2D-texture array using information from a shader-resource view (see ).
D3D11_TEX2D_ARRAY_SRV Texture2DArray
View the resource as a 2D-multisampled texture using information from a shader-resource view (see ).
D3D11_TEX2DMS_SRV Texture2DMS
View the resource as a 2D-multisampled-texture array using information from a shader-resource view (see ).
D3D11_TEX2DMS_ARRAY_SRV Texture2DMSArray
View the resource as a 3D texture using information from a shader-resource view (see ).
D3D11_TEX3D_SRV Texture3D
View the resource as a 3D-cube texture using information from a shader-resource view (see ).
D3D11_TEXCUBE_SRV TextureCube
View the resource as a 3D-cube-texture array using information from a shader-resource view (see ).
D3D11_TEXCUBE_ARRAY_SRV TextureCubeArray
View the resource as an extended buffer using information from a shader-resource view (see ).
D3D11_BUFFEREX_SRV BufferEx
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_TEX2D_ARRAY_SRV
Index of the most detailed mipmap level to use; this number is between 0 and MipLevels (from the original Texture2D for which creates a view) -1.
unsigned int MostDetailedMip
The maximum number of mipmap levels for the view of the texture. See the remarks in .
Set to -1 to indicate all the mipmap levels from MostDetailedMip on down to least detailed.
unsigned int MipLevels
The index of the first texture to use in an array of textures.
unsigned int FirstArraySlice
Number of textures in the array.
unsigned int ArraySize
Describes a raw buffer resource.
This structure is used by to create a raw buffer.
D3D11_BUFFEREX_SRV
The index of the first element to be accessed by the view.
unsigned int FirstElement
The number of elements in the resource.
unsigned int NumElements
Options for binding a raw buffer (see ).
D3D11_BUFFEREX_SRV_FLAG Flags
Specifies the elements in a buffer resource to use in a shader-resource view.
The structure is a member of the structure, which represents a shader-resource view description. You can create a shader-resource view by calling the method.
D3D11_BUFFER_SRV
Number of bytes between the beginning of the buffer and the first element to access.
unsigned int FirstElement
The offset of the first element in the view to access, relative to element 0.
unsigned int ElementOffset
The total number of elements in the view.
unsigned int NumElements
The width of each element (in bytes). This can be determined from the format stored in the shader-resource-view description.
unsigned int ElementWidth
Specifies the subresource from a 1D texture to use in a shader-resource view.
This structure is one member of a shader-resource-view description (see ).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 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.
D3D11_TEX1D_SRV
Index of the most detailed mipmap level to use; this number is between 0 and MipLevels (from the original Texture1D for which creates a view) -1.
unsigned int MostDetailedMip
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.
unsigned int MipLevels
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_TEX1D_ARRAY_SRV
Index of the most detailed mipmap level to use; this number is between 0 and MipLevels (from the original Texture1D for which creates a view) -1.
unsigned int MostDetailedMip
The maximum number of mipmap levels for the view of the texture. See the remarks in .
Set to -1 to indicate all the mipmap levels from MostDetailedMip on down to least detailed.
unsigned int MipLevels
The index of the first texture to use in an array of textures.
unsigned int FirstArraySlice
Number of textures in the array.
unsigned int ArraySize
Specifies the subresource from a 2D texture to use in a shader-resource view.
This structure is one member of a shader-resource-view description (see ).
D3D11_TEX2D_SRV
Index of the most detailed mipmap level to use; this number is between 0 and MipLevels (from the original Texture2D for which creates a view) -1.
unsigned int MostDetailedMip
The maximum number of mipmap levels for the view of the texture. See the remarks in .
Set to -1 to indicate all the mipmap levels from MostDetailedMip on down to least detailed.
unsigned int MipLevels
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 . Consequently, UnusedField_NothingToDefine is included so that this structure will compile in C.
D3D11_TEX2DMS_SRV
Integer of any value. See remarks.
unsigned int UnusedField_NothingToDefine
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_TEX2DMS_ARRAY_SRV
The index of the first texture to use in an array of textures.
unsigned int FirstArraySlice
Number of textures to use.
unsigned int ArraySize
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_TEX3D_SRV
Index of the most detailed mipmap level to use; this number is between 0 and MipLevels (from the original Texture3D for which creates a view) -1.
unsigned int MostDetailedMip
The maximum number of mipmap levels for the view of the texture. See the remarks in .
Set to -1 to indicate all the mipmap levels from MostDetailedMip on down to least detailed.
unsigned int MipLevels
Specifies the subresource from a cube texture to use in a shader-resource view.
This structure is one member of a shader-resource-view description (see ).
D3D11_TEXCUBE_SRV
Index of the most detailed mipmap level to use; this number is between 0 and MipLevels (from the original TextureCube for which creates a view) -1.
unsigned int MostDetailedMip
The maximum number of mipmap levels for the view of the texture. See the remarks in .
Set to -1 to indicate all the mipmap levels from MostDetailedMip on down to least detailed.
unsigned int MipLevels
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_TEXCUBE_ARRAY_SRV
Index of the most detailed mipmap level to use; this number is between 0 and MipLevels (from the original TextureCube for which creates a view) -1.
unsigned int MostDetailedMip
The maximum number of mipmap levels for the view of the texture. See the remarks in .
Set to -1 to indicate all the mipmap levels from MostDetailedMip on down to least detailed.
unsigned int MipLevels
Index of the first 2D texture to use.
unsigned int First2DArrayFace
Number of cube textures in the array.
unsigned int NumCubes
Description of a vertex element in a vertex buffer in an output slot.
D3D11_SO_DECLARATION_ENTRY
Zero-based, stream number.
unsigned int Stream
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.
const char* SemanticName
Output element's zero-based index. Should be used if, for example, you have more than one texture coordinate stored in each vertex.
unsigned int SemanticIndex
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.
unsigned char StartComponent
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.
unsigned char ComponentCount
The associated stream output buffer that is bound to the pipeline (see ). The valid range for OutputSlot is 0 to 3.
unsigned char OutputSlot
Query information about the amount of data streamed out to the stream-output buffers in between and .
D3D11_QUERY_DATA_SO_STATISTICS
No documentation.
unsigned longlong NumPrimitivesWritten
No documentation.
unsigned longlong PrimitivesStorageNeeded
Describes a 1D texture.
This structure is used in a call to . A helpful derived structure CD3D11_TEXTURE1D_DESC is declared in D3D11.h, 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 () and call to create an , you must constrain the maximum texture size to (8192) when you create your 1D texture.
D3D11_TEXTURE1D_DESC
Texture width (in texels). The range is from 1 to (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.
unsigned int Width
The maximum number of mipmap levels in the texture. See the remarks in . Use 1 for a multisampled texture; or 0 to generate a full set of subtextures.
unsigned int MipLevels
Number of textures in the array. The range is from 1 to (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.
unsigned int ArraySize
Texture format (see ).
DXGI_FORMAT Format
Value that identifies how the texture is to be read from and written to. The most common value is ; see for all possible values.
D3D11_USAGE Usage
Flags (see ) for binding to pipeline stages. The flags can be combined by a logical OR. For a 1D texture, the allowable values are: , and .
D3D11_BIND_FLAG BindFlags
Flags (see ) to specify the types of CPU access allowed. Use 0 if CPU access is not required. These flags can be combined with a logical OR.
D3D11_CPU_ACCESS_FLAG CPUAccessFlags
Flags (see ) that identify other, less common resource options. Use 0 if none of these flags apply. These flags can be combined with a logical OR.
D3D11_RESOURCE_MISC_FLAG MiscFlags
[This documentation is preliminary and is subject to change.]
D3D11_TEX2D_ARRAY_VPOV
The zero-based index into the array of subtextures.
unsigned int MipSlice
The index of the first texture to use.
unsigned int FirstArraySlice
The number of textures in the array.
unsigned int ArraySize
Describes a 2D texture.
This structure is used in a call to . A helpful derived structure CD3D11_TEXTURE2D_DESC is declared in D3D11.h, 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 () and call to create an , you must constrain the maximum texture size to (8192) when you create your 2D texture.
D3D11_TEXTURE2D_DESC
Texture width (in texels). The range is from 1 to (16384). For a texture cube-map, the range is from 1 to (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.
unsigned int Width
Texture height (in texels). The range is from 1 to (16384). For a texture cube-map, the range is from 1 to (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.
unsigned int Height
The maximum number of mipmap levels in the texture. See the remarks in . Use 1 for a multisampled texture; or 0 to generate a full set of subtextures.
unsigned int MipLevels
Number of textures in the texture array. The range is from 1 to (2048). For a texture cube-map, this value is a multiple of 6 (that is, 6 times the value in the NumCubes member of ), and the range is from 6 to . The range is actually constrained by the feature level at which you create the rendering device. For more information about restrictions, see Remarks.
unsigned int ArraySize
Texture format (see ).
DXGI_FORMAT Format
Structure that specifies multisampling parameters for the texture. See .
DXGI_SAMPLE_DESC SampleDesc
Value that identifies how the texture is to be read from and written to. The most common value is ; see for all possible values.
D3D11_USAGE Usage
Flags (see ) for binding to pipeline stages. The flags can be combined by a logical OR.
D3D11_BIND_FLAG BindFlags
Flags (see ) to specify the types of CPU access allowed. Use 0 if CPU access is not required. These flags can be combined with a logical OR.
D3D11_CPU_ACCESS_FLAG CPUAccessFlags
Flags (see ) that identify other, less common resource options. Use 0 if none of these flags apply. These flags can be combined by using a logical OR. For a texture cube-map, set the flag. Cube-map arrays (that is, ArraySize > 6) require feature level or higher.
D3D11_RESOURCE_MISC_FLAG MiscFlags
[This documentation is preliminary and is subject to change.]
D3D11_TEX2D_VDOV
The zero-based index of the texture.
unsigned int ArraySlice
[This documentation is preliminary and is subject to change.]
D3D11_TEX2D_VPIV
The zero-based index into the array of subtextures.
unsigned int MipSlice
The zero-based index of the texture.
unsigned int ArraySlice
[This documentation is preliminary and is subject to change.]
D3D11_TEX2D_VPOV
The zero-based index into the array of subtextures.
unsigned int MipSlice
Describes a 3D texture.
This structure is used in a call to . A helpful derived structure CD3D11_TEXTURE3D_DESC is declared in D3D11.h, 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 () and call to create an , you must constrain the maximum texture size to (2048) when you create your 3D texture.
D3D11_TEXTURE3D_DESC
Texture width (in texels). The range is from 1 to (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.
unsigned int Width
Texture height (in texels). The range is from 1 to (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.
unsigned int Height
Texture depth (in texels). The range is from 1 to (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.
unsigned int Depth
The maximum number of mipmap levels in the texture. See the remarks in . Use 1 for a multisampled texture; or 0 to generate a full set of subtextures.
unsigned int MipLevels
Texture format (see ).
DXGI_FORMAT Format
Value that identifies how the texture is to be read from and written to. The most common value is ; see for all possible values.
D3D11_USAGE Usage
Flags (see ) for binding to pipeline stages. The flags can be combined by a logical OR.
D3D11_BIND_FLAG BindFlags
Flags (see ) to specify the types of CPU access allowed. Use 0 if CPU access is not required. These flags can be combined with a logical OR.
D3D11_CPU_ACCESS_FLAG CPUAccessFlags
Flags (see ) that identify other, less common resource options. Use 0 if none of these flags apply. These flags can be combined with a logical OR.
D3D11_RESOURCE_MISC_FLAG MiscFlags
Specifies the subresources from a resource that are accessible using an unordered-access view.
An unordered-access-view description is passed into to create a view.
D3D11_UNORDERED_ACCESS_VIEW_DESC
The data format (see ).
DXGI_FORMAT Format
The resource type (see ), which specifies how the resource will be accessed.
D3D11_UAV_DIMENSION ViewDimension
Specifies which buffer elements can be accessed (see ).
D3D11_BUFFER_UAV Buffer
Specifies the subresources in a 1D texture that can be accessed (see ).
D3D11_TEX1D_UAV Texture1D
Specifies the subresources in a 1D texture array that can be accessed (see ).
D3D11_TEX1D_ARRAY_UAV Texture1DArray
Specifies the subresources in a 2D texture that can be accessed (see ).
D3D11_TEX2D_UAV Texture2D
Specifies the subresources in a 2D texture array that can be accessed (see ).
D3D11_TEX2D_ARRAY_UAV Texture2DArray
Specifies subresources in a 3D texture that can be accessed (see ).
D3D11_TEX3D_UAV Texture3D
Describes a unordered-access 1D texture resource.
This structure is used by a .
D3D11_TEX1D_UAV
The mipmap slice index.
unsigned int MipSlice
Describes an array of unordered-access 1D texture resources.
This structure is used by a .
D3D11_TEX1D_ARRAY_UAV
The mipmap slice index.
unsigned int MipSlice
The zero-based index of the first array slice to be accessed.
unsigned int FirstArraySlice
The number of slices in the array.
unsigned int ArraySize
Describes a unordered-access 2D texture resource.
This structure is used by a .
D3D11_TEX2D_UAV
The mipmap slice index.
unsigned int MipSlice
Describes a unordered-access 3D texture resource.
This structure is used by a .
D3D11_TEX3D_UAV
The mipmap slice index.
unsigned int MipSlice
The zero-based index of the first depth slice to be accessed.
unsigned int FirstWSlice
The number of depth slices.
unsigned int WSize
Describes an array of unordered-access 2D texture resources.
This structure is used by a .
D3D11_TEX2D_ARRAY_UAV
The mipmap slice index.
unsigned int MipSlice
The zero-based index of the first array slice to be accessed.
unsigned int FirstArraySlice
The number of slices in the array.
unsigned int ArraySize
Unordered-access-view buffer options.
D3D11_BUFFER_UAV
Resource contains raw, unstructured data. Requires the UAV format to be .
unsigned int FirstElement
Allow data to be appended to the end of the buffer. flag must also be used for any view that will be used as a AppendStructuredBuffer or a ConsumeStructuredBuffer. Requires the UAV format to be .
unsigned int NumElements
Adds a counter to the unordered-access-view buffer. can only be used on a UAV that is a RWStructuredBuffer and it enables the functionality needed for the IncrementCounter and DecrementCounter methods in HLSL. Requires the UAV format to be .
D3D11_BUFFER_UAV_FLAG Flags
[This documentation is preliminary and is subject to change.]
Values have a nominal range of [0...1]. Given a format with n bits per channel, the value of each color component is calculated as follows:val = f * ((1 << n)-1)For example, for 8-bit YUV formats, val = BYTE(f * 255.0). Reference black is (0.0625, 0.5, 0.5), which corresponds to (16, 128, 128) in an 8-bit representation.
D3D11_VIDEO_COLOR
The Y (luma) value.
D3D11_VIDEO_COLOR_YCbCrA YCbCr
The Cb chroma value.
D3D11_VIDEO_COLOR_RGBA RGBA
No documentation.
D3D11_VIDEO_COLOR_RGBA
No documentation.
float R
No documentation.
float G
No documentation.
float B
No documentation.
float A
No documentation.
D3D11_VIDEO_COLOR_YCbCrA
No documentation.
float Y
No documentation.
float Cb
No documentation.
float Cr
No documentation.
float A
No documentation.
D3D11_VIDEO_CONTENT_PROTECTION_CAPS
No documentation.
unsigned int Caps
No documentation.
unsigned int KeyExchangeTypeCount
No documentation.
unsigned int BlockAlignmentSize
No documentation.
unsigned longlong ProtectedMemorySize
No documentation.
D3D11_VIDEO_DECODER_BUFFER_DESC
No documentation.
D3D11_VIDEO_DECODER_BUFFER_TYPE BufferType
No documentation.
unsigned int BufferIndex
No documentation.
unsigned int DataOffset
No documentation.
unsigned int DataSize
No documentation.
unsigned int FirstMBaddress
No documentation.
unsigned int NumMBsInBuffer
No documentation.
unsigned int Width
No documentation.
unsigned int Height
No documentation.
unsigned int Stride
No documentation.
unsigned int ReservedBits
No documentation.
void* pIV
No documentation.
unsigned int IVSize
No documentation.
D3D11_ENCRYPTED_BLOCK_INFO EncryptedBlockInfo
No documentation.
BOOL PartialEncryption
[This documentation is preliminary and is subject to change.]
D3D11_VIDEO_DECODER_CONFIG
Defines the encryption protocol type for bit-stream data buffers. If no encryption is applied, the value is DXVA_NoEncrypt. If ConfigBitstreamRaw is 0, the value must be DXVA_NoEncrypt.
GUID guidConfigBitstreamEncryption
Defines the encryption protocol type for macroblock control data buffers. If no encryption is applied, the value is DXVA_NoEncrypt. If ConfigBitstreamRaw is 1, the value must be DXVA_NoEncrypt.
GUID guidConfigMBcontrolEncryption
Defines the encryption protocol type for residual difference decoding data buffers (buffers containing spatial-domain data or sets of transform-domain coefficients for accelerator-based inverse discrete cosine transform [IDCT]). If no encryption is applied, the value is DXVA_NoEncrypt. If ConfigBitstreamRaw is 1, the value must be DXVA_NoEncrypt.
GUID guidConfigResidDiffEncryption
Indicates whether the host-decoder sends raw bit-stream data. If the value is 1, the data for the pictures will be sent in bit-stream buffers as raw bit-stream content. If the value is 0, picture data will be sent using macroblock control command buffers. If either ConfigResidDiffHost or ConfigResidDiffAccelerator is 1, the value must be 0.
unsigned int ConfigBitstreamRaw
Specifies whether macroblock control commands are in raster scan order or in arbitrary order. If the value is 1, the macroblock control commands within each macroblock control command buffer are in raster-scan order. If the value is 0, the order is arbitrary. For some types of bit streams, forcing raster order either greatly increases the number of required macroblock control buffers that must be processed, or requires host reordering of the control information. Therefore, supporting arbitrary order can be more efficient.
unsigned int ConfigMBcontrolRasterOrder
Contains the host residual difference configuration. If the value is 1, some residual difference decoding data may be sent as blocks in the spatial domain from the host. If the value is 0, spatial domain data will not be sent.
unsigned int ConfigResidDiffHost
Indicates the word size used to represent residual difference spatial-domain blocks for predicted (non-intra) pictures when using host-based residual difference decoding.
If ConfigResidDiffHost is 1 and ConfigSpatialResid8 is 1, the host will send residual difference spatial-domain blocks for non-intra macroblocks using 8-bit signed samples and for intra macroblocks in predicted (non-intra) pictures in a format that depends on the value of ConfigIntraResidUnsigned:
If ConfigIntraResidUnsigned is 0, spatial-domain blocks for intra macroblocks are sent as 8-bit signed integer values relative to a constant reference value of 2^(BPP?1). If ConfigIntraResidUnsigned is 1, spatial-domain blocks for intra macroblocks are sent as 8-bit unsigned integer values relative to a constant reference value of 0. If ConfigResidDiffHost is 1 and ConfigSpatialResid8 is 0, the host will send residual difference spatial-domain blocks of data for non-intra macroblocks using 16-bit signed samples and for intra macroblocks in predicted (non-intra) pictures in a format that depends on the value of ConfigIntraResidUnsigned:
If ConfigIntraResidUnsigned is 0, spatial domain blocks for intra macroblocks are sent as 16-bit signed integer values relative to a constant reference value of 2^(BPP?1). If ConfigIntraResidUnsigned is 1, spatial domain blocks for intra macroblocks are sent as 16-bit unsigned integer values relative to a constant reference value of 0. If ConfigResidDiffHost is 0, ConfigSpatialResid8 must be 0.
For intra pictures, spatial-domain blocks must be sent using 8-bit samples if bits-per-pixel (BPP) is 8, and using 16-bit samples if BPP > 8. If ConfigIntraResidUnsigned is 0, these samples are sent as signed integer values relative to a constant reference value of 2^(BPP?1), and if ConfigIntraResidUnsigned is 1, these samples are sent as unsigned integer values relative to a constant reference value of 0.
unsigned int ConfigSpatialResid8
If the value is 1, 8-bit difference overflow blocks are subtracted rather than added. The value must be 0 unless ConfigSpatialResid8 is 1.
The ability to subtract differences rather than add them enables 8-bit difference decoding to be fully compliant with the full ?255 range of values required in video decoder specifications, because +255 cannot be represented as the addition of two signed 8-bit numbers, but any number in the range ?255 can be represented as the difference between two signed 8-bit numbers (+255 = +127 minus ?128).
unsigned int ConfigResid8Subtraction
If the value is 1, spatial-domain blocks for intra macroblocks must be clipped to an 8-bit range on the host and spatial-domain blocks for non-intra macroblocks must be clipped to a 9-bit range on the host. If the value is 0, no such clipping is necessary by the host.
The value must be 0 unless ConfigSpatialResid8 is 0 and ConfigResidDiffHost is 1.
unsigned int ConfigSpatialHost8or9Clipping
If the value is 1, any spatial-domain residual difference data must be sent in a chrominance-interleaved form matching the YUV format chrominance interleaving pattern. The value must be 0 unless ConfigResidDiffHost is 1 and the YUV format is NV12 or NV21.
unsigned int ConfigSpatialResidInterleaved
Indicates the method of representation of spatial-domain blocks of residual difference data for intra blocks when using host-based difference decoding.
If ConfigResidDiffHost is 1 and ConfigIntraResidUnsigned is 0, spatial-domain residual difference data blocks for intra macroblocks must be sent as follows:
In a non-intra picture, if ConfigSpatialResid8 is 0, the spatial-domain residual difference data blocks for intra macroblocks are sent as 16-bit signed integer values relative to a constant reference value of 2^(BPP?1). In a non-intra picture, if ConfigSpatialResid8 is 1, the spatial-domain residual difference data blocks for intra macroblocks are sent as 8-bit signed integer values relative to a constant reference value of 2^(BPP?1). In an intra picture, if BPP is 8, the spatial-domain residual difference data blocks for intra macroblocks are sent as 8-bit signed integer values relative to a constant reference value of 2^(BPP?1), regardless of the value of ConfigSpatialResid8. If ConfigResidDiffHost is 1 and ConfigIntraResidUnsigned is 1, spatial-domain residual difference data blocks for intra macroblocks must be sent as follows:
In a non-intra picture, if ConfigSpatialResid8 is 0, the spatial-domain residual difference data blocks for intra macroblocks must be sent as 16-bit unsigned integer values relative to a constant reference value of 0. In a non-intra picture, if ConfigSpatialResid8 is 1, the spatial-domain residual difference data blocks for intra macroblocks are sent as 8-bit unsigned integer values relative to a constant reference value of 0. In an intra picture, if BPP is 8, the spatial-domain residual difference data blocks for intra macroblocks are sent as 8-bit unsigned integer values relative to a constant reference value of 0, regardless of the value of ConfigSpatialResid8. The value of the member must be 0 unless ConfigResidDiffHost is 1.
unsigned int ConfigIntraResidUnsigned
If the value is 1, transform-domain blocks of coefficient data may be sent from the host for accelerator-based IDCT. If the value is 0, accelerator-based IDCT will not be used. If both ConfigResidDiffHost and ConfigResidDiffAccelerator are 1, this indicates that some residual difference decoding will be done on the host and some on the accelerator, as indicated by macroblock-level control commands.
The value must be 0 if ConfigBitstreamRaw is 1.
unsigned int ConfigResidDiffAccelerator
If the value is 1, the inverse scan for transform-domain block processing will be performed on the host, and absolute indices will be sent instead for any transform coefficients. If the value is 0, the inverse scan will be performed on the accelerator.
The value must be 0 if ConfigResidDiffAccelerator is 0 or if Config4GroupedCoefs is 1.
unsigned int ConfigHostInverseScan
If the value is 1, the IDCT specified in Annex W of ITU-T Recommendation H.263 is used. If the value is 0, any compliant IDCT can be used for off-host IDCT.
The H.263 annex does not comply with the IDCT requirements of MPEG-2 corrigendum 2, so the value must not be 1 for use with MPEG-2 video.
The value must be 0 if ConfigResidDiffAccelerator is 0, indicating purely host-based residual difference decoding.
unsigned int ConfigSpecificIDCT
If the value is 1, transform coefficients for off-host IDCT will be sent using the DXVA_TCoef4Group structure. If the value is 0, the DXVA_TCoefSingle structure is used. The value must be 0 if ConfigResidDiffAccelerator is 0 or if ConfigHostInverseScan is 1.
unsigned int Config4GroupedCoefs
Specifies how many frames the decoder device processes at any one time.
unsigned short ConfigMinRenderTargetBuffCount
Contains decoder-specific configuration information.
unsigned short ConfigDecoderSpecific
[This documentation is preliminary and is subject to change.]
D3D11_VIDEO_DECODER_DESC
The DirectX Video Acceleration (DXVA) decoding profile. To get the list of profiles supported by the device, call the method.
GUID Guid
The width of the video frame, in pixels.
unsigned int SampleWidth
The height of the video frame, in pixels.
unsigned int SampleHeight
The output surface format, specified as a value.
DXGI_FORMAT OutputFormat
[This documentation is preliminary and is subject to change.]
The exact meaning of each structure member depends on the value of Function.
D3D11_VIDEO_DECODER_EXTENSION
No documentation.
unsigned int Function
No documentation.
void* pPrivateInputData
No documentation.
unsigned int PrivateInputDataSize
No documentation.
void* pPrivateOutputData
No documentation.
unsigned int PrivateOutputDataSize
No documentation.
unsigned int ResourceCount
No documentation.
ID3D11Resource** ppResourceList
No documentation.
D3D11_VIDEO_DECODER_OUTPUT_VIEW_DESC
No documentation.
GUID DecodeProfile
No documentation.
D3D11_VDOV_DIMENSION ViewDimension
No documentation.
D3D11_TEX2D_VDOV Texture2D
No documentation.
D3D11_VIDEO_PROCESSOR_CAPS
No documentation.
unsigned int DeviceCaps
No documentation.
unsigned int FeatureCaps
No documentation.
unsigned int FilterCaps
No documentation.
unsigned int InputFormatCaps
No documentation.
unsigned int AutoStreamCaps
No documentation.
unsigned int StereoCaps
No documentation.
unsigned int RateConversionCapsCount
No documentation.
unsigned int MaxInputStreams
No documentation.
unsigned int MaxStreamStates
[This documentation is preliminary and is subject to change.]
The RGB_Range member applies to RGB output, while the YCbCr_Matrix and YCbCr_xvYCC members apply to YCbCr output. If the driver performs color-space conversion on the background color, it uses the values that apply to both color spaces.If the driver supports extended YCbCr (xvYCC), it returns the capabilities flag in the method. Otherwise, the driver ignores the value of YCbCr_xvYCC and treats all YCbCr output as conventional YCbCr.If extended YCbCr is supported, it can be used with either transfer matrix. Extended YCbCr does not change the black point or white point?the black point is still 16 and the white point is still 235. However, extended YCbCr explicitly allows blacker-than-black values in the range 1?15, and whiter-than-white values in the range 236?254. When extended YCbCr is used, the driver should not clip the luma values to the nominal 16?235 range.
D3D11_VIDEO_PROCESSOR_COLOR_SPACE
Reserved. Set to zero.
unsigned int Reserved
[This documentation is preliminary and is subject to change.]
D3D11_VIDEO_PROCESSOR_CONTENT_DESC
A member of the enumeration that describes how the video stream is interlaced.
D3D11_VIDEO_FRAME_FORMAT InputFrameFormat
The frame rate of the input video stream, specified as a structure.
DXGI_RATIONAL InputFrameRate
The width of the input frames, in pixels.
unsigned int InputWidth
The height of the input frames, in pixels.
unsigned int InputHeight
The frame rate of the output video stream, specified as a structure.
DXGI_RATIONAL OutputFrameRate
The width of the output frames, in pixels.
unsigned int OutputWidth
The height of the output frames, in pixels.
unsigned int OutputHeight
A member of the enumeration that describes how the video processor will be used. The value indicates the desired trade-off between speed and video quality. The driver uses this flag as a hint when it creates the video processor.
D3D11_VIDEO_USAGE Usage
[This documentation is preliminary and is subject to change.]
The CustomRate member gives the rate conversion factor, while the remaining members define the pattern of input and output samples.
D3D11_VIDEO_PROCESSOR_CUSTOM_RATE
The ratio of the output frame rate to the input frame rate, expressed as a structure that holds a rational number.
DXGI_RATIONAL CustomRate
The number of output frames that will be generated for every N input samples, where N = InputFramesOrFields.
unsigned int OutputFrames
The number of input fields or frames for every N output frames that will be generated, where N = OutputFrames.
unsigned int InputFramesOrFields
If TRUE, the input stream must be interlaced. Otherwise, the input stream must be progressive.
BOOL InputInterlaced
[This documentation is preliminary and is subject to change.]
The multiplier enables the filter range to have a fractional step value.For example, a hue filter might have an actual range of [?180.0 ... +180.0] with a step size of 0.25. The device would report the following range and multiplier:Minimum: ?720 Maximum: +720 Multiplier: 0.25In this case, a filter value of 2 would be interpreted by the device as 0.50 (or 2 ? 0.25).The device should use a multiplier that can be represented exactly as a base-2 fraction.
D3D11_VIDEO_PROCESSOR_FILTER_RANGE
The minimum value of the filter.
int Minimum
The maximum value of the filter.
int Maximum
The default value of the filter.
int Default
A multiplier. Use the following formula to translate the filter setting into the actual filter value: Actual Value = Set Value???Multiplier.
float Multiplier
No documentation.
D3D11_VIDEO_PROCESSOR_INPUT_VIEW_DESC
No documentation.
unsigned int FourCC
No documentation.
D3D11_VPIV_DIMENSION ViewDimension
No documentation.
D3D11_TEX2D_VPIV Texture2D
[This documentation is preliminary and is subject to change.]
D3D11_VIDEO_PROCESSOR_OUTPUT_VIEW_DESC
The resource type of the view, specified as a member of the enumeration.
D3D11_VPOV_DIMENSION ViewDimension
A structure that identifies the texture resource for the output view.
Use this member of the union when ViewDimension equals .
D3D11_TEX2D_VPOV Texture2D
A structure that identifies the texture array for the output view.
Use this member of the union when ViewDimension equals .
D3D11_TEX2D_ARRAY_VPOV Texture2DArray
No documentation.
D3D11_VIDEO_PROCESSOR_RATE_CONVERSION_CAPS
No documentation.
unsigned int PastFrames
No documentation.
unsigned int FutureFrames
No documentation.
unsigned int ProcessorCaps
No documentation.
unsigned int ITelecineCaps
No documentation.
unsigned int CustomRateCount
No documentation.
D3D11_VIDEO_PROCESSOR_STREAM
No documentation.
unsigned int OutputIndex
No documentation.
unsigned int InputFrameOrField
No documentation.
unsigned int PastFrames
No documentation.
unsigned int FutureFrames
No documentation.
ID3D11VideoProcessorInputView** ppPastSurfaces
No documentation.
ID3D11VideoProcessorInputView* pInputSurface
No documentation.
ID3D11VideoProcessorInputView** ppFutureSurfaces
No documentation.
ID3D11VideoProcessorInputView** ppPastSurfacesRight
No documentation.
ID3D11VideoProcessorInputView* pInputSurfaceRight
No documentation.
ID3D11VideoProcessorInputView** ppFutureSurfacesRight
No documentation.
BOOL Enable
Defines the dimensions of a viewport.
In all cases, Width and Height must be >= 0 and TopLeftX + Width and TopLeftY + Height must be <= D3D11_VIEWPORT_BOUNDS_MAX.Viewport Sizes and Feature Level Support Differences between Direct3D 11 and Direct3D 10:
The range for the minimum and maximum viewport size is dependent on the feature level defined by .
Direct3D 11 supports fractional viewports; the parameter types are floating-point numbers. The feature level, , supports (D3D11_VIEWPORT_BOUNDS_MIN, D3D11_VIEWPORT_BOUNDS_MAX) values between (-32768, 32,767). Direct3D 10 does not support fractional viewports. The feature levels, (or below), supports (D3D10_VIEWPORT_BOUNDS_MIN, D3D10_VIEWPORT_BOUNDS_MAX) values between (-16384, 16383).?
D3D11_VIEWPORT
X position of the left hand side of the viewport. Ranges between D3D11_VIEWPORT_BOUNDS_MIN and D3D11_VIEWPORT_BOUNDS_MAX.
float TopLeftX
Y position of the top of the viewport. Ranges between D3D11_VIEWPORT_BOUNDS_MIN and D3D11_VIEWPORT_BOUNDS_MAX.
float TopLeftY
Width of the viewport.
float Width
Height of the viewport.
float Height
Minimum depth of the viewport. Ranges between 0 and 1.
float MinDepth
Maximum depth of the viewport. Ranges between 0 and 1.
float MaxDepth
Initializes a new instance of the structure.
The X coordinate of the viewport.
The Y coordinate of the viewport.
The width of the viewport.
The height of the viewport.
The minimum Z distance of the viewport.
The maximum Z distance of the viewport.
Initializes a new instance of the structure.
The X coordinate of the viewport.
The Y coordinate of the viewport.
The width of the viewport.
The height of the viewport.
The default value for load options.
Properties defining the way a buffer is bound to the pipeline as a target for stream output operations.
Initializes a new instance of the struct.
The buffer being bound.
The offset to the first vertex (in bytes).
Gets or sets the buffer being bound.
Gets or sets the offset from the start of the buffer of the first vertex to use (in bytes).
Properties defining the way a buffer (containing vertex data) is bound
to the pipeline for rendering.
Initializes a new instance of the struct.
The buffer being bound.
The stride between vertex element (in bytes).
The offset to the first vertex (in bytes).
Gets or sets the buffer being bound.
Gets or sets the stride between vertex elements in the buffer (in bytes).
Gets or sets the offset from the start of the buffer of the first vertex to use (in bytes).