D3D11On12CreateDevice-Funktion (d3d11on12.h)
Erstellt ein Gerät, das Direct3D 11-Funktionalität in Direct3D 12 verwendet, und gibt ein bereits vorhandenes Direct3D 12-Gerät an, das für direct3D 11-Interop verwendet werden soll.
Syntax
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
);
Parameter
[in] pDevice
Typ: IUnknown*
Gibt ein bereits vorhandenes Direct3D 12-Gerät an, das für direct3D 11-Interop verwendet werden soll. Ist möglicherweise nicht NULL.
Flags
Typ: UINT
Ein oder mehrere bitweise OR'd-Flags von D3D11_CREATE_DEVICE_FLAG. Dies sind dieselben Flags wie die von D3D11CreateDeviceAndSwapChain. Gibt an, welche Laufzeitebenen aktiviert werden sollen. Flags müssen mit Geräteflags kompatibel sein, und ihre NodeMask muss eine Teilmenge der NodeMask sein, die für die vorliegende API bereitgestellt wird.
[in, optional] pFeatureLevels
Typ: const D3D_FEATURE_LEVEL*
Ein Array mit einer der folgenden Optionen:
- 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
Die erste Featureebene, die kleiner oder gleich der Featureebene des Direct3D 12-Geräts ist, wird verwendet, um die Direct3D 11-Überprüfung durchzuführen. Die Erstellung schlägt fehl, wenn keine akzeptablen Featureebenen bereitgestellt werden. Die Angabe von NULL wird standardmäßig auf die Featureebene des Direct3D 12-Geräts festgelegt.
FeatureLevels
Typ: UINT
Die Größe des pFeatureLevels-Arrays (d. h. die Anzahl der Elemente in).
[in, optional] ppCommandQueues
Typ: IUnknown* const *
Ein Array eindeutiger Warteschlangen, die D3D11On12 verwenden soll. Die Warteschlangen müssen den 3D-Befehlswarteschlangentyp aufweisen.
NumQueues
Typ: UINT
Die Größe des ppCommandQueues-Arrays (d. h. die Anzahl der Elemente in).
NodeMask
Typ: UINT
Welcher Knoten des Direct3D 12-Geräts verwendet werden soll. Es kann nur 1 Bit festgelegt werden.
[out, optional] ppDevice
Typ: ID3D11Device**
Zeiger auf das zurückgegebene ID3D11Device. Kann NULL sein.
[out, optional] ppImmediateContext
Typ: ID3D11DeviceContext**
Ein Zeiger auf den zurückgegebenen ID3D11DeviceContext. Kann NULL sein.
[out, optional] pChosenFeatureLevel
Typ: D3D_FEATURE_LEVEL*
Ein Zeiger auf die zurückgegebene Featureebene. Kann NULL sein.
Rückgabewert
Typ: HRESULT
Diese Methode gibt einen der Direct3D 12-Rückgabecodes zurück, die für D3D11CreateDevice dokumentiert sind.
Diese Methode gibt DXGI_ERROR_SDK_COMPONENT_MISSING zurück, wenn Sie D3D11_CREATE_DEVICE_DEBUG in Flags angeben und die falsche Version der Debugebene auf Ihrem Computer installiert ist. Installieren Sie das neueste Windows SDK, um die richtige Version zu erhalten.
Hinweise
Die Funktionssignatur PFN_D3D11ON12_CREATE_DEVICE wird als Typedef bereitgestellt, sodass Sie dynamische Verknüpfungstechniken (GetProcAddress) anstelle von statisch verknüpfen können.
Beispiele
Um Text über Direct3D 12 mithilfe von Direct2D über das 11On12-Gerät zu rendern, laden Sie die Renderingpipelineabhängigkeiten.
// 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])));
}
}
}
Siehe die Hinweise zum Beispielcode im Direct3D 12-Referenzinhalt.
Anforderungen
| Zielplattform | Windows |
| Kopfzeile | d3d11on12.h |
| Bibliothek | D3D11.lib |
| DLL | D3D11.dll |