Erweitern des Spielbeispiels

Hinweis

Dieses Thema ist Teil der Erstellen eines einfachen UWP-Spiels (Universelle Windows-Plattform) mit DirectX-Tutorial-Reihe. Das Thema unter diesem Link legt den Kontext für die Reihe fest.

Informationen zum Herunterladen der Version dieses Spiels, die XAML für das Overlay verwendet, finden Sie unter DirectX- und XAML-Spielbeispiel. Lesen Sie die Infodatei dort, um Details zum Erstellen des Beispiels zu erhalten.

An diesem Punkt haben wir die wichtigsten Komponenten eines einfachen Universelle Windows-Plattform (UWP) DirectX 3D-Spiels behandelt. Sie können das Framework für ein Spiel einrichten, einschließlich des Ansichtsanbieters und der Renderingpipeline, und eine einfache Spielschleife implementieren. Sie können auch eine einfache Benutzeroberfläche-Überlagerung erstellen, Sounds integrieren und Steuerelemente implementieren. Sie sind auf dem Weg, ein eigenes Spiel zu erstellen, aber wenn Sie weitere Hilfe und Informationen benötigen, schauen Sie sich diese Ressourcen an.

• DirectX-Grafiken und -Spiele
• Übersicht über Direct3D 11
• Direct3D 11-Referenz

Verwenden von XAML für die Überlagerung

Eine Alternative, die wir nicht ausführlich erörtert haben, ist die Verwendung von XAML anstelle von Direct2D für das Overlay. XAML bietet gegenüber Direct2D viele Vorteile für Das Zeichnen von Benutzeroberflächenelementen. Der wichtigste Vorteil besteht darin, dass die Integration des Windows 10-Erscheinungsbilds in Ihr DirectX-Spiel komfortabler wird. Viele der gängigen Elemente, Stile und Verhaltensweisen, die eine UWP-App definieren, sind eng in das XAML-Modell integriert, wodurch die Implementierung eines Spieleentwicklers wesentlich geringer ist. Wenn Ihr eigenes Spieldesign über eine komplizierte Benutzeroberfläche verfügt, sollten Sie XAML anstelle von Direct2D verwenden.

Mit XAML können wir eine Spielschnittstelle erstellen, die dem zuvor erstellten Direct2D ähnelt.

XAML

Direct2D

Obwohl sie ähnliche Endergebnisse aufweisen, gibt es eine Reihe von Unterschieden zwischen der Implementierung von Direct2D- und XAML-Schnittstellen.

Funktion	XAML	Direct2D
Definieren der Überlagerung	Definiert in einer XAML-Datei, \*.xaml. Nach dem Verständnis von XAML werden das Erstellen und Konfigurieren komplizierterer Überlagerungen im Vergleich zu Direct2D vereinfacht.	Definiert als Eine Auflistung von Direct2D-Grundtypen und DirectWrite-Zeichenfolgen manuell platziert und in einen Direct2D-Zielpuffer geschrieben.
Benutzeroberflächenelemente	XAML-Benutzeroberflächenelemente stammen aus standardisierten Elementen, die Teil der Windows-Runtime XAML-APIs sind, einschließlich Windows::UI::Xaml und Windows::UI::Xaml::Controls. Der Code, der das Verhalten der XAML-Benutzeroberflächenelemente behandelt, wird in einer Codebehind-Datei definiert, Main.xaml.cpp.	Einfache Formen können wie Rechtecke und Auslassungspunkte gezeichnet werden.
Fenstergröße ändern	Behandelt natürlich Änderungen der Größe und Änderung des Ansichtszustands, wobei die Überlagerung entsprechend transformiert wird.	Sie müssen manuell angeben, wie die Komponenten des Overlays neu gezeichnet werden.

Ein weiterer großer Unterschied besteht in der Swapchain. Sie müssen die Swapchain nicht an ein Windows::UI::Core::CoreWindow-Objekt anfügen. Stattdessen ordnet eine DirectX-App, die XAML enthält, eine SwapchainPanel-Objekt zu, wenn ein neues SwapChainPanel-Objekt erstellt wird.

Der folgende Codeausschnitt zeigt, wie XAML für das SwapChainPanel in der DirectXPage.xaml-Datei deklariert wird.

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

Das SwapChainPanel-Objekt wird als Content-Eigenschaft des aktuellen Fensterobjekts festgelegt, das beim Start durch das App-Singleton erstellt wurde.

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

Um die konfigurierte Swapchain an die swapChainPanel-Instanz anzufügen, die von Ihrem XAML definiert wird, müssen Sie einen Zeiger auf die zugrunde liegende systemeigene ISwapChainPanelNative-Schnittstellenimplementierung abrufen und ISwapChainPanelNative::SetSwapChain darauf aufrufen und die konfigurierte Swapchain übergeben.

Der folgende Codeausschnitt aus DX::D eviceResources::CreateWindowSizeDependentResources enthält details für die DirectX/XAML-Interoperabilität:

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

Weitere Informationen zu diesem Prozess finden Sie unter DirectX- und XAML-Interoperabilität.

Beispiel

Informationen zum Herunterladen der Version dieses Spiels, die XAML für das Overlay verwendet, finden Sie unter DirectX- und XAML-Spielbeispiel. Lesen Sie die Infodatei dort, um Details zum Erstellen des Beispiels zu erhalten.

Im Gegensatz zu der version des Beispielspiels, das in den restlichen Themen behandelt wird, definiert die XAML-Version ihr Framework in den Dateien App.xaml.cpp und DirectXPage.xaml.cpp , anstelle von App.cpp bzw . GameInfoOverlay.cpp.