Dela via

Utöka exempelspelet

Anmärkning

Det här avsnittet är en del av Skapa ett enkelt UWP-spel (Universal Windows Platform) med DirectX självstudieserie. Ämnet på länken anger kontexten för serien.

Information om hur du laddar ned den version av det här spelet som använder XAML för överlägget finns i DirectX- och XAML-spelexempel. Se till att läsa readme-filen där för mer information om hur du skapar exemplet.

Nu har vi gått igenom de viktigaste komponenterna i ett grundläggande UWP-spel (Universal Windows Platform) DirectX 3D. Du kan konfigurera ramverket för ett spel, inklusive visningsprovidern och renderingspipelinen, och implementera en grundläggande spelloop. Du kan också skapa ett grundläggande överlägg för användargränssnittet, införliva ljud och implementera kontroller. Du är på väg att skapa ett eget spel, men om du behöver mer hjälp och information kan du kolla in dessa resurser.

Använda XAML för överlägget

Ett alternativ som vi inte diskuterade på djupet är användningen av XAML i stället för Direct2D för överlägget. XAML har många fördelar jämfört med Direct2D för att rita användargränssnittselement. Den viktigaste fördelen är att det gör det enklare att införliva utseendet och känslan av Windows 10 i ditt DirectX-spel. Många av de vanliga element, stilar och beteenden som definierar en UWP-app är tätt integrerade i XAML-modellen, vilket gör det mycket enklare för en spelutvecklare att implementera. Om din egen speldesign har ett komplicerat användargränssnitt bör du överväga att använda XAML i stället för Direct2D.

Med XAML kan vi skapa ett spelgränssnitt som ser ut ungefär som direct2D-gränssnittet som gjordes tidigare.

XAML

XAML-överlägg

Direct2D

D2D-överlägg

Även om de har liknande slutresultat finns det ett antal skillnader mellan implementering av Direct2D- och XAML-gränssnitt.

Egenskap XAML Direct2D
Definiera överlagring Definierad i en XAML-fil, \*.xaml. När du har förstått XAML blir det enklare att skapa och konfigurera mer komplicerade överlägg jämfört med Direct2D. Definierad som en samling Direct2D-primitiver och DirectWrite-strängar, manuellt placerade och skrivna till en Direct2D-målbuffert.
Användargränssnittselement XAML-användargränssnittselement kommer från standardiserade element som ingår i Windows Runtime XAML-API:er, inklusive Windows::UI::Xaml och Windows::UI::Xaml::Controls. Koden som hanterar beteendet för XAML-användargränssnittselement definieras i en kodfil Main.xaml.cpp. Enkla former kan ritas som rektanglar och ellipser.
Storleksändring av fönster Hanterar naturligtvis storleksändring och visning av tillståndsändringshändelser och transformerar överlägget i enlighet med detta Du måste ange hur du ska rita om överläggets komponenter manuellt.

En annan stor skillnad är växlingskedjan. Du behöver inte koppla växlingskedjan till ett Windows::UI::Core::CoreWindow-objekt . I stället associerar en DirectX-app som innehåller XAML en växlingskedja när ett nytt SwapChainPanel-objekt skapas.

Följande kodfragment visar hur du deklarerar XAML för SwapChainPanel i filen DirectXPage.xaml .

<Page
    x:Class="Simple3DGameXaml.DirectXPage"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    xmlns:local="using:Simple3DGameXaml"
    xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
    xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
    mc:Ignorable="d">
    <SwapChainPanel x:Name="DXSwapChainPanel">

    <!-- ... XAML user controls and elements -->

    </SwapChainPanel>
</Page>

Objektet SwapChainPanel ansätts som egenskapen Content för det nuvarande fönsterobjektet som skapades vid start av appens singleton.

void App::OnLaunched(_In_ LaunchActivatedEventArgs^ /* args */)
{
    m_mainPage = ref new DirectXPage();

    Window::Current->Content = m_mainPage;
    // Bring the application to the foreground so that it's visible
    Window::Current->Activate();
}

Om du vill koppla den konfigurerade byttkedjan till SwapChainPanel-instansen som definierats av XAML måste du hämta en pekare till den underliggande ISwapChainPanelNative-gränssnittsimplementeringen och sedan anropa ISwapChainPanelNative::SetSwapChain på den, med din konfigurerade byttkedja som argument.

Följande kodfragment från DX::DeviceResources::CreateWindowSizeDependentResources beskriver detta för DirectX/XAML-interop:

        ComPtr<IDXGIDevice3> dxgiDevice;
        DX::ThrowIfFailed(
            m_d3dDevice.As(&dxgiDevice)
            );

        ComPtr<IDXGIAdapter> dxgiAdapter;
        DX::ThrowIfFailed(
            dxgiDevice->GetAdapter(&dxgiAdapter)
            );

        ComPtr<IDXGIFactory2> dxgiFactory;
        DX::ThrowIfFailed(
            dxgiAdapter->GetParent(IID_PPV_ARGS(&dxgiFactory))
            );

        // When using XAML interop, the swap chain must be created for composition.
        DX::ThrowIfFailed(
            dxgiFactory->CreateSwapChainForComposition(
                m_d3dDevice.Get(),
                &swapChainDesc,
                nullptr,
                &m_swapChain
                )
            );

        // Associate swap chain with SwapChainPanel
        // UI changes will need to be dispatched back to the UI thread
        m_swapChainPanel->Dispatcher->RunAsync(CoreDispatcherPriority::High, ref new DispatchedHandler([=]()
        {
            // Get backing native interface for SwapChainPanel
            ComPtr<ISwapChainPanelNative> panelNative;
            DX::ThrowIfFailed(
                reinterpret_cast<IUnknown*>(m_swapChainPanel)->QueryInterface(IID_PPV_ARGS(&panelNative))
                );
            DX::ThrowIfFailed(
                panelNative->SetSwapChain(m_swapChain.Get())
                );
        }, CallbackContext::Any));

        // Ensure that DXGI does not queue more than one frame at a time. This both reduces latency and
        // ensures that the application will only render after each VSync, minimizing power consumption.
        DX::ThrowIfFailed(
            dxgiDevice->SetMaximumFrameLatency(1)
            );
    }

Mer information om den här processen finns i DirectX- och XAML-interop.

Exempel

Information om hur du laddar ned den version av det här spelet som använder XAML för överlägget finns i DirectX- och XAML-spelexempel. Se till att läsa readme-filen där för mer information om hur du skapar exemplet.

Till skillnad från den version av exempelspelet som beskrivs i resten av dessa ämnen definierar XAML-versionen dess ramverk i App.xaml.cpp - och DirectXPage.xaml.cpp-filer i stället för App.cpp respektive GameInfoOverlay.cpp.