D3D11On12CreateDevice, fonction (d3d11on12.h)
Crée un appareil qui utilise la fonctionnalité Direct3D 11 dans Direct3D 12, en spécifiant un appareil Direct3D 12 préexistant à utiliser pour l’interopérabilité Direct3D 11.
Syntaxe
HRESULT D3D11On12CreateDevice(
[in] IUnknown *pDevice,
UINT Flags,
[in, optional] const D3D_FEATURE_LEVEL *pFeatureLevels,
UINT FeatureLevels,
[in, optional] IUnknown * const *ppCommandQueues,
UINT NumQueues,
UINT NodeMask,
[out, optional] ID3D11Device **ppDevice,
[out, optional] ID3D11DeviceContext **ppImmediateContext,
[out, optional] D3D_FEATURE_LEVEL *pChosenFeatureLevel
);
Paramètres
[in] pDevice
Type : IUnknown*
Spécifie un appareil Direct3D 12 préexistant à utiliser pour l’interopérabilité Direct3D 11. Peut ne pas être NULL.
Flags
Type : UINT
Un ou plusieurs indicateurs OR au niveau du bit de D3D11_CREATE_DEVICE_FLAG. Il s’agit des mêmes indicateurs que ceux utilisés par D3D11CreateDeviceAndSwapChain. Spécifie les couches d’exécution à activer. Les indicateurs doivent être compatibles avec les indicateurs d’appareil, et son NœudMask doit être un sous-ensemble de nodeMask fourni à l’API actuelle.
[in, optional] pFeatureLevels
Type : const D3D_FEATURE_LEVEL*
Tableau de l’un des éléments suivants :
- D3D_FEATURE_LEVEL_12_1
- D3D_FEATURE_LEVEL_12_0
- D3D_FEATURE_LEVEL_11_1
- D3D_FEATURE_LEVEL_11_0
- D3D_FEATURE_LEVEL_10_1
- D3D_FEATURE_LEVEL_10_0
- D3D_FEATURE_LEVEL_9_3
- D3D_FEATURE_LEVEL_9_2
- D3D_FEATURE_LEVEL_9_1
Le premier niveau de fonctionnalité inférieur ou égal au niveau de fonctionnalité de l’appareil Direct3D 12 sera utilisé pour effectuer la validation Direct3D 11. La création échoue si aucun niveau de fonctionnalité acceptable n’est fourni. La valeur NULL est définie par défaut sur le niveau de fonctionnalité de l’appareil Direct3D 12.
FeatureLevels
Type : UINT
Taille du tableau pFeatureLevels (c’est-à-dire le nombre d’éléments dans).
[in, optional] ppCommandQueues
Type : IUnknown* const *
Tableau de files d’attente uniques à utiliser par D3D11On12. Les files d’attente doivent être du type de file d’attente de commandes 3D.
NumQueues
Type : UINT
Taille (c’est-à-dire le nombre d’éléments dans) du tableau ppCommandQueues .
NodeMask
Type : UINT
Nœud de l’appareil Direct3D 12 à utiliser. Seul 1 bit peut être défini.
[out, optional] ppDevice
Type : ID3D11Device**
Pointeur vers l’objet ID3D11Device retourné. Peut être NULL.
[out, optional] ppImmediateContext
Type : ID3D11DeviceContext**
Pointeur vers l’id3D11DeviceContext retourné. Peut être NULL.
[out, optional] pChosenFeatureLevel
Type : D3D_FEATURE_LEVEL*
Pointeur vers le niveau de fonctionnalité retourné. Peut être NULL.
Valeur retournée
Type : HRESULT
Cette méthode retourne l’un des codes de retour Direct3D 12 documentés pour D3D11CreateDevice.
Cette méthode retourne DXGI_ERROR_SDK_COMPONENT_MISSING si vous spécifiez D3D11_CREATE_DEVICE_DEBUG dans Indicateurs et que la version incorrecte de la couche de débogage est installée sur votre ordinateur. Installez la dernière version du SDK Windows pour obtenir la version correcte.
Notes
Le PFN_D3D11ON12_CREATE_DEVICE de signature de fonction est fourni en tant que typedef, ce qui vous permet d’utiliser des techniques de liaison dynamique (GetProcAddress) au lieu d’une liaison statique.
Exemples
Pour afficher du texte sur Direct3D 12 à l’aide de Direct2D via l’appareil 11On12, chargez les dépendances du pipeline de rendu.
// Load the rendering pipeline dependencies.
void D3D1211on12::LoadPipeline()
{
UINT d3d11DeviceFlags = D3D11_CREATE_DEVICE_BGRA_SUPPORT;
D2D1_FACTORY_OPTIONS d2dFactoryOptions = {};
#if defined(_DEBUG)
// Enable the D2D debug layer.
d2dFactoryOptions.debugLevel = D2D1_DEBUG_LEVEL_INFORMATION;
// Enable the Direct3D 11 debug layer.
d3d11DeviceFlags |= D3D11_CREATE_DEVICE_DEBUG;
// Enable the Direct3D 12 debug layer.
{
ComPtr<ID3D12Debug> debugController;
if (SUCCEEDED(D3D12GetDebugInterface(IID_PPV_ARGS(&debugController))))
{
debugController->EnableDebugLayer();
}
}
#endif
ComPtr<IDXGIFactory4> factory;
ThrowIfFailed(CreateDXGIFactory1(IID_PPV_ARGS(&factory)));
if (m_useWarpDevice)
{
ComPtr<IDXGIAdapter> warpAdapter;
ThrowIfFailed(factory->EnumWarpAdapter(IID_PPV_ARGS(&warpAdapter)));
ThrowIfFailed(D3D12CreateDevice(
warpAdapter.Get(),
D3D_FEATURE_LEVEL_11_0,
IID_PPV_ARGS(&m_d3d12Device)
));
}
else
{
ComPtr<IDXGIAdapter1> hardwareAdapter;
GetHardwareAdapter(factory.Get(), &hardwareAdapter);
ThrowIfFailed(D3D12CreateDevice(
hardwareAdapter.Get(),
D3D_FEATURE_LEVEL_11_0,
IID_PPV_ARGS(&m_d3d12Device)
));
}
// Describe and create the command queue.
D3D12_COMMAND_QUEUE_DESC queueDesc = {};
queueDesc.Flags = D3D12_COMMAND_QUEUE_FLAG_NONE;
queueDesc.Type = D3D12_COMMAND_LIST_TYPE_DIRECT;
ThrowIfFailed(m_d3d12Device->CreateCommandQueue(&queueDesc, IID_PPV_ARGS(&m_commandQueue)));
// Describe the swap chain.
DXGI_SWAP_CHAIN_DESC swapChainDesc = {};
swapChainDesc.BufferCount = FrameCount;
swapChainDesc.BufferDesc.Width = m_width;
swapChainDesc.BufferDesc.Height = m_height;
swapChainDesc.BufferDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM;
swapChainDesc.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT;
swapChainDesc.SwapEffect = DXGI_SWAP_EFFECT_FLIP_DISCARD;
swapChainDesc.OutputWindow = Win32Application::GetHwnd();
swapChainDesc.SampleDesc.Count = 1;
swapChainDesc.Windowed = TRUE;
ComPtr<IDXGISwapChain> swapChain;
ThrowIfFailed(factory->CreateSwapChain(
m_commandQueue.Get(), // Swap chain needs the queue so that it can force a flush on it.
&swapChainDesc,
&swapChain
));
ThrowIfFailed(swapChain.As(&m_swapChain));
// This sample does not support fullscreen transitions.
ThrowIfFailed(factory->MakeWindowAssociation(Win32Application::GetHwnd(), DXGI_MWA_NO_ALT_ENTER));
m_frameIndex = m_swapChain->GetCurrentBackBufferIndex();
// Create an 11 device wrapped around the 12 device and share
// 12's command queue.
ComPtr<ID3D11Device> d3d11Device;
ThrowIfFailed(D3D11On12CreateDevice(
m_d3d12Device.Get(),
d3d11DeviceFlags,
nullptr,
0,
reinterpret_cast<IUnknown**>(m_commandQueue.GetAddressOf()),
1,
0,
&d3d11Device,
&m_d3d11DeviceContext,
nullptr
));
// Query the 11On12 device from the 11 device.
ThrowIfFailed(d3d11Device.As(&m_d3d11On12Device));
// Create D2D/DWrite components.
{
D2D1_DEVICE_CONTEXT_OPTIONS deviceOptions = D2D1_DEVICE_CONTEXT_OPTIONS_NONE;
ThrowIfFailed(D2D1CreateFactory(
D2D1_FACTORY_TYPE_SINGLE_THREADED,
__uuidof(ID2D1Factory3),
&d2dFactoryOptions,
&m_d2dFactory));
ComPtr<IDXGIDevice> dxgiDevice;
ThrowIfFailed(m_d3d11On12Device.As(&dxgiDevice));
ThrowIfFailed(m_d2dFactory->CreateDevice(dxgiDevice.Get(), &m_d2dDevice));
ThrowIfFailed(m_d2dDevice->CreateDeviceContext(deviceOptions, &m_d2dDeviceContext));
ThrowIfFailed(DWriteCreateFactory(
DWRITE_FACTORY_TYPE_SHARED,
__uuidof(IDWriteFactory),
&m_dWriteFactory));
}
// Query the desktop's dpi settings, which will be used to create
// D2D's render targets.
float dpi = GetDpiForWindow(Win32Application::GetHwnd());
D2D1_BITMAP_PROPERTIES1 bitmapProperties = D2D1::BitmapProperties1(
D2D1_BITMAP_OPTIONS_TARGET | D2D1_BITMAP_OPTIONS_CANNOT_DRAW,
D2D1::PixelFormat(DXGI_FORMAT_UNKNOWN, D2D1_ALPHA_MODE_PREMULTIPLIED),
dpi,
dpi
);
// Create descriptor heaps.
{
// Describe and create a render target view (RTV) descriptor heap.
D3D12_DESCRIPTOR_HEAP_DESC rtvHeapDesc = {};
rtvHeapDesc.NumDescriptors = FrameCount;
rtvHeapDesc.Type = D3D12_DESCRIPTOR_HEAP_TYPE_RTV;
rtvHeapDesc.Flags = D3D12_DESCRIPTOR_HEAP_FLAG_NONE;
ThrowIfFailed(m_d3d12Device->CreateDescriptorHeap(&rtvHeapDesc, IID_PPV_ARGS(&m_rtvHeap)));
m_rtvDescriptorSize =
m_d3d12Device->GetDescriptorHandleIncrementSize(D3D12_DESCRIPTOR_HEAP_TYPE_RTV);
}
// Create frame resources.
{
CD3DX12_CPU_DESCRIPTOR_HANDLE rtvHandle(m_rtvHeap->GetCPUDescriptorHandleForHeapStart());
// Create a RTV, D2D render target, and a command allocator for each frame.
for (UINT n = 0; n < FrameCount; n++)
{
ThrowIfFailed(m_swapChain->GetBuffer(n, IID_PPV_ARGS(&m_renderTargets[n])));
m_d3d12Device->CreateRenderTargetView(m_renderTargets[n].Get(), nullptr, rtvHandle);
// Create a wrapped 11On12 resource of this back buffer. Since we are
// rendering all Direct3D 12 content first and then all D2D content, we specify
// the In resource state as RENDER_TARGET - because Direct3D 12 will have last
// used it in this state - and the Out resource state as PRESENT. When
// ReleaseWrappedResources() is called on the 11On12 device, the resource
// will be transitioned to the PRESENT state.
D3D11_RESOURCE_FLAGS d3d11Flags = { D3D11_BIND_RENDER_TARGET };
ThrowIfFailed(m_d3d11On12Device->CreateWrappedResource(
m_renderTargets[n].Get(),
&d3d11Flags,
D3D12_RESOURCE_STATE_RENDER_TARGET,
D3D12_RESOURCE_STATE_PRESENT,
IID_PPV_ARGS(&m_wrappedBackBuffers[n])
));
// Create a render target for D2D to draw directly to this back buffer.
ComPtr<IDXGISurface> surface;
ThrowIfFailed(m_wrappedBackBuffers[n].As(&surface));
ThrowIfFailed(m_d2dDeviceContext->CreateBitmapFromDxgiSurface(
surface.Get(),
&bitmapProperties,
&m_d2dRenderTargets[n]
));
rtvHandle.Offset(1, m_rtvDescriptorSize);
ThrowIfFailed(m_d3d12Device->CreateCommandAllocator(
D3D12_COMMAND_LIST_TYPE_DIRECT,
IID_PPV_ARGS(&m_commandAllocators[n])));
}
}
}
Consultez les notes relatives à l’exemple de code dans le contenu de référence Direct3D 12.
Spécifications
| Plateforme cible | Windows |
| En-tête | d3d11on12.h |
| Bibliothèque | D3D11.lib |
| DLL | D3D11.dll |
Voir aussi
Commentaires
Bientôt disponible : Tout au long de 2024, nous allons supprimer progressivement GitHub Issues comme mécanisme de commentaires pour le contenu et le remplacer par un nouveau système de commentaires. Pour plus d’informations, consultez https://aka.ms/ContentUserFeedback.
Envoyer et afficher des commentaires pour