Estendere l'esempio di giocoExtend the sample game

Nota

Questo argomento fa parte della serie di esercitazioni su come creare un semplice piattaforma UWP (Universal Windows Platform) (UWP) con DirectX .This topic is part of the Create a simple Universal Windows Platform (UWP) game with DirectX tutorial series. L'argomento in corrispondenza di tale collegamento imposta il contesto per la serie.The topic at that link sets the context for the series.

A questo punto sono stati trattati i componenti chiave di un gioco di base piattaforma UWP (Universal Windows Platform) DirectX 3D (UWP).At this point we've covered the key components of a basic Universal Windows Platform (UWP) DirectX 3D game. È possibile configurare il Framework per un gioco, inclusa la pipeline di visualizzazione e del provider di rendering, e implementare un ciclo di gioco di base.You can set up the framework for a game, including the view-provider and rendering pipeline, and implement a basic game loop. È anche possibile creare una sovrapposizione dell'interfaccia utente di base, incorporare suoni e implementare i controlli.You can also create a basic user interface overlay, incorporate sounds, and implement controls. È possibile creare un gioco personalizzato, ma se sono necessarie altre informazioni e altre informazioni, vedere queste risorse.You're on your way to creating a game of your own, but if you need more help and info, check out these resources.

Uso di XAML per la sovrimpressioneUsing XAML for the overlay

Un'alternativa che non è stata illustrata in dettaglio è l'uso di XAML anziché Direct2D per la sovrimpressione.One alternative that we didn't discuss in depth is the use of XAML instead of Direct2D for the overlay. XAML offre molti vantaggi rispetto a Direct2D per il disegno degli elementi dell'interfaccia utente.XAML has many benefits over Direct2D for drawing user interface elements. Il vantaggio più importante è il fatto che rende più semplice l'integrazione dell'aspetto di Windows 10 nel gioco DirectX.The most important benefit is that it makes incorporating the Windows 10 look and feel into your DirectX game more convenient. Molti degli elementi, degli stili e dei comportamenti comuni che definiscono un'app UWP sono strettamente integrati nel modello XAML, riducendo sensibilmente il lavoro richiesto agli sviluppatori di giochi per l'implementazione.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. Se il tuo progetto di gioco prevede un'interfaccia utente complicata, è preferibile usare XAML invece di Direct2D.If your own game design has a complicated user interface, consider using XAML instead of Direct2D.

Con XAML, è possibile creare un'interfaccia di gioco simile a quella di Direct2D eseguita in precedenza.With XAML, we can make a game interface that looks similar to the Direct2D one made earlier.

XAMLXAML

Sovrapposizione XAML

Direct2DDirect2D

Sovrapposizione D2D

Anche se hanno risultati finali simili, esistono diverse differenze tra l'implementazione di interfacce Direct2D e XAML.While they have similar end results, there are a number of differences between implementing Direct2D and XAML interfaces.

FunzionalitàFeature XAMLXAML Direct2DDirect2D
Definizione della sovrimpressioneDefining overlay Definito in un file XAML, \*.xaml .Defined in a XAML file, \*.xaml. Una volta compreso XAML, la creazione e la configurazione di sovrapposizioni più complesse vengono rese simpiler rispetto a Direct2D.Once understanding XAML, creating and configuring more complicated overlays are made simpiler when compared to Direct2D. Definito come raccolta di primitive Direct2D e stringhe DirectWrite posizionate manualmente e scritte in un buffer di destinazione Direct2D.Defined as a collection of Direct2D primitives and DirectWrite strings manually placed and written to a Direct2D target buffer.
Elementi dell'interfaccia utenteUser interface elements Gli elementi dell'interfaccia utente XAML provengono da elementi standardizzati che fanno parte delle API Windows Runtime XAML, tra cui Windows:: UI:: XAML e 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. Il codice che gestisce il comportamento degli elementi dell'interfaccia utente XAML è definito in un file code-behind, Main.xaml.cpp.The code that handles the behavior of the XAML user interface elements is defined in a codebehind file, Main.xaml.cpp. È possibile disegnare forme semplici come rettangoli ed ellissi.Simple shapes can be drawn like rectangles and ellipses.
Ridimensionamento della finestraWindow resizing Gestisce naturalmente gli eventi di modifica dello stato di ridimensionamento e visualizzazione, trasformando di conseguenza la sovrapposizioneNaturally handles resize and view state change events, transforming the overlay accordingly È necessario specificare manualmente come ricreare i componenti della sovrimpressione.Need to manually specify how to redraw the overlay's components.

Un'altra differenza importante riguarda la catena di scambio.Another big difference involves the swap chain. Non è necessario aggiungere la catena di scambio a un oggetto Windows:: UI:: Core:: CoreWindow .You don't have to attach the swap chain to a Windows::UI::Core::CoreWindow object. Al contrario, un'app DirectX che incorpora XAML associa una catena di scambio quando viene costruito un nuovo oggetto SwapChainPanel .Instead, a DirectX app that incorporates XAML associates a swap chain when a new SwapChainPanel object is constructed.

Il frammento di codice seguente illustra come dichiarare XAML per SwapChainPanel nel file DirectXPage. XAML .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>

L'oggetto SwapChainPanel è impostato come proprietà Content dell'oggetto finestra corrente creato al momento dell'avvio dal singleton dell'app.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();
}

Per collegare la catena di scambio configurata all'istanza di SwapChainPanel definita dal codice XAML, è necessario ottenere un puntatore all'implementazione nativa dell'interfaccia ISwapChainPanelNative sottostante e chiamare ISwapChainPanelNative:: SetSwapChain , passandogli la catena di scambio configurata.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.

Il frammento di codice seguente da DX::D eviceresources:: CreateWindowSizeDependentResources descrive in dettaglio questa operazione per l'interoperabilità DirectX/XAML: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)
            );
    }

Per altre info su questo processo, vedi Interoperabilità tra DirectX e XAML.For more info about this process, see DirectX and XAML interop.

EsempioSample

Per scaricare la versione di questo gioco che usa XAML per la sovrimpressione, passare al gioco di esempio Direct3D Shooting (XAML).To download the version of this game that uses XAML for the overlay, go to the Direct3D shooting sample game (XAML).

A differenza della versione del gioco di esempio illustrata nel resto di questi argomenti, la versione XAML definisce il Framework nei file app. XAML. cpp e DirectXPage. XAML. cpp , anziché app. cpp e GameInfoOverlay. cpp, rispettivamente.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.