Condividi tramite


Funzione D3D111On12CreateDevice (d3d1111on12.h)

Crea un dispositivo che usa la funzionalità Direct3D 11 in Direct3D 12, specificando un dispositivo Direct3D 12 esistente da usare per l'interoperabilità Direct3D 11.

Sintassi

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
);

Parametri

[in] pDevice

Tipo: IUnknown*

Specifica un dispositivo Direct3D 12 esistente da usare per l'interoperabilità Direct3D 11. Potrebbe non essere NULL.

Flags

Tipo: UINT

Uno o più flag OR bit per bit da D3D11_CREATE_DEVICE_FLAG. Questi sono gli stessi flag usati da D3D11CreateDeviceAndSwapChain. Specifica i livelli di runtime da abilitare. I flag devono essere compatibili con i flag di dispositivo e il relativo NodoMask deve essere un subset di NodeMask fornito all'API presente.

[in, optional] pFeatureLevels

Tipo: const D3D_FEATURE_LEVEL*

Matrice di uno dei seguenti elementi:

  • 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

Il primo livello di funzionalità minore o uguale al livello di funzionalità del dispositivo Direct3D 12 verrà usato per eseguire la convalida direct3D 11. La creazione avrà esito negativo se non vengono forniti livelli di funzionalità accettabili. Se si specifica NULL, il valore predefinito verrà impostato sul livello di funzionalità del dispositivo Direct3D 12.

FeatureLevels

Tipo: UINT

Dimensione di (ovvero il numero di elementi in) della matrice pFeatureLevels .

[in, optional] ppCommandQueues

Tipo: IUnknown* const *

Matrice di code univoche da usare per D3D11On11On12. Le code devono essere del tipo di coda dei comandi 3D.

NumQueues

Tipo: UINT

Dimensione di (ovvero il numero di elementi in) della matrice ppCommandQueues .

NodeMask

Tipo: UINT

Nodo del dispositivo Direct3D 12 da usare. È possibile impostare solo 1 bit.

[out, optional] ppDevice

Tipo: ID3D11Device**

Puntatore all'ID3D11Device restituito. Può essere Null.

[out, optional] ppImmediateContext

Tipo: ID3D11DeviceContext**

Puntatore all'ID3D11DeviceContext restituito. Può essere Null.

[out, optional] pChosenFeatureLevel

Tipo: D3D_FEATURE_LEVEL*

Puntatore al livello di funzionalità restituito. Può essere Null.

Valore restituito

Tipo: HRESULT

Questo metodo restituisce uno dei codici restituiti Direct3D 12 documentati per D3D11CreateDevice.

Questo metodo restituisce DXGI_ERROR_SDK_COMPONENT_MISSING se si specifica D3D11_CREATE_DEVICE_DEBUG in Flag e la versione errata del livello di debug viene installata nel computer. Installare windows SDK più recente per ottenere la versione corretta.

Commenti

La firma della funzione PFN_D3D11ON12_CREATE_DEVICE viene fornita come typedef, in modo che sia possibile usare tecniche di collegamento dinamico (GetProcAddress) anziché collegare staticamente.

Esempio

Per eseguire il rendering del testo su Direct3D 12 usando Direct2D tramite il dispositivo 11On12, caricare le dipendenze della pipeline di rendering.

// 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])));
        }
    }
}

Vedere le note sul codice di esempio nel contenuto di riferimento Direct3D 12.

Requisiti

   
Piattaforma di destinazione Windows
Intestazione d3d11on12.h
Libreria D3D11.lib
DLL D3D11.dll

Vedi anche

Funzioni 11on12