Erweitern des SpielbeispielsExtend the sample game

Hinweis

Dieses Thema ist Teil der Tutorial-Reihe zum Erstellen eines einfachen universelle Windows-Plattform (UWP) mit DirectX .This topic is part of the Create a simple Universal Windows Platform (UWP) game with DirectX tutorial series. Das Thema unter diesem Link legt den Kontext für die Reihe fest.The topic at that link sets the context for the series.

An dieser Stelle haben wir die wichtigsten Komponenten eines grundlegenden universelle Windows-Plattform (UWP) DirectX 3D-Spiel behandelt.At this point we've covered the key components of a basic Universal Windows Platform (UWP) DirectX 3D game. Sie können das Framework für ein Spiel einrichten, einschließlich der Ansichts Anbieter-und Renderingpipeline, und eine einfache Spiel Schleife implementieren.You can set up the framework for a game, including the view-provider and rendering pipeline, and implement a basic game loop. Sie können auch eine grundlegende Überlagerung der Benutzeroberfläche erstellen, Sounds integrieren und Steuerelemente implementieren.You can also create a basic user interface overlay, incorporate sounds, and implement controls. Sie sind auf dem besten Weg, ein eigenes Spiel zu erstellen, aber wenn Sie weitere Hilfe und Informationen benötigen, sehen Sie sich diese Ressourcen an.You're on your way to creating a game of your own, but if you need more help and info, check out these resources.

Verwenden von XAML für die ÜberlagerungUsing XAML for the overlay

Eine Alternative, die wir nicht ausführlich besprochen haben, ist die Verwendung von XAML anstelle von Direct2D für die Überlagerung.One alternative that we didn't discuss in depth is the use of XAML instead of Direct2D for the overlay. XAML hat gegenüber Direct2D viele Vorteile für das Zeichnen von Elementen der Benutzeroberfläche.XAML has many benefits over Direct2D for drawing user interface elements. Der wichtigste Vorteil besteht darin, dass dadurch das Aussehen und fühlen von Windows 10 in Ihr DirectX-Spiel vereinfacht wird.The most important benefit is that it makes incorporating the Windows 10 look and feel into your DirectX game more convenient. Viele der allgemeinen Elemente, Stile und Verhalten, die eine UWP-App ausmachen, sind eng in das XAML-Modell integriert und ersparen einem Spieleentwickler eine Menge Arbeit bei der Implementierung.Many of the common elements, styles, and behaviors that define a UWP app are tightly integrated into the XAML model, making it far less work for a game developer to implement. Falls Ihr eigenes Spieldesign eine komplizierte Benutzeroberfläche hat, empfiehlt sich unter Umständen die Verwendung von XAML anstelle von Direct2D.If your own game design has a complicated user interface, consider using XAML instead of Direct2D.

Mit XAML können wir eine spielschnittstelle erstellen, die der Direct2D ähnelt, die zuvor erstellt wurde.With XAML, we can make a game interface that looks similar to the Direct2D one made earlier.

XAMLXAML

XAML-Overlay

Direct2DDirect2D

D2D-Overlay

Obwohl Sie ähnliche Endergebnisse aufweisen, gibt es eine Reihe von Unterschieden zwischen der Implementierung von Direct2D-und XAML-Schnittstellen.While they have similar end results, there are a number of differences between implementing Direct2D and XAML interfaces.

FunktionFeature XAMLXAML Direct2DDirect2D
Definieren von OverlayDefining overlay Definiert in einer XAML-Datei, \*.xaml .Defined in a XAML file, \*.xaml. Nachdem Sie XAML verstanden haben, werden das Erstellen und konfigurieren komplizierterer Überlagerungen im Vergleich zu Direct2D zu simpiler.Once understanding XAML, creating and configuring more complicated overlays are made simpiler when compared to Direct2D. Definiert als eine Auflistung von Direct2D primitiven und DirectWrite -Zeichen folgen, die manuell in einen Direct2D-Ziel Puffer eingefügt und geschrieben werden.Defined as a collection of Direct2D primitives and DirectWrite strings manually placed and written to a Direct2D target buffer.
BenutzeroberflächenelementeUser interface elements XAML-Benutzeroberflächen Elemente stammen aus standardisierten Elementen, die Teil der Windows-Runtime XAML-APIs sind, darunter Windows:: UI:: XAML und Windows:: UI:: XAML:: Controls.XAML user interface elements come from standardized elements that are part of the Windows Runtime XAML APIs, including Windows::UI::Xaml and Windows::UI::Xaml::Controls. Der Code zum Behandeln des Verhaltens der XAML-UI-Elemente ist in der CodeBehind-Datei „Main.xaml.cpp“ definiert.The code that handles the behavior of the XAML user interface elements is defined in a codebehind file, Main.xaml.cpp. Einfache Formen können wie Rechtecke und Ellipsen gezeichnet werden.Simple shapes can be drawn like rectangles and ellipses.
Fenstergröße ändernWindow resizing Verarbeitet natürlich die Größen Änderungs-und Ansichts Zustands Änderungs Ereignisse und wandelt das Overlay entsprechend umNaturally handles resize and view state change events, transforming the overlay accordingly Sie müssen manuell angeben, wie die Komponenten der Überlagerung neu gezeichnet werden sollen.Need to manually specify how to redraw the overlay's components.

Ein weiterer großer Unterschied besteht in der SwapChain.Another big difference involves the swap chain. Sie müssen die SwapChain nicht an ein Windows:: UI:: Core:: corewindow -Objekt anfügen.You don't have to attach the swap chain to a Windows::UI::Core::CoreWindow object. Stattdessen ordnet eine DirectX-APP, die XAML integriert, eine austauschkette zu, wenn ein neues swapchainpanel -Objekt erstellt wird.Instead, a DirectX app that incorporates XAML associates a swap chain when a new SwapChainPanel object is constructed.

Der folgende Code Ausschnitt zeigt, wie Sie XAML für das " Swap "-Element in der Datei " directxpage. XAML " deklarieren.The following snippet show how to declare XAML for the SwapChainPanel in the DirectXPage.xaml file.

<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 Objekt " sexapchainpanel " wird als Content -Eigenschaft des aktuellen Fenster Objekts festgelegt, das beim Start von der APP-Singleton erstellt wird.The SwapChainPanel object is set as the Content property of the current window object created at launch by the app 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();
}

Wenn Sie die konfigurierte SwapChain an die swapchainpanel -Instanz anfügen möchten, die von Ihrem XAML-Code definiert wird, müssen Sie einen Zeiger auf die zugrunde liegende systemeigene iswapchainpanelnative -Schnittstellen Implementierung abrufen und iswapchainpanelnative:: setwapchain für Sie erstellen.To attach the configured swap chain to the SwapChainPanel instance defined by your XAML, you must obtain a pointer to the underlying native ISwapChainPanelNative interface implementation and call ISwapChainPanelNative::SetSwapChain on it, passing it your configured swap chain.

Der folgende Code Ausschnitt von DX::D eviceresources:: createwindowsizedependentresources erläutert dies für DirectX/XAML-Interop:The following snippet from DX::DeviceResources::CreateWindowSizeDependentResources details this for 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)
            );
    }

Weitere Informationen zu diesem Prozess finden Sie unter Interoperabilität von DirectX und XAML.For more info about this process, see DirectX and XAML interop.

BeispielSample

Wenn Sie die Version dieses Spiels herunterladen möchten, das XAML für das Overlay verwendet, wechseln Sie zum Direct3D Shooting Sample Game (XAML).To download the version of this game that uses XAML for the overlay, go to the Direct3D shooting sample game (XAML).

Anders als die Version des in den restlichen Themen erläuterten samplingspiels definiert die XAML-Version das Framework in der app. XAML. cpp -und der directxpage. XAML. cpp -Datei anstelle von app. cpp bzw. gameinfooverlay. cpp.Unlike the version of the sample game discussed in the rest of these topics, the XAML version defines its framework in the App.xaml.cpp and DirectXPage.xaml.cpp files, instead of App.cpp and GameInfoOverlay.cpp, respectively.