Gets a description of how a resource is bound to a function.
/// ///A zero-based resource index.
A reference to a
A reference to a
A shader consists of executable code (the compiled HLSL functions) and a set of resources that supply the shader with input data. GetResourceBindingDesc gets info about how one resource in the set is bound as an input to the shader. The ResourceIndex parameter specifies the index for the resource.
///Gets a description of how a resource is bound to a function.
/// ///Resource name.
A reference to a
A reference to a
A shader consists of executable code (the compiled HLSL functions) and a set of resources that supply the shader with input data. GetResourceBindingDesc gets info about how one resource in the set is bound as an input to the shader. The ResourceIndex parameter specifies the index for the resource.
///You cannot use GetFrameStatistics for swap chains that both use the bit-block transfer (bitblt) presentation model and draw in windowed mode.
You can only use GetFrameStatistics for swap chains that either use the flip presentation model or draw in full-screen mode. You set the
Starting with Direct3D 11.1, we recommend to instead use
For the best performance when flipping swap-chain buffers in a full-screen application, see Full-Screen Application Performance Hints.
Because calling Present might cause the render thread to wait on the message-pump thread, be careful when calling this method in an application that uses multiple threads. For more details, see Multithreading Considerations.
| Differences between Direct3D 9 and Direct3D 10: Specifying |
?
For flip presentation model swap chains that you create with the
For info about how data values change when you present content to the screen, see Converting data for the color space.
///[This documentation is preliminary and is subject to change.]
Gets the source region used for the swap chain.
Use GetSourceSize to get the portion of the swap chain from which the operating system presents. The source rectangle is always defined by the region [0, 0, Width, Height]. Use SetSourceSize to set this portion of the swap chain.
///This method can return error codes that are described in the DXGI_ERROR topic.
The baselineOriginX, baslineOriginY, measuringMethod, and glyphRun parameters are provided (as arguments) when the callback method is invoked. The renderingParams, textColor and blackBoxRect are not.
Default rendering params can be retrieved by using the
Whether the glyphs are rotated on their side, which is the default case for CJK and the case stacked Latin
Whether the script should be shaped as right-to-left. For Arabic stacked top-to-bottom, even when the adjusted bidi level is coerced to an even level, this will still be true.
Returns a successful code or an error code to abort analysis.
The text analyzer calls back to this to get the desired glyph orientation and resolved bidi level, which it uses along with the script properties of the text to determine the actual orientation of each character, which it reports back to the client via the sink SetGlyphOrientation method.
///Length to analyze.
Length to analyze.
If this method succeeds, it returns
If SetSize is not called prior to calling WriteSource, the size given in prc is used if not
If SetPixelFormat is not called prior to calling WriteSource, the pixel format of the
If SetResolution is not called prior to calling WriteSource, the pixel format of pIBitmapSource is used.
If SetPalette is not called prior to calling WriteSource, the target pixel format is indexed, and the pixel format of pIBitmapSource matches the encoder frame's pixel format, then the pIBitmapSource pixel format is used.
When encoding a GIF image, if the global palette is set and the frame level palette is not set directly by the user or by a custom independent software vendor (ISV) GIF codec, WriteSource will use the global palette to encode the frame even when pIBitmapSource has a frame level palette.
Windows Vista:The source rect width must match the width set through SetSize. Repeated WriteSource calls can be made as long as the total accumulated source rect height is the same as set through SetSize.
///If SetSize is not called prior to calling WriteSource, the size given in prc is used if not
If SetPixelFormat is not called prior to calling WriteSource, the pixel format of the
If SetResolution is not called prior to calling WriteSource, the pixel format of pIBitmapSource is used.
If SetPalette is not called prior to calling WriteSource, the target pixel format is indexed, and the pixel format of pIBitmapSource matches the encoder frame's pixel format, then the pIBitmapSource pixel format is used.
When encoding a GIF image, if the global palette is set and the frame level palette is not set directly by the user or by a custom independent software vendor (ISV) GIF codec, WriteSource will use the global palette to encode the frame even when pIBitmapSource has a frame level palette.
Windows Vista:The source rect width must match the width set through SetSize. Repeated WriteSource calls can be made as long as the total accumulated source rect height is the same as set through SetSize.
///Refer to Capability Querying.
/// The REFIID, or
The device creates command lists from the command allocator.
/// Specifies the
The globally unique identifier (
Specifies a reference, that on successful completion of the method will point to the created command signature (
This method creates both a resource and a heap, such that the heap is big enough to contain the entire resource and the resource is mapped to the heap. The created heap is known as an implicit heap, because the heap object cannot be obtained by the application. The application must ensure the GPU will no longer read or write to this resource before releasing the final reference on the resource.
The implicit heap is made resident for GPU access before the method returns to the application. See Residency.
The resource GPU VA mapping cannot be changed. See
This method may be called by multiple threads concurrently.
/// A reference to a
The globally unique identifier (
A reference to a memory block that receives a reference to the
CreateHeap creates a heap that can be used with placed resources and reserved resources. Before releasing the final reference on the heap, the application must ensure that the GPU will no longer read or write to this heap. Placed resource objects will hold a reference on the heap they are created on, but reserved resources will not hold a reference for each mapping made to a heap.
///Refer to Queries for more information.
///CreatePlacedResource is similar to fully mapping a reserved resource to an offset within a heap; but the virtual address space associated with a heap may be reused as well.
Placed resources are lighter weight than committed resources to create and destroy, because no heap is created or destroyed during this operation. However, placed resources enable an even lighter weight technique to reuse memory than resource creation and destruction: reuse through aliasing and aliasing barriers. Multiple placed resources may simultaneously overlap each other on the same heap, but only a single overlapping resource can be used at a time.
There are two placed resource usage semantics, a simple model and an advanced model. The simple model is recommended, and is the most likely model for tool support, until the advanced model is proven to be required by the app.
///When using CreatePlacedResource, the application must use this method to understand the size and alignment characteristics of texture resources. The results of this method vary depending on the particular adapter, and must be treated as unique to this adapter and driver version.
Applications cannot use the output of GetResourceAllocationInfo to understand packed mip properties of textures. To understand packed mip properties of textures, applications must use GetResourceTiling. Texture resource sizes significantly differ from the information returned by GetResourceTiling, because some adapter architectures allocate extra memory for textures to reduce the effective bandwidth during common rendering scenarios. This even includes textures that have constraints on their texture layouts or have standardized texture layouts. That extra memory cannot be sparsely mapped or remapped by an application using CreateReservedResource and UpdateTileMappings, so it isn't reported in GetResourceTiling.
Applications can forgo using GetResourceAllocationInfo for buffer resources (
When multiple resource descriptions are passed in, the C++ algorithm for calculating a structure size and alignment are used. For example, a three-element array with two tiny 64KB-aligned resources and a tiny 4MB-aligned resource reports differing sizes based on the order of the array. If the 4MB aligned resource is in the middle, the resulting Size is 12MB. Otherwise, the resulting Size is 8MB. The Alignment returned would always be 4MB, as it is the superset of all alignments in the resource array.
///Refer to Capability Querying.
///Refer to Capability Querying.
///A value to clear the stencil buffer with.
The number of rectangles in the array that the pRects parameter specifies.
An array of D3D12_RECT structures for the rectangles in the resource view to clear. If
A 4-component array that represents the color to fill the render target with.
The number of rectangles in the array that the pRects parameter specifies.
An array of D3D12_RECT structures for the rectangles in the resource view to clear. If
There are three types of barrier descriptions:
When
For descriptions of the usage states a subresource can be in, see the
A subresource can be in any state when
When a back buffer is presented, it must be in the
The resource usage bits are group into two categories, read-only and read/write.
The following usage bits are read-only:
The following usage bits are read/write:
At most one write bit can be set. If any write bit is set, then no read bit may be set. If no write bit is set, then any number of read bits may be set.
At any given time, a subresource is in exactly one state (determined by a set of flags). The application must ensure that the states are matched when making a sequence of ResourceBarrier calls. In other words, the before and after states in consecutive calls to ResourceBarrier must agree.
To transition all subresources within a resource, the application can set the subresource index to D3D12_RESOURCE_BARRIER_ALL_SUBRESOURCES, which implies that all subresources are changed.
For improved performance, applications should use split barriers (refer to Synchronization and Multi-Engine). Applications should also batch multiple transitions into a single call whenever possible.
///There are three types of barrier descriptions:
When
For descriptions of the usage states a subresource can be in, see the
A subresource can be in any state when
When a back buffer is presented, it must be in the
The resource usage bits are group into two categories, read-only and read/write.
The following usage bits are read-only:
The following usage bits are read/write:
At most one write bit can be set. If any write bit is set, then no read bit may be set. If no write bit is set, then any number of read bits may be set.
At any given time, a subresource is in exactly one state (determined by a set of flags). The application must ensure that the states are matched when making a sequence of ResourceBarrier calls. In other words, the before and after states in consecutive calls to ResourceBarrier must agree.
To transition all subresources within a resource, the application can set the subresource index to D3D12_RESOURCE_BARRIER_ALL_SUBRESOURCES, which implies that all subresources are changed.
For improved performance, applications should use split barriers (refer to Synchronization and Multi-Engine). Applications should also batch multiple transitions into a single call whenever possible.
///There are three types of barrier descriptions:
When
For descriptions of the usage states a subresource can be in, see the
A subresource can be in any state when
When a back buffer is presented, it must be in the
The resource usage bits are group into two categories, read-only and read/write.
The following usage bits are read-only:
The following usage bits are read/write:
At most one write bit can be set. If any write bit is set, then no read bit may be set. If no write bit is set, then any number of read bits may be set.
At any given time, a subresource is in exactly one state (determined by a set of flags). The application must ensure that the states are matched when making a sequence of ResourceBarrier calls. In other words, the before and after states in consecutive calls to ResourceBarrier must agree.
To transition all subresources within a resource, the application can set the subresource index to D3D12_RESOURCE_BARRIER_ALL_SUBRESOURCES, which implies that all subresources are changed.
For improved performance, applications should use split barriers (refer to Synchronization and Multi-Engine). Applications should also batch multiple transitions into a single call whenever possible.
///There are three types of barrier descriptions:
When
For descriptions of the usage states a subresource can be in, see the
A subresource can be in any state when
When a back buffer is presented, it must be in the
The resource usage bits are group into two categories, read-only and read/write.
The following usage bits are read-only:
The following usage bits are read/write:
At most one write bit can be set. If any write bit is set, then no read bit may be set. If no write bit is set, then any number of read bits may be set.
At any given time, a subresource is in exactly one state (determined by a set of flags). The application must ensure that the states are matched when making a sequence of ResourceBarrier calls. In other words, the before and after states in consecutive calls to ResourceBarrier must agree.
To transition all subresources within a resource, the application can set the subresource index to D3D12_RESOURCE_BARRIER_ALL_SUBRESOURCES, which implies that all subresources are changed.
For improved performance, applications should use split barriers (refer to Synchronization and Multi-Engine). Applications should also batch multiple transitions into a single call whenever possible.
///There are three types of barrier descriptions:
When
For descriptions of the usage states a subresource can be in, see the
A subresource can be in any state when
When a back buffer is presented, it must be in the
The resource usage bits are group into two categories, read-only and read/write.
The following usage bits are read-only:
The following usage bits are read/write:
At most one write bit can be set. If any write bit is set, then no read bit may be set. If no write bit is set, then any number of read bits may be set.
At any given time, a subresource is in exactly one state (determined by a set of flags). The application must ensure that the states are matched when making a sequence of ResourceBarrier calls. In other words, the before and after states in consecutive calls to ResourceBarrier must agree.
To transition all subresources within a resource, the application can set the subresource index to D3D12_RESOURCE_BARRIER_ALL_SUBRESOURCES, which implies that all subresources are changed.
For improved performance, applications should use split barriers (refer to Synchronization and Multi-Engine). Applications should also batch multiple transitions into a single call whenever possible.
///SetDescriptorHeaps can be called on a bundle, but the bundle descriptor heaps must match the calling command list descriptor heap. For more information on bundle restrictions, refer to Creating and Recording Command Lists and Bundles.
/// Specifies an array of
True means the handle passed in is the reference to a contiguous range of NumRenderTargetDescriptors descriptors. This case is useful if the set of descriptors to bind already happens to be contiguous in memory (so all that?s needed is a handle to the first one). For example, if NumRenderTargetDescriptors is 3 then the memory layout is taken as follows:
In this case the driver dereferences the handle and then increments the memory being pointed to.
False means that the handle is the first of an array of NumRenderTargetDescriptors handles. The false case allows an application to bind a set of descriptors from different locations at once. Again assuming that NumRenderTargetDescriptors is 3, the memory layout is taken as follows:
In this case the driver dereferences three handles that are expected to be adjacent to each other in memory.
A reference to a
Specifies an array of
True means the handle passed in is the reference to a contiguous range of NumRenderTargetDescriptors descriptors. This case is useful if the set of descriptors to bind already happens to be contiguous in memory (so all that?s needed is a handle to the first one). For example, if NumRenderTargetDescriptors is 3 then the memory layout is taken as follows:
In this case the driver dereferences the handle and then increments the memory being pointed to.
False means that the handle is the first of an array of NumRenderTargetDescriptors handles. The false case allows an application to bind a set of descriptors from different locations at once. Again assuming that NumRenderTargetDescriptors is 3, the memory layout is taken as follows:
In this case the driver dereferences three handles that are expected to be adjacent to each other in memory.
A reference to a
Specifies an array of
True means the handle passed in is the reference to a contiguous range of NumRenderTargetDescriptors descriptors. This case is useful if the set of descriptors to bind already happens to be contiguous in memory (so all that?s needed is a handle to the first one). For example, if NumRenderTargetDescriptors is 3 then the memory layout is taken as follows:
In this case the driver dereferences the handle and then increments the memory being pointed to.
False means that the handle is the first of an array of NumRenderTargetDescriptors handles. The false case allows an application to bind a set of descriptors from different locations at once. Again assuming that NumRenderTargetDescriptors is 3, the memory layout is taken as follows:
In this case the driver dereferences three handles that are expected to be adjacent to each other in memory.
A reference to a
Sets a CPU descriptor handle for the vertex buffers.
///Index into the device's zero-based array to begin setting vertex buffers.
Specifies the vertex buffer views in an array of
The number of views in the pViews array.
Specifies the vertex buffer views in an array of
For internal use only.
/// ///Internal.
For internal use only.
/// ///Internal.
An array of
Gets the layout of the root signature.
///Gets the layout of the root signature.
/// Returns a reference to a
An array of
Use this structure with CopyTextureRegion.
///The parent in the composition tree for the content being added.
parentVisual must also be a parent of childVisual in the composition tree.
The child in the composition tree for the content being added.
parentVisual must also be a parent of childVisual in the composition tree.
The content to remove from the composition tree.
Commits all pending updates in the compositor to the system for rendering.
SyntaxParametersFlush();
This method has no parameters.
Return valueIf the method succeeds, it returns
This method enables Direct Manipulation to flush any pending changes to its visuals before a system event, such as a process suspension.
Requirements /// ///The parent in the composition tree for the content being added.
parentVisual must also be a parent of childVisual in the composition tree.
The child in the composition tree for the content being added.
parentVisual must also be a parent of childVisual in the composition tree.
The content to remove from the composition tree.
Commits all pending updates in the compositor to the system for rendering.
SyntaxParametersFlush();
This method has no parameters.
Return valueIf the method succeeds, it returns
This method enables Direct Manipulation to flush any pending changes to its visuals before a system event, such as a process suspension.
Requirements /// ///Some Microsoft Media Foundation objects must be shut down before being released. If so, the caller is responsible for shutting down the object that is returned in ppv. To shut down the object, do one of the following:
The
After the first call to ActivateObject, subsequent calls return a reference to the same instance, until the client calls either ShutdownObject or
Some Microsoft Media Foundation objects must be shut down before being released. If so, the caller is responsible for shutting down the object that is returned in ppv. To shut down the object, do one of the following:
The
After the first call to ActivateObject, subsequent calls return a reference to the same instance, until the client calls either ShutdownObject or
Before calling this method, call the
You must call this method once before using the capture engine. Calling the method a second time returns
This method is asynchronous. If the method returns a success code, the caller will receive an MF_CAPTURE_ENGINE_INITIALIZED event through the
Calling this method overrides any previous call to
Calling this method overrides any previous call to
Calling this method overrides any previous call to
Calling this method overrides any previous call to
Calling this method overrides any previous call to
Within your implementation of Invoke, call the corresponding End... method.
This interface is available on the following platforms if the Windows Media Format 11 SDK redistributable components are installed:
This method corresponds to setting the src attribute of the HTMLMediaElement interface in HTML5.
The URL specified by this method takes precedence over media resources specified in the
This method asynchronously loads the URL. When the operation starts, the Media Engine sends an
If the Media Engine is unable to load the URL, the Media Engine sends an
For more information about event handling in the Media Engine, see
Media types are returned in the approximate order of preference. The list of supported types is not guaranteed to be complete. To test whether a particular media type is supported, call
This interface is available on the following platforms if the Windows Media Format 11 SDK redistributable components are installed:
This interface is available on the following platforms if the Windows Media Format 11 SDK redistributable components are installed:
The Flush method discards all queued samples and cancels all pending sample requests.
This method can complete either synchronously or asynchronously. If you provide a callback reference when you create the source reader, the method is asynchronous. Otherwise, the method is synchronous. For more information about the setting the callback reference, see
In synchronous mode, the method blocks until the operation is complete.
In asynchronous mode, the application's
Note??In Windows?7, there was a bug in the implementation of this method, which causes OnFlush to be called before the flush operation completes. A hotfix is available that fixes this bug. For more information, see http://support.microsoft.com/kb/979567.
This interface is available on Windows?Vista if Platform Update Supplement for Windows?Vista is installed.
///The pChannelMask argument is a bit-mask of the various channels in the speaker geometry reported by the audio system. This information is needed for the
The X3DAUDIO.H header declares a number of SPEAKER_ positional defines to decode these channels masks.
Examples include:
// (0x1) | (0x2) // (0x1) | (0x2) // | (0x4) // | (0x8) // | (0x10) | (0x20)
Note??For the DirectX SDK versions of XAUDIO, the channel mask for the output device was obtained via the IXAudio2::GetDeviceDetails method, which doesn't exist in Windows?8 and later.
///Returns information about the creation flags, input channels, and sample rate of a voice.
///You typically call
Important?? The listener and emitter values must be valid. Floating-point specials (NaN, QNaN, +INF, -INF) can cause the entire audio output to go silent if introduced into a running audio graph.
///X3DAUDIO_HANDLE is an opaque data structure. Because the operating system doesn't allocate any additional storage for the 3D audio instance handle, you don't need to free or close it.
///You typically call
Important?? The listener and emitter values must be valid. Floating-point specials (NaN, QNaN, +INF, -INF) can cause the entire audio output to go silent if introduced into a running audio graph.
///X3DAUDIO_HANDLE is an opaque data structure. Because the operating system doesn't allocate any additional storage for the 3D audio instance handle, you don't need to free or close it.
///The DirectX SDK versions of XAUDIO2 supported a flag
Note??No versions of the DirectX SDK contain the xaudio2.lib import library. DirectX SDK versions use COM to create a new XAudio2 object.
///